Temporarily disable struct member extraction transformation

The transformation is causing false positives - it's being applied to object
expressions in non-struct contexts, leading to byref type errors in files like
ServiceParamInfoLocations.fs.

Root cause: The check for `v.IsInstanceMember && isStructTyconRef v.DeclaringEntity`
is too broad - it matches any struct instance member that appears as a free variable,
even when the object expression is not inside a struct instance member method.

Need to add context awareness to only transform when we're truly inside a struct
instance member context, not just when we happen to reference any struct member.

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

Author: Copilot

src/Compiler/Checking/Expressions/CheckExpressionsOps.fs

@@ -404,62 +404,8 @@ let TryExtractStructMembersFromObjectExpr
     overridesAndVirts
     (mWholeExpr: range) : (Val * Expr) list * Remap =
 
-    // Early guard: Only apply for object expressions deriving from base classes, not pure interface implementations
-    // Interface implementations don't pass struct members to base constructors, so they don't have the byref issue
-    if isInterfaceTy then
-        [], Remap.Empty
-    else
-        // Collect all method bodies from the object expression overrides
-        let allMethodBodies =
-            overridesAndVirts
-            |> List.collect (fun (_, _, _, _, _, overrides) ->
-                overrides |> List.map (fun (_, (_, _, _, _, bindingBody)) -> bindingBody))
-        
-        // Early exit if no methods to analyze
-        if allMethodBodies.IsEmpty then
-            [], Remap.Empty
-        else
-            // Find all free variables in the method bodies
-            let freeVars =
-                allMethodBodies
-                |> List.fold (fun acc body ->
-                    let bodyFreeVars = freeInExpr CollectTyparsAndLocals body
-                    unionFreeVars acc bodyFreeVars) emptyFreeVars
-            
-            // Filter to only instance members of struct types
-            // This identifies the problematic case: when an object expression inside a struct
-            // captures instance members, which would require capturing 'this' as a byref
-            let structMembers =
-                freeVars.FreeLocals
-                |> Zset.elements
-                |> List.filter (fun (v: Val) ->
-                    // Must be an instance member (not static)
-                    v.IsInstanceMember &&
-                    // Must have a declaring entity
-                    v.HasDeclaringEntity &&
-                    // The declaring entity must be a struct type
-                    isStructTyconRef v.DeclaringEntity)
-            
-            // Early exit if no struct members captured
-            if structMembers.IsEmpty then
-                [], Remap.Empty
-            else
-                // Create local variables for each captured struct member
-                let bindings =
-                    structMembers
-                    |> List.map (fun (memberVal: Val) ->
-                        // Create a new local to hold the member's value
-                        let localVal, _ = mkCompGenLocal mWholeExpr memberVal.DisplayName memberVal.Type
-                        // The value expression is just a reference to the member
-                        let valueExpr = exprForVal mWholeExpr memberVal
-                        (memberVal, localVal, valueExpr))
-                
-                // Build a remap from original member vals to new local vals
-                let remap =
-                    bindings
-                    |> List.fold (fun (remap: Remap) (origVal, localVal, _) ->
-                        { remap with valRemap = remap.valRemap.Add origVal (mkLocalValRef localVal) }) Remap.Empty
-                
-                // Return the bindings to be added before the object expression
-                let bindPairs = bindings |> List.map (fun (_, localVal, valueExpr) -> (localVal, valueExpr))
-                bindPairs, remap
+    // TEMPORARILY DISABLED: This transformation is causing false positives
+    // TODO: Need to add better context checks to ensure we're only transforming
+    // object expressions that are truly inside struct instance member methods
+    // See issue: https://github.com/dotnet/fsharp/issues/19068
+    [], Remap.Empty