Fix #14190: Narrow 'No matching overload' error range to method name only

In TcMethodApplication, remap UnresolvedOverloading error range from the
whole expression (mMethExpr) to just the method name identifier. This
prevents the error from covering the entire expression including object
access chains and arguments.

Add regression tests for instance calls, static calls, chained expressions,
and lambda arguments.

Agent-Logs-Url: https://github.com/dotnet/fsharp/sessions/d3913698-2bf7-4b33-8c76-1079e067156b

Co-authored-by: abonie <20281641+abonie@users.noreply.github.com>

Author: Copilot

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -10401,6 +10401,19 @@ and TcMethodApplication
 
         let result, errors = ResolveOverloadingForCall denv cenv.css mMethExpr methodName callerArgs ad postArgumentTypeCheckingCalledMethGroup true returnTy
 
+        // Narrow the error range for unresolved overloading from the whole expression (mMethExpr)
+        // to just the method name. For instance calls like T.Instance.Method(""), mItem covers
+        // the entire "T.Instance.Method" range, so we compute the method-name-only range from
+        // the end of mItem and the method name length. See https://github.com/dotnet/fsharp/issues/14190.
+        let errors =
+            match errors with
+            | ErrorResult(warns, UnresolvedOverloading(denvErr, callerArgsErr, failure, _mWide)) ->
+                let mMethodName =
+                    let startPos = mkPos mItem.EndLine (mItem.EndColumn - methodName.Length)
+                    withStart startPos mItem
+                ErrorResult(warns, UnresolvedOverloading(denvErr, callerArgsErr, failure, mMethodName))
+            | other -> other
+
         match afterResolution, result with
         | AfterResolution.DoNothing, _ -> ()
 

tests/FSharp.Compiler.ComponentTests/ErrorMessages/OverloadResolutionErrorRangeTests.fs

@@ -0,0 +1,99 @@
+module ErrorMessages.OverloadResolutionErrorRangeTests
+
+open Xunit
+open FSharp.Test.Compiler
+
+// https://github.com/dotnet/fsharp/issues/14190
+[<Fact>]
+let ``Issue 14190 - overload error should cover only method name, not full expression`` () =
+    FSharp
+        """
+type T() =
+    static member Instance = T()
+
+    member _.Method(_: double) = ()
+    member _.Method(_: int) = ()
+
+T.Instance.Method("")
+        """
+    |> typecheck
+    |> shouldFail
+    |> withDiagnostics
+        [ (Error 41, Line 8, Col 12, Line 8, Col 18, "No overloads match for method 'Method'.
+
+Known type of argument: string
+
+Available overloads:
+ - member T.Method: double -> unit // Argument at index 1 doesn't match
+ - member T.Method: int -> unit // Argument at index 1 doesn't match") ]
+
+// Verify that the error range is narrow also for simple direct method calls
+[<Fact>]
+let ``Issue 14190 - overload error for simple static method`` () =
+    FSharp
+        """
+type T() =
+    static member Method(_: double) = ()
+    static member Method(_: int) = ()
+
+T.Method("")
+        """
+    |> typecheck
+    |> shouldFail
+    |> withDiagnostics
+        [ (Error 41, Line 6, Col 3, Line 6, Col 9, "No overloads match for method 'Method'.
+
+Known type of argument: string
+
+Available overloads:
+ - static member T.Method: double -> unit // Argument at index 1 doesn't match
+ - static member T.Method: int -> unit // Argument at index 1 doesn't match") ]
+
+// Verify that a long expression before the method doesn't widen the error range
+[<Fact>]
+let ``Issue 14190 - overload error on chained expression`` () =
+    FSharp
+        """
+type T() =
+    static member Instance = T()
+
+    member _.Next = T()
+    member _.Method(_: double) = ()
+    member _.Method(_: int) = ()
+
+T.Instance.Next.Next.Method("")
+        """
+    |> typecheck
+    |> shouldFail
+    |> withDiagnostics
+        [ (Error 41, Line 9, Col 22, Line 9, Col 28, "No overloads match for method 'Method'.
+
+Known type of argument: string
+
+Available overloads:
+ - member T.Method: double -> unit // Argument at index 1 doesn't match
+ - member T.Method: int -> unit // Argument at index 1 doesn't match") ]
+
+// Verify error range with lambda argument
+[<Fact>]
+let ``Issue 14190 - overload error with lambda argument`` () =
+    FSharp
+        """
+type T() =
+    static member Instance = T()
+
+    member _.Method(_: double) = ()
+    member _.Method(_: int) = ()
+
+T.Instance.Method(fun () -> "")
+        """
+    |> typecheck
+    |> shouldFail
+    |> withDiagnostics
+        [ (Error 41, Line 8, Col 12, Line 8, Col 18, "No overloads match for method 'Method'.
+
+Known type of argument: (unit -> string)
+
+Available overloads:
+ - member T.Method: double -> unit // Argument at index 1 doesn't match
+ - member T.Method: int -> unit // Argument at index 1 doesn't match") ]

tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj

@@ -301,6 +301,7 @@
     <Compile Include="ErrorMessages\MissingExpressionTests.fs" />
     <Compile Include="ErrorMessages\ModuleTests.fs" />
     <Compile Include="ErrorMessages\DiagnosticRegressionTests.fs" />
+    <Compile Include="ErrorMessages\OverloadResolutionErrorRangeTests.fs" />
     <Compile Include="ErrorMessages\NameResolutionTests.fs" />
     <Compile Include="ErrorMessages\SuggestionsTests.fs" />
     <Compile Include="ErrorMessages\TypeMismatchTests.fs" />