Update to using unbound nameof(X<>) expressions

src/Analyzers/CSharp/Analyzers/UseCollectionExpression/CSharpUseCollectionExpressionForBuilderDiagnosticAnalyzer.cs

@@ -27,7 +27,7 @@ internal sealed partial class CSharpUseCollectionExpressionForBuilderDiagnosticA
         EnforceOnBuildValues.UseCollectionExpressionForBuilder)
 {
     private const string CreateBuilderName = nameof(ImmutableArray.CreateBuilder);
-    private const string GetInstanceName = nameof(ArrayBuilder<int>.GetInstance);
+    private const string GetInstanceName = nameof(ArrayBuilder<>.GetInstance);
 
     protected override void InitializeWorker(CodeBlockStartAnalysisContext<SyntaxKind> context, INamedTypeSymbol? expressionType)
         => context.RegisterSyntaxNodeAction(context => AnalyzeInvocationExpression(context, expressionType), SyntaxKind.InvocationExpression);
@@ -117,7 +117,7 @@ void FadeOutCode(SyntaxNodeAnalysisContext context, AnalysisResult analysisResul
             return null;
 
         if (memberAccessExpression.Name.Identifier.ValueText == GetInstanceName &&
-            memberAccessExpression.Expression is not GenericNameSyntax { Identifier.ValueText: nameof(ArrayBuilder<int>) })
+            memberAccessExpression.Expression is not GenericNameSyntax { Identifier.ValueText: nameof(ArrayBuilder<>) })
         {
             return null;
         }
@@ -217,12 +217,12 @@ identifierName.Parent is MemberAccessExpressionSyntax(SyntaxKind.SimpleMemberAcc
                     memberAccess.Expression == identifierName &&
                     memberAccess.Parent is InvocationExpressionSyntax { ArgumentList.Arguments.Count: 0 } invocationExpression &&
                     memberAccess.Name.Identifier.ValueText
-                        is nameof(ImmutableArray<int>.Builder.ToImmutable)
-                        or nameof(ImmutableArray<int>.Builder.MoveToImmutable)
-                        or nameof(ImmutableArray<int>.Builder.ToArray)
-                        or nameof(ArrayBuilder<int>.ToImmutableAndClear)
-                        or nameof(ArrayBuilder<int>.ToImmutableAndFree)
-                        or nameof(ArrayBuilder<int>.ToArrayAndFree)
+                        is nameof(ImmutableArray<>.Builder.ToImmutable)
+                        or nameof(ImmutableArray<>.Builder.MoveToImmutable)
+                        or nameof(ImmutableArray<>.Builder.ToArray)
+                        or nameof(ArrayBuilder<>.ToImmutableAndClear)
+                        or nameof(ArrayBuilder<>.ToImmutableAndFree)
+                        or nameof(ArrayBuilder<>.ToArrayAndFree)
                         or nameof(Enumerable.ToList))
                 {
                     return invocationExpression;

src/Analyzers/CSharp/Analyzers/UseCollectionExpression/CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs

@@ -42,24 +42,24 @@ internal sealed partial class CSharpUseCollectionExpressionForFluentDiagnosticAn
     private static readonly ImmutableArray<string> s_suffixes =
     [
         nameof(Array),
-        nameof(Span<int>),
-        nameof(ReadOnlySpan<int>),
-        nameof(System.Collections.Generic.List<int>),
-        nameof(HashSet<int>),
-        nameof(LinkedList<int>),
-        nameof(Queue<int>),
-        nameof(SortedSet<int>),
-        nameof(Stack<int>),
-        nameof(ICollection<int>),
-        nameof(IReadOnlyCollection<int>),
-        nameof(IList<int>),
-        nameof(IReadOnlyList<int>),
-        nameof(ImmutableArray<int>),
-        nameof(ImmutableHashSet<int>),
-        nameof(ImmutableList<int>),
-        nameof(ImmutableQueue<int>),
-        nameof(ImmutableSortedSet<int>),
-        nameof(ImmutableStack<int>),
+        nameof(Span<>),
+        nameof(ReadOnlySpan<>),
+        nameof(System.Collections.Generic.List<>),
+        nameof(HashSet<>),
+        nameof(LinkedList<>),
+        nameof(Queue<>),
+        nameof(SortedSet<>),
+        nameof(Stack<>),
+        nameof(ICollection<>),
+        nameof(IReadOnlyCollection<>),
+        nameof(IList<>),
+        nameof(IReadOnlyList<>),
+        nameof(ImmutableArray<>),
+        nameof(ImmutableHashSet<>),
+        nameof(ImmutableList<>),
+        nameof(ImmutableQueue<>),
+        nameof(ImmutableSortedSet<>),
+        nameof(ImmutableStack<>),
         nameof(System.Collections.Immutable),
     ];
 

src/Analyzers/CSharp/Analyzers/UseCollectionExpression/CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs

@@ -53,7 +53,7 @@ private void AnalyzeBaseObjectCreationExpression(
 
         var symbol = semanticModel.GetSymbolInfo(objectCreationExpression, cancellationToken).Symbol;
         if (symbol is not IMethodSymbol { MethodKind: MethodKind.Constructor, Parameters: [var constructorParameter] } ||
-            constructorParameter.Type.Name != nameof(IEnumerable<int>))
+            constructorParameter.Type.Name != nameof(IEnumerable<>))
         {
             return;
         }

src/Analyzers/CSharp/Analyzers/UseCollectionExpression/UseCollectionExpressionHelpers.cs

@@ -193,11 +193,11 @@ bool IsSafeConversionWhenTypesDoNotMatch(out bool changesSemantics)
             var convertedType = originalTypeInfo.ConvertedType;
 
             var convertedToReadOnlySpan =
-                convertedType.Name == nameof(ReadOnlySpan<int>) &&
+                convertedType.Name == nameof(ReadOnlySpan<>) &&
                 convertedType.OriginalDefinition.Equals(compilation.ReadOnlySpanOfTType());
 
             var convertedToSpan =
-                convertedType.Name == nameof(Span<int>) &&
+                convertedType.Name == nameof(Span<>) &&
                 convertedType.OriginalDefinition.Equals(compilation.SpanOfTType());
 
             // ReadOnlySpan<X> x = stackalloc[] ...
@@ -206,7 +206,7 @@ bool IsSafeConversionWhenTypesDoNotMatch(out bool changesSemantics)
             // restrictive than Span<X>
             var isSpanToReadOnlySpan =
                 convertedToReadOnlySpan &&
-                type.Name == nameof(Span<int>) &&
+                type.Name == nameof(Span<>) &&
                 type.OriginalDefinition.Equals(compilation.SpanOfTType()) &&
                 convertedType.GetTypeArguments()[0].Equals(type.GetTypeArguments()[0]);
             if (isSpanToReadOnlySpan)
@@ -264,7 +264,7 @@ bool IsSafeConversionWhenTypesDoNotMatch(out bool changesSemantics)
                 // disallow converting those types to ensure semantics are preserved.  We do this even though
                 // allowSemanticsChange is true because this will basically be certain to break semantics, as opposed to
                 // the more common case where semantics may change slightly, but likely not in a way that breaks code.
-                if (type.Name is nameof(ObservableCollection<int>) or nameof(ReadOnlyObservableCollection<int>))
+                if (type.Name is nameof(ObservableCollection<>) or nameof(ReadOnlyObservableCollection<>))
                     return false;
 
                 // If the original expression was creating a set, but is being assigned to one of the well known
@@ -933,7 +933,7 @@ bool IsCompatibleSignatureAndArguments(
                     {
                         Type: INamedTypeSymbol
                         {
-                            Name: nameof(IEnumerable<int>),
+                            Name: nameof(IEnumerable<>),
                             TypeArguments: [ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method }]
                         } enumerableType
                     }] &&
@@ -980,7 +980,7 @@ originalCreateMethod.Parameters is [
                     {
                         Type: INamedTypeSymbol
                         {
-                            Name: nameof(Span<int>) or nameof(ReadOnlySpan<int>),
+                            Name: nameof(Span<>) or nameof(ReadOnlySpan<>),
                             TypeArguments: [ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method }]
                         } spanType
                     }])

