private static string ToDisplayString(INamedTypeSymbol symbol, INamespaceSymbol containingNamespace)
{
ImmutableArray <SymbolDisplayPart> .Builder builder = ImmutableArray.CreateBuilder <SymbolDisplayPart>();
builder.AddDisplayParts(symbol, containingNamespace);
return(builder.ToImmutableArray().ToDisplayString());
}
private static void AddDisplayParts(this ImmutableArray <SymbolDisplayPart> .Builder builder, ISymbol symbol, INamespaceSymbol containingNamespace)
{
if (containingNamespace != null &&
symbol.ContainingNamespace == containingNamespace)
{
builder.AddRange(symbol.ToDisplayParts(SymbolDisplayFormats.TypeNameAndContainingTypes));
}
else
{
builder.AddRange(symbol.ToDisplayParts(SymbolDisplayFormats.TypeNameAndContainingTypesAndNamespaces));
}
if (!(symbol is INamedTypeSymbol typeSymbol))
{
return;
}
ImmutableArray <ITypeSymbol> typeArguments = typeSymbol.TypeArguments;
ImmutableArray <ITypeSymbol> .Enumerator en = typeArguments.GetEnumerator();
if (en.MoveNext())
{
builder.AddPunctuation("<");
while (true)
{
if (en.Current.Kind == SymbolKind.NamedType)
{
builder.AddDisplayParts((INamedTypeSymbol)en.Current, containingNamespace);
}
else
{
Debug.Assert(en.Current.Kind == SymbolKind.TypeParameter, en.Current.Kind.ToString());
builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.TypeParameterName, en.Current, en.Current.Name));
}
if (en.MoveNext())
{
builder.AddPunctuation(",");
builder.AddSpace();
}
else
{
break;
}
}
builder.AddPunctuation(">");
}
}
private static void AddAttribute(
ImmutableArray <SymbolDisplayPart> .Builder parts,
AttributeData attribute,
SymbolDisplayFormat format,
SymbolDisplayAdditionalOptions additionalOptions)
{
parts.AddDisplayParts(attribute.AttributeClass, format, additionalOptions, removeAttributeSuffix: true);
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.IncludeAttributeArguments))
{
AddAttributeArguments();
}
void AddAttributeArguments()
{
bool hasConstructorArgument = false;
bool hasNamedArgument = false;
AppendConstructorArguments();
AppendNamedArguments();
if (hasConstructorArgument || hasNamedArgument)
{
parts.AddPunctuation(")");
}
void AppendConstructorArguments()
{
ImmutableArray <TypedConstant> .Enumerator en = attribute.ConstructorArguments.GetEnumerator();
if (en.MoveNext())
{
hasConstructorArgument = true;
parts.AddPunctuation("(");
while (true)
{
AddConstantValue(en.Current);
if (en.MoveNext())
{
parts.AddPunctuation(",");
parts.AddSpace();
}
else
{
break;
}
}
}
}
void AppendNamedArguments()
{
ImmutableArray <KeyValuePair <string, TypedConstant> > .Enumerator en = attribute.NamedArguments.GetEnumerator();
if (en.MoveNext())
{
hasNamedArgument = true;
if (hasConstructorArgument)
{
parts.AddPunctuation(",");
parts.AddSpace();
}
else
{
parts.AddPunctuation("(");
}
while (true)
{
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.PropertyName, null, en.Current.Key));
parts.AddSpace();
parts.AddPunctuation("=");
parts.AddSpace();
AddConstantValue(en.Current.Value);
if (en.MoveNext())
{
parts.AddPunctuation(",");
parts.AddSpace();
}
else
{
break;
}
}
}
}
}
void AddConstantValue(TypedConstant typedConstant)
{
switch (typedConstant.Kind)
{
case TypedConstantKind.Primitive:
{
parts.Add(new SymbolDisplayPart(
GetSymbolDisplayPart(typedConstant.Type.SpecialType),
null,
SymbolDisplay.FormatPrimitive(typedConstant.Value, quoteStrings: true, useHexadecimalNumbers: false)));
break;
}
case TypedConstantKind.Enum:
{
OneOrMany <EnumFieldSymbolInfo> oneOrMany = EnumUtility.GetConstituentFields(typedConstant.Value, (INamedTypeSymbol)typedConstant.Type);
OneOrMany <EnumFieldSymbolInfo> .Enumerator en = oneOrMany.GetEnumerator();
if (en.MoveNext())
{
while (true)
{
AddDisplayParts(parts, en.Current.Symbol, format, additionalOptions);
if (en.MoveNext())
{
parts.AddSpace();
parts.AddPunctuation("|");
parts.AddSpace();
}
else
{
break;
}
}
}
else
{
parts.AddPunctuation("(");
AddDisplayParts(parts, (INamedTypeSymbol)typedConstant.Type, format, additionalOptions);
parts.AddPunctuation(")");
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.NumericLiteral, null, typedConstant.Value.ToString()));
}
break;
}
case TypedConstantKind.Type:
{
parts.AddKeyword("typeof");
parts.AddPunctuation("(");
AddDisplayParts(parts, (ISymbol)typedConstant.Value, format, additionalOptions);
parts.AddPunctuation(")");
break;
}
case TypedConstantKind.Array:
{
var arrayType = (IArrayTypeSymbol)typedConstant.Type;
parts.AddKeyword("new");
parts.AddSpace();
AddDisplayParts(parts, arrayType.ElementType, format, additionalOptions);
parts.AddPunctuation("[");
parts.AddPunctuation("]");
parts.AddSpace();
parts.AddPunctuation("{");
parts.AddSpace();
ImmutableArray <TypedConstant> .Enumerator en = typedConstant.Values.GetEnumerator();
if (en.MoveNext())
{
while (true)
{
AddConstantValue(en.Current);
if (en.MoveNext())
{
parts.AddPunctuation(",");
parts.AddSpace();
}
else
{
break;
}
}
}
parts.AddSpace();
parts.AddPunctuation("}");
break;
}
default:
{
throw new InvalidOperationException();
}
}
SymbolDisplayPartKind GetSymbolDisplayPart(SpecialType specialType)
{
switch (specialType)
{
case SpecialType.System_Boolean:
return(SymbolDisplayPartKind.Keyword);
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_Single:
case SpecialType.System_Double:
return(SymbolDisplayPartKind.NumericLiteral);
case SpecialType.System_Char:
case SpecialType.System_String:
return(SymbolDisplayPartKind.StringLiteral);
default:
throw new InvalidOperationException();
}
}
}
}
public static ImmutableArray <SymbolDisplayPart> GetDisplayParts(
ISymbol symbol,
SymbolDisplayFormat format,
SymbolDisplayTypeDeclarationOptions typeDeclarationOptions = SymbolDisplayTypeDeclarationOptions.None,
SymbolDisplayAdditionalOptions additionalOptions = SymbolDisplayAdditionalOptions.None,
Func <ISymbol, AttributeData, bool> shouldDisplayAttribute = null)
{
ImmutableArray <SymbolDisplayPart> parts;
if (symbol is INamedTypeSymbol typeSymbol)
{
parts = typeSymbol.ToDisplayParts(format, typeDeclarationOptions);
}
else
{
parts = symbol.ToDisplayParts(format);
typeSymbol = null;
}
IEnumerable <AttributeData> attributes = (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.IncludeAttributes))
? GetAttributes(symbol, shouldDisplayAttribute)
: ImmutableArray <AttributeData> .Empty;
ImmutableArray <SymbolDisplayPart> .Builder builder = default;
INamedTypeSymbol baseType = null;
ImmutableArray <INamedTypeSymbol> interfaces = ImmutableArray <INamedTypeSymbol> .Empty;
if (typeSymbol != null &&
(typeDeclarationOptions & SymbolDisplayTypeDeclarationOptions.BaseList) != 0)
{
if ((typeDeclarationOptions & SymbolDisplayTypeDeclarationOptions.BaseType) != 0 &&
typeSymbol.TypeKind.Is(TypeKind.Class, TypeKind.Interface))
{
baseType = typeSymbol.BaseType;
if (baseType?.SpecialType == SpecialType.System_Object)
{
baseType = null;
}
}
if ((typeDeclarationOptions & SymbolDisplayTypeDeclarationOptions.Interfaces) != 0)
{
interfaces = typeSymbol.Interfaces;
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.OmitIEnumerable) &&
interfaces.Any(f => f.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T))
{
interfaces = interfaces.RemoveAll(f => f.SpecialType == SpecialType.System_Collections_IEnumerable);
}
}
}
int baseListCount = interfaces.Length;
if (baseType != null)
{
baseListCount++;
}
int constraintCount = 0;
int whereIndex = -1;
for (int i = 0; i < parts.Length; i++)
{
if (parts[i].IsKeyword("where"))
{
if (whereIndex == -1)
{
whereIndex = i;
}
constraintCount++;
}
}
if (baseListCount > 0)
{
InitializeBuilder();
if (whereIndex != -1)
{
builder.AddRange(parts, whereIndex);
}
else
{
builder.AddRange(parts);
builder.AddSpace();
}
builder.AddPunctuation(":");
builder.AddSpace();
if (baseType != null)
{
builder.AddDisplayParts(baseType, format, additionalOptions);
if (interfaces.Any())
{
builder.AddPunctuation(",");
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.FormatBaseList))
{
builder.AddLineBreak();
builder.AddIndentation();
}
else
{
builder.AddSpace();
}
}
}
IComparer <INamedTypeSymbol> comparer = (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.OmitContainingNamespace))
? SymbolDefinitionComparer.SystemFirstOmitContainingNamespace.TypeComparer
: SymbolDefinitionComparer.SystemFirst.TypeComparer;
interfaces = interfaces.Sort(comparer);
ImmutableArray <INamedTypeSymbol> .Enumerator en = interfaces.GetEnumerator();
if (en.MoveNext())
{
while (true)
{
builder.AddDisplayParts(en.Current, format, additionalOptions);
if (en.MoveNext())
{
builder.AddPunctuation(",");
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.FormatBaseList))
{
builder.AddLineBreak();
builder.AddIndentation();
}
else
{
builder.AddSpace();
}
}
else
{
break;
}
}
}
if (whereIndex != -1)
{
if (!additionalOptions.HasOption(SymbolDisplayAdditionalOptions.FormatConstraints) ||
(baseListCount == 1 && constraintCount == 1))
{
builder.AddSpace();
}
}
}
if (whereIndex != -1)
{
InitializeBuilder();
if (baseListCount == 0)
{
builder.AddRange(parts, whereIndex);
}
for (int i = whereIndex; i < parts.Length; i++)
{
if (parts[i].IsKeyword("where") &&
additionalOptions.HasOption(SymbolDisplayAdditionalOptions.FormatConstraints) &&
(baseListCount > 1 || constraintCount > 1))
{
builder.AddLineBreak();
builder.AddIndentation();
}
builder.Add(parts[i]);
}
}
if (builder == null &&
attributes.Any())
{
builder = ImmutableArray.CreateBuilder <SymbolDisplayPart>(parts.Length);
AddAttributes(builder, attributes, format, additionalOptions, includeTrailingNewLine: true);
builder.AddRange(parts);
}
bool hasEventAccessorList = false;
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.IncludeAccessorAttributes))
{
if (symbol.Kind == SymbolKind.Property)
{
var propertySymbol = (IPropertySymbol)symbol;
IMethodSymbol getMethod = propertySymbol.GetMethod;
if (getMethod != null)
{
builder = builder ?? parts.ToBuilder();
AddAccessorAttributes(builder, getMethod, format, additionalOptions, shouldDisplayAttribute: shouldDisplayAttribute);
}
IMethodSymbol setMethod = propertySymbol.SetMethod;
if (setMethod != null)
{
builder = builder ?? parts.ToBuilder();
AddAccessorAttributes(builder, setMethod, format, additionalOptions, shouldDisplayAttribute: shouldDisplayAttribute);
}
}
else if (symbol.Kind == SymbolKind.Event)
{
var eventSymbol = (IEventSymbol)symbol;
IEnumerable <AttributeData> addAttributes = GetAttributes(eventSymbol.AddMethod, shouldDisplayAttribute);
IEnumerable <AttributeData> removeAttributes = GetAttributes(eventSymbol.RemoveMethod, shouldDisplayAttribute);
if (addAttributes.Any() ||
removeAttributes.Any())
{
hasEventAccessorList = true;
builder = builder ?? parts.ToBuilder();
AddEventAccessorAttributes(builder, addAttributes, removeAttributes, format, additionalOptions);
}
}
}
ImmutableArray <IParameterSymbol> parameters = symbol.GetParameters();
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.IncludeParameterAttributes) &&
parameters.Any(f => GetAttributes(f, shouldDisplayAttribute).Any()))
{
builder = builder ?? parts.ToBuilder();
AddParameterAttributes(builder, symbol, parameters, format, additionalOptions, shouldDisplayAttribute);
}
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.FormatParameters) &&
parameters.Length > 1)
{
builder = builder ?? parts.ToBuilder();
FormatParameters(symbol, builder, DefinitionListFormat.Default.IndentChars);
}
if (ShouldAddTrailingSemicolon())
{
if (builder == null)
{
parts = parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, ";"));
}
else
{
builder.AddPunctuation(";");
}
}
return(builder?.ToImmutableArray() ?? parts);
void InitializeBuilder()
{
if (builder == null)
{
builder = ImmutableArray.CreateBuilder <SymbolDisplayPart>(parts.Length);
if (attributes.Any())
{
AddAttributes(builder, attributes, format, additionalOptions, includeTrailingNewLine: true);
}
}
}
bool ShouldAddTrailingSemicolon()
{
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.IncludeTrailingSemicolon))
{
if (typeSymbol?.TypeKind == TypeKind.Delegate)
{
return(true);
}
switch (symbol.Kind)
{
case SymbolKind.Event:
return(!hasEventAccessorList);
case SymbolKind.Field:
return(symbol.ContainingType?.TypeKind != TypeKind.Enum);
case SymbolKind.Method:
return(true);
}
}
return(false);
}
}
private static void AddDisplayParts(
this ImmutableArray <SymbolDisplayPart> .Builder parts,
ISymbol symbol,
SymbolDisplayFormat format,
SymbolDisplayAdditionalOptions additionalOptions,
bool removeAttributeSuffix = false)
{
SymbolDisplayFormat format2;
if (additionalOptions.HasOption(SymbolDisplayAdditionalOptions.OmitContainingNamespace))
{
format2 = TypeSymbolDisplayFormats.Name_ContainingTypes_SpecialTypes;
}
else if (format.GlobalNamespaceStyle == SymbolDisplayGlobalNamespaceStyle.Included)
{
format2 = TypeSymbolDisplayFormats.Name_ContainingTypes_Namespaces_GlobalNamespace_SpecialTypes;
}
else
{
format2 = TypeSymbolDisplayFormats.Name_ContainingTypes_Namespaces_SpecialTypes;
}
parts.AddRange(symbol.ToDisplayParts(format2));
if (!(symbol is INamedTypeSymbol typeSymbol))
{
return;
}
if (removeAttributeSuffix)
{
SymbolDisplayPart last = parts.Last();
if (last.Kind == SymbolDisplayPartKind.ClassName)
{
const string attributeSuffix = "Attribute";
string text = last.ToString();
if (text.EndsWith(attributeSuffix, StringComparison.Ordinal))
{
parts[parts.Count - 1] = last.WithText(text.Remove(text.Length - attributeSuffix.Length));
}
}
}
ImmutableArray <ITypeSymbol> typeArguments = typeSymbol.TypeArguments;
ImmutableArray <ITypeSymbol> .Enumerator en = typeArguments.GetEnumerator();
if (en.MoveNext())
{
parts.AddPunctuation("<");
while (true)
{
if (en.Current.Kind == SymbolKind.NamedType)
{
parts.AddDisplayParts((INamedTypeSymbol)en.Current, format, additionalOptions);
}
else
{
Debug.Assert(en.Current.Kind == SymbolKind.TypeParameter, en.Current.Kind.ToString());
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.TypeParameterName, en.Current, en.Current.Name));
}
if (en.MoveNext())
{
parts.AddPunctuation(",");
parts.AddSpace();
}
else
{
break;
}
}
parts.AddPunctuation(">");
}
}
private static void AddAttributes(
ImmutableArray <SymbolDisplayPart> .Builder builder,
ImmutableArray <AttributeData> attributes,
Func <INamedTypeSymbol, bool> predicate = null,
INamespaceSymbol containingNamespace = null,
bool splitAttributes = true,
bool includeAttributeArguments = false,
bool isAssemblyAttribute = false,
bool addNewLine = true)
{
using (IEnumerator <AttributeData> en = attributes
.Where(f => predicate(f.AttributeClass))
.OrderBy(f => ToDisplayString(f.AttributeClass, containingNamespace)).GetEnumerator())
{
if (en.MoveNext())
{
builder.AddPunctuation("[");
if (isAssemblyAttribute)
{
builder.AddKeyword("assembly");
builder.AddPunctuation(":");
builder.AddSpace();
}
while (true)
{
builder.AddDisplayParts(en.Current.AttributeClass, containingNamespace);
if (includeAttributeArguments)
{
AddAttributeArguments(en.Current);
}
if (en.MoveNext())
{
if (splitAttributes)
{
builder.AddPunctuation("]");
if (addNewLine)
{
builder.AddLineBreak();
}
else
{
builder.AddSpace();
}
builder.AddPunctuation("[");
if (isAssemblyAttribute)
{
builder.AddKeyword("assembly");
builder.AddPunctuation(":");
builder.AddSpace();
}
}
else
{
builder.AddPunctuation(",");
builder.AddSpace();
}
}
else
{
break;
}
}
builder.AddPunctuation("]");
if (addNewLine)
{
builder.AddLineBreak();
}
}
}
void AddAttributeArguments(AttributeData attributeData)
{
bool hasConstructorArgument = false;
bool hasNamedArgument = false;
AppendConstructorArguments();
AppendNamedArguments();
if (hasConstructorArgument || hasNamedArgument)
{
builder.AddPunctuation(")");
}
void AppendConstructorArguments()
{
ImmutableArray <TypedConstant> .Enumerator en = attributeData.ConstructorArguments.GetEnumerator();
if (en.MoveNext())
{
hasConstructorArgument = true;
builder.AddPunctuation("(");
while (true)
{
AddConstantValue(en.Current);
if (en.MoveNext())
{
builder.AddPunctuation(",");
builder.AddSpace();
}
else
{
break;
}
}
}
}
void AppendNamedArguments()
{
ImmutableArray <KeyValuePair <string, TypedConstant> > .Enumerator en = attributeData.NamedArguments.GetEnumerator();
if (en.MoveNext())
{
hasNamedArgument = true;
if (hasConstructorArgument)
{
builder.AddPunctuation(",");
builder.AddSpace();
}
else
{
builder.AddPunctuation("(");
}
while (true)
{
builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.PropertyName, null, en.Current.Key));
builder.AddSpace();
builder.AddPunctuation("=");
builder.AddSpace();
AddConstantValue(en.Current.Value);
if (en.MoveNext())
{
builder.AddPunctuation(",");
builder.AddSpace();
}
else
{
break;
}
}
}
}
}
void AddConstantValue(TypedConstant typedConstant)
{
switch (typedConstant.Kind)
{
case TypedConstantKind.Primitive:
{
builder.Add(new SymbolDisplayPart(
GetSymbolDisplayPart(typedConstant.Type.SpecialType),
null,
SymbolDisplay.FormatPrimitive(typedConstant.Value, quoteStrings: true, useHexadecimalNumbers: false)));
break;
}
case TypedConstantKind.Enum:
{
OneOrMany <EnumFieldInfo> oneOrMany = EnumUtility.GetConstituentFields(typedConstant.Value, (INamedTypeSymbol)typedConstant.Type);
OneOrMany <EnumFieldInfo> .Enumerator en = oneOrMany.GetEnumerator();
if (en.MoveNext())
{
while (true)
{
AddDisplayParts(builder, en.Current.Symbol, containingNamespace);
if (en.MoveNext())
{
builder.AddSpace();
builder.AddPunctuation("|");
builder.AddSpace();
}
else
{
break;
}
}
}
else
{
builder.AddPunctuation("(");
AddDisplayParts(builder, (INamedTypeSymbol)typedConstant.Type, containingNamespace);
builder.AddPunctuation(")");
builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.NumericLiteral, null, typedConstant.Value.ToString()));
}
break;
}
case TypedConstantKind.Type:
{
builder.AddKeyword("typeof");
builder.AddPunctuation("(");
AddDisplayParts(builder, (ISymbol)typedConstant.Value, containingNamespace);
builder.AddPunctuation(")");
break;
}
case TypedConstantKind.Array:
{
var arrayType = (IArrayTypeSymbol)typedConstant.Type;
builder.AddKeyword("new");
builder.AddSpace();
AddDisplayParts(builder, arrayType.ElementType, containingNamespace);
builder.AddPunctuation("[");
builder.AddPunctuation("]");
builder.AddSpace();
builder.AddPunctuation("{");
builder.AddSpace();
ImmutableArray <TypedConstant> .Enumerator en = typedConstant.Values.GetEnumerator();
if (en.MoveNext())
{
while (true)
{
AddConstantValue(en.Current);
if (en.MoveNext())
{
builder.AddPunctuation(",");
builder.AddSpace();
}
else
{
break;
}
}
}
builder.AddSpace();
builder.AddPunctuation("}");
break;
}
default:
{
throw new InvalidOperationException();
}
}
SymbolDisplayPartKind GetSymbolDisplayPart(SpecialType specialType)
{
switch (specialType)
{
case SpecialType.System_Boolean:
return(SymbolDisplayPartKind.Keyword);
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_Single:
case SpecialType.System_Double:
return(SymbolDisplayPartKind.NumericLiteral);
case SpecialType.System_Char:
case SpecialType.System_String:
return(SymbolDisplayPartKind.StringLiteral);
default:
throw new InvalidOperationException();
}
}
}
}
public static ImmutableArray <SymbolDisplayPart> GetDisplayParts(
ISymbol symbol,
SymbolDisplayFormat format,
SymbolDisplayTypeDeclarationOptions typeDeclarationOptions = SymbolDisplayTypeDeclarationOptions.None,
Func <INamedTypeSymbol, bool> isVisibleAttribute = null,
bool formatBaseList = false,
bool formatConstraints = false,
bool formatParameters = false,
bool splitAttributes = true,
bool includeAttributeArguments = false,
bool omitIEnumerable = false,
bool useNameOnlyIfPossible = false)
{
ImmutableArray <SymbolDisplayPart> parts;
if (symbol is INamedTypeSymbol typeSymbol)
{
parts = typeSymbol.ToDisplayParts(format, typeDeclarationOptions);
}
else
{
parts = symbol.ToDisplayParts(format);
typeSymbol = null;
}
ImmutableArray <AttributeData> attributes = ImmutableArray <AttributeData> .Empty;
bool hasAttributes = false;
if (isVisibleAttribute != null)
{
attributes = symbol.GetAttributes();
hasAttributes = attributes.Any(f => isVisibleAttribute(f.AttributeClass));
}
int baseListCount = 0;
INamedTypeSymbol baseType = null;
ImmutableArray <INamedTypeSymbol> interfaces = default;
if (typeSymbol != null)
{
if (typeSymbol.TypeKind.Is(TypeKind.Class, TypeKind.Interface))
{
baseType = typeSymbol.BaseType;
if (baseType?.SpecialType == SpecialType.System_Object)
{
baseType = null;
}
}
interfaces = typeSymbol.Interfaces;
if (omitIEnumerable &&
interfaces.Any(f => f.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T))
{
interfaces = interfaces.RemoveAll(f => f.SpecialType == SpecialType.System_Collections_IEnumerable);
}
baseListCount = interfaces.Length;
if (baseType != null)
{
baseListCount++;
}
}
int constraintCount = 0;
int whereIndex = -1;
for (int i = 0; i < parts.Length; i++)
{
if (parts[i].IsKeyword("where"))
{
if (whereIndex == -1)
{
whereIndex = i;
}
constraintCount++;
}
}
if (!hasAttributes &&
baseListCount == 0 &&
constraintCount == 0 &&
(!formatParameters || symbol.GetParameters().Length <= 1))
{
return(parts);
}
INamespaceSymbol containingNamespace = (useNameOnlyIfPossible) ? symbol.ContainingNamespace : null;
ImmutableArray <SymbolDisplayPart> .Builder builder = ImmutableArray.CreateBuilder <SymbolDisplayPart>(parts.Length);
AddAttributes(builder, attributes, isVisibleAttribute, containingNamespace, splitAttributes: splitAttributes, includeAttributeArguments: includeAttributeArguments);
if (baseListCount > 0)
{
if (whereIndex != -1)
{
builder.AddRange(parts, whereIndex);
}
else
{
builder.AddRange(parts);
builder.AddSpace();
}
builder.AddPunctuation(":");
builder.AddSpace();
if (baseType != null)
{
builder.AddDisplayParts(baseType, containingNamespace);
if (interfaces.Any())
{
builder.AddPunctuation(",");
if (formatBaseList)
{
builder.AddLineBreak();
builder.AddIndentation();
}
else
{
builder.AddSpace();
}
}
}
interfaces = interfaces.Sort((x, y) =>
{
INamespaceSymbol n1 = x.ContainingNamespace;
INamespaceSymbol n2 = y.ContainingNamespace;
if (!MetadataNameEqualityComparer <INamespaceSymbol> .Instance.Equals(n1, n2))
{
return(string.CompareOrdinal(
n1.ToDisplayString(SymbolDisplayFormats.TypeNameAndContainingTypesAndNamespaces),
n2.ToDisplayString(SymbolDisplayFormats.TypeNameAndContainingTypesAndNamespaces)));
}
return(string.CompareOrdinal(
ToDisplayString(x, containingNamespace),
ToDisplayString(y, containingNamespace)));
});
ImmutableArray <INamedTypeSymbol> .Enumerator en = interfaces.GetEnumerator();
if (en.MoveNext())
{
while (true)
{
builder.AddDisplayParts(en.Current, containingNamespace);
if (en.MoveNext())
{
builder.AddPunctuation(",");
if (formatBaseList)
{
builder.AddLineBreak();
builder.AddIndentation();
}
else
{
builder.AddSpace();
}
}
else
{
break;
}
}
}
if (whereIndex != -1)
{
if (!formatConstraints ||
(baseListCount == 1 && constraintCount == 1))
{
builder.AddSpace();
}
}
}
else if (whereIndex != -1)
{
builder.AddRange(parts, whereIndex);
}
else
{
builder.AddRange(parts);
}
if (whereIndex != -1)
{
for (int i = whereIndex; i < parts.Length; i++)
{
if (parts[i].IsKeyword("where"))
{
if (formatConstraints &&
(baseListCount > 1 || constraintCount > 1))
{
builder.AddLineBreak();
builder.AddIndentation();
}
builder.Add(parts[i]);
}
else if (parts[i].IsTypeName() &&
parts[i].Symbol is INamedTypeSymbol namedTypeSymbol)
{
builder.AddDisplayParts(namedTypeSymbol, containingNamespace);
}
else
{
builder.Add(parts[i]);
}
}
}
if (formatParameters)
{
ImmutableArray <IParameterSymbol> parameters = symbol.GetParameters();
if (parameters.Length > 1)
{
FormatParameters(symbol, builder, DeclarationListOptions.DefaultValues.IndentChars);
}
}
return(builder.ToImmutableArray());
}