Improve implied argument names

docs/release-notes/.FSharp.Compiler.Service/11.0.100.md

@@ -106,6 +106,7 @@
 * Debug: rework conditional erasure, fix stepping over literals ([PR #19897](https://github.com/dotnet/fsharp/pull/19897))
 * Debug: fix if and match condition sequence points ([PR #19932](https://github.com/dotnet/fsharp/pull/19932))
 * Checker: recover on checking language version ([PR ##19970](https://github.com/dotnet/fsharp/pull/19970))
+* Implied argument names for function-to-delegate coercions now fall back to the delegate's `Invoke` parameter names when the function has no recoverable names (e.g. a partial application like `System.Func<int, int>((+) 1)`), instead of synthetic `delegateArg0`, `delegateArg1`, … names. ([PR #20001](https://github.com/dotnet/fsharp/pull/20001))
 
 ### Improved
 

docs/release-notes/.Language/preview.md

@@ -3,6 +3,7 @@
 * Warn (FS3884) when a function or delegate value is used as an interpolated string argument, since it will be formatted via `ToString` rather than being applied. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289))
 * Added `MethodOverloadsCache` language feature (preview) that caches overload resolution results for repeated method calls, significantly improving compilation performance. ([PR #19072](https://github.com/dotnet/fsharp/pull/19072))
 * Added `ErrorOnMissingSignatureAttribute` preview language feature: makes FS3888 (compiler-semantic attribute on the `.fs` but not on the `.fsi`) an error instead of a warning. ([Issue #19560](https://github.com/dotnet/fsharp/issues/19560), [PR #19880](https://github.com/dotnet/fsharp/pull/19880))
+* Added `ImprovedImpliedArgumentNamesPartTwo` language feature: when a function with no recoverable parameter names is coerced to a delegate (e.g. a partial application like `System.Func<int, int>((+) 1)`), the synthesized `Invoke` parameters take their names from the delegate's own `Invoke` signature instead of synthetic `delegateArg0`, `delegateArg1`, … names. ([PR #20001](https://github.com/dotnet/fsharp/pull/20001))
 
 ### Fixed
 

src/Compiler/Checking/MethodCalls.fs

@@ -1355,15 +1355,24 @@ let BuildNewDelegateExpr (eventInfoOpt: EventInfo option, g, amap, delegateTy, d
                     | _ -> None
                 | _ -> None
 
+            let delInvokeArgNamesIfFeatureEnabled =
+                if g.langVersion.SupportsFeature LanguageFeature.ImprovedImpliedArgumentNamesPartTwo then
+                    delInvokeMeth.GetParamNames() |> List.concat
+                else
+                    []
+
             let delArgVals =
                 delArgTys
                 |> List.mapi (fun i argTy ->
                     let argName =
                         match delFuncArgNamesIfFeatureEnabled with
                         | Some argNames -> argNames[i]
-                        | None -> "delegateArg" + string i
+                        | None ->
+                            match List.tryItem i delInvokeArgNamesIfFeatureEnabled with
+                            | Some (Some name) when name <> "" -> name
+                            | _ -> "delegateArg" + string i
 
-                    fst (mkCompGenLocal m argName argTy)) 
+                    fst (mkCompGenLocal m argName argTy))
 
             let expr = 
                 let args = 

src/Compiler/FSComp.txt

@@ -1822,3 +1822,4 @@ featurePreprocessorElif,"#elif preprocessor directive"
 3889,tastNamespaceAndTypeWithSameNameInAssembly,"The namespace '%s' clashes with the type '%s'."
 featureExceptionFieldSerializationSupport,"emit GetObjectData and field-restoring deserialization constructor for exception types"
 featureErrorOnMissingSignatureAttribute,"error (rather than warning) when an enforced compiler-semantic attribute is present in the .fs but missing from the .fsi"
+featureImprovedImpliedArgumentNamesPartTwo,"Improved implied argument names with partial application"

src/Compiler/Facilities/LanguageFeatures.fs

@@ -110,6 +110,7 @@ type LanguageFeature =
     | PreprocessorElif
     | ExceptionFieldSerializationSupport
     | ErrorOnMissingSignatureAttribute
+    | ImprovedImpliedArgumentNamesPartTwo
 
 /// LanguageVersion management
 type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) =
@@ -254,6 +255,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
                 LanguageFeature.WarnWhenFunctionValueUsedAsInterpolatedStringArg, languageVersion110
                 LanguageFeature.PreprocessorElif, languageVersion110
                 LanguageFeature.ExceptionFieldSerializationSupport, languageVersion110
+                LanguageFeature.ImprovedImpliedArgumentNamesPartTwo, languageVersion110
 
                 // Difference between languageVersion110 and preview - 11.0 gets turned on automatically by picking a preview .NET 11 SDK
                 // previewVersion is only when "preview" is specified explicitly in project files  and users also need a preview SDK
@@ -459,6 +461,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
         | LanguageFeature.PreprocessorElif -> FSComp.SR.featurePreprocessorElif ()
         | LanguageFeature.ExceptionFieldSerializationSupport -> FSComp.SR.featureExceptionFieldSerializationSupport ()
         | LanguageFeature.ErrorOnMissingSignatureAttribute -> FSComp.SR.featureErrorOnMissingSignatureAttribute ()
+        | LanguageFeature.ImprovedImpliedArgumentNamesPartTwo -> FSComp.SR.featureImprovedImpliedArgumentNamesPartTwo ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -101,6 +101,7 @@ type LanguageFeature =
     | PreprocessorElif
     | ExceptionFieldSerializationSupport
     | ErrorOnMissingSignatureAttribute
+    | ImprovedImpliedArgumentNamesPartTwo
 
 /// LanguageVersion management
 type LanguageVersion =

tests/FSharp.Compiler.ComponentTests/EmittedIL/ArgumentNames.fs

@@ -176,3 +176,48 @@ let test1 = System.Action<_, _>(add)
                                                  int32)
   IL_0009:  ret
 } """ ]
+
+    [<Fact>]
+    let ``Implied argument names are taken from delegate Invoke for a partial application``() =
+        FSharp """
+module ArgumentNames
+
+type Combine = delegate of first: int * second: int * third: int * fourth: int -> int
+
+[<System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)>]
+let f a b c d e g = a + b + c + d + e + g
+
+let test1 = Combine(f 1 2)
+        """
+        |> withLangVersion11
+        |> compile
+        |> shouldSucceed
+        |> verifyIL ["
+.method assembly static int32  Invoke(int32 first,
+                                      int32 second,
+                                      int32 third,
+                                      int32 fourth) cil managed" ]
+
+    [<Fact>]
+    let ``Implied argument names are taken from delegate Invoke for a function composition``() =
+        FSharp """
+module ArgumentNames
+
+let test1 = System.Func<int, int>(((+) 1) >> ((*) 2))
+        """
+        |> withLangVersion11
+        |> compile
+        |> shouldSucceed
+        |> verifyIL ["Invoke(int32 arg) cil managed" ]
+
+    [<Fact>]
+    let ``Partial application delegate falls back to synthetic name before the feature``() =
+        FSharp """
+module ArgumentNames
+
+let test1 = System.Func<int, int>((+) 1)
+        """
+        |> withLangVersion10
+        |> compile
+        |> shouldSucceed
+        |> verifyIL ["Invoke(int32 delegateArg0) cil managed" ]

tests/FSharp.Test.Utilities/Compiler.fs

@@ -644,6 +644,9 @@ $ code --diff {outFile} {expectedFile}
 
     let withLangVersion10 (cUnit: CompilationUnit) : CompilationUnit =
         withOptionsHelper [ "--langversion:10.0" ] "withLangVersion10 is only supported on F#" cUnit
+
+    let withLangVersion11 (cUnit: CompilationUnit) : CompilationUnit =
+        withOptionsHelper [ "--langversion:11.0" ] "withLangVersion11 is only supported on F#" cUnit
 
     let withLangVersionPreview (cUnit: CompilationUnit) : CompilationUnit =
         withOptionsHelper [ "--langversion:preview" ] "withLangVersionPreview is only supported on F#" cUnit