src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs

@@ -158,7 +158,7 @@ private MemberInfo ComputeMemberInfo(IMethodSymbol sliceLikeMethod, bool require
                 // Also, look to see if the type has a `.Slice(int start, int length)` method.
                 // This is also a method the compiler knows to look for when a user writes `x[a..b]`
                 var actualSliceMethod =
-                    sliceLikeMethod.ContainingType.GetMembers(nameof(Span<int>.Slice))
+                    sliceLikeMethod.ContainingType.GetMembers(nameof(Span<>.Slice))
                                                   .OfType<IMethodSymbol>()
                                                   .FirstOrDefault(s => IsTwoArgumentSliceLikeMethod(s));
                 if (actualSliceMethod != null)

src/Analyzers/CSharp/CodeFixes/MakeMethodAsynchronous/CSharpMakeMethodAsynchronousCodeFixProvider.cs

@@ -131,13 +131,13 @@ private static TypeSyntax FixMethodReturnType(
             if (IsIEnumerable(returnType, knownTypes) && IsIterator(methodSymbol, cancellationToken))
             {
                 newReturnType = knownTypes.IAsyncEnumerableOfTType is null
-                    ? MakeGenericType(nameof(IAsyncEnumerable<int>), methodSymbol.ReturnType)
+                    ? MakeGenericType(nameof(IAsyncEnumerable<>), methodSymbol.ReturnType)
                     : knownTypes.IAsyncEnumerableOfTType.Construct(methodSymbol.ReturnType.GetTypeArguments()[0]).GenerateTypeSyntax();
             }
             else if (IsIEnumerator(returnType, knownTypes) && IsIterator(methodSymbol, cancellationToken))
             {
                 newReturnType = knownTypes.IAsyncEnumeratorOfTType is null
-                    ? MakeGenericType(nameof(IAsyncEnumerator<int>), methodSymbol.ReturnType)
+                    ? MakeGenericType(nameof(IAsyncEnumerator<>), methodSymbol.ReturnType)
                     : knownTypes.IAsyncEnumeratorOfTType.Construct(methodSymbol.ReturnType.GetTypeArguments()[0]).GenerateTypeSyntax();
             }
             else if (IsIAsyncEnumerableOrEnumerator(returnType, knownTypes))

src/Analyzers/CSharp/CodeFixes/UseUtf8StringLiteral/UseUtf8StringLiteralCodeFixProvider.cs

@@ -206,7 +206,7 @@ private static ExpressionSyntax CreateUtf8String(SyntaxTriviaList leadingTrivia,
                  MemberAccessExpression(
                      SyntaxKind.SimpleMemberAccessExpression,
                      stringLiteral,
-                     IdentifierName(nameof(ReadOnlySpan<byte>.ToArray))))
+                     IdentifierName(nameof(ReadOnlySpan<>.ToArray))))
                .WithTrailingTrivia(trailingTrivia);
     }
 }

