anchor.diff:         quals |> List.contains TotalEffect
        )
      in
  -   let lbs, env = List.fold_left (fun (lbs, env) lb ->
  +   let lbs, env, g = List.fold_left (fun (lbs, env, g_acc) lb ->
           let univ_vars, t, check_t = TcUtil.extract_let_rec_annotation env lb in
           let env = Env.push_univ_vars env univ_vars in //no polymorphic recursion on universes
           let e = U.unascribe lb.lbdef in
  -        let t =
  +        let g, t =
               if not check_t
  -            then t
  +            then g_acc, t
               else (let env0 = Env.push_univ_vars env0 univ_vars in
                     let t, _, g = tc_check_tot_or_gtot_term ({env0 with check_uvars=true}) t (fst <| U.type_u()) in
  -                  let g = Rel.resolve_implicits env g in
  -                  ignore <| Rel.discharge_guard env g;
  -                  norm env0 t) in
  +                  Rel.conj_guard g_acc (g |> Rel.resolve_implicits env |> Rel.discharge_guard env), norm env0 t) in
           let env = if termination_check_enabled lb.lbname e t  //AR: This code also used to have && Env.should_verify env
                                                                 //i.e. when lax checking it was adding lbname in the second branch
                                                                 //this was a problem for 2-phase, if an implicit type was the type of a let rec (see bug056)
  
positive.code:                                                                                 //adding universes here so that when we add the let binding, we can add a typescheme with these universes
                    else Env.push_let_binding env lb.lbname (univ_vars, t) in
          let lb = {lb with lbtyp=t; lbunivs=univ_vars; lbdef=e} in
          lb::lbs,  env)
      ([],env)
      lbs  in
    List.rev lbs, env
  
  and check_let_recs env lbs =
      let lbs, gs = lbs |> List.map (fun lb ->
  
negative.code:             * the expected type is defined within lbs
              * *)
             let env0, topt = Env.clear_expected_typ env in
             let lbs, rec_env, g_t = build_let_rec_env true env0 lbs in
             (* now we type check each let rec *)
             let lbs, g_lbs = check_let_recs rec_env lbs in
             let g_lbs = Rel.conj_guard g_t g_lbs |> Rel.solve_deferred_constraints env |> Rel.resolve_implicits env in
  
             let all_lb_names = lbs |> List.map (fun lb -> right lb.lbname) |> Some in
  
  