public static TypeStatement Identify( string typeIdentifier, ClassMetadata classMetadata, AbstractSyntaxTree ast, TypeOverrideDetails typeOverrideDetails ) { // Get node from typeIdentifier var node = ast.RootNode.OfKind( SyntaxKind.TypeAliasDeclaration ).FirstOrDefault( child => child.IdentifierStr == typeIdentifier ); if (node == null) { return(null); } return(GenericTypeIdentifier.Identify( node.Last, classMetadata, ast, typeOverrideDetails )); }
public static TypeStatement Identify( Node node, TypeScriptAST ast, ClassMetadata classMetadata, TypeOverrideDetails typeOverrideDetails ) { // Check if Class var classesCache = ast.RootNode.OfKind( SyntaxKind.ClassDeclaration ); if (node is ClassDeclaration classDeclaration && classDeclaration.HeritageClauses != null && classDeclaration.HeritageClauses.Any()) { var herited = classDeclaration.HeritageClauses.First(); if (herited != null) { var identifiedClass = GenericTypeIdentifier.Identify( herited.First, classMetadata, ast, typeOverrideDetails ); if (classesCache.Any(a => a.IdentifierStr == identifiedClass.Name)) { return(identifiedClass); } } } return(null); }
internal static bool Identify( Node parameter, ClassMetadata classMetadata, AbstractSyntaxTree ast, TypeOverrideDetails typeOverrideDetails, out TypeStatement type ) { type = new TypeStatement { Name = GenerationIdentifiedTypes.Unknown, }; if (IsUnionTypeRule.Check(parameter)) { var unionNode = parameter.OfKind( SyntaxKind.UnionType ).FirstOrDefault() .Children.Where( // Make sure does not contain undefined a => a.Kind != SyntaxKind.UndefinedKeyword && a.Kind != SyntaxKind.NullKeyword && a.Kind != SyntaxKind.TypeLiteral && a.Kind != SyntaxKind.LiteralType ).ToList().FirstOrDefault(); if (unionNode != null) { type = GenericTypeIdentifier.Identify( unionNode, classMetadata, ast, typeOverrideDetails ); } return(true); } else if (parameter.Kind == SyntaxKind.UnionType) { type = GenericTypeIdentifier.Identify( parameter.First, classMetadata, ast, typeOverrideDetails ); return(true); } return(false); }
public static IList <TypeStatement> Identify( Node node, TypeScriptAST ast, ClassMetadata classMetadata, TypeOverrideDetails typeOverrideDetails ) { var interfaces = new List <TypeStatement>(); // Check if Class var interfaceCache = ast.RootNode.OfKind( SyntaxKind.InterfaceDeclaration ); if (node is ClassDeclaration classDeclaration && classDeclaration.HeritageClauses != null && classDeclaration.HeritageClauses.Any()) { foreach (var heritageClauses in classDeclaration.HeritageClauses) { foreach (var heritageClauseType in heritageClauses.Types) { var identifiers = heritageClauseType.OfKind(SyntaxKind.Identifier); foreach (var identifier in identifiers) { var interfaceNode = interfaceCache.FirstOrDefault( a => a.IdentifierStr == identifier.IdentifierStr ); if (interfaceNode != null) { interfaces.Add( GenericTypeIdentifier.Identify( heritageClauseType, classMetadata, ast, typeOverrideDetails ) ); break; } } } } } return(interfaces); }
internal static IList <ArgumentStatement> Identify( Node node, ClassMetadata classMetadata, TypeScriptAST ast, TypeOverrideDetails typeOverrideDetails ) { var methodTypeParameters = TypeParameterIdentifier.Identify(node); var parameters = node.Children .Where(childNode => childNode.Kind == SyntaxKind.Parameter) .Cast <ParameterDeclaration>() .Select(parameter => { var type = GenericTypeIdentifier.Identify( parameter.Last, classMetadata, ast, typeOverrideDetails ); if (UnionTypeIdentifier.Identify( parameter, classMetadata, ast, typeOverrideDetails, out var unionType )) { type = unionType; } if (type.Name == GenerationIdentifiedTypes.CachedEntity) { type.Name = GenerationIdentifiedTypes.Object; } if (type.Name == GenerationIdentifiedTypes.Action) { type.GenericTypes = type.Arguments.Select(a => a.Type); } var name = parameter.IdentifierStr; var methodOrConstructorName = node.IdentifierStr; if (node.Kind == SyntaxKind.Constructor) { methodOrConstructorName = Constants.TYPESCRIPT_CONSTRUCTOR_NAME; } if (TypeOverrideIdentifier.Identify( TypeOverrideDeclarationIdentifier.IdentifyArgument( classMetadata, typeOverrideDetails.IsStatic, methodOrConstructorName, name ), typeOverrideDetails.TypeOverrideMap, type, out var overrideType )) { type = overrideType; } return(new ArgumentStatement { Name = parameter.IdentifierStr, Type = type, IsOptional = IsOptionalRule.Check( parameter ), UsedClassNames = UsedClassNamesIdentifier.Identify( type ), }); }).ToList(); return(parameters); }