Improve arity error message to prefer generic type when both generic and non-generic exist (#80707)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: CyrusNajmabadi <4564579+CyrusNajmabadi@users.noreply.github.com>
Co-authored-by: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Co-authored-by: jcouv <12466233+jcouv@users.noreply.github.com>

Author: 3 people

src/Compilers/CSharp/Portable/Binder/LookupResult.cs

@@ -280,17 +280,42 @@ internal void MergeEqual(SingleLookupResult result)
         {
             if (Kind > result.Kind)
             {
-                // existing result is better
+                // Existing result is strictly better.  Ignore what is incoming.  
+                return;
             }
-            else if (result.Kind > Kind)
+
+            if (result.Kind > Kind)
             {
+                // Incoming result is better.  Let it win completely over anything we've built up so far.
                 this.SetFrom(result);
+                return;
             }
-            else if ((object)result.Symbol != null)
+
+            if (Kind == LookupResultKind.WrongArity && result.Kind == LookupResultKind.WrongArity)
             {
-                // Same goodness. Include all symbols
-                _symbolList.Add(result.Symbol);
+                if (isNonGenericVersusGeneric(result.Symbol, this.SingleSymbolOrDefault))
+                {
+                    // Current result is generic, and incoming is not.  We just want stick with what we currently have
+                    // as the better symbol to be referring to when generics are provided, but arity is wrong.
+                    return;
+                }
+
+                if (isNonGenericVersusGeneric(this.SingleSymbolOrDefault, result.Symbol))
+                {
+                    // Current result is non generic, but incoming is generic.  It's strictly the better symbol to be
+                    // referring to when generics are provided, but arity is wrong.
+                    this.SetFrom(result);
+                    return;
+                }
+
+                // Neither is preferred, fall through and include all symbols.
             }
+
+            // Same goodness. Include all symbols
+            _symbolList.AddIfNotNull(result.Symbol);
+
+            static bool isNonGenericVersusGeneric(Symbol firstSymbol, Symbol secondSymbol)
+                => firstSymbol.GetArity() == 0 && secondSymbol.GetArity() > 0;
         }
 
         // global pool

src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs

@@ -1833,9 +1833,9 @@ class C
                 // (20,27): error CS0305: Using the generic type 'N.A<T>' requires '1' type arguments
                 // 
                 Diagnostic(ErrorCode.ERR_BadArity, "A").WithArguments("N.A<T>", "type", "1"),
-                // (21,34): error CS0308: The non-generic type 'N.B' cannot be used with type arguments
+                // (21,34): error CS0305: Using the generic type 'N.B<T1, T2>' requires '2' type arguments
                 // 
-                Diagnostic(ErrorCode.ERR_HasNoTypeVars, "B<int>").WithArguments("N.B", "type")
+                Diagnostic(ErrorCode.ERR_BadArity, "B<int>").WithArguments("N.B<T1, T2>", "type", "2")
                 );
         }
 
@@ -4080,5 +4080,198 @@ static void M(bool a, object b)
 
             VerifyOperationTree(comp, model.GetOperation(ifStmt), operationString);
         }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24406")]
