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