anchor.diff:  		      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
  +				 case lists:member(refac_syntax:atom_value(Mod), AtomNames) of
  +				     true ->
  +					 S ++ [{module, refac_syntax:get_pos(Mod)}];
  +				    false -> S
   				 end;
  -			     _ -> S
  +			       _ -> 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;
  +			  atom ->
  +			      case lists:member(refac_syntax:atom_value(Fun), AtomNames) of
  +				  true -> S1 ++ [{function, refac_syntax:get_pos(Fun)}];
  +				  false -> 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;
  +			Fun = refac_syntax:arity_qualifier_body(T),
  +			case lists:member(refac_syntax:atom_value(Fun), AtomNames) of
  +			    true -> S ++ [{function, refac_syntax:get_pos(Fun)}];
  +			    false -> 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)}];
  +			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 lists:member(refac_syntax:atom_value(Left),AtomNames) of
  +					    true ->
  +						S ++ [{process, refac_syntax:get_pos(Left)}];
  +					    _ -> S
  +					end;
   				    _ -> 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)}];
  +				end;
  +			    _ -> S
  +			end;
  +		    record_expr -> Type = refac_syntax:record_expr_type(T),
  +				   case refac_syntax:type(Type) of 
  +				       atom -> 
  +					   case lists:member(refac_syntax:atom_value(Type), AtomNames) of 
  +					       true ->
  +						   S ++ [{record, refac_syntax:get_pos(Type)}];
  +					       false ->
  +						   S
  +					   end;
   				       _ -> 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
  +		    record_field -> Name = refac_syntax:record_field_name(T),
  +				    case refac_syntax:type(Name) of 
  +					atom -> 
  +					    case lists:member(refac_syntax:atom_value(Name), AtomNames) of
  +						true ->
  +						    S ++ [{record, refac_syntax:get_pos(Name)}];
  +						_ -> S
  +					    end;
  +					_ -> 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 -> 
  +						 case lists:member(refac_syntax:atom_value(Type), AtomNames) of 
  +						     true ->
  +							 S ++ [{record, refac_syntax:get_pos(Type)}];
  +						     false ->
  +							 S
  +						 end;
  +					     _ -> S
  +					 end,
  +				     case refac_syntax:type(Field) of 
  +					 atom -> 
  +					     case lists:member(refac_syntax:atom_value(Field), AtomNames) of 
  +						 true ->
  +						     S ++ [{record, refac_syntax:get_pos(Field)}];
  +						 false ->
  +						     S
  +					     end;
  +					 _ -> S1
  +				     end;
  +		    atom ->
  +			case lists:member(refac_syntax:atom_value(T), AtomNames) of
  +			    true ->
  +				Pos = refac_syntax:get_pos(T), S ++ [{atom, Pos}];
  +			    false -> S
  +			end;
  +		    _ -> S
   		end
   	end,
       refac_syntax_lib:fold(F, [], Tree).
  
positive.code: 				      4 -> refac_syntax:application(Operator, [N2, Mod, Fun2, Args]);
  				      3 -> refac_syntax:application(Operator, [Mod, Fun2, Args])
  				  end,
  			    {refac_syntax:copy_pos(Node, refac_syntax:copy_attrs(Node, App)), true};
  			false -> {Node, false}
  		    end;
  		_ ->
  
negative.code: 	    ok
      end.
  
  output_atom_warning_msg(Pid, Names) ->
      Pid ! {self(), get},
      receive
  	{Pid, {NotRenamed, Renamed}} ->
  	    output_atom_warnings({NotRenamed, Renamed}, Names);
  	_ -> throw({error, "Refactoring failed because of a Wrangler error."})
      end.
      
      
  