anchor.diff:  		case refac_syntax:type(T) of 
   		    match_expr ->  %% TO THINK: assume only match expressions export variables, is this correct?
   			case refac_util:once_tdTU(F1, T, []) of 
  -			    {_, true} -> S++refac_util:get_var_exports(T);
  +			    {_, true} -> 
  +				S++refac_util:get_var_exports(T);
   			    _ -> S
   			end;
   		    _ -> S
  
positive.code:     FunClauses = refac_syntax:function_clauses(FunDef),
      NewFunClauses = lists:map(fun(Cs) ->
  			    process_a_clause(AnnAST, ModName,Cs, Expr) end, FunClauses),
      NewFunDef = refac_syntax:function(FunName, NewFunClauses),
      sliced_funs ! {add, {{ModName, FunName1, Arity}, NewFunDef}},
      case returns_undefined(NewFunDef) of 
  	true ->    %% None of the variables depending on the selected expression is exported.
  	    get_all_sliced_funs();
  	false -> CallerFuns = get_caller_funs(Files, {ModName, FunName1, Arity}),
  		 F = fun(T,Acc) -> case refac_syntax:type(T) of 
  				       application ->
  					   Op = refac_syntax:application_operator(T),
  					   Ann = refac_syntax:get_ann(Op),
  					   case lists:keysearch(fun_def,1, Ann) of
  					       {value, {fun_def, {ModName, FunName1, Arity, _, _}}} ->
  						   [T|Acc];
  					       _ ->  Acc
  					   end;
  				       _ -> Acc
  				   end
  		     end,	 
  		 case CallerFuns of 
  		     [] -> get_all_sliced_funs();
  		     _ ->  SliceCriterion = lists:flatmap(fun(FunDef1) -> AppExprs = refac_syntax_lib:fold(F, [], FunDef1),
  								     lists:map(fun(E) -> {FunDef1, E} end, AppExprs)
  						      end, CallerFuns),
  			   lists:flatmap(fun(SC) ->forward_slice_1(Files, AnnAST, ModName,SC) end, SliceCriterion)
  		 end		 
      end.
  
  returns_undefined(FunDef) ->
  
negative.code: 					    {[], []}, Body),
      case FreeVarsInBody of 
  	[] ->
  	    [refac_syntax:block_expr(Body)];
  	_ -> 
  	    SlicePoints = collect_app_sites(AnnAST, ModName, FunName, Arity),
  	    case SlicePoints of 
  		[] -> [refac_syntax:block_expr(Body)]; %% could not find any use sites of this function.
  		_ -> Slices = lists:map(fun({Fun, S}) ->
  						lists:flatmap(fun(E) -> backward_slice(Files, AnnAST, ModName, Fun, E) end, S)
  					end,  SlicePoints),
  		     FunExpr = refac_syntax:fun_expr([C]),
  		     Result = lists:map(fun(S) ->refac_syntax:application(FunExpr, S) end, Slices),
  		     Result       
  	    end
      end. 
  		 
  	    
  collect_app_sites(AnnAST, ModName, FunName, Arity) ->    
      HandleSpecialFuns=fun(Args) ->
  			      Args1 = list_to_tuple(lists:reverse(Args)),
  			      A = element(1, Args1),
  			      F = element(2, Args1),
  			      M = element(3, Args1),
  			      case {refac_syntax:type(M), refac_syntax:type(F), refac_syntax:type(A)} of 
  				  {atom, atom, list} ->
  				      case {refac_syntax:atom_value(M), refac_syntax:atom_value(F), refac_syntax:list_length(A)} of 
  					  {ModName, FunName, Arity} -> [refac_syntax:list_elements(A)];
  					  _ -> []
  				      end;
  				  _ -> []
  			      end
  		      end,
       F1 = fun(T,Acc) ->
  		case refac_syntax:type(T) of 
  		    application ->
  			Op = refac_syntax:application_operator(T),
  			Args = refac_syntax:application_arguments(T),
  			Ann = refac_syntax:get_ann(Op),
  			case lists:keysearch(fun_def,1, Ann) of
  			    {value, {fun_def, {M, F, A, _, _}}} ->
  				case {M, F, A} of 
  				    {ModName, FunName, Arity} ->
  					case Args of 
  					    [] -> Acc;
  					    _ -> Acc ++ [Args]  
  					end;
  				    {erlang, apply, 3} -> HandleSpecialFuns(Args)++Acc;
  				    {erlang, spawn, 3} -> HandleSpecialFuns(Args)++Acc;
  				    {erlang, spawn, 4} -> HandleSpecialFuns(Args)++Acc;
  				    {erlang, spawn_link, 3} -> HandleSpecialFuns(Args)++Acc;
  				    {erlang, spawn_link, 4} -> HandleSpecialFuns(Args)++Acc;
  				    _ -> Acc
  				end;
  			    _ -> Acc			
  			end;
  		    _ -> Acc
  		end
  	 end,				
      F = fun(T, Acc) ->
  		case refac_syntax:type(T) of 
  		    function ->
  