public static string FullName(this ITypeSymbol symbol) { Contract.Requires(symbol != null); var symbolDisplayFormat = new SymbolDisplayFormat( typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces); return symbol.ToDisplayString(symbolDisplayFormat); }
static ProtocolCompletionData () { NameFormat = new SymbolDisplayFormat ( globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Omitted, typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces, propertyStyle: SymbolDisplayPropertyStyle.NameOnly, genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance, memberOptions: SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeExplicitInterface, parameterOptions: SymbolDisplayParameterOptions.IncludeParamsRefOut | SymbolDisplayParameterOptions.IncludeExtensionThis | SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName, miscellaneousOptions: SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers | SymbolDisplayMiscellaneousOptions.UseSpecialTypes ); overrideNameFormat = NameFormat.WithParameterOptions ( SymbolDisplayParameterOptions.IncludeDefaultValue | SymbolDisplayParameterOptions.IncludeExtensionThis | SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeParamsRefOut ); }
internal FormattedSymbolList(IEnumerable<ISymbol> symbols, SymbolDisplayFormat symbolDisplayFormat = null) { Debug.Assert(symbols != null); _symbols = symbols; _symbolDisplayFormat = symbolDisplayFormat; }
internal FormattedSymbol(ISymbol symbol, SymbolDisplayFormat symbolDisplayFormat) { Debug.Assert(symbol != null && symbolDisplayFormat != null); _symbol = symbol; _symbolDisplayFormat = symbolDisplayFormat; }
protected override void BuildDelegateDeclaration(INamedTypeSymbol typeSymbol, _VSOBJDESCOPTIONS options) { Debug.Assert(typeSymbol.TypeKind == TypeKind.Delegate); BuildTypeModifiers(typeSymbol); AddText("delegate "); var delegateInvokeMethod = typeSymbol.DelegateInvokeMethod; AddTypeLink(delegateInvokeMethod.ReturnType, LinkFlags.None); AddText(" "); var typeQualificationStyle = (options & _VSOBJDESCOPTIONS.ODO_USEFULLNAME) != 0 ? SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces : SymbolDisplayTypeQualificationStyle.NameOnly; var typeNameFormat = new SymbolDisplayFormat( typeQualificationStyle: typeQualificationStyle, genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance); AddName(typeSymbol.ToDisplayString(typeNameFormat)); AddText("("); BuildParameterList(delegateInvokeMethod.Parameters); AddText(")"); if (typeSymbol.IsGenericType) { BuildGenericConstraints(typeSymbol); } }
internal static string SafeMinimalDisplayString (ISymbol symbol, SemanticModel semanticModel, int position, SymbolDisplayFormat format) { try { return symbol.ToMinimalDisplayString (semanticModel, position, format); } catch (ArgumentOutOfRangeException) { try { return symbol.ToMinimalDisplayString (semanticModel, semanticModel.SyntaxTree.Length / 2, format); } catch (ArgumentOutOfRangeException) { return symbol.Name; } } }
protected AbstractLibraryService( Guid libraryId, __SymbolToolLanguage preferredLanguage, SymbolDisplayFormat typeDisplayFormat, SymbolDisplayFormat memberDisplayFormat) { this.LibraryId = libraryId; this.PreferredLanguage = preferredLanguage; this.TypeDisplayFormat = typeDisplayFormat; this.MemberDisplayFormat = memberDisplayFormat; this.NavInfoFactory = new NavInfoFactory(this); }
public string Generate(ISymbol symbol) { _sb = new StringBuilder(); _format = SymbolDisplayFormat.MinimallyQualifiedFormat; _format = _format.WithMemberOptions(_format.MemberOptions ^ SymbolDisplayMemberOptions.IncludeContainingType ^ SymbolDisplayMemberOptions.IncludeType); if (IsConstructor(symbol)) { // only the containing type contains the type parameters var parts = symbol.ContainingType.ToDisplayParts(_format); RenderDisplayParts(symbol, parts); parts = symbol.ToDisplayParts(_format); RenderParameters(symbol as IMethodSymbol); } else { var symbolKind = symbol.Kind; if (symbol.Kind == SymbolKind.Method) { RenderMethodSymbol(symbol as IMethodSymbol); } else if (symbol.Kind == SymbolKind.Event || symbol.Kind == SymbolKind.Local || symbol.Kind == SymbolKind.Parameter) { _sb.Append(symbol.Name); } else { var parts = symbol.ToDisplayParts(_format); RenderDisplayParts(symbol, parts); } } if (IncludeMarkers) { _sb.Append("$0"); } return _sb.ToString(); }
private static string GetSymbolText(ISymbol symbol, bool includeContainingSymbol, SymbolDisplayFormat displayFormat) { var label = symbol.ToDisplayString(displayFormat); var typeToShow = GetType(symbol); if (typeToShow != null) { label += " : " + typeToShow.ToDisplayString(s_labelFormat); } if (includeContainingSymbol && symbol.ContainingSymbol != null) { label += " (" + symbol.ContainingSymbol.ToDisplayString(s_labelFormat) + ")"; } return label; }
public ImmutableArray <SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, int position, SymbolDisplayFormat format = null) { // Call the right API once https://github.com/dotnet/roslyn/pull/35698 is merged var convertedFlowState = Nullability == NullableAnnotation.Annotated ? NullableFlowState.MaybeNull : NullableFlowState.None; return(WrappedSymbol.ToMinimalDisplayParts(semanticModel, convertedFlowState, position, format)); }
public ImmutableArray <SymbolDisplayPart> ToDisplayParts(SymbolDisplayFormat format = null) { return(WrappedSymbol.ToDisplayParts(format)); }
protected void AddTypeLink(ITypeSymbol typeSymbol, LinkFlags flags) { if (typeSymbol.TypeKind == TypeKind.Unknown || typeSymbol.TypeKind == TypeKind.Error || typeSymbol.TypeKind == TypeKind.TypeParameter || typeSymbol.SpecialType == SpecialType.System_Void) { AddName(typeSymbol.ToDisplayString(s_typeDisplay)); return; } var useSpecialTypes = (flags & LinkFlags.ExpandPredefinedTypes) == 0; var splitLink = !useSpecialTypes & (flags & LinkFlags.SplitNamespaceAndType) != 0; if (splitLink && !typeSymbol.ContainingNamespace.IsGlobalNamespace) { AddNamespaceLink(typeSymbol.ContainingNamespace); AddText("."); } var typeQualificationStyle = splitLink ? SymbolDisplayTypeQualificationStyle.NameAndContainingTypes : SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces; var miscellaneousOptions = useSpecialTypes ? SymbolDisplayMiscellaneousOptions.UseSpecialTypes : SymbolDisplayMiscellaneousOptions.ExpandNullable; var typeDisplayFormat = new SymbolDisplayFormat( typeQualificationStyle: typeQualificationStyle, genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance, miscellaneousOptions: miscellaneousOptions); var text = typeSymbol.ToDisplayString(typeDisplayFormat); var navInfo = _libraryManager.GetTypeNavInfo(typeSymbol, _project, GetCompilation(), useExpandedHierarchy: false); _description.AddDescriptionText3(text, VSOBDESCRIPTIONSECTION.OBDS_TYPE, navInfo); }
public string ToMinimalDisplayString(SemanticModel semanticModel, NullableFlowState topLevelNullability, int position, SymbolDisplayFormat format = null) { return(WrappedSymbol.ToMinimalDisplayString(semanticModel, topLevelNullability, position, format)); }
public ImmutableArray <SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, int position, SymbolDisplayFormat format = null) { return(WrappedSymbol.ToMinimalDisplayParts(semanticModel, position, format)); }
public ImmutableArray <SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, NullableFlowState topLevelNullability, int position, SymbolDisplayFormat format = null) { return(WrappedSymbol.ToMinimalDisplayParts(semanticModel, topLevelNullability, position, format)); }
public string ToDisplayString(SymbolDisplayFormat format = null) { return(WrappedSymbol.ToDisplayString(format)); }
public string ToDisplayString(NullableFlowState topLevelNullability, SymbolDisplayFormat format = null) { return(WrappedSymbol.ToDisplayString(topLevelNullability, format)); }
public string ToMinimalDisplayString(SemanticModel semanticModel, int position, SymbolDisplayFormat format = null) { return(WrappedSymbol.ToMinimalDisplayString(semanticModel, position, format)); }
public ImmutableArray <SymbolDisplayPart> ToDisplayParts(NullableFlowState topLevelNullability, SymbolDisplayFormat format = null) { return(WrappedSymbol.ToDisplayParts(topLevelNullability, format)); }
protected override void BuildMethodDeclaration(IMethodSymbol methodSymbol, _VSOBJDESCOPTIONS options) { BuildMemberModifiers(methodSymbol); if (methodSymbol.MethodKind != MethodKind.Constructor && methodSymbol.MethodKind != MethodKind.Destructor && methodSymbol.MethodKind != MethodKind.StaticConstructor && methodSymbol.MethodKind != MethodKind.Conversion) { AddTypeLink(methodSymbol.ReturnType, LinkFlags.None); AddText(" "); } if (methodSymbol.MethodKind == MethodKind.Conversion) { switch (methodSymbol.Name) { case WellKnownMemberNames.ImplicitConversionName: AddName("implicit operator "); break; case WellKnownMemberNames.ExplicitConversionName: AddName("explicit operator "); break; } AddTypeLink(methodSymbol.ReturnType, LinkFlags.None); } else { var methodNameFormat = new SymbolDisplayFormat( genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance); AddName(methodSymbol.ToDisplayString(methodNameFormat)); } AddText("("); if (methodSymbol.IsExtensionMethod) { AddText("this "); } BuildParameterList(methodSymbol.Parameters); AddText(")"); if (methodSymbol.IsGenericMethod) { BuildGenericConstraints(methodSymbol); } }
/// <summary> /// Tries all possible ways to retrieve the full name using the semantic model. /// </summary> /// <param name="node"></param> /// <param name="semanticModel"></param> /// <returns></returns> internal static string TryGetTypeSymbolFullName(TypeSyntax node, SemanticModel semanticModel) { var displayFormat = new SymbolDisplayFormat(typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces); // Symbol can be found via Symbol ISymbol symbol = semanticModel.GetSymbolInfo(node).Symbol; if (symbol != null) { return symbol.ToDisplayString(displayFormat); } // Symbol can be found via TypeSymbol ITypeSymbol type = semanticModel.GetTypeInfo(node).Type; if (type != null) { return type.ToDisplayString(displayFormat); } // Could not find symbol return null; }
protected override void BuildTypeDeclaration(INamedTypeSymbol typeSymbol, _VSOBJDESCOPTIONS options) { BuildTypeModifiers(typeSymbol); switch (typeSymbol.TypeKind) { case TypeKind.Enum: AddText("enum "); break; case TypeKind.Struct: AddText("struct "); break; case TypeKind.Interface: AddText("interface "); break; case TypeKind.Class: AddText("class "); break; default: Debug.Fail("Invalid type kind encountered: " + typeSymbol.TypeKind.ToString()); break; } var typeNameFormat = new SymbolDisplayFormat( genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance); AddName(typeSymbol.ToDisplayString(typeNameFormat)); if (typeSymbol.TypeKind == TypeKind.Enum) { var underlyingType = typeSymbol.EnumUnderlyingType; if (underlyingType != null) { if (underlyingType.SpecialType != SpecialType.System_Int32) { AddText(" : "); AddTypeLink(underlyingType, LinkFlags.None); } } } else { var baseType = typeSymbol.BaseType; if (baseType != null) { if (baseType.SpecialType != SpecialType.System_Object && baseType.SpecialType != SpecialType.System_Delegate && baseType.SpecialType != SpecialType.System_MulticastDelegate && baseType.SpecialType != SpecialType.System_Enum && baseType.SpecialType != SpecialType.System_ValueType) { AddText(" : "); AddTypeLink(baseType, LinkFlags.None); } } } if (typeSymbol.IsGenericType) { BuildGenericConstraints(typeSymbol); } }
public abstract ImmutableArray<SymbolDisplayPart> ToDisplayParts(ISymbol symbol, SymbolDisplayFormat format = null);
public void SymbolDisplayFormatTest() { TestCode testCode = new TestCode(@" class C1<T> { } class C2 { public static TSource M<TSource>(this C1<TSource> source, // comment here int index) {} }"); SymbolDisplayFormat format = new SymbolDisplayFormat( extensionMethodStyle: SymbolDisplayExtensionMethodStyle.StaticMethod, genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance, memberOptions: SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeModifiers | SymbolDisplayMemberOptions.IncludeAccessibility | SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeContainingType, parameterOptions: SymbolDisplayParameterOptions.IncludeExtensionThis | SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeDefaultValue, miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes); var symbol = testCode.Compilation .SourceModule .GlobalNamespace .GetTypeMembers("C2")[0] .GetMembers("M")[0]; Assert.AreEqual("public static TSource C2.M<TSource>(this C1<TSource> source, int index)", symbol.ToDisplayString(format)); }
public abstract ImmutableArray<SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, int position, ISymbol symbol, SymbolDisplayFormat format);
public static string ToFullQualifiedName(this ISymbol symbol) { var fullQualifiedNameFormat = new SymbolDisplayFormat(typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces); return symbol.ToDisplayString(fullQualifiedNameFormat); }
public string ToDisplayString(ISymbol symbol, SymbolDisplayFormat format = null) { return ToDisplayParts(symbol, format).ToDisplayString(); }
private InvocationExpressionSyntax RewriteExtensionMethodInvocation( InvocationExpressionSyntax originalNode, ExpressionSyntax thisExpression, IMethodSymbol reducedExtensionMethod, SymbolDisplayFormat symbolDisplayFormat) { var containingType = reducedExtensionMethod.ContainingType.ToDisplayString(symbolDisplayFormat); var newMemberAccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseExpression(containingType), ((MemberAccessExpressionSyntax)originalNode.Expression).OperatorToken, ((MemberAccessExpressionSyntax)originalNode.Expression).Name) .WithLeadingTrivia(thisExpression.GetFirstToken().LeadingTrivia); // Copies the annotation for the member access expression newMemberAccess = originalNode.Expression.CopyAnnotationsTo(newMemberAccess).WithAdditionalAnnotations(Simplifier.Annotation); var thisArgument = SyntaxFactory.Argument(thisExpression).WithLeadingTrivia(SyntaxTriviaList.Empty); // Copies the annotation for the left hand side of the member access expression to the first argument in the complexified form thisArgument = ((MemberAccessExpressionSyntax)originalNode.Expression).Expression.CopyAnnotationsTo(thisArgument); var arguments = originalNode.ArgumentList.Arguments.Insert(0, thisArgument); var replacementNode = SyntaxFactory.InvocationExpression( newMemberAccess, originalNode.ArgumentList.WithArguments(arguments)); // This Annotation copy is for the InvocationExpression return originalNode.CopyAnnotationsTo(replacementNode).WithAdditionalAnnotations(Simplifier.Annotation, Formatter.Annotation); }
public string ToMinimalDisplayString(SemanticModel semanticModel, int position, ISymbol symbol, SymbolDisplayFormat format = null) { return ToMinimalDisplayParts(semanticModel, position, symbol, format).ToDisplayString(); }