Improve arity error message to prefer generic type when both generic and non-generic exist

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

@@ -286,11 +286,34 @@ internal void MergeEqual(SingleLookupResult result)
             {
                 this.SetFrom(result);
             }
+            else if (Kind == LookupResultKind.WrongArity && result.Kind == LookupResultKind.WrongArity)
+            {
+                // When both results are WrongArity, prefer the generic type over the non-generic one
+                // if the user supplied type arguments
+                if (PreferGenericOverNonGeneric(this.SingleSymbolOrDefault, result.Symbol))
+                {
+                    this.SetFrom(result);
+                }
+                else if (!PreferGenericOverNonGeneric(result.Symbol, this.SingleSymbolOrDefault))
+                {
+                    // Neither is preferred, add both symbols
+                    if ((object)result.Symbol != null)
+                    {
+                        _symbolList.Add(result.Symbol);
+                    }
+                }
+                // else: existing result is preferred (generic over non-generic), keep it
+            }
             else if ((object)result.Symbol != null)
             {
                 // Same goodness. Include all symbols
                 _symbolList.Add(result.Symbol);
             }
+
+            static bool PreferGenericOverNonGeneric(Symbol currentSymbol, Symbol newSymbol)
+            {
+                return currentSymbol is NamedTypeSymbol { Arity: 0 } && newSymbol is NamedTypeSymbol { Arity: > 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,126 @@ 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));
+        }
     }
 }

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

@@ -0,0 +1,122 @@
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public class ImprovedArityErrorTests : CSharpTestBase
+    {
+        [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
+                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
+                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
+                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
+                Diagnostic(ErrorCode.ERR_HasNoTypeVars, "MyExpression<int>").WithArguments("MyExpression", "type").WithLocation(7, 9),
+                // (7,27): warning CS0168: The variable 'x' is declared but never used
+                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
+                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
+                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;
+                    }
+                }
+                """;
+            // With multiple generic types and non-generic, should prefer the closest match
+            // In this case, we look for arity 3, find generic with arity 2, that's better than non-generic
+            CreateCompilation(text).VerifyDiagnostics(
+                // (9,9): error CS0305: Using the generic type 'MyExpression<T>' requires 1 type arguments
+                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
+                Diagnostic(ErrorCode.WRN_UnreferencedVar, "x").WithArguments("x").WithLocation(9, 41));
+        }
+    }
+}