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