anchor.diff:          _ ->
               throw({error, "Invalid new variable name."})
       end.
  +
  +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  +%%                                                                     %%
  +%%                       Testing                                       %% 
  +%%                                                                     %%
  +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  +test_refac_1(TestFun) ->
  +    apply(?MODULE, TestFun, [["c:/cygwin/home/hl/git_repos/test"], false]).
  +
  +test_refac_2(TestFun) ->
  +    case apply(?MODULE, TestFun, [["c:/cygwin/home/hl/git_repos/test"], true]) of
  +        [] -> [];
  +        [Refac] ->
  +            wrangler_io:format("Refac:\n~p\n", [Refac]);
  +        {Refac, {lazy_gen, Gen}} ->
  +            wrangler_io:format("Refac0:\n~p\n\n", [Refac]),
  +            test_refac_3({lazy_gen, Gen})
  +    end.
  +          
  +test_refac_3({lazy_gen, Gen}) ->  
  +    case Gen() of 
  +        {Refac, Gen1} ->
  +            wrangler_io:format("Refac1:\n~p\n", [Refac]),
  +            test_refac_3(Gen1);
  +        [Refac] ->
  +            wrangler_io:format("Refac2:\n~p\n", [Refac]);
  +        [] -> []
  +    end.
  
positive.code:         _ ->   
              ?FULL_TD_TU(
                 [?COLLECT(?T("V@"), 
                           {range, {File, [api_refac:start_end_loc(V@)]},?SPLICE(V@)},
                           api_refac:type(V@)==variable andalso
                           api_refac:bound_vars(V@)/=[] andalso 
                           case VarFilter of 
  
negative.code: 
   
  get_fun_arity(File, FA) ->
      get_fun_arity(File, FA, false).
  get_fun_arity(File, FA, Lazy) ->
      get_fun_arity(File, FA, Lazy, default).
  
  get_fun_arity(File, FA, false, Order) ->
      Funs = get_funs(File, Order),
      if is_function(FA) ->
              [{F,A}||{F,A}<-Funs, FA({F,A})];
         is_tuple(FA) ->
              normalise_fa(FA);
         true ->
              throw({error, "Invalid function-arity."})
      end;
  
  get_fun_arity({File, NextFileGen}, FA, true, Order) ->
      FAs = get_fun_arity(File, FA, true, Order),
      case FAs of
          [] ->
              case NextFileGen of 
                  {lazy_file_gen, FileGen} ->
                      case FileGen() of
                          [] -> [];
                          {File1, NextFileGen1}->
                              case File1 of 
                                  [] -> [];
                                  _ ->
                                      case FA of 
                                          {lazy_fa_gen, OriginFA, _} ->
                                              get_fun_arity({File1, NextFileGen1},OriginFA, true, Order);
                                          _ ->
                                              get_fun_arity({File1, NextFileGen1},FA, true, Order)
                                      end
                              end
                      end;
                  none -> []
              end;
          [{F, A}] ->
              case NextFileGen of 
                  {lazy_file_gen, FileGen} ->
                      case FileGen() of
                          [] ->  [];
                          {File1, NextFileGen1} ->
                              case File1 of 
                                  [] -> [{F,A}];
                                  _ ->
                                      {{File, F, A}, {File1, NextFileGen1}, FA}
                              end
                      end;
                  none -> [{F,A}]
              end;
          {{F,A}, {lazy_fa_gen, OriginFA, NextFAGen}} ->
              {{File, F,A}, {File, NextFileGen}, {lazy_fa_gen, OriginFA, NextFAGen}}
      end;
  get_fun_arity(_File, {lazy_fa_gen, _OriginFA, Gen}, true, _Order) ->
        Gen();
  get_fun_arity(File, FA, true, Order) ->
      Funs = get_funs(File, Order),
      if is_function(FA) ->
              get_next_fun_arity(Funs, FA);
         is_tuple(FA) ->
              normalise_fa(FA);
         true ->
              throw({error, "Invalid function-arity."})
      end.
  
  normalise_fa(F,A) -> normalise_fa({F,A}).
  
  normalise_fa({F, A}) ->
      F1 = case is_list(F) of
             true -> list_to_atom(F);
             _ -> F
           end,
      A1 = case is_list(A) of
             true -> list_to_integer(A);
             _ -> A
           end,
      [{F1, A1}].
  
  get_next_fun_arity([], _FA) -> [];
  get_next_fun_arity([{F,A}|Fs], FA)->
      case FA({F,A}) of
          true ->
              {{F,A}, {lazy_fa_gen, FA, fun() -> get_next_fun_arity(Fs, FA) end}};
          false ->
              get_next_fun_arity(Fs, FA)
      end.
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                         
    
  get_vars(File, FunName, Arity, VarFilter) ->
      ModName=list_to_atom(filename:basename(File, ".erl")),
      FunDef=api_refac:mfa_to_fun_def({ModName, FunName, Arity}, File),
  