Fix layering of modifier api.

src/Analyzers/Core/CodeFixes/GenerateConstructor/AbstractGenerateConstructorService.State.cs

@@ -19,12 +19,6 @@
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.GenerateMember.GenerateConstructor;
 
 using static GenerateConstructorHelpers;
@@ -440,7 +434,7 @@ public async Task<Document> GetChangedDocumentAsync(
             var constructor = CodeGenerationSymbolFactory.CreateConstructorSymbol(
                 attributes: default,
                 accessibility: Accessibility.Public,
-                modifiers: new DeclarationModifiers(isUnsafe: generateUnsafe),
+                modifiers: DeclarationModifiers.None.WithIsUnsafe(generateUnsafe),
                 typeName: TypeToGenerateIn.Name,
                 parameters: newParameters,
                 statements: assignments,

src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeAction.cs

@@ -11,12 +11,6 @@
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.GenerateDefaultConstructors;
 
 internal abstract partial class AbstractGenerateDefaultConstructorsService<TService>
@@ -62,7 +56,7 @@ private IMethodSymbol CreateConstructorDefinition(
             return CodeGenerationSymbolFactory.CreateConstructorSymbol(
                 attributes: default,
                 accessibility: accessibility,
-                modifiers: new DeclarationModifiers(),
+                modifiers: DeclarationModifiers.None,
                 typeName: classType.Name,
                 parameters: baseConstructor.Parameters.SelectAsArray(p => WithoutInaccessibleAttributes(p, classType)),
                 statements: default,

src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.SignatureInfo.cs

@@ -19,12 +19,6 @@
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.GenerateMember.GenerateParameterizedMember;
 
 internal abstract partial class AbstractGenerateParameterizedMemberService<TService, TSimpleNameSyntax, TExpressionSyntax, TInvocationExpressionSyntax>
@@ -82,7 +76,7 @@ internal async ValueTask<IPropertySymbol> GeneratePropertyAsync(
             return CodeGenerationSymbolFactory.CreatePropertySymbol(
                 attributes: default,
                 accessibility: accessibility,
-                modifiers: new DeclarationModifiers(isStatic: State.IsStatic, isAbstract: isAbstract),
+                modifiers: DeclarationModifiers.None.WithIsStatic(State.IsStatic).WithIsAbstract(isAbstract),
                 type: await DetermineReturnTypeAsync(cancellationToken).ConfigureAwait(false),
                 refKind: DetermineRefKind(cancellationToken),
                 explicitInterfaceImplementations: default,
@@ -110,8 +104,8 @@ public async ValueTask<IMethodSymbol> GenerateMethodAsync(
             var method = CodeGenerationSymbolFactory.CreateMethodSymbol(
                 attributes: default,
                 accessibility: DetermineAccessibility(isAbstract),
-                modifiers: new DeclarationModifiers(
-                    isStatic: State.IsStatic, isAbstract: isAbstract, isUnsafe: isUnsafe, isAsync: knownTypes.IsTaskLike(returnType)),
+                modifiers: DeclarationModifiers.None
+                    .WithIsStatic(State.IsStatic).WithIsAbstract(isAbstract).WithIsUnsafe(isUnsafe).WithAsync(knownTypes.IsTaskLike(returnType)),
                 returnType: returnType,
                 refKind: DetermineRefKind(cancellationToken),
                 explicitInterfaceImplementations: default,

src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs

@@ -13,12 +13,6 @@
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.GenerateMember.GenerateVariable;
 
 internal abstract partial class AbstractGenerateVariableService<TService, TSimpleNameSyntax, TExpressionSyntax>
@@ -72,7 +66,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                 var propertySymbol = CodeGenerationSymbolFactory.CreatePropertySymbol(
                     attributes: default,
                     accessibility: _state.DetermineMaximalAccessibility(),
-                    modifiers: new DeclarationModifiers(isStatic: _state.IsStatic, isUnsafe: generateUnsafe),
+                    modifiers: DeclarationModifiers.None.WithIsStatic(_state.IsStatic).WithIsUnsafe(generateUnsafe),
                     type: _state.TypeMemberType,
                     refKind: _refKind,
                     explicitInterfaceImplementations: default,
@@ -91,8 +85,8 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                     attributes: default,
                     accessibility: DetermineMinimalAccessibility(_state),
                     modifiers: _isConstant
-                        ? new DeclarationModifiers(isConst: true, isUnsafe: generateUnsafe)
-                        : new DeclarationModifiers(isStatic: _state.IsStatic, isReadOnly: _isReadonly, isUnsafe: generateUnsafe),
+                        ? DeclarationModifiers.None.WithIsConst(true).WithIsUnsafe(generateUnsafe)
+                        : DeclarationModifiers.None.WithIsStatic(_state.IsStatic).WithIsReadOnly(_isReadonly).WithIsUnsafe(generateUnsafe),
                     type: _state.TypeMemberType,
                     name: _state.IdentifierToken.ValueText);
 

src/Analyzers/Core/CodeFixes/ImplementAbstractClass/ImplementAbstractClassData.cs

@@ -21,12 +21,6 @@
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.ImplementAbstractClass;
 
 internal sealed class ImplementAbstractClassData(
@@ -152,7 +146,7 @@ private ImmutableArray<ISymbol> GenerateMembers(
         Compilation compilation, ISymbol member, ISymbol? throughMember, bool addUnsafe,
         ImplementTypePropertyGenerationBehavior propertyGenerationBehavior)
     {
-        var modifiers = new DeclarationModifiers(isOverride: true, isUnsafe: addUnsafe, isRequired: member.IsRequired());
+        var modifiers = DeclarationModifiers.Override.WithIsUnsafe(addUnsafe).WithIsRequired(member.IsRequired());
         var accessibility = member.ComputeResultantAccessibility(ClassType);
 
         // only call through one of members for this symbol if we can actually access the symbol

src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator.cs

@@ -18,12 +18,6 @@
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.ImplementInterface;
 
 using static ImplementHelpers;
@@ -293,7 +287,7 @@ public ImmutableArray<ISymbol> GenerateMembers(
             ImplementTypePropertyGenerationBehavior propertyGenerationBehavior)
         {
             var factory = Document.GetRequiredLanguageService<SyntaxGenerator>();
-            var modifiers = new DeclarationModifiers(isStatic: member.IsStatic, isAbstract: generateAbstractly, isNew: addNew, isUnsafe: addUnsafe);
+            var modifiers = DeclarationModifiers.None.WithIsStatic(member.IsStatic).WithIsAbstract(generateAbstractly).WithIsNew(addNew).WithIsUnsafe(addUnsafe);
 
             var useExplicitInterfaceSymbol = generateInvisibly || !Service.CanImplementImplicitly;
             var accessibility = member.Name == memberName || generateAbstractly

src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator_Conflicts.cs

@@ -10,12 +10,6 @@
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.ImplementInterface;
 
 internal abstract partial class AbstractImplementInterfaceService

src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator_DisposePattern.cs

@@ -18,12 +18,6 @@
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.ImplementInterface;
 
 using static ImplementHelpers;

src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator_Method.cs

@@ -9,12 +9,6 @@
 using Microsoft.CodeAnalysis.LanguageService;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.ImplementInterface;
 
 internal abstract partial class AbstractImplementInterfaceService

src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator_Property.cs

@@ -13,12 +13,6 @@
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers;
-#else
-using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers;
-#endif
-
 namespace Microsoft.CodeAnalysis.ImplementInterface;
 
 internal abstract partial class AbstractImplementInterfaceService

src/CodeStyle/Core/Analyzers/Microsoft.CodeAnalysis.CodeStyle.csproj

@@ -35,7 +35,6 @@
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.VisualBasic.CodeStyle.UnitTests" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="..\..\..\Workspaces\Core\Portable\Editing\DeclarationModifiers.cs" Link="Editing\DeclarationModifiers.cs" />
     <Compile Include="..\..\..\Workspaces\Core\Portable\Formatting\VisualBasic\VisualBasicSyntaxFormattingOptions.cs" Link="Formatting\VisualBasic\VisualBasicSyntaxFormattingOptions.cs" />
   </ItemGroup>
   <ItemGroup>

src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs

@@ -155,7 +155,7 @@ async Task ContinueOnMainThreadAsync(
 
                 var namingRule = await document.GetApplicableNamingRuleAsync(
                     new SymbolKindOrTypeKind(MethodKind.Ordinary),
-                    new DeclarationModifiers(isStatic: plusEqualsToken.Value.GetRequiredParent().IsInStaticContext()),
+                    new DeclarationModifiers(isStatic: plusEqualsToken.Value.GetRequiredParent().IsInStaticContext()).Modifiers,
                     Accessibility.Private,
                     cancellationToken).ConfigureAwait(false);
 

src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationName/DeclarationNameInfo.cs

@@ -554,7 +554,7 @@ private static ImmutableArray<SymbolKindOrTypeKind> GetPossibleLocalDeclarations
 
     private static DeclarationModifiers GetDeclarationModifiers(SyntaxTokenList modifiers)
     {
-        var declarationModifiers = new DeclarationModifiers();
+        var declarationModifiers = DeclarationModifiers.None;
         foreach (var modifer in modifiers)
         {
             switch (modifer.Kind())

src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationName/DeclarationNameRecommender.cs

@@ -237,7 +237,7 @@ static void ProcessRules(
             var modifiers = declarationInfo.Modifiers;
             foreach (var rule in rules)
             {
-                if (rule.SymbolSpecification.AppliesTo(kind, declarationInfo.Modifiers, declarationInfo.DeclaredAccessibility))
+                if (rule.SymbolSpecification.AppliesTo(kind, declarationInfo.Modifiers.Modifiers, declarationInfo.DeclaredAccessibility))
                 {
                     foreach (var baseName in baseNames)
                     {

src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs

@@ -37,7 +37,7 @@ protected override async Task<string> GetFieldNameAsync(Document document, IProp
     {
         var rule = await document.GetApplicableNamingRuleAsync(
             new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),
-            property.IsStatic ? DeclarationModifiers.Static : DeclarationModifiers.None,
+            property.IsStatic ? Modifiers.Static : Modifiers.None,
             Accessibility.Private,
             cancellationToken).ConfigureAwait(false);
 

src/Features/CSharp/Portable/ConvertPrimaryToRegularConstructor/ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs

@@ -84,7 +84,7 @@ private static async Task<Solution> ConvertAsync(
         // The naming rule we need to follow if we synthesize new private fields.
         var fieldNameRule = await document.GetApplicableNamingRuleAsync(
             new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),
-            DeclarationModifiers.None,
+            Modifiers.None,
             Accessibility.Private,
             cancellationToken).ConfigureAwait(false);
 

src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.CSharpCodeGenerator.cs

@@ -1153,13 +1153,13 @@ protected string GenerateMethodNameFromUserPreference()
                 }
 
                 // For local functions, pascal case and camel case should be the most common and therefore we only consider those cases.
-                var localFunctionPreferences = Options.NamingStyle.SymbolSpecifications.Where(symbol => symbol.AppliesTo(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction), CreateMethodModifiers(), null));
+                var localFunctionPreferences = Options.NamingStyle.SymbolSpecifications.Where(symbol => symbol.AppliesTo(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction), CreateMethodModifiers().Modifiers, null));
 
                 var namingRules = Options.NamingStyle.Rules.NamingRules;
                 var localFunctionKind = new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction);
                 if (LocalFunction)
                 {
-                    if (namingRules.Any(static (rule, arg) => rule.NamingStyle.CapitalizationScheme.Equals(Capitalization.CamelCase) && rule.SymbolSpecification.AppliesTo(arg.localFunctionKind, arg.self.CreateMethodModifiers(), null), (self: this, localFunctionKind)))
+                    if (namingRules.Any(static (rule, arg) => rule.NamingStyle.CapitalizationScheme.Equals(Capitalization.CamelCase) && rule.SymbolSpecification.AppliesTo(arg.localFunctionKind, arg.self.CreateMethodModifiers().Modifiers, null), (self: this, localFunctionKind)))
                     {
                         methodName = NewMethodCamelCaseStr;
                     }

src/Features/CSharp/Portable/Formatting/CSharpAccessibilityModifiersNewDocumentFormattingProvider.cs

@@ -62,7 +62,7 @@ public async Task<Document> FormatNewDocumentAsync(Document document, Document?
             // error.
             var modifiers = syntaxFacts.GetModifiers(declaration);
             CSharpAccessibilityFacts.GetAccessibilityAndModifiers(modifiers, out _, out var declarationModifiers, out _);
-            if (declarationModifiers.IsPartial)
+            if (declarationModifiers.HasFlag(Modifiers.Partial))
                 continue;
 
             var type = semanticModel.GetDeclaredSymbol(declaration, cancellationToken);

src/Features/CSharp/Portable/GenerateType/CSharpGenerateTypeService.cs

@@ -782,7 +782,7 @@ private static IPropertySymbol CreatePropertySymbol(
         return CodeGenerationSymbolFactory.CreatePropertySymbol(
             attributes: [],
             accessibility: Accessibility.Public,
-            modifiers: new DeclarationModifiers(),
+            modifiers: DeclarationModifiers.None,
             explicitInterfaceImplementations: default,
             name: propertyName.Identifier.ValueText,
             type: propertyType,

src/Features/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs

@@ -140,7 +140,7 @@ private static NamingStylePreferences CreateCustomStaticFieldNamingStylePreferen
             "Name",
             [new SymbolKindOrTypeKind(SymbolKind.Field)],
             accessibilityList: default,
-            [new ModifierKind(DeclarationModifiers.Static)]);
+            [new ModifierKind(Modifiers.Static)]);
 
         var namingStyle = new NamingStyle(
             Guid.NewGuid(),

src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs

@@ -140,7 +140,7 @@ public async Task<ExtractInterfaceResult> ExtractInterfaceFromAnalyzedTypeAsync(
         var extractedInterfaceSymbol = CodeGenerationSymbolFactory.CreateNamedTypeSymbol(
             attributes: default,
             accessibility: ShouldIncludeAccessibilityModifier(refactoringResult.TypeNode) ? refactoringResult.TypeToExtractFrom.DeclaredAccessibility : Accessibility.NotApplicable,
-            modifiers: new DeclarationModifiers(),
+            modifiers: DeclarationModifiers.None,
             typeKind: TypeKind.Interface,
             name: extractInterfaceOptions.InterfaceName,
             typeParameters: ExtractTypeHelpers.GetRequiredTypeParametersForMembers(refactoringResult.TypeToExtractFrom, extractInterfaceOptions.IncludedMembers),

src/Features/Core/Portable/GenerateConstructors/AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs

@@ -90,7 +90,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                 CodeGenerationSymbolFactory.CreateConstructorSymbol(
                     attributes: default,
                     accessibility: _state.ContainingType.IsAbstractClass() ? Accessibility.Protected : Accessibility.Public,
-                    modifiers: new DeclarationModifiers(),
+                    modifiers: DeclarationModifiers.None,
                     typeName: _state.ContainingType.Name,
                     parameters: _state.Parameters,
                     statements: statements,

src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs

@@ -337,7 +337,7 @@ private IPropertySymbol CreateProperty(
                 return CodeGenerationSymbolFactory.CreatePropertySymbol(
                     default,
                     accessibilityLevel,
-                    new DeclarationModifiers(),
+                    DeclarationModifiers.None,
                     parameter.Type,
                     RefKind.None,
                     explicitInterfaceImplementations: default,

src/Features/Core/Portable/Shared/Extensions/DocumentExtensions.cs

@@ -10,7 +10,6 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
 using Microsoft.CodeAnalysis.Editing;
-using Roslyn.Utilities;
 using static Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles.SymbolSpecification;
 
 namespace Microsoft.CodeAnalysis.Shared.Extensions;
@@ -104,7 +103,7 @@ public static async Task<NamingRule> GetApplicableNamingRuleAsync(this Document
     }
 
     public static async Task<NamingRule> GetApplicableNamingRuleAsync(
-        this Document document, SymbolKindOrTypeKind kind, DeclarationModifiers modifiers, Accessibility? accessibility, CancellationToken cancellationToken)
+        this Document document, SymbolKindOrTypeKind kind, Modifiers modifiers, Accessibility? accessibility, CancellationToken cancellationToken)
     {
         var rules = await document.GetNamingRulesAsync(cancellationToken).ConfigureAwait(false);
         foreach (var rule in rules)

src/VisualStudio/Core/Def/Venus/ContainedLanguageCodeSupport.cs

@@ -189,7 +189,7 @@ public static Tuple<string, string, VsTextSpan> EnsureEventHandler(
         var newMethod = CodeGenerationSymbolFactory.CreateMethodSymbol(
             attributes: default,
             accessibility: Accessibility.Protected,
-            modifiers: new DeclarationModifiers(),
+            modifiers: DeclarationModifiers.None,
             returnType: targetDocument.Project.GetCompilationAsync(cancellationToken).WaitAndGetResult_Venus(cancellationToken).GetSpecialType(SpecialType.System_Void),
             refKind: RefKind.None,
             explicitInterfaceImplementations: default,

src/VisualStudio/Core/Impl/Options/Style/NamingPreferences/NamingStyleOptionPageViewModel.cs

@@ -99,7 +99,7 @@ internal void UpdateSpecificationList(ManageSymbolSpecificationsDialogViewModel
             n.ItemName,
             [.. n.SymbolKindList.Where(s => s.IsChecked).Select(k => k.CreateSymbolOrTypeOrMethodKind())],
             [.. n.AccessibilityList.Where(s => s.IsChecked).Select(a => a._accessibility)],
-            [.. n.ModifierList.Where(s => s.IsChecked).Select(m => new SymbolSpecification.ModifierKind(m._modifier))]));
+            [.. n.ModifierList.Where(s => s.IsChecked).Select(m => new SymbolSpecification.ModifierKind(m._modifier.Modifiers))]));
 
         Specifications.Clear();
         foreach (var specification in symbolSpecifications)