anchor.diff:  %%       _ -> refactor_undo ! {add, Files1}
   %%     end,
       %% Actually the result of writing to files should be checked!
  -    lists:foreach(F, Files).    
  +    lists:foreach(F, Files).   
   
   %% =====================================================================
   %% @spec tokenize(File::filename()) -> [token()]
  
positive.code:     lists:flatmap(fun(C) ->
  			  case C of 
  			      ' ' -> [C];
  			      $\n -> "\\n";
  			      $\\ -> "\\\\";
  			    %%  $\s  -> "\\s";
  			      $\r ->  "\\r";
  			      $\t -> "\\t";
  			      $\v -> "\\v";
  			      $\b -> "\\f";
  			      $\f -> "\\f";
  			      $\e -> "\\e";
  			      $\d -> "\\d";
  			      _ -> [C]
  			  end
  		  end, S).
  
negative.code:    
  -spec(do_build_callgraph/2::(filename(), {syntaxTree(),moduleInfo()}) -> 
      [{{{atom(), atom(), integer()}, syntaxTree()}, [{atom(), atom(), integer()}]}]).
  
  do_build_callgraph(FileName, {AnnAST, Info}) ->
      case lists:keysearch(module, 1, Info) of 
  	{value, {module, ModName}}  -> ModName;
  	_ -> ModName = list_to_atom(filename:basename(FileName, ".erl")),
  	     ModName
      end,
      InscopeFuns = refac_util:auto_imported_bifs() ++ refac_util:inscope_funs(Info), 
      F1 = fun (T, S) ->
  		 case refac_syntax:type(T) of
  		   function ->
  		       FunName = refac_syntax:data(refac_syntax:function_name(T)),
  		       Arity = refac_syntax:function_arity(T),
  		       Caller = {{ModName, FunName, Arity}, T},
  		       CalledFuns = called_funs(ModName, InscopeFuns, T),
  		       ordsets:add_element({Caller, CalledFuns}, S);
  		   %% lists:foldr(fun(E,S_) -> ordsets:add_element({Caller, E}, S_) end, S,  CalledFuns);
  		   _ -> S
  		 end
  	 end,
      lists:usort(refac_syntax_lib:fold(F1, [], AnnAST)).
  
  -spec(called_funs/3::(modulename(), [{modulename(), functionname(), arity()}], syntaxTree()) ->
  	     [{modulename(), functionname, arity()}]).
  called_funs(ModName, InscopeFuns,  Tree) ->
      HandleSpecialFuns = fun (Arguments, S) ->
  				case Arguments of
  				    [F, A] ->
  