anchor.diff:          let defnsDs = TcMutRecBindings_Phase2D_ExtractImplicitFieldAndMethodBindings cenv envMutRec tpenv (denv, generalizedTyparsForRecursiveBlock, defnsCs)
           
           // Phase2E - rewrite values to initialization graphs
  -        //
  -        // TODO: Note that this does initialization graphs in each type independently.
           let defnsEs = 
  -            defnsDs |> MutRecShapes.map 
  -                (fun (tyconOpt, fixupValueExprBinds, methodBinds) -> 
  -                    let fixedBinds = EliminateInitializationGraphs g true denv fixupValueExprBinds bindsm
  -                    tyconOpt, fixedBinds @ methodBinds)
  -                (fun (fixupValueExprBinds) -> 
  -                    EliminateInitializationGraphs g true denv fixupValueExprBinds bindsm)
  -                id
  +           EliminateInitializationGraphs 
  +             p23
  +             (fun morpher (tyconOpt,fixupValueExprBinds,methodBinds) -> (tyconOpt, morpher fixupValueExprBinds @ methodBinds))
  +             id
  +             (fun morpher oldBinds -> morpher oldBinds)
  +             g true denv defnsDs bindsm 
           
           defnsEs,envMutRec
   
  
positive.code:     if !directRecursiveData && requiresLazyBindings then 
          error(Error(FSComp.SR.tcInvalidMixtureOfRecursiveForms(),bindsm))
  
      let bindsBefore, bindsAfter = 
        if requiresLazyBindings then 
            let bindsBeforeL, bindsAfterL = 
              
                (fixupsl, bindsWithoutLaziness) 
                ||> List.map2 (fun (RecursiveUseFixupPoints(fixupPoints)) (TBind(v,e,seqPtOpt)) -> 
                     match stripChooseAndExpr e with
                     | Expr.Lambda _ | Expr.TyLambda _ -> 
                         [mkInvisibleBind v e],[] 
                     | _ -> 
                         let ty = v.Type
                         let m = v.Range
                         let vty = (mkLazyTy g ty)
  
                         let fty = (g.unit_ty --> ty)
                         let flazy,felazy = Tastops.mkCompGenLocal m  v.LogicalName fty 
                         let frhs = mkUnitDelayLambda g m e
                         if mustHaveArity then flazy.SetValReprInfo (Some(InferArityOfExpr g fty [] [] frhs))
  
                         let vlazy,velazy = Tastops.mkCompGenLocal m  v.LogicalName vty 
                         let vrhs = (mkLazyDelayed g m ty felazy)
                         
                         if mustHaveArity then vlazy.SetValReprInfo (Some(InferArityOfExpr g vty [] [] vrhs))
                         fixupPoints |> List.iter (fun (fp,_) -> fp := mkLazyForce g (!fp).Range ty velazy)
  
                         [mkInvisibleBind flazy frhs; mkInvisibleBind vlazy vrhs],
                         [mkBind seqPtOpt v (mkLazyForce g m ty velazy)])
                 |> List.unzip
            List.concat bindsBeforeL, List.concat bindsAfterL
        else
            bindsWithoutLaziness,[]
      bindsBefore @ bindsAfter
  
  //-------------------------------------------------------------------------
  // Check the shape of an object constructor and rewrite calls 
  
negative.code:         | Expr.TyChoose(_,b,_) -> stripChooseAndExpr b
          | e -> e
  
      let availIfInOrder = ValHash<_>.Create()
      let check boundv expr = 
          let strict = function
              | MaybeLazy -> MaybeLazy
              | DefinitelyLazy -> DefinitelyLazy
  