WIP :: Bugfix :: Codegen

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

@@ -1,5 +1,22 @@
 ### Fixed
 
+* Fix TypeLoadException when creating delegate with voidptr parameter. (Issue [#11132](https://github.com/dotnet/fsharp/issues/11132))
+* Suppress tail calls when localloc (NativePtr.stackalloc) is used. (Issue [#13447](https://github.com/dotnet/fsharp/issues/13447))
+* Fix outref parameter compiled as byref. (Issue [#13468](https://github.com/dotnet/fsharp/issues/13468))
+* Fix DU case names matching IWSAM member names no longer cause duplicate property entries. (Issue [#14321](https://github.com/dotnet/fsharp/issues/14321))
+* Fix TypeLoadException in Release builds with inline constraints. (Issue [#14492](https://github.com/dotnet/fsharp/issues/14492))
+* Fix nativeptr in interfaces leads to TypeLoadException. (Issue [#14508](https://github.com/dotnet/fsharp/issues/14508))
+* Fix DefaultAugmentation(false) duplicate entry in method table. (Issue [#16565](https://github.com/dotnet/fsharp/issues/16565))
+* Avoid duplicate parameter names in closure constructors. (Issue [#17692](https://github.com/dotnet/fsharp/issues/17692))
+* Fix static abstract interface members with byref params. (Issue [#18135](https://github.com/dotnet/fsharp/issues/18135))
+* Use constrained.callvirt for method calls on value types. (Issue [#18140](https://github.com/dotnet/fsharp/issues/18140))
+* Fix box instruction for literal upcasts. (Issue [#18319](https://github.com/dotnet/fsharp/issues/18319))
+* Fix RuntimeWrappedException cannot be caught. (Issue [#18374](https://github.com/dotnet/fsharp/issues/18374))
+* Fix Action/Func conversion captures result not expression. (Issue [#18953](https://github.com/dotnet/fsharp/issues/18953))
+* Fix Decimal Literal causes InvalidProgramException in Debug builds. (Issue [#18956](https://github.com/dotnet/fsharp/issues/18956))
+* Fix object expressions in struct types no longer generate invalid IL with byref fields. (Issue [#19068](https://github.com/dotnet/fsharp/issues/19068))
+* Fix abstract event accessors now have SpecialName flag. (Issue [#5834](https://github.com/dotnet/fsharp/issues/5834))
+* Fix F# exception serialization now preserves fields. (Issue [#878](https://github.com/dotnet/fsharp/issues/878))
 * Fixed Find All References not correctly finding active pattern cases in signature files. ([Issue #19173](https://github.com/dotnet/fsharp/issues/19173), [Issue #14969](https://github.com/dotnet/fsharp/issues/14969), [PR #19252](https://github.com/dotnet/fsharp/pull/19252))
 * Fixed Rename not correctly handling operators containing `.` (e.g., `-.-`). ([Issue #17221](https://github.com/dotnet/fsharp/issues/17221), [Issue #14057](https://github.com/dotnet/fsharp/issues/14057), [PR #19252](https://github.com/dotnet/fsharp/pull/19252))
 * Fixed Find All References not correctly applying `#line` directive remapping. ([Issue #9928](https://github.com/dotnet/fsharp/issues/9928), [PR #19252](https://github.com/dotnet/fsharp/pull/19252))

src/Compiler/AbstractIL/il.fs

@@ -3333,6 +3333,15 @@ let mkILSimpleTypar nm =
         MetadataIndex = NoMetadataIdx
     }
 
+let stripILGenericParamConstraints (gp: ILGenericParameterDef) =
+    { gp with
+        Constraints = []
+        HasReferenceTypeConstraint = false
+        HasNotNullableValueTypeConstraint = false
+        HasDefaultConstructorConstraint = false
+        HasAllowsRefStruct = false
+    }
+
 let genericParamOfGenericActual (_ga: ILType) = mkILSimpleTypar "T"
 
 let mkILFormalTypars (x: ILGenericArgsList) = List.map genericParamOfGenericActual x

src/Compiler/AbstractIL/il.fsi

@@ -2066,6 +2066,7 @@ val internal mkILFormalNamedTy: ILBoxity -> ILTypeRef -> ILGenericParameterDef l
 val internal mkILFormalTypars: ILType list -> ILGenericParameterDefs
 val internal mkILFormalGenericArgs: int -> ILGenericParameterDefs -> ILGenericArgsList
 val internal mkILSimpleTypar: string -> ILGenericParameterDef
+val internal stripILGenericParamConstraints: ILGenericParameterDef -> ILGenericParameterDef
 
 /// Make custom attributes.
 val internal mkILCustomAttribMethRef:

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/Checking/MethodCalls.fs

@@ -1305,7 +1305,16 @@ let BuildObjCtorCall (g: TcGlobals) m =
 /// Implements the elaborated form of adhoc conversions from functions to delegates at member callsites
 let BuildNewDelegateExpr (eventInfoOpt: EventInfo option, g, amap, delegateTy, delInvokeMeth: MethInfo, delArgTys, delFuncExpr, delFuncTy, m) =
     let slotsig = delInvokeMeth.GetSlotSig(amap, m)
-    let delArgVals, expr = 
+
+    let needsBinding =
+        match delFuncExpr with
+        | Expr.Val _
+        | Expr.Lambda _
+        | Expr.TyLambda _
+        | Expr.App(Expr.Val _, _, _, [], _) -> false
+        | _ -> true
+
+    let delArgVals, expr, wrapperOpt = 
         let valReprInfo = ValReprInfo([], List.replicate (max 1 (List.length delArgTys)) ValReprInfo.unnamedTopArg, ValReprInfo.unnamedRetVal)
 
         // Try to pull apart an explicit lambda and use it directly 
@@ -1322,6 +1331,13 @@ let BuildNewDelegateExpr (eventInfoOpt: EventInfo option, g, amap, delegateTy, d
             if List.exists (isByrefTy g) delArgTys then
                     error(Error(FSComp.SR.tcFunctionRequiresExplicitLambda(delArgTys.Length), m)) 
 
+            let funcExprToUse, funcTyToUse, wrapper =
+                if needsBinding then
+                    let v, ve = mkCompGenLocal m "delegateFunc" delFuncTy
+                    ve, delFuncTy, Some (fun body -> mkCompGenLet m v delFuncExpr body)
+                else
+                    delFuncExpr, delFuncTy, None
+
             let delFuncArgNamesIfFeatureEnabled =
                 match delFuncExpr with
                 | Expr.Val (valRef = vref) when g.langVersion.SupportsFeature LanguageFeature.ImprovedImpliedArgumentNames ->
@@ -1350,15 +1366,16 @@ let BuildNewDelegateExpr (eventInfoOpt: EventInfo option, g, amap, delegateTy, d
                         | h :: t -> [exprForVal m h; mkRefTupledVars g m t] 
                     | None -> 
                         if isNil delArgTys then [mkUnit g m] else List.map (exprForVal m) delArgVals
-                mkApps g ((delFuncExpr, delFuncTy), [], args, m)
-            delArgVals, expr
+                mkApps g ((funcExprToUse, funcTyToUse), [], args, m)
+            delArgVals, expr, wrapper
 
         | Some _ -> 
             let _, _, _, vsl, body, _ = IteratedAdjustLambdaToMatchValReprInfo g amap valReprInfo delFuncExpr
-            List.concat vsl, body
+            List.concat vsl, body, None
 
     let meth = TObjExprMethod(slotsig, [], [], [delArgVals], expr, m)
-    mkObjExpr(delegateTy, None, BuildObjCtorCall g m, [meth], [], m)
+    let delegateExpr = mkObjExpr(delegateTy, None, BuildObjCtorCall g m, [meth], [], m)
+    (wrapperOpt |> Option.defaultValue id) delegateExpr
 
 let CoerceFromFSharpFuncToDelegate g amap infoReader ad callerArgTy m callerArgExpr delegateTy =    
     let (SigOfFunctionForDelegate(delInvokeMeth, delArgTys, _, _)) = GetSigOfFunctionForDelegate infoReader delegateTy m ad

src/Compiler/CodeGen/EraseClosures.fs

@@ -152,7 +152,19 @@ let newIlxPubCloEnv (ilg, addMethodGeneratedAttrs, addFieldGeneratedAttrs, addFi
 
 let mkILTyFuncTy cenv = cenv.mkILTyFuncTy
 
+let inline private (|IsVoidPtr|_|) ty =
+    match ty with
+    | ILType.Ptr ILType.Void -> true
+    | _ -> false
+
+let private fixVoidPtrForGenericArg (ilg: ILGlobals) ty =
+    match ty with
+    | IsVoidPtr -> ilg.typ_IntPtr
+    | _ -> ty
+
 let mkILFuncTy cenv dty rty =
+    let dty = fixVoidPtrForGenericArg cenv.ilg dty
+    let rty = fixVoidPtrForGenericArg cenv.ilg rty
     mkILBoxedTy cenv.tref_Func[0] [ dty; rty ]
 
 let mkILCurriedFuncTy cenv dtys rty =
@@ -167,6 +179,8 @@ let typ_Func cenv (dtys: ILType list) rty =
         else
             mkFuncTypeRef cenv.ilg.fsharpCoreAssemblyScopeRef n
 
+    let dtys = dtys |> List.map (fixVoidPtrForGenericArg cenv.ilg)
+    let rty = fixVoidPtrForGenericArg cenv.ilg rty
     mkILBoxedTy tref (dtys @ [ rty ])
 
 let rec mkTyOfApps cenv apps =
@@ -189,6 +203,8 @@ let mkMethSpecForMultiApp cenv (argTys: ILType list, retTy) =
     let n = argTys.Length
     let formalArgTys = List.mapi (fun i _ -> ILType.TypeVar(uint16 i)) argTys
     let formalRetTy = ILType.TypeVar(uint16 n)
+    let argTys = argTys |> List.map (fixVoidPtrForGenericArg cenv.ilg)
+    let retTy = fixVoidPtrForGenericArg cenv.ilg retTy
     let inst = argTys @ [ retTy ]
 
     if n = 1 then
@@ -392,6 +408,19 @@ let mkILFreeVarForParam (p: ILParameter) =
 
 let mkILLocalForFreeVar (p: IlxClosureFreeVar) = mkILLocal p.fvType None
 
+let mkUniqueFreeVarName (baseName: string) (existingFields: IlxClosureFreeVar[]) =
+    let existingNames = existingFields |> Array.map (fun fv -> fv.fvName) |> Set.ofArray
+
+    let rec findUnique n =
+        let candidate = if n = 0 then baseName else baseName + string n
+
+        if Set.contains candidate existingNames then
+            findUnique (n + 1)
+        else
+            candidate
+
+    findUnique 0
+
 let mkILCloFldSpecs _cenv flds =
     flds |> Array.map (fun fv -> (fv.fvName, fv.fvType)) |> Array.toList
 
@@ -490,7 +519,8 @@ let rec convIlxClosureDef cenv encl (td: ILTypeDef) clo =
                 let laterGenericParams = td.GenericParams @ addedGenParams
 
                 let selfFreeVar =
-                    mkILFreeVar (CompilerGeneratedName("self" + string nowFields.Length), true, nowCloSpec.ILType)
+                    let baseName = CompilerGeneratedName("self" + string nowFields.Length)
+                    mkILFreeVar (mkUniqueFreeVarName baseName nowFields, true, nowCloSpec.ILType)
 
                 let laterFields = Array.append nowFields [| selfFreeVar |]
                 let laterCloRef = IlxClosureRef(laterTypeRef, laterStruct, laterFields)
@@ -545,12 +575,14 @@ let rec convIlxClosureDef cenv encl (td: ILTypeDef) clo =
 
                 let convil = convILMethodBody (Some nowCloSpec, boxReturnTy) clo.cloCode.Value
 
+                let specializeGenParams = addedGenParams |> List.map stripILGenericParamConstraints
+
                 let nowApplyMethDef =
                     mkILGenericVirtualMethod (
                         "Specialize",
                         ILCallingConv.Instance,
                         ILMemberAccess.Public,
-                        addedGenParams (* method is generic over added ILGenericParameterDefs *) ,
+                        specializeGenParams,
                         [],
                         mkILReturn cenv.ilg.typ_Object,
                         MethodBody.IL(notlazy convil)
@@ -612,7 +644,8 @@ let rec convIlxClosureDef cenv encl (td: ILTypeDef) clo =
                 let laterGenericParams = td.GenericParams
                 // Number each argument left-to-right, adding one to account for the "this" pointer
                 let selfFreeVar =
-                    mkILFreeVar (CompilerGeneratedName "self", true, nowCloSpec.ILType)
+                    let baseName = CompilerGeneratedName "self"
+                    mkILFreeVar (mkUniqueFreeVarName baseName nowFields, true, nowCloSpec.ILType)
 
                 let argToFreeVarMap =
                     (0, selfFreeVar)
@@ -676,7 +709,17 @@ let rec convIlxClosureDef cenv encl (td: ILTypeDef) clo =
             else
                 // CASE 2b - Build an Invoke method
 
-                let nowEnvParentClass = typ_Func cenv (typesOfILParams nowParams) nowReturnTy
+                let fixedNowParams =
+                    nowParams
+                    |> List.map (fun (p: ILParameter) ->
+                        match p.Type with
+                        | IsVoidPtr -> { p with Type = cenv.ilg.typ_IntPtr }
+                        | _ -> p)
+
+                let fixedNowReturnTy = fixVoidPtrForGenericArg cenv.ilg nowReturnTy
+
+                let nowEnvParentClass =
+                    typ_Func cenv (typesOfILParams fixedNowParams) fixedNowReturnTy
 
                 let cloTypeDef =
                     let convil = convILMethodBody (Some nowCloSpec, None) clo.cloCode.Value
@@ -685,8 +728,8 @@ let rec convIlxClosureDef cenv encl (td: ILTypeDef) clo =
                         mkILNonGenericVirtualInstanceMethod (
                             "Invoke",
                             ILMemberAccess.Public,
-                            nowParams,
-                            mkILReturn nowReturnTy,
+                            fixedNowParams,
+                            mkILReturn fixedNowReturnTy,
                             MethodBody.IL(notlazy convil)
                         )