Update to using unbound nameof(X<>) expressions (#78731)

Author: CyrusNajmabadi

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,
         };
 }