anchor.diff:  
   % Represents a method call. The arguments need to be packed into
   % an array before sending it to dispatch (which has fixed arity).
  -transform({method_call, Line, Name, Args, Expr}, F, S) ->
  -  TransformedArgs = transform({list, Line, Args}, F, S),
  -  ?ELIXIR_WRAP_CALL(Line, elixir_dispatch, dispatch, [transform(Expr, F, S), {atom, Line, Name}, TransformedArgs]);
  +transform({method_call, Line, Name, Args, Expr}, V, S) ->
  +  { TArgs, _ } = transform({list, Line, Args}, V, S),
  +  { TExpr, _ } = transform(Expr, V, S),
  +  { ?ELIXIR_WRAP_CALL(Line, elixir_dispatch, dispatch, [TExpr, {atom, Line, Name}, TArgs]), V };
   
  -transform({constant, Line, Name}, F, S) ->
  -  ?ELIXIR_WRAP_CALL(Line, elixir_constants, lookup, [{atom, Line, Name}]);
  +transform({constant, Line, Name}, V, S) ->
  +  { ?ELIXIR_WRAP_CALL(Line, elixir_constants, lookup, [{atom, Line, Name}]), V };
   
  -transform({fun_call, Line, Vars, Args }, F, S) ->
  -  {call, Line, Vars, [transform(Arg, F, S) || Arg <- Args]};
  +transform({fun_call, Line, Var, Args }, V, S) ->
  +  { TArgs, _ } = transform_tree(Args, V, S),
  +  { TVar, _ }  = transform(Var, V, S),
  +  { {call, Line, TVar, TArgs}, V };
   
  -transform({match, Line, Left, Right}, F, S) ->
  -  {match, Line, transform(Left, F, S), transform(Right, F, S)};
  +transform({match, Line, Left, Right}, V, S) ->
  +  { TLeft, _ } = transform(Left, V, S),
  +  { TRight, _ } = transform(Right, V, S),
  +  { {match, Line, TLeft, TRight }, V };
   
  -transform({tuple, Line, Exprs }, F, S) ->
  -  {tuple, Line, [transform(Expr, F, S) || Expr <- Exprs]};
  +transform({tuple, Line, Exprs }, V, S) ->
  +  { TExprs, _ } = transform_tree(Exprs, V, S),
  +  { {tuple, Line, TExprs}, V };
   
  -transform({list, Line, Exprs }, F, S) ->
  -  Transform = fun(X, Acc) -> {cons, Line, transform(X, F, S), Acc} end,
  -  lists:foldr(Transform, {nil, Line}, Exprs);
  +transform({list, Line, Exprs }, V, S) ->
  +  { TExprs, _ } = transform_tree(Exprs, V, S),
  +  Transform = fun(Expr, Acc) -> {cons, Line, Expr, Acc} end,
  +  { lists:foldr(Transform, {nil, Line}, TExprs), V };
   
  -transform({binary_op, Line, Op, Left, Right}, F, S) ->
  -  Args = { cons, Line, transform(Right, F, S), {nil, Line} },
  -  ?ELIXIR_WRAP_CALL(Line, elixir_dispatch, dispatch, [transform(Left, F, S), {atom, Line, Op}, Args]);
  +transform({binary_op, Line, Op, Left, Right}, V, S) ->
  +  { TLeft, _ } = transform(Left, V, S),
  +  { TRight, _ } = transform(Right, V, S),
  +  Args = { cons, Line, TRight, {nil, Line} },
  +  { ?ELIXIR_WRAP_CALL(Line, elixir_dispatch, dispatch, [TLeft, {atom, Line, Op}, Args]), V };
   
  -transform({unary_op, Line, Op, Right}, F, S) ->
  -  {op, Line, Op, transform(Right, F, S)};
  +transform({unary_op, Line, Op, Right}, V, S) ->
  +  { TRight, _ } = transform(Right, V, S),
  +  { { op, Line, Op, TRight }, V };
   
  -transform({'fun', Line, Clauses}, F, S) ->
  -  {'fun', Line, transform(Clauses, F, S)};
  +transform({'fun', Line, Clauses}, V, S) ->
  +  { TClauses, _ } = transform(Clauses, V, S),
  +  { { 'fun', Line, TClauses }, V };
   
  -transform({clauses, Clauses}, F, S) ->
  -  {clauses, [transform(Clause, F, S) || Clause <- Clauses]};
  +% Clauses do not use transform_subtree because variables in one
  +% clause do not affect the other.
  +transform({clauses, Clauses}, V, S) ->
  +  TClauses = [element(1, transform(Clause, V, S)) || Clause <- Clauses],
  +  { { clauses, TClauses }, V };
   
  -transform({clause, Line, Args, Guards, Exprs}, F, S) ->
  -  {clause, Line, [transform(Arg, F, S) || Arg <- Args], Guards, [transform(Expr, F, S) || Expr <- Exprs]};
  +transform({clause, Line, Args, Guards, Exprs}, V, S) ->
  +  { TArgs, _  } = transform_tree(Args, V, S),
  +  { TExprs, _ } = transform_tree(Exprs, V, S),
  +  { { clause, Line, TArgs, Guards, TExprs }, V };
   
  -transform({object, Line, Name, Exprs}, F, S) ->
  +transform({object, Line, Name, Exprs}, V, S) ->
     Scope = elixir_module:scope_for(S, Name),
  -  Body = [transform(Expr, F, Scope) || Expr <- Exprs],
  -  elixir_module:transform(object, Line, Scope, Body);
  +  { TExprs, _ } = transform_tree(Exprs, V, Scope),
  +  { elixir_module:transform(object, Line, Scope, TExprs), V };
   
  -transform({module, Line, Name, Exprs}, F, S) ->
  +transform({module, Line, Name, Exprs}, V, S) ->
     Scope = elixir_module:scope_for(S, Name),
  -  Body = [transform(Expr, F, Scope) || Expr <- Exprs],
  -  elixir_module:transform(module, Line, Scope, Body);
  +  { TExprs, _ } = transform_tree(Exprs, V, Scope),
  +  { elixir_module:transform(module, Line, Scope, TExprs), V };
   
  -transform({erlang_call, Line, Prefix, Suffix, Args}, F, S) ->
  -  ?ELIXIR_WRAP_CALL(Line, transform(Prefix, F, S), transform(Suffix, F, S), [transform(Arg, F, S) || Arg <- Args]);
  -
  -transform({const_assign, Line, Left, Right}, F, S) ->
  -  ?ELIXIR_WRAP_CALL(Line, elixir_constants, store, [{atom, Line, Left}, transform(Right, F, S)]);
  +transform({erlang_call, Line, Prefix, Suffix, Args}, V, S) ->
  +  { TPrefix, _ } = transform(Prefix, V, S),
  +  { TSuffix, _ } = transform(Suffix, V, S),
  +  { TArgs, _ }   = transform_tree(Args, V, S),
  +  { ?ELIXIR_WRAP_CALL(Line, TPrefix, TSuffix, TArgs), V };
   
   % TODO This cannot be tested yet, because in theory the parser will
   % never allow us to have this behavior. In any case, we will need
  
positive.code: parse(String) ->
  	{ok, Tokens, _} = elixir_lexer:string(String),
  	{ok, Forms} = elixir_parser:parse(Tokens),
    Transform = fun(X, Acc) -> [transform(X, [], [])|Acc] end,
    lists:foldr(Transform, [], Forms).
  
  % TODO transformations should contain the filename
  
  
negative.code: % Method definitions are never executed by Elixir runtime. Their
  % abstract form is stored into an ETS table and is just added to
  % an Erlang module when they are compiled.
  transform({method, Line, Name, Arity, Clauses}, V, S) ->
    { TClauses, _ } = mapfoldl_tree(Clauses, fun pack_method_clause/3, V, S),
    Method = {function, Line, Name, Arity + 1, TClauses},
    { elixir_module:wrap_method_definition(S, Line, Method), V };
  
  % Match all other expressions.
  transform(Expr, V, S) -> { Expr, V }.
  
  % Pack method clause in a format that receives Elixir metadata
  % as first argument (like self) and annotates __current__ with
  % the current module name (for super)
  pack_method_clause({clause, Line, Args, Guards, Exprs}, V, S) -> 
    transform({clause, Line, [{var, Line, self}|Args], Guards, Exprs}, V, S).