anchor.diff:      lfe_io:format1("function ~w undefined", [F]);
   format_error({multi_var,S}) ->
       lfe_io:format1("variable ~w multiply defined", [S]);
  -format_error({redef_func,F}) ->
  -    lfe_io:format1("redefining function ~w", [F]);
  +format_error({redefine_function,F}) ->
  +    lfe_io:format1("function ~w already defined", [F]);
   format_error({bad_fdef,F}) ->
       lfe_io:format1("bad definition of function ~w", [F]);
   format_error({illegal_literal,Lit}) ->
  
positive.code: 
  %% pat_record(Name, Fields, PatVars, Env, Line State) -> {PatVars,State}.
  
  pat_record(R, Fs, Pvs, Env, L, #lint{recs=Rs}=St) ->
      case orddict:find(R, Rs) of
          {ok,Rfs} ->
              pat_record_fields(Fs, Rfs, Pvs, Env, L, St);
  
negative.code:                   fun (S) -> bad_meta_error(L, spec, S) end,
                    St, Sps).
  
  check_func_spec([Func|Spec], L, St) ->
      check_func_spec(Func, Spec, L, St);
  check_func_spec(_, L, St) ->
      bad_meta_error(L, spec, St).
  
  check_func_spec(Func, Spec, L, St0) ->
      {Ar,St1} = check_func_name(Func, L, St0),
      %% case lfe_types:check_func_spec_list(Spec, Ar, St1#lfe_lint.types) of
      case lfe_types:check_func_spec_list(Spec, Ar, St1#lfe_lint.recs) of
          {ok,Tvss} -> 
              check_type_vars_list(Tvss, L, St1);
          {error,Error,Tvss} ->
              St2 = add_error(L, Error, St1),
              check_type_vars_list(Tvss, L, St2)
      end.
  
  check_func_name([F,Ar], L, #lfe_lint{specs=Kss}=St)
    when is_atom(F), is_integer(Ar), Ar >= 0 ->
      Ks = {F,Ar},
      case lists:member(Ks, Kss) of
          true -> {Ar,add_error(L, {redefine_spec,{F,Ar}}, St)};
          false -> {Ar,St#lfe_lint{specs=[Ks|Kss]}}
      end;
  check_func_name(F, L, St) ->
      {0,add_error(L, {bad_spec,F}, St)}.
  