anchor.diff:  
   '#new-/1'(Exports) ->
       {?function, fname(new), 1,
  -     lists:map(fun 'new-'/1, Exports)}.
  +     lists:map(fun 'new-'/1, Exports) ++ [?BADARG(1)]}.
   
   'new-'(R) ->
       {?clause, [?ATOM(R)],
  
positive.code: 
  -export([parse_transform/2]).
  
  %% Form tag with line number.
  -define(F(T), T, ?LINE).
  %% Yes, that's right. The replacement is to the first unmatched ')'.
  
  -define(attribute,    ?F(attribute)).
  -define(clause,       ?F(clause)).
  -define(function,     ?F(function)).
  -define(call,         ?F(call)).
  -define('fun',        ?F('fun')).
  -define(generate,     ?F(generate)).
  -define(lc,           ?F(lc)).
  -define(match,        ?F(match)).
  -define(remote,       ?F(remote)).
  -define(record,       ?F(record)).
  -define(record_field, ?F(record_field)).
  -define(record_index, ?F(record_index)).
  -define(tuple,        ?F(tuple)).
  
  -define(ATOM(T),      {atom, ?LINE, T}).
  -define(VAR(V),       {var, ?LINE, V}).
  
  -define(CALL(F,A),    {?call, ?ATOM(F), A}).
  -define(APPLY(M,F,A), {?call, {?remote, ?ATOM(M), ?ATOM(F)}, A}).
  
  %% parse_transform/2
  
  parse_transform(Forms, _Options) ->
      Rs = [R || {attribute, _, record, R} <- Forms],
      case lists:append([E || {attribute, _, export_records, E} <- Forms]) of
          [] ->
              Forms;
          Es ->
              {H,T} = lists:splitwith(fun is_head/1, Forms),
              H ++ [a_export(Es) | f_accessors(Es, Rs)] ++ T
      end.
  
  is_head(T) ->
      not lists:member(element(1,T), [function, eof]).
  
negative.code: 
  '#info-/2'(Exports) ->
      {?function, fname(info), 2,
       lists:map(fun 'info-'/1, Exports) ++ [?BADARG(2)]}.
  
  'info-'(R) ->
      {?clause, [?ATOM(R), ?VAR('Info')],
  