Fix method signatures and calling conventions

Fix 4 codegen bugs in method call emission and parameter metadata:
- #13468: outref parameter compiled as byref
- #18135: Static abstract interface members with byref params
- #18140: callvirt on value types causes ILVerify errors
- #18374: RuntimeWrappedException cannot be caught

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: T-Gro

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

@@ -14,6 +14,9 @@
 * Fix FS0229 B-stream misalignment when reading metadata from assemblies compiled with LangVersion < 9.0, introduced by [#17706](https://github.com/dotnet/fsharp/pull/17706). ([PR #19260](https://github.com/dotnet/fsharp/pull/19260))
 * Fix FS3356 false positive for instance extension members with same name on different types, introduced by [#18821](https://github.com/dotnet/fsharp/pull/18821). ([PR #19260](https://github.com/dotnet/fsharp/pull/19260))
 * F# Scripts: Fix default reference paths resolving when an SDK directory is specified. ([PR #19270](https://github.com/dotnet/fsharp/pull/19270))
+* Fix outref parameter compiled as byref. (Issue [#13468](https://github.com/dotnet/fsharp/issues/13468), [PR #19340](https://github.com/dotnet/fsharp/pull/19340))
+* Fix static abstract interface members with byref params. (Issue [#18135](https://github.com/dotnet/fsharp/issues/18135), [PR #19340](https://github.com/dotnet/fsharp/pull/19340))
+* Use constrained.callvirt for method calls on value types. (Issue [#18140](https://github.com/dotnet/fsharp/issues/18140), [PR #19340](https://github.com/dotnet/fsharp/pull/19340))
 
 ### Added
 

src/Compiler/AbstractIL/ilwrite.fs

@@ -446,16 +446,24 @@ type MethodDefKey(ilg:ILGlobals, tidx: int, garity: int, nm: string, retTy: ILTy
     override _.Equals(obj: obj) =
         match obj with
         | :? MethodDefKey as y ->
-            let compareILTypes o1 o2 =
+            let rec compareILTypes o1 o2 =
                 match o1, o2 with
-                | ILType.Value v1, ILType.Value v2 -> v1.EqualsWithPrimaryScopeRef(ilg.primaryAssemblyScopeRef, v2 :> obj )
+                | ILType.Value v1, ILType.Value v2 -> v1.EqualsWithPrimaryScopeRef(ilg.primaryAssemblyScopeRef, v2 :> obj)
+                | ILType.Boxed v1, ILType.Boxed v2 -> v1.EqualsWithPrimaryScopeRef(ilg.primaryAssemblyScopeRef, v2 :> obj)
+                | ILType.Byref t1, ILType.Byref t2 -> compareILTypes t1 t2
+                | ILType.Ptr t1, ILType.Ptr t2 -> compareILTypes t1 t2
+                | ILType.Array(sh1, t1), ILType.Array(sh2, t2) -> sh1 = sh2 && compareILTypes t1 t2
+                | ILType.Modified(req1, tref1, t1), ILType.Modified(req2, tref2, t2) -> 
+                    req1 = req2 && tref1.EqualsWithPrimaryScopeRef(ilg.primaryAssemblyScopeRef, tref2 :> obj) && compareILTypes t1 t2
+                | ILType.Modified(_, _, t1), t2 -> compareILTypes t1 t2
+                | t1, ILType.Modified(_, _, t2) -> compareILTypes t1 t2
                 | _ -> o1 = o2
 
             tidx = y.TypeIdx &&
             garity = y.GenericArity &&
             nm = y.Name &&
-            // note: these next two use structural equality on AbstractIL ILType values
-            retTy = y.ReturnType && List.lengthsEqAndForall2 compareILTypes argTys y.ArgTypes &&
+            // note: these next two use scope-aware equality on AbstractIL ILType values
+            compareILTypes retTy y.ReturnType && List.lengthsEqAndForall2 compareILTypes argTys y.ArgTypes &&
             isStatic = y.IsStatic
         | _ -> false
 

src/Compiler/CodeGen/IlxGen.fs

@@ -605,6 +605,10 @@ let voidCheck m g permits ty =
 [<Struct>]
 type DuFieldCoordinates = { CaseIdx: int; FieldIdx: int }
 
+/// Flags propagated from interface slot signatures to parameter metadata.
+[<Struct>]
+type SlotParamFlags = { IsIn: bool; IsOut: bool }
+
 /// Structure for maintaining field reuse across struct unions
 type UnionFieldReuseMap = MultiMap<string, DuFieldCoordinates>
 
@@ -3491,7 +3495,6 @@ and GenLinearExpr cenv cgbuf eenv expr sequel preSteps (contf: FakeUnit -> FakeU
         if preSteps && GenExprPreSteps cenv cgbuf eenv expr sequel then
             contf Fake
         else
-
             // This case implemented here to get a guaranteed tailcall
             // Make sure we generate the debug point outside the scope of the variable
             let startMark, endMark as scopeMarks = StartDelayedLocalScope "let" cgbuf
@@ -5423,6 +5426,7 @@ and GenILCall
     (virt, valu, newobj, valUseFlags, isDllImport, ilMethRef: ILMethodRef, enclArgTys, methArgTys, argExprs, returnTys, m)
     sequel
     =
+    let g = cenv.g
     let hasByrefArg = ilMethRef.ArgTypes |> List.exists IsILTypeByref
 
     let isSuperInit =
@@ -5445,6 +5449,24 @@ and GenILCall
     let makesNoCriticalTailcalls = (newobj || not virt) // Don't tailcall for 'newobj', or 'call' to IL code
     let hasStructObjArg = valu && ilMethRef.CallingConv.IsInstance
 
+    let ilEnclArgTys = GenTypeArgs cenv m eenv.tyenv enclArgTys
+    let ilMethArgTys = GenTypeArgs cenv m eenv.tyenv methArgTys
+    let ilReturnTys = GenTypes cenv m eenv.tyenv returnTys
+    let ilMethSpec = mkILMethSpec (ilMethRef, boxity, ilEnclArgTys, ilMethArgTys)
+
+    let useICallVirt =
+        (virt || useCallVirt cenv boxity ilMethSpec isBaseCall)
+        && ilMethRef.CallingConv.IsInstance
+
+    let ccallInfo =
+        ccallInfo
+        |> Option.orElseWith (fun () ->
+            match argExprs with
+            | objArgExpr :: _ when useICallVirt ->
+                let objArgTy = tyOfExpr g objArgExpr
+                if isStructTy g objArgTy then Some objArgTy else None
+            | _ -> None)
+
     let tail =
         CanTailcall(
             hasStructObjArg,
@@ -5459,15 +5481,6 @@ and GenILCall
             sequel
         )
 
-    let ilEnclArgTys = GenTypeArgs cenv m eenv.tyenv enclArgTys
-    let ilMethArgTys = GenTypeArgs cenv m eenv.tyenv methArgTys
-    let ilReturnTys = GenTypes cenv m eenv.tyenv returnTys
-    let ilMethSpec = mkILMethSpec (ilMethRef, boxity, ilEnclArgTys, ilMethArgTys)
-
-    let useICallVirt =
-        (virt || useCallVirt cenv boxity ilMethSpec isBaseCall)
-        && ilMethRef.CallingConv.IsInstance
-
     // Load the 'this' pointer to pass to the superclass constructor. This argument is not
     // in the expression tree since it can't be treated like an ordinary value
     if isSuperInit then
@@ -8975,6 +8988,7 @@ and GenParams
     (argInfos: ArgReprInfo list)
     methArgTys
     (implValsOpt: Val list option)
+    (slotSigParamFlags: SlotParamFlags list option)
     =
     let g = cenv.g
     let ilWitnessParams = GenWitnessParams cenv eenv m witnessInfos
@@ -8993,11 +9007,18 @@ and GenParams
         | _ -> List.map (fun x -> x, None) ilArgTysAndInfos
 
     let ilParams, _ =
-        (Set.empty, List.zip methArgTys ilArgTysAndInfoAndVals)
-        ||> List.mapFold (fun takenNames (methodArgTy, ((ilArgTy, topArgInfo), implValOpt)) ->
+        ((Set.empty, 0), List.zip methArgTys ilArgTysAndInfoAndVals)
+        ||> List.mapFold (fun (takenNames, paramIdx) (methodArgTy, ((ilArgTy, topArgInfo), implValOpt)) ->
             let inFlag, outFlag, optionalFlag, defaultParamValue, Marshal, attribs =
                 GenParamAttribs cenv methodArgTy topArgInfo.Attribs
 
+            let inFlag, outFlag =
+                match slotSigParamFlags with
+                | Some flags when paramIdx < flags.Length ->
+                    let slotFlags = flags[paramIdx]
+                    (inFlag || slotFlags.IsIn, outFlag || slotFlags.IsOut)
+                | _ -> (inFlag, outFlag)
+
             let idOpt =
                 match topArgInfo.Name with
                 | Some v -> Some v
@@ -9036,7 +9057,7 @@ and GenParams
                     MetadataIndex = NoMetadataIdx
                 }
 
-            param, takenNames)
+            param, (takenNames, paramIdx + 1))
 
     ilWitnessParams @ ilParams
 
@@ -9389,8 +9410,18 @@ and GenMethodForBinding
 
     let ilTypars = GenGenericParams cenv eenvUnderMethLambdaTypars methLambdaTypars
 
+    let slotSigParamFlags =
+        match v.ImplementedSlotSigs with
+        | slotsig :: _ ->
+            let slotParams = slotsig.FormalParams |> List.concat
+
+            slotParams
+            |> List.map (fun (TSlotParam(_, _, inFlag, outFlag, _, _)) -> { IsIn = inFlag; IsOut = outFlag })
+            |> Some
+        | [] -> None
+
     let ilParams =
-        GenParams cenv eenvUnderMethTypeTypars m mspec witnessInfos paramInfos argTys (Some nonUnitNonSelfMethodVars)
+        GenParams cenv eenvUnderMethTypeTypars m mspec witnessInfos paramInfos argTys (Some nonUnitNonSelfMethodVars) slotSigParamFlags
 
     let ilReturn =
         GenReturnInfo cenv eenvUnderMethTypeTypars (Some returnTy) mspec.FormalReturnType retInfo
@@ -10720,7 +10751,7 @@ and GenAbstractBinding cenv eenv tref (vref: ValRef) =
         let ilReturn =
             GenReturnInfo cenv eenvForMeth returnTy mspec.FormalReturnType retInfo
 
-        let ilParams = GenParams cenv eenvForMeth m mspec [] argInfos methArgTys None
+        let ilParams = GenParams cenv eenvForMeth m mspec [] argInfos methArgTys None None
 
         let compileAsInstance = ValRefIsCompiledAsInstanceMember g vref
 

src/Compiler/Service/FSharpCheckerResults.fs

@@ -11,7 +11,9 @@ open System.Diagnostics
 open System.IO
 open System.Threading
 open FSharp.Compiler.IO
+open FSharp.Compiler.Import.Nullness
 open FSharp.Compiler.NicePrint
+open FSharp.Compiler.TypeHierarchy
 open Internal.Utilities.Library
 open Internal.Utilities.Library.Extras
 open Internal.Utilities.TypeHashing
@@ -2108,6 +2110,16 @@ type internal TypeCheckInfo
         |> Seq.tryFindBack (fun (_, _, _, m) -> equals m range)
         |> Option.map (fun (_, q, _, _) -> FSharpDisplayContext(fun _ -> q.DisplayEnv))
 
+    member scope.ImportILType(ty: ILType) : FSharpType =
+        let amap = tcImports.GetImportMap()
+        let assemblyRef = ILAssemblyRef.Create("", None, None, false, None, None)
+        let scopeRef = ILScopeRef.Assembly assemblyRef
+
+        let typ =
+            ImportILTypeFromMetadata amap range0 scopeRef [] [] NullableAttributesSource.Empty ty
+
+        FSharpType(cenv, typ)
+
     /// Get the auto-complete items at a location
     member _.GetDeclarations(parseResultsOpt, line, lineStr, partialName, completionContextAtPos, getAllEntities, options) =
         let isSigFile = SourceFileImpl.IsSignatureFile mainInputFileName
@@ -3522,6 +3534,9 @@ type FSharpCheckFileResults
         | None -> None
         | Some(scope, _) -> scope.TryGetCapturedDisplayContext(range)
 
+    member _.ImportILType(ty: ILType) =
+        scopeOptX |> Option.map _.ImportILType(ty)
+
     member _.GetAllUsesOfAllSymbolsInFile(?cancellationToken: CancellationToken) =
         match details with
         | None -> Seq.empty

src/Compiler/Service/FSharpCheckerResults.fsi

@@ -274,6 +274,9 @@ type public FSharpCheckFileResults =
     member TryGetCapturedType: range -> FSharpType option
     member TryGetCapturedDisplayContext: range -> FSharpDisplayContext option
 
+    /// Imports a compiled type for subsequent Symbols API use
+    member ImportILType: ILType -> FSharpType option
+
     /// <summary>Get the items for a declaration list</summary>
     ///
     /// <param name="parsedFileResults">

src/Compiler/Symbols/Symbols.fs

@@ -442,25 +442,22 @@ type FSharpEntity(cenv: SymbolEnv, entity: EntityRef, tyargs: TType list) =
         | Some _ -> None
 
     member x.CompiledRepresentation =
-        checkIsResolved()
-
-        let fail () =
-            invalidOp $"the type '{x.LogicalName}' does not have a qualified name"
+        if isUnresolved () then None else
 
 #if !NO_TYPEPROVIDERS
-        if entity.IsTypeAbbrev || entity.IsProvidedErasedTycon || entity.IsNamespace then fail ()
+        if entity.IsTypeAbbrev || entity.IsProvidedErasedTycon || entity.IsNamespace then None else
 #else
-        if entity.IsTypeAbbrev || entity.IsNamespace then fail ()
+        if entity.IsTypeAbbrev || entity.IsNamespace then None else
 #endif
         match entity.CompiledRepresentation with
-        | CompiledTypeRepr.ILAsmNamed(tref, _, _) -> tref
-        | CompiledTypeRepr.ILAsmOpen _ -> fail ()
+        | CompiledTypeRepr.ILAsmNamed(tref, _, _) -> Some tref
+        | CompiledTypeRepr.ILAsmOpen _ -> None
 
     member x.QualifiedName =
-        x.CompiledRepresentation.QualifiedName
+         x.CompiledRepresentation |> Option.map _.QualifiedName
 
     member x.BasicQualifiedName =
-        x.CompiledRepresentation.BasicQualifiedName
+        x.CompiledRepresentation |> Option.map _.BasicQualifiedName
 
     member x.FullName = 
         checkIsResolved()
@@ -2683,16 +2680,13 @@ type FSharpType(cenv, ty:TType) =
         FSharpType(cenv, stripTyEqnsWrtErasure EraseAll cenv.g ty)
 
     member x.BasicQualifiedName =
-        let fail () =
-            invalidOp $"the type '{x}' does not have a qualified name"
-
         protect <| fun () ->
             match stripTyparEqns ty with 
             | TType_app(tcref, _, _) ->
                 match tcref.CompiledRepresentation with 
-                | CompiledTypeRepr.ILAsmNamed(tref, _, _) -> tref.BasicQualifiedName
-                | CompiledTypeRepr.ILAsmOpen _ -> fail () 
-            | _ -> fail ()
+                | CompiledTypeRepr.ILAsmNamed(tref, _, _) -> Some tref.BasicQualifiedName
+                | CompiledTypeRepr.ILAsmOpen _ -> None 
+            | _ -> None
 
     member _.Instantiate(instantiation:(FSharpGenericParameter * FSharpType) list) = 
         let resTy = instType (instantiation |> List.map (fun (tyv, ty) -> tyv.TypeParameter, ty.Type)) ty

src/Compiler/Symbols/Symbols.fsi

@@ -224,10 +224,10 @@ type FSharpEntity =
     member Namespace: string option
 
     /// Get the fully qualified name of the type or module
-    member QualifiedName: string
+    member QualifiedName: string option
 
     /// The fully qualified name of the type or module without strong assembly name.
-    member BasicQualifiedName: string
+    member BasicQualifiedName: string option
 
     /// Get the full name of the type or module
     member FullName: string
@@ -1165,7 +1165,7 @@ type FSharpType =
     member ErasedType: FSharpType
 
     /// The fully qualified name of the type or module without strong assembly name.
-    member BasicQualifiedName: string
+    member BasicQualifiedName: string option
 
     /// Adjust the type by removing any occurrences of type inference variables, replacing them
     /// systematically with lower-case type inference variables such as <c>'a</c>.

src/Compiler/Utilities/Activity.fs

@@ -135,7 +135,7 @@ module internal Activity =
 
             depth this 0
 
-    let private activitySource = new ActivitySource(ActivityNames.FscSourceName)
+    let private activitySource = new ActivitySource(ActivityNames.FscSourceName, "")
 
     let start (name: string) (tags: (string * string) seq) : System.IDisposable | null =
         let activity = activitySource.CreateActivity(name, ActivityKind.Internal)
@@ -173,7 +173,8 @@ module internal Activity =
 
             let profilingTags = [| workingSetMB; gc0; gc1; gc2; handles; threads |]
 
-        let private profiledSource = new ActivitySource(ActivityNames.ProfiledSourceName)
+        let private profiledSource =
+            new ActivitySource(ActivityNames.ProfiledSourceName, "")
 
         let startAndMeasureEnvironmentStats (name: string) : System.IDisposable | null = profiledSource.StartActivity(name)
 

src/FSharp.Core/math/z.fsi

@@ -17,31 +17,31 @@ namespace Microsoft.FSharp.Core
 /// <category>Basic Types</category>
 type bigint = System.Numerics.BigInteger
 
-/// <summary>Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI' </summary>
+/// <summary>Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI' </summary>
 ///
 /// <category>Language Primitives</category>
 [<AutoOpen>]
 module NumericLiterals =
 
-    /// Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI'
+    /// Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI'
     module NumericLiteralI =
-        /// Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI'
+        /// Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI'
         val FromZero: value: unit -> 'T
 
-        /// Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI'
+        /// Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI'
         val FromOne: value: unit -> 'T
 
-        /// Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI'
+        /// Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI'
         val FromInt32: value: int32 -> 'T
 
-        /// Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI'
+        /// Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI'
         val FromInt64: value: int64 -> 'T
 
-        /// Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI'
+        /// Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI'
         val FromString: text: string -> 'T
 
-        /// Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI'
+        /// Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI'
         val FromInt64Dynamic: value: int64 -> objnull
 
-        /// Provides a default implementations of F# numeric literal syntax  for literals of the form 'dddI'
+        /// Provides a default implementation of F# numeric literal syntax for literals of the form 'dddI'
         val FromStringDynamic: text: string -> objnull

src/FSharp.Core/prim-types.fs

@@ -5995,8 +5995,8 @@ namespace Microsoft.FSharp.Core
                     }
 
                     let current () = 
-                        // according to IEnumerator<int>.Current documentation, the result of of Current
-                        // is undefined prior to the first call of MoveNext and post called to MoveNext
+                        // according to IEnumerator<int>.Current documentation, the result of Current
+                        // is undefined prior to the first call of MoveNext and post call to MoveNext
                         // that return false (see https://learn.microsoft.com/dotnet/api/system.collections.generic.ienumerator-1.current?view=net-7.0)
                         // so we should be able to just return value here, and we could get rid of the 
                         // complete variable which would be faster
@@ -6053,8 +6053,8 @@ namespace Microsoft.FSharp.Core
                         let mutable value = n - GenericOne
 
                         let inline current () =
-                            // according to IEnumerator<int>.Current documentation, the result of of Current
-                            // is undefined prior to the first call of MoveNext and post called to MoveNext
+                            // according to IEnumerator<int>.Current documentation, the result of Current
+                            // is undefined prior to the first call of MoveNext and post call to MoveNext
                             // that return false (see https://learn.microsoft.com/dotnet/api/system.collections.generic.ienumerator-1.current?view=net-7.0)
                             // so we should be able to just return value here, which would be faster
                             let derefValue = value