anchor.diff:      erlang:error({reference_to_undefined_function,FnName,Arity}).
   
   subst_atom(Term, AtomToBeChanged, NewExpr) ->
  -    AtomLiteralToBeChanged = erl_syntax:atom_literal(AtomToBeChanged),
  +    AtomLiteralToBeChanged = erl_syntax:atom_name(AtomToBeChanged),
       map_term(fun(Node) -> try_subst_atom(Node, AtomLiteralToBeChanged, NewExpr)
                end,
                Term).
   
   try_subst_atom(Node, AtomLiteralToBeChanged, NewExpr) ->
  -    try {erl_syntax:type(Node), erl_syntax:atom_literal(Node)} of
  -        {atom, AtomLiteralToBeChanged} ->
  -            NewExpr;
  -        {atom, _Other} ->
  -            Node
  -    catch error:_ ->
  -            Node
  +    case safe_analyze_atom_as_name(Node) of
  +        {atom, AtomLiteralToBeChanged} -> NewExpr;
  +        {atom, _Other}                 -> Node;
  +        non_atom                       -> Node
       end.
   
   map_term(F, [Term | Rest]) ->
  
positive.code:     Arity = erl_syntax:function_arity(Tree),
      %% Return a format like that of analyze_implicit_fun_name (no module)
      {Name, Arity}.
  
negative.code:     runtime_transform(ParseTree, []).
  
  runtime_transform(ParseTree, Transforms) ->
      erl_syntax:revert(lists:foldl(fun apply_transform/2, ParseTree, Transforms)).
  
  apply_transform(Transform, ParseTree) ->
      map_term(transform_to_mapper(Transform), ParseTree).
  
  transform_to_mapper({replace, Marker, Replacement}) ->
      replacing_mapper(Marker, Replacement).
  
  replacing_mapper(Marker, Replacement) ->
      ReplacementTree = erl_parse:abstract(Replacement),
      fun(Node) ->
              case safe_analyze_atom_as_value(Node) of
                  {atom, Marker} -> ReplacementTree;
                  {atom, _Other} -> Node;
                  non_atom       -> Node
              end
      end.
  
  %% -> {Name,Arity} | {Module,{Name,Arity}}
  analyze_implicit_fun_name(Tree) ->
  