anchor.diff:                           foldl(fun ({{F,A},R}, E) ->
                                          lfe_env:add_ibinding(M, F, A, R, E)
                                  end, Env, Fs)
  -                 end, lfe_env:new(), St#lint.imps),
  +                 end, lfe_env:new(), St#lfe_lint.imps),
       %% Basic predefines
       Predefs0 = [{module_info,[lambda,[],?Q(dummy)],1},
                   {module_info,[lambda,[x],?Q(dummy)],1}],
       Exps0 = [{module_info,0},{module_info,1}],
       {Predefs0,Env0,
  -     St#lint{exps=add_exports(Exps0, St#lint.mline, St#lint.exps)}}.
  +     St#lfe_lint{exps=add_exports(Exps0, St#lfe_lint.mline, St#lfe_lint.exps)}}.
   
   %% check_functions(FuncBindings, Env, State) -> {Funcs,Env,State}.
   %%  Check the top-level functions definitions. These have the format
  
positive.code: collect_form(_, L, St) ->
      {[],add_error(L, unknown_form, St)}.
  
  %% check_mdef(Metadata, Attributes, Line, State) -> State.
  %%  Check a module definition, its metasdata and attributes.
  
  check_mdef(Metas, Atts, L, St0) ->
      St1 = check_mmetas(Metas, L, St0),
      check_attrs(Atts, L, St1).
  
  %% check_mmetas(Metas, Line, State) -> State.
  %%  Only allow docs and type definitions.
  
  check_mmetas(Ms, L, St) ->
      check_foreach(fun (M, S) -> check_mmeta(M, L, S) end,
                    fun (S) -> bad_mdef_error(L, form, S) end,
                    St, Ms).
  
  check_mmeta([doc|Docs], L, St) ->
      ?IF(check_docs(Docs), St, bad_meta_error(L, doc, St));
  check_mmeta([type|Tds], L, St) ->
      check_type_defs(Tds, L, St);
  check_mmeta([opaque|Tds], L, St) ->
      check_type_defs(Tds, L, St);
  check_mmeta([spec|Sps], L, St) ->
      check_func_specs(Sps, L, St);
  check_mmeta([record|_Rds], L, St) ->
      depr_error(L, "record definition meta", St);
  check_mmeta([M|Vals], L, St) ->
      %% Other metadata, must be list and have symbol name.
      ?IF(is_atom(M) and lfe_lib:is_proper_list(Vals),
          St, bad_meta_error(L, M, St));
  check_mmeta(_, L, St) -> bad_mdef_error(L, meta, St).
  
  %% check_attrs(Attributes, Line, State) -> State.
  %%  Check the attributes of the module.
  
negative.code: expr(E) -> expr(E, lfe_env:new()).
  
  expr(E, Env) ->
      St0 = #lfe_lint{},
      St1 = check_expr(E, Env, 1, St0),
      return_status(St1).
  
  