anchor.diff:  
   check_type_def(Type, Def, L, St0) ->
       {Tvs0,St1} = check_type_name(Type, L, St0),
  -    case lfe_types:check_type_def(Def, St1#lint.types, Tvs0) of
  +    %% case lfe_types:check_type_def(Def, St1#lfe_lint.types, Tvs0) of
  +    case lfe_types:check_type_def(Def, St1#lfe_lint.recs, Tvs0) of
           {ok,Tvs1} -> check_type_vars(Tvs1, L, St1);
           {error,Error,Tvs1} ->
               St2 = add_error(L, Error, St1),
               check_type_vars(Tvs1, L, St2)
       end.
   
  -check_type_name([T|Args], L, #lint{types=Kts}=St) when is_atom(T) ->
  +check_type_name([T|Args], L, #lfe_lint{types=Kts}=St) when is_atom(T) ->
       case lfe_lib:is_symb_list(Args) of
           true ->
               Arity = length(Args),
               Kt = {T,Arity},
  -            Ts = lists:foldl(fun (V, S) -> orddict:update_counter(V, 1, S) end,
  -                             [], Args),
  +            Tvs = lists:foldl(fun (V, S) -> orddict:update_counter(V, 1, S) end,
  +                              [], Args),
               case lists:member(Kt, Kts) of
  -                true -> {Ts,add_error(L, {redefine_type,{T,Arity}}, St)};
  +                true -> {Tvs,add_error(L, {redefine_type,{T,Arity}}, St)};
                   false ->
  -                    case lfe_types:is_predefined_type(T, Arity) of
  +                    case lfe_internal:is_type(T, Arity) of
                           true ->
  -                            {Ts,add_error(L, {builtin_type,{T,Arity}}, St)};
  +                            {Tvs,add_error(L, {builtin_type,{T,Arity}}, St)};
                           false ->
  -                            {Ts,St#lint{types=[Kt|Kts]}}
  +                            {Tvs,St#lfe_lint{types=[Kt|Kts]}}
                       end
               end;
           false -> {[],bad_type_error(L, T, St)}
  
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:                                           is_integer(A),
                                            is_atom(R) ->
                      {orddict:store({F,A}, R, Imps),S};
                  (_, Imps, S) -> {Imps,bad_mdef_error(L, <<"import rename">>, S)}
              end,
      check_import(Check, Mod, L, St, Rs);
  check_import([prefix,Mod,Pre], L, St0) when is_atom(Mod), is_atom(Pre) ->
      St1 = deprecated_error(L, <<"import prefix">>, St0),
      Pstr = atom_to_list(Pre),
      case orddict:find(Pstr, St1#lfe_lint.pref) of
          {ok,_} ->
              bad_mdef_error(L, prefix, St1);
          error ->
              Pref = orddict:store(Pstr, Mod, St1#lfe_lint.pref),
              St1#lfe_lint{pref=Pref}
      end;
  check_import(_, L, St) -> import_error(L, St).
  
  check_import(Check, Mod, L, St0, Fs) ->
      Imps0 = safe_fetch(Mod, St0#lfe_lint.imps, []),
      {Imps1,St1} = foldl_form(Check, import, L, Imps0, St0, Fs),
      St1#lfe_lint{imps=orddict:store(Mod, Imps1, St1#lfe_lint.imps)}.
  
  import_error(L, St) -> bad_mdef_error(L, import, St).
  
  is_func_list(Fs) -> is_func_list(Fs, []).
  
  is_func_list([[F,Ar]|Fs], Funcs) when is_atom(F), is_integer(Ar), Ar >= 0 ->
      is_func_list(Fs, add_element({F,Ar}, Funcs));
  is_func_list([], Funcs) -> {yes,Funcs};
  is_func_list(_, _) -> no.
  
  %% check_type_defs(TypeDefs, Line, State) -> State.
  %% check_type_def(TypeDef, Line, State) -> State.
  %% check_type_def(Type, Def, Line, State) -> State.
  %%  Check a type definition.
  
  