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 OrderMember(MemberOrderHelper memberOrder, SyntaxList <MemberDeclarationSyntax> members, ImmutableArray <OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationSettings indentationSettings) { var memberIndex = members.IndexOf(memberOrder.Member); MemberOrderHelper target = default; for (var i = memberIndex - 1; i >= 0; --i) { var orderHelper = new MemberOrderHelper(members[i], elementOrder); if (orderHelper.Priority < memberOrder.Priority) { target = orderHelper; } else { break; } } return(target.Member != null?MoveMember(syntaxRoot, memberOrder.Member, target.Member, indentationSettings) : syntaxRoot); }
private static SyntaxNode MoveField(FieldDeclarationSyntax fieldDeclaration, TypeDeclarationSyntax typeDeclarationNode, SyntaxNode syntaxRoot) { var fieldToMove = new MemberOrderHelper(fieldDeclaration); foreach (var member in typeDeclarationNode.Members) { if (!member.IsKind(SyntaxKind.FieldDeclaration)) { continue; } var orderHelper = new MemberOrderHelper(member); if (orderHelper.ModifierPriority < fieldToMove.ModifierPriority) { syntaxRoot = MoveField(syntaxRoot, fieldToMove.Member, member); break; } } return(syntaxRoot); }
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 UpdateSyntaxRoot(MemberDeclarationSyntax memberDeclaration, ImmutableArray<OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationOptions indentationOptions) { var parentDeclaration = memberDeclaration.Parent; var memberToMove = new MemberOrderHelper(memberDeclaration, elementOrder); if (parentDeclaration is TypeDeclarationSyntax) { return HandleTypeDeclaration(memberToMove, (TypeDeclarationSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationOptions); } if (parentDeclaration is NamespaceDeclarationSyntax) { return HandleNamespaceDeclaration(memberToMove, (NamespaceDeclarationSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationOptions); } if (parentDeclaration is CompilationUnitSyntax) { return HandleCompilationUnitDeclaration(memberToMove, (CompilationUnitSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationOptions); } return syntaxRoot; }
private static SyntaxNode UpdateSyntaxRoot(MemberDeclarationSyntax memberDeclaration, ImmutableArray <OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationSettings indentationSettings) { var parentDeclaration = memberDeclaration.Parent; var memberToMove = new MemberOrderHelper(memberDeclaration, elementOrder); if (parentDeclaration is TypeDeclarationSyntax) { return(HandleTypeDeclaration(memberToMove, (TypeDeclarationSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings)); } if (parentDeclaration is NamespaceDeclarationSyntax) { return(HandleNamespaceDeclaration(memberToMove, (NamespaceDeclarationSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings)); } if (parentDeclaration is CompilationUnitSyntax) { return(HandleCompilationUnitDeclaration(memberToMove, (CompilationUnitSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings)); } return(syntaxRoot); }
private static SyntaxNode HandleCompilationUnitDeclaration(MemberOrderHelper memberOrder, CompilationUnitSyntax compilationUnitDeclaration, ImmutableArray <OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationSettings indentationSettings) { return(OrderMember(memberOrder, compilationUnitDeclaration.Members, elementOrder, syntaxRoot, indentationSettings)); }
private static SyntaxNode HandleTypeDeclaration(MemberOrderHelper memberOrder, TypeDeclarationSyntax typeDeclarationNode, ImmutableArray <OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationSettings indentationSettings) { return(OrderMember(memberOrder, typeDeclarationNode.Members, elementOrder, syntaxRoot, indentationSettings)); }
private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings) { var elementOrder = settings.OrderingRules.ElementOrder; int constantIndex = elementOrder.IndexOf(OrderingTrait.Constant); if (constantIndex < 0) { return; } var typeDeclaration = (TypeDeclarationSyntax)context.Node; var members = typeDeclaration.Members; var previousFieldConstant = true; var previousFieldStatic = false; var previousFieldReadonly = false; var previousAccessLevel = AccessLevel.NotSpecified; foreach (var member in members) { var field = member as FieldDeclarationSyntax; if (field == null) { continue; } AccessLevel currentAccessLevel = MemberOrderHelper.GetAccessLevelForOrdering(field, field.Modifiers); bool currentFieldConstant = field.Modifiers.Any(SyntaxKind.ConstKeyword); bool currentFieldReadonly = currentFieldConstant || field.Modifiers.Any(SyntaxKind.ReadOnlyKeyword); bool currentFieldStatic = currentFieldConstant || field.Modifiers.Any(SyntaxKind.StaticKeyword); bool compareConst = true; for (int j = 0; compareConst && j < constantIndex; j++) { switch (elementOrder[j]) { case OrderingTrait.Accessibility: if (currentAccessLevel != previousAccessLevel) { compareConst = false; } continue; case OrderingTrait.Readonly: if (currentFieldReadonly != previousFieldReadonly) { compareConst = false; } continue; case OrderingTrait.Static: if (currentFieldStatic != previousFieldStatic) { compareConst = false; } continue; case OrderingTrait.Kind: // Only fields may be marked const, and all fields have the same kind. continue; case OrderingTrait.Constant: default: continue; } } if (compareConst) { if (!previousFieldConstant && currentFieldConstant) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, NamedTypeHelpers.GetNameOrIdentifierLocation(member))); } } previousFieldConstant = currentFieldConstant; previousFieldReadonly = currentFieldReadonly; previousFieldStatic = currentFieldStatic; previousAccessLevel = currentAccessLevel; } }
private static void HandleMemberList(SyntaxNodeAnalysisContext context, ImmutableArray <OrderingTrait> elementOrder, int staticIndex, SyntaxList <MemberDeclarationSyntax> members) { var previousSyntaxKind = SyntaxKind.None; var previousAccessLevel = AccessLevel.NotSpecified; var previousMemberStatic = true; var previousMemberConstant = false; var previousMemberReadonly = false; foreach (var member in members) { var modifiers = member.GetModifiers(); var currentSyntaxKind = member.Kind(); currentSyntaxKind = currentSyntaxKind == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : currentSyntaxKind; var currentAccessLevel = MemberOrderHelper.GetAccessLevelForOrdering(member, modifiers); bool currentMemberConstant = modifiers.Any(SyntaxKind.ConstKeyword); bool currentMemberReadonly = currentMemberConstant || modifiers.Any(SyntaxKind.ReadOnlyKeyword); bool currentMemberStatic = currentMemberConstant || modifiers.Any(SyntaxKind.StaticKeyword); bool compareStatic = true; for (int j = 0; compareStatic && j < staticIndex; j++) { switch (elementOrder[j]) { case OrderingTrait.Accessibility: if (currentAccessLevel != previousAccessLevel) { compareStatic = false; } continue; case OrderingTrait.Readonly: if (currentMemberReadonly != previousMemberReadonly) { compareStatic = false; } continue; case OrderingTrait.Constant: if (currentMemberConstant != previousMemberConstant) { compareStatic = false; } continue; case OrderingTrait.Kind: if (previousSyntaxKind != currentSyntaxKind) { compareStatic = false; } continue; case OrderingTrait.Static: default: continue; } } if (compareStatic) { if (currentMemberStatic && !previousMemberStatic) { context.ReportDiagnostic( Diagnostic.Create( Descriptor, NamedTypeHelpers.GetNameOrIdentifierLocation(member), AccessLevelHelper.GetName(currentAccessLevel))); } } previousSyntaxKind = currentSyntaxKind; previousAccessLevel = currentAccessLevel; previousMemberStatic = currentMemberStatic; previousMemberConstant = currentMemberConstant; previousMemberReadonly = currentMemberReadonly; } }
private static SyntaxNode HandleTypeDeclaration(MemberOrderHelper memberOrder, TypeDeclarationSyntax typeDeclarationNode, ImmutableArray<OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationOptions indentationOptions) { return OrderMember(memberOrder, typeDeclarationNode.Members, elementOrder, 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 void HandleMemberList(SyntaxNodeAnalysisContext context, ImmutableArray <OrderingTrait> elementOrder, int kindIndex, SyntaxList <MemberDeclarationSyntax> members, ImmutableArray <SyntaxKind> order) { for (int i = 0; i < members.Count - 1; i++) { if (members[i + 1].IsKind(SyntaxKind.IncompleteMember)) { i++; continue; } if (members[i].IsKind(SyntaxKind.IncompleteMember)) { continue; } bool compareKind = true; for (int j = 0; compareKind && j < kindIndex; j++) { switch (elementOrder[j]) { case OrderingTrait.Accessibility: if (MemberOrderHelper.GetAccessLevelForOrdering(members[i + 1], members[i + 1].GetModifiers()) != MemberOrderHelper.GetAccessLevelForOrdering(members[i], members[i].GetModifiers())) { compareKind = false; } continue; case OrderingTrait.Constant: case OrderingTrait.Readonly: // Only fields may be marked const or readonly, and all fields have the same kind. continue; case OrderingTrait.Static: bool currentIsStatic = members[i].GetModifiers().Any(SyntaxKind.StaticKeyword); bool nextIsStatic = members[i + 1].GetModifiers().Any(SyntaxKind.StaticKeyword); if (currentIsStatic != nextIsStatic) { compareKind = false; } continue; case OrderingTrait.Kind: default: continue; } } if (!compareKind) { continue; } var elementSyntaxKind = members[i].Kind(); elementSyntaxKind = elementSyntaxKind == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : elementSyntaxKind; int index = order.IndexOf(elementSyntaxKind); var nextElementSyntaxKind = members[i + 1].Kind(); nextElementSyntaxKind = nextElementSyntaxKind == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : nextElementSyntaxKind; int nextIndex = order.IndexOf(nextElementSyntaxKind); if (index > nextIndex) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, NamedTypeHelpers.GetNameOrIdentifierLocation(members[i + 1]), MemberNames[nextElementSyntaxKind], MemberNames[elementSyntaxKind])); } } }
private static SyntaxNode HandleNamespaceDeclaration(MemberOrderHelper memberOrder, NamespaceDeclarationSyntax namespaceDeclaration, ImmutableArray <OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationSettings indentationSettings) { return(OrderMember(memberOrder, namespaceDeclaration.Members, elementOrder, syntaxRoot, indentationSettings)); }
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 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)); }
private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings) { var elementOrder = settings.OrderingRules.ElementOrder; int readonlyIndex = elementOrder.IndexOf(OrderingTrait.Readonly); if (readonlyIndex < 0) { return; } var typeDeclaration = (TypeDeclarationSyntax)context.Node; // This variable is null when the previous member is not a field. FieldDeclarationSyntax previousField = null; var previousFieldConst = true; var previousFieldStatic = false; var previousFieldReadonly = false; var previousAccessLevel = AccessLevel.NotSpecified; foreach (var member in typeDeclaration.Members) { FieldDeclarationSyntax field = member as FieldDeclarationSyntax; if (field == null) { previousField = null; continue; } var modifiers = member.GetModifiers(); var currentAccessLevel = MemberOrderHelper.GetAccessLevelForOrdering(member, modifiers); bool currentFieldConst = modifiers.Any(SyntaxKind.ConstKeyword); bool currentFieldStatic = currentFieldConst || modifiers.Any(SyntaxKind.StaticKeyword); bool currentFieldReadonly = currentFieldConst || modifiers.Any(SyntaxKind.ReadOnlyKeyword); if (previousField == null) { previousField = field; previousFieldConst = currentFieldConst; previousFieldStatic = currentFieldStatic; previousFieldReadonly = currentFieldReadonly; previousAccessLevel = currentAccessLevel; continue; } bool compareReadonly = true; for (int j = 0; compareReadonly && j < readonlyIndex; j++) { switch (elementOrder[j]) { case OrderingTrait.Kind: // This analyzer only ever looks at sequences of fields. continue; case OrderingTrait.Accessibility: if (previousAccessLevel != currentAccessLevel) { compareReadonly = false; } continue; case OrderingTrait.Constant: if (previousFieldConst != currentFieldConst) { compareReadonly = false; } continue; case OrderingTrait.Static: if (previousFieldStatic != currentFieldStatic) { compareReadonly = false; } continue; case OrderingTrait.Readonly: default: continue; } } if (compareReadonly) { if (currentFieldReadonly && !previousFieldReadonly) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, NamedTypeHelpers.GetNameOrIdentifierLocation(member))); } } previousField = field; previousFieldConst = currentFieldConst; previousFieldStatic = currentFieldStatic; previousFieldReadonly = currentFieldReadonly; previousAccessLevel = currentAccessLevel; } }
private static SyntaxNode HandleCompilationUnitDeclaration(MemberOrderHelper memberOrder, CompilationUnitSyntax compilationUnitDeclaration, ImmutableArray<OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationOptions indentationOptions) { return OrderMember(memberOrder, compilationUnitDeclaration.Members, elementOrder, syntaxRoot, indentationOptions); }
private static SyntaxNode HandleNamespaceDeclaration(MemberOrderHelper memberOrder, NamespaceDeclarationSyntax namespaceDeclaration, ImmutableArray<OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationOptions indentationOptions) { return OrderMember(memberOrder, namespaceDeclaration.Members, elementOrder, syntaxRoot, indentationOptions); }
private static void HandleMemberList(SyntaxNodeAnalysisContext context, ImmutableArray <OrderingTrait> elementOrder, int accessibilityIndex, SyntaxList <MemberDeclarationSyntax> members) { var previousSyntaxKind = SyntaxKind.None; var previousAccessLevel = AccessLevel.NotSpecified; bool previousIsConst = false; bool previousIsReadonly = false; bool previousIsStatic = false; foreach (var member in members) { var currentSyntaxKind = member.Kind(); currentSyntaxKind = currentSyntaxKind == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : currentSyntaxKind; // if the SyntaxKind of this member (e.g. SyntaxKind.IncompleteMember) will not // be handled, skip early. if (!MemberKinds.Contains(currentSyntaxKind)) { continue; } var modifiers = member.GetModifiers(); AccessLevel currentAccessLevel = MemberOrderHelper.GetAccessLevelForOrdering(member, modifiers); bool currentIsConst = modifiers.Any(SyntaxKind.ConstKeyword); bool currentIsReadonly = modifiers.Any(SyntaxKind.ReadOnlyKeyword); bool currentIsStatic = modifiers.Any(SyntaxKind.StaticKeyword); if (previousAccessLevel != AccessLevel.NotSpecified) { bool compareAccessLevel = true; for (int j = 0; compareAccessLevel && j < accessibilityIndex; j++) { switch (elementOrder[j]) { case OrderingTrait.Kind: if (previousSyntaxKind != currentSyntaxKind) { compareAccessLevel = false; } continue; case OrderingTrait.Constant: if (previousIsConst != currentIsConst) { compareAccessLevel = false; } continue; case OrderingTrait.Readonly: if (previousIsReadonly != currentIsReadonly) { compareAccessLevel = false; } continue; case OrderingTrait.Static: if (previousIsStatic != currentIsStatic) { compareAccessLevel = false; } continue; case OrderingTrait.Accessibility: default: continue; } } if (compareAccessLevel && currentAccessLevel > previousAccessLevel) { context.ReportDiagnostic( Diagnostic.Create( Descriptor, NamedTypeHelpers.GetNameOrIdentifierLocation(member), AccessLevelHelper.GetName(currentAccessLevel), AccessLevelHelper.GetName(previousAccessLevel))); } } previousSyntaxKind = currentSyntaxKind; previousAccessLevel = currentAccessLevel; previousIsConst = currentIsConst; previousIsReadonly = currentIsReadonly; previousIsStatic = currentIsStatic; } }
private static SyntaxNode OrderMember(MemberOrderHelper memberOrder, SyntaxList<MemberDeclarationSyntax> members, ImmutableArray<OrderingTrait> elementOrder, 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], elementOrder); if (orderHelper.Priority < memberOrder.Priority) { target = orderHelper; } else { break; } } return target.Member != null ? MoveMember(syntaxRoot, memberOrder.Member, target.Member, indentationOptions) : syntaxRoot; }
private static void HandleMemberList(SyntaxNodeAnalysisContext context, ImmutableArray <OrderingTrait> elementOrder, int kindIndex, SyntaxList <MemberDeclarationSyntax> members, ImmutableArray <SyntaxKind> order) { for (int i = 0; i < members.Count - 1; i++) { if (members[i + 1].IsKind(SyntaxKind.IncompleteMember)) { i++; continue; } if (members[i].IsKind(SyntaxKind.IncompleteMember)) { continue; } bool compareKind = true; for (int j = 0; compareKind && j < kindIndex; j++) { switch (elementOrder[j]) { case OrderingTrait.Accessibility: if (MemberOrderHelper.GetAccessLevelForOrdering(members[i + 1], members[i + 1].GetModifiers()) != MemberOrderHelper.GetAccessLevelForOrdering(members[i], members[i].GetModifiers())) { compareKind = false; } continue; case OrderingTrait.Constant: case OrderingTrait.Readonly: // Only fields may be marked const or readonly, and all fields have the same kind. continue; case OrderingTrait.Static: bool currentIsStatic = members[i].GetModifiers().Any(SyntaxKind.StaticKeyword); bool nextIsStatic = members[i + 1].GetModifiers().Any(SyntaxKind.StaticKeyword); if (currentIsStatic != nextIsStatic) { compareKind = false; } continue; case OrderingTrait.Kind: default: continue; } } if (!compareKind) { continue; } var elementSyntaxKind = members[i].Kind(); int index = order.IndexOf(GetSyntaxKindForOrdering(elementSyntaxKind)); var nextElementSyntaxKind = members[i + 1].Kind(); int nextIndex = order.IndexOf(GetSyntaxKindForOrdering(nextElementSyntaxKind)); if (index > nextIndex) { // [Issue #3160] Added hardening here to make sure that this won't crash when working with invalid code. var nextElementMemberName = MemberNames.GetValueOrDefault(nextElementSyntaxKind, "<unknown>"); var elementMemberName = MemberNames.GetValueOrDefault(elementSyntaxKind, "<unknown>"); context.ReportDiagnostic(Diagnostic.Create(Descriptor, NamedTypeHelpers.GetNameOrIdentifierLocation(members[i + 1]), nextElementMemberName, elementMemberName)); } } }
private static SyntaxNode HandleTypeDeclaration(MemberOrderHelper memberOrder, TypeDeclarationSyntax typeDeclarationNode, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions) { return OrderMember(memberOrder, typeDeclarationNode.Members, checks, syntaxRoot, indentationOptions); }