private static async Task <ElementOrderingChecks> GetEnabledRulesForDocumentAsync(Document document, CancellationToken cancellationToken)
{
SemanticModel semanticModel;
if (!document.TryGetSemanticModel(out semanticModel))
{
semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
}
return(ElementOrderingChecks.GetElementOrderingChecksForSemanticModel(semanticModel));
}
/// <summary>
/// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct.
/// </summary>
/// <param name="member">The member to wrap.</param>
/// <param name="checks">The element ordering checks.</param>
internal MemberOrderHelper(MemberDeclarationSyntax member, ElementOrderingChecks checks)
{
this.Member = member;
var modifiers = member.GetModifiers();
var type = member.Kind();
type = type == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : type;
this.elementPriority = checks.ElementType ? TypeMemberOrder.IndexOf(type) : 0;
this.modifierFlags = GetModifierFlags(modifiers, checks);
if (checks.AccessLevel)
{
if ((type == SyntaxKind.ConstructorDeclaration && this.modifierFlags.HasFlag(ModifierFlags.Static)) ||
(type == SyntaxKind.MethodDeclaration && ((MethodDeclarationSyntax)member).ExplicitInterfaceSpecifier != null) ||
(type == SyntaxKind.PropertyDeclaration && ((PropertyDeclarationSyntax)member).ExplicitInterfaceSpecifier != null) ||
(type == SyntaxKind.IndexerDeclaration && ((IndexerDeclarationSyntax)member).ExplicitInterfaceSpecifier != null))
{
this.accessibilty = AccessLevel.Public;
}
else
{
this.accessibilty = AccessLevelHelper.GetAccessLevel(modifiers);
if (this.accessibilty == AccessLevel.NotSpecified)
{
if (member.Parent.IsKind(SyntaxKind.CompilationUnit) || member.Parent.IsKind(SyntaxKind.NamespaceDeclaration))
{
this.accessibilty = AccessLevel.Internal;
}
else
{
this.accessibilty = AccessLevel.Private;
}
}
}
}
else
{
this.accessibilty = AccessLevel.Public;
}
}
private static ModifierFlags GetModifierFlags(SyntaxTokenList syntax, ElementOrderingChecks checks)
{
var flags = ModifierFlags.None;
if (checks.Const && syntax.Any(SyntaxKind.ConstKeyword))
{
flags |= ModifierFlags.Const;
}
else
{
if (checks.Static && syntax.Any(SyntaxKind.StaticKeyword))
{
flags |= ModifierFlags.Static;
}
if (checks.Readonly && syntax.Any(SyntaxKind.ReadOnlyKeyword))
{
flags |= ModifierFlags.Readonly;
}
}
return(flags);
}
private static SyntaxNode UpdateSyntaxRoot(MemberDeclarationSyntax memberDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
var parentDeclaration = memberDeclaration.Parent;
var memberToMove = new MemberOrderHelper(memberDeclaration, checks);
if (parentDeclaration is TypeDeclarationSyntax)
{
return(HandleTypeDeclaration(memberToMove, (TypeDeclarationSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions));
}
if (parentDeclaration is NamespaceDeclarationSyntax)
{
return(HandleNamespaceDeclaration(memberToMove, (NamespaceDeclarationSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions));
}
if (parentDeclaration is CompilationUnitSyntax)
{
return(HandleCompilationUnitDeclaration(memberToMove, (CompilationUnitSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions));
}
return(syntaxRoot);
}
private static SyntaxNode OrderMember(MemberOrderHelper memberOrder, SyntaxList <MemberDeclarationSyntax> members, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
var memberIndex = members.IndexOf(memberOrder.Member);
MemberOrderHelper target = default(MemberOrderHelper);
for (var i = memberIndex - 1; i >= 0; --i)
{
var orderHelper = new MemberOrderHelper(members[i], checks);
if (orderHelper.Priority < memberOrder.Priority)
{
target = orderHelper;
}
else
{
break;
}
}
return(target.Member != null?MoveMember(syntaxRoot, memberOrder.Member, target.Member, indentationOptions) : syntaxRoot);
}
private static SyntaxNode HandleNamespaceDeclaration(MemberOrderHelper memberOrder, NamespaceDeclarationSyntax namespaceDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
return(OrderMember(memberOrder, namespaceDeclaration.Members, checks, syntaxRoot, indentationOptions));
}
private static SyntaxNode HandleCompilationUnitDeclaration(MemberOrderHelper memberOrder, CompilationUnitSyntax compilationUnitDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
return(OrderMember(memberOrder, compilationUnitDeclaration.Members, checks, syntaxRoot, indentationOptions));
}
private static SyntaxNode HandleTypeDeclaration(MemberOrderHelper memberOrder, TypeDeclarationSyntax typeDeclarationNode, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
return(OrderMember(memberOrder, typeDeclarationNode.Members, checks, syntaxRoot, indentationOptions));
}
