anchor.diff:  %%  updated record tuple.
   
   record_setel(R, Name, Fs, Us0) ->
  -    Us1 = foldl(fun ({record_field,Lf,Field,Val}, Acc) ->
  -                        {integer,_,FieldIndex} = I = index_expr(Lf, Field, Name, Fs),
  -                        [{FieldIndex,{I,Lf,Val}} | Acc]
  +    Us1 = foldl(fun ({record_field,Anno,Field,Val}, Acc) ->
  +                        {integer,_,FieldIndex} = I = index_expr(Anno, Field, Name, Fs),
  +                        [{FieldIndex,{I,Anno,Val}} | Acc]
                   end, [], Us0),
       Us2 = sort(Us1),
       Us = [T || {_,T} <- Us2],
  -    Lr = element(2, hd(Us)),
  -    Wildcards = duplicate(length(Fs), {var,Lr,'_'}),
  -    NLr = no_compiler_warning(Lr),
  +    AnnoR = element(2, hd(Us)),
  +    Wildcards = duplicate(length(Fs), {var,AnnoR,'_'}),
  +    NAnnoR = no_compiler_warning(AnnoR),
       %% Note: calling mark_record() here is not necessary since it is
       %% targeted at Dialyzer which always calls the compiler with
       %% 'strict_record_updates' meaning that record_setel() will never
       %% be called.
  -    {'case',Lr,R,
  -     [{clause,Lr,[{tuple,Lr,[{atom,Lr,Name} | Wildcards]}],[],
  -       [foldr(fun ({I,Lf,Val}, Acc) ->
  -                      {call,Lf,{remote,Lf,{atom,Lf,erlang},
  -				{atom,Lf,setelement}},[I,Acc,Val]} end,
  +    {'case',AnnoR,R,
  +     [{clause,AnnoR,[{tuple,AnnoR,[{atom,AnnoR,Name} | Wildcards]}],[],
  +       [foldr(fun ({I,Anno,Val}, Acc) ->
  +                      {call,Anno,{remote,Anno,{atom,Anno,erlang},
  +				{atom,Anno,setelement}},[I,Acc,Val]} end,
                 R, Us)]},
  -      {clause,NLr,[{var,NLr,'_'}],[],
  -       [call_error(NLr, {tuple,NLr,[{atom,NLr,badrecord},{atom,NLr,Name}]})]}]}.
  +      {clause,NAnnoR,[{var,NAnnoR,'_'}],[],
  +       [call_error(NAnnoR, {tuple,NAnnoR,[{atom,NAnnoR,badrecord},{atom,NAnnoR,Name}]})]}]}.
   
   %% Expand a call to record_info/2. We have checked that it is not
   %% shadowed by an import.
   
  -record_info_call(Line, [{atom,_Li,Info},{atom,_Ln,Name}], St) ->
  +record_info_call(Anno, [{atom,_AnnoI,Info},{atom,_AnnoN,Name}], St) ->
       case Info of
           size ->
  -            {{integer,Line,1+length(record_fields(Name, Line, St))},St};
  +            {{integer,Anno,1+length(record_fields(Name, Anno, St))},St};
           fields ->
  -            {make_list(field_names(record_fields(Name, Line, St)), Line),St}
  +            {make_list(field_names(record_fields(Name, Anno, St)), Anno),St}
       end.
   
   %% Break out expressions from an record update list and bind to new
  
positive.code: %%  passed through expr again.
  
  record_update(R, Name, Fs, Us0, St0) ->
      Line = element(2, R),
      {Pre,Us,St1} = record_exprs(Us0, St0),
      Nf = length(Fs),                            %# of record fields
      Nu = length(Us),                            %# of update fields
  
negative.code:     {String,St};
  pattern({nil,_}=Nil, St) ->
      {Nil,St};
  pattern({cons,Anno,H,T}, St0) ->
      {TH,St1} = pattern(H, St0),
      {TT,St2} = pattern(T, St1),
      {{cons,Anno,TH,TT},St2};
  pattern({tuple,Anno,Ps}, St0) ->
      {TPs,St1} = pattern_list(Ps, St0),
      {{tuple,Anno,TPs},St1};
  pattern({map,Anno,Ps}, St0) ->
      {TPs,St1} = pattern_list(Ps, St0),
      {{map,Anno,TPs},St1};
  pattern({map_field_exact,Anno,K0,V0}, St0) ->
      {K,St1} = expr(K0, St0),
      {V,St2} = pattern(V0, St1),
      {{map_field_exact,Anno,K,V},St2};
  pattern({record_index,Anno,Name,Field}, St) ->
      {index_expr(Anno, Field, Name, record_fields(Name, Anno, St)),St};
  pattern({record,Anno0,Name,Pfs}, St0) ->
      Fs = record_fields(Name, Anno0, St0),
      {TMs,St1} = pattern_list(pattern_fields(Fs, Pfs), St0),
      Anno = mark_record(Anno0, St1),
      {{tuple,Anno,[{atom,Anno0,Name} | TMs]},St1};
  pattern({bin,Anno,Es0}, St0) ->
      {Es1,St1} = pattern_bin(Es0, St0),
      {{bin,Anno,Es1},St1};
  pattern({match,Anno,Pat1, Pat2}, St0) ->
      {TH,St1} = pattern(Pat2, St0),
      {TT,St2} = pattern(Pat1, St1),
      {{match,Anno,TT,TH},St2};
  pattern({op,Anno,Op,A0}, St0) ->
      {A,St1} = pattern(A0, St0),
      {{op,Anno,Op,A},St1};
  pattern({op,Anno,Op,L0,R0}, St0) ->
      {L,St1} = pattern(L0, St0),
      {R,St2} = pattern(R0, St1),
      {{op,Anno,Op,L,R},St2}.
  
  pattern_list([P0 | Ps0], St0) ->
      {P,St1} = pattern(P0, St0),
  