anchor.diff:  		      N = refac_syntax:function_name(T),
   		      collect_atoms_1(AtomNames, S, N, function);
   		  application ->
  -			Operator = refac_syntax:application_operator(T),
  -			collect_atoms_1(AtomNames, S, Operator, function);
  +		      Operator = refac_syntax:application_operator(T),
  +		      collect_atoms_1(AtomNames, S, Operator, function);
   		  module_qualifier ->
   		      Mod = refac_syntax:module_qualifier_argument(T),
   		      Fun = refac_syntax:module_qualifier_body(T),
  
positive.code:       {value, Val, _} -> {value, Val}
      catch
        _:_ ->
  	  case has_macros(Node) andalso refac_util:get_free_vars(Node) == [] of
  	    true ->
  		Dir = filename:dirname(FileName),
  		DefaultIncl2 = [filename:join(Dir, X) || X <- refac_util:default_incls()],
  		NewSearchPaths = SearchPaths ++ DefaultIncl2,
  		{Ms, UMs} = case refac_epp:parse_file(FileName, NewSearchPaths, []) of
  			      {ok, _, {Defs, Uses}} ->
  				  {dict:from_list(Defs), dict:from_list(Uses)};
  			      _ -> []
  
negative.code: 
  get_fun_def_mod(Node) ->
      As = refac_syntax:get_ann(Node),
      case lists:keysearch(fun_def, 1, As) of
        {value, {fun_def, {M, _N, _A, _P, _DefinePos}}} -> M;
        _ -> '_'
      end.
  
  rename_fun_in_client_modules(Files, {Mod, Fun, Arity}, NewName, SearchPaths, TabWidth, Pid) ->
      case Files of
        [] -> [];
        [F| Fs] ->
  	  ?wrangler_io("The current file under refactoring is:\n~p\n", [F]),
  	  {ok, {AnnAST0, Info}} = refac_util:parse_annotate_file(F, true, SearchPaths, TabWidth),
  	  AnnAST = refac_type_annotation:type_ann_ast(F, AnnAST0, SearchPaths, TabWidth),
  	  {AnnAST1, Changed} = rename_fun_in_client_module_1({AnnAST, Info}, {Mod, Fun, Arity}, NewName),
  	  check_atoms(F, AnnAST1, [Fun], Pid),
  	  if Changed ->
  		 [{{F, F}, AnnAST1}| rename_fun_in_client_modules(
  				       Fs, {Mod, Fun, Arity}, NewName, SearchPaths, TabWidth, Pid)];
  	     true ->
  		 rename_fun_in_client_modules(
  		   Fs, {Mod, Fun, Arity}, NewName, SearchPaths, TabWidth, Pid)
  	  end
      end.
  
  get_fun_def_info(Node) ->
      As = refac_syntax:get_ann(Node),
      case lists:keysearch(fun_def, 1, As) of
        {value, {fun_def, {Mod, FunName, Arity, _UsePos, DefinePos}}} ->
  	  {Mod, FunName, Arity, DefinePos};
        _ -> false
      end.
  
  rename_fun_in_client_module_1({Tree, Info}, {M, OldName, Arity}, NewName) ->
      case lists:keysearch(module, 1, Info) of
        {value, {module, ClientModName}} ->
  	  Inscope_Funs = [{F, A} || {_M, F, A} <- refac_util:inscope_funs(Info)],
  	  case
  	    lists:member({list_to_atom(NewName), Arity}, Inscope_Funs)
  	      and lists:member({OldName, Arity}, Inscope_Funs)
  	      of
  	    true ->
  		throw({error, "The new function name causes confliction in module '"
  				++ atom_to_list(ClientModName) ++ "'"});
  	    _ -> ok
  	  end;
        _ -> ok
      end,
      refac_util:full_tdTP(fun do_rename_fun_in_client_module_1/2, Tree,
  			 {{M, OldName, Arity}, NewName}).
  
  do_rename_fun_in_client_module_1(Tree, {{M, OldName, Arity}, NewName}) ->
      case refac_syntax:type(Tree) of
        application -> do_rename_in_fun_app(Tree, M, OldName, Arity, NewName);
        arity_qualifier ->   %% is there a module name?
  	  do_rename_fun_in_arity_qualifier(Tree, M, OldName, Arity, NewName);
        atom ->
  	  As = refac_syntax:get_ann(Tree),
  	  case lists:keysearch(type, 1, As) of
  	    {value, {type, {f_atom, [M, OldName, Arity]}}} ->
  		{refac_syntax:copy_attrs(Tree, refac_syntax:atom(NewName)), true};
  	    _ -> {Tree, false}
  	  end;
        _ -> {Tree, false}
      end.
  
  do_rename_fun_in_arity_qualifier(Tree, M, OldName, Arity, NewName) ->
      Fun = refac_syntax:arity_qualifier_body(Tree),
  