diff --git a/src/Analyzers/CSharp/Tests/MisplacedUsingDirectives/MisplacedUsingDirectivesCodeFixProviderTests.cs b/src/Analyzers/CSharp/Tests/MisplacedUsingDirectives/MisplacedUsingDirectivesCodeFixProviderTests.cs index ab67d6a313589e241aec0a15972e0ee15d5a9ffc..b547225f41104b62bb88fa7a76afbf019d88a69b 100644 --- a/src/Analyzers/CSharp/Tests/MisplacedUsingDirectives/MisplacedUsingDirectivesCodeFixProviderTests.cs +++ b/src/Analyzers/CSharp/Tests/MisplacedUsingDirectives/MisplacedUsingDirectivesCodeFixProviderTests.cs @@ -11,7 +11,7 @@ using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.Editing; using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics; -using Microsoft.CodeAnalysis.Options; +using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Xunit; namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.MisplacedUsingDirectives @@ -54,7 +54,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider protected const string DelegateDefinition = @"public delegate void TestDelegate();"; private TestParameters GetTestParameters(CodeStyleOption2 preferredPlacementOption) - => new TestParameters(options: OptionsSet((new OptionKey2(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement), preferredPlacementOption))); + => new TestParameters(options: new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferredUsingDirectivePlacement, preferredPlacementOption } }); private protected Task TestDiagnosticMissingAsync(string initialMarkup, CodeStyleOption2 preferredPlacementOption) => TestDiagnosticMissingAsync(initialMarkup, GetTestParameters(preferredPlacementOption)); @@ -64,11 +64,11 @@ private protected Task TestMissingAsync(string initialMarkup, CodeStyleOption2 preferredPlacementOption, bool placeSystemNamespaceFirst) { - var options = OptionsSet - ( - (new OptionKey2(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement), preferredPlacementOption), - (new OptionKey2(GenerationOptions.PlaceSystemNamespaceFirst, LanguageNames.CSharp), placeSystemNamespaceFirst) - ); + var options = new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferredUsingDirectivePlacement, preferredPlacementOption }, + { GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst }, + }; return TestInRegularAndScriptAsync(initialMarkup, expectedMarkup, options: options); } diff --git a/src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs b/src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs index 21e1903822d6992e089e4e04edbcaf1dc7c4fbc5..35d878c6d94600ae3c0f7a9e20006ed33b6dd540 100644 --- a/src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs +++ b/src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs @@ -23,12 +23,12 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider => (new CSharpUseConditionalExpressionForAssignmentDiagnosticAnalyzer(), new CSharpUseConditionalExpressionForAssignmentCodeFixProvider()); - private OptionsCollection PreferImplicitTypeAlways => OptionsSet - ( - (CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions2.TrueWithSilentEnforcement), - (CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions2.TrueWithSilentEnforcement), - (CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions2.TrueWithSilentEnforcement) - ); + private OptionsCollection PreferImplicitTypeAlways => new OptionsCollection(LanguageNames.CSharp) + { + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions2.TrueWithSilentEnforcement }, + { CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions2.TrueWithSilentEnforcement }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions2.TrueWithSilentEnforcement }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseConditionalExpression)] public async Task TestOnSimpleAssignment() diff --git a/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForAccessorsAnalyzerTests.cs b/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForAccessorsAnalyzerTests.cs index 3dc86e1dd8c6c4362efcc4c0b2ad103e3b8f9e33..76ab89f3de07bb0db0e388083ce613c639540f7c 100644 --- a/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForAccessorsAnalyzerTests.cs +++ b/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForAccessorsAnalyzerTests.cs @@ -23,22 +23,28 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider => (new UseExpressionBodyDiagnosticAnalyzer(), new UseExpressionBodyCodeFixProvider()); private OptionsCollection UseExpressionBody => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement }, + }; private OptionsCollection UseExpressionBodyIncludingPropertiesAndIndexers => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement }, + }; private OptionsCollection UseBlockBodyIncludingPropertiesAndIndexers => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)] public async Task TestUseExpressionBody1() @@ -305,10 +311,12 @@ int Goo public async Task TestUseBlockBody5() { var whenOnSingleLineWithNoneEnforcement = new CodeStyleOption2(ExpressionBodyPreference.WhenOnSingleLine, NotificationOption2.None); - var options = OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, whenOnSingleLineWithNoneEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, whenOnSingleLineWithNoneEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, whenOnSingleLineWithNoneEnforcement)); + var options = new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, whenOnSingleLineWithNoneEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, whenOnSingleLineWithNoneEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, whenOnSingleLineWithNoneEnforcement }, + }; await TestMissingInRegularAndScriptAsync( @"class C diff --git a/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForIndexersAnalyzerTests.cs b/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForIndexersAnalyzerTests.cs index 31f2e10fadf9df99b5634a059bed88449fcdf931..b7bfb73eb56365b24523710c5e93f1111e0ab5dc 100644 --- a/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForIndexersAnalyzerTests.cs +++ b/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForIndexersAnalyzerTests.cs @@ -21,19 +21,25 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider => (new UseExpressionBodyDiagnosticAnalyzer(), new UseExpressionBodyCodeFixProvider()); private OptionsCollection UseExpressionBody => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; private OptionsCollection UseBlockBody => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; private OptionsCollection UseBlockBodyExceptAccessor => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)] public async Task TestUseExpressionBody1() diff --git a/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForPropertiesAnalyzerTests.cs b/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForPropertiesAnalyzerTests.cs index 8d4523e33ab9e18a4da507d8a113a016152c34b3..867e003d87e55e718feebc8a5bf00a0bc37dca95 100644 --- a/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForPropertiesAnalyzerTests.cs +++ b/src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForPropertiesAnalyzerTests.cs @@ -22,19 +22,25 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider => (new UseExpressionBodyDiagnosticAnalyzer(), new UseExpressionBodyCodeFixProvider()); private OptionsCollection UseExpressionBody => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; private OptionsCollection UseBlockBody => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; private OptionsCollection UseBlockBodyExceptAccessor => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)] public async Task TestUseExpressionBody1() diff --git a/src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseExplicitTypeTests.cs b/src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseExplicitTypeTests.cs index 81d1b14437a589dde3b60adc40fc2f74d47785df..2c1904d4bf56e1f1e64fd262a74d5328318dd621 100644 --- a/src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseExplicitTypeTests.cs +++ b/src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseExplicitTypeTests.cs @@ -31,30 +31,45 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider private readonly CodeStyleOption2 offWithError = new CodeStyleOption2(false, NotificationOption2.Error); // specify all options explicitly to override defaults. - private OptionsCollection ExplicitTypeEverywhere() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo)); - - private OptionsCollection ExplicitTypeExceptWhereApparent() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo)); - - private OptionsCollection ExplicitTypeForBuiltInTypesOnly() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo)); - - private OptionsCollection ExplicitTypeEnforcements() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithWarning), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo)); - - private OptionsCollection ExplicitTypeSilentEnforcement() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithSilent), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent)); + private OptionsCollection ExplicitTypeEverywhere() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo }, + }; + + private OptionsCollection ExplicitTypeExceptWhereApparent() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo }, + }; + + private OptionsCollection ExplicitTypeForBuiltInTypesOnly() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo }, + }; + + private OptionsCollection ExplicitTypeEnforcements() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithWarning }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo }, + }; + + private OptionsCollection ExplicitTypeSilentEnforcement() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithSilent }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent }, + }; #region Error Cases diff --git a/src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseImplicitTypeTests.cs b/src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseImplicitTypeTests.cs index fdac9e235a5b3b4e6053d78dc7494c06a08dcd94..ea2175112925346e44e62b1335b57975b2ae404b 100644 --- a/src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseImplicitTypeTests.cs +++ b/src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseImplicitTypeTests.cs @@ -32,35 +32,53 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider private static readonly CodeStyleOption2 offWithError = new CodeStyleOption2(false, NotificationOption2.Error); // specify all options explicitly to override defaults. - internal OptionsCollection ImplicitTypeEverywhere() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo)); - - private OptionsCollection ImplicitTypeWhereApparent() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo)); - - private OptionsCollection ImplicitTypeWhereApparentAndForIntrinsics() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo)); - - internal OptionsCollection ImplicitTypeButKeepIntrinsics() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo)); - - private OptionsCollection ImplicitTypeEnforcements() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithWarning), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo)); - - private OptionsCollection ImplicitTypeSilentEnforcement() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent)); + internal OptionsCollection ImplicitTypeEverywhere() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo }, + }; + + private OptionsCollection ImplicitTypeWhereApparent() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo }, + }; + + private OptionsCollection ImplicitTypeWhereApparentAndForIntrinsics() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo }, + }; + + internal OptionsCollection ImplicitTypeButKeepIntrinsics() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + }; + + private OptionsCollection ImplicitTypeEnforcements() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithWarning }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo }, + }; + + private OptionsCollection ImplicitTypeSilentEnforcement() => + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithSilent }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent }, + }; [WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsUseImplicitType)] public async Task NotOnFieldDeclaration() diff --git a/src/Analyzers/CSharp/Tests/UseVarTestExtensions.cs b/src/Analyzers/CSharp/Tests/UseVarTestExtensions.cs index 7dc64fd459a66a35dac337b7866e35ecdecc03c1..ac57f3cba05048a59d87efa915a2edaff2a62234 100644 --- a/src/Analyzers/CSharp/Tests/UseVarTestExtensions.cs +++ b/src/Analyzers/CSharp/Tests/UseVarTestExtensions.cs @@ -26,63 +26,83 @@ internal static class UseVarTestExtensions private static readonly CodeStyleOption2 onWithError = new CodeStyleOption2(true, NotificationOption2.Error); public static OptionsCollection PreferExplicitTypeWithError(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithError), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithError)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithError }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithError }, + }; public static OptionsCollection PreferImplicitTypeWithError(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithError), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithError)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithError }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithError }, + }; public static OptionsCollection PreferExplicitTypeWithWarning(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithWarning), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithWarning), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithWarning)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithWarning }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithWarning }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithWarning }, + }; public static OptionsCollection PreferImplicitTypeWithWarning(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithWarning), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithWarning), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithWarning)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithWarning }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithWarning }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithWarning }, + }; public static OptionsCollection PreferExplicitTypeWithInfo(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo }, + }; public static OptionsCollection PreferImplicitTypeWithInfo(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo }, + }; public static OptionsCollection PreferExplicitTypeWithSilent(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithSilent), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithSilent }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent }, + }; public static OptionsCollection PreferImplicitTypeWithSilent(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithSilent }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent }, + }; public static OptionsCollection PreferExplicitTypeWithNone(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithNone), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithNone), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithNone)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, offWithNone }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithNone }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, offWithNone }, + }; public static OptionsCollection PreferImplicitTypeWithNone(this AbstractCodeActionOrUserDiagnosticTest test) - => test.OptionsSet( - test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithNone), - test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithNone), - test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithNone)); + => new OptionsCollection(test.GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithNone }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithNone }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithNone }, + }; } } diff --git a/src/Analyzers/CSharp/Tests/ValidateFormatString/ValidateFormatStringTests.cs b/src/Analyzers/CSharp/Tests/ValidateFormatString/ValidateFormatStringTests.cs index 7a848188b7fbd749ddc62cb6a2f5f48caa3cb696..8942cf07ef55b8576ee3da9556e8679c459a8629 100644 --- a/src/Analyzers/CSharp/Tests/ValidateFormatString/ValidateFormatStringTests.cs +++ b/src/Analyzers/CSharp/Tests/ValidateFormatString/ValidateFormatStringTests.cs @@ -21,6 +21,7 @@ public class ValidateFormatStringTests : AbstractCSharpDiagnosticProviderBasedUs internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace) => (new CSharpValidateFormatStringDiagnosticAnalyzer(), null); +#pragma warning disable CS0618 // Type or member is obsolete private OptionsCollection CSharpOptionOffVBOptionOn() => OptionsSet( (new OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.CSharp), false), (new OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.VisualBasic), true)); @@ -28,6 +29,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider private OptionsCollection CSharpOptionOnVBOptionOff() => OptionsSet( (new OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.CSharp), true), (new OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.VisualBasic), false)); +#pragma warning restore CS0618 // Type or member is obsolete [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)] public async Task OnePlaceholder() diff --git a/src/Analyzers/VisualBasic/Tests/ValidateFormatString/ValidateFormatStringTests.vb b/src/Analyzers/VisualBasic/Tests/ValidateFormatString/ValidateFormatStringTests.vb index 0ec88182cf5cf57eb4f0c7a625be75e051fca4d5..dad823ac9c1346c27d0fa4c87d04386aed498765 100644 --- a/src/Analyzers/VisualBasic/Tests/ValidateFormatString/ValidateFormatStringTests.vb +++ b/src/Analyzers/VisualBasic/Tests/ValidateFormatString/ValidateFormatStringTests.vb @@ -19,6 +19,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ValidateFormatStri Return (New VisualBasicValidateFormatStringDiagnosticAnalyzer, Nothing) End Function +#Disable Warning BC40000 ' Type or member is obsolete Private Function VBOptionOnCSharpOptionOff() As OptionsCollection Return OptionsSet( (New OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.CSharp), False), @@ -30,6 +31,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ValidateFormatStri (New OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.CSharp), True), (New OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.VisualBasic), False)) End Function +#Enable Warning BC40000 ' Type or member is obsolete Public Async Function ParamsObjectArray() As Task diff --git a/src/CodeStyle/CSharp/Tests/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.cs b/src/CodeStyle/CSharp/Tests/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.cs index aebefdaa7c794e9542b4637538bb63dd57feef84..c600109e7e60d4d1c82b4dca0e6b046095e5dc18 100644 --- a/src/CodeStyle/CSharp/Tests/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.cs +++ b/src/CodeStyle/CSharp/Tests/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. +using System; using Microsoft.CodeAnalysis.CodeStyle; using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.Options; @@ -32,23 +33,24 @@ internal static (OptionKey2, object) SingleOption(PerLanguageOption2 (new OptionKey2(option, language), codeStyle); internal OptionsCollection Option(Option2> option, T enabled, NotificationOption2 notification) - => OptionsSet(SingleOption(option, enabled, notification)); + => new OptionsCollection(GetLanguage()) { { option, enabled, notification } }; internal OptionsCollection Option(Option2> option, CodeStyleOption2 codeStyle) - => OptionsSet(SingleOption(option, codeStyle)); + => new OptionsCollection(GetLanguage()) { { option, codeStyle } }; internal OptionsCollection Option(PerLanguageOption2> option, T enabled, NotificationOption2 notification) - => OptionsSet(SingleOption(option, enabled, notification)); + => new OptionsCollection(GetLanguage()) { { option, enabled, notification } }; internal OptionsCollection Option(PerLanguageOption2> option, CodeStyleOption2 codeStyle) - => OptionsSet(SingleOption(option, codeStyle)); + => new OptionsCollection(GetLanguage()) { { option, codeStyle } }; internal OptionsCollection Option(Option2 option, T value) - => OptionsSet(SingleOption(option, value)); + => new OptionsCollection(GetLanguage()) { { option, value } }; internal OptionsCollection Option(PerLanguageOption2 option, T value) - => OptionsSet(SingleOption(option, value)); + => new OptionsCollection(GetLanguage()) { { option, value } }; + [Obsolete("Use a strongly-typed overload instead.")] internal OptionsCollection OptionsSet(params (OptionKey2 key, object value)[] options) => new OptionsCollection(LanguageNames.CSharp, options); } diff --git a/src/CodeStyle/VisualBasic/Tests/AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.vb b/src/CodeStyle/VisualBasic/Tests/AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.vb index c01065a7eaeadbb3ba3d2470dabbcc1563d072f6..62d6e82a513b113e86753b9db1d7ec7e33a89577 100644 --- a/src/CodeStyle/VisualBasic/Tests/AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.vb +++ b/src/CodeStyle/VisualBasic/Tests/AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.vb @@ -2,8 +2,8 @@ ' The .NET Foundation licenses this file to you under the MIT license. ' See the LICENSE file in the project root for more information. -Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions Imports Microsoft.CodeAnalysis.CodeStyle +Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions Imports Microsoft.CodeAnalysis.Options Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics @@ -38,29 +38,30 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics End Function Friend Function [Option](Of T)(optionParam As Option2(Of CodeStyleOption2(Of T)), enabled As T, notification As NotificationOption2) As OptionsCollection - Return OptionsSet(SingleOption(optionParam, enabled, notification)) + Return New OptionsCollection(GetLanguage()) From {{optionParam, enabled, notification}} End Function Friend Function [Option](Of T)(optionParam As Option2(Of CodeStyleOption2(Of T)), codeStyle As CodeStyleOption2(Of T)) As OptionsCollection - Return OptionsSet(SingleOption(optionParam, codeStyle)) + Return New OptionsCollection(GetLanguage()) From {{optionParam, codeStyle}} End Function Friend Function [Option](Of T)(optionParam As PerLanguageOption2(Of CodeStyleOption2(Of T)), enabled As T, notification As NotificationOption2) As OptionsCollection - Return OptionsSet(SingleOption(optionParam, enabled, notification)) + Return New OptionsCollection(GetLanguage()) From {{optionParam, enabled, notification}} End Function Friend Function [Option](Of T)(optionParam As PerLanguageOption2(Of CodeStyleOption2(Of T)), codeStyle As CodeStyleOption2(Of T)) As OptionsCollection - Return OptionsSet(SingleOption(optionParam, codeStyle)) + Return New OptionsCollection(GetLanguage()) From {{optionParam, codeStyle}} End Function Friend Function [Option](Of T)(optionParam As Option2(Of T), value As T) As OptionsCollection - Return OptionsSet(SingleOption(optionParam, value)) + Return New OptionsCollection(GetLanguage()) From {{optionParam, value}} End Function Friend Function [Option](Of T)(optionParam As PerLanguageOption2(Of T), value As T) As OptionsCollection - Return OptionsSet(SingleOption(optionParam, value)) + Return New OptionsCollection(GetLanguage()) From {{optionParam, value}} End Function + Friend Shared Function OptionsSet(ParamArray options As (OptionKey2, Object)()) As OptionsCollection Return New OptionsCollection(LanguageNames.VisualBasic, options) End Function diff --git a/src/EditorFeatures/CSharpTest/AddUsing/AddUsingTestsWithAddImportDiagnosticProvider.cs b/src/EditorFeatures/CSharpTest/AddUsing/AddUsingTestsWithAddImportDiagnosticProvider.cs index 6acacaf8aac637fcdd0b84f9fbadbe4e2ae33251..c17f98f5c2bcf3c0cb3e20fadcf51cb6479fdfd4 100644 --- a/src/EditorFeatures/CSharpTest/AddUsing/AddUsingTestsWithAddImportDiagnosticProvider.cs +++ b/src/EditorFeatures/CSharpTest/AddUsing/AddUsingTestsWithAddImportDiagnosticProvider.cs @@ -10,7 +10,6 @@ using Microsoft.CodeAnalysis.Editing; using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics; using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; -using Microsoft.CodeAnalysis.Options; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; using Xunit; @@ -30,7 +29,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider { return TestInRegularAndScriptAsync(initialMarkup, expected, index: index, options: new OptionsCollection(LanguageNames.CSharp) { - { new OptionKey2(GenerationOptions.PlaceSystemNamespaceFirst, LanguageNames.CSharp), systemSpecialCase } + { GenerationOptions.PlaceSystemNamespaceFirst, systemSpecialCase } }); } diff --git a/src/EditorFeatures/CSharpTest/ChangeSignature/ChangeSignature_Delegates.cs b/src/EditorFeatures/CSharpTest/ChangeSignature/ChangeSignature_Delegates.cs index c483df43396922082c3b8a0bf213ad0c7182061b..81e0e69906dc691c07203a4a36c55bc4ec48ad42 100644 --- a/src/EditorFeatures/CSharpTest/ChangeSignature/ChangeSignature_Delegates.cs +++ b/src/EditorFeatures/CSharpTest/ChangeSignature/ChangeSignature_Delegates.cs @@ -19,7 +19,7 @@ public partial class ChangeSignatureTests : AbstractChangeSignatureTests protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new ChangeSignatureCodeRefactoringProvider(); - protected override string GetLanguage() + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) diff --git a/src/EditorFeatures/CSharpTest/CodeActions/AbstractCSharpCodeActionTest.cs b/src/EditorFeatures/CSharpTest/CodeActions/AbstractCSharpCodeActionTest.cs index abcf85da0e3f99824a9c87fa9221ffd7e9095c01..3f907ebc6383c67992f823aa3fc555baa36e7418 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/AbstractCSharpCodeActionTest.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/AbstractCSharpCodeActionTest.cs @@ -12,7 +12,7 @@ public abstract class AbstractCSharpCodeActionTest : AbstractCodeActionTest { protected override ParseOptions GetScriptOptions() => Options.Script; - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); diff --git a/src/EditorFeatures/CSharpTest/CodeActions/EncapsulateField/EncapsulateFieldTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/EncapsulateField/EncapsulateFieldTests.cs index 436d00aab434e54b5726753f79dc7b1255854f82..e07f73e6f8bccb065a267cf6842e1f03144f37d1 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/EncapsulateField/EncapsulateFieldTests.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/EncapsulateField/EncapsulateFieldTests.cs @@ -12,7 +12,6 @@ using Microsoft.CodeAnalysis.EncapsulateField; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; -using Roslyn.Utilities; using Xunit; namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.EncapsulateField @@ -23,9 +22,11 @@ protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspa => new EncapsulateFieldRefactoringProvider(); private OptionsCollection AllOptionsOff => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; internal Task TestAllOptionsOffAsync( string initialMarkup, string expectedMarkup, @@ -34,10 +35,7 @@ protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspa int index = 0, OptionsCollection options = null) { options = options ?? new OptionsCollection(GetLanguage()); - foreach (var (key, value) in AllOptionsOff) - { - options.Add(key, value); - } + options.AddRange(AllOptionsOff); return TestAsync(initialMarkup, expectedMarkup, parseOptions, compilationOptions, index, options); @@ -209,9 +207,11 @@ void baz() } "; await TestInRegularAndScriptAsync(text, expected, - options: OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent))); + options: new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent }, + }); } [Fact, Trait(Traits.Feature, Traits.Features.EncapsulateField)] diff --git a/src/EditorFeatures/CSharpTest/CodeActions/IntroduceVariable/IntroduceVariableTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/IntroduceVariable/IntroduceVariableTests.cs index ff6b7258541ff138838ecf844d5d228d2ecacc5d..c88c3cd6d1ef0c3092a37f44752c855bf000c22b 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/IntroduceVariable/IntroduceVariableTests.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/IntroduceVariable/IntroduceVariableTests.cs @@ -29,11 +29,13 @@ protected override ImmutableArray MassageActions(ImmutableArray onWithInfo = new CodeStyleOption2(true, NotificationOption2.Suggestion); // specify all options explicitly to override defaults. - private OptionsCollection ImplicitTypingEverywhere() => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo)); + private OptionsCollection ImplicitTypingEverywhere() + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)] public async Task TestEmptySpan1() diff --git a/src/EditorFeatures/CSharpTest/CodeActions/MoveType/CSharpMoveTypeTestsBase.cs b/src/EditorFeatures/CSharpTest/CodeActions/MoveType/CSharpMoveTypeTestsBase.cs index 3ba29b01ead1b473c6ae861a22e7f439e1e089f9..471b14731ec230bf267db9ec2ec830a08f2383b0 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/MoveType/CSharpMoveTypeTestsBase.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/MoveType/CSharpMoveTypeTestsBase.cs @@ -12,7 +12,7 @@ public abstract class CSharpMoveTypeTestsBase : AbstractMoveTypeTest { protected override ParseOptions GetScriptOptions() => Options.Script; - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) { diff --git a/src/EditorFeatures/CSharpTest/CodeActions/ReplaceMethodWithProperty/ReplaceMethodWithPropertyTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/ReplaceMethodWithProperty/ReplaceMethodWithPropertyTests.cs index 234105de8d1f1afcc3b0fc922d18c2864e9be7f1..a3e0d1d7170a138a4f80a2fe9021e842444a69aa 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/ReplaceMethodWithProperty/ReplaceMethodWithPropertyTests.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/ReplaceMethodWithProperty/ReplaceMethodWithPropertyTests.cs @@ -1902,9 +1902,11 @@ int Goo e; } } -}", options: OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement))); +}", options: new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement }, + }); } [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsReplaceMethodWithProperty)] @@ -2368,20 +2370,32 @@ int Goo1 options: AllCodeStyleOff); } - private OptionsCollection AllCodeStyleOff => - OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection AllCodeStyleOff + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; - private OptionsCollection PreferExpressionBodiedAccessors => - OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection PreferExpressionBodiedAccessors + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; - private OptionsCollection PreferExpressionBodiedProperties => - OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement)); + private OptionsCollection PreferExpressionBodiedProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement }, + }; - private OptionsCollection PreferExpressionBodiedAccessorsAndProperties => - OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement)); + private OptionsCollection PreferExpressionBodiedAccessorsAndProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement }, + }; } } diff --git a/src/EditorFeatures/CSharpTest/CodeActions/ReplacePropertyWithMethods/ReplacePropertyWithMethodsTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/ReplacePropertyWithMethods/ReplacePropertyWithMethodsTests.cs index 23d102f5dae687f7b692796a9e38a7e59d5780f2..37791108aefadc408a98c5f00d002da228adfdbe 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/ReplacePropertyWithMethods/ReplacePropertyWithMethodsTests.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/ReplacePropertyWithMethods/ReplacePropertyWithMethodsTests.cs @@ -1844,6 +1844,6 @@ public static void Set(int value) } private OptionsCollection PreferExpressionBodiedMethods => - OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement)); + new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement } }; } } diff --git a/src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/CSharpSyncNamespaceTestsBase.cs b/src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/CSharpSyncNamespaceTestsBase.cs index 48aed8fe013375b4c819eca6530390800b281abd..d74a9c3fef5cbb50ce7b0708275f0e061a368c59 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/CSharpSyncNamespaceTestsBase.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/CSharpSyncNamespaceTestsBase.cs @@ -24,7 +24,7 @@ public abstract class CSharpSyncNamespaceTestsBase : AbstractCodeActionTest { protected override ParseOptions GetScriptOptions() => Options.Script; - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new CSharpSyncNamespaceCodeRefactoringProvider(); diff --git a/src/EditorFeatures/CSharpTest/CodeRefactorings/AddMissingImports/CSharpAddMissingImportsRefactoringProviderTests.cs b/src/EditorFeatures/CSharpTest/CodeRefactorings/AddMissingImports/CSharpAddMissingImportsRefactoringProviderTests.cs index 439d5ed34f959ee3adc7dede67045ad6005aa607..39d0fa9046be974db6a0fcce6273a17e9a3d9da6 100644 --- a/src/EditorFeatures/CSharpTest/CodeRefactorings/AddMissingImports/CSharpAddMissingImportsRefactoringProviderTests.cs +++ b/src/EditorFeatures/CSharpTest/CodeRefactorings/AddMissingImports/CSharpAddMissingImportsRefactoringProviderTests.cs @@ -8,6 +8,7 @@ using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.AddMissingImports; using Microsoft.CodeAnalysis.Editing; using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings; +using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces; using Microsoft.CodeAnalysis.PasteTracking; using Microsoft.CodeAnalysis.Test.Utilities; @@ -52,9 +53,12 @@ protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, T string initialMarkup, string expectedMarkup, bool placeSystemNamespaceFirst, bool separateImportDirectiveGroups) { - var options = OptionsSet( - SingleOption(GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst), - SingleOption(GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups)); + var options = + new OptionsCollection(GetLanguage()) + { + { GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst }, + { GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups }, + }; return TestInRegularAndScriptAsync(initialMarkup, expectedMarkup, options: options); } diff --git a/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs b/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs index 526754ef8a70fc452216d64a36749762124339e9..0e4552e86677f438013aac068232be879d205ab0 100644 --- a/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs +++ b/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs @@ -19,43 +19,55 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertAutoPropertyToFu public partial class ConvertAutoPropertyToFullPropertyTests : AbstractCSharpCodeActionTest { private OptionsCollection PreferExpressionBodiedAccessorsWhenPossible - => OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement)); + => new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement } }; private OptionsCollection PreferExpressionBodiedAccessorsWhenOnSingleLine - => OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement)); + => new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement } }; private OptionsCollection DoNotPreferExpressionBodiedAccessors - => OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + => new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement } }; private OptionsCollection DoNotPreferExpressionBodiedAccessorsAndPropertyOpenBraceOnSameLine - => OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpFormattingOptions2.NewLinesForBracesInProperties, false)); + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpFormattingOptions2.NewLinesForBracesInProperties, false }, + }; private OptionsCollection DoNotPreferExpressionBodiedAccessorsAndAccessorOpenBraceOnSameLine - => OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpFormattingOptions2.NewLinesForBracesInAccessors, false)); + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpFormattingOptions2.NewLinesForBracesInAccessors, false }, + }; private OptionsCollection PreferExpressionBodiesOnAccessorsAndMethods - => OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement)); + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + }; private OptionsCollection UseCustomFieldName - => OptionsSet( - SingleOption(NamingStyleOptions.NamingPreferences, CreateCustomFieldNamingStylePreference()), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + => new OptionsCollection(GetLanguage()) + { + { NamingStyleOptions.NamingPreferences, CreateCustomFieldNamingStylePreference() }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; private OptionsCollection UseUnderscorePrefixedFieldName - => OptionsSet( - SingleOption(NamingStyleOptions.NamingPreferences, CreateUnderscorePrefixedFieldNamingStylePreference()), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + => new OptionsCollection(GetLanguage()) + { + { NamingStyleOptions.NamingPreferences, CreateUnderscorePrefixedFieldNamingStylePreference() }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; private OptionsCollection UseCustomStaticFieldName - => OptionsSet( - SingleOption(NamingStyleOptions.NamingPreferences, CreateCustomStaticFieldNamingStylePreference()), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + => new OptionsCollection(GetLanguage()) + { + { NamingStyleOptions.NamingPreferences, CreateCustomStaticFieldNamingStylePreference() }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; private NamingStylePreferences CreateCustomFieldNamingStylePreference() { diff --git a/src/EditorFeatures/CSharpTest/ConvertForEachToFor/ConvertForEachToForTests.cs b/src/EditorFeatures/CSharpTest/ConvertForEachToFor/ConvertForEachToForTests.cs index be6cd8b4e705a6db4288f6d8a3e59d8d09956b49..626dfe66e6ba90e71cc7c8fffdb60306f834d9b5 100644 --- a/src/EditorFeatures/CSharpTest/ConvertForEachToFor/ConvertForEachToForTests.cs +++ b/src/EditorFeatures/CSharpTest/ConvertForEachToFor/ConvertForEachToForTests.cs @@ -24,10 +24,13 @@ public partial class ConvertForEachToForTests : AbstractCSharpCodeActionTest private readonly CodeStyleOption2 onWithSilent = new CodeStyleOption2(true, NotificationOption2.Silent); - private OptionsCollection ImplicitTypeEverywhere => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent)); + private OptionsCollection ImplicitTypeEverywhere + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithSilent }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent }, + }; [WorkItem(31621, "https://github.com/dotnet/roslyn/issues/31621")] [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertForEachToFor)] diff --git a/src/EditorFeatures/CSharpTest/ConvertForToForEach/ConvertForToForEachTests.cs b/src/EditorFeatures/CSharpTest/ConvertForToForEach/ConvertForToForEachTests.cs index a7c5400a5b5fb7534aafbef9218f11bf4c7561ca..90a965f0e9fbf503e76a83b927c3614c6e4bb86d 100644 --- a/src/EditorFeatures/CSharpTest/ConvertForToForEach/ConvertForToForEachTests.cs +++ b/src/EditorFeatures/CSharpTest/ConvertForToForEach/ConvertForToForEachTests.cs @@ -23,10 +23,13 @@ protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspa private readonly CodeStyleOption2 onWithSilent = new CodeStyleOption2(true, NotificationOption2.Silent); - private OptionsCollection ImplicitTypeEverywhere() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent)); + private OptionsCollection ImplicitTypeEverywhere() + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithSilent }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertForToForEach)] public async Task TestArray1() diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest.cs b/src/EditorFeatures/CSharpTest/Diagnostics/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest.cs index cab7012c7aca8f10f528c8fa0b3e5083efa33ee8..268a313baeeca8632e409e485c6ab7377b832d28 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest.cs @@ -12,7 +12,7 @@ public abstract partial class AbstractCSharpDiagnosticProviderBasedUserDiagnosti { protected override ParseOptions GetScriptOptions() => Options.Script; - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/BooleanCodeStyleOptionConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/BooleanCodeStyleOptionConfigurationTests.cs index aec2281a0fa93ae32267265e727b11737961ccca..6ab6872f3bb8c647593071a1662e130556af7c58 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/BooleanCodeStyleOptionConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/BooleanCodeStyleOptionConfigurationTests.cs @@ -21,7 +21,7 @@ public abstract partial class BooleanCodeStyleOptionConfigurationTests : Abstrac protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/EnumCodeStyleOptionConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/EnumCodeStyleOptionConfigurationTests.cs index c8c5c40dc81c46cefe687acf5a3a08c452068ec9..58ebcbc57ba33f2ff67d94ee201899358aac57fd 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/EnumCodeStyleOptionConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/EnumCodeStyleOptionConfigurationTests.cs @@ -21,7 +21,7 @@ public abstract partial class EnumCodeStyleOptionConfigurationTests : AbstractSu protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/MultipleCodeStyleOptionConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/MultipleCodeStyleOptionConfigurationTests.cs index 76c379195ed87084fa292800baf50d3c0f5c2f42..843f727f3fe6b0ab3b5cea68ab68df03e72bc551 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/MultipleCodeStyleOptionConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/MultipleCodeStyleOptionConfigurationTests.cs @@ -32,7 +32,7 @@ protected override ImmutableArray MassageActions(ImmutableArray TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/AllAnalyzersSeverityConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/AllAnalyzersSeverityConfigurationTests.cs index 649e16d2c4e8bf3a4f1d438c390378ab4636d6c1..632c93d367a7762369631e4609d04afb8bfb8012 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/AllAnalyzersSeverityConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/AllAnalyzersSeverityConfigurationTests.cs @@ -42,7 +42,7 @@ public override void Initialize(AnalysisContext context) protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CSharpCodeStyleOptionBasedSeverityConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CSharpCodeStyleOptionBasedSeverityConfigurationTests.cs index 637bd90bce71a82b5f049c4b5d86bdbbd142101c..dea8d75b1c16b1dedc500f5a9a7763af4bc5f931 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CSharpCodeStyleOptionBasedSeverityConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CSharpCodeStyleOptionBasedSeverityConfigurationTests.cs @@ -22,7 +22,7 @@ public abstract partial class CSharpCodeStyleOptionBasedSeverityConfigurationTes protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CategoryBasedSeverityConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CategoryBasedSeverityConfigurationTests.cs index 278dffbe76fb495fc00c3be4a71378930e62395f..fb12f10f452e2f9cbfd91024e95bee4cc65e0a9c 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CategoryBasedSeverityConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CategoryBasedSeverityConfigurationTests.cs @@ -42,7 +42,7 @@ public override void Initialize(AnalysisContext context) protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CodeStyleOptionBasedSeverityConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CodeStyleOptionBasedSeverityConfigurationTests.cs index 3b55c59628607fc5e4adf80211dc1f00402f40e5..66dc33daa1ecc221a9cf7b34eb54fcab1ee543a5 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CodeStyleOptionBasedSeverityConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CodeStyleOptionBasedSeverityConfigurationTests.cs @@ -21,7 +21,7 @@ public abstract partial class CodeStyleOptionBasedSeverityConfigurationTests : A protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs index 13a6362165fa7d04e8d5c7be97cc6c727ceac1aa..75ae83a3f42c473817a8f8e33c6ce70459610b99 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs @@ -42,7 +42,7 @@ public override void Initialize(AnalysisContext context) protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/MultipleCodeStyleOptionBasedSeverityConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/MultipleCodeStyleOptionBasedSeverityConfigurationTests.cs index 460b006a6fd6d62469914244db05447752c64804..89fe635114cff95ea13ed74a0473395e2412e56d 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/MultipleCodeStyleOptionBasedSeverityConfigurationTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/MultipleCodeStyleOptionBasedSeverityConfigurationTests.cs @@ -21,7 +21,7 @@ public abstract partial class MultipleCodeStyleOptionBasedSeverityConfigurationT protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override ParseOptions GetScriptOptions() => Options.Script; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.cs index b08a28fc5cfd8f05365f8d2ad5c30752bc6729be..2a38c09f55842d9180f6915d93009dbf2147785c 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.cs @@ -22,21 +22,33 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider private readonly CodeStyleOption2 onWithInfo = new CodeStyleOption2(true, NotificationOption2.Suggestion); private readonly CodeStyleOption2 offWithInfo = new CodeStyleOption2(false, NotificationOption2.Suggestion); - private OptionsCollection NoFrameworkType => OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, onWithInfo, GetLanguage())); - - private OptionsCollection FrameworkTypeEverywhere => OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, offWithInfo, GetLanguage())); - - private OptionsCollection FrameworkTypeInDeclaration => OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, onWithInfo, GetLanguage())); - - private OptionsCollection FrameworkTypeInMemberAccess => OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, offWithInfo, GetLanguage())); + private OptionsCollection NoFrameworkType + => new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Suggestion }, + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, onWithInfo }, + }; + + private OptionsCollection FrameworkTypeEverywhere + => new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false, NotificationOption2.Suggestion }, + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, offWithInfo }, + }; + + private OptionsCollection FrameworkTypeInDeclaration + => new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false, NotificationOption2.Suggestion }, + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, onWithInfo }, + }; + + private OptionsCollection FrameworkTypeInMemberAccess + => new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Suggestion }, + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, offWithInfo }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseFrameworkType)] public async Task NotWhenOptionsAreNotSet() diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs index 7a058978e8066c57851166305bd4d3325ad20b39..09aad9a11d48e5ba31c7c3e19a131e3afb3e6abe 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs @@ -17,7 +17,6 @@ using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.Diagnostics.CSharp; using Microsoft.CodeAnalysis.Editor.Shared.Utilities; -using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics; using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces; using Microsoft.CodeAnalysis.ErrorLogger; @@ -34,7 +33,7 @@ public abstract partial class CSharpSuppressionTests : AbstractSuppressionDiagno { protected override ParseOptions GetScriptOptions() => Options.Script; - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions); diff --git a/src/EditorFeatures/CSharpTest/EmbeddedLanguages/ValidateRegexStringTests.cs b/src/EditorFeatures/CSharpTest/EmbeddedLanguages/ValidateRegexStringTests.cs index eb38a05c4648d69a30673ba23e46809ad28fc714..e73b622add13b294f9e22276b29847342f54bdf9 100644 --- a/src/EditorFeatures/CSharpTest/EmbeddedLanguages/ValidateRegexStringTests.cs +++ b/src/EditorFeatures/CSharpTest/EmbeddedLanguages/ValidateRegexStringTests.cs @@ -2,7 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -using System.Collections.Generic; using System.Threading.Tasks; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.CSharp.EmbeddedLanguages; @@ -11,7 +10,6 @@ using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions; using Microsoft.CodeAnalysis.Features.EmbeddedLanguages.RegularExpressions; -using Microsoft.CodeAnalysis.Options; using Microsoft.CodeAnalysis.Test.Utilities; using Xunit; @@ -25,7 +23,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider private OptionsCollection OptionOn() { var optionsSet = new OptionsCollection(LanguageNames.CSharp); - optionsSet.Add(new OptionKey2(RegularExpressionsOptions.ReportInvalidRegexPatterns, LanguageNames.CSharp), true); + optionsSet.Add(RegularExpressionsOptions.ReportInvalidRegexPatterns, true); return optionsSet; } diff --git a/src/EditorFeatures/CSharpTest/GenerateVariable/GenerateVariableTests.cs b/src/EditorFeatures/CSharpTest/GenerateVariable/GenerateVariableTests.cs index 775a62326940f28d4a19066c9007e646c11404be..91e980540c9dd310b5825d86d8e28917c97f636f 100644 --- a/src/EditorFeatures/CSharpTest/GenerateVariable/GenerateVariableTests.cs +++ b/src/EditorFeatures/CSharpTest/GenerateVariable/GenerateVariableTests.cs @@ -36,17 +36,13 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider private readonly CodeStyleOption2 onWithInfo = new CodeStyleOption2(true, NotificationOption2.Suggestion); // specify all options explicitly to override defaults. - private OptionsCollection ImplicitTypingEverywhere() => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo)); - - internal IDictionary OptionSet(OptionKey2 option, object value) - { - var options = new Dictionary(); - options.Add(option, value); - return options; - } + private OptionsCollection ImplicitTypingEverywhere() + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo }, + }; protected override ImmutableArray MassageActions(ImmutableArray actions) => FlattenActions(actions); diff --git a/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs b/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs index 358d6d416bb5d263b9b3eb4657455531d4190b77..ff637756321f144db1d872a01e2b9ed6afcf14cb 100644 --- a/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs +++ b/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs @@ -15,7 +15,6 @@ using Microsoft.CodeAnalysis.ImplementType; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; -using Roslyn.Utilities; using Xunit; namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ImplementAbstractClass @@ -25,14 +24,16 @@ public partial class ImplementAbstractClassTests : AbstractCSharpDiagnosticProvi internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace) => (null, new CSharpImplementAbstractClassCodeFixProvider()); - private OptionsCollection AllOptionsOff => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection AllOptionsOff + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; internal Task TestAllOptionsOffAsync( string initialMarkup, @@ -42,10 +43,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider ParseOptions parseOptions = null) { options = options ?? new OptionsCollection(GetLanguage()); - foreach (var (key, value) in AllOptionsOff) - { - options.Add(key, value); - } + options.AddRange(AllOptionsOff); return TestInRegularAndScriptAsync( initialMarkup, @@ -1239,9 +1237,11 @@ public override int M throw new System.NotImplementedException(); } } -}", options: OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent))); +}", options: new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent }, + }); } [WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")] @@ -1276,9 +1276,11 @@ public override int M throw new System.NotImplementedException(); } } -}", options: OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent))); +}", options: new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent }, + }); } [WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")] @@ -1332,9 +1334,11 @@ class T : A throw new System.NotImplementedException(); } } -}", options: OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent))); +}", options: new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent }, + }); } [WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")] @@ -1369,9 +1373,11 @@ class T : A throw new System.NotImplementedException(); } } -}", options: OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent))); +}", options: new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent }, + }); } [WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")] @@ -1395,9 +1401,11 @@ class [|T|] : A class T : A { public override int M { get => throw new System.NotImplementedException(); } -}", options: OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.Silent), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent))); +}", options: new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.Silent }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent }, + }); } [WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")] diff --git a/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests_ThroughMember.cs b/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests_ThroughMember.cs index 209f6d79e123ad75f7415e867b6093ab9b8cff07..19bed65ccf11db7659a4744cdc389e02fcf0eca4 100644 --- a/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests_ThroughMember.cs +++ b/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests_ThroughMember.cs @@ -11,7 +11,6 @@ using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; -using Roslyn.Utilities; using Xunit; namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ImplementAbstractClass @@ -22,14 +21,16 @@ public sealed class ImplementAbstractClassTests_ThroughMemberTests : AbstractCSh internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace) => (null, new CSharpImplementAbstractClassCodeFixProvider()); - private OptionsCollection AllOptionsOff => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection AllOptionsOff + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; internal Task TestAllOptionsOffAsync( string initialMarkup, @@ -38,10 +39,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider ParseOptions parseOptions = null) { options ??= new OptionsCollection(GetLanguage()); - foreach (var (key, value) in AllOptionsOff) - { - options.Add(key, value); - } + options.AddRange(AllOptionsOff); return TestInRegularAndScriptAsync( initialMarkup, diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs index 8e24d0ba9f8a164e93f286ae9e9d5685281d6901..a1aa1321cf4ee2cc01f94a0a1d3e0426b630cfa3 100644 --- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs +++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs @@ -25,32 +25,38 @@ public partial class ImplementInterfaceTests : AbstractCSharpDiagnosticProviderB internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace) => (null, new CSharpImplementInterfaceCodeFixProvider()); - private OptionsCollection AllOptionsOff => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); - - private OptionsCollection AllOptionsOn => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement)); - - private OptionsCollection AccessorOptionsOn => - OptionsSet( - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection AllOptionsOff + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; + + private OptionsCollection AllOptionsOn + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + }; + + private OptionsCollection AccessorOptionsOn + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; private static readonly ParseOptions CSharp7_1 = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_1); diff --git a/src/EditorFeatures/CSharpTest/IntroduceVariable/IntroduceLocalForExpressionTests.cs b/src/EditorFeatures/CSharpTest/IntroduceVariable/IntroduceLocalForExpressionTests.cs index 8c5045d8874b0e414701b08a97ac0d438b52d65b..7fcfae1cb6cb69b7327aca2dbe142b746585cb11 100644 --- a/src/EditorFeatures/CSharpTest/IntroduceVariable/IntroduceLocalForExpressionTests.cs +++ b/src/EditorFeatures/CSharpTest/IntroduceVariable/IntroduceLocalForExpressionTests.cs @@ -8,6 +8,7 @@ using Microsoft.CodeAnalysis.CSharp.CodeStyle; using Microsoft.CodeAnalysis.CSharp.IntroduceVariable; using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings; +using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; using Xunit; @@ -326,9 +327,11 @@ void M() { var {|Rename:dateTime|} = new DateTime(); } -}", options: OptionsSet( - (CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions2.TrueWithSuggestionEnforcement), - (CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions2.TrueWithSuggestionEnforcement))); +}", options: new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions2.TrueWithSuggestionEnforcement }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions2.TrueWithSuggestionEnforcement }, + }); } [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceLocalForExpression)] diff --git a/src/EditorFeatures/CSharpTest/MoveToNamespace/MoveToNamespaceTests.cs b/src/EditorFeatures/CSharpTest/MoveToNamespace/MoveToNamespaceTests.cs index 459ce2b8e98a24d55a5ccdc02c62752b59b05eac..33b314d6bd0449a768d2e221adc2b2065c4ffff4 100644 --- a/src/EditorFeatures/CSharpTest/MoveToNamespace/MoveToNamespaceTests.cs +++ b/src/EditorFeatures/CSharpTest/MoveToNamespace/MoveToNamespaceTests.cs @@ -33,7 +33,7 @@ protected TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParame protected override ParseOptions GetScriptOptions() => Options.Script; - protected override string GetLanguage() => LanguageNames.CSharp; + protected internal override string GetLanguage() => LanguageNames.CSharp; public static IEnumerable SupportedKeywords => new[] { diff --git a/src/EditorFeatures/CSharpTest/SimplifyThisOrMe/SimplifyThisOrMeTests.cs b/src/EditorFeatures/CSharpTest/SimplifyThisOrMe/SimplifyThisOrMeTests.cs index 5e72fb41eb5da9d3d440800fa38590da1c89ce80..9a246e84e885dce95482f3f9d33b91a406a184e8 100644 --- a/src/EditorFeatures/CSharpTest/SimplifyThisOrMe/SimplifyThisOrMeTests.cs +++ b/src/EditorFeatures/CSharpTest/SimplifyThisOrMe/SimplifyThisOrMeTests.cs @@ -8,6 +8,7 @@ using Microsoft.CodeAnalysis.CSharp.SimplifyThisOrMe; using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics; +using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.Test.Utilities; using Roslyn.Test.Utilities; using Xunit; @@ -419,9 +420,12 @@ void N() "; - var options = OptionsSet( - SingleOption(CodeStyleOptions2.QualifyPropertyAccess, false, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.QualifyFieldAccess, true, NotificationOption2.Suggestion)); + var options = + new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.QualifyPropertyAccess, false, NotificationOption2.Suggestion }, + { CodeStyleOptions2.QualifyFieldAccess, true, NotificationOption2.Suggestion }, + }; await TestInRegularAndScriptAsync( initialMarkup: input, diff --git a/src/EditorFeatures/CSharpTest/SimplifyTypeNames/SimplifyTypeNamesTests.cs b/src/EditorFeatures/CSharpTest/SimplifyTypeNames/SimplifyTypeNamesTests.cs index 72a60310b1132386810ed48e0d75fa424a142d98..a7b99e8902fafcc2cdafcaa694d65f4380f943dd 100644 --- a/src/EditorFeatures/CSharpTest/SimplifyTypeNames/SimplifyTypeNamesTests.cs +++ b/src/EditorFeatures/CSharpTest/SimplifyTypeNames/SimplifyTypeNamesTests.cs @@ -4495,7 +4495,7 @@ public async Task TestCrefIdAtTopLevel() /// class Base { -}", OptionsSet(), IDEDiagnosticIds.PreferBuiltInOrFrameworkTypeDiagnosticId, DiagnosticSeverity.Hidden); +}", new OptionsCollection(GetLanguage()), IDEDiagnosticIds.PreferBuiltInOrFrameworkTypeDiagnosticId, DiagnosticSeverity.Hidden); } [WorkItem(40639, "https://github.com/dotnet/roslyn/issues/40639")] @@ -4509,7 +4509,7 @@ public async Task TestCrefIdAtNestedLevel() class Base { public void Foo(string s) { } -}", OptionsSet(), IDEDiagnosticIds.PreferBuiltInOrFrameworkTypeDiagnosticId, DiagnosticSeverity.Hidden); +}", new OptionsCollection(GetLanguage()), IDEDiagnosticIds.PreferBuiltInOrFrameworkTypeDiagnosticId, DiagnosticSeverity.Hidden); } [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsSimplifyTypeNames)] @@ -5848,7 +5848,7 @@ void Goo() { var v = nameof([|System|].Int32); } -}", OptionsSet(), IDEDiagnosticIds.SimplifyMemberAccessDiagnosticId, DiagnosticSeverity.Hidden); +}", new OptionsCollection(GetLanguage()), IDEDiagnosticIds.SimplifyMemberAccessDiagnosticId, DiagnosticSeverity.Hidden); } [WorkItem(11380, "https://github.com/dotnet/roslyn/issues/11380")] @@ -5869,26 +5869,41 @@ static void Main(string[] args) private async Task TestWithPredefinedTypeOptionsAsync(string code, string expected, int index = 0) => await TestInRegularAndScriptAsync(code, expected, index: index, options: PreferIntrinsicTypeEverywhere); - private OptionsCollection PreferIntrinsicTypeEverywhere => OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Error), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.onWithError, GetLanguage())); + private OptionsCollection PreferIntrinsicTypeEverywhere + => new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Error }, + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.onWithError }, + }; - private OptionsCollection PreferIntrinsicTypeEverywhereAsWarning => OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Warning), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.onWithWarning, GetLanguage())); + private OptionsCollection PreferIntrinsicTypeEverywhereAsWarning + => new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Warning }, + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.onWithWarning }, + }; - private OptionsCollection PreferIntrinsicTypeInDeclaration => OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Error), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.offWithSilent, GetLanguage())); + private OptionsCollection PreferIntrinsicTypeInDeclaration + => new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Error }, + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.offWithSilent }, + }; - private OptionsCollection PreferIntrinsicTypeInMemberAccess => OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, true, NotificationOption2.Error), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, this.offWithSilent, GetLanguage())); + private OptionsCollection PreferIntrinsicTypeInMemberAccess + => new OptionsCollection(GetLanguage()) + { + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, true, NotificationOption2.Error }, + { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, this.offWithSilent }, + }; - private OptionsCollection PreferImplicitTypeEverywhere => OptionsSet( - SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo), - SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo)); + private OptionsCollection PreferImplicitTypeEverywhere + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.VarElsewhere, onWithInfo }, + { CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo }, + { CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo }, + }; private readonly CodeStyleOption2 onWithSilent = new CodeStyleOption2(true, NotificationOption2.Silent); private readonly CodeStyleOption2 offWithSilent = new CodeStyleOption2(false, NotificationOption2.Silent); diff --git a/src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForAccessorsRefactoringTests.cs b/src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForAccessorsRefactoringTests.cs index 60769a50d4c7c39ad071174973145a9b6faad035..d9217dd5461bb870e70ba6ba1dd800dd1adf8afb 100644 --- a/src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForAccessorsRefactoringTests.cs +++ b/src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForAccessorsRefactoringTests.cs @@ -20,45 +20,61 @@ public class UseExpressionBodyForAccessorsRefactoringTests : AbstractCSharpCodeA protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new UseExpressionBodyCodeRefactoringProvider(); - private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; - private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2(ExpressionBodyPreference.Never, NotificationOption2.None))); + private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.None }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.None }, + }; - private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement)); + private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + }; - private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2(ExpressionBodyPreference.WhenPossible, NotificationOption2.None))); + private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.None }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.None }, + }; - private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement)); + private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + }; - private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2(ExpressionBodyPreference.Never, NotificationOption2.None)), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2(ExpressionBodyPreference.WhenPossible, NotificationOption2.None))); + private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.None }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.None }, + }; - private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; - private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2(ExpressionBodyPreference.Never, NotificationOption2.None)), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2(ExpressionBodyPreference.Never, NotificationOption2.None))); + private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.None }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.None }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)] public async Task TestUpdatePropertyIfPropertyWantsBlockAndAccessorWantsExpression() diff --git a/src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForPropertiesRefactoringTests.cs b/src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForPropertiesRefactoringTests.cs index 0b1b61af83b8b07543df10a381f1632185e8719e..747994e959219df62d8a3264b25a2a1edef91ed4 100644 --- a/src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForPropertiesRefactoringTests.cs +++ b/src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForPropertiesRefactoringTests.cs @@ -21,45 +21,61 @@ public class UseExpressionBodyForPropertiesRefactoringTests : AbstractCSharpCode protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new UseExpressionBodyCodeRefactoringProvider(); - private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; - private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2(ExpressionBodyPreference.Never, NotificationOption2.None))); + private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.None }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.None }, + }; - private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement)); + private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + }; - private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2(ExpressionBodyPreference.WhenPossible, NotificationOption2.None))); + private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.None }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.None }, + }; - private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement)); + private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement }, + }; - private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2(ExpressionBodyPreference.Never, NotificationOption2.None)), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2(ExpressionBodyPreference.WhenPossible, NotificationOption2.None))); + private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.None }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.None }, + }; - private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement)); + private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement }, + }; - private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic => - OptionsSet( - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2(ExpressionBodyPreference.Never, NotificationOption2.None)), - this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2(ExpressionBodyPreference.Never, NotificationOption2.None))); + private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic + => new OptionsCollection(GetLanguage()) + { + { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.None }, + { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.None }, + }; [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)] public async Task TestNotOfferedIfUserPrefersExpressionBodiesAndInBlockBody() diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest.cs b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest.cs index 460bf269c741de9ce260655cd02ae5b74a81762b..a92f42d5d54bbc1c005ee1407bdf30df3ce4b7c9 100644 --- a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest.cs +++ b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest.cs @@ -90,7 +90,7 @@ public TestParameters WithIncludeDiagnosticsOutsideSelection(bool includeDiagnos private const string AutoGeneratedAnalyzerConfigHeader = @"# auto-generated .editorconfig for code style options"; - protected abstract string GetLanguage(); + protected internal abstract string GetLanguage(); protected ParenthesesOptionsProvider ParenthesesOptionsProvider => new ParenthesesOptionsProvider(this.GetLanguage()); protected abstract ParseOptions GetScriptOptions(); diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest_OptionHelpers.cs b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest_OptionHelpers.cs index 64214143de02f47c965977eee55f1fd61daa15a6..3f011e4b6f816f441dc1a2b3e1d378015099bbed 100644 --- a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest_OptionHelpers.cs +++ b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest_OptionHelpers.cs @@ -4,6 +4,7 @@ #nullable enable +using System; using Microsoft.CodeAnalysis.CodeStyle; using Microsoft.CodeAnalysis.Options; @@ -33,26 +34,28 @@ internal static (OptionKey2, object) SingleOption(PerLanguageOption2 (new OptionKey2(option, language), codeStyle); internal OptionsCollection Option(Option2> option, T enabled, NotificationOption2 notification) - => OptionsSet(SingleOption(option, enabled, notification)); + => new OptionsCollection(GetLanguage()) { { option, enabled, notification } }; internal OptionsCollection Option(Option2> option, CodeStyleOption2 codeStyle) - => OptionsSet(SingleOption(option, codeStyle)); + => new OptionsCollection(GetLanguage()) { { option, codeStyle } }; internal OptionsCollection Option(PerLanguageOption2> option, T enabled, NotificationOption2 notification) - => OptionsSet(SingleOption(option, enabled, notification)); + => new OptionsCollection(GetLanguage()) { { option, enabled, notification } }; internal OptionsCollection Option(Option2 option, T value) - => OptionsSet(SingleOption(option, value)); + => new OptionsCollection(GetLanguage()) { { option, value } }; internal OptionsCollection Option(PerLanguageOption2 option, T value) - => OptionsSet(SingleOption(option, value)); + => new OptionsCollection(GetLanguage()) { { option, value } }; internal OptionsCollection Option(PerLanguageOption2> option, CodeStyleOption2 codeStyle) - => OptionsSet(SingleOption(option, codeStyle)); + => new OptionsCollection(GetLanguage()) { { option, codeStyle } }; + [Obsolete("Use a strongly-typed overload instead.")] internal OptionsCollection OptionsSet(OptionKey2 option, object value) => OptionsSet((option, value)); + [Obsolete("Use a strongly-typed overload instead.")] internal OptionsCollection OptionsSet(params (OptionKey2 key, object? value)[] options) => new OptionsCollection(GetLanguage(), options: options); } diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/OptionsCollection.cs b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/OptionsCollection.cs index 653eaf93e42559d9f162b44a5cef70b791eb5623..7568f117066fa20ea43c1434b7d72f6d2770d091 100644 --- a/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/OptionsCollection.cs +++ b/src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/OptionsCollection.cs @@ -4,10 +4,12 @@ #nullable enable +using System; using System.Collections; using System.Collections.Generic; using Microsoft.CodeAnalysis.CodeStyle; using Microsoft.CodeAnalysis.Options; +using Roslyn.Utilities; namespace Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions { @@ -17,16 +19,20 @@ internal sealed class OptionsCollection : IReadOnlyCollection _options.Count; @@ -46,9 +52,18 @@ public void Add(PerLanguageOption2> option, T value) public void Add(PerLanguageOption2> option, T value, NotificationOption2 notification) => _options.Add(new OptionKey2(option, _languageName), new CodeStyleOption2(value, notification)); + [Obsolete("Use a strongly-typed overload instead.")] public void Add(OptionKey2 optionKey, T value) => _options.Add(optionKey, value); + public void AddRange(OptionsCollection options) + { + foreach (var (key, value) in options) + { + _options.Add(key, value); + } + } + public IEnumerator> GetEnumerator() => _options.GetEnumerator(); diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/ParenthesesOptionsProvider.cs b/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/ParenthesesOptionsProvider.cs index 8fd5aaf85e381e64b2ccfe58dfb142c1acd6ecad..fa51d6ec4070995290f2a2264787c98db687dd09 100644 --- a/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/ParenthesesOptionsProvider.cs +++ b/src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/ParenthesesOptionsProvider.cs @@ -47,28 +47,61 @@ private IEnumerable>> => GetAllExceptOtherParenthesesOptions().Concat(CodeStyleOptions2.OtherParentheses); internal OptionsCollection IgnoreAllParentheses - => OptionsSet(GetAllParenthesesOptions().Select( - o => SingleOption(o, IgnorePreference)).ToArray()); + { + get + { + var optionsCollection = new OptionsCollection(_language); + foreach (var option in GetAllParenthesesOptions()) + { + optionsCollection.Add(option, IgnorePreference); + } + + return optionsCollection; + } + } internal OptionsCollection RemoveAllUnnecessaryParentheses - => OptionsSet(GetAllParenthesesOptions().Select( - o => SingleOption(o, RemoveIfUnnecessaryPreference)).ToArray()); + { + get + { + var optionsCollection = new OptionsCollection(_language); + foreach (var option in GetAllParenthesesOptions()) + { + optionsCollection.Add(option, RemoveIfUnnecessaryPreference); + } + + return optionsCollection; + } + } internal OptionsCollection RequireAllParenthesesForClarity - => OptionsSet(GetAllExceptOtherParenthesesOptions() - .Select(o => SingleOption(o, RequireForPrecedenceClarityPreference)) - .Concat(SingleOption(CodeStyleOptions2.OtherParentheses, RemoveIfUnnecessaryPreference)).ToArray()); + { + get + { + var optionsCollection = new OptionsCollection(_language); + foreach (var option in GetAllExceptOtherParenthesesOptions()) + { + optionsCollection.Add(option, RequireForPrecedenceClarityPreference); + } + + optionsCollection.Add(CodeStyleOptions2.OtherParentheses, RemoveIfUnnecessaryPreference); + return optionsCollection; + } + } private OptionsCollection GetSingleRequireOption(PerLanguageOption2> option) - => OptionsSet(GetAllParenthesesOptions() - .Where(o => o != option) - .Select(o => SingleOption(o, RemoveIfUnnecessaryPreference)) - .Concat(SingleOption(option, RequireForPrecedenceClarityPreference)).ToArray()); - - private (OptionKey2, object) SingleOption(PerLanguageOption2> option, CodeStyleOption2 codeStyle) - => (new OptionKey2(option, _language), codeStyle); - - internal OptionsCollection OptionsSet(params (OptionKey2 key, object value)[] options) - => new OptionsCollection(_language, options); + { + var optionsCollection = new OptionsCollection(_language); + foreach (var o in GetAllParenthesesOptions()) + { + if (o != option) + { + optionsCollection.Add(o, RemoveIfUnnecessaryPreference); + } + } + + optionsCollection.Add(option, RequireForPrecedenceClarityPreference); + return optionsCollection; + } } } diff --git a/src/EditorFeatures/DiagnosticsTestUtilities/NamingStyles/NamingStylesTestOptionSets.cs b/src/EditorFeatures/DiagnosticsTestUtilities/NamingStyles/NamingStylesTestOptionSets.cs index 35edce2fe8b1c08f9256495fc34bbf1660dd1524..132d83e9307fee15d01fc0fe78e2fb6a5cb97521 100644 --- a/src/EditorFeatures/DiagnosticsTestUtilities/NamingStyles/NamingStylesTestOptionSets.cs +++ b/src/EditorFeatures/DiagnosticsTestUtilities/NamingStyles/NamingStylesTestOptionSets.cs @@ -31,74 +31,74 @@ internal OptionsCollection MergeStyles(OptionsCollection first, OptionsCollectio { var firstPreferences = (NamingStylePreferences)first.First().Value; var secondPreferences = (NamingStylePreferences)second.First().Value; - return Options(_optionKey, new NamingStylePreferences( + return new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, new NamingStylePreferences( firstPreferences.SymbolSpecifications.AddRange(secondPreferences.SymbolSpecifications), firstPreferences.NamingStyles.AddRange(secondPreferences.NamingStyles), - firstPreferences.NamingRules.AddRange(secondPreferences.NamingRules))); + firstPreferences.NamingRules.AddRange(secondPreferences.NamingRules)) } }; } internal OptionsCollection ClassNamesArePascalCase => - Options(_optionKey, ClassNamesArePascalCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ClassNamesArePascalCaseOption() } }; internal OptionsCollection FieldNamesAreCamelCase => - Options(_optionKey, FieldNamesAreCamelCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, FieldNamesAreCamelCaseOption() } }; internal OptionsCollection FieldNamesAreCamelCaseWithUnderscorePrefix => - Options(_optionKey, FieldNamesAreCamelCaseWithUnderscorePrefixOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, FieldNamesAreCamelCaseWithUnderscorePrefixOption() } }; internal OptionsCollection FieldNamesAreCamelCaseWithFieldUnderscorePrefix => - Options(_optionKey, FieldNamesAreCamelCaseWithFieldUnderscorePrefixOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, FieldNamesAreCamelCaseWithFieldUnderscorePrefixOption() } }; internal OptionsCollection FieldNamesAreCamelCaseWithFieldUnderscorePrefixAndUnderscoreEndSuffix => - Options(_optionKey, FieldNamesAreCamelCaseWithFieldUnderscorePrefixAndUnderscoreEndSuffixOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, FieldNamesAreCamelCaseWithFieldUnderscorePrefixAndUnderscoreEndSuffixOption() } }; internal OptionsCollection MethodNamesArePascalCase => - Options(_optionKey, MethodNamesArePascalCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, MethodNamesArePascalCaseOption() } }; internal OptionsCollection MethodNamesAreCamelCase => - Options(_optionKey, MethodNamesAreCamelCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, MethodNamesAreCamelCaseOption() } }; internal OptionsCollection ParameterNamesAreCamelCase => - Options(_optionKey, ParameterNamesAreCamelCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ParameterNamesAreCamelCaseOption() } }; internal OptionsCollection ParameterNamesAreCamelCaseWithPUnderscorePrefix => - Options(_optionKey, ParameterNamesAreCamelCaseWithPUnderscorePrefixOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ParameterNamesAreCamelCaseWithPUnderscorePrefixOption() } }; internal OptionsCollection ParameterNamesAreCamelCaseWithPUnderscorePrefixAndUnderscoreEndSuffix => - Options(_optionKey, ParameterNamesAreCamelCaseWithPUnderscorePrefixAndUnderscoreEndSuffixOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ParameterNamesAreCamelCaseWithPUnderscorePrefixAndUnderscoreEndSuffixOption() } }; internal OptionsCollection LocalNamesAreCamelCase => - Options(_optionKey, LocalNamesAreCamelCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, LocalNamesAreCamelCaseOption() } }; internal OptionsCollection LocalFunctionNamesAreCamelCase => - Options(_optionKey, LocalFunctionNamesAreCamelCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, LocalFunctionNamesAreCamelCaseOption() } }; internal OptionsCollection PropertyNamesArePascalCase => - Options(_optionKey, PropertyNamesArePascalCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, PropertyNamesArePascalCaseOption() } }; internal OptionsCollection InterfaceNamesStartWithI => - Options(_optionKey, InterfaceNamesStartWithIOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, InterfaceNamesStartWithIOption() } }; internal OptionsCollection TypeParameterNamesStartWithT => - Options(_optionKey, TypeParameterNamesStartWithTOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, TypeParameterNamesStartWithTOption() } }; internal OptionsCollection ConstantsAreUpperCase => - Options(_optionKey, ConstantsAreUpperCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ConstantsAreUpperCaseOption() } }; internal OptionsCollection LocalsAreCamelCaseConstantsAreUpperCase => - Options(_optionKey, LocalsAreCamelCaseConstantsAreUpperCaseOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, LocalsAreCamelCaseConstantsAreUpperCaseOption() } }; internal OptionsCollection AsyncFunctionNamesEndWithAsync => - Options(_optionKey, AsyncFunctionNamesEndWithAsyncOption()); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, AsyncFunctionNamesEndWithAsyncOption() } }; internal OptionsCollection MethodNamesWithAccessibilityArePascalCase(ImmutableArray accessibilities) => - Options(_optionKey, MethodNamesArePascalCaseOption(accessibilities)); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, MethodNamesArePascalCaseOption(accessibilities) } }; internal OptionsCollection SymbolKindsArePascalCase(ImmutableArray symbolKinds) => - Options(_optionKey, SymbolKindsArePascalCaseOption(symbolKinds)); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, SymbolKindsArePascalCaseOption(symbolKinds) } }; internal OptionsCollection SymbolKindsArePascalCaseEmpty() => - Options(_optionKey, SymbolKindsArePascalCaseOption(ImmutableArray.Empty)); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, SymbolKindsArePascalCaseOption(ImmutableArray.Empty) } }; internal OptionsCollection SymbolKindsArePascalCase(object symbolOrTypeKind) => SymbolKindsArePascalCase(ImmutableArray.Create(ToSymbolKindOrTypeKind(symbolOrTypeKind))); @@ -122,13 +122,7 @@ internal static SymbolSpecification.SymbolKindOrTypeKind ToSymbolKindOrTypeKind( } internal OptionsCollection AccessibilitiesArePascalCase(ImmutableArray accessibilities) => - Options(_optionKey, AccessibilitiesArePascalCaseOption(accessibilities)); - - private OptionsCollection Options(OptionKey2 option, object value) - => Options(new[] { (option, value) }); - - private OptionsCollection Options(params (OptionKey2 key, object value)[] options) - => new OptionsCollection(_languageName, options); + new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, AccessibilitiesArePascalCaseOption(accessibilities) } }; private static NamingStylePreferences ClassNamesArePascalCaseOption() { diff --git a/src/EditorFeatures/Test/LinkedFiles/LinkedFileDiffMergingEditorTests.cs b/src/EditorFeatures/Test/LinkedFiles/LinkedFileDiffMergingEditorTests.cs index 945ec388d2be4c1964e820a0635684d23043b7b7..af84fc611b9139b51e5b58e8410cc351c33161fe 100644 --- a/src/EditorFeatures/Test/LinkedFiles/LinkedFileDiffMergingEditorTests.cs +++ b/src/EditorFeatures/Test/LinkedFiles/LinkedFileDiffMergingEditorTests.cs @@ -10,7 +10,6 @@ using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions; using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces; using Roslyn.Test.Utilities; -using Roslyn.Utilities; using Xunit; namespace Microsoft.CodeAnalysis.Editor.UnitTests.LinkedFiles @@ -26,7 +25,7 @@ public partial class LinkedFileDiffMergingEditorTests : AbstractCodeActionTest "; - protected override string GetLanguage() + protected internal override string GetLanguage() => LanguageNames.CSharp; protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) diff --git a/src/EditorFeatures/VisualBasicTest/CodeRefactorings/AddMissingImports/VisualBasicAddMissingImportsRefactoringProviderTests.vb b/src/EditorFeatures/VisualBasicTest/CodeRefactorings/AddMissingImports/VisualBasicAddMissingImportsRefactoringProviderTests.vb index c1e2b9f0480fc456eb42201fc282edda4bce7474..c45d8d3387b3d6a72be37dba8f8c12e4ad346980 100644 --- a/src/EditorFeatures/VisualBasicTest/CodeRefactorings/AddMissingImports/VisualBasicAddMissingImportsRefactoringProviderTests.vb +++ b/src/EditorFeatures/VisualBasicTest/CodeRefactorings/AddMissingImports/VisualBasicAddMissingImportsRefactoringProviderTests.vb @@ -4,6 +4,7 @@ Imports Microsoft.CodeAnalysis.CodeRefactorings Imports Microsoft.CodeAnalysis.Editing +Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings Imports Microsoft.CodeAnalysis.PasteTracking @@ -44,9 +45,10 @@ Namespace Microsoft.CodeAnalysis.AddMissingImports initialMarkup As String, expectedMarkup As String, placeSystemNamespaceFirst As Boolean, separateImportDirectiveGroups As Boolean) As Task - Dim options = OptionsSet( - SingleOption(GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst), - SingleOption(GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups)) + Dim options = New OptionsCollection(GetLanguage()) From { + {GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst}, + {GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups} + } Return TestInRegularAndScriptAsync(initialMarkup, expectedMarkup, options:=options) End Function diff --git a/src/EditorFeatures/VisualBasicTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.vb b/src/EditorFeatures/VisualBasicTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.vb index f9b3cec7f5389e518340c1e5a9788edb62e8bf38..5e7fecb3beb7d8ccccee5bbaa869c0f0379d65db 100644 --- a/src/EditorFeatures/VisualBasicTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.vb +++ b/src/EditorFeatures/VisualBasicTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.vb @@ -25,33 +25,37 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.Prefer Private ReadOnly Property NoFrameworkType As OptionsCollection Get - Return OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithInfo, GetLanguage())) + Return New OptionsCollection(GetLanguage()) From { + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Suggestion}, + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithInfo} + } End Get End Property Private ReadOnly Property FrameworkTypeEverywhere As OptionsCollection Get - Return OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, False, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.offWithInfo, GetLanguage())) + Return New OptionsCollection(GetLanguage()) From { + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, False, NotificationOption2.Suggestion}, + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.offWithInfo} + } End Get End Property Private ReadOnly Property FrameworkTypeInDeclaration As OptionsCollection Get - Return OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, False, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithInfo, GetLanguage())) + Return New OptionsCollection(GetLanguage()) From { + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, False, NotificationOption2.Suggestion}, + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithInfo} + } End Get End Property Private ReadOnly Property FrameworkTypeInMemberAccess As OptionsCollection Get - Return OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, False, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, Me.onWithInfo, GetLanguage())) + Return New OptionsCollection(GetLanguage()) From { + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, False, NotificationOption2.Suggestion}, + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, Me.onWithInfo} + } End Get End Property diff --git a/src/EditorFeatures/VisualBasicTest/EmbeddedLanguages/ValidateRegexStringTests.vb b/src/EditorFeatures/VisualBasicTest/EmbeddedLanguages/ValidateRegexStringTests.vb index d9b0812d0587a5101deeae713f80c2c126c8eaff..9f11f82be3c7c55ea7ddfe25dfa0ccbc27e904a3 100644 --- a/src/EditorFeatures/VisualBasicTest/EmbeddedLanguages/ValidateRegexStringTests.vb +++ b/src/EditorFeatures/VisualBasicTest/EmbeddedLanguages/ValidateRegexStringTests.vb @@ -8,7 +8,6 @@ Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics Imports Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions Imports Microsoft.CodeAnalysis.Features.EmbeddedLanguages.RegularExpressions -Imports Microsoft.CodeAnalysis.Options Imports Microsoft.CodeAnalysis.VisualBasic.Features.EmbeddedLanguages Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EmbeddedLanguages @@ -21,7 +20,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EmbeddedLanguages Private Function OptionOn() As OptionsCollection Dim values = New OptionsCollection(LanguageNames.VisualBasic) - values.Add(New OptionKey2(RegularExpressionsOptions.ReportInvalidRegexPatterns, LanguageNames.VisualBasic), True) + values.Add(RegularExpressionsOptions.ReportInvalidRegexPatterns, True) Return values End Function diff --git a/src/EditorFeatures/VisualBasicTest/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.vb b/src/EditorFeatures/VisualBasicTest/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.vb index 4d85d91ddc0e9da5707b4102df6f51d22b04baad..c32dc36ebddfd63c441f5c16a947d5628d3ae1b8 100644 --- a/src/EditorFeatures/VisualBasicTest/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.vb +++ b/src/EditorFeatures/VisualBasicTest/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.vb @@ -6,7 +6,6 @@ Imports Microsoft.CodeAnalysis.CodeRefactorings Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings Imports Microsoft.CodeAnalysis.GenerateConstructorFromMembers -Imports Microsoft.CodeAnalysis.Options Imports Microsoft.CodeAnalysis.PickMembers Imports Microsoft.CodeAnalysis.VisualBasic.GenerateConstructorFromMembers @@ -368,7 +367,7 @@ End Class", chosenSymbols:={"i"}) Public Async Function TestWithDialog1WithNullCheck() As Task Dim options = New OptionsCollection(LanguageNames.VisualBasic) - options.Add(New OptionKey2(GenerateConstructorFromMembersOptions.AddNullChecks, language:=LanguageNames.VisualBasic), True) + options.Add(GenerateConstructorFromMembersOptions.AddNullChecks, True) Dim parameters = New TestParameters() parameters = parameters.WithOptions(options) diff --git a/src/EditorFeatures/VisualBasicTest/SimplifyThisOrMe/SimplifyThisOrMeTests.vb b/src/EditorFeatures/VisualBasicTest/SimplifyThisOrMe/SimplifyThisOrMeTests.vb index 89891bdf71fa982ab3d1abd9033284448dc6cbf8..3a34646627282f53a82d7b6cb1295771f360a7b7 100644 --- a/src/EditorFeatures/VisualBasicTest/SimplifyThisOrMe/SimplifyThisOrMeTests.vb +++ b/src/EditorFeatures/VisualBasicTest/SimplifyThisOrMe/SimplifyThisOrMeTests.vb @@ -5,13 +5,9 @@ Imports Microsoft.CodeAnalysis.CodeFixes Imports Microsoft.CodeAnalysis.CodeStyle Imports Microsoft.CodeAnalysis.Diagnostics -Imports Microsoft.CodeAnalysis.Editor.UnitTests.Extensions -Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces +Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics -Imports Microsoft.CodeAnalysis.Options -Imports Microsoft.CodeAnalysis.VisualBasic.CodeFixes.SimplifyTypeNames Imports Microsoft.CodeAnalysis.VisualBasic.SimplifyThisOrMe -Imports Microsoft.CodeAnalysis.VisualBasic.SimplifyTypeNames Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.SimplifyThisOrMe Partial Public Class SimplifyThisOrMeTests @@ -66,7 +62,7 @@ End Class") Public Async Function TestAppropriateDiagnosticOnMissingQualifier() As Task Await TestDiagnosticInfoAsync( "Class C : Property SomeProperty As Integer : Sub M() : [|Me|].SomeProperty = 1 : End Sub : End Class", - options:=OptionsSet(SingleOption(CodeStyleOptions2.QualifyPropertyAccess, False, NotificationOption2.Error)), + options:=New OptionsCollection(GetLanguage()) From {{CodeStyleOptions2.QualifyPropertyAccess, False, NotificationOption2.Error}}, diagnosticId:=IDEDiagnosticIds.RemoveQualificationDiagnosticId, diagnosticSeverity:=DiagnosticSeverity.Error) End Function @@ -344,9 +340,10 @@ End Class]]> .ToString() - Dim options = OptionsSet( - SingleOption(CodeStyleOptions2.QualifyPropertyAccess, False, NotificationOption2.Suggestion), - SingleOption(CodeStyleOptions2.QualifyFieldAccess, True, NotificationOption2.Suggestion)) + Dim options = New OptionsCollection(GetLanguage()) From { + {CodeStyleOptions2.QualifyPropertyAccess, False, NotificationOption2.Suggestion}, + {CodeStyleOptions2.QualifyFieldAccess, True, NotificationOption2.Suggestion} + } Await TestInRegularAndScriptAsync( initialMarkup:=input, expectedMarkup:=expected, diff --git a/src/EditorFeatures/VisualBasicTest/SimplifyTypeNames/SimplifyTypeNamesTests.vb b/src/EditorFeatures/VisualBasicTest/SimplifyTypeNames/SimplifyTypeNamesTests.vb index e2f158f255cdd7555ecb85635b5fc390eefd0813..31ce3cd89eeb248bac53fa9369bff43c9edab169 100644 --- a/src/EditorFeatures/VisualBasicTest/SimplifyTypeNames/SimplifyTypeNamesTests.vb +++ b/src/EditorFeatures/VisualBasicTest/SimplifyTypeNames/SimplifyTypeNamesTests.vb @@ -24,25 +24,28 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.SimplifyTypeNames Private Function PreferIntrinsicPredefinedTypeEverywhere() As OptionsCollection Dim language = GetLanguage() - Return OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Error), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithError, language)) + Return New OptionsCollection(language) From { + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Error}, + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithError} + } End Function Private Function PreferIntrinsicPredefinedTypeInDeclaration() As OptionsCollection Dim language = GetLanguage() - Return OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Error), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.offWithSilent, language)) + Return New OptionsCollection(language) From { + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Error}, + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.offWithSilent} + } End Function Private Function PreferIntrinsicTypeInMemberAccess() As OptionsCollection Dim language = GetLanguage() - Return OptionsSet( - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, True, NotificationOption2.Error), - SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, Me.offWithSilent, language)) + Return New OptionsCollection(language) From { + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, True, NotificationOption2.Error}, + {CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, Me.offWithSilent} + } End Function Private ReadOnly onWithError As New CodeStyleOption2(Of Boolean)(True, NotificationOption2.Error) diff --git a/src/VisualStudio/CSharp/Test/EventHookup/EventHookupCommandHandlerTests.cs b/src/VisualStudio/CSharp/Test/EventHookup/EventHookupCommandHandlerTests.cs index 4738d4144397148a63f8f2893344819209fb1163..7425ea64999af2d0d3af0492e77a39ce2b71580a 100644 --- a/src/VisualStudio/CSharp/Test/EventHookup/EventHookupCommandHandlerTests.cs +++ b/src/VisualStudio/CSharp/Test/EventHookup/EventHookupCommandHandlerTests.cs @@ -1023,6 +1023,6 @@ private void C_MyEvent() } private OptionsCollection QualifyMethodAccessWithNotification(NotificationOption2 notification) - => new OptionsCollection(LanguageNames.CSharp) { { new OptionKey2(CodeStyleOptions2.QualifyMethodAccess, LanguageNames.CSharp), new CodeStyleOption2(true, notification) } }; + => new OptionsCollection(LanguageNames.CSharp) { { CodeStyleOptions2.QualifyMethodAccess, true, notification } }; } }