anchor.diff:      [C1|fun_clauses(Cs)];
   fun_clauses([]) -> [].
   
  -function_type_list([{type,Line,bounded_fun,[Ft,Fc]}|Fts]) ->
  +function_type_list([{type,Anno,bounded_fun,[Ft,Fc]}|Fts]) ->
       Ft1 = function_type(Ft),
       Fc1 = function_constraint(Fc),
  -    [{type,Line,bounded_fun,[Ft1,Fc1]}|function_type_list(Fts)];
  +    [{type,Anno,bounded_fun,[Ft1,Fc1]}|function_type_list(Fts)];
   function_type_list([Ft|Fts]) ->
       [function_type(Ft)|function_type_list(Fts)];
   function_type_list([]) -> [].
   
  -function_type({type,Line,'fun',[{type,Lt,product,As},B]}) ->
  +function_type({type,Anno,'fun',[{type,At,product,As},B]}) ->
       As1 = type_list(As),
       B1 = type(B),
  -    {type,Line,'fun',[{type,Lt,product,As1},B1]}.
  +    {type,Anno,'fun',[{type,At,product,As1},B1]}.
   
   function_constraint([C|Cs]) ->
       C1 = constraint(C),
       [C1|function_constraint(Cs)];
   function_constraint([]) -> [].
   
  -constraint({type,Line,constraint,[{atom,L,A},[V,T]]}) ->
  +constraint({type,Anno,constraint,[{atom,Annoa,A},[V,T]]}) ->
       V1 = type(V),
       T1 = type(T),
  -    {type,Line,constraint,[{atom,L,A},[V1,T1]]}.
  -
  -type({ann_type,Line,[{var,Lv,V},T]}) ->
  +    {type,Anno,constraint,[{atom,Annoa,A},[V1,T1]]}.
  +
  +type({ann_type,Anno,[{var,Av,V},T]}) ->
       T1 = type(T),
  -    {ann_type,Line,[{var,Lv,V},T1]};
  -type({atom,Line,A}) ->
  -    {atom,Line,A};
  -type({integer,Line,I}) ->
  -    {integer,Line,I};
  -type({op,Line,Op,T}) ->
  +    {ann_type,Anno,[{var,Av,V},T1]};
  +type({atom,Anno,A}) ->
  +    {atom,Anno,A};
  +type({integer,Anno,I}) ->
  +    {integer,Anno,I};
  +type({op,Anno,Op,T}) ->
       T1 = type(T),
  -    {op,Line,Op,T1};
  -type({op,Line,Op,L,R}) ->
  +    {op,Anno,Op,T1};
  +type({op,Anno,Op,L,R}) ->
       L1 = type(L),
       R1 = type(R),
  -    {op,Line,Op,L1,R1};
  -type({type,Line,binary,[M,N]}) ->
  +    {op,Anno,Op,L1,R1};
  +type({type,Anno,binary,[M,N]}) ->
       M1 = type(M),
       N1 = type(N),
  -    {type,Line,binary,[M1,N1]};
  -type({type,Line,'fun',[]}) ->
  -    {type,Line,'fun',[]};
  -type({type,Line,'fun',[{type,Lt,any},B]}) ->
  +    {type,Anno,binary,[M1,N1]};
  +type({type,Anno,'fun',[]}) ->
  +    {type,Anno,'fun',[]};
  +type({type,Anno,'fun',[{type,At,any},B]}) ->
       B1 = type(B),
  -    {type,Line,'fun',[{type,Lt,any},B1]};
  -type({type,Line,range,[L,H]}) ->
  +    {type,Anno,'fun',[{type,At,any},B1]};
  +type({type,Anno,range,[L,H]}) ->
       L1 = type(L),
       H1 = type(H),
  -    {type,Line,range,[L1,H1]};
  -type({type,Line,map,any}) ->
  -    {type,Line,map,any};
  -type({type,Line,map,Ps}) ->
  +    {type,Anno,range,[L1,H1]};
  +type({type,Anno,map,any}) ->
  +    {type,Anno,map,any};
  +type({type,Anno,map,Ps}) ->
       Ps1 = map_pair_types(Ps),
  -    {type,Line,map,Ps1};
  -type({type,Line,record,[{atom,La,N}|Fs]}) ->
  +    {type,Anno,map,Ps1};
  +type({type,Anno,record,[{atom,Aa,N}|Fs]}) ->
       Fs1 = field_types(Fs),
  -    {type,Line,record,[{atom,La,N}|Fs1]};
  -type({remote_type,Line,[{atom,Lm,M},{atom,Ln,N},As]}) ->
  +    {type,Anno,record,[{atom,Aa,N}|Fs1]};
  +type({remote_type,Anno,[{atom,Am,M},{atom,An,N},As]}) ->
       As1 = type_list(As),
  -    {remote_type,Line,[{atom,Lm,M},{atom,Ln,N},As1]};
  -type({type,Line,tuple,any}) ->
  -    {type,Line,tuple,any};
  -type({type,Line,tuple,Ts}) ->
  +    {remote_type,Anno,[{atom,Am,M},{atom,An,N},As1]};
  +type({type,Anno,tuple,any}) ->
  +    {type,Anno,tuple,any};
  +type({type,Anno,tuple,Ts}) ->
       Ts1 = type_list(Ts),
  -    {type,Line,tuple,Ts1};
  -type({type,Line,union,Ts}) ->
  +    {type,Anno,tuple,Ts1};
  +type({type,Anno,union,Ts}) ->
       Ts1 = type_list(Ts),
  -    {type,Line,union,Ts1};
  -type({var,Line,V}) ->
  -    {var,Line,V};
  -type({user_type,Line,N,As}) ->
  +    {type,Anno,union,Ts1};
  +type({var,Anno,V}) ->
  +    {var,Anno,V};
  +type({user_type,Anno,N,As}) ->
       As1 = type_list(As),
  -    {user_type,Line,N,As1};
  -type({type,Line,N,As}) ->
  +    {user_type,Anno,N,As1};
  +type({type,Anno,N,As}) ->
       As1 = type_list(As),
  -    {type,Line,N,As1}.
  -
  -map_pair_types([{type,Line,map_field_assoc,[K,V]}|Ps]) ->
  +    {type,Anno,N,As1}.
  +
  +map_pair_types([{type,Anno,map_field_assoc,[K,V]}|Ps]) ->
       K1 = type(K),
       V1 = type(V),
  -    [{type,Line,map_field_assoc,[K1,V1]}|map_pair_types(Ps)];
  -map_pair_types([{type,Line,map_field_exact,[K,V]}|Ps]) ->
  +    [{type,Anno,map_field_assoc,[K1,V1]}|map_pair_types(Ps)];
  +map_pair_types([{type,Anno,map_field_exact,[K,V]}|Ps]) ->
       K1 = type(K),
       V1 = type(V),
  -    [{type,Line,map_field_exact,[K1,V1]}|map_pair_types(Ps)];
  +    [{type,Anno,map_field_exact,[K1,V1]}|map_pair_types(Ps)];
   map_pair_types([]) -> [].
   
  -field_types([{type,Line,field_type,[{atom,La,A},T]}|Fs]) ->
  +field_types([{type,Anno,field_type,[{atom,Aa,A},T]}|Fs]) ->
       T1 = type(T),
  -    [{type,Line,field_type,[{atom,La,A},T1]}|field_types(Fs)];
  +    [{type,Anno,field_type,[{atom,Aa,A},T1]}|field_types(Fs)];
   field_types([]) -> [].
   
   type_list([T|Ts]) ->
  
positive.code: 	     _ ->
  		 bit_types(T1)
  	 end,
      [{bin_element,L1,expr(E1),S2,T2} | pattern_grp(Fs)];
  pattern_grp([]) ->
      [].
  
  
negative.code: %% -type lc_bc_quals([Qualifier]) -> [Qualifier].
  %%  Allow filters to be both guard tests and general expressions.
  
  lc_bc_quals([{generate,Anno,P0,E0}|Qs]) ->
      E1 = expr(E0),
      P1 = pattern(P0),
      [{generate,Anno,P1,E1}|lc_bc_quals(Qs)];
  lc_bc_quals([{b_generate,Anno,P0,E0}|Qs]) ->
      E1 = expr(E0),
      P1 = pattern(P0),
      [{b_generate,Anno,P1,E1}|lc_bc_quals(Qs)];
  lc_bc_quals([E0|Qs]) ->
      E1 = expr(E0),
      [E1|lc_bc_quals(Qs)];
  