Prefer expanded form for error reporting when params arguments are convertible

src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs

@@ -1263,9 +1263,15 @@ private static bool PreferExpandedFormOverNormalForm<TMember>(MemberResolutionRe
                         expandedResult.Result.ParamsElementTypeOpt.HasType &&
                         expandedResult.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel)
                     {
-                        if (haveBadArgumentForLastParameter(normalResult) && haveBadArgumentForLastParameter(expandedResult))
+                        // Prefer expanded form if the normal form has a bad argument for the last parameter.
+                        // This handles two cases:
+                        // 1. Both normal and expanded forms have bad arguments for the last parameter
+                        //    (e.g., both fail but expanded gives better error messages)
+                        // 2. Normal form has a bad argument for the last parameter but expanded form doesn't
+                        //    (e.g., M(char c, params object[] args) called with M(string[], string) where
+                        //    string -> object[] is bad in normal form but string -> object is good in expanded form)
+                        if (haveBadArgumentForLastParameter(normalResult))
                         {
-                            // Errors are better if we use the expanded form in this case.
                             return true;
                         }
                     }

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

@@ -11945,5 +11945,88 @@ readonly struct S
                 """;
             CreateCompilation(source).VerifyDiagnostics();
         }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/12933")]
+        public void ParamsErrorSuppression_StringConvertibleToObject()
+        {
+            var source = """
+                class Program
+                {
+                    static void M(char c, params object[] args) { }
+
+                    static void Test(string[] arr)
+                    {
+                        M(arr, "test");
+                    }
+                }
+                """;
+            CreateCompilation(source).VerifyDiagnostics(
+                // (7,11): error CS1503: Argument 1: cannot convert from 'string[]' to 'char'
+                //         M(arr, "test");
+                Diagnostic(ErrorCode.ERR_BadArgType, "arr").WithArguments("1", "string[]", "char").WithLocation(7, 11));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/12933")]
+        public void ParamsErrorSuppression_IntNotConvertibleToString()
+        {
+            var source = """
+                class C
+                {
+                    static void M(char c, params string[] args) { }
+
+                    static void Test()
+                    {
+                        M(1, 2);
+                    }
+                }
+                """;
+            CreateCompilation(source).VerifyDiagnostics(
+                // (7,11): error CS1503: Argument 1: cannot convert from 'int' to 'char'
+                //         M(1, 2);
+                Diagnostic(ErrorCode.ERR_BadArgType, "1").WithArguments("1", "int", "char").WithLocation(7, 11),
+                // (7,14): error CS1503: Argument 2: cannot convert from 'int' to 'string'
+                //         M(1, 2);
+                Diagnostic(ErrorCode.ERR_BadArgType, "2").WithArguments("2", "int", "string").WithLocation(7, 14));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/43920")]
+        public void ParamsErrorSuppression_Issue43920()
+        {
+            var source = """
+                class Program
+                {
+                    static void M(int x, params object[] args) { }
+
+                    static void Test()
+                    {
+                        M("wrong", "test");
+                    }
+                }
+                """;
+            CreateCompilation(source).VerifyDiagnostics(
+                // (7,11): error CS1503: Argument 1: cannot convert from 'string' to 'int'
+                //         M("wrong", "test");
+                Diagnostic(ErrorCode.ERR_BadArgType, @"""wrong""").WithArguments("1", "string", "int").WithLocation(7, 11));
+        }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/43920")]
+        public void ParamsErrorSuppression_Issue43920_StringParams()
+        {
+            var source = """
+                class Program
+                {
+                    static void A(string a, params string[] b) { }
+
+                    static void Test()
+                    {
+                        A(1, "test");
+                    }
+                }
+                """;
+            CreateCompilation(source).VerifyDiagnostics(
+                // (7,11): error CS1503: Argument 1: cannot convert from 'int' to 'string'
+                //         A(1, "test");
+                Diagnostic(ErrorCode.ERR_BadArgType, "1").WithArguments("1", "int", "string").WithLocation(7, 11));
+        }
     }
 }