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