src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionForNullableTernaryConditionalCheckDiagnosticAnalyzer.cs

@@ -80,7 +80,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         syntaxFacts.GetPartsOfMemberAccessExpression(conditionMemberAccess, out var conditionExpression, out var conditionSimpleName);
         syntaxFacts.GetNameAndArityOfSimpleName(conditionSimpleName, out var conditionName, out _);
 
-        if (conditionName != nameof(Nullable<int>.HasValue))
+        if (conditionName != nameof(Nullable<>.HasValue))
             return;
 
         var whenPartToCheck = notHasValueExpression ? whenFalseNodeLow : whenTrueNodeLow;
@@ -90,7 +90,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         syntaxFacts.GetPartsOfMemberAccessExpression(whenPartMemberAccess, out var whenPartExpression, out var whenPartSimpleName);
         syntaxFacts.GetNameAndArityOfSimpleName(whenPartSimpleName, out var whenPartName, out _);
 
-        if (whenPartName != nameof(Nullable<int>.Value))
+        if (whenPartName != nameof(Nullable<>.Value))
             return;
 
         if (!syntaxFacts.AreEquivalent(conditionExpression, whenPartExpression))

src/Analyzers/Core/Analyzers/UseCollectionInitializer/UpdateExpressionState.cs

@@ -26,7 +26,7 @@ internal readonly struct UpdateExpressionState<
 {
     private static readonly ImmutableArray<(string name, bool isLinq)> s_multiAddNames =
     [
-        (nameof(List<int>.AddRange), isLinq: false),
+        (nameof(List<>.AddRange), isLinq: false),
         (nameof(Enumerable.Concat), isLinq: true),
         (nameof(Enumerable.Append), isLinq: true),
     ];

src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs

@@ -22,7 +22,7 @@ internal static class UseNullPropagationHelpers
     public static bool IsSystemNullableValueProperty([NotNullWhen(true)] ISymbol? symbol)
         => symbol is
         {
-            Name: nameof(Nullable<int>.Value),
+            Name: nameof(Nullable<>.Value),
             ContainingType.OriginalDefinition.SpecialType: SpecialType.System_Nullable_T,
         };
 }

src/Analyzers/Core/CodeFixes/ForEachCast/AbstractForEachCastCodeFixProvider.cs

