anchor.diff:  %
   % This is parsed as a function call but is properly disambiguated to a method
   % call in this method.
  -transform({fun_call, Line, Var, Args }, V, S) ->
  +transform({fun_call, Line, Var, Args }, F, V, S) ->
     case Var of
       { identifier, _, Name } -> Method = not lists:member(Name, V);
       Name -> Method = false
     end,
   
     case Method of
  -    true -> transform({local_call, Line, Name, Args}, V, S);
  +    true -> transform({local_call, Line, Name, Args}, F, V, S);
       false ->
  -      { TArgs, VA } = transform_tree(Args, V, S),
  -      { TVar, VV }  = transform(Var, V, S),
  +      { TArgs, VA } = transform_tree(Args, F, V, S),
  +      { TVar, VV }  = transform(Var, F, V, S),
         { {call, Line, TVar, TArgs}, umerge3(V, VA, VV) }
     end;
   
  
positive.code: % Variables declared in args do affect the exprs and should be taken
  % into account. Clauses do not return variables list as second argument
  % because variables in one clause should not affect the other.
  transform({clause, Line, Args, Guards, Exprs}, V, S) ->
    { Var, Def, Mod } = S,
    { TArgs, V1 } = transform_tree(Args, V, { true, Def, Mod }),
    { TExprs, _ } = transform_tree(Exprs, umerge(V, V1), S),
    { clause, Line, TArgs, Guards, TExprs };
  
  % Handles erlang function calls in the following format:
  
negative.code: %
  % Each expression in the list can contain a match expression.
  % Variables defined inside these expressions needs to be added to the var list.
  transform({list, Line, Exprs, Tail }, F, V, S) ->
    Transformer = fun (X, Acc) -> transform(X, F, Acc, S) end,
    { TTail, TV }  = transform(Tail, F, V, S),
    { TExprs, VE } = build_list(Transformer, Exprs, Line, TV, TTail),
    { TExprs, VE };
  
  