anchor.diff:  
       [se], []
   
  +(* [tc_decl env se] typechecks [se] in environment [env] and returns *)
  +(* the list of typechecked sig_elts, and a list of new sig_elts elaborated during typechecking but not yet typechecked *)
  +let tc_decl env se: list<sigelt> * list<sigelt> =
  +  let env = set_hint_correlator env se in
  +  if Env.debug env Options.Low
  +  then BU.print1 ">>>>>>>>>>>>>>tc_decl %s\n" (Print.sigelt_to_string se);
  +  match get_fail_se se with
  +  | Some (_, false) when not (Env.should_verify env) ->
  +    (* If we're --laxing, and we didn't find fail_lax, then just ignore the definition *)
  +    [], []
  +
  +  | Some (errnos, _) ->
  +    if Env.debug env Options.Low then
  +        BU.print1 ">> Expecting errors: [%s]\n" (String.concat "; " <| List.map string_of_int errnos);
  +    let errs = Errors.catch_errors (fun () -> tc_decl' env se) in
  +    if Env.debug env Options.Low then begin
  +        BU.print_string ">> Got issues: [\n";
  +        List.iter Errors.print_issue errs;
  +        BU.print_string ">>]\n"
  +    end;
  +    begin match errs, check_multi_contained errnos (List.concatMap (fun i -> list_of_option i.issue_number) errs) with
  +    | [], _ ->
  +        List.iter Errors.print_issue errs;
  +        raise_error (Errors.Error_DidNotFail, "This top-level definition was expected to fail, but it succeeded") se.sigrng
  +    | _, Some (e, n1, n2) ->
  +        List.iter Errors.print_issue errs;
  +        raise_error (Errors.Error_DidNotFail, BU.format3 "This top-level definition was expected to raise Error #%s %s times, but it raised it %s times"
  +                                                (string_of_int e) (string_of_int n1) (string_of_int n2)) se.sigrng
  +    | _, None -> [], []
  +    end
  +
  +  | None ->
  +    tc_decl' env se
  +
   let for_export hidden se : list<sigelt> * list<lident> =
      (* Exporting symbols based on whether they have been marked 'abstract'
   
  
positive.code: let tc_inductive env ses quals lids =
      let env = Env.push env "tc_inductive" in
  
      let sig_bndle, tcs, datas = TcInductive.check_inductive_well_typedness env ses quals lids in
      (* we have a well-typed inductive;
              we still need to check whether or not it supports equality
  
negative.code:     in
      aux l1 l2
  
  let tc_decl' env se: list<sigelt> * list<sigelt> =
    TcUtil.check_sigelt_quals env se;
    let r = se.sigrng in
    match se.sigel with
    | Sig_inductive_typ _
  