anchor.diff:  ltype(T) ->
       ltype(T, 0).
   
  -ltype({ann_type,_Line,[V,T]}, Prec) ->
  +ltype({ann_type,_Anno,[V,T]}, Prec) ->
       {L,P,R} = type_inop_prec('::'),
       Vl = ltype(V, L),
       Tr = ltype(T, R),
       El = {list,[{cstep,[Vl,' ::'],Tr}]},
       maybe_paren(P, Prec, El);
  -ltype({paren_type,_Line,[T]}, P) ->
  +ltype({paren_type,_Anno,[T]}, P) ->
       %% Generated before Erlang/OTP 18.
       ltype(T, P);
  -ltype({type,_Line,union,Ts}, Prec) ->
  +ltype({type,_Anno,union,Ts}, Prec) ->
       {_L,P,R} = type_inop_prec('|'),
       E = {seq,[],[],[' |'],ltypes(Ts, R)},
       maybe_paren(P, Prec, E);
  -ltype({type,_Line,list,[T]}, _) ->
  +ltype({type,_Anno,list,[T]}, _) ->
       {seq,$[,$],$,,[ltype(T)]};
  -ltype({type,_Line,nonempty_list,[T]}, _) ->
  +ltype({type,_Anno,nonempty_list,[T]}, _) ->
       {seq,$[,$],[$,],[ltype(T),leaf("...")]};
  -ltype({type,Line,nil,[]}, _) ->
  -    lexpr({nil,Line}, options(none));
  -ltype({type,Line,map,any}, _) ->
  -    simple_type({atom,Line,map}, []);
  -ltype({type,_Line,map,Pairs}, Prec) ->
  +ltype({type,Anno,nil,[]}, _) ->
  +    lexpr({nil,Anno}, options(none));
  +ltype({type,Anno,map,any}, _) ->
  +    simple_type({atom,Anno,map}, []);
  +ltype({type,_Anno,map,Pairs}, Prec) ->
       {P,_R} = type_preop_prec('#'),
       E = map_type(Pairs),
       maybe_paren(P, Prec, E);
  -ltype({type,Line,tuple,any}, _) ->
  -    simple_type({atom,Line,tuple}, []);
  -ltype({type,_Line,tuple,Ts}, _) ->
  +ltype({type,Anno,tuple,any}, _) ->
  +    simple_type({atom,Anno,tuple}, []);
  +ltype({type,_Anno,tuple,Ts}, _) ->
       tuple_type(Ts, fun ltype/2);
  -ltype({type,_Line,record,[{atom,_,N}|Fs]}, Prec) ->
  +ltype({type,_Anno,record,[{atom,_,N}|Fs]}, Prec) ->
       {P,_R} = type_preop_prec('#'),
       E = record_type(N, Fs),
       maybe_paren(P, Prec, E);
  -ltype({type,_Line,range,[_I1,_I2]=Es}, Prec) ->
  +ltype({type,_Anno,range,[_I1,_I2]=Es}, Prec) ->
       {_L,P,R} = type_inop_prec('..'),
       F = fun(E, Opts) -> lexpr(E, R, Opts) end,
       E = expr_list(Es, '..', F, options(none)),
       maybe_paren(P, Prec, E);
  -ltype({type,_Line,binary,[I1,I2]}, _) ->
  +ltype({type,_Anno,binary,[I1,I2]}, _) ->
       binary_type(I1, I2); % except binary()
  -ltype({type,_Line,'fun',[]}, _) ->
  +ltype({type,_Anno,'fun',[]}, _) ->
       leaf("fun()");
   ltype({type,_,'fun',[{type,_,any},_]}=FunType, _) ->
       [fun_type(['fun',$(], FunType),$)];
  -ltype({type,_Line,'fun',[{type,_,product,_},_]}=FunType, _) ->
  +ltype({type,_Anno,'fun',[{type,_,product,_},_]}=FunType, _) ->
       [fun_type(['fun',$(], FunType),$)];
  -ltype({type,Line,T,Ts}, _) ->
  -    simple_type({atom,Line,T}, Ts);
  -ltype({user_type,Line,T,Ts}, _) ->
  -    simple_type({atom,Line,T}, Ts);
  -ltype({remote_type,Line,[M,F,Ts]}, _) ->
  -    simple_type({remote,Line,M,F}, Ts);
  +ltype({type,Anno,T,Ts}, _) ->
  +    simple_type({atom,Anno,T}, Ts);
  +ltype({user_type,Anno,T,Ts}, _) ->
  +    simple_type({atom,Anno,T}, Ts);
  +ltype({remote_type,Anno,[M,F,Ts]}, _) ->
  +    simple_type({remote,Anno,M,F}, Ts);
   ltype({atom,_,T}, _) ->
       {singleton_atom_type,T};
   ltype(E, P) ->
  
positive.code: map_pair_types(Fs) ->
      tuple_type(Fs, fun map_pair_type/2).
  
  map_pair_type({type,_Line,map_field_assoc,[KType,VType]}, Prec) ->
      {list,[{cstep,[ltype(KType, Prec),leaf(" =>")],ltype(VType, Prec)}]};
  map_pair_type({type,_Line,map_field_exact,[KType,VType]}, Prec) ->
      {list,[{cstep,[ltype(KType, Prec),leaf(" :=")],ltype(VType, Prec)}]}.
  
  record_type(Name, Fields) ->
  
negative.code:     try attrib(optional_callbacks, falist(Falist))
      catch _:_ -> attr(optional_callbacks, [abstract(Falist, Opts)])
      end;
  lattribute(file, {Name,Anno}, _Opts) ->
      attr(file, [{string,a0(),Name},{integer,a0(),Anno}]);
  lattribute(record, {Name,Is}, Opts) ->
      Nl = [leaf("-record("),{atom,Name},$,],
      [{first,Nl,record_fields(Is, Opts)},$)];
  