WIP: Fix optional argument and caller info for delegates - encountering IL generation issue

Co-authored-by: T-Gro <[email protected]>

Author: Copilot

src/Compiler/Checking/CheckDeclarations.fs

@@ -3714,18 +3714,19 @@ module EstablishTypeDefinitionCores =
                                   let ttps = thisTyconRef.Typars m
                                   let fparams =
                                       curriedArgInfos.Head
-                                      |> List.map (fun (ty, argInfo: ArgReprInfo) ->
+                                      |> List.map (fun (origTy, argInfo: ArgReprInfo) ->
                                             let ty =
                                               if HasFSharpAttribute g g.attrib_OptionalArgumentAttribute argInfo.Attribs then
                                                   match TryFindFSharpAttribute g g.attrib_StructAttribute argInfo.Attribs with
                                                   | Some (Attrib(range=m)) ->
                                                       checkLanguageFeatureAndRecover g.langVersion LanguageFeature.SupportValueOptionsAsOptionalParameters m
-                                                      mkValueOptionTy g ty
+                                                      mkValueOptionTy g origTy
                                                   | _ ->
-                                                      mkOptionTy g ty            
-                                              else ty
+                                                      mkOptionTy g origTy            
+                                              else origTy
 
-                                            MakeSlotParam(ty, argInfo)) 
+                                            let (ParamAttribs(_, isInArg, isOutArg, optArgInfo, _, _)) = CrackParamAttribsInfo g (origTy, argInfo)
+                                            TSlotParam(Option.map textOfId argInfo.Name, ty, isInArg, isOutArg, optArgInfo.IsOptional, argInfo.Attribs)) 
                                   TFSharpDelegate (MakeSlotSig("Invoke", thisTy, ttps, [], [fparams], returnTy))
                               | _ -> 
                                   error(InternalError("should have inferred tycon kind", m))

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/DelegateTypes/DelegateDefinition.fs

@@ -66,4 +66,83 @@ let a = A f
 a.Invoke(5)"""
         |> compileExeAndRun
         |> shouldSucceed
-        |> verifyOutput "line: 5" 
+        |> verifyOutput "line: 5"
+
+    [<Fact>]
+    let ``Delegate with OptionalArgument and CallerFilePath`` () =
+        FSharp """open System.Runtime.CompilerServices
+open System.Runtime.InteropServices
+type TestDelegate = delegate of [<OptionalArgument; CallerFilePath>] path: string option -> unit
+let f = fun (path: string option) -> 
+    match path with
+    | Some p -> if p.Contains("test") then printfn "SUCCESS" else printfn "FAIL: %s" p
+    | None -> printfn "FAIL: None"
+let d = TestDelegate f
+d.Invoke()"""
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> verifyOutput "SUCCESS"
+
+    [<Fact>]
+    let ``Delegate with OptionalArgument and CallerLineNumber`` () =
+        FSharp """open System.Runtime.CompilerServices
+open System.Runtime.InteropServices
+type TestDelegate = delegate of [<OptionalArgument; CallerLineNumber>] line: int option -> unit
+let f = fun (line: int option) -> 
+    match line with
+    | Some l -> if l > 0 then printfn "SUCCESS: line %d" l else printfn "FAIL"
+    | None -> printfn "FAIL: None"
+let d = TestDelegate f
+d.Invoke()"""
+        |> compileExeAndRun
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``Delegate with OptionalArgument and CallerMemberName`` () =
+        FSharp """open System.Runtime.CompilerServices
+open System.Runtime.InteropServices
+type TestDelegate = delegate of [<OptionalArgument; CallerMemberName>] memberName: string option -> unit
+let f = fun (memberName: string option) -> 
+    match memberName with
+    | Some m -> printfn "member: %s" m
+    | None -> printfn "FAIL"
+let d = TestDelegate f
+d.Invoke()"""
+        |> compileExeAndRun
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``Delegate with CallerFilePath without optional should fail`` () =
+        FSharp """namespace Test
+open System.Runtime.CompilerServices
+type TestDelegate = delegate of [<CallerFilePath>] path: string -> unit"""
+        |> compile
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 1247, Line 3, Col 41, Line 3, Col 45, "'CallerFilePath' can only be applied to optional arguments")
+        ]
+
+    [<Fact>]
+    let ``Delegate with CallerFilePath on wrong type should fail`` () =
+        FSharp """namespace Test
+open System.Runtime.CompilerServices
+open System.Runtime.InteropServices
+type TestDelegate = delegate of [<OptionalArgument; CallerFilePath>] x: int option -> unit"""
+        |> compile
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 1246, Line 4, Col 69, Line 4, Col 70, "'CallerFilePath' must be applied to an argument of type 'string', but has been applied to an argument of type 'int'")
+        ]
+
+    [<Fact>]
+    let ``Delegate with CallerLineNumber on wrong type should fail`` () =
+        FSharp """namespace Test
+open System.Runtime.CompilerServices
+open System.Runtime.InteropServices
+type TestDelegate = delegate of [<OptionalArgument; CallerLineNumber>] x: string option -> unit"""
+        |> compile
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 1246, Line 4, Col 73, Line 4, Col 74, "'CallerLineNumber' must be applied to an argument of type 'int', but has been applied to an argument of type 'string'")
+        ]
+