private static string GetTypeNameForTypeSyntax(TypeSyntax type)
{
return(type switch
{
IdentifierNameSyntax identifierName => identifierName.Identifier.ValueText,
PredefinedTypeSyntax predefinedType => predefinedType.Keyword.ValueText,
_ => throw new NotSupportedException($"Type {type?.GetType()} is not supported")
});
public TypeStructure ConvertTypeStructure(TypeSyntax syntax)
{
return(syntax switch
{
PredefinedTypeSyntax ptSyntax => ToPredefinedIdentifierStructure(ptSyntax.Keyword.Text),
IdentifierNameSyntax inSyntax => ToIdentifierStructure(inSyntax, _typeLocator),
QualifiedNameSyntax qnSyntax => ToIdentifierStructure(qnSyntax),
GenericNameSyntax gnSyntax => ToGenericTypeStructure(gnSyntax),
ArrayTypeSyntax atSyntax => ToArrayTypeStructure(atSyntax),
PointerTypeSyntax ptSyntax => ToPointerTypeStructure(ptSyntax),
NullableTypeSyntax ntSyntax => ToNullableTypeStructure(ntSyntax),
TupleTypeSyntax ttSyntax => ToTupleTypeStructure(ttSyntax),
_ => throw new ArgumentException(syntax.GetType().ToString())
});
public virtual ULTypeInfo GetTypeInfo(TypeSyntax typeSyntax)
{
if (typeSyntax == null)
{
return(null);
}
if (typeSyntax is PredefinedTypeSyntax)
{
PredefinedTypeSyntax predefinedTypeSyntax = typeSyntax as PredefinedTypeSyntax;
string typeName = GetKeywordTypeName(predefinedTypeSyntax.Keyword.Text);
return(Data.GetType("System." + typeName));
}
else if (typeSyntax is IdentifierNameSyntax)
{
IdentifierNameSyntax ts = typeSyntax as IdentifierNameSyntax;
var identifier = ts.Identifier.Text;
var info = GetIdentifierInfo(identifier);
if (info != null)
{
return(Data.GetType(info.TypeID));
}
}
else if (typeSyntax is QualifiedNameSyntax)
{
QualifiedNameSyntax qns = typeSyntax as QualifiedNameSyntax;
string name_space = qns.Left.ToString();
var name = qns.Right.Identifier.Text;
//Metadata.Expression.QualifiedNameSyntax my_qns = new Metadata.Expression.QualifiedNameSyntax();
//my_qns.Left = GetTypeSyntax(qns.Left) as Metadata.Expression.NameSyntax;
return(Data.GetType(name_space + "." + name));
}
else
{
Console.Error.WriteLine("不支持的类型语法 " + typeSyntax.GetType().FullName);
}
if (Parent != null)
{
return(Parent.GetTypeInfo(typeSyntax));
}
return(null);
}
private static SchemaTypeInfo GetSchemaTypeInfo(TypeSyntax typeSyntax)
{
var info = new SchemaTypeInfo();
switch (typeSyntax)
{
case PredefinedTypeSyntax predefinedType:
info.TypeName = predefinedType.Keyword.ValueText;
info.Syntax = SchemaTypeInfo.SyntaxType.primitive;
break;
case IdentifierNameSyntax identifierName:
info.Syntax = SchemaTypeInfo.SyntaxType.complex;
info.TypeName = identifierName.Identifier.Text;
break;
case NullableTypeSyntax nullableType:
info.Syntax = SchemaTypeInfo.SyntaxType.nullable;
var np = nullableType.ElementType as PredefinedTypeSyntax;
info.TypeName = np.Keyword.ValueText;
break;
case GenericNameSyntax genericType:
info.TypeName = genericType.Identifier.Text;
info.Syntax = SchemaTypeInfo.SyntaxType.generic;
info.GenericParameters = new List <SchemaTypeInfo>();
foreach (var a in genericType.TypeArgumentList.Arguments)
{
info.GenericParameters.Add(GetSchemaTypeInfo(a));
}
break;
case ArrayTypeSyntax arrayType:
info = GetSchemaTypeInfo(arrayType.ElementType);
info.Syntax = SchemaTypeInfo.SyntaxType.array;
break;
default:
throw new Exception($"Unknown TypeSyntax {typeSyntax.GetType()} at line {typeSyntax.GetLocation().GetLineSpan().StartLinePosition.Line}");
}
return(info);
}
public static string GetTypeString(TypeSyntax type)
{
if (type is IdentifierNameSyntax identifierName)
{
return(identifierName.Identifier.Text);
}
// int, bool, string, etc...
else if (type is PredefinedTypeSyntax predefinedType)
{
return(predefinedType.Keyword.Text);
}
else if (type is GenericNameSyntax genericType)
{
var typeName = genericType.Identifier.Text;
var argumentNames = genericType.TypeArgumentList.Arguments.Select(GetTypeString);
return($"{typeName}<{string.Join(", ", argumentNames)}>");
}
else if (type is ArrayTypeSyntax arrayType)
{
var elementType = GetTypeString(arrayType.ElementType);
return($"{elementType}[]");
}
else if (type is QualifiedNameSyntax qualifiedNameSyntax)
{
var left = GetTypeString(qualifiedNameSyntax.Left);
var right = GetTypeString(qualifiedNameSyntax.Right);
return($"{left}.{right}");
}
else
{
throw new NotSupportedException($"{nameof(TypeSyntax)}'s subtype {type.GetType().FullName} is not supported.");
}
}
/// <summary>
/// Determines whether the specified <see cref="TypeSyntax"/> instances refer to the same type.
/// </summary>
/// <param name="syntax1">The first <see cref="TypeSyntax"/> to compare.</param>
/// <param name="syntax2">The second <see cref="TypeSyntax"/> to compare.</param>
/// <returns><c>true</c> if <paramref name="syntax1"/> refers to the same type as <paramref name="syntax2"/>; otherwise, <c>false</c>.</returns>
private static bool AreSame(TypeSyntax syntax1, TypeSyntax syntax2)
{
return(syntax1.GetType() == syntax2.GetType() && syntax1.WithoutTrivia().NormalizeWhitespace().ToString() == syntax2.WithoutTrivia().NormalizeWhitespace().ToString());
}
public void VisitVariableDeclarator(VariableDeclaratorSyntax node, TypeSyntax type)
{
if (lang == TargetLang.TypeScript)
{
// if (node.Parent.Parent.Kind() == SyntaxKind.LocalDeclarationStatement)
{
emit("let ");
}
emit($"{node.Identifier.Text}");
emit(": ");
var type_dec = src.Model.GetTypeInfo(type);
if (type is PredefinedTypeSyntax)
{
Visit(type);
}
else if (type is ArrayTypeSyntax)
{
Visit(type);
}
else if (type is IdentifierNameSyntax)
{
Visit(type);
}
else
{
throw new ApplicationException($"VisitVariableDeclarator: {type.GetType().ToString()}");
}
if (node.Initializer != null)
{
emit(" = ");
var value = node.Initializer.Value;
base.Visit(value);
}
emit_line(";");
}
else
{
var type_dec = src.Model.GetTypeInfo(type);
if (type is PredefinedTypeSyntax)
{
Visit(type);
}
else if (type is ArrayTypeSyntax)
{
Visit(type);
}
else if (type is IdentifierNameSyntax)
{
Visit(type);
}
else
{
throw new ApplicationException($"VisitVariableDeclarator: {type.GetType().ToString()}");
}
emit($" {node.Identifier.Text}");
if (node.Initializer != null)
{
emit(" = ");
var value = node.Initializer.Value;
base.Visit(value);
}
emit_line(";");
}
}
public ULTypeInfo GetType(TypeSyntax typeSyntax)
{
if (typeSyntax == null)
{
return(null);
}
if (typeSyntax is PredefinedTypeSyntax)
{
PredefinedTypeSyntax predefinedTypeSyntax = typeSyntax as PredefinedTypeSyntax;
string typeName = GetKeywordTypeName(predefinedTypeSyntax.Keyword.Text);
return(Model.ModelData.FindTypeByFullName("System." + typeName));
}
//else if (typeSyntax is ArrayTypeSyntax)
//{
// ArrayTypeSyntax ts = typeSyntax as ArrayTypeSyntax;
// Metadata.Expression.TypeSyntax elementType = GetTypeSyntax(ts.ElementType, "");
// List<Metadata.Expression.TypeSyntax> parameters = new List<Metadata.Expression.TypeSyntax>();
// parameters.Add(elementType);
// Metadata.Expression.TypeSyntax gns = new Metadata.Expression.TypeSyntax();
// gns.Name = "ArrayT";
// gns.args = parameters.ToArray();
// gns.isGenericType = true;
// if (elementType.isGenericParameter)
// {
// gns.isGenericTypeDefinition = true;
// }
// //Metadata.Expression.QualifiedNameSyntax qns = new Metadata.Expression.QualifiedNameSyntax();
// //qns.Left = new Metadata.Expression.IdentifierNameSyntax() { Identifier = "System" };
// //qns.Right = gns;
// gns.name_space = "System";
// //Metadata.DB_Type arrayType = Model.GetType("System.ArrayT[1]");
// return gns;
//}
else if (typeSyntax is IdentifierNameSyntax)
{
IdentifierNameSyntax ts = typeSyntax as IdentifierNameSyntax;
var identifier = ts.Identifier.Text;
var info = GetIdentifierInfo(identifier);
if (info != null)
{
return(Model.ModelData.FindTypeByFullName(info.TypeFullName));
}
}
//else if (typeSyntax is GenericNameSyntax)
//{
// GenericNameSyntax ts = typeSyntax as GenericNameSyntax;
// string Name = ts.Identifier.Text;
// List<Metadata.Expression.TypeSyntax> parameters = new List<Metadata.Expression.TypeSyntax>();
// foreach (var p in ts.TypeArgumentList.Arguments)
// {
// parameters.Add(GetTypeSyntax(p, ""));
// }
// Metadata.Expression.TypeSyntax gns = new Metadata.Expression.TypeSyntax();
// gns.Name = Name;
// gns.args = parameters.ToArray();
// gns.isGenericType = true;
// Metadata.DB_Type type = Model.Instance.GetIndifierInfo(gns.GetTypeDefinitionName()).type;
// gns.name_space = type._namespace;
// return gns;
//}
else if (typeSyntax is QualifiedNameSyntax)
{
QualifiedNameSyntax qns = typeSyntax as QualifiedNameSyntax;
string name_space = qns.Left.ToString();
var name = qns.Right.Identifier.Text;
//Metadata.Expression.QualifiedNameSyntax my_qns = new Metadata.Expression.QualifiedNameSyntax();
//my_qns.Left = GetTypeSyntax(qns.Left) as Metadata.Expression.NameSyntax;
return(Model.ModelData.FindTypeByFullName(name_space + "." + name));
}
else
{
Console.Error.WriteLine("不支持的类型语法 " + typeSyntax.GetType().FullName);
}
return(null);
}
private static SimpleNameSyntax GetCallingMethod(TypeSyntax interfaceMethodReturnType)
{
switch (interfaceMethodReturnType)
{
case GenericNameSyntax genericName:
return(GenericName(nameof(IRemoteRequestProcessor.GetResultAsync)).WithTypeArgumentList(genericName.TypeArgumentList));
case QualifiedNameSyntax _:
case IdentifierNameSyntax _:
return(IdentifierName(nameof(IRemoteRequestProcessor.ExecuteAsync)));
default:
throw new InvalidOperationException($"Unknown return type: {interfaceMethodReturnType} ({interfaceMethodReturnType.GetType()})");
}
}
