Add fixer to convert from bound generic types in nameof to unbound types.

src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems

@@ -155,6 +155,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UsePatternMatching\CSharpUseNotPatternDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseSimpleUsingStatement\UseSimpleUsingStatementDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseThrowExpression\CSharpUseThrowExpressionDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseUnboundTypeInNameOf\UseUnboundTypeInNameOfDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ValidateFormatString\CSharpValidateFormatStringDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementDiagnosticAnalyzer.cs" />

src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx

@@ -422,4 +422,7 @@
     <value>Use 'System.Threading.Lock'</value>
     <comment>{Locked="System.Threading.Lock"} "System.Threading.Lock" is the name of a .Net type and should not be localized.</comment>
   </data>
+  <data name="Use_unbound_generic_type" xml:space="preserve">
+    <value>Use unbound generic type</value>
+  </data>
 </root>

src/Analyzers/CSharp/Analyzers/CodeStyle/CSharpAnalyzerOptionsProvider.cs

@@ -69,6 +69,7 @@ internal CSharpSimplifierOptions GetSimplifierOptions()
     public CodeStyleOption2<bool> PreferMethodGroupConversion => GetOption(CSharpCodeStyleOptions.PreferMethodGroupConversion);
     public CodeStyleOption2<bool> PreferPrimaryConstructors => GetOption(CSharpCodeStyleOptions.PreferPrimaryConstructors);
     public CodeStyleOption2<bool> PreferSystemThreadingLock => GetOption(CSharpCodeStyleOptions.PreferSystemThreadingLock);
+    public CodeStyleOption2<bool> PreferUnboundTypeInNameOf => GetOption(CSharpCodeStyleOptions.PreferUnboundTypeInNameOf);
 
     // CodeGenerationOptions
 

src/Analyzers/CSharp/Analyzers/UseUnboundTypeInNameOf/UseUnboundTypeInNameOfDiagnosticAnalyzer.cs

@@ -0,0 +1,88 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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.Linq;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.CSharp.UseUnboundTypeInNameOf;
+
+/// <summary>
+/// Looks for code of the form:
+/// 
+/// <code>
+///     nameof(List&lt;...&gt;)
+/// </code>
+///
+/// and converts it to:
+/// 
+/// <code>
+///     nameof(List&lt;&gt;)
+/// </code>
+/// 
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+internal sealed class CSharpUseUnboundTypeInNameOfDiagnosticAnalyzer()
+    : AbstractBuiltInCodeStyleDiagnosticAnalyzer(
+        IDEDiagnosticIds.UseUnboundTypeInNameOfDiagnosticId,
+        EnforceOnBuildValues.UseUnboundTypeInNameOf,
+        CSharpCodeStyleOptions.PreferUnboundTypeInNameOf,
+        new LocalizableResourceString(
+            nameof(CSharpAnalyzersResources.Use_unbound_generic_type), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)))
+{
+    public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+        => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
+
+    protected override void InitializeWorker(AnalysisContext context)
+    {
+        context.RegisterCompilationStartAction(context =>
+        {
+            // Tuples are only available in C# 14 and above.
+            var compilation = context.Compilation;
+            if (!compilation.LanguageVersion().IsCSharp14OrAbove())
+                return;
+
+            context.RegisterSyntaxNodeAction(
+                AnalyzeInvocationExpression,
+                SyntaxKind.InvocationExpression);
+        });
+    }
+
+    private void AnalyzeInvocationExpression(SyntaxNodeAnalysisContext syntaxContext)
+    {
+        var cancellationToken = syntaxContext.CancellationToken;
+        var styleOption = syntaxContext.GetCSharpAnalyzerOptions().PreferUnboundTypeInNameOf;
+        if (!styleOption.Value || ShouldSkipAnalysis(syntaxContext, styleOption.Notification))
+            return;
+
+        var invocation = (InvocationExpressionSyntax)syntaxContext.Node;
+        if (!invocation.IsNameOfInvocation())
+            return;
+
+        foreach (var typeArgumentList in invocation.DescendantNodesAndSelf().OfType<TypeArgumentListSyntax>())
+        {
+            foreach (var argument in typeArgumentList.Arguments)
+            {
+                if (argument.Kind() != SyntaxKind.OmittedTypeArgument)
+                {
+                    syntaxContext.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
+                        Descriptor,
+                        invocation.GetFirstToken().GetLocation(),
+                        styleOption.Notification,
+                        syntaxContext.Options,
+                        [invocation.GetLocation()],
+                        additionalUnnecessaryLocations: [invocation.SyntaxTree.GetLocation(
+                            TextSpan.FromBounds(typeArgumentList.LessThanToken.Span.End, typeArgumentList.GreaterThanToken.Span.Start))]));
+
+                    return;
+                }
+            }
+        }
+    }
+}

