From b0147a1bc8902094fef68ef019257f2a2f5a17ff Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Fri, 1 Jun 2018 08:03:42 -0500 Subject: [PATCH] Fix handling of unrecognized naming style values Related to #20907 --- .../DeclarationNameCompletionProviderTests.cs | 4 +- ...oPropertyToFullPropertyTests_OptionSets.cs | 6 +- .../EditorConfigNamingStyleParserTests.cs | 87 +++++++++++--- .../NamingStyles/NamingStylesTests.cs | 72 ++++++++++++ .../NamingStylesTestOptionSets.cs | 106 ++++++++++++++---- ...ionNameCompletionProvider_BuiltInStyles.cs | 10 +- ...tyToFullPropertyCodeRefactoringProvider.cs | 2 +- ...ditorConfigNamingStyleParser_SymbolSpec.cs | 4 +- .../Serialization/SymbolSpecification.cs | 20 ++-- 9 files changed, 250 insertions(+), 61 deletions(-) diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests.cs index 80200ff772d..942e4426191 100644 --- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests.cs +++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/DeclarationNameCompletionProviderTests.cs @@ -1546,8 +1546,8 @@ private static NamingStylePreferences NamesEndWithSuffixPreferences() id: null, symbolSpecName: suffix, ImmutableArray.Create(kind), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), diff --git a/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs b/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs index 92100628c03..ad56402c440 100644 --- a/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs +++ b/src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs @@ -57,8 +57,8 @@ private NamingStylePreferences CreateCustomFieldNamingStylePreference() null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), @@ -89,7 +89,7 @@ private NamingStylePreferences CreateCustomStaticFieldNamingStylePreference() null, "Name", ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field)), - ImmutableArray.Empty, + accessibilityList: default, ImmutableArray.Create(new ModifierKind(DeclarationModifiers.Static))); var namingStyle = new NamingStyle( diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs index 7da4550cf89..334147e3de5 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs @@ -4,6 +4,7 @@ using System.Linq; using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles; using Roslyn.Test.Utilities; +using Roslyn.Utilities; using Xunit; using static Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles.EditorConfigNamingStyleParser; using static Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles.SymbolSpecification; @@ -90,7 +91,9 @@ public static void TestAsyncMethodsAndLocalFunctionsRule() AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); Assert.Single(symbolSpec.RequiredModifierList); Assert.Contains(new ModifierKind(ModifierKindEnum.IsAsync), symbolSpec.RequiredModifierList); - Assert.Empty(symbolSpec.ApplicableAccessibilityList); + Assert.Equal( + new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal }, + symbolSpec.ApplicableAccessibilityList); Assert.Equal("end_in_async_style", namingStyle.Name); Assert.Equal("", namingStyle.Prefix); Assert.Equal("Async", namingStyle.Suffix); @@ -236,7 +239,9 @@ public static void TestParametersAndLocalsAreCamelCaseRule() new SymbolKindOrTypeKind(SymbolKind.Local), }; AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); - Assert.Empty(symbolSpec.ApplicableAccessibilityList); + Assert.Equal( + new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal }, + symbolSpec.ApplicableAccessibilityList); Assert.Empty(symbolSpec.RequiredModifierList); Assert.Equal("camel_case_style", namingStyle.Name); @@ -273,7 +278,9 @@ public static void TestLocalFunctionsAreCamelCaseRule() Assert.Equal("local_functions", symbolSpec.Name); var expectedApplicableSymbolKindList = new[] { new SymbolKindOrTypeKind(MethodKind.LocalFunction) }; AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); - Assert.Empty(symbolSpec.ApplicableAccessibilityList); + Assert.Equal( + new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal }, + symbolSpec.ApplicableAccessibilityList); Assert.Empty(symbolSpec.RequiredModifierList); Assert.Equal("camel_case_style", namingStyle.Name); @@ -298,31 +305,79 @@ public static void TestNoRulesAreReturned() Assert.Empty(result.SymbolSpecifications); } - [Fact] - public static void TestApplicableAccessibilitiesParse() + [Theory] + [InlineData("property,method", new object[] { SymbolKind.Property, MethodKind.Ordinary })] + [InlineData("*", new object[] { TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.Local })] + [InlineData(null, new object[] { TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.Local })] + [InlineData("property,method,invalid", new object[] { SymbolKind.Property, MethodKind.Ordinary })] + [InlineData("invalid", new object[] { })] + [InlineData("", new object[] { })] + [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")] + public static void TestApplicableKindsParse(string specification, object[] typeOrSymbolKinds) { - var charpRule = new Dictionary() + var rule = new Dictionary() { - ["dotnet_naming_rule.accessibilities_parse.severity"] = "error", - ["dotnet_naming_rule.accessibilities_parse.symbols"] = "accessibilities", - ["dotnet_naming_rule.accessibilities_parse.style"] = "pascal_case", - ["dotnet_naming_symbols.accessibilities.applicable_accessibilities"] = "internal,protected_internal", + ["dotnet_naming_rule.kinds_parse.severity"] = "error", + ["dotnet_naming_rule.kinds_parse.symbols"] = "kinds", + ["dotnet_naming_rule.kinds_parse.style"] = "pascal_case", ["dotnet_naming_style.pascal_case.capitalization "] = "pascal_case", }; - var vbRule = new Dictionary() + + if (specification != null) + { + rule["dotnet_naming_symbols.kinds.applicable_kinds"] = specification; + } + + var kinds = typeOrSymbolKinds + .Select(typeOrSymbolKind => + { + switch (typeOrSymbolKind) + { + case TypeKind typeKind: + return new SymbolKindOrTypeKind(typeKind); + + case SymbolKind symbolKind: + return new SymbolKindOrTypeKind(symbolKind); + + case MethodKind methodKind: + return new SymbolKindOrTypeKind(methodKind); + + default: + throw ExceptionUtilities.UnexpectedValue(typeOrSymbolKind); + } + }) + .ToArray(); + + var result = ParseDictionary(rule); + Assert.Equal(kinds, result.SymbolSpecifications.SelectMany(x => x.ApplicableSymbolKindList)); + } + + [Theory] + [InlineData("internal,protected_internal", new[] { Accessibility.Internal, Accessibility.ProtectedOrInternal })] + [InlineData("friend,protected_friend", new[] { Accessibility.Friend, Accessibility.ProtectedOrFriend })] + [InlineData("*", new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal })] + [InlineData(null, new[] { Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal })] + [InlineData("internal,protected,invalid", new[] { Accessibility.Internal, Accessibility.Protected })] + [InlineData("invalid", new Accessibility[] { })] + [InlineData("", new Accessibility[] { })] + [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")] + public static void TestApplicableAccessibilitiesParse(string specification, Accessibility[] accessibilities) + { + var rule = new Dictionary() { ["dotnet_naming_rule.accessibilities_parse.severity"] = "error", ["dotnet_naming_rule.accessibilities_parse.symbols"] = "accessibilities", ["dotnet_naming_rule.accessibilities_parse.style"] = "pascal_case", - ["dotnet_naming_symbols.accessibilities.applicable_accessibilities"] = "friend,protected_friend", ["dotnet_naming_style.pascal_case.capitalization "] = "pascal_case", }; - var csharpResult = ParseDictionary(charpRule); - var vbResult = ParseDictionary(vbRule); + if (specification != null) + { + rule["dotnet_naming_symbols.accessibilities.applicable_accessibilities"] = specification; + } - Assert.Equal(csharpResult.SymbolSpecifications.SelectMany(x => x.ApplicableAccessibilityList), - vbResult.SymbolSpecifications.SelectMany(x => x.ApplicableAccessibilityList)); + var result = ParseDictionary(rule); + Assert.Equal(accessibilities, result.SymbolSpecifications.SelectMany(x => x.ApplicableAccessibilityList)); } [Fact] diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/NamingStylesTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/NamingStylesTests.cs index 7feb7f1beaf..b23a6e5d51f 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/NamingStylesTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/NamingStylesTests.cs @@ -1,11 +1,13 @@ // Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. +using System.Collections.Immutable; using System.Threading; using System.Threading.Tasks; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.CodeFixes.NamingStyles; using Microsoft.CodeAnalysis.CSharp.Diagnostics.NamingStyles; using Microsoft.CodeAnalysis.Diagnostics; +using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles; using Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics.NamingStyles; using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces; using Microsoft.CodeAnalysis.Test.Utilities; @@ -55,6 +57,76 @@ public async Task TestPascalCaseMethod_CorrectName() }", new TestParameters(options: options.MethodNamesArePascalCase)); } + [Theory, Trait(Traits.Feature, Traits.Features.NamingStyle)] + [InlineData("")] + [InlineData("public")] + [InlineData("protected")] + [InlineData("internal")] + [InlineData("protected internal")] + [InlineData("private")] + [InlineData("protected private")] + [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")] + public async Task TestPascalCaseMethod_NoneAndDefaultAccessibilities(string accessibility) + { + await TestMissingInRegularAndScriptAsync( +$@"class C +{{ + {accessibility} void [|m|]() + {{ + }} +}}", new TestParameters(options: options.MethodNamesWithAccessibilityArePascalCase(ImmutableArray.Empty))); + + await TestInRegularAndScriptAsync( +$@"class C +{{ + {accessibility} void [|m|]() + {{ + }} +}}", +$@"class C +{{ + {accessibility} void M() + {{ + }} +}}", options: options.MethodNamesWithAccessibilityArePascalCase(accessibilities: default)); + } + + [Theory, Trait(Traits.Feature, Traits.Features.NamingStyle)] + [InlineData("} namespace [|c2|] {", "} namespace C2 {")] + [InlineData("class [|c2|] { }", "class C2 { }")] + [InlineData("struct [|c2|] { }", "struct C2 { }")] + [InlineData("interface [|c2|] { }", "interface C2 { }")] + [InlineData("delegate void [|c2|]();", "delegate void C2();")] + [InlineData("enum [|c2|] { }", "enum C2 { }")] + [InlineData("class M<[|t|]> {}", "class M {}", Skip = "https://github.com/dotnet/roslyn/issues/18121")] + [InlineData("void M<[|t|]>() {}", "void M() {}", Skip = "https://github.com/dotnet/roslyn/issues/18121")] + [InlineData("int [|m|] { get; }", "int M { get; }")] + [InlineData("void [|m|]() {}", "void M() {}")] + [InlineData("void Outer() { void [|m|]() {} }", "void Outer() { void M() {} }")] + [InlineData("int [|m|];", "int M;")] + [InlineData("event System.EventHandler [|m|];", "event System.EventHandler M;")] + [InlineData("void Outer(int [|m|]) {}", "void Outer(int M) {}")] + [InlineData("void Outer() { int [|m|]; }", "void Outer() { int M; }")] + [WorkItem(20907, "https://github.com/dotnet/roslyn/issues/20907")] + public async Task TestPascalCaseSymbol_NoneAndDefaultSymbolKinds(string camelCaseSymbol, string pascalCaseSymbol) + { + await TestMissingInRegularAndScriptAsync( +$@"class C +{{ + {camelCaseSymbol} +}}", new TestParameters(options: options.SymbolKindsArePascalCase(ImmutableArray.Empty))); + + await TestInRegularAndScriptAsync( +$@"class C +{{ + {camelCaseSymbol} +}}", +$@"class C +{{ + {pascalCaseSymbol} +}}", options: options.SymbolKindsArePascalCase(symbolKinds: default)); + } + [Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)] public async Task TestPascalCaseMethod_NameGetsCapitalized() { diff --git a/src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs b/src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs index 38654e194e1..c8c529dec12 100644 --- a/src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs +++ b/src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs @@ -49,6 +49,12 @@ public NamingStylesTestOptionSets(string languageName) public IDictionary AsyncFunctionNamesEndWithAsync => Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), AsyncFunctionNamesEndWithAsyncOption()); + public IDictionary MethodNamesWithAccessibilityArePascalCase(ImmutableArray accessibilities) => + Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), MethodNamesArePascalCaseOption(accessibilities)); + + internal IDictionary SymbolKindsArePascalCase(ImmutableArray symbolKinds) => + Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), SymbolKindsArePascalCaseOption(symbolKinds)); + private static IDictionary Options(OptionKey option, object value) { return new Dictionary @@ -63,8 +69,8 @@ private static NamingStylePreferences ClassNamesArePascalCaseOption() null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Class)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), @@ -93,8 +99,70 @@ private static NamingStylePreferences MethodNamesArePascalCaseOption() null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); + + var namingStyle = new NamingStyle( + Guid.NewGuid(), + capitalizationScheme: Capitalization.PascalCase, + name: "Name", + prefix: "", + suffix: "", + wordSeparator: ""); + + var namingRule = new SerializableNamingRule() + { + SymbolSpecificationID = symbolSpecification.ID, + NamingStyleID = namingStyle.ID, + EnforcementLevel = DiagnosticSeverity.Error + }; + var info = new NamingStylePreferences( + ImmutableArray.Create(symbolSpecification), + ImmutableArray.Create(namingStyle), + ImmutableArray.Create(namingRule)); + + return info; + } + + private static NamingStylePreferences MethodNamesArePascalCaseOption(ImmutableArray accessibilities) + { + var symbolSpecification = new SymbolSpecification( + null, + "Name", + ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)), + accessibilities, + modifiers: default); + + var namingStyle = new NamingStyle( + Guid.NewGuid(), + capitalizationScheme: Capitalization.PascalCase, + name: "Name", + prefix: "", + suffix: "", + wordSeparator: ""); + + var namingRule = new SerializableNamingRule() + { + SymbolSpecificationID = symbolSpecification.ID, + NamingStyleID = namingStyle.ID, + EnforcementLevel = DiagnosticSeverity.Error + }; + var info = new NamingStylePreferences( + ImmutableArray.Create(symbolSpecification), + ImmutableArray.Create(namingStyle), + ImmutableArray.Create(namingRule)); + + return info; + } + + private static NamingStylePreferences SymbolKindsArePascalCaseOption(ImmutableArray symbolKinds) + { + var symbolSpecification = new SymbolSpecification( + null, + "Name", + symbolKinds, + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), @@ -124,8 +192,8 @@ private static NamingStylePreferences ParameterNamesAreCamelCaseOption() null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Parameter)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), @@ -156,8 +224,8 @@ private static NamingStylePreferences LocalNamesAreCamelCaseOption() null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), @@ -188,8 +256,8 @@ private static NamingStylePreferences LocalFunctionNamesAreCamelCaseOption() null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), @@ -220,8 +288,8 @@ private static NamingStylePreferences PropertyNamesArePascalCaseOption() null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Property)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), @@ -252,8 +320,8 @@ private static NamingStylePreferences InterfacesNamesStartWithIOption() null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Interface)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var namingStyle = new NamingStyle( Guid.NewGuid(), @@ -286,7 +354,7 @@ private static NamingStylePreferences ConstantsAreUpperCaseOption() ImmutableArray.Create( new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field), new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), - ImmutableArray.Empty, + accessibilityList: default, ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst))); var namingStyle = new NamingStyle( @@ -318,14 +386,14 @@ private static NamingStylePreferences LocalsAreCamelCaseConstantsAreUpperCaseOpt null, "Locals", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), - ImmutableArray.Empty, - ImmutableArray.Empty); + accessibilityList: default, + modifiers: default); var constLocalsSymbolSpecification = new SymbolSpecification( null, "Const Locals", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), - ImmutableArray.Empty, + accessibilityList: default, ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst))); var camelCaseNamingStyle = new NamingStyle( @@ -374,7 +442,7 @@ private static NamingStylePreferences AsyncFunctionNamesEndWithAsyncOption() ImmutableArray.Create( new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary), new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)), - ImmutableArray.Empty, + accessibilityList: default, ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsAsync))); var namingStyle = new NamingStyle( diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs index 4f30effdd73..45736ee729a 100644 --- a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs +++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider_BuiltInStyles.cs @@ -26,7 +26,7 @@ private static NamingRule CreateGetAsyncRule() var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); return new NamingRule( - new SymbolSpecification(Guid.NewGuid(), "endswithasync", kinds, ImmutableArray.Create(), modifiers), + new SymbolSpecification(Guid.NewGuid(), "endswithasync", kinds, accessibilityList: default, modifiers), new NamingStyles.NamingStyle(Guid.NewGuid(), prefix: "Get", suffix: "Async"), DiagnosticSeverity.Info); } @@ -34,9 +34,8 @@ private static NamingRule CreateGetAsyncRule() private static NamingRule CreateCamelCaseFieldsAndParametersRule() { var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field), new SymbolKindOrTypeKind(SymbolKind.Parameter), new SymbolKindOrTypeKind(SymbolKind.Local)); - var modifiers = ImmutableArray.Create(); return new NamingRule( - new SymbolSpecification(Guid.NewGuid(), "camelcasefields", kinds, ImmutableArray.Create(), modifiers), + new SymbolSpecification(Guid.NewGuid(), "camelcasefields", kinds, accessibilityList: default, modifiers: default), new NamingStyles.NamingStyle(Guid.NewGuid(), capitalizationScheme: Capitalization.CamelCase), DiagnosticSeverity.Info); } @@ -46,7 +45,7 @@ private static NamingRule CreateEndWithAsyncRule() var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); return new NamingRule( - new SymbolSpecification(Guid.NewGuid(), "endswithasynct", kinds, ImmutableArray.Create(), modifiers), + new SymbolSpecification(Guid.NewGuid(), "endswithasynct", kinds, accessibilityList: default, modifiers), new NamingStyles.NamingStyle(Guid.NewGuid(), suffix: "Async"), DiagnosticSeverity.Info); } @@ -54,9 +53,8 @@ private static NamingRule CreateEndWithAsyncRule() private static NamingRule CreateMethodStartsWithGetRule() { var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); - var modifiers = ImmutableArray.Create(); return new NamingRule( - new SymbolSpecification(Guid.NewGuid(), "startswithget", kinds, ImmutableArray.Create(), modifiers), + new SymbolSpecification(Guid.NewGuid(), "startswithget", kinds, accessibilityList: default, modifiers: default), new NamingStyles.NamingStyle(Guid.NewGuid(), prefix: "Get"), DiagnosticSeverity.Info); } diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs index 1ec35406a13..3add8820c76 100644 --- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs @@ -74,7 +74,7 @@ internal override async Task GetFieldNameAsync(Document document, IPrope var namingPreferencesOption = optionSet.GetOption(SimplificationOptions.NamingPreferences); var rules = namingPreferencesOption.CreateRules().NamingRules .AddRange(CreateNewRule(ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsStatic)), defaultStaticFieldPrefix)) - .AddRange(CreateNewRule(ImmutableArray.Create(), defaultFieldPrefix)); + .AddRange(CreateNewRule(modifiers: default, defaultFieldPrefix)); return rules; } diff --git a/src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs b/src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs index 85bccee13b2..47423b81d3c 100644 --- a/src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs +++ b/src/Workspaces/Core/Portable/NamingStyles/EditorConfig/EditorConfigNamingStyleParser_SymbolSpec.cs @@ -59,7 +59,7 @@ internal static partial class EditorConfigNamingStyleParser return ParseSymbolKindList(result as string ?? string.Empty); } - return ImmutableArray.Empty; + return _all; } private static readonly SymbolKindOrTypeKind _class = new SymbolKindOrTypeKind(TypeKind.Class); @@ -159,7 +159,7 @@ private static ImmutableArray ParseSymbolKindList(string s return ParseAccessibilityKindList(result as string ?? string.Empty); } - return ImmutableArray.Empty; + return _allAccessibility; } private static readonly ImmutableArray _allAccessibility = ImmutableArray.Create(Accessibility.Public, Accessibility.Internal, Accessibility.Private, Accessibility.Protected, Accessibility.ProtectedOrInternal); diff --git a/src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs b/src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs index dd40ff649f3..c8bf733a1e4 100644 --- a/src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs +++ b/src/Workspaces/Core/Portable/NamingStyles/Serialization/SymbolSpecification.cs @@ -14,6 +14,8 @@ namespace Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles { internal class SymbolSpecification { + private static readonly SymbolSpecification DefaultSymbolSpecificationTemplate = CreateDefaultSymbolSpecification(); + public Guid ID { get; } public string Name { get; } @@ -29,9 +31,9 @@ internal class SymbolSpecification { ID = id ?? Guid.NewGuid(); Name = symbolSpecName; - ApplicableSymbolKindList = symbolKindList; - ApplicableAccessibilityList = accessibilityList.NullToEmpty(); - RequiredModifierList = modifiers.NullToEmpty(); + ApplicableSymbolKindList = symbolKindList.IsDefault ? DefaultSymbolSpecificationTemplate.ApplicableSymbolKindList : symbolKindList; + ApplicableAccessibilityList = accessibilityList.IsDefault ? DefaultSymbolSpecificationTemplate.ApplicableAccessibilityList : accessibilityList; + RequiredModifierList = modifiers.IsDefault ? DefaultSymbolSpecificationTemplate.RequiredModifierList : modifiers; } public static SymbolSpecification CreateDefaultSymbolSpecification() @@ -82,7 +84,7 @@ internal bool AppliesTo(SymbolKind symbolKind, Accessibility accessibility) internal bool AppliesTo(SymbolKindOrTypeKind kind, DeclarationModifiers modifiers, Accessibility accessibility) { - if (ApplicableSymbolKindList.Any() && !ApplicableSymbolKindList.Any(k => k.Equals(kind))) + if (!ApplicableSymbolKindList.Any(k => k.Equals(kind))) { return false; } @@ -93,8 +95,7 @@ internal bool AppliesTo(SymbolKindOrTypeKind kind, DeclarationModifiers modifier return false; } - if (ApplicableAccessibilityList.Any() && - accessibility != Accessibility.NotApplicable && + if (accessibility != Accessibility.NotApplicable && !ApplicableAccessibilityList.Any(k => k == accessibility)) { return false; @@ -138,11 +139,6 @@ private DeclarationModifiers CollapseModifiers(ImmutableArray requ private bool AnyMatches(ImmutableArray matchers, ISymbol symbol) where TSymbolMatcher : ISymbolMatcher { - if (!matchers.Any()) - { - return true; - } - foreach (var matcher in matchers) { if (matcher.MatchesSymbol(symbol)) @@ -156,7 +152,7 @@ private bool AnyMatches(ImmutableArray matchers, private bool AnyMatches(ImmutableArray matchers, ISymbol symbol) { - if (!matchers.Any()) + if (symbol.DeclaredAccessibility == Accessibility.NotApplicable) { return true; } -- GitLab