Merge pull request #41452 from chris-schuetz/Issue38513

Add UnitTests for Issue #38513

src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/EditorConfigNamingStyleParserTests.cs

@@ -353,6 +353,7 @@ public static void TestNoRulesAreReturned()
         [InlineData("property,method", new object[] { SymbolKind.Property, MethodKind.Ordinary })]
         [InlineData("namespace", new object[] { SymbolKind.Namespace })]
         [InlineData("type_parameter", new object[] { SymbolKind.TypeParameter })]
+        [InlineData("interface", new object[] { TypeKind.Interface })]
         [InlineData("*", new object[] { SymbolKind.Namespace, TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.TypeParameter, SymbolKind.Local })]
         [InlineData(null, new object[] { SymbolKind.Namespace, TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.TypeParameter, SymbolKind.Local })]
         [InlineData("property,method,invalid", new object[] { SymbolKind.Property, MethodKind.Ordinary })]
@@ -437,5 +438,40 @@ public static void TestRequiredModifiersParse()
             Assert.Equal(csharpResult.SymbolSpecifications.SelectMany(x => x.RequiredModifierList.Select(y => y.ModifierKindWrapper)),
                          vbResult.SymbolSpecifications.SelectMany(x => x.RequiredModifierList.Select(y => y.ModifierKindWrapper)));
         }
+
+        [Fact]
+        [WorkItem(38513, "https://github.com/dotnet/roslyn/issues/38513")]
+        public static void TestPrefixParse()
+        {
+            var rule = new Dictionary<string, string>()
+            {
+                ["dotnet_naming_style.pascal_case_and_prefix_style.required_prefix"] = "I",
+                ["dotnet_naming_style.pascal_case_and_prefix_style.capitalization"] = "pascal_case",
+                ["dotnet_naming_symbols.symbols.applicable_kinds"] = "interface",
+                ["dotnet_naming_symbols.symbols.applicable_accessibilities"] = "*",
+                ["dotnet_naming_rule.must_be_pascal_cased_and_prefixed.symbols"] = "symbols",
+                ["dotnet_naming_rule.must_be_pascal_cased_and_prefixed.style"] = "pascal_case_and_prefix_style",
+                ["dotnet_naming_rule.must_be_pascal_cased_and_prefixed.severity"] = "warning",
+            };
+
+            var result = ParseDictionary(rule);
+            Assert.Single(result.NamingRules);
+            var namingRule = result.NamingRules.Single();
+            Assert.Single(result.NamingStyles);
+            var namingStyle = result.NamingStyles.Single();
+            Assert.Single(result.SymbolSpecifications);
+            var symbolSpec = result.SymbolSpecifications.Single();
+            Assert.Equal(namingStyle.ID, namingRule.NamingStyleID);
+            Assert.Equal(symbolSpec.ID, namingRule.SymbolSpecificationID);
+            Assert.Equal(ReportDiagnostic.Warn, namingRule.EnforcementLevel);
+            Assert.Equal("symbols", symbolSpec.Name);
+            var expectedApplicableTypeKindList = new[] { new SymbolKindOrTypeKind(TypeKind.Interface) };
+            AssertEx.SetEqual(expectedApplicableTypeKindList, symbolSpec.ApplicableSymbolKindList);
+            Assert.Equal("pascal_case_and_prefix_style", namingStyle.Name);
+            Assert.Equal("I", namingStyle.Prefix);
+            Assert.Equal("", namingStyle.Suffix);
+            Assert.Equal("", namingStyle.WordSeparator);
+            Assert.Equal(Capitalization.PascalCase, namingStyle.CapitalizationScheme);
+        }
     }
 }

src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/NamingStylesTests.cs

