C# MemberDeclarationSyntax.GetModifiers方法代码示例

        private static bool ShouldUseOverrideKeyword(MemberDeclarationSyntax member, bool isInterface)
        {
            ISymbol symbol = TypeProcessor.GetDeclaredSymbol(member);

            if (symbol is IMethodSymbol)
            {
                if ((symbol as IMethodSymbol).IsGenericMethod)
                    return false;
            }

            if (symbol.ContainingType.TypeKind == TypeKind.Struct ||
                symbol.ContainingType.TypeKind == TypeKind.Interface)
            {
                return false;
                // Structs dont have a base class to override (maybe opEquals) ... but that will be handled separately
                //Interfaces are contracts, so no overriding here// maybe we should compare the methods 
            }

            if (member.GetModifiers().Any(SyntaxKind.OverrideKeyword) && !isInterface)
                return true;


            if (member.GetModifiers().Any(SyntaxKind.StaticKeyword))
                return false;
            //          if (method.Modifiers.Any(SyntaxKind.NewKeyword))
            //              return  symbol.ContainingType.BaseType.GetMembers(symbol.Name).Any(k=>k.IsAbstract || k.IsVirtual);

            if (member.GetModifiers().Any(SyntaxKind.PartialKeyword))
                //partial methods seem exempt from C#'s normal override keyword requirement, so we have to check manually to see if it exists in a base class
                return symbol.ContainingType.BaseType.GetMembers(symbol.Name).Any();

            return member.GetModifiers().Any(SyntaxKind.OverrideKeyword);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct.
        /// </summary>
        /// <param name="member">The member to wrap.</param>
        public MemberOrderHelper(MemberDeclarationSyntax member)
        {
            this.Member = member;
            var modifiers = member.GetModifiers();

            this.modifierFlags = GetModifierFlags(modifiers);
            this.accessibilty = AccessLevelHelper.GetAccessLevel(modifiers);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct.
        /// </summary>
        /// <param name="member">The member to wrap.</param>
        /// <param name="elementOrder">The element ordering traits.</param>
        internal MemberOrderHelper(MemberDeclarationSyntax member, ImmutableArray<OrderingTrait> elementOrder)
        {
            this.Member = member;
            var modifiers = member.GetModifiers();
            var type = member.Kind();
            type = type == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : type;

            this.Priority = 0;
            foreach (OrderingTrait trait in elementOrder)
            {
                switch (trait)
                {
                case OrderingTrait.Kind:
                    // 4 bits are required to store this.
                    this.Priority <<= 4;
                    this.Priority |= TypeMemberOrder.IndexOf(type) & 0x0F;
                    break;

                case OrderingTrait.Accessibility:
                    // 3 bits are required to store this.
                    this.Priority <<= 3;
                    this.Priority |= (int)GetAccessLevelForOrdering(member, modifiers) & 0x07;
                    break;

                case OrderingTrait.Constant:
                    this.Priority <<= 1;
                    if (modifiers.Any(SyntaxKind.ConstKeyword))
                    {
                        this.Priority |= 1;
                    }

                    break;

                case OrderingTrait.Static:
                    this.Priority <<= 1;
                    if (modifiers.Any(SyntaxKind.StaticKeyword))
                    {
                        this.Priority |= 1;
                    }

                    break;

                case OrderingTrait.Readonly:
                    this.Priority <<= 1;
                    if (modifiers.Any(SyntaxKind.ReadOnlyKeyword))
                    {
                        this.Priority |= 1;
                    }

                    break;

                default:
                    continue;
                }
            }
        }

        public static string GetAccessModifiers(MemberDeclarationSyntax member, bool isInterface)
        {
            bool isStatic;
            var acccessmodifiers = "";
            var modifiers = member.GetModifiers();
            bool isoverride = ShouldUseOverrideKeyword(member, isInterface);



            if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) ||
                modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) ||
                isInterface)
                acccessmodifiers += ("public ");

            if (!modifiers.Any(SyntaxKind.VirtualKeyword) && !isInterface && !isoverride)
                acccessmodifiers += ("final ");

            ///  if (modifiers.Any(SyntaxKind.PrivateKeyword)) // Reflection cannot work with this, cant get address or set value
            //     acccessmodifiers += ("private ");


            if (modifiers.Any(SyntaxKind.StaticKeyword))
            {
                acccessmodifiers += "static ";
            }

            if (member.GetModifiers().Any(SyntaxKind.AbstractKeyword))
                acccessmodifiers += "abstract ";




            if (isoverride)
                acccessmodifiers += ("override ");

            return acccessmodifiers;
        }

        /// <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 MemberDeclarationSyntax ReplaceDeclarationModifiers(MemberDeclarationSyntax declaration, List<SyntaxToken> oldAccessibilityModifiers, SyntaxTokenList newAccessibilityModifiers)
        {
            var result = declaration;
            var replacedModifiers = declaration.GetModifiers();

            if (oldAccessibilityModifiers.Count == 0)
            {
                replacedModifiers = replacedModifiers.InsertRange(0,newAccessibilityModifiers);
            }
            else if(oldAccessibilityModifiers.Count == 1)
            {
                replacedModifiers = replacedModifiers.ReplaceRange(oldAccessibilityModifiers[0], newAccessibilityModifiers);
            }
            else if(oldAccessibilityModifiers.Count == 2)
            {
                replacedModifiers = replacedModifiers.ReplaceRange(oldAccessibilityModifiers[0], newAccessibilityModifiers);
                replacedModifiers = replacedModifiers.Remove(replacedModifiers.SingleOrDefault(token => token.IsKind(oldAccessibilityModifiers[1].Kind())));
            }

            result = declaration.WithModifiers(replacedModifiers);

            return result;
        }

 private static IEnumerable<SyntaxToken> GetAccessibilityModifiersFromMember(MemberDeclarationSyntax member) => member.GetModifiers().Where(token => token.IsKind(SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.InternalKeyword, SyntaxKind.PrivateKeyword));

        private static MemberDeclarationSyntax ChangeAccessibilityModifiersInDeclaration(MemberDeclarationSyntax declaration, SyntaxTokenList newAccessibilityModifiers)
        {
            var newDeclaration = declaration;

            var actualTypeAccessibilityModifiers = GetAccessibilityModifiersFromMember(declaration);
            var hasAccessibilityModifiers = actualTypeAccessibilityModifiers.Any();

            var leadingTrivias = default(SyntaxTriviaList);
            var trailingTrivias = default(SyntaxTriviaList);
            if (!hasAccessibilityModifiers)
            {
                var modifiers = declaration.GetModifiers();
                if (modifiers.Count > 0)
                {
                    var firstModifier = modifiers.First();
                    leadingTrivias = firstModifier.LeadingTrivia;
                    newDeclaration = RemoveLeadingTriviasFromFirstDeclarationModifier(declaration, modifiers, firstModifier);
                }
                else
                {
                    leadingTrivias = declaration.GetLeadingTrivia();
                    newDeclaration = RemoveLeadingTriviasFromDeclaration(declaration);
                }
                trailingTrivias = SyntaxFactory.TriviaList(SyntaxFactory.Space);
            }
            else
            {
                leadingTrivias = actualTypeAccessibilityModifiers.First().LeadingTrivia;
                trailingTrivias = GetAllTriviasAfterFirstModifier(actualTypeAccessibilityModifiers);
            }

            newAccessibilityModifiers = MergeActualTriviasIntoNewAccessibilityModifiers(newAccessibilityModifiers, leadingTrivias, trailingTrivias);

            newDeclaration = ReplaceDeclarationModifiers(newDeclaration, actualTypeAccessibilityModifiers.ToList(), newAccessibilityModifiers);

            return newDeclaration;
        }

 bool IsAltered(SemanticModel model, MemberDeclarationSyntax member, ISymbol symbol, CancellationToken token, out bool wasUsed)
 {
     wasUsed = false;
     foreach (var usage in member.DescendantNodesAndSelf().Where(n => n.IsKind(SyntaxKind.IdentifierName)).OfType<ExpressionSyntax>())
     {
         var info = model.GetSymbolInfo(usage).Symbol;
         if (info == symbol)
             wasUsed = true;
         if (!usage.IsWrittenTo())
             continue;
         if (member.IsKind(SyntaxKind.ConstructorDeclaration) && !usage.Ancestors().Any(a => a.IsKind(SyntaxKind.AnonymousMethodExpression) || a.IsKind(SyntaxKind.SimpleLambdaExpression) || a.IsKind(SyntaxKind.ParenthesizedLambdaExpression)))
         {
             if (member.GetModifiers().Any(m => m.IsKind(SyntaxKind.StaticKeyword)) == info.IsStatic)
                 continue;
         }
         if (info == symbol)
             return true;
     }
     return false;
 }

        static SyntaxNode AddModifier(MemberDeclarationSyntax abstractDeclaration, SyntaxKind token)
        {
            var method = abstractDeclaration as MethodDeclarationSyntax;

            var modifier = abstractDeclaration.GetModifiers();
            var newMods = modifier.Where(m => !m.IsKind(SyntaxKind.AbstractKeyword) && !m.IsKind(SyntaxKind.StaticKeyword));

            newMods = newMods.Concat(
                new[] { SyntaxFactory.Token(token) }
            );

            var newModifier = SyntaxFactory.TokenList(newMods);

            if (method != null)
            {
                return method.WithModifiers(newModifier);
            }

            var property = abstractDeclaration as PropertyDeclarationSyntax;
            if (property != null)
            {
                return property.WithModifiers(newModifier);
            }

            var indexer = abstractDeclaration as IndexerDeclarationSyntax;
            if (indexer != null)
            {
                return indexer.WithModifiers(newModifier);
            }

            var evt = abstractDeclaration as EventDeclarationSyntax;
            if (evt != null)
            {
                return evt.WithModifiers(newModifier);
            }

            var evt2 = abstractDeclaration as EventFieldDeclarationSyntax;
            if (evt2 != null)
            {
                return evt2.WithModifiers(newModifier);
            }
            return null;
        }

        static SyntaxNode MakeAbstractDeclaration(MemberDeclarationSyntax abstractDeclaration)
        {
            var method = abstractDeclaration as MethodDeclarationSyntax;

            var modifier = abstractDeclaration.GetModifiers();
            var newModifier = SyntaxFactory.TokenList(modifier.Where(m => !m.IsKind(SyntaxKind.VirtualKeyword) && !m.IsKind(SyntaxKind.StaticKeyword) && !m.IsKind(SyntaxKind.SealedKeyword)).Concat(
                new[] { SyntaxFactory.Token(SyntaxKind.AbstractKeyword) }
            ));

            if (method != null)
            {
                return SyntaxFactory.MethodDeclaration(
                    method.AttributeLists,
                    newModifier,
                    method.ReturnType,
                    method.ExplicitInterfaceSpecifier,
                    method.Identifier,
                    method.TypeParameterList,
                    method.ParameterList,
                    method.ConstraintClauses,
                    null,
                    method.ExpressionBody,
                    SyntaxFactory.Token(SyntaxKind.SemicolonToken));
            }

            var property = abstractDeclaration as PropertyDeclarationSyntax;
            if (property != null)
            {
                var accessors = new List<AccessorDeclarationSyntax>();
                foreach (var accessor in property.AccessorList.Accessors)
                {
                    accessors.Add(SyntaxFactory.AccessorDeclaration(accessor.Kind(), accessor.AttributeLists, accessor.Modifiers, accessor.Keyword, null, SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
                }
                return SyntaxFactory.PropertyDeclaration(
                    property.AttributeLists,
                    newModifier,
                    property.Type,
                    property.ExplicitInterfaceSpecifier,
                    property.Identifier,
                    SyntaxFactory.AccessorList(SyntaxFactory.List<AccessorDeclarationSyntax>(accessors)),
                    property.ExpressionBody,
                    property.Initializer);
            }

            var indexer = abstractDeclaration as IndexerDeclarationSyntax;
            if (indexer != null)
            {
                var accessors = new List<AccessorDeclarationSyntax>();
                foreach (var accessor in indexer.AccessorList.Accessors)
                {
                    accessors.Add(SyntaxFactory.AccessorDeclaration(accessor.Kind(), accessor.AttributeLists, accessor.Modifiers, accessor.Keyword, null, SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
                }
                return SyntaxFactory.IndexerDeclaration(
                    indexer.AttributeLists,
                    newModifier,
                    indexer.Type,
                    indexer.ExplicitInterfaceSpecifier,
                    indexer.ParameterList,
                    SyntaxFactory.AccessorList(SyntaxFactory.List<AccessorDeclarationSyntax>(accessors)),
                    indexer.ExpressionBody);
            }
            var evt = abstractDeclaration as EventDeclarationSyntax;
            if (evt != null)
            {
                return SyntaxFactory.EventFieldDeclaration(
                    evt.AttributeLists,
                    newModifier,
                    SyntaxFactory.VariableDeclaration(
                        evt.Type,
                        SyntaxFactory.SeparatedList<VariableDeclaratorSyntax>(
                            new[] {
                                SyntaxFactory.VariableDeclarator(evt.Identifier)
                            }
                        )
                    )
                );
            }
            var evt2 = abstractDeclaration as EventFieldDeclarationSyntax;
            if (evt2 != null)
            {
                return evt2.WithModifiers(newModifier);
            }
            return null;
        }

        static SyntaxNode ImplementAbstractDeclaration(MemberDeclarationSyntax abstractDeclaration, bool implementAsVirtual = false)
        {
            var method = abstractDeclaration as MethodDeclarationSyntax;

            var modifier = abstractDeclaration.GetModifiers();
            var newMods = modifier.Where(m => !m.IsKind(SyntaxKind.AbstractKeyword) && !m.IsKind(SyntaxKind.StaticKeyword));
            if (implementAsVirtual)
            {
                newMods = newMods.Concat(
                    new[] { SyntaxFactory.Token(SyntaxKind.VirtualKeyword) }
                );
            }

            var newModifier = SyntaxFactory.TokenList(newMods);

            if (method != null)
            {
                return SyntaxFactory.MethodDeclaration(
                    method.AttributeLists,
                    newModifier,
                    method.ReturnType,
                    method.ExplicitInterfaceSpecifier,
                    method.Identifier,
                    method.TypeParameterList,
                    method.ParameterList,
                    method.ConstraintClauses,
                    CreateNotImplementedBody(),
                    method.ExpressionBody);
            }

            var property = abstractDeclaration as PropertyDeclarationSyntax;
            if (property != null)
            {
                var accessors = new List<AccessorDeclarationSyntax>();
                foreach (var accessor in property.AccessorList.Accessors)
                {
                    accessors.Add(SyntaxFactory.AccessorDeclaration(accessor.Kind(), accessor.AttributeLists, accessor.Modifiers, CreateNotImplementedBody()));
                }
                return SyntaxFactory.PropertyDeclaration(
                    property.AttributeLists,
                    newModifier,
                    property.Type,
                    property.ExplicitInterfaceSpecifier,
                    property.Identifier,
                    SyntaxFactory.AccessorList(SyntaxFactory.List<AccessorDeclarationSyntax>(accessors)),
                    property.ExpressionBody,
                    property.Initializer);
            }

            var indexer = abstractDeclaration as IndexerDeclarationSyntax;
            if (indexer != null)
            {
                var accessors = new List<AccessorDeclarationSyntax>();
                foreach (var accessor in indexer.AccessorList.Accessors)
                {
                    accessors.Add(SyntaxFactory.AccessorDeclaration(accessor.Kind(), accessor.AttributeLists, accessor.Modifiers, CreateNotImplementedBody()));
                }
                return SyntaxFactory.IndexerDeclaration(
                    indexer.AttributeLists,
                    newModifier,
                    indexer.Type,
                    indexer.ExplicitInterfaceSpecifier,
                    indexer.ParameterList,
                    SyntaxFactory.AccessorList(SyntaxFactory.List<AccessorDeclarationSyntax>(accessors)),
                    indexer.ExpressionBody);
            }

            var evt = abstractDeclaration as EventDeclarationSyntax;
            if (evt != null)
            {
                var accessors = new List<AccessorDeclarationSyntax>();
                foreach (var accessor in evt.AccessorList.Accessors)
                {
                    accessors.Add(SyntaxFactory.AccessorDeclaration(accessor.Kind(), CreateNotImplementedBody()));
                }
                return SyntaxFactory.EventDeclaration(
                    evt.AttributeLists,
                    newModifier,
                    evt.Type,
                    evt.ExplicitInterfaceSpecifier,
                    evt.Identifier,
                    SyntaxFactory.AccessorList(SyntaxFactory.List<AccessorDeclarationSyntax>(accessors))
                );
            }

            var evtField = abstractDeclaration as EventFieldDeclarationSyntax;
            if (evtField != null)
            {
                return SyntaxFactory.EventFieldDeclaration(
                    evtField.AttributeLists,
                    newModifier,
                    evtField.Declaration
                );
            }

            return null;
        }

        private static AccessLevel GetAccessLevel(MemberDeclarationSyntax member)
        {
            bool isProtected = false;
            bool isInternal = false;
            foreach (var modifier in member.GetModifiers())
            {
                switch (modifier.Kind())
                {
                case SyntaxKind.PublicKeyword:
                    return AccessLevel.Public;
                case SyntaxKind.PrivateKeyword:
                    return AccessLevel.Private;
                case SyntaxKind.InternalKeyword:
                    if (isProtected)
                    {
                        return AccessLevel.ProtectedInternal;
                    }
                    else
                    {
                        isInternal = true;
                    }

                    break;
                case SyntaxKind.ProtectedKeyword:
                    if (isInternal)
                    {
                        return AccessLevel.ProtectedInternal;
                    }
                    else
                    {
                        isProtected = true;
                    }

                    break;
                }
            }

            if (isProtected)
            {
                return AccessLevel.Protected;
            }
            else if (isInternal)
            {
                return AccessLevel.Internal;
            }

            return AccessLevel.NotSpecified;
        }

        bool IsAltered(SemanticModel model, MemberDeclarationSyntax member, ISymbol symbol, CancellationToken token, out bool wasUsed)
        {
            wasUsed = false;
            foreach (var usage in member.DescendantNodesAndSelf().Where(n => n.IsKind(SyntaxKind.IdentifierName)).OfType<ExpressionSyntax>())
            {
                var info = model.GetSymbolInfo(usage).Symbol;
                if (info == symbol)
                    wasUsed = true;
                if (!usage.IsWrittenTo())
                {
                    // Special case: If variable is of a value type, check if one of its members is altered.
                    var memberAccExpr = usage.Parent as MemberAccessExpressionSyntax;
                    if (symbol.GetReturnType().IsReferenceType
                        || (memberAccExpr == null)
                        || (info != symbol)
                        || (memberAccExpr.Name == usage)
                        || !memberAccExpr.IsWrittenTo())
                        continue;
                }

                if (member.IsKind(SyntaxKind.ConstructorDeclaration) && !usage.Ancestors().Any(a => a.IsKind(SyntaxKind.AnonymousMethodExpression) || a.IsKind(SyntaxKind.SimpleLambdaExpression) || a.IsKind(SyntaxKind.ParenthesizedLambdaExpression)))
                {
                    if (member.GetModifiers().Any(m => m.IsKind(SyntaxKind.StaticKeyword)) == info.IsStatic)
                        continue;
                }
                if (info == symbol)
                    return true;
            }
            return false;
        }