+        public void TestGenericAndNonGenericType()
+        {
+            var text = """
+                class MyExpression { }
+                class MyExpression<T> { }
+
+                class Test
+                {
+                    void M()
+                    {
+                        MyExpression<int, string> x;
+                    }
+                }
+                """;
+
+            CreateCompilation(text).VerifyDiagnostics(
+                // (8,9): error CS0305: Using the generic type 'MyExpression<T>' requires 1 type arguments
+                //         MyExpression<int, string> x;
+                Diagnostic(ErrorCode.ERR_BadArity, "MyExpression<int, string>").WithArguments("MyExpression<T>", "type", "1").WithLocation(8, 9),
+                // (8,35): warning CS0168: The variable 'x' is declared but never used
+                //         MyExpression<int, string> x;
+                Diagnostic(ErrorCode.WRN_UnreferencedVar, "x").WithArguments("x").WithLocation(8, 35));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24406")]
+        public void TestGenericAndNonGenericType_SingleTypeArgument()
+        {
+            var text = """
+                class MyExpression { }
+                class MyExpression<T> { }
+
+                class Test
+                {
+                    void M()
+                    {
+                        MyExpression<int> x = null;
+                    }
+                }
+                """;
+
+            CreateCompilation(text).VerifyDiagnostics(
+                // (8,27): warning CS0219: The variable 'x' is assigned but its value is never used
+                //         MyExpression<int> x = null;
+                Diagnostic(ErrorCode.WRN_UnreferencedVarAssg, "x").WithArguments("x").WithLocation(8, 27));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24406")]
+        public void TestNonGenericTypeOnly()
+        {
+            var text = """
+                class MyExpression { }
+
+                class Test
+                {
+                    void M()
+                    {
+                        MyExpression<int> x;
+                    }
+                }
+                """;
+
+            CreateCompilation(text).VerifyDiagnostics(
+                // (7,9): error CS0308: The non-generic type 'MyExpression' cannot be used with type arguments
+                //         MyExpression<int> x;
+                Diagnostic(ErrorCode.ERR_HasNoTypeVars, "MyExpression<int>").WithArguments("MyExpression", "type").WithLocation(7, 9),
+                // (7,27): warning CS0168: The variable 'x' is declared but never used
+                //         MyExpression<int> x;
+                Diagnostic(ErrorCode.WRN_UnreferencedVar, "x").WithArguments("x").WithLocation(7, 27));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24406")]
+        public void TestGenericTypeOnly()
+        {
+            var text = """
+                class MyExpression<T> { }
+
+                class Test
+                {
+                    void M()
+                    {
+                        MyExpression<int, string> x;
+                    }
+                }
+                """;
+
+            CreateCompilation(text).VerifyDiagnostics(
+                // (7,9): error CS0305: Using the generic type 'MyExpression<T>' requires 1 type arguments
+                //         MyExpression<int, string> x;
+                Diagnostic(ErrorCode.ERR_BadArity, "MyExpression<int, string>").WithArguments("MyExpression<T>", "type", "1").WithLocation(7, 9),
+                // (7,35): warning CS0168: The variable 'x' is declared but never used
+                //         MyExpression<int, string> x;
+                Diagnostic(ErrorCode.WRN_UnreferencedVar, "x").WithArguments("x").WithLocation(7, 35));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24406")]
+        public void TestMultipleGenericTypes()
+        {
+            var text = """
+                class MyExpression { }
+                class MyExpression<T> { }
+                class MyExpression<T1, T2> { }
+
+                class Test
+                {
+                    void M()
+                    {
+                        MyExpression<int, string, bool> x;
+                    }
+                }
+                """;
+
+            CreateCompilation(text).VerifyDiagnostics(
+                // (9,9): error CS0305: Using the generic type 'MyExpression<T>' requires 1 type arguments
+                //         MyExpression<int, string, bool> x;
+                Diagnostic(ErrorCode.ERR_BadArity, "MyExpression<int, string, bool>").WithArguments("MyExpression<T>", "type", "1").WithLocation(9, 9),
+                // (9,41): warning CS0168: The variable 'x' is declared but never used
+                //         MyExpression<int, string, bool> x;
+                Diagnostic(ErrorCode.WRN_UnreferencedVar, "x").WithArguments("x").WithLocation(9, 41));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24406")]
+        public void TestGenericTypeWithNoTypeArguments()
+        {
+            var text = """
+                class MyExpression { }
+                class MyExpression<T> { }
+
+                class Test
+                {
+                    void M()
+                    {
+                        MyExpression x;
+                    }
+                }
+                """;
+
+            // When both generic and non-generic versions exist and no type arguments are provided,
+            // the non-generic version is successfully used (no error expected)
+            CreateCompilation(text).VerifyDiagnostics(
+                // (8,22): warning CS0168: The variable 'x' is declared but never used
+                //         MyExpression x;
+                Diagnostic(ErrorCode.WRN_UnreferencedVar, "x").WithArguments("x").WithLocation(8, 22));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24406")]
+        public void TestGenericTypeOnlyWithNoTypeArguments()
+        {
+            var text = """
+                class MyExpression<T> { }
+
+                class Test
+                {
+                    void M()
+                    {
+                        MyExpression x;
+                    }
+                }
+                """;
+
+            // When only a generic type exists and no type arguments are provided,
+            // an error is reported about the required type arguments
+            CreateCompilation(text).VerifyDiagnostics(
+                // (7,9): error CS0305: Using the generic type 'MyExpression<T>' requires 1 type arguments
+                //         MyExpression x;
+                Diagnostic(ErrorCode.ERR_BadArity, "MyExpression").WithArguments("MyExpression<T>", "type", "1").WithLocation(7, 9),
+                // (7,22): warning CS0168: The variable 'x' is declared but never used
+                //         MyExpression x;
+                Diagnostic(ErrorCode.WRN_UnreferencedVar, "x").WithArguments("x").WithLocation(7, 22));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24406")]
+        public void TestGenericAndNonGenericMethod()
+        {
+            var text = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        M<int>(default!); 
+                    }
+
+                    void M(object obj) { }
+                    T2 M<T1, T2>(T1 t) => throw null!;
+                }
+                """;
+
+            CreateCompilation(text).VerifyEmitDiagnostics(
+                // (5,9): error CS0305: Using the generic method 'Program.M<T1, T2>(T1)' requires 2 type arguments
+                //         M<int>(default!); 
+                Diagnostic(ErrorCode.ERR_BadArity, "M<int>").WithArguments("Program.M<T1, T2>(T1)", "method", "2").WithLocation(5, 9));
+        }
     }
 }

src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs

@@ -3588,12 +3588,12 @@ static void Main()
 }";
             var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
             comp.VerifyDiagnostics(
-                // (12,13): error CS0308: The non-generic method 'Program.F0(object)' cannot be used with type arguments
+                // (12,13): error CS0305: Using the generic method 'Program.F0<T>(object)' requires 1 type arguments
                 //         d = F0<int, object>;
-                Diagnostic(ErrorCode.ERR_HasNoTypeVars, "F0<int, object>").WithArguments("Program.F0(object)", "method").WithLocation(12, 13),
-                // (13,13): error CS0308: The non-generic method 'Program.F1(object)' cannot be used with type arguments
+                Diagnostic(ErrorCode.ERR_BadArity, "F0<int, object>").WithArguments("Program.F0<T>(object)", "method", "1").WithLocation(12, 13),
+                // (13,13): error CS0305: Using the generic method 'Program.F1<T, U>(object)' requires 2 type arguments
                 //         d = F1<int>;
-                Diagnostic(ErrorCode.ERR_HasNoTypeVars, "F1<int>").WithArguments("Program.F1(object)", "method").WithLocation(13, 13),
+                Diagnostic(ErrorCode.ERR_BadArity, "F1<int>").WithArguments("Program.F1<T, U>(object)", "method", "2").WithLocation(13, 13),
                 // (14,13): error CS8917: The delegate type could not be inferred.
                 //         d = F2;
                 Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F2").WithLocation(14, 13));

src/EditorFeatures/Test2/FindReferences/FindReferencesTests.NamedTypeSymbols.vb

@@ -446,7 +446,7 @@ class A
             private C<T> c2;
             private C<int> c3;
             private C<C<T>> c4;
-            private [|C|]<int,string> c5;
+            private C<int,string> c5;
         }
         class C<T>
         {