@@ -29,7 +29,7 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         if (context.Diagnostics.First().Properties.ContainsKey(ForEachCastHelpers.IsFixable))
         {
-            RegisterCodeFix(context, AnalyzersResources.Add_explicit_cast, nameof(AbstractForEachCastCodeFixProvider<SyntaxNode>));
+            RegisterCodeFix(context, AnalyzersResources.Add_explicit_cast, nameof(AbstractForEachCastCodeFixProvider<>));
         }
 
         return Task.CompletedTask;

src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateMethodService.State.cs

@@ -167,7 +167,7 @@ private bool TryInitializeSimpleName(
                 {
                     // If we inferred Func/Action here, attempt to create better parameter names than the default
                     // 'arg1/arg2/arg3' form that the delegate specifies.
-                    var parameterNames = delegateInvokeMethod.ContainingType is { Name: nameof(Action) or nameof(Func<int>), ContainingNamespace.Name: nameof(System) }
+                    var parameterNames = delegateInvokeMethod.ContainingType is { Name: nameof(Action) or nameof(Func<>), ContainingNamespace.Name: nameof(System) }
                         ? GenerateParameterNamesBasedOnParameterTypes(delegateInvokeMethod.Parameters)
                         : delegateInvokeMethod.Parameters.SelectAsArray(p => p.Name);
 

src/Analyzers/Core/CodeFixes/UseNullPropagation/AbstractUseNullPropagationCodeFixProvider.cs

@@ -243,7 +243,7 @@ private void FixIfStatement(
                 syntaxFacts.GetNameAndArityOfSimpleName(nameNode, out var name, out var arity);
                 var comparer = syntaxFacts.StringComparer;
 
-                if (arity == 0 && comparer.Equals(name, nameof(Nullable<int>.Value)))
+                if (arity == 0 && comparer.Equals(name, nameof(Nullable<>.Value)))
                 {
                     // They're calling ".Value" off of a nullable.  Because we're moving to ?.
                     // we want to remove the .Value as well.  i.e. we should generate:

src/EditorFeatures/Core/Lightup/ISmartRenameSessionWrapper.cs

@@ -63,10 +63,10 @@ static ISmartRenameSessionWrapper()
                                                                                                                                defaultValue: SpecializedTasks.Null<object>());
 
             s_renameContextImmutableListBuilderAddAccessor = LightupHelpers.CreateActionAccessor<object, object>(typeof(ImmutableArray<>.Builder).MakeGenericType(s_wrappedRenameContextType),
-                                                                                                                 nameof(ImmutableArray<object>.Builder.Add),
+                                                                                                                 nameof(ImmutableArray<>.Builder.Add),
                                                                                                                  s_wrappedRenameContextType);
             s_renameContextImmutableListBuilderToArrayAccessor = LightupHelpers.CreateFunctionAccessor<object, object>(typeof(ImmutableArray<>.Builder).MakeGenericType(s_wrappedRenameContextType),
-                                                                                                                       nameof(ImmutableArray<object>.Builder.ToImmutable),
+                                                                                                                       nameof(ImmutableArray<>.Builder.ToImmutable),
                                                                                                                        typeof(ImmutableArray<>).MakeGenericType(s_wrappedRenameContextType));
 
             var immutableArrayOfRenameContextType = typeof(ImmutableArray<>).MakeGenericType(s_wrappedRenameContextType);

src/EditorFeatures/TestUtilities/Diagnostics/DiagnosticTaggerWrapper.cs

@@ -55,7 +55,7 @@ public AbstractDiagnosticsTaggerProvider<TTag> TaggerProvider
         {
             if (_taggerProvider == null)
             {
-                WpfTestRunner.RequireWpfFact($"{nameof(DiagnosticTaggerWrapper<TProvider, TTag>)}.{nameof(TaggerProvider)} creates asynchronous taggers");
+                WpfTestRunner.RequireWpfFact($"{nameof(DiagnosticTaggerWrapper<,>)}.{nameof(TaggerProvider)} creates asynchronous taggers");
 
                 if (typeof(TProvider) == typeof(InlineDiagnosticsTaggerProvider))
                 {

src/Features/CSharp/Portable/ConvertLinq/ConvertForEachToLinqQuery/ToToListConverter.cs

@@ -49,6 +49,6 @@ protected override StatementSyntax CreateDefaultStatement(ExpressionSyntax query
                 SyntaxFactory.MemberAccessExpression(
                     SyntaxKind.SimpleMemberAccessExpression,
                     expression,
-                    SyntaxFactory.IdentifierName(nameof(List<object>.AddRange))),
+                    SyntaxFactory.IdentifierName(nameof(List<>.AddRange))),
                 SyntaxFactory.ArgumentList([SyntaxFactory.Argument(queryOrLinqInvocationExpression)])));
 }

src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs

@@ -119,7 +119,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
 
     private static IMethodSymbol? TryGetCompareMethodImpl(INamedTypeSymbol containingType, ITypeSymbol comparableType)
     {
-        foreach (var member in comparableType.GetMembers(nameof(IComparable<int>.CompareTo)))
+        foreach (var member in comparableType.GetMembers(nameof(IComparable<>.CompareTo)))
         {
             if (member is IMethodSymbol method)
                 return (IMethodSymbol?)containingType.FindImplementationForInterfaceMember(method);

src/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/MethodHandlerDetails.cs

@@ -115,9 +115,9 @@ private static (string name, IEnumerable<string> languages) GetRequestHandlerMet
 
         static LanguageServerEndpointAttribute? GetMethodAttributeFromHandlerMethod(Type handlerType, Type? requestType, Type contextType, Type? responseType)
         {
-            const string HandleRequestName = nameof(IRequestHandler<object, object, object>.HandleRequestAsync);
+            const string HandleRequestName = nameof(IRequestHandler<,,>.HandleRequestAsync);
             const string HandleRequestSuffix = "." + HandleRequestName;
-            const string HandleNotificationName = nameof(INotificationHandler<object, object>.HandleNotificationAsync);
+            const string HandleNotificationName = nameof(INotificationHandler<,>.HandleNotificationAsync);
             const string HandleNotificationSuffix = "." + HandleNotificationName;
 
             foreach (var methodInfo in handlerType.GetRuntimeMethods())

src/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestExecutionQueue.cs

@@ -55,7 +55,7 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 internal class RequestExecutionQueue<TRequestContext> : IRequestExecutionQueue<TRequestContext>
 {
     private static readonly MethodInfo s_processQueueCoreAsync = typeof(RequestExecutionQueue<TRequestContext>)
-        .GetMethod(nameof(RequestExecutionQueue<TRequestContext>.ProcessQueueCoreAsync), BindingFlags.NonPublic | BindingFlags.Instance)!;
+        .GetMethod(nameof(RequestExecutionQueue<>.ProcessQueueCoreAsync), BindingFlags.NonPublic | BindingFlags.Instance)!;
 
     protected readonly ILspLogger _logger;
     protected readonly AbstractHandlerProvider _handlerProvider;

src/RoslynAnalyzers/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Helpers/DiagnosticWellKnownNames.cs

@@ -11,7 +11,7 @@ internal static class DiagnosticWellKnownNames
         internal const string RegisterSyntaxNodeActionName = nameof(AnalysisContext.RegisterSyntaxNodeAction);
         internal const string RegisterSymbolActionName = nameof(AnalysisContext.RegisterSymbolAction);
         internal const string RegisterCodeBlockStartActionName = nameof(AnalysisContext.RegisterCodeBlockStartAction);
-        internal const string RegisterCodeBlockEndActionName = nameof(CodeBlockStartAnalysisContext<int>.RegisterCodeBlockEndAction);
+        internal const string RegisterCodeBlockEndActionName = nameof(CodeBlockStartAnalysisContext<>.RegisterCodeBlockEndAction);
         internal const string RegisterCodeBlockActionName = nameof(AnalysisContext.RegisterCodeBlockAction);
         internal const string RegisterOperationBlockStartActionName = nameof(AnalysisContext.RegisterOperationBlockStartAction);
         internal const string RegisterOperationBlockEndActionName = nameof(OperationBlockStartAnalysisContext.RegisterOperationBlockEndAction);

src/RoslynAnalyzers/Roslyn.Diagnostics.Analyzers/Core/AbstractApplyTraitToClass`1.cs

@@ -61,7 +61,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 CodeAction.Create(
                     RoslynDiagnosticsAnalyzersResources.ApplyTraitToContainingType,
                     cancellationToken => ApplyTraitToClassAsync(state, cancellationToken),
-                    nameof(AbstractApplyTraitToClass<TAttributeSyntax>)));
+                    nameof(AbstractApplyTraitToClass<>)));
         }
 
         private async Task<Document> ApplyTraitToClassAsync(State state, CancellationToken cancellationToken)