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); }
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 )); }
private static IList <TypeStatement> GetGenericTypes( Node node, ClassMetadata classMetadata, AbstractSyntaxTree ast, TypeOverrideDetails typeOverrideDetails ) { if (node.Kind == SyntaxKind.ClassDeclaration && node.TypeParameters != null ) { return(node.TypeParameters.Select( typeParam => GenericTypeIdentifier.Identify( typeParam, classMetadata, ast, typeOverrideDetails ) ).ToList()); } else if (node.Kind == SyntaxKind.InterfaceDeclaration && node.TypeParameters != null ) { return(node.TypeParameters.Select( typeParam => GenericTypeIdentifier.Identify( typeParam, classMetadata, ast, typeOverrideDetails ) ).ToList()); } return(new List <TypeStatement>()); }
public static TypeQueryStatement Identify( Node node, ClassMetadata classMetadata, AbstractSyntaxTree ast, TypeOverrideDetails typeOverrideDetails ) { if (node.Kind != GenerationIdentifiedTypes.TypeQuery || node.First?.First == null) { return(null); } var firstNode = node.First; return(new TypeQueryStatement { Class = TypeIdentifier.Identify( firstNode.First, classMetadata ), Type = TypeIdentifier.Identify( firstNode.Last, classMetadata ) }); }
public void ShouldReturnNullWhenNodeIsNotFound() { // Given var rootNode = new Mock <Node>(); var typeIdentifier = "type-identifier"; var classMetadataMock = new Mock <ClassMetadata>(); var astMock = new Mock <AbstractSyntaxTree>(); var typeOverrideDetails = new TypeOverrideDetails(); astMock.Setup( mock => mock.RootNode ).Returns( rootNode.Object ); // When var actual = AliasTypeStatementIdentifier.Identify( typeIdentifier, classMetadataMock.Object, astMock.Object, typeOverrideDetails ); // Then actual.Should().BeNull(); }
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); }
private static TypeStatement NormalizeLiteralTypeStatement( TypeStatement type, ClassMetadata classMetadata, AbstractSyntaxTree ast, TypeOverrideDetails typeOverrideDetails ) { if (type.IsTypeQuery) { var(found, className, toGenerateNode) = GetNode( type.TypeQuery.Class, ast ); if (!found) { return(type); } var typeNode = toGenerateNode.Children.FirstOrDefault( a => a.IdentifierStr == type.TypeQuery.Type ); if (typeNode is not null) { var typedType = GenericTypeIdentifier.Identify( typeNode.Last, classMetadata, ast, typeOverrideDetails ); return(typedType); } } if (type.IsLiteral) { type.Name = GenerationIdentifiedTypes.CachedEntity; } var literalGenericTypes = type.GenericTypes.Where( a => a.IsLiteral ); foreach (var genericType in literalGenericTypes) { genericType.Name = GenerationIdentifiedTypes.CachedEntity; } return(type); }
public static TypeStatement Identify( Node node, ClassMetadata classMetadata, TypeScriptAST ast, TypeOverrideDetails typeOverrideDetails ) { var typeIdentifier = TypeIdentifier.Identify( node, classMetadata ); var isTypeAlias = AliasTypeIdentifier.Identify( node, ast ); var aliasType = isTypeAlias ? AliasTypeStatementIdentifier.Identify( typeIdentifier, classMetadata, ast, typeOverrideDetails ) : null; var isLiteral = IsTypeLiteralRule.Check( node ) || TypeLiteralIdentifier.Identify( typeIdentifier ); var genericTypes = new List <TypeStatement>(); if (node is TypeReferenceNode referenceNode && referenceNode.TypeArguments != null && referenceNode.TypeArguments.Any()) { foreach (var typeArgument in referenceNode.TypeArguments) { if (typeArgument is Node typeArgumentNode) { genericTypes.Add( Identify( typeArgumentNode, classMetadata, ast, typeOverrideDetails ) ); } } }
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); }
private static IList <TypeStatement> GetGenericTypes( Node node, ClassMetadata classMetadata, TypeScriptAST ast, TypeOverrideDetails typeOverrideDetails ) { if (node is ClassDeclaration classDeclaration && classDeclaration.TypeParameters != null ) { return(classDeclaration.TypeParameters.Select( typeParam => GenericTypeIdentifier.Identify( typeParam, classMetadata, ast, typeOverrideDetails ) ).ToList()); }
public static TypeStatement Identify( Node node, ClassMetadata classMetadata, TypeScriptAST ast, TypeOverrideDetails typeOverrideDetails ) { // Observer<SomeTypeData> //var template = "[[NAME]]<[[CHILDREN_TYPES]]>"; var typeIdentifier = TypeIdentifier.Identify( node, classMetadata ); var isLiteral = IsTypeLiteralRule.Check( node ) || TypeLiteralIdentifier.Identify( typeIdentifier ); var genericTypes = new List <TypeStatement>(); if (node is TypeReferenceNode referenceNode && referenceNode.TypeArguments != null && referenceNode.TypeArguments.Any()) { foreach (var typeArgument in referenceNode.TypeArguments) { if (typeArgument is Node typeArgumentNode) { genericTypes.Add( Identify( typeArgumentNode, classMetadata, ast, typeOverrideDetails ) ); } } }
internal static IList <ArgumentStatement> Identify( Node classDeclaration, ClassMetadata classMetadata, TypeScriptAST ast, TypeOverrideDetails typeOverrideDetails ) { var constructor = classDeclaration .OfKind(SyntaxKind.Constructor) .FirstOrDefault(); if (constructor != null) { return(ArgumentIdentifier.Identify( constructor, classMetadata, ast, typeOverrideDetails )); } return(EMPTY); }
public static IList <AccessorStatement> FlattenAccessorStatements( this IEnumerable <Node> nodes, AbstractSyntaxTree ast, ClassMetadata classMetadata, IDictionary <string, string> typeOverrideMap ) { var flattenedAccessorList = nodes.Where(a => IsGetterRule.Check(a)).Select( accessor => { var name = accessor.IdentifierStr; var isStatic = IsStaticRule.Check(accessor); var typeOverrideDetails = new TypeOverrideDetails { IsStatic = isStatic, TypeOverrideMap = typeOverrideMap, }; var type = GenericTypeIdentifier.Identify( accessor.Last, classMetadata, ast, typeOverrideDetails ); if (TypeOverrideIdentifier.Identify( TypeOverrideDeclarationIdentifier.Identify( classMetadata, isStatic, name ), typeOverrideMap, type, out var overrideType )) { type = overrideType; } return(new AccessorStatement { Name = name, Type = NormalizeLiteralTypeStatement( type, classMetadata, ast, typeOverrideDetails ), IsStatic = isStatic, IsInterfaceResponse = InterfaceResponseTypeIdentifier.Identify( type, ast ), HasSetter = IsSetterRule.Check(accessor), //IsArrayResponse = IsArrayResposneTypeRule.Check(accessor), UsedClassNames = UsedClassNamesIdentifier.Identify(type), }); } ).ToList(); // Loop through Setters and on the setter flat as HasSetter foreach (var node in nodes.Where(a => IsSetterRule.Check(a))) { var getNode = flattenedAccessorList.FirstOrDefault( a => a.Name == node.IdentifierStr ); if (getNode != null) { getNode.HasSetter = true; } } return(flattenedAccessorList); }
public static ClassStatement Generate( string projectAssembly, string classIdentifier, AbstractSyntaxTree ast, IDictionary <string, string> typeOverrideMap ) { var(found, className, toGenerateNode) = GetNode( classIdentifier, ast ); if (!found) { return(null); } var namespaceIdentifier = string.Join(".", GetNamespace(toGenerateNode)); var classMetadata = new ClassMetadata { Namespace = namespaceIdentifier, Name = className, }; var typeOverrideDetails = new TypeOverrideDetails { IsStatic = false, TypeOverrideMap = typeOverrideMap, }; // Get ExtendedClassNames var extendedClassType = ExtendedClassTypesIdentifier.Identify( toGenerateNode, ast, classMetadata, typeOverrideDetails ); // Get ImplementedInterfaces var implementedInterfaces = ImplementedInterfacesIdentifier.Identify( toGenerateNode, ast, classMetadata, typeOverrideDetails ); // Public Properties var publicProperties = toGenerateNode .Children.Where( child => IsNotPrivate(child) && IsPropertyType(child, classMetadata) ); // Public Methods/Functions var publicMethods = toGenerateNode .Children.Where( child => IsNotPrivate(child) && IsMethodType(child, classMetadata) ); // Get/Set Accessors var accessorMethods = toGenerateNode .Children.Where( child => IsNotPrivate(child) && IsAccessorType(child) ); // Is Observer Method/Function var observalbleMethods = publicProperties.Where( a => IsObservablePropertyRule.Check(a) ).ToList(); var classStatement = new ClassStatement { ProjectAssembly = projectAssembly, Namespace = namespaceIdentifier, Name = DotNetClassNormalizer.Normalize( className ), IsInterface = IsInterfaceRule.Check( toGenerateNode ), GenericTypes = GetGenericTypes( toGenerateNode, classMetadata, ast, new TypeOverrideDetails { IsStatic = false, TypeOverrideMap = typeOverrideMap, } ), ExtendedType = extendedClassType, ImplementedInterfaces = implementedInterfaces, ConstructorStatement = new ConstructorStatement { Arguments = ConstructorArgumentIdentifier.Identify( toGenerateNode, classMetadata, ast, new TypeOverrideDetails { IsStatic = false, TypeOverrideMap = typeOverrideMap, } ), }, PublicPropertyStatements = publicProperties.ToList().Select( a => { var name = a.IdentifierStr; var isStatic = IsStaticRule.Check(a); var typeOverrideDetails = new TypeOverrideDetails { IsStatic = isStatic, TypeOverrideMap = typeOverrideMap, }; var type = GenericTypeIdentifier.Identify( a.Last, classMetadata, ast, typeOverrideDetails ); if (TypeOverrideIdentifier.Identify( TypeOverrideDeclarationIdentifier.Identify( classMetadata, typeOverrideDetails.IsStatic, name ), typeOverrideDetails.TypeOverrideMap, type, out var overrideType )) { type = overrideType; } return(new PublicPropertyStatement { Name = name, Type = NormalizeLiteralTypeStatement( type, classMetadata, ast, typeOverrideDetails ), IsStatic = isStatic, IsInterfaceResponse = InterfaceResponseTypeIdentifier.Identify( type, ast ), //IsArrayResponse = IsArrayResposneTypeRule.Check(a), IsReadonly = IsReadonlyRule.Check(a), UsedClassNames = UsedClassNamesIdentifier.Identify(type), }); } ).ToList(), PublicMethodStatements = publicMethods.ToList().Select( a => { var name = a.IdentifierStr; var isStatic = IsStaticRule.Check(a); var typeOverrideDetails = new TypeOverrideDetails { IsStatic = isStatic, TypeOverrideMap = typeOverrideMap, }; var type = GenericTypeIdentifier.Identify( a.Last, classMetadata, ast, typeOverrideDetails ); if (TypeOverrideIdentifier.Identify( TypeOverrideDeclarationIdentifier.Identify( classMetadata, typeOverrideDetails.IsStatic, name ), typeOverrideDetails.TypeOverrideMap, type, out var overrideType )) { type = overrideType; } return(new PublicMethodStatement { Name = name, Type = NormalizeLiteralTypeStatement( type, classMetadata, ast, typeOverrideDetails ), GenericTypes = DeclarationGenericTypesIdentifier.Identify( a ), Arguments = ArgumentIdentifier.Identify( a, classMetadata, ast, typeOverrideDetails ), IsStatic = isStatic, IsInterfaceResponse = InterfaceResponseTypeIdentifier.Identify( type, ast ), UsedClassNames = UsedClassNamesIdentifier.Identify(type), }); } ).Distinct().ToList(), AccessorStatements = accessorMethods.FlattenAccessorStatements( ast, classMetadata, typeOverrideMap ), }; classStatement.ConstructorStatement.NeedsInvokableReference = InvokableReferenceIdentifier.Identify( classStatement ); return(classStatement); }
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); }
public static TypeStatement Identify( Node node, ClassMetadata classMetadata, AbstractSyntaxTree ast, TypeOverrideDetails typeOverrideDetails ) { var typeIdentifier = TypeIdentifier.Identify( node, classMetadata ); var isAction = ActionTypeIdentifier.Identify( typeIdentifier ); var isTypeQuery = IsTypeQueryRule.Check( node ); var isTypeAlias = AliasTypeIdentifier.Identify( node, ast ); var aliasType = isTypeAlias ? AliasTypeStatementIdentifier.Identify( typeIdentifier, classMetadata, ast, typeOverrideDetails ) : null; var isLiteral = IsTypeLiteralRule.Check( node ) || TypeLiteralIdentifier.Identify( typeIdentifier ); var actionResultType = default(TypeStatement); var genericTypes = new List <TypeStatement>(); if (node.TypeArguments != null && node.TypeArguments.Any()) { foreach (var typeArgument in node.TypeArguments) { genericTypes.Add( Identify( typeArgument, classMetadata, ast, typeOverrideDetails ) ); } } else if (node.Parameters != null && node.Parameters.Any()) { foreach (var functionParamerter in node.Parameters) { genericTypes.Add( Identify( functionParamerter, classMetadata, ast, typeOverrideDetails ) ); } } else if (typeIdentifier == GenerationIdentifiedTypes.Array && node.Type != null && node.Type.Kind == SyntaxKind.ArrayType) { // This Type is an Array, so we will take the ElementType and use that as the result. var resultType = Identify( node.Type.ElementType, classMetadata, ast, typeOverrideDetails ); resultType.IsArray = true; return(resultType); } else if (IsNumericArrayRule.Check(node)) { genericTypes.Add( new TypeStatement { Name = GenerationIdentifiedTypes.Number, } ); } else if (IsArrayResposneTypeRule.Check(node)) { genericTypes.Add( Identify( node.First, classMetadata, ast, typeOverrideDetails ) ); } else if (IsVoidTypeRule.Check(node)) { if (node.Kind == SyntaxKind.Identifier && node.IdentifierStr == typeIdentifier) { typeIdentifier = GenerationIdentifiedTypes.Void; } } else if (NullableTypeIdentifier.Identify( typeIdentifier ) && node.Type is not null && node.Type.TypeArguments is not null && node.Type.TypeArguments.Any() && node.Type.TypeArguments.First() is Node typeArgumentFirst) { genericTypes.Add( Identify( typeArgumentFirst, classMetadata, ast, typeOverrideDetails ) ); }