anchor.diff:  				      application ->
   					  Operator = add_category(refac_syntax:application_operator(MacroHead), macro_name),
   					  Arguments = add_category(refac_syntax:application_arguments(MacroHead), attribute),
  -					  refac_syntax:copy_attrs(MacroHead, refac_syntax:application(Operator, Arguments));
  +					  rewrite(MacroHead, refac_syntax:application(Operator, Arguments));
   				      _ -> add_category(MacroHead, macro_name)
   				    end,
   		       MacroBody1 = add_category(MacroBody, attribute),
  -		       Node1 = refac_syntax:copy_attrs(Node, refac_syntax:attribute(Name, [MacroHead1|MacroBody1])),
  +		       Node1 = rewrite(Node, refac_syntax:attribute(Name, [MacroHead1| MacroBody1])),
   		       {refac_syntax:add_ann({category, attribute}, Node1), true};
   		   _ -> {refac_syntax:add_ann({category, C}, Node), false}
   		 end;
  
positive.code: 		       T2 = [update_ann(C, {fun_def, {ModName, Fun_Name, Arity, refac_syntax:get_pos(C), Pos}})
  			     || C <- refac_syntax:function_clauses(T)],
  		       Name1 = update_ann(Name, {fun_def, {ModName, Fun_Name, Arity, Pos, Pos}}),
  		       T3 = refac_syntax:copy_pos(T, refac_syntax:copy_attrs(T, refac_syntax:function(Name1, T2))),
  		       update_ann(T3, {fun_def, {ModName, Fun_Name, Arity, Pos, Pos}});
  		   application ->
  		       Operator = refac_syntax:application_operator(T),
  		       Arguments = refac_syntax:application_arguments(T),
  		       case refac_syntax:type(Operator) of
  			 atom ->
  			     Op = refac_syntax:atom_value(Operator),
  			     Arity = length(Arguments),
  			     {DefMod, DefLoc} = Define_Mod_Loc(Op, Arity),
  			     Operator1 = update_ann(Operator, {fun_def, {DefMod, Op, Arity, refac_syntax:get_pos(Operator), DefLoc}}),
  			     refac_syntax:copy_pos(T, refac_syntax:copy_attrs(T, refac_syntax:application(Operator1, Arguments)));
  			 module_qualifier ->
  			       Mod = refac_syntax:module_qualifier_argument(Operator),
  			       Fun = refac_syntax:module_qualifier_body(Operator),
  			       M = case refac_syntax:type(Mod) of 
  				       atom ->refac_syntax:atom_value(Mod);
  				       macro -> MacroName = refac_syntax:macro_name(Mod),
  						case refac_syntax:type(MacroName) of 
  						    variable ->
  							case refac_syntax:variable_name(MacroName) of 
  							    'MODULE' -> ModName;
  								_ -> '_'
  							end;
  						    _ -> '_'
  						end;
  				       _ -> '_'
  				   end,								    
  			       Fun_Name = case refac_syntax:type(Fun) of 
  					      atom ->refac_syntax:atom_value(Fun);
  					      _ -> '_'
  					  end,
  			       Arity = length(Arguments),
  			       DefLoc = if M == ModName -> {_ModName, DefLoc1} = Define_Mod_Loc(Fun_Name, Arity), DefLoc1;
  					   true -> ?DEFAULT_LOC
  					end,
  			       Operator1 = refac_syntax:copy_attrs(Operator, refac_syntax:module_qualifier(Mod, Fun)),
  			       Operator2 = update_ann(Operator1, {fun_def, {M, Fun_Name, Arity, refac_syntax:get_pos(T), DefLoc}}),
  			       refac_syntax:copy_attrs(T, refac_syntax:application(Operator2, Arguments));			   
  			   _ -> Arity = length(Arguments),
  				Operator1 = update_ann(Operator, {fun_def, {'_', '_', Arity, refac_syntax:get_pos(Operator), ?DEFAULT_LOC}}),
  				refac_syntax:copy_pos(T, refac_syntax:copy_attrs(T, refac_syntax:application(Operator1, Arguments)))
  		       end;
  		     arity_qualifier ->
  			 Fun = refac_syntax:arity_qualifier_body(T),
  			 A = refac_syntax:arity_qualifier_argument(T),
  			 FunName = refac_syntax:atom_value(Fun),
  			 Arity = refac_syntax:integer_value(A),
  			 {DefMod, DefLoc} = Define_Mod_Loc(FunName, Arity),
  			 Fun1 = update_ann(Fun, {fun_def, {DefMod, FunName, Arity, refac_syntax:get_pos(Fun), DefLoc}}),
  			 update_ann(refac_syntax:copy_attrs(T, refac_syntax:arity_qualifier(Fun1, A)),
  				    {fun_def, {DefMod, FunName, Arity, refac_syntax:get_pos(Fun), DefLoc}});
  		     _ -> T
  		 end
  	 end,
      refac_syntax_lib:map(F1, Node).
  
negative.code: 			     Fs = ordsets:filter(fun ({_M, F, A, _Pos}) -> (F == Name) and (Arity == A) end, Inscope_Funs),
  			     case Fs of
  			       [] -> {erlang, ?DEFAULT_LOC};   %% is this correct? what about the function is not a BIF?
  			       [{M, _, _, Pos}| _] -> {M, Pos}
  			     end
  		     end,
      F1 = fun (T) ->
  