Fix

Author: auduchinok

src/Compiler/CodeGen/IlxGen.fs

@@ -269,6 +269,8 @@ type IlxGenOptions =
 
         /// When set to true, the IlxGen will delay generation of method bodies and generated them later in parallel (parallelized across files)
         parallelIlxGenEnabled: bool
+
+        inlineNamedFunctions: bool
     }
 
 /// Compilation environment for compiling a fragment of an assembly
@@ -5586,8 +5588,13 @@ and GenTraitCall (cenv: cenv) cgbuf eenv (traitInfo: TraitConstraintInfo, argExp
 
     | None ->
 
-        // If witnesses are available, we should now always find trait witnesses in scope
-        assert not generateWitnesses
+        // When inlineNamedFunctions is true, all trait calls should be resolved via witnesses in scope.
+        // When inlineNamedFunctions is false, inline functions are kept as calls rather than inlined.
+        // Their witness arguments may contain TraitCall operations for constraints that were resolved
+        // without a witness (e.g., when the constraint is satisfied by a known concrete type).
+        // In such cases, generateWitnesses can be true (because other witnesses are in scope) but
+        // the specific trait's witness is not found. Fall through to the constraint solver to resolve it.
+        assert (not generateWitnesses || not cenv.options.inlineNamedFunctions)
 
         let exprOpt =
             CommitOperationResult(ConstraintSolver.CodegenWitnessExprForTraitConstraint cenv.tcVal g cenv.amap m traitInfo argExprs)

src/Compiler/CodeGen/IlxGen.fsi

@@ -61,6 +61,9 @@ type internal IlxGenOptions =
 
         /// When set to true, the IlxGen will delay generation of method bodies and generate them later in parallel (parallelized across files)
         parallelIlxGenEnabled: bool
+
+        /// Indicates if inline named functions are being inlined or emitted as calls
+        inlineNamedFunctions: bool
     }
 
 /// The results of the ILX compilation of one fragment of an assembly

src/Compiler/Driver/OptimizeInputs.fs

@@ -582,6 +582,9 @@ let GenerateIlxCode
             isInteractiveItExpr = isInteractiveItExpr
             alwaysCallVirt = tcConfig.alwaysCallVirt
             parallelIlxGenEnabled = tcConfig.parallelIlxGen
+            inlineNamedFunctions =
+                tcConfig.inlineNamedFunctions
+                |> Option.defaultValue (not tcConfig.debuginfo || tcConfig.optSettings.LocalOptimizationsEnabled)
         }
 
     ilxGenerator.GenerateCode(ilxGenOpts, optimizedImpls, topAttrs.assemblyAttrs, topAttrs.netModuleAttrs)

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

@@ -539,6 +539,62 @@ let main _ =
         |> compileAndRun
         |> shouldSucceed
 
+    [<Fact>]
+    let ``SRTP 14 - StateMachine with unresolved trait from composed inline function`` () =
+        FSharp """
+open Microsoft.FSharp.Core.CompilerServices
+open Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers
+open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators
+
+[<Struct>]
+type S<'T> = member _.M(_: 'T) = ()
+
+let inline f<'A, 'R, 'B when 'A: (member M: int -> 'R) and 'B: (member M: 'R -> unit)> (_a: 'A) : 'B = Unchecked.defaultof<_>
+
+let inline g (_: S<'T>) =
+    if __useResumableCode then
+        __stateMachine<S<'T>, int>
+            (MoveNextMethodImpl<_>(fun _ -> ()))
+            (SetStateMachineMethodImpl<_>(fun _ _ -> ()))
+            (AfterCode<_, _>(fun _ -> 0))
+    else 0
+
+let inline h a = g (f a)
+
+[<EntryPoint>]
+let main _ =
+    let _ = h (S<int>())
+    0
+"""
+        |> withDebug
+        |> withNoOptimize
+        |> asExe
+        |> compileAndRun
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``SRTP 15 - Composed inline with linked constraints`` () =
+        FSharp """
+[<Struct>]
+type S<'T> = member _.M(_: 'T) = ()
+
+let inline f<'A, 'R, 'B when 'A: (member M: int -> 'R) and 'B: (member M: 'R -> unit)> (_a: 'A) : 'B = Unchecked.defaultof<_>
+
+let inline g (_: S<'T>) = 42
+
+let inline h a = g (f a)
+
+[<EntryPoint>]
+let main _ =
+    let i = h (S<int>())
+    if i = 42 then 0 else 1
+"""
+        |> withDebug
+        |> withNoOptimize
+        |> asExe
+        |> compileAndRun
+        |> shouldSucceed
+
     [<Fact>]
     let ``Member 01 - Non-generic`` () =
         FSharp """