anchor.diff:  	    case length(Cs) >1 of
   		true -> throw({error, "Inlining a function with multiple function clauses is not supported yet."});
   		false-> C = hd(Cs),
  -			_B = refac_syntax:clause_body(C),
  +			Body = refac_syntax:clause_body(C),
   			Ps = refac_syntax:clause_patterns(C),
   			G = refac_syntax:clause_guard(C),
   			case G of 
  
positive.code: 	_ ->{Node,false}
      end.
  	
  	    
      
  pos_to_fun_app(Node, Pos) ->
      case refac_util:once_tdTU(fun pos_to_fun_app_1/2, Node, Pos) of
  	{_, false} -> {error, "You have not selected a function application, "
  		       "or the function containing the function application does not parse."};
  	{R, true} -> {ok, R}
      end.
  
  pos_to_fun_app_1(Node, Pos) ->
  
negative.code: 	_ -> {Node, false}
      end.
      
  collect_exprs_in_expr_sequences(Tree) ->  
      Fun = fun (T, S) ->
  		  case refac_syntax:type(T) of
  		      clause ->
  			  S++refac_syntax:clause_body(T);
  		      block_expr ->
  			  S++ refac_syntax:block_expr_body(T);
  		      try_expr ->
  			  S++ refac_syntax:try_expr_body(T);
  		      _ -> S
  		  end
  	  end,
      refac_syntax_lib:fold(Fun, [], Tree).
  
  remove_begin_end(Node, BlockBody) ->
      Fun = fun(E) ->
  		  case refac_syntax:type(E) of
  		      block_expr ->
  			  case refac_syntax:block_expr_body(E) of
  			      BlockBody ->
  				  BlockBody;
  			      _ -> [E]
  			  end;
  		      _ -> [E]
  		  end
  	  end,
      case refac_syntax:type(Node) of
  	clause ->
  	    P = refac_syntax:clause_patterns(Node),
  	    G = refac_syntax:clause_guard(Node),
  	    B= refac_syntax:clause_body(Node),
  	    B1=lists:append([Fun(E)||E <-B]),
  	    {refac_util:rewrite(Node, refac_syntax:clause(P, G, B1)), 
  	     length(B) =/= length(B1)};
  	block_expr ->
  	    Es = refac_syntax:block_expr_body(Node),
  	    case Es of 
  		BlockBody ->
  		    {Node, false};
  		_ ->
  		    Es1 = lists:append([Fun(E)||E <-Es]),
  		    {refac_util:rewrite(Node, refac_syntax:block_expr(Es1)), 
  		     length(Es)=/=length(Es1)}
  	    end;
  	try_expr->
  	    B = refac_syntax:try_expr_body(Node),
  	    B1 = lists:append([Fun(E)||E <-B]),
  	    Cs = refac_syntax:try_expr_clauses(Node),
  	    Handlers = refac_syntax:try_expr_handlers(Node),
  	    After = refac_syntax:try_expr_after(Node),
  	    {refac_util:rewrite(Node, refac_syntax:try_expr(B, Cs, Handlers, After)),
  	     length(B)=/=length(B1)};
  	_ ->
  	    {Node, false}
      end.
      
  	     
  	    
  
  		    
  	    
      
  do_subst(Node, Subst) ->
      case refac_syntax:type(Node) of
  