public static string GetTrackerClassName(TypeSyntax type) { // NOTE: it's naive approach because we don't know semantic type information here. var genericType = type as GenericNameSyntax; if (genericType == null) { if (type.ToString().StartsWith("Trackable")) { return($"TrackablePocoTracker<I{type.ToString().Substring(9)}>"); } } else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(), "TrackableData.TrackableDictionary")) { return($"TrackableDictionaryTracker{genericType.TypeArgumentList}"); } else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(), "TrackableData.TrackableSet")) { return($"TrackableSetTracker{genericType.TypeArgumentList}"); } else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(), "TrackableData.TrackableList")) { return($"TrackableListTracker{genericType.TypeArgumentList}"); } throw new Exception("Cannot resolve tracker class of " + type); }
/// <summary> /// Returns a fully-qualified name for the type inside the syntax node. /// </summary> /// <param name="typeUsed">Identifier of the type to rewrite</param> /// <param name="succeeded">Whether the fully qualified name was found</param> /// <returns>The fully qualified name</returns> internal string GetQualifiedName(TypeSyntax typeUsed, out bool succeeded) { var typeName = typeUsed.ToString(); var fullyQualifiedName = this.GetFullyQualifiedStateName(typeName); succeeded = fullyQualifiedName != typeUsed.ToString(); return(fullyQualifiedName); }
private static string GetMethodSignature( string name, SyntaxList <AttributeListSyntax> attributeLists, TypeSyntax returnType, ParameterListSyntax parameterList) { StringBuilder ret = new StringBuilder(); foreach (var list in attributeLists) { if (list.Target != null && list.Target.Identifier.Text == "return") { continue; } foreach (var attr in list.Attributes) { if (attr.ToString().StartsWith("return:")) { continue; } ret.Append($"[{attr}]"); } } var retType = GetTypeName(returnType.ToString(), attributeLists); if (retType == null) { retType = returnType.ToString(); } ret.Append(retType); ret.Append(' '); ret.Append(name); ret.Append('('); bool firstParam = true; foreach (var param in parameterList.Parameters) { if (firstParam) { firstParam = false; } else { ret.Append(','); } var typeName = GetTypeName(param.Type.ToString(), param.AttributeLists); ret.Append(typeName); ret.Append(' '); ret.Append(param.Identifier.ValueText); } ret.Append(')'); return(ret.ToString()); }
private void RegisterMakeCollectionActions(CodeRefactoringContext context, SyntaxNode root, TypeSyntax type) { context.RegisterRefactoring(CodeAction.Create( "Make collection", ImmutableArray.Create( CodeAction.Create(ienumerableType(type.ToString()), token => Task.FromResult(context.Document.WithSyntaxRoot(root.ReplaceNode(type, SyntaxFactory.IdentifierName(ienumerableType(type.ToString())))))), CodeAction.Create(listType(type.ToString()), token => Task.FromResult(context.Document.WithSyntaxRoot(root.ReplaceNode(type, SyntaxFactory.IdentifierName(listType(type.ToString()))))))), isInlinable: true)); }
public static TRoot ReplaceType <TRoot>(this TRoot node, TypeSyntax type) where TRoot : SyntaxNode { string value = HlslKnownTypes.GetMappedName(type.ToString()); if (value == type.ToString()) { return(node); } else { return(node.ReplaceNode(type, SyntaxFactory.ParseTypeName(value).WithTriviaFrom(type))); } }
/// <summary> /// Synthesize the concrete type that should be used to initialize a collection- /// valued property in the implementation of the generated class's <code>Init</code> /// method. /// </summary> /// <remarks> /// For array-valued properties, the property type stored in the /// PropertyInfoDictionary is <see cref="IList{T}" />. But in the implementation /// of the <code>Init</code> method, the concrete type used to initialize the /// property is <see cref="List{T}" />. /// </remarks> internal TypeSyntax GetConcreteListType(string propertyName) { TypeSyntax type = this[propertyName].Type; string typeName = type.ToString(); if (typeName.StartsWith("IList")) { typeName = Regex.Replace(type.ToString(), "^IList<", "List<"); } return(SyntaxFactory.ParseTypeName(typeName)); }
private static TypeSyntax WrapInEnumerable(TypeSyntax type) { // very rough heuristic, if we have something like object[] make it IEnumerable<object[]> // as required by xunit. But if the data type is already enumerable, like object[][] // or IList<IList<object>> don't touch it if (type.ToString() == "IEnumerable<object[]>" || type.ToString().EndsWith("[][]") || type.ToString().Count(c => c == '<') >= 2) { return(type.WithoutLeadingTrivia()); } return(ParseTypeName($"IEnumerable<{type}>").WithTrailingTrivia(Space)); }
private static bool IsSimpleType(TypeSyntax type) { if (type.ToString() == "DateTime" || type.ToString().EndsWith(".DateTime")) { return(true); } if (type is PredefinedTypeSyntax) { return(true); } return(false); }
public static TRoot ReplaceType <TRoot>(this TRoot node, TypeSyntax type) where TRoot : SyntaxNode { string value = HlslKnownTypes.GetMappedName(type.ToString()); // If the HLSL mapped full type name equals the original type, just return the input node if (value == type.ToString()) { return(node); } // Process and return the type name TypeSyntax newType = SyntaxFactory.ParseTypeName(value).WithLeadingTrivia(type.GetLeadingTrivia()).WithTrailingTrivia(type.GetTrailingTrivia()); return(node.ReplaceNode(type, newType)); }
private void ParseTypeAndVariables(TypeSyntax type, SeparatedSyntaxList <VariableDeclaratorSyntax> variables) { string typeString = type.ToString(); string variableSuffix = String.Empty; int index = typeString.IndexOf("["); if (index != -1) { variableSuffix = typeString.Substring(index); typeString = typeString.Substring(0, index); } _output.HandleLeadingTrivia(type); _output.Add(typeString); _output.HandleTrailingTrivia(type); foreach (var variable in variables) { _output.HandleLeadingTrivia(variable.Identifier); _output.Add(variable.Identifier.ToString() + variableSuffix); _output.HandleTrailingTrivia(variable.Identifier); if (variable.Initializer != null) { HandleTokenAndTrivia(variable.Initializer.EqualsToken); _expression.ParseExpressionSyntax(variable.Initializer.Value); } } }
/// <summary> /// Initializes a new instance of the <see cref="PropertyInfo"/> class. /// </summary> /// <param name="description"> /// The description of the property, for use in a summary comment. /// </param> /// <param name="serializedName"> /// The name of the property as serialized in the JSON file. /// </param> /// <param name="comparisonKind"> /// The kind of comparison code required by the property. /// </param> /// <param name="hashKind"> /// The kind of hash value computation code required by the property. /// </param> /// <param name="initializationKind"> /// The kind of initialization code required by the property. /// </param> /// <param name="type"> /// The type of the property. /// </param> /// <param name="typeName"> /// The name of the type of the property. /// </param> /// <param name="namespaceName"> /// The qualified name of the namespace declaration required by this type, /// or <code>null</code> if no namespace declaration is required. /// </param> /// <param name="isRequired"> /// <code>true</code> if this property is required by the schema; /// otherwise <code>false</code>. /// </param> /// <param name="isOfSchemaDefinedType"> /// <code>true</code> if this property is of a type defined by the schema (or an; /// array of a schema-defined type otherwise <code>false</code>. /// </param> /// <param name="arrayRank"> /// The array rank of the property type. 0 means the property is not an array. /// </param> /// <param name="declarationOrder"> /// The 0-based order in which the property was declared in the schema. /// </param> public PropertyInfo( string description, string serializedName, ComparisonKind comparisonKind, HashKind hashKind, InitializationKind initializationKind, TypeSyntax type, string namespaceName, bool isRequired, bool isOfSchemaDefinedType, int arrayRank, int declarationOrder) { Description = description; SerializedName = serializedName; ComparisonKind = comparisonKind; HashKind = hashKind; InitializationKind = initializationKind; Type = type; TypeName = type.ToString(); NamespaceName = namespaceName; IsRequired = isRequired; IsOfSchemaDefinedType = isOfSchemaDefinedType; ArrayRank = arrayRank; DeclarationOrder = declarationOrder; }
private static string GetFunctionDescription(TypeSyntax returnType, SyntaxToken name, ParameterListSyntax parameterList, bool includeReturnType, bool includeParameterNames) { var result = new StringBuilder(); if (includeReturnType) { result.Append($"{returnType.ToString(true)} "); } result.Append(name.GetFullyQualifiedName()); result.Append("("); for (var i = 0; i < parameterList.Parameters.Count; i++) { var parameter = parameterList.Parameters[i]; result.Append(parameter.GetDescription(includeParameterNames)); if (i < parameterList.Parameters.Count - 1) { result.Append(", "); } } result.Append(")"); return(result.ToString().Replace(Environment.NewLine, string.Empty)); }
/// <summary> /// Tries to resolve the given type name. /// </summary> /// <param name="type">The simple or full type name.</param> /// <param name="diagnostics">A diagnostics sink for resolution errors.</param> /// <param name="resolvedType">If this method returns true, the resolved type.</param> public static bool TryResolve(TypeSyntax type, IDiagnosticSink diagnostics, [NotNullWhen(true)] out TypeDefinition?resolvedType) { // TODO: Proper type resolution with a declaration provider switch (((TypeNameSyntax)type).TypeName) { case "bool": resolvedType = SimpleType.Bool; break; case "int32": resolvedType = SimpleType.Int32; break; case "void": resolvedType = SimpleType.Void; break; default: diagnostics.Add(DiagnosticCode.TypeNotFound, type.Position, type.ToString()); resolvedType = null; return(false); } return(true); }
public static string translateType(TypeSyntax type_syntax) { string s = type_syntax.ToString(); switch (s) { // basic types case "int": case "float": case "bool": return(s); // double -> float case "double": Translator.translatorWarning("translating \"double\" as \"float\"", "[uncertainty] type approximation"); return("float"); // void -> null case "void": return("null"); } // enumerable types if (s.EndsWith("[]") || s.StartsWith("List<")) { return("list"); // NOT COOL ! } return(Translator.translatorWarning("unknown type \"" + s + "\"", "[unsupported type] type approximation") + "auto"); //throw new NotImplementedException("Unsupported type: " + s); }
private string GetTypeName(TypeSyntax typeSyntax) { if (typeSyntax is NullableTypeSyntax nullableTypeSyntax) { // string? typeSyntax = nullableTypeSyntax.ElementType; } if (typeSyntax is GenericNameSyntax genericNameSyntax) { // List<string> // Dictionary<string, string> return(genericNameSyntax.Identifier.ToString()); } else if (typeSyntax is ArrayTypeSyntax) { // string[] return("[]"); } else if (typeSyntax is PredefinedTypeSyntax predefinedTypeSyntax) { // string return(predefinedTypeSyntax.ToString()); } else if (typeSyntax is QualifiedNameSyntax qualifiedNameSyntax) { // System.String return(qualifiedNameSyntax.ChildNodes().OfType <IdentifierNameSyntax>().Last().ToString()); } else { // String return(typeSyntax.ToString()); } }
public static string ToTypescript(this TypeSyntax type) { switch (type) { case PredefinedTypeSyntax syntaxItem: return(syntaxItem.ToTypescript()); case NullableTypeSyntax syntaxItem: return(syntaxItem.ElementType.ToTypescript()); case GenericNameSyntax syntaxItem: return(syntaxItem.ToTypescript()); case IdentifierNameSyntax syntaxItem: return(syntaxItem.ToTypescript()); case ArrayTypeSyntax syntaxItem: if (syntaxItem.RankSpecifiers.IsMultiRankArray()) { Log.Info($"WARNING: To many ranks: {syntaxItem} returning any"); return("any"); } return(syntaxItem.ElementType.ToTypescript() + syntaxItem.RankSpecifiers.ToTypescript()); case QualifiedNameSyntax syntaxItem: return(syntaxItem.ToTypescript()); } Log.Warn($"unknown type: {type}"); return(type.ToString()); }
public static NetType GetType(TypeSyntax typeSyntax) { if (typeSyntax is QualifiedNameSyntax) { typeSyntax = ((QualifiedNameSyntax)typeSyntax).Right; } if (typeSyntax is GenericNameSyntax) { var genericType = (GenericNameSyntax)typeSyntax; return(new NetType() { Name = genericType.Identifier.ToString(), GenericParameters = GetGenericParameters(genericType.TypeArgumentList) }); } if (typeSyntax is NullableTypeSyntax) { return(new NetType { Name = ((NullableTypeSyntax)typeSyntax).ElementType.ToString(), IsNullable = true }); } return(new NetType { Name = typeSyntax.ToString(), }); }
public IVariable SetupNewVariable(VariableKind variableKind, RDomBaseVariable newItem, TypeSyntax typeSyntax, SyntaxNode node, IDom parent, SemanticModel model) { CreateFromWorker.StandardInitialize(newItem, node, parent, model, OutputContext); newItem.Name = newItem.TypedSymbol.Name; var declaredType = typeSyntax.ToString(); var returnType = OutputContext.Corporation .Create(typeSyntax, newItem, model) .FirstOrDefault() as IReferencedType; newItem.Type = returnType; newItem.VariableKind = variableKind; newItem.IsImplicitlyTyped = (declaredType == "var"); if (!newItem.IsImplicitlyTyped && newItem.Type.TypeArguments.Count() == 0 && declaredType != newItem.Type.Name) { var test = Mappings.AliasFromSystemType(newItem.Type.Name); if (declaredType == test) { newItem.IsAliased = true; } } return(newItem); }
private static string Convert(TypeSyntax typeSyntax) { if (typeSyntax is IdentifierNameSyntax identifierNameSyntax) { switch (identifierNameSyntax.Identifier.ValueText) { case nameof(Boolean): return("bool"); case nameof(Byte): return("int"); case nameof(Char): return("string"); case nameof(Decimal): return("decimal"); case nameof(Double): return("double"); case nameof(Int16): case nameof(Int32): return("int"); case nameof(Int64): return("long"); case nameof(Object): return("object"); case nameof(SByte): return("sbyte"); case nameof(Single): return("float"); case nameof(String): return("string"); case nameof(UInt16): return("int"); case nameof(UInt32): return("long"); case nameof(UInt64): return("ulong"); case nameof(Byte) + "[]": return("blob"); case nameof(DateTime): return("timestamp"); } } return(typeSyntax.ToString().Trim()); }
/// <summary> /// Synthesize the concrete type that should be used to initialize a dictionary- /// valued property in the implementation of the generated class's <code>Init</code> /// method. /// <remarks> /// For dictionary-valued properties, the property type stored in the /// PropertyInfoDictionary is <see cref="IDictionary{K,V}" />. But in the /// implementation of the <code>Init</code> method, the concrete type used to /// initialize the property is <see cref="Dictionary{K,V}" />. /// </remarks> internal TypeSyntax GetConcreteDictionaryType(string propertyName) { TypeSyntax type = this[propertyName].Type; string typeName = Regex.Replace(type.ToString(), "^IDictionary<", "Dictionary<"); return(SyntaxFactory.ParseTypeName(typeName)); }
public static bool IsTrackableType(TypeSyntax type) { // NOTE: it's naive approach because we don't know semantic type information here. var parts = type.ToString().Split('.'); var typeName = parts[parts.Length - 1]; return(typeName.StartsWith("Trackable")); }
internal static bool IsCommand(this TypeSyntax value, SemanticModel semanticModel) { var name = value.ToString(); return(name.Contains("Command") && semanticModel.LookupSymbols(value.GetLocation().SourceSpan.Start, name: name).FirstOrDefault() is ITypeSymbol symbol && symbol.IsCommand()); }
public static string GetClassName(this TypeSyntax classDec) { // Dong Xie: not really sure what's this for? REVIEW return(classDec.ToString()); //return classDec.PlainName; }
/// <summary> /// Heuristically identifies if typeSyntax is an interface /// </summary> /// <param name="typeSyntax">Type syntax to be analyzed</param> /// <returns>True if TypeSyntax looks like interface name</returns> private static bool IsInterfaceName(TypeSyntax typeSyntax) { var fullTypeName = typeSyntax.ToString(); // zero if does not contain dot var typeName = fullTypeName.Substring(fullTypeName.LastIndexOf(".", StringComparison.Ordinal) + 1); return(typeName.StartsWith("I") && typeName.Length > 1 && char.IsUpper(typeName[1])); }
public override string ToString() { System.Text.StringBuilder sb = new System.Text.StringBuilder(ElementType.ToString()); for (int i = 0; i < Rank; i++) { sb.Append("[]"); } return(sb.ToString()); }
private static string getNodeServer(TypeSyntax type) { switch (type.ToString()) { case "NetMQ.Node": return("NetMQNode"); } throw new ArgumentException("type"); }
private string ResolvePlainOrGenericType(TypeSyntax type) { if (Context.GetTypeInfo(type).Type is INamedTypeSymbol namedTypeSymbol && namedTypeSymbol.IsGenericType) { return(Context.TypeResolver.ResolveGenericType(namedTypeSymbol)); } return(Context.TypeResolver.Resolve(type.ToString())); }
public static string Map(TypeSyntax type, bool useLongNames = false) { if (type == null) { return(string.Empty); } return(Map(type.ToString(), useLongNames)); }
private ApexTypeSyntax ConvertType(TypeSyntax type) { if (type != null) { var apexType = GenericExpressionHelper.ConvertCSharpTypesToApex(type.ToString()); return(new ApexTypeSyntax(apexType)); } return(null); }
/// <summary> /// 变量类型的转换 /// </summary> /// <param name="typeSyntax"></param> /// <returns></returns> private string CharpTypeToGolangType(TypeSyntax typeSyntax) { if (typeSyntax is PredefinedTypeSyntax) { string gotype; if (PrimitiveTypes.TryGetValue(typeSyntax.ToString(), out gotype)) { return(gotype); } return(typeSyntax.ToString()); } if (typeSyntax is IdentifierNameSyntax) { return(typeSyntax.ToString()); } if (typeSyntax is GenericNameSyntax) { var genericSyntax = typeSyntax as GenericNameSyntax; if (genericSyntax.Identifier.Text == DICTIONARY) { var key = genericSyntax.TypeArgumentList.Arguments[0]; var value = genericSyntax.TypeArgumentList.Arguments[1]; return($"map[{key}]{value}"); } if (genericSyntax.Identifier.Text.IndexOf(LIST, StringComparison.Ordinal) != -1) { var typeArgumen = genericSyntax.TypeArgumentList.ToString(); return("[]" + typeArgumen.Replace("<", "").Replace(">", "")); } } if (typeSyntax is ArrayTypeSyntax) { return("[]" + ((ArrayTypeSyntax)typeSyntax).ElementType); } return(typeSyntax.ToString()); }