@@ -1231,5 +1231,50 @@ public async Task TestRefactorNotify()
             Assert.Equal("c", symbolRenamedOperation._symbol.Name);
             Assert.Equal("C", symbolRenamedOperation._newName);
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)]
+        [WorkItem(38513, "https://github.com/dotnet/roslyn/issues/38513")]
+        public async Task TestRefactorNotifyInterfaceNamesStartWithI()
+        {
+            var markup = @"public interface [|test|] { }";
+            var testParameters = new TestParameters(options: options.InterfaceNamesStartWithI);
+
+            using var workspace = CreateWorkspaceFromOptions(markup, testParameters);
+            var (_, action) = await GetCodeActionsAsync(workspace, testParameters);
+
+            var previewOperations = await action.GetPreviewOperationsAsync(CancellationToken.None);
+            Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>());
+
+            var commitOperations = await action.GetOperationsAsync(CancellationToken.None);
+            Assert.Equal(2, commitOperations.Length);
+
+            var symbolRenamedOperation = (TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation)commitOperations[1];
+            Assert.Equal("test", symbolRenamedOperation._symbol.Name);
+            Assert.Equal("ITest", symbolRenamedOperation._newName);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)]
+        [WorkItem(38513, "https://github.com/dotnet/roslyn/issues/38513")]
+        public async Task TestRefactorNotifyTypeParameterNamesStartWithT()
+        {
+            var markup = @"public class A
+{
+    void DoOtherThing<[|arg|]>() { }
+}";
+            var testParameters = new TestParameters(options: options.TypeParameterNamesStartWithT);
+
+            using var workspace = CreateWorkspaceFromOptions(markup, testParameters);
+            var (_, action) = await GetCodeActionsAsync(workspace, testParameters);
+
+            var previewOperations = await action.GetPreviewOperationsAsync(CancellationToken.None);
+            Assert.Empty(previewOperations.OfType<TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation>());
+
+            var commitOperations = await action.GetOperationsAsync(CancellationToken.None);
+            Assert.Equal(2, commitOperations.Length);
+
+            var symbolRenamedOperation = (TestSymbolRenamedCodeActionOperationFactoryWorkspaceService.Operation)commitOperations[1];
+            Assert.Equal("arg", symbolRenamedOperation._symbol.Name);
+            Assert.Equal("TArg", symbolRenamedOperation._newName);
+        }
     }
 }

src/EditorFeatures/TestUtilities/Diagnostics/NamingStyles/NamingStylesTestOptionSets.cs

@@ -72,6 +72,9 @@ public NamingStylesTestOptionSets(string languageName)
         public IDictionary<OptionKey, object> InterfaceNamesStartWithI =>
             Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), InterfaceNamesStartWithIOption());
 
+        public IDictionary<OptionKey, object> TypeParameterNamesStartWithT =>
+            Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), TypeParameterNamesStartWithTOption());
+
         public IDictionary<OptionKey, object> ConstantsAreUpperCase =>
             Options(new OptionKey(SimplificationOptions.NamingPreferences, languageName), ConstantsAreUpperCaseOption());
 
@@ -604,6 +607,38 @@ private static NamingStylePreferences InterfaceNamesStartWithIOption()
             return info;
         }
 
+        private static NamingStylePreferences TypeParameterNamesStartWithTOption()
+        {
+            var symbolSpecification = new SymbolSpecification(
+                null,
+                "Name",
+                ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.TypeParameter)),
+                accessibilityList: default,
+                modifiers: default);
+
+            var namingStyle = new NamingStyle(
+                Guid.NewGuid(),
+                capitalizationScheme: Capitalization.PascalCase,
+                name: "Name",
+                prefix: "T",
+                suffix: "",
+                wordSeparator: "");
+
+            var namingRule = new SerializableNamingRule()
+            {
+                SymbolSpecificationID = symbolSpecification.ID,
+                NamingStyleID = namingStyle.ID,
+                EnforcementLevel = ReportDiagnostic.Error
+            };
+
+            var info = new NamingStylePreferences(
+                ImmutableArray.Create(symbolSpecification),
+                ImmutableArray.Create(namingStyle),
+                ImmutableArray.Create(namingRule));
+
+            return info;
+        }
+
         private static NamingStylePreferences ConstantsAreUpperCaseOption()
         {
             var symbolSpecification = new SymbolSpecification(

src/EditorFeatures/VisualBasicTest/Diagnostics/NamingStyles/NamingStylesTests.vb

@@ -470,5 +470,27 @@ end module",
                 options:=options.LocalsAreCamelCaseConstantsAreUpperCase)
         End Function
 
+        <Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)>
+        <WorkItem(38513, "https://github.com/dotnet/roslyn/issues/38513")>
+        Public Async Function TestInterfaceNamesStartWithI() As Task
+            Await TestInRegularAndScriptAsync(
+"Interface [|test|]
+End Interface",
+"Interface ITest
+End Interface",
+                options:=options.InterfaceNamesStartWithI)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)>
+        <WorkItem(38513, "https://github.com/dotnet/roslyn/issues/38513")>
+        Public Async Function TestTypeParameterNamesStartWithT() As Task
+            Await TestInRegularAndScriptAsync(
+"Public Class classHolder(Of [|type|])
+End Class",
+"Public Class classHolder(Of TType)
+End Class",
+                options:=options.TypeParameterNamesStartWithT)
+        End Function
+
     End Class
 End Namespace