public void TestClassNameOnlyComplex()
{
var text = @"
namespace N1 {
namespace N2.N3 {
class C1 {
class C2 {} } } }
";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetNestedNamespace("N1").
GetNestedNamespace("N2").
GetNestedNamespace("N3").
GetTypeMembers("C1").Single().
GetTypeMembers("C2").Single();
var format = new SymbolDisplayFormat(
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameOnly);
TestSymbolDescription(
text,
findSymbol,
format,
"C2",
SymbolDisplayPartKind.ClassName);
}
/// <summary>
/// Displays a symbol in the C# style, based on a <see cref="SymbolDisplayFormat"/>.
/// Based on the context, qualify type and member names as little as possible without
/// introducing ambiguities.
/// </summary>
/// <param name="symbol">The symbol to be displayed.</param>
/// <param name="semanticModel">Semantic information about the context in which the symbol is being displayed.</param>
/// <param name="position">A position within the <see cref="SyntaxTree"/> or <paramref name="semanticModel"/>.</param>
/// <param name="format">The formatting options to apply. If null is passed, <see cref="SymbolDisplayFormat.CSharpErrorMessageFormat"/> will be used.</param>
/// <returns>A formatted string that can be displayed to the user.</returns>
/// <remarks>
/// The return value is not expected to be syntactically valid C#.
/// </remarks>
public static string ToMinimalDisplayString(
ISymbol symbol,
SemanticModel semanticModel,
int position,
SymbolDisplayFormat format = null)
{
return ToMinimalDisplayParts(symbol, semanticModel, position, format).ToDisplayString();
}
internal SymbolDisplayVisitor(
ArrayBuilder<SymbolDisplayPart> builder,
SymbolDisplayFormat format,
SemanticModel semanticModelOpt,
int positionOpt)
: base(builder, format, true, semanticModelOpt, positionOpt)
{
_escapeKeywordIdentifiers = format.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers);
}
/// <summary>
/// Convert a symbol to an array of string parts, each of which has a kind. Useful for
/// colorizing the display string.
/// </summary>
/// <param name="symbol">The symbol to be displayed.</param>
/// <param name="format">The formatting options to apply. If null is passed, <see cref="SymbolDisplayFormat.CSharpErrorMessageFormat"/> will be used.</param>
/// <returns>A list of display parts.</returns>
/// <remarks>
/// Parts are not localized until they are converted to strings.
/// </remarks>
public static ImmutableArray<SymbolDisplayPart> ToDisplayParts(
ISymbol symbol,
SymbolDisplayFormat format = null)
{
// null indicates the default format
format = format ?? SymbolDisplayFormat.CSharpErrorMessageFormat;
return ToDisplayParts(
symbol, semanticModelOpt: null, positionOpt: -1, format: format, minimal: false);
}
private SymbolDisplayVisitor(
ArrayBuilder<SymbolDisplayPart> builder,
SymbolDisplayFormat format,
SemanticModel semanticModelOpt,
int positionOpt,
bool escapeKeywordIdentifiers,
IDictionary<INamespaceOrTypeSymbol, IAliasSymbol> aliasMap,
bool isFirstSymbolVisited)
: base(builder, format, isFirstSymbolVisited, semanticModelOpt, positionOpt)
{
_escapeKeywordIdentifiers = escapeKeywordIdentifiers;
_lazyAliasMap = aliasMap;
}
public void TestClassNameOnlySimple()
{
var text = "class A {}";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetTypeMembers("A", 0).Single();
var format = new SymbolDisplayFormat(
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameOnly);
TestSymbolDescription(
text,
findSymbol,
format,
"A",
SymbolDisplayPartKind.ClassName);
}
protected AbstractSymbolDisplayVisitor(
ArrayBuilder<SymbolDisplayPart> builder,
SymbolDisplayFormat format,
bool isFirstSymbolVisited,
SemanticModel semanticModelOpt,
int positionOpt)
{
Debug.Assert(format != null);
this.builder = builder;
this.format = format;
this.isFirstSymbolVisited = isFirstSymbolVisited;
this.semanticModelOpt = semanticModelOpt;
this.positionOpt = positionOpt;
// If we're not the first symbol visitor, then we will just recurse into ourselves.
if (!isFirstSymbolVisited)
{
_lazyNotFirstVisitor = this;
}
}
public static ImmutableArray <SymbolDisplayPart> ToDisplayParts(this INamedTypeSymbol typeSymbol, SymbolDisplayFormat format, SymbolDisplayTypeDeclarationOptions typeDeclarationOptions)
{
if (typeDeclarationOptions == SymbolDisplayTypeDeclarationOptions.None)
{
return(typeSymbol.ToDisplayParts(format));
}
ImmutableArray <SymbolDisplayPart> parts = typeSymbol.ToDisplayParts(format);
ImmutableArray <SymbolDisplayPart> .Builder builder = ImmutableArray.CreateBuilder <SymbolDisplayPart>(parts.Length);
if ((typeDeclarationOptions & SymbolDisplayTypeDeclarationOptions.IncludeAccessibility) != 0)
{
switch (typeSymbol.DeclaredAccessibility)
{
case Accessibility.Public:
{
AddKeyword(SyntaxKind.PublicKeyword);
break;
}
case Accessibility.ProtectedOrInternal:
{
AddKeyword(SyntaxKind.ProtectedKeyword);
AddKeyword(SyntaxKind.InternalKeyword);
break;
}
case Accessibility.Internal:
{
AddKeyword(SyntaxKind.InternalKeyword);
break;
}
case Accessibility.Protected:
{
AddKeyword(SyntaxKind.ProtectedKeyword);
break;
}
case Accessibility.ProtectedAndInternal:
{
AddKeyword(SyntaxKind.PrivateKeyword);
AddKeyword(SyntaxKind.ProtectedKeyword);
break;
}
case Accessibility.Private:
{
AddKeyword(SyntaxKind.PrivateKeyword);
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
if ((typeDeclarationOptions & SymbolDisplayTypeDeclarationOptions.IncludeModifiers) != 0)
{
if (typeSymbol.IsStatic)
{
AddKeyword(SyntaxKind.StaticKeyword);
}
if (typeSymbol.IsSealed &&
!typeSymbol.TypeKind.Is(TypeKind.Struct, TypeKind.Enum, TypeKind.Delegate))
{
AddKeyword(SyntaxKind.SealedKeyword);
}
if (typeSymbol.IsAbstract &&
typeSymbol.TypeKind != TypeKind.Interface)
{
AddKeyword(SyntaxKind.AbstractKeyword);
}
}
builder.AddRange(parts);
return(builder.ToImmutableArray());
void AddKeyword(SyntaxKind kind)
{
builder.Add(SymbolDisplayPartFactory.Keyword(SyntaxFacts.GetText(kind)));
AddSpace();
}
void AddSpace()
{
builder.Add(SymbolDisplayPartFactory.Space());
}
}
public void DateTimeDefaultParameterValue()
{
var text = @"
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
class C
{
static void Foo([Optional][DateTimeConstant(100)] DateTime d) { }
}";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetMember<NamedTypeSymbol>("C").
GetMember<MethodSymbol>("Foo");
var format = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeParameters,
parameterOptions: SymbolDisplayParameterOptions.IncludeType |
SymbolDisplayParameterOptions.IncludeName |
SymbolDisplayParameterOptions.IncludeDefaultValue);
TestSymbolDescription(
text,
findSymbol,
format,
"Foo(DateTime d)",
SymbolDisplayPartKind.MethodName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.StructName,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName,
SymbolDisplayPartKind.Punctuation);
}
private static string?ProcessClass(INamedTypeSymbol classSymbol, List <IFieldSymbol> fields, ISymbol attributeSymbol, INamedTypeSymbol notifySymbol)
{
if (!classSymbol.ContainingSymbol.Equals(classSymbol.ContainingNamespace, SymbolEqualityComparer.Default))
{
return(null);
}
string namespaceName = classSymbol.ContainingNamespace.ToDisplayString();
var addNotifyInterface = !classSymbol.Interfaces.Contains(notifySymbol);
var baseType = classSymbol.BaseType;
while (true)
{
if (baseType is null)
{
break;
}
if (SymbolEqualityComparer.Default.Equals(baseType, notifySymbol))
{
addNotifyInterface = false;
break;
}
baseType = baseType.BaseType;
}
var source = new StringBuilder();
var format = new SymbolDisplayFormat(
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypes,
genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeTypeConstraints | SymbolDisplayGenericsOptions.IncludeVariance);
if (addNotifyInterface)
{
source.Append($@"// <auto-generated />
#nullable enable
using ReactiveUI;
namespace {namespaceName}
{{
public partial class {classSymbol.ToDisplayString(format)} : {notifySymbol.ToDisplayString()}
{{");
}
else
{
source.Append($@"// <auto-generated />
#nullable enable
using ReactiveUI;
namespace {namespaceName}
{{
public partial class {classSymbol.ToDisplayString(format)}
{{");
}
foreach (IFieldSymbol fieldSymbol in fields)
{
ProcessField(source, fieldSymbol, attributeSymbol);
}
source.Append($@"
}}
}}");
return(source.ToString());
}
public override ImmutableArray <SymbolDisplayPart> ToDisplayParts(ISymbol symbol, SymbolDisplayFormat format = null)
{
return(Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(symbol, format));
}
public void TestOptionalParameters_Constrained_Struct()
{
var text = @"
using System.Runtime.InteropServices;
class C
{
void F<T>([Optional]T arg) where T : struct { }
";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetTypeMembers("C", 0).Single().
GetMembers("F").Single();
var format = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeParameters,
parameterOptions: SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeDefaultValue,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers | SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
TestSymbolDescription(
text,
findSymbol,
format,
"void F(T arg)",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.MethodName, // F
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.TypeParameterName,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, // arg
SymbolDisplayPartKind.Punctuation);
}
public abstract ImmutableArray<SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, int position, ISymbol symbol, SymbolDisplayFormat format);
public ImmutableArray <SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, NullableFlowState topLevelNullability, int position, SymbolDisplayFormat format = null) => throw new System.NotImplementedException();
public void UnconventionalExplicitInterfaceImplementation()
{
var il = @"
.class public auto ansi sealed DTest
extends [mscorlib]System.MulticastDelegate
{
.method public hidebysig specialname rtspecialname
instance void .ctor(object 'object',
native int 'method') runtime managed
{
} // end of method DTest::.ctor
.method public hidebysig newslot virtual
instance void Invoke() runtime managed
{
} // end of method DTest::Invoke
.method public hidebysig newslot virtual
instance class [mscorlib]System.IAsyncResult
BeginInvoke(class [mscorlib]System.AsyncCallback callback,
object 'object') runtime managed
{
} // end of method DTest::BeginInvoke
.method public hidebysig newslot virtual
instance void EndInvoke(class [mscorlib]System.IAsyncResult result) runtime managed
{
} // end of method DTest::EndInvoke
} // end of class DTest
.class interface public abstract auto ansi ITest
{
.method public hidebysig newslot abstract virtual
instance void M1() cil managed
{
} // end of method ITest::M1
.method public hidebysig newslot specialname abstract virtual
instance int32 get_P1() cil managed
{
} // end of method ITest::get_P1
.method public hidebysig newslot specialname abstract virtual
instance void set_P1(int32 'value') cil managed
{
} // end of method ITest::set_P1
.method public hidebysig newslot specialname abstract virtual
instance void add_E1(class DTest 'value') cil managed
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
} // end of method ITest::add_E1
.method public hidebysig newslot specialname abstract virtual
instance void remove_E1(class DTest 'value') cil managed
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
} // end of method ITest::remove_E1
.event DTest E1
{
.addon instance void ITest::add_E1(class DTest)
.removeon instance void ITest::remove_E1(class DTest)
} // end of event ITest::E1
.property instance int32 P1()
{
.get instance int32 ITest::get_P1()
.set instance void ITest::set_P1(int32)
} // end of property ITest::P1
} // end of class ITest
.class public auto ansi beforefieldinit CTest
extends [mscorlib]System.Object
implements ITest
{
.method public hidebysig newslot specialname virtual final
instance int32 get_P1() cil managed
{
.override ITest::get_P1
// Code size 7 (0x7)
.maxstack 8
IL_0000: nop
IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor()
IL_0006: throw
} // end of method CTest::ITest.get_P1
.method public hidebysig newslot specialname virtual final
instance void set_P1(int32 'value') cil managed
{
.override ITest::set_P1
// Code size 7 (0x7)
.maxstack 8
IL_0000: nop
IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor()
IL_0006: throw
} // end of method CTest::ITest.set_P1
.method public hidebysig newslot specialname virtual final
instance void add_E1(class DTest 'value') cil managed
{
.override ITest::add_E1
// Code size 7 (0x7)
.maxstack 8
IL_0000: nop
IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor()
IL_0006: throw
} // end of method CTest::ITest.add_E1
.method public hidebysig newslot specialname virtual final
instance void remove_E1(class DTest 'value') cil managed
{
.override ITest::remove_E1
// Code size 7 (0x7)
.maxstack 8
IL_0000: nop
IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor()
IL_0006: throw
} // end of method CTest::ITest.remove_E1
.method public hidebysig newslot virtual final
instance void M1() cil managed
{
.override ITest::M1
// Code size 7 (0x7)
.maxstack 8
IL_0000: nop
IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor()
IL_0006: throw
} // end of method CTest::ITest.M1
.method public hidebysig specialname rtspecialname
instance void .ctor() cil managed
{
// Code size 8 (0x8)
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: nop
IL_0007: ret
} // end of method CTest::.ctor
.event DTest E1
{
.addon instance void CTest::add_E1(class DTest)
.removeon instance void CTest::remove_E1(class DTest)
} // end of event CTest::ITest.E1
.property instance int32 P1()
{
.get instance int32 CTest::get_P1()
.set instance void CTest::set_P1(int32)
} // end of property CTest::ITest.P1
} // end of class CTest
";
var text = @"";
var comp = CreateCompilationWithCustomILSource(text, il);
var format = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeExplicitInterface);
var cTest = comp.GetTypeByMetadataName("CTest");
var m1 = cTest.GetMember("M1");
Assert.Equal("M1", m1.Name);
Assert.Equal("M1", m1.ToDisplayString(format));
var p1 = cTest.GetMember("P1");
Assert.Equal("P1", p1.Name);
Assert.Equal("P1", p1.ToDisplayString(format));
var e1 = cTest.GetMember("E1");
Assert.Equal("E1", e1.Name);
Assert.Equal("E1", e1.ToDisplayString(format));
}
public ImmutableArray <SymbolDisplayPart> ToDisplayParts(NullableFlowState topLevelNullability, SymbolDisplayFormat format = null) => throw new System.NotImplementedException();
public string ToMinimalDisplayString(SemanticModel semanticModel, NullableFlowState topLevelNullability, int position, SymbolDisplayFormat format = null) => throw new System.NotImplementedException();
public string ToDisplayString(NullableFlowState topLevelNullability, SymbolDisplayFormat format = null) => throw new System.NotImplementedException();
protected override void WriteSymbol(
ISymbol symbol,
SymbolDisplayFormat format = null,
bool removeAttributeSuffix = false)
{
bool shouldWriteContainingNamespace = false;
if (symbol.Kind == SymbolKind.Field &&
symbol.ContainingType.TypeKind == TypeKind.Enum)
{
base.WriteSymbol(symbol, format);
}
else
{
shouldWriteContainingNamespace = ShouldWriteContainingNamespace();
if (IsExternal(symbol))
{
string url = WellKnownExternalUrlProviders.MicrosoftDocs.CreateUrl(symbol).Url;
if (url != null)
{
if (shouldWriteContainingNamespace)
{
WriteContainingNamespace(symbol);
}
WriteStartElement("a");
WriteAttributeString("href", url);
WriteName();
WriteEndElement();
}
else
{
WriteName();
}
}
else
{
if (shouldWriteContainingNamespace)
{
WriteContainingNamespace(symbol);
}
WriteStartElement("a");
WriteStartAttribute("href");
Write("#");
WriteLocalLink(symbol);
WriteEndAttribute();
WriteName();
WriteEndElement();
}
}
bool ShouldWriteContainingNamespace()
{
return(symbol.IsKind(SymbolKind.NamedType) &&
!symbol.ContainingNamespace.IsGlobalNamespace &&
Format.Includes(SymbolDefinitionPartFilter.ContainingNamespace) &&
!CSharpFacts.IsPredefinedType(((INamedTypeSymbol)symbol).SpecialType) &&
(format == null || format.TypeQualificationStyle == SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces));
}
void WriteName()
{
if (symbol.IsKind(SymbolKind.Namespace))
{
format = TypeSymbolDisplayFormats.Name_ContainingTypes_Namespaces;
}
else if (shouldWriteContainingNamespace)
{
format = TypeSymbolDisplayFormats.Name_ContainingTypes_SpecialTypes;
}
base.WriteSymbol(symbol, format, removeAttributeSuffix: removeAttributeSuffix);
}
}
public override void WriteNamespaceDefinition(INamespaceSymbol namespaceSymbol, SymbolDisplayFormat format = null)
{
if (namespaceSymbol.IsGlobalNamespace)
{
return;
}
if (DocumentationDisplayMode == DocumentationDisplayMode.Xml)
{
WriteDocumentationComment(namespaceSymbol);
}
WriteDefinition(namespaceSymbol, format);
WriteEndElement();
WriteLine();
IncreaseDepth();
}
public void TestMethodVB()
{
var text = @"
Class A
Public Sub Foo(a As Integer)
End Sub
End Class";
var format = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeModifiers | SymbolDisplayMemberOptions.IncludeAccessibility | SymbolDisplayMemberOptions.IncludeType,
parameterOptions: SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeDefaultValue,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
var comp = CreateVisualBasicCompilation("c", text);
var a = (ITypeSymbol)comp.GlobalNamespace.GetMembers("A").Single();
var foo = a.GetMembers("Foo").Single();
var parts = Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(foo, format);
Verify(
parts,
"public void Foo(int a)",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.MethodName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName,
SymbolDisplayPartKind.Punctuation);
}
public static string ToDisplayString(this ISymbol symbol, SymbolDisplayFormat format, SymbolDisplayAdditionalMemberOptions additionalOptions)
{
return(symbol.ToDisplayParts(format, additionalOptions).ToDisplayString());
}
public void KindOptions()
{
var source = @"
namespace N
{
class C
{
event System.Action E;
}
}
";
var memberFormat = new SymbolDisplayFormat(
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
memberOptions: SymbolDisplayMemberOptions.IncludeContainingType,
kindOptions: SymbolDisplayKindOptions.IncludeMemberKeyword);
var typeFormat = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeContainingType,
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
kindOptions: SymbolDisplayKindOptions.IncludeTypeKeyword);
var namespaceFormat = new SymbolDisplayFormat(
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
memberOptions: SymbolDisplayMemberOptions.IncludeContainingType,
kindOptions: SymbolDisplayKindOptions.IncludeNamespaceKeyword);
var comp = CreateCompilationWithMscorlib(source);
var namespaceSymbol = comp.GlobalNamespace.GetMember<NamespaceSymbol>("N");
var typeSymbol = namespaceSymbol.GetMember<NamedTypeSymbol>("C");
var eventSymbol = typeSymbol.GetMember<EventSymbol>("E");
Verify(
namespaceSymbol.ToDisplayParts(memberFormat),
"N",
SymbolDisplayPartKind.NamespaceName);
Verify(
namespaceSymbol.ToDisplayParts(typeFormat),
"N",
SymbolDisplayPartKind.NamespaceName);
Verify(
namespaceSymbol.ToDisplayParts(namespaceFormat),
"namespace N",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.NamespaceName);
Verify(
typeSymbol.ToDisplayParts(memberFormat),
"N.C",
SymbolDisplayPartKind.NamespaceName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.ClassName);
Verify(
typeSymbol.ToDisplayParts(typeFormat),
"class N.C",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.NamespaceName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.ClassName);
Verify(
typeSymbol.ToDisplayParts(namespaceFormat),
"N.C",
SymbolDisplayPartKind.NamespaceName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.ClassName);
Verify(
eventSymbol.ToDisplayParts(memberFormat),
"event N.C.E",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.NamespaceName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.EventName);
Verify(
eventSymbol.ToDisplayParts(typeFormat),
"N.C.E",
SymbolDisplayPartKind.NamespaceName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.EventName);
Verify(
eventSymbol.ToDisplayParts(namespaceFormat),
"N.C.E",
SymbolDisplayPartKind.NamespaceName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.EventName);
}
public static ImmutableArray <SymbolDisplayPart> ToDisplayParts(this ISymbol symbol, SymbolDisplayFormat format, SymbolDisplayAdditionalMemberOptions additionalOptions)
{
if (additionalOptions == SymbolDisplayAdditionalMemberOptions.None)
{
return(symbol.ToDisplayParts(format));
}
ImmutableArray <SymbolDisplayPart> parts = symbol.ToDisplayParts(format);
int length = parts.Length;
for (int i = 0; i < length; i++)
{
SymbolDisplayPart part = parts[i];
switch (part.Kind)
{
case SymbolDisplayPartKind.Keyword:
{
switch (part.ToString())
{
case "this":
{
if ((additionalOptions & SymbolDisplayAdditionalMemberOptions.UseItemPropertyName) != 0 &&
(symbol as IPropertySymbol)?.IsIndexer == true)
{
parts = parts.Replace(part, SymbolDisplayPartFactory.PropertyName("Item", part.Symbol));
}
break;
}
case "operator":
{
if ((additionalOptions & SymbolDisplayAdditionalMemberOptions.UseOperatorName) != 0 &&
symbol is IMethodSymbol methodSymbol &&
methodSymbol.MethodKind == MethodKind.UserDefinedOperator)
{
string name = methodSymbol.Name;
Debug.Assert(name.StartsWith("op_", StringComparison.Ordinal), name);
if (name.StartsWith("op_", StringComparison.Ordinal) &&
i < length - 2 &&
parts[i + 1].IsSpace() &&
parts[i + 2].Kind == SymbolDisplayPartKind.MethodName)
{
parts = parts.Replace(parts[i + 2], SymbolDisplayPartFactory.MethodName(name.Substring(3), parts[i + 2].Symbol));
parts = parts.RemoveRange(i, 2);
length -= 2;
}
}
break;
}
case "implicit":
case "explicit":
{
if ((additionalOptions & SymbolDisplayAdditionalMemberOptions.UseOperatorName) != 0 &&
symbol is IMethodSymbol methodSymbol &&
methodSymbol.MethodKind == MethodKind.Conversion)
{
string name = methodSymbol.Name;
Debug.Assert(name.StartsWith("op_", StringComparison.Ordinal), name);
if (name.StartsWith("op_", StringComparison.Ordinal) &&
i < length - 2 &&
parts[i + 1].IsSpace() &&
parts[i + 2].IsKeyword("operator"))
{
List <SymbolDisplayPart> list = parts.ToList();
list[i + 2] = SymbolDisplayPartFactory.MethodName(name.Substring(3), list[i + 4].Symbol);
list.RemoveRange(i, 2);
length -= 2;
if (i == length - 3 &&
list[i + 1].IsSpace() &&
list[i + 2].IsName())
{
list.RemoveRange(i + 1, 2);
length -= 2;
}
else if (i < length - 5 &&
list[i + 1].IsSpace() &&
list[i + 2].IsName() &&
list[i + 3].IsPunctuation() &&
list[i + 4].IsName() &&
list[i + 5].IsPunctuation())
{
list.Insert(i + 5, list[i + 2]);
list.Insert(i + 5, SymbolDisplayPartFactory.Text(" to "));
list.RemoveRange(i + 1, 2);
length -= 5;
}
parts = list.ToImmutableArray();
}
}
break;
}
}
break;
}
}
}
return(parts);
}
public void TestArrayRank()
{
var text = @"
class A {
int[][,][,,] f; }
";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetTypeMembers("A", 0).Single().
GetMembers("f").Single();
var format = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeType,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
TestSymbolDescription(
text,
findSymbol,
format,
"int[][,][,,] f",
SymbolDisplayPartKind.Keyword, //int
SymbolDisplayPartKind.Punctuation, //[
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation, //[
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation, //[
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.FieldName); //f
}
public override void WriteEnumMemberDefinition(ISymbol symbol, SymbolDisplayFormat format = null)
{
base.WriteEnumMemberDefinition(symbol, format);
WriteEndBulletItem();
}
public void TestEscapeKeywordIdentifiers()
{
var text = @"
class @true {
@true @false(@true @true, bool @bool = true) { return @true; } }
";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetTypeMembers("true", 0).Single().
GetMembers("false").Single();
var format = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeParameters,
parameterOptions: SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeDefaultValue,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers | SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
TestSymbolDescription(
text,
findSymbol,
format,
"@true @false(@true @true, bool @bool = true)",
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.MethodName, //@false
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, //@true
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, //@bool
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Punctuation);
}
public override void WriteNamespaceDefinition(INamespaceSymbol namespaceSymbol, SymbolDisplayFormat format = null)
{
base.WriteNamespaceDefinition(namespaceSymbol, format);
WriteEndBulletItem();
}
public static string ToDisplayString(this INamedTypeSymbol typeSymbol, SymbolDisplayFormat format, SymbolDisplayTypeDeclarationOptions typeDeclarationOptions)
{
return(typeSymbol.ToDisplayParts(format, typeDeclarationOptions).ToDisplayString());
}
public override void WriteTypeDefinition(INamedTypeSymbol typeSymbol, SymbolDisplayFormat format = null)
{
base.WriteTypeDefinition(typeSymbol, format);
WriteEndBulletItem();
}
public override ImmutableArray <SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, int position, ISymbol symbol, SymbolDisplayFormat format)
{
return(symbol.ToMinimalDisplayParts(semanticModel, position, format));
}
protected override string ToDisplayString(IMethodSymbol disposeImplMethod, SymbolDisplayFormat format) => SymbolDisplay.ToDisplayString(disposeImplMethod, format);
protected abstract string ToDisplayString(IParameterSymbol parameter, SymbolDisplayFormat format);
public static ExpressionSyntax ToDefaultValueSyntax(this ITypeSymbol typeSymbol, SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
{
if (typeSymbol == null)
{
throw new ArgumentNullException(nameof(typeSymbol));
}
if (semanticModel == null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
return(ToDefaultValueSyntax(typeSymbol, default(TypeSyntax), semanticModel, position, format));
}
public void TestEnumMember_FlagsWithoutAttribute()
{
var text =
@"enum E { A = 1, B = 2, C = 4, D = A | B | C }";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetTypeMembers("E", 0).Single().
GetMembers("D").Single();
var format = new SymbolDisplayFormat(
memberOptions:
SymbolDisplayMemberOptions.IncludeAccessibility |
SymbolDisplayMemberOptions.IncludeContainingType |
SymbolDisplayMemberOptions.IncludeExplicitInterface |
SymbolDisplayMemberOptions.IncludeModifiers |
SymbolDisplayMemberOptions.IncludeParameters |
SymbolDisplayMemberOptions.IncludeType |
SymbolDisplayMemberOptions.IncludeConstantValue);
TestSymbolDescription(
text,
findSymbol,
format,
"E.D = 7",
SymbolDisplayPartKind.EnumName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.FieldName,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.NumericLiteral);
}
private static ExpressionSyntax ToDefaultValueSyntax(ITypeSymbol typeSymbol, TypeSyntax type, SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
{
if (typeSymbol.IsErrorType())
{
return(null);
}
switch (typeSymbol.SpecialType)
{
case SpecialType.System_Boolean:
return(FalseLiteralExpression());
case SpecialType.System_Char:
return(CharacterLiteralExpression('\0'));
case SpecialType.System_SByte:
case SpecialType.System_Byte:
case SpecialType.System_Int16:
case SpecialType.System_UInt16:
case SpecialType.System_Int32:
case SpecialType.System_UInt32:
case SpecialType.System_Int64:
case SpecialType.System_UInt64:
case SpecialType.System_Decimal:
case SpecialType.System_Single:
case SpecialType.System_Double:
return(NumericLiteralExpression(0));
}
if (typeSymbol.IsConstructedFrom(SpecialType.System_Nullable_T))
{
return(NullLiteralExpression());
}
if (typeSymbol.BaseType?.SpecialType == SpecialType.System_Enum)
{
IFieldSymbol fieldSymbol = typeSymbol.FindFieldWithConstantValue(0);
if (fieldSymbol != null)
{
type = type ?? ((semanticModel != null)
? typeSymbol.ToMinimalTypeSyntax(semanticModel, position, format)
: typeSymbol.ToTypeSyntax().WithSimplifierAnnotation());
Debug.Assert(type != null);
return(SimpleMemberAccessExpression(type, IdentifierName(fieldSymbol.Name)));
}
else
{
return(NumericLiteralExpression(0));
}
}
if (typeSymbol.IsReferenceType)
{
return(NullLiteralExpression());
}
type = type ?? ((semanticModel != null)
? typeSymbol.ToMinimalTypeSyntax(semanticModel, position, format)
: typeSymbol.ToTypeSyntax().WithSimplifierAnnotation());
Debug.Assert(type != null);
return(DefaultExpression(type));
}
public void ReverseArrayRankSpecifiers()
{
var text = @"
public class C
{
C[][,] F;
}
";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetMember<NamedTypeSymbol>("C").GetMember<FieldSymbol>("F").Type;
var normalFormat = new SymbolDisplayFormat();
var reverseFormat = new SymbolDisplayFormat(
compilerInternalOptions: SymbolDisplayCompilerInternalOptions.ReverseArrayRankSpecifiers);
TestSymbolDescription(
text,
findSymbol,
normalFormat,
"C[][,]",
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation);
TestSymbolDescription(
text,
findSymbol,
reverseFormat,
"C[,][]",
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation);
}
internal static TypeSyntax ToTypeSyntax(this INamespaceOrTypeSymbol namespaceOrTypeSymbol, SymbolDisplayFormat format = null)
{
if (namespaceOrTypeSymbol == null)
{
throw new ArgumentNullException(nameof(namespaceOrTypeSymbol));
}
if (namespaceOrTypeSymbol.IsType)
{
return(ToTypeSyntax((ITypeSymbol)namespaceOrTypeSymbol, format));
}
else
{
return(ToTypeSyntax((INamespaceSymbol)namespaceOrTypeSymbol, format));
}
}
public void TestWindowsRuntimeEvent()
{
var source = @"
class C
{
event System.Action E;
}
";
var format = new SymbolDisplayFormat(
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypes,
memberOptions: SymbolDisplayMemberOptions.IncludeContainingType | SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeExplicitInterface);
var comp = CreateCompilation(source, WinRtRefs, TestOptions.ReleaseWinMD);
var eventSymbol = comp.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<EventSymbol>("E");
Assert.True(eventSymbol.IsWindowsRuntimeEvent);
Verify(
eventSymbol.ToDisplayParts(format),
"Action C.E",
SymbolDisplayPartKind.DelegateName,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.EventName);
Verify(
eventSymbol.AddMethod.ToDisplayParts(format),
"EventRegistrationToken C.E.add",
SymbolDisplayPartKind.StructName,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.EventName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Keyword);
Verify(
eventSymbol.RemoveMethod.ToDisplayParts(format),
"void C.E.remove",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ClassName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.EventName,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Keyword);
}
internal static TypeSyntax ToMinimalTypeSyntax(this INamespaceOrTypeSymbol namespaceOrTypeSymbol, SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
{
if (namespaceOrTypeSymbol == null)
{
throw new ArgumentNullException(nameof(namespaceOrTypeSymbol));
}
if (semanticModel == null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
if (namespaceOrTypeSymbol.IsType)
{
return(ToMinimalTypeSyntax((ITypeSymbol)namespaceOrTypeSymbol, semanticModel, position, format));
}
else
{
return(ToMinimalTypeSyntax((INamespaceSymbol)namespaceOrTypeSymbol, semanticModel, position, format));
}
}
public void EnumAmbiguityResolution()
{
var source = @"
using System;
class Program
{
static void M(E1 e1 = (E1)1, E2 e2 = (E2)1)
{
}
}
enum E1
{
B = 1,
A = 1,
}
[Flags]
enum E2 // Identical to E1, but has [Flags]
{
B = 1,
A = 1,
}
";
var comp = CreateCompilationWithMscorlib(source);
var method = comp.GlobalNamespace.GetMember<NamedTypeSymbol>("Program").GetMember<MethodSymbol>("M");
var memberFormat = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeParameters,
parameterOptions: SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeDefaultValue);
Assert.Equal("M(e1 = A, e2 = A)", method.ToDisplayString(memberFormat)); // Alphabetically first candidate chosen for both enums.
}
public static TypeSyntax ToMinimalTypeSyntax(this INamespaceSymbol namespaceSymbol, SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
{
if (namespaceSymbol == null)
{
throw new ArgumentNullException(nameof(namespaceSymbol));
}
if (semanticModel == null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
ThrowIfExplicitDeclarationIsNotSupported(namespaceSymbol);
return(ParseTypeName(namespaceSymbol.ToMinimalDisplayString(semanticModel, position, format ?? NamespaceSymbolDisplayFormat)));
}
public void TestReducedExtensionMethodAsDefault()
{
var text = @"
class C1 { }
class C2 {
public static TSource M<TSource>(this C1 source, int index) {} }
";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
{
var type = global.GetTypeMember("C1");
var method = (MethodSymbol)global.GetTypeMember("C2").GetMember("M");
return method.ReduceExtensionMethod(type);
};
var format = new SymbolDisplayFormat(
extensionMethodStyle: SymbolDisplayExtensionMethodStyle.Default,
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);
TestSymbolDescription(
text,
findSymbol,
format,
"public TSource C1.M<TSource>(int index)",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.TypeParameterName, //TSource
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ClassName, //C1
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.MethodName, //M
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.TypeParameterName, //TSource
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, //index
SymbolDisplayPartKind.Punctuation);
}
public string ToDisplayString(SymbolDisplayFormat format = null)
{
throw new NotImplementedException();
}
public void TestOptionalParameters_String()
{
var text = @"
class C
{
void F(string s = ""f\t\r\noo"") { }
";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetTypeMembers("C", 0).Single().
GetMembers("F").Single();
var format = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeParameters,
parameterOptions: SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeDefaultValue,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers | SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
TestSymbolDescription(
text,
findSymbol,
format,
@"void F(string s = ""f\t\r\noo"")",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.MethodName, // F
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, // s
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.Punctuation, // =
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.StringLiteral,
SymbolDisplayPartKind.Punctuation);
}
/// <summary>
/// Convert a symbol to an array of string parts, each of which has a kind. Useful for
/// colorizing the display string.
/// </summary>
/// <param name="symbol">The symbol to be displayed.</param>
/// <param name="semanticModel">Semantic information about the context in which the symbol is being displayed.</param>
/// <param name="position">A position within the <see cref="SyntaxTree"/> or <paramref name="semanticModel"/>.</param>
/// <param name="format">The formatting options to apply. If null is passed, <see cref="SymbolDisplayFormat.CSharpErrorMessageFormat"/> will be used.</param>
/// <returns>A list of display parts.</returns>
/// <remarks>
/// Parts are not localized until they are converted to strings.
/// </remarks>
public static ImmutableArray<SymbolDisplayPart> ToMinimalDisplayParts(
ISymbol symbol,
SemanticModel semanticModel,
int position,
SymbolDisplayFormat format = null)
{
format = format ?? SymbolDisplayFormat.MinimallyQualifiedFormat;
return ToDisplayParts(symbol, semanticModel, position, format, minimal: true);
}
public void TestOptionalParameters_ArrayAndType()
{
var text = @"
using System.Runtime.InteropServices;
class C
{
void F<T>(int a, [Optional]double[] arg, int b, [Optional]System.Type t) { }
";
Func<NamespaceSymbol, Symbol> findSymbol = global =>
global.GetTypeMembers("C", 0).Single().
GetMembers("F").Single();
var format = new SymbolDisplayFormat(
memberOptions: SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeParameters,
parameterOptions: SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeDefaultValue,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers | SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
TestSymbolDescription(
text,
findSymbol,
format,
"void F(int a, double[] arg, int b, Type t)",
SymbolDisplayPartKind.Keyword,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.MethodName, // F
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Keyword, // int
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, // a
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.Keyword, // double
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, // arg
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.Keyword, // int
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, // b
SymbolDisplayPartKind.Punctuation,
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ClassName, // Type
SymbolDisplayPartKind.Space,
SymbolDisplayPartKind.ParameterName, // t
SymbolDisplayPartKind.Punctuation);
}
public IEnumerable<TaggedText> Format(string rawXmlText, SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
{
if (rawXmlText == null)
{
return null;
}
var state = new FormatterState() { SemanticModel = semanticModel, Position = position, Format = format };
// In case the XML is a fragment (that is, a series of elements without a parent)
// wrap it up in a single tag. This makes parsing it much, much easier.
var inputString = "<tag>" + rawXmlText + "</tag>";
var summaryElement = XElement.Parse(inputString, LoadOptions.PreserveWhitespace);
AppendTextFromNode(state, summaryElement, state.SemanticModel.Compilation);
return state.Builder;
}
public abstract ImmutableArray<SymbolDisplayPart> ToDisplayParts(ISymbol symbol, SymbolDisplayFormat format = null);
protected ImmutableArray<SymbolDisplayPart> ToMinimalDisplayParts(ISymbol symbol, SymbolDisplayFormat format = null)
{
format = format ?? MinimallyQualifiedFormat;
return _displayService.ToMinimalDisplayParts(_semanticModel, _position, symbol, format);
}
/// <summary>
/// Displays a symbol in the C# style, based on a <see cref="SymbolDisplayFormat"/>.
/// </summary>
/// <param name="symbol">The symbol to be displayed.</param>
/// <param name="format">The formatting options to apply. If null is passed, <see cref="SymbolDisplayFormat.CSharpErrorMessageFormat"/> will be used.</param>
/// <returns>A formatted string that can be displayed to the user.</returns>
/// <remarks>
/// The return value is not expected to be syntactically valid C#.
/// </remarks>
public static string ToDisplayString(
ISymbol symbol,
SymbolDisplayFormat format = null)
{
return ToDisplayParts(symbol, format).ToDisplayString();
}
protected IEnumerable <SymbolDisplayPart> ToDisplayParts(ISymbol symbol, SymbolDisplayFormat format = null)
{
return(_displayService.ToDisplayParts(symbol, format));
}
public ImmutableArray <SymbolDisplayPart> ToDisplayParts(SymbolDisplayFormat format = null)
{
throw new NotImplementedException();
}
public IEnumerable <TaggedText> Format(string rawXmlText, SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
{
if (rawXmlText == null)
{
return(null);
}
var state = new FormatterState()
{
SemanticModel = semanticModel, Position = position, Format = format
};
// In case the XML is a fragment (that is, a series of elements without a parent)
// wrap it up in a single tag. This makes parsing it much, much easier.
var inputString = "<tag>" + rawXmlText + "</tag>";
var summaryElement = XElement.Parse(inputString, LoadOptions.PreserveWhitespace);
AppendTextFromNode(state, summaryElement, state.SemanticModel.Compilation);
return(state.Builder);
}
private static ImmutableArray<SymbolDisplayPart> ToDisplayParts(
ISymbol symbol,
SemanticModel semanticModelOpt,
int positionOpt,
SymbolDisplayFormat format,
bool minimal)
{
if (symbol == null)
{
throw new ArgumentNullException(nameof(symbol));
}
if (minimal)
{
if (semanticModelOpt == null)
{
throw new ArgumentException(CSharpResources.SyntaxTreeSemanticModelMust);
}
else if (positionOpt < 0 || positionOpt > semanticModelOpt.SyntaxTree.Length) // Note: not >= since EOF is allowed.
{
throw new ArgumentOutOfRangeException(CSharpResources.PositionNotWithinTree);
}
}
else
{
Debug.Assert(semanticModelOpt == null);
Debug.Assert(positionOpt < 0);
}
var builder = ArrayBuilder<SymbolDisplayPart>.GetInstance();
var visitor = new SymbolDisplayVisitor(builder, format, semanticModelOpt, positionOpt);
symbol.Accept(visitor);
return builder.ToImmutableAndFree();
}
public string ToMinimalDisplayString(SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
{
throw new NotImplementedException();
}
internal static IEnumerable<SymbolDisplayPart> CrefToSymbolDisplayParts(
string crefValue, int position, SemanticModel semanticModel, SymbolDisplayFormat format = null)
{
// first try to parse the symbol
if (semanticModel != null)
{
var symbol = DocumentationCommentId.GetFirstSymbolForDeclarationId(crefValue, semanticModel.Compilation);
if (symbol != null)
{
if (symbol.IsConstructor())
{
format = format.WithMemberOptions(SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeExplicitInterface);
}
return symbol.ToMinimalDisplayParts(semanticModel, position, format);
}
}
// if any of that fails fall back to just displaying the raw text
return SpecializedCollections.SingletonEnumerable(
new SymbolDisplayPart(SymbolDisplayPartKind.Text, symbol: null, text: TrimCrefPrefix(crefValue)));
}
public ImmutableArray <SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
{
throw new NotImplementedException();
}
protected IEnumerable<SymbolDisplayPart> ToDisplayParts(ISymbol symbol, SymbolDisplayFormat format = null)
{
return _displayService.ToDisplayParts(symbol, format);
}
protected abstract string ToDisplayString(IMethodSymbol disposeImplMethod, SymbolDisplayFormat format);
