anchor.diff:          argExprs |> List.map (transformExpr com ctx) |> Fable.TupleConst |> Fable.Value
   
       | BasicPatterns.ObjectExpr(objType, baseCallExpr, overrides, otherOverrides) ->
  -        // If `this` is available, capture it to avoid conflicts (see #158)
  -        let capturedThis =
  -            match ctx.thisAvailability with
  -            | ThisUnavailable -> None
  -            | ThisAvailable -> Some [None, com.GetUniqueVar() |> makeIdentExpr]
  -            | ThisCaptured(prevThis, prevVars) ->
  -                (prevThis, com.GetUniqueVar() |> makeIdentExpr)::prevVars |> Some
  -        let baseClass, baseCons =
  -            match baseCallExpr with
  -            | BasicPatterns.Call(None, meth, _, _, args) ->
  -                let args = List.map (com.Transform ctx) args
  -                let typ, range = makeType com ctx.typeArgs baseCallExpr.Type, makeRange baseCallExpr.Range
  -                let baseClass =
  -                    tryEnclosingEntity meth
  -                    |> Option.map (fun ent ->
  -                        makeTypeFromDef com ctx.typeArgs ent []
  -                        |> makeNonGenTypeRef com)
  -                let baseCons =
  -                    let c = Fable.Apply(Fable.Value Fable.Super, args, Fable.ApplyMeth, typ, Some range)
  -                    let m = Fable.Member(".ctor", Fable.Constructor, Fable.InstanceLoc, [], Fable.Any)
  -                    Some(m, [], c)
  -                baseClass, baseCons
  -            | _ -> None, None
  -        let members =
  -            (objType, overrides)::otherOverrides
  -            |> List.collect (fun (typ, overrides) ->
  -                let overrides =
  -                    if not typ.HasTypeDefinition then overrides else
  -                    let typName = typ.TypeDefinition.FullName.Replace(".","-")
  -                    overrides |> List.where (fun x ->
  -                        typName + "-" + x.Signature.Name
  -                        |> Naming.ignoredInterfaceMethods.Contains
  -                        |> not)
  -                overrides |> List.map (fun over ->
  -                    let info = { isInstance = true; passGenerics = false }
  -                    let args, range = over.CurriedParameterGroups, makeRange fsExpr.Range
  -                    let ctx, thisArg, args', extraArgs' = bindMemberArgs com ctx info args
  -                    let args' = args'@extraArgs'
  -                    let ctx =
  -                        match capturedThis, thisArg with
  -                        | None, _ -> { ctx with thisAvailability = ThisAvailable }
  -                        | Some(capturedThis), Some thisArg ->
  -                            { ctx with thisAvailability=ThisCaptured(Some thisArg, capturedThis) }
  -                        | Some _, None -> failwithf "Unexpected Object Expression method withouth `this` argument %O" range
  -                    // Don't use the typ argument as the override may come
  -                    // from another type, like ToString()
  -                    let typ =
  -                        if over.Signature.DeclaringType.HasTypeDefinition
  -                        then Some over.Signature.DeclaringType.TypeDefinition
  -                        else None
  -                    // TODO: Check for indexed getter and setter also in object expressions?
  -                    let name = over.Signature.Name |> Naming.removeGetSetPrefix
  -                    let kind =
  -                        match over.Signature.Name with
  -                        | Naming.StartsWith "get_" _ -> Fable.Getter
  -                        | Naming.StartsWith "set_" _ -> Fable.Setter
  -                        | _ -> Fable.Method
  -                    // FSharpObjectExprOverride.CurriedParameterGroups doesn't offer
  -                    // information about ParamArray, we need to check the source method.
  -                    let hasRestParams =
  -                        match typ with
  -                        | None -> false
  -                        | Some typ ->
  -                            typ.MembersFunctionsAndValues
  -                            |> Seq.tryFind (fun x -> x.CompiledName = over.Signature.Name)
  -                            |> function Some m -> hasRestParams m | None -> false
  -                    let body = transformExpr com ctx over.Body
  -                    let args = List.map Fable.Ident.getType args'
  -                    let m = Fable.Member(name, kind, Fable.InstanceLoc, args, body.Type, Fable.Function(args, body.Type),
  -                                over.GenericParameters |> List.map (fun x -> x.Name),
  -                                hasRestParams = hasRestParams)
  -                    m, args', body))
  -        let interfaces =
  -            objType::(otherOverrides |> List.map fst)
  -            |> List.map (fun x -> sanitizeEntityFullName x.TypeDefinition)
  -            |> List.filter (Naming.ignoredInterfaces.Contains >> not)
  -            |> List.distinct
  -        let members =
  -            [ match baseCons with Some c -> yield c | None -> ()
  -              yield! members
  -              if List.contains "System.Collections.Generic.IEnumerable" interfaces
  -              then yield makeIteratorMethodArgsAndBody()
  -              yield makeReflectionMethodArgsAndBody com None false false interfaces None None
  -            ]
  -        let range = makeRangeFrom fsExpr
  -        let objExpr = Fable.ObjExpr (members, interfaces, baseClass, range)
  -        match capturedThis with
  -        | Some((_,Fable.Value(Fable.IdentValue capturedThis))::_) ->
  -            let varDecl = Fable.VarDeclaration(capturedThis, Fable.Value Fable.This, false)
  -            Fable.Sequential([varDecl; objExpr], range)
  -        | _ -> objExpr
  +        transformObjExpr com ctx fsExpr objType baseCallExpr overrides otherOverrides
   
       | BasicPatterns.NewObject(meth, typArgs, args) ->
           let r, typ = makeRangeFrom fsExpr, makeType com ctx.typeArgs fsExpr.Type
  
positive.code:         transformNonListNewUnionCase com ctx fsExpr fsType unionCase argExprs
      | _ -> failwithf "Expected ComposableExpr %O" (makeRange fsExpr.Range)
  
  let private transformExpr (com: IFableCompiler) ctx fsExpr =
      match fsExpr with
      (** ## Custom patterns *)
  
negative.code:     (** ## Applications *)
      | BasicPatterns.TraitCall(sourceTypes, traitName, flags, argTypes, _argTypes2, argExprs) ->
          let r, typ = makeRangeFrom fsExpr, makeType com ctx.typeArgs fsExpr.Type
          transformTraitCall com ctx r typ sourceTypes traitName flags argTypes argExprs
  
      | BasicPatterns.Call(callee, meth, typArgs, methTypArgs, args) ->
          let callee = Option.map (com.Transform ctx) callee
  