private void AppendMembers(INamedTypeSymbol typeModel)
{
bool isAny = false;
using (IEnumerator <ISymbol> en = typeModel.GetMembers().Where(f => IsVisibleMember(f))
.OrderBy(f => f, MemberComparer)
.GetEnumerator())
{
if (en.MoveNext())
{
MemberDeclarationKind kind = MemberDeclarationComparer.GetKind(en.Current);
while (true)
{
ImmutableArray <SymbolDisplayPart> attributeParts = SymbolDeclarationBuilder.GetAttributesParts(
en.Current.GetAttributes(),
predicate: IsVisibleAttribute,
splitAttributes: Options.SplitAttributes,
includeAttributeArguments: Options.IncludeAttributeArguments);
Append(attributeParts);
ImmutableArray <SymbolDisplayPart> parts = en.Current.ToDisplayParts(_memberFormat);
//XTODO: attribute on event accessor
if (en.Current.Kind == SymbolKind.Property)
{
var propertySymbol = (IPropertySymbol)en.Current;
IMethodSymbol getMethod = propertySymbol.GetMethod;
if (getMethod != null)
{
parts = AppendAccessorAttributes(parts, getMethod, "get");
}
IMethodSymbol setMethod = propertySymbol.SetMethod;
if (setMethod != null)
{
parts = AppendAccessorAttributes(parts, setMethod, "set");
}
}
ImmutableArray <IParameterSymbol> parameters = en.Current.GetParameters();
if (parameters.Any())
{
parts = AppendParameterAttributes(parts, en.Current, parameters);
if (Options.FormatParameters &&
parameters.Length > 1)
{
ImmutableArray <SymbolDisplayPart> .Builder builder = parts.ToBuilder();
SymbolDeclarationBuilder.FormatParameters(en.Current, builder, Options.IndentChars);
parts = builder.ToImmutableArray();
}
}
Append(parts);
if (en.Current.Kind != SymbolKind.Property)
{
Append(";");
}
AppendLine();
isAny = true;
if (en.MoveNext())
{
MemberDeclarationKind kind2 = MemberDeclarationComparer.GetKind(en.Current);
if (kind != kind2 ||
Options.EmptyLineBetweenMembers)
{
AppendLine();
}
kind = kind2;
}
else
{
break;
}
}
}
}
AppendTypes(typeModel.GetTypeMembers().Where(f => IsVisibleType(f)), insertNewLineBeforeFirstType: isAny);
}
public int Compare(ISymbol x, ISymbol y)
{
Debug.Assert(x.IsKind(SymbolKind.Event, SymbolKind.Field, SymbolKind.Method, SymbolKind.Property), x.Kind.ToString());
Debug.Assert(y.IsKind(SymbolKind.Event, SymbolKind.Field, SymbolKind.Method, SymbolKind.Property), y.Kind.ToString());
if (object.ReferenceEquals(x, y))
{
return(0);
}
if (x == null)
{
return(-1);
}
if (y == null)
{
return(1);
}
int diff = 0;
if ((SymbolComparer.Options & SymbolDefinitionSortOptions.OmitContainingNamespace) == 0)
{
diff = SymbolComparer.NamespaceComparer.Compare(x.ContainingNamespace, y.ContainingNamespace);
if (diff != 0)
{
return(diff);
}
}
if ((SymbolComparer.Options & SymbolDefinitionSortOptions.OmitContainingType) == 0)
{
diff = SymbolComparer.TypeComparer.Compare(x.ContainingType, y.ContainingType);
if (diff != 0)
{
return(diff);
}
}
MemberDeclarationKind kind1 = x.GetMemberDeclarationKind();
MemberDeclarationKind kind2 = y.GetMemberDeclarationKind();
diff = ((int)kind1).CompareTo((int)kind2);
if (diff != 0)
{
return(diff);
}
switch (kind1)
{
case MemberDeclarationKind.Constructor:
case MemberDeclarationKind.Method:
{
return(CompareMethods((IMethodSymbol)x, (IMethodSymbol)y));
}
case MemberDeclarationKind.Indexer:
case MemberDeclarationKind.Property:
{
return(CompareProperties((IPropertySymbol)x, (IPropertySymbol)y));
}
case MemberDeclarationKind.ExplicitlyImplementedEvent:
{
var e1 = (IEventSymbol)x;
var e2 = (IEventSymbol)y;
diff = CompareExplicitImplementations(e1.ExplicitInterfaceImplementations, e2.ExplicitInterfaceImplementations);
if (diff != 0)
{
return(diff);
}
break;
}
case MemberDeclarationKind.ExplicitlyImplementedMethod:
{
var m1 = (IMethodSymbol)x;
var m2 = (IMethodSymbol)y;
diff = CompareExplicitImplementations(m1.ExplicitInterfaceImplementations, m2.ExplicitInterfaceImplementations);
if (diff != 0)
{
return(diff);
}
return(CompareMethods(m1, m2));
}
case MemberDeclarationKind.ExplicitlyImplementedProperty:
{
var p1 = (IPropertySymbol)x;
var p2 = (IPropertySymbol)y;
diff = CompareExplicitImplementations(p1.ExplicitInterfaceImplementations, p2.ExplicitInterfaceImplementations);
if (diff != 0)
{
return(diff);
}
return(CompareProperties(p1, p2));
}
}
return(SymbolDefinitionComparer.CompareName(x, y));
}