anchor.diff:  
           and CheckExprOp st op m = 
               match op with 
  -            | TOp.LValueOp (_,lvr) -> CheckValSpec (strict st) lvr m
  +            | TOp.LValueOp (_,lvr) -> CheckValRef (strict st) lvr m
               | _ -> ()
             
  -        and CheckValSpec st v m = 
  +        and CheckValRef st (v: ValRef) m = 
               match st with 
               | MaybeLazy -> 
  -                if ListSet.contains g.valRefEq v rvs then 
  +                if recursiveVals.TryFind v.Deref |> Option.isSome then 
                       warning (RecursiveUseCheckedAtRuntime (denv,v,m)) 
                       if not !reportedEager then 
                         (warning (LetRecCheckedAtRuntime m); reportedEager := true)
                       runtimeChecks := true
   
               | Top | DefinitelyStrict ->
  -                if ListSet.contains g.valRefEq v rvs then 
  -                    if not (ListSet.contains g.valRefEq v availIfInOrder) then 
  +                if recursiveVals.TryFind v.Deref |> Option.isSome then 
  +                    if availIfInOrder.TryFind v.Deref |> Option.isNone then 
                           warning (LetRecEvaluatedOutOfOrder (denv,boundv,v,m)) 
                           outOfOrder := true
                           if not !reportedEager then 
                             (warning (LetRecCheckedAtRuntime m); reportedEager := true)
                       definiteDependencies := (boundv,v) :: !definiteDependencies
               | InnerTop -> 
  -                if ListSet.contains g.valRefEq v rvs then 
  +                if recursiveVals.TryFind v.Deref |> Option.isSome then 
                       directRecursiveData := true
               | DefinitelyLazy -> () 
           and checkDelayed st b = 
  
positive.code:    
  
      // Check the bindings one by one, each w.r.t. the previously available set of binding
      ([], bindsWithoutLaziness) ||> List.fold  (fun availIfInOrder (TBind(v,e,_)) -> 
             check availIfInOrder (mkLocalValRef v) e 
             (mkLocalValRef v::availIfInOrder))
        |> ignore
      
      // ddg = definiteDependencyGraph 
      let ddgNodes = bindsWithoutLaziness |> List.map (fun (TBind(v,_,_)) -> mkLocalValRef v) 
      let ddg = Graph<ValRef, Stamp>((fun v -> v.Stamp), ddgNodes, !definiteDependencies )
      ddg.IterateCycles (fun path -> error (LetRecUnsound (denv,path,path.Head.Range))) 
  
  
negative.code:           let envForNamespace = LocateEnv cenv.topCcu env enclosingNamespacePath
            let envForNamespace = ImplicitlyOpenOwnNamespace cenv.tcSink cenv.g cenv.amap m enclosingNamespacePath envForNamespace
  
            let! mexpr, topAttrs, _, envAtEnd = TcModuleOrNamespaceElements cenv parent endm envForNamespace xml (if isModule then false else isRec) defs
            
            let env = 
                if isNil enclosingNamespacePath then 
  