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
)
);
}
