anchor.diff:  
       %% We need a new variable for the record expression
       %% to guarantee that it is only evaluated once.
  -    {Var,St2} = new_var(Line, St1),
  +    {Var,St2} = new_var(Anno, St1),
   
       StrictUpdates = strict_record_updates(St2#exprec.compile),
   
  
positive.code: 	_ ->
  	    {Var,Rs0}
      end;
  opt_pattern({cons,Line,H0,T0}, Rs0) ->
      {H,Rs1} = opt_pattern(H0, Rs0),
      {T,Rs} = opt_pattern(T0, Rs1),
      {{cons,Line,H,T},Rs};
  opt_pattern({tuple,Line,Es0}, Rs0) ->
      {Es,Rs} = opt_pattern_list(Es0, Rs0),
      {{tuple,Line,Es},Rs};
  opt_pattern({match,Line,Pa0,Pb0}, Rs0) ->
      {Pa,Rs1} = opt_pattern(Pa0, Rs0),
      {Pb,Rs} = opt_pattern(Pb0, Rs1),
      {{match,Line,Pa,Pb},Rs};
  opt_pattern(P, Rs) -> {P,Rs}.
  
  opt_var({var,Line,_}=Var, Tag, Sz) ->
      Rp = record_pattern(2, -1, ignore, Sz, Line, [{atom,Line,Tag}]),
      {match,Line,{tuple,Line,Rp},Var}.
  
  opt_remove(Gs, Rs) ->
      [opt_remove_1(G, Rs) || G <- Gs].
  
negative.code:     St = St0#exprec{records=maps:put(Name, NDefs, St0#exprec.records)},
      {Fs1, St1} = forms(Fs, St),
      {[Attr | Fs1], St1};
  forms([{function,Anno,N,A,Cs0} | Fs0], St0) ->
      {Cs,St1} = clauses(Cs0, St0),
      {Fs,St2} = forms(Fs0, St1),
      {[{function,Anno,N,A,Cs} | Fs],St2};
  forms([F | Fs0], St0) ->
      {Fs,St} = forms(Fs0, St0),
      {[F | Fs], St};
  forms([], St) -> {[],St}.
  
  clauses([{clause,Anno,H0,G0,B0} | Cs0], St0) ->
      {H1,St1} = head(H0, St0),
      {G1,St2} = guard(G0, St1),
      {H,G} = optimize_is_record(H1, G1, St2),
      {B,St3} = exprs(B0, St2),
      {Cs,St4} = clauses(Cs0, St3),
      {[{clause,Anno,H,G,B} | Cs],St4};
  clauses([], St) -> {[],St}.
  
  head(As, St) -> pattern_list(As, St).
  