anchor.diff:                  true ->
   		    St;
                   false ->
  -		    add_warning(Line, {deprecated, MFA, Replacement, Rel}, St)
  +		    add_warning(Anno, {deprecated, MFA, Replacement, Rel}, St)
               end;
   	{removed, String} when is_list(String) ->
  -	    add_removed_warning(Line, MFA, {removed, MFA, String}, St);
  +	    add_removed_warning(Anno, MFA, {removed, MFA, String}, St);
   	{removed, Replacement, Rel} ->
  -	    add_removed_warning(Line, MFA, {removed, MFA, Replacement, Rel}, St);
  +	    add_removed_warning(Anno, MFA, {removed, MFA, Replacement, Rel}, St);
           no ->
   	    St
       end.
   
  -add_removed_warning(Line, {M, _, _}=MFA, Warning, #lint{not_removed=NotRemoved}=St) ->
  +add_removed_warning(Anno, {M, _, _}=MFA, Warning, #lint{not_removed=NotRemoved}=St) ->
       case is_warn_enabled(removed, St) andalso
           not gb_sets:is_element(M, NotRemoved) andalso
           not gb_sets:is_element(MFA, NotRemoved) of
           true ->
  -            add_warning(Line, Warning, St);
  +            add_warning(Anno, Warning, St);
           false ->
               St
       end.
   
   -dialyzer({no_match, deprecated_type/5}).
   
  -deprecated_type(L, M, N, As, St) ->
  +deprecated_type(Anno, M, N, As, St) ->
       NAs = length(As),
       case otp_internal:obsolete_type(M, N, NAs) of
           {deprecated, String} when is_list(String) ->
               case is_warn_enabled(deprecated_type, St) of
                   true ->
  -                    add_warning(L, {deprecated_type, {M,N,NAs}, String}, St);
  +                    add_warning(Anno, {deprecated_type, {M,N,NAs}, String}, St);
                   false ->
                       St
               end;
           {removed, String} ->
  -            add_warning(L, {removed_type, {M,N,NAs}, String}, St);
  +            add_warning(Anno, {removed_type, {M,N,NAs}, String}, St);
           no ->
               St
       end.
   
  -obsolete_guard({call,Line,{atom,Lr,F},As}, St0) ->
  +obsolete_guard({call,Anno,{atom,Ar,F},As}, St0) ->
       Arity = length(As),
       case erl_internal:old_type_test(F, Arity) of
   	false ->
  -	    deprecated_function(Line, erlang, F, As, St0);
  +	    deprecated_function(Anno, erlang, F, As, St0);
   	true ->
   	    St = case is_warn_enabled(obsolete_guard, St0) of
   		     true ->
  -			 add_warning(Lr, {obsolete_guard, {F, Arity}}, St0);
  +			 add_warning(Ar, {obsolete_guard, {F, Arity}}, St0);
   		     false ->
   			 St0
   		 end,
  -	    test_overriden_by_local(Lr, F, Arity, St)
  +	    test_overriden_by_local(Ar, F, Arity, St)
       end;
   obsolete_guard(_G, St) ->
       St.
   
  -test_overriden_by_local(Line, OldTest, Arity, St) ->
  +test_overriden_by_local(Anno, OldTest, Arity, St) ->
       ModernTest = list_to_atom("is_"++atom_to_list(OldTest)),
       case is_local_function(St#lint.locals, {ModernTest, Arity}) of
   	true ->
  -	    add_error(Line, {obsolete_guard_overridden,OldTest}, St);
  +	    add_error(Anno, {obsolete_guard_overridden,OldTest}, St);
   	false ->
   	    St
       end.
   
  -%% keyword_warning(Line, Atom, State) -> State.
  +%% keyword_warning(Anno, Atom, State) -> State.
   %%  Add warning for atoms that will be reserved keywords in the future.
   %%  (Currently, no such keywords to warn for.)
  -keyword_warning(_Line, _A, St) -> St.
  -
  -%% format_function(Line, ModName, FuncName, [Arg], State) -> State.
  +keyword_warning(_Anno, _A, St) -> St.
  +
  +%% format_function(Anno, ModName, FuncName, [Arg], State) -> State.
   %%  Add warning for bad calls to io:fwrite/format functions.
   
  -format_function(Line, M, F, As, St) ->
  +format_function(Anno, M, F, As, St) ->
       case is_format_function(M, F) of
           true ->
               case St#lint.warn_format of
                   Lev when Lev > 0 ->
                       case check_format_1(As) of
                           {warn,Level,Fmt,Fas} when Level =< Lev ->
  -                            add_warning(Line, {format_error,{Fmt,Fas}}, St);
  +                            add_warning(Anno, {format_error,{Fmt,Fas}}, St);
                           _ -> St
                       end;
                   _Lev -> St
  
positive.code: %% used         variable has been used
  %% unused       variable has been bound but not used
  %%
  %% Lines is a list of line numbers where the variable was bound.
  %%
  %% Report variable errors/warnings as soon as possible and then change
  %% the state to ok. This simplifies the code and reports errors only
  
negative.code:                recdef_top=false :: boolean(),	%true in record initialisation
  						%outside any fun or lc
                 xqlc= false :: boolean(),	%true if qlc.hrl included
                 called= [] :: [{fa(),anno()}],   %Called functions
                 usage = #usage{}		:: #usage{},
                 specs = maps:new()               %Type specifications
                     :: #{mfa() => anno()},
                 callbacks = maps:new()           %Callback types
                     :: #{mfa() => anno()},
                 optional_callbacks = maps:new()  %Optional callbacks
                     :: #{mfa() => anno()},
                 types = maps:new()               %Type definitions
                     :: #{ta() => #typeinfo{}},
                 exp_types=gb_sets:empty()        %Exported types
  