anchor.diff:  
   search_candidate_exprs(AnnAST, MacroDef) ->
       Args = refac_syntax:attribute_arguments(MacroDef),
  -    MacroHead = refac_util:ghead("refac_fold_against_macro:search_candiate_exprs", Args),
  -    MacroParNames = case refac_syntax:type(MacroHead) of 
  -		   application ->
  -		       Pars = refac_syntax:application_arguments(MacroHead),
  -		       lists:map(fun(A) ->refac_syntax:variable_name(A) end, Pars);
  -		   _ -> []
  -	       end,	    
  +    MacroHead = refac_misc:ghead("refac_fold_against_macro:search_candiate_exprs", Args),
  +    MacroParNames = case refac_syntax:type(MacroHead) of
  +		      application ->
  +			  Pars = refac_syntax:application_arguments(MacroHead),
  +			  [refac_syntax:variable_name(A) || A <- Pars];
  +		      _ -> []
  +		    end,
       MacroBody = tl(Args),
       Res = do_search_candidate_exprs(AnnAST, MacroBody, MacroParNames),
  -    case MacroBody of 
  -	[] ->[];
  -	_ -> lists:map(fun({Range, Subst}) ->
  -			       {Range, make_macro_app(MacroHead, Subst)}
  -		       end, Res)
  +    case MacroBody of
  +      [] ->
  +	  [];
  +      _ ->
  +	  [{Range, make_macro_app(MacroHead, Subst)} || {Range, Subst} <- Res]
       end.
   
   
  
positive.code: 
  %%=====================================================================================
  expr_unification(Exp1, Exp2, MacroParNames) ->
      case refac_fold_expression:expr_unification(Exp1, Exp2) of
        false -> false;
        {true, Subst} ->
  	  Subst1 = lists:usort(lists:map(fun ({E1, E2}) -> {E1, refac_prettypr:format(E2)} end, Subst)),
  	  Vars = lists:map(fun ({E1, _E2}) -> E1 end, Subst1),
  	  SVars = lists:usort(Vars),
  	  case length(Vars) == length(SVars) of
  	      true ->
  		  case lists:subtract(SVars, MacroParNames) of
  		      [] ->{true, Subst};
  		      Res ->
  			  ResSubst = lists:filter(fun({E1,_E2}) -> 
  							  lists:member(E1, Res) 
  						  end, Subst),
  			  case lists:all(fun({E1,E2}) ->
  						 list_to_atom(refac_prettypr:format(E2)) == E1
  					 end, ResSubst) of 
  			      true -> {true, Subst};
  			      _ -> false
  			  end			  
  		  end;
  	      _ -> false
  	  end
      end.
  
  
negative.code: %% Distel seems turn {wrapper, nil, ...} into {wrapper, [], ...}
  %% We have to turn it back.
  transform(Node) ->
      ast_traverse_api:full_buTP(fun (T, _Others) ->
  				       case T of
  					 {wrapper, [], A, {[], B}} ->
  					     {wrapper, nil, A, {nil, B}};
  					 _ -> T
  				       end
  			       end, Node, {}).
  