anchor.diff:  			       case refac_syntax:get_pos(P) of
   				 Pos ->
   				     [T] = refac_syntax:application_arguments(B),
  -				     refac_util:rewrite(Node, refac_syntax:match_expr(P, T));
  +				     refac_misc:rewrite(Node, refac_syntax:match_expr(P, T));
   				 _ -> Node
   			       end;
   			   _ -> Node
  
positive.code: 
  do_state_to_record_in_pats_2(P, RecordName, RecordFields, IsTuple) ->
      case refac_syntax:type(P) of
  	variable ->
  	    {P, [refac_syntax:get_pos(P)]};
  	tuple when IsTuple ->
  	    RecordExpr = tuple_to_record_expr(P, RecordName, RecordFields),
  	    {refac_util:rewrite(P, RecordExpr),[]};
  	match_expr ->
  	    tuple_to_record_in_match_expr_pattern(
  	      P, RecordName, RecordFields, IsTuple);
  	underscore ->
  	    {P, []};
  	_ when IsTuple ->
  	    Pos = refac_syntax:get_pos(P),
  	    throw({error, "Wrangler did not know how to transform the pattern at location: " 
  		   ++ io_lib:format("~p", [Pos])});
  	_ when length(RecordFields) == 1 ->
  	    Fields = [mk_record_field(hd(RecordFields), P)],
  	    P1 = refac_util:rewrite(P, mk_record_expr(RecordName, Fields)),
  	    {P1, []};
        _ ->
  	  Pos = refac_syntax:get_pos(P),
  	  throw({error, "Wrangler did not know how to transform the pattern at location: " 
  		 ++ io_lib:format("~p", [Pos])})
      end.
  
  tuple_to_record_in_match_expr_pattern(State, RecordName, RecordFields, IsTuple)->	   
      P=refac_syntax:match_expr_pattern(State),
      B = refac_syntax:match_expr_body(State),
      {P1, Pos1} =
  	do_state_to_record_in_pats_2(P, RecordName, RecordFields, IsTuple),
      {B1, Pos2} = 
  	do_state_to_record_in_pats_2(B, RecordName, RecordFields, IsTuple),
      {refac_util:rewrite(State, refac_syntax:match_expr(P1,B1)), Pos1++Pos2}.
  
  
  do_state_to_record_in_callback_fun_clause_body(Body, RecordName, RecordFields,
  
negative.code: 	    _ ->
  		{Form2, _} = ast_traverse_api:stop_tdTP(fun wrap_run_commands_result/2, Form1,
  							{RecordName, RecordFields, Res, IsTuple,
  							 refac_misc:collect_var_names(Form1), SM}),
  		Form2
  	  end
      end.
  
  check_use_of_run_commands(Form, SM) ->
      Fun = fun (Node, {Acc1, Acc2}) ->
  		  case refac_syntax:type(Node) of
  		    match_expr ->
  			P = refac_syntax:match_expr_pattern(Node),
  			B = refac_syntax:match_expr_body(Node),
  			case is_app(B, {SM, run_commands, 2}) orelse
  			       is_app(B, {SM, run_commands, 3})
  			    of
  			  true ->
  			      case refac_syntax:type(P) of
  				tuple ->
  				    Es = refac_syntax:tuple_elements(P),
  				    case Es of
  				      [_H, S, _Res] ->
  					  case refac_syntax:type(S) of
  					    variable ->
  						case refac_misc:get_free_vars(S) of
  						  [] ->
  						      {[refac_syntax:get_pos(S)| Acc1],
  						       [refac_syntax:get_pos(B)| Acc2]};
  						  _ ->
  						      {[refac_syntax:get_pos(B)| Acc1], Acc2}
  						end;
  					    _ -> {[refac_syntax:get_pos(B)| Acc1], Acc2}
  					  end;
  				      _ -> {[refac_syntax:get_pos(B)| Acc1], Acc2}
  				    end;
  				_ -> {[refac_syntax:get_pos(B)| Acc1], Acc2}
  			      end;
  			  _ -> {Acc1, Acc2}
  			end;
  		    application -> case is_app(Node, {SM, run_commands, 2}) orelse
  					  is_app(Node, {SM, run_commands, 3})
  				       of
  				     true ->
  					 Pos = refac_syntax:get_pos(Node),
  					 case lists:member(Pos, Acc2) of
  					   true -> {Acc1, Acc2};
  					   false ->
  					       {[Pos| Acc1], Acc2}
  					 end;
  				     false ->
  					 {Acc1, Acc2}
  				   end;
  		    _ -> {Acc1, Acc2}
  		  end
  	  end,
      {Acc1, Acc2} = refac_syntax_lib:fold(Fun, {[], []}, Form),
      lists:usort(Acc1) -- lists:usort(Acc2).
     
      
  