anchor.diff:      {deprecated, {2, 255}, ""};
   obsolete_builtin_type({Name, A}) when is_atom(Name), is_integer(A) -> no.
   
  -%% spec_decl(Line, Fun, Types, State) -> State.
  -
  -spec_decl(Line, MFA0, TypeSpecs, St00 = #lint{specs = Specs, module = Mod}) ->
  +%% spec_decl(Anno, Fun, Types, State) -> State.
  +
  +spec_decl(Anno, MFA0, TypeSpecs, St00 = #lint{specs = Specs, module = Mod}) ->
       MFA = case MFA0 of
   	      {F, Arity} -> {Mod, F, Arity};
   	      {_M, _F, Arity} -> MFA0
   	  end,
  -    St0 = check_module_name(element(1, MFA), Line, St00),
  -    St1 = St0#lint{specs = maps:put(MFA, Line, Specs)},
  +    St0 = check_module_name(element(1, MFA), Anno, St00),
  +    St1 = St0#lint{specs = maps:put(MFA, Anno, Specs)},
       case is_map_key(MFA, Specs) of
  -	true -> add_error(Line, {redefine_spec, MFA0}, St1);
  +	true -> add_error(Anno, {redefine_spec, MFA0}, St1);
   	false ->
               case MFA of
                   {Mod, _, _} ->
                       check_specs(TypeSpecs, spec_wrong_arity, Arity, St1);
                   _ ->
  -                    add_error(Line, {bad_module, MFA}, St1)
  +                    add_error(Anno, {bad_module, MFA}, St1)
               end
       end.
   
  -%% callback_decl(Line, Fun, Types, State) -> State.
  -
  -callback_decl(Line, MFA0, TypeSpecs,
  +%% callback_decl(Anno, Fun, Types, State) -> State.
  +
  +callback_decl(Anno, MFA0, TypeSpecs,
   	      St0 = #lint{callbacks = Callbacks, module = Mod}) ->
       case MFA0 of
           {M, _F, _A} ->
  -            St1 = check_module_name(M, Line, St0),
  -            add_error(Line, {bad_callback, MFA0}, St1);
  +            St1 = check_module_name(M, Anno, St0),
  +            add_error(Anno, {bad_callback, MFA0}, St1);
           {F, Arity} ->
               MFA = {Mod, F, Arity},
  -            St1 = St0#lint{callbacks = maps:put(MFA, Line, Callbacks)},
  +            St1 = St0#lint{callbacks = maps:put(MFA, Anno, Callbacks)},
               case is_map_key(MFA, Callbacks) of
  -                true -> add_error(Line, {redefine_callback, MFA0}, St1);
  +                true -> add_error(Anno, {redefine_callback, MFA0}, St1);
                   false -> check_specs(TypeSpecs, callback_wrong_arity,
                                        Arity, St1)
               end
       end.
   
  -%% optional_callbacks(Line, FAs, State) -> State.
  -
  -optional_callbacks(Line, Term, St0) ->
  +%% optional_callbacks(Anno, FAs, State) -> State.
  +
  +optional_callbacks(Anno, Term, St0) ->
       try true = is_fa_list(Term), Term of
           FAs ->
  -            optional_cbs(Line, FAs, St0)
  +            optional_cbs(Anno, FAs, St0)
       catch
           _:_ ->
               St0 % ignore others
       end.
   
  -optional_cbs(_Line, [], St) ->
  +optional_cbs(_Anno, [], St) ->
       St;
  -optional_cbs(Line, [{F,A}|FAs], St0) ->
  +optional_cbs(Anno, [{F,A}|FAs], St0) ->
       #lint{optional_callbacks = OptionalCbs, module = Mod} = St0,
       MFA = {Mod, F, A},
  -    St1 = St0#lint{optional_callbacks = maps:put(MFA, Line, OptionalCbs)},
  +    St1 = St0#lint{optional_callbacks = maps:put(MFA, Anno, OptionalCbs)},
       St2 = case is_map_key(MFA, OptionalCbs) of
                 true ->
  -                  add_error(Line, {redefine_optional_callback, {F,A}}, St1);
  +                  add_error(Anno, {redefine_optional_callback, {F,A}}, St1);
                 false ->
                     St1
             end,
  -    optional_cbs(Line, FAs, St2).
  +    optional_cbs(Anno, FAs, St2).
   
   is_fa_list([E|L]) -> is_fa(E) andalso is_fa_list(L);
   is_fa_list([]) -> true;
  
positive.code:             {unknown,Evt,St1}
      end.
  
  %% bit_type(Line, Size, TypeList, State) ->  {Size,#bittype,St}.
  %%  Perform warning check on type and size.
  
  bit_type(Line, Size0, Type, St) ->
      case erl_bits:set_bit_type(Size0, Type) of
          {ok,Size1,Bt} -> {Size1,Bt,St};
  	{error,What} ->
              %% Flag error and generate a default.
              {ok,Size1,Bt} = erl_bits:set_bit_type(default, []),
              {Size1,Bt,add_error(Line, What, St)}
      end.
  
  %% bit_size_check(Line, Size, BitType, State) -> {BitSize,State}.
  %%  Do some checking & warnings on types
  %%   float == 32 or 64
  
  bit_size_check(_Line, unknown, _, St) -> {unknown,St};
  bit_size_check(_Line, undefined, #bittype{type=Type}, St) ->
      true = (Type =:= utf8) or (Type =:= utf16) or (Type =:= utf32), %Assertion.
      {undefined,St};
  bit_size_check(Line, all, #bittype{type=Type}, St) ->
      case Type of
          binary -> {all,St};
          _ -> {unknown,add_error(Line, illegal_bitsize, St)}
      end;
  bit_size_check(Line, Size, #bittype{type=Type,unit=Unit}, St) ->
      Sz = Unit * Size,                           %Total number of bits!
      St2 = elemtype_check(Line, Type, Sz, St),
      {Sz,St2}.
  
  elemtype_check(_Line, float, 32, St) -> St;
  elemtype_check(_Line, float, 64, St) -> St;
  elemtype_check(Line, float, _Size, St) ->
      add_warning(Line, {bad_bitsize,"float"}, St);
  elemtype_check(_Line, _Type, _Size, St) ->  St.
  
  
  %% add_bit_size(Line, ElementSize, BinSize, Build, State) -> {Size,State}.
  %%  Add bits to group size.
  
  add_bit_size(Line, _Sz1, all, false, St) ->
      {all,add_error(Line, unsized_binary_not_at_end, St)};
  add_bit_size(_Line, _Sz1, all, true, St) ->
      {all,St};
  add_bit_size(_Line, all, _Sz2, _B, St) -> {all,St};
  add_bit_size(_Line, undefined, _Sz2, _B, St) -> {undefined,St};
  add_bit_size(_Line, unknown, _Sz2, _B, St) -> {unknown,St};
  add_bit_size(_Line, _Sz1, undefined, _B, St) -> {unknown,St};
  add_bit_size(_Line, _Sz1, unknown, _B, St) -> {unknown,St};
  add_bit_size(_Line, Sz1, Sz2, _B, St) -> {Sz1 + Sz2,St}.
  
  %% guard([GuardTest], VarTable, State) ->
  %%      {UsedVarTable,State}
  
negative.code:                defined=gb_sets:empty()          %Defined fuctions
                     :: gb_sets:set(fa()),
  	       on_load=[] :: [fa()],		%On-load function
  	       on_load_anno=erl_anno:new(0)	%Location for on_load
                     :: erl_anno:anno(),
  	       clashes=[],			%Exported functions named as BIFs
                 not_deprecated=[],               %Not considered deprecated
  