anchor.diff:  
   
   do_rename_fun(FileName, SearchPaths, Tree, {ModName, OldName, Arity}, {DefinePos, NewName}, Pid) ->
  -    refac_util:stop_tdTP(fun do_rename_fun_1/2, Tree, {FileName, {ModName, OldName, Arity}, {DefinePos, NewName},SearchPaths, Pid}).
  +    refac_util:full_tdTP(fun do_rename_fun_1/2, Tree, {FileName, {ModName, OldName, Arity}, {DefinePos, NewName},SearchPaths, Pid}).
     
   do_rename_fun_1(Tree, {FileName, {M, OldName, Arity}, {DefinePos, NewName}, SearchPaths, Pid}) ->
       case refac_syntax:type(Tree) of
         function ->
   	  case get_fun_def_loc(Tree) of
   	    DefinePos ->
  -		N = refac_syntax:function_name(Tree),
  -		Cs = refac_syntax:function_clauses(Tree),
  -		N1 = refac_syntax:copy_attrs(N, refac_syntax:atom(NewName)),
  -		{refac_syntax:copy_attrs(Tree, refac_syntax:function(N1, Cs)), false};
  +		  N = refac_syntax:function_name(Tree),
  +		  Cs = refac_syntax:function_clauses(Tree),
  +		  N1 = copy_pos_attrs(N, refac_syntax:atom(NewName)),
  +		  {copy_pos_attrs(Tree, refac_syntax:function(N1, Cs)), true};
   	    _ -> {Tree, false}
   	  end;
         application ->
  
positive.code: 		      Fun = refac_syntax:module_qualifier_body(T),
  		      S1 = case refac_syntax:type(Mod) of
  			     atom ->
  				 case refac_syntax:atom_value(Mod) of
  				   AtomName ->
  				       S ++ [{module, refac_syntax:get_pos(Mod)}];
  				   _ -> S
  				 end;
  			     _ -> S
  			   end,
  		      case refac_syntax:type(Fun) of
  			atom ->
  			    case refac_syntax:atom_value(Fun) of
  			      AtomName -> S1 ++ [{function, refac_syntax:get_pos(Fun)}];
  			      _ -> S1
  			    end;
  			_ -> S1
  		      end;
  		  arity_qualifier ->
  		      Fun = refac_syntax:arity_qualifier_body(T),
  		      case refac_syntax:atom_value(Fun) of
  			AtomName -> S ++ [{function, refac_syntax:get_pos(Fun)}];
  			_ -> S
  		      end;
  		  infix_expr ->
  		      Op = refac_syntax:infix_expr_operator(T),
  		      Left = refac_syntax:infix_expr_left(T),
  		      case refac_syntax:operator_name(Op) of
  			'!' ->
  			    case refac_syntax:type(Left) of
  			      atom ->
  				  case refac_syntax:atom_value(Left) of
  				    AtomName ->
  					S ++ [{process, refac_syntax:get_pos(Left)}];
  				    _ -> S
  				  end;
  			      _ -> S
  			    end;
  			_ -> S
  		      end;
  		  record_expr -> Type = refac_syntax:record_expr_type(T),
  				 case refac_syntax:type(Type) of 
  				     atom -> S ++ [{record, refac_syntax:get_pos(Type)}];
  				     _ -> S
  				 end;
  		  record_field -> Name = refac_syntax:record_field_name(T),
  				   case refac_syntax:type(Name) of 
  				       atom -> S ++ [{record, refac_syntax:get_pos(Name)}];
  				       _ -> S
  				   end;				   
  		  record_access -> Type = refac_syntax:record_access_type(T),
  				   Field = refac_syntax:record_access_field(T),
  				   S1 =case refac_syntax:type(Type) of 
  					   atom -> S ++ [{record, refac_syntax:get_pos(Type)}];
  					   _ -> S
  				       end,
  				   case refac_syntax:type(Field) of 
  				       atom -> S1 ++ [{record, refac_syntax:get_pos(Field)}];
  				       _ -> S1
  				   end;
  		  atom ->
  		      case refac_syntax:atom_value(T) of
  			AtomName ->
  			    Pos = refac_syntax:get_pos(T), S ++ [{atom, Pos}];
  			_ -> S
  		      end;
  		  _ -> S
  		end
  	end,
      refac_syntax_lib:fold(F, [], Tree).
  
negative.code: 					Fun = refac_syntax:module_qualifier_body(Operator),
  					case get_fun_def_info(Operator) of
  					    {M, OldName, Arity, _} ->
  						Fun2 = copy_pos_attrs(Fun, refac_syntax:atom(NewName)),
  						%% Need to change the fun_def annotation as well?
  						Operator1 = copy_pos_attrs(Operator, refac_syntax:module_qualifier(Mod, Fun2)),
  						Tree1 = copy_pos_attrs(Tree, refac_syntax:application(Operator1, Arguments)),
  						{Tree1, true};
  					    _ -> {Tree, false}
  					end;
  