src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems

@@ -176,6 +176,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UsePatternMatching\CSharpAsAndNullCheckCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UsePatternMatching\CSharpIsAndCastCheckCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseSimpleUsingStatement\UseSimpleUsingStatementCodeFixProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseUnboundTypeInNameOf\CSharpUseUnboundTypeInNameOfCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseUtf8StringLiteral\UseUtf8StringLiteralCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementCodeFixProvider.cs" />
   </ItemGroup>

src/Analyzers/CSharp/CodeFixes/UseUnboundTypeInNameOf/CSharpUseUnboundTypeInNameOfCodeFixProvider.cs

@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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 System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.CSharp.UseUnboundTypeInNameOf;
+
+using static SyntaxFactory;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.UseUnboundTypeInNameOf), Shared]
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed partial class CSharpUseUnboundTypeInNameOfCodeFixProvider() : SyntaxEditorBasedCodeFixProvider
+{
+    private static readonly SyntaxNodeOrToken s_omittedArgument = (SyntaxNodeOrToken)OmittedTypeArgument();
+
+    public override ImmutableArray<string> FixableDiagnosticIds { get; }
+        = [IDEDiagnosticIds.UseUnboundTypeInNameOfDiagnosticId];
+
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        RegisterCodeFix(context, CSharpAnalyzersResources.Use_unbound_generic_type, nameof(CSharpAnalyzersResources.Use_unbound_generic_type));
+        return Task.CompletedTask;
+    }
+
+    protected override Task FixAllAsync(
+        Document document, ImmutableArray<Diagnostic> diagnostics,
+        SyntaxEditor editor, CancellationToken cancellationToken)
+    {
+        foreach (var diagnostic in diagnostics)
+            FixOne(editor, diagnostic, cancellationToken);
+
+        return Task.CompletedTask;
+    }
+
+    private static void FixOne(
+        SyntaxEditor editor, Diagnostic diagnostic, CancellationToken cancellationToken)
+    {
+        var nameofInvocation = (InvocationExpressionSyntax)diagnostic.AdditionalLocations[0].FindNode(getInnermostNodeForTie: true, cancellationToken);
+        if (!nameofInvocation.IsNameOfInvocation())
+            return;
+
+        foreach (var typeArgumentList in nameofInvocation.DescendantNodes().OfType<TypeArgumentListSyntax>().OrderByDescending(t => t.SpanStart))
+        {
+            if (typeArgumentList.Arguments.Any(a => a.Kind() != SyntaxKind.OmittedTypeArgument))
+            {
+                var list = NodeOrTokenList(typeArgumentList.Arguments.GetWithSeparators().Select(
+                    t => t.IsToken ? t.AsToken().WithoutTrivia() : s_omittedArgument));
+                editor.ReplaceNode(typeArgumentList, typeArgumentList.WithArguments(SeparatedList<TypeSyntax>(list)));
+            }
+        }
+    }
+}

src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems

@@ -185,6 +185,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseSystemHashCode\UseSystemHashCodeTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseThrowExpression\UseThrowExpressionTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseThrowExpression\UseThrowExpressionTests_FixAllTests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseUnboundTypeInNameOf\UseUnboundTypeInNameOfTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseUtf8StringLiteral\UseUtf8StringLiteralTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseVarTestExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ValidateFormatString\ValidateFormatStringTests.cs" />

src/Analyzers/CSharp/Tests/UseTupleSwap/UseTupleSwapTests.cs

@@ -18,8 +18,8 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseTupleSwap;
     CSharpUseTupleSwapDiagnosticAnalyzer,
     CSharpUseTupleSwapCodeFixProvider>;
 
-[Trait(Traits.Feature, Traits.Features.CodeActionsUseLocalFunction)]
-public partial class UseTupleSwapTests
+[Trait(Traits.Feature, Traits.Features.CodeActionsUseTupleSwap)]
+public sealed class UseTupleSwapTests
 {
     [Fact]
     public async Task TestMissingBeforeCSharp7()