anchor.diff:  				  refac_syntax:macro_arguments(Tree)
   				    of
   				  none -> {none, {[], []}};
  -				  As1 -> vann_patterns(As1, Env, Ms, VI)
  +				  As1 -> vann_patterns(As1, Env, Ms, VI, Pid)
   				end,
   	  N = refac_syntax:macro_name(Tree),
   	  Tree1 = rewrite(Tree, refac_syntax:macro(N, As)),
   	  {ann_bindings(Tree1, Env, Bound, Free), Bound, Free};
         _Type ->
  -	  F = vann_patterns_join(Env, Ms, VI),
  +	  F = vann_patterns_join(Env, Ms, VI, Pid),
   	  {Tree1, {Bound, Free}} = mapfold_subtrees(F, {[], []},
   						    Tree),
   	  {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}
       end.
   
  -vann_fun_expr_pattern(Tree, Env,Ms, VI) ->
  +vann_fun_expr_pattern(Tree, Env,Ms, VI, Pid) ->
       case refac_syntax:type(Tree) of
         variable ->
   	    V = refac_syntax:variable_name(Tree),
  
positive.code: 	_ -> false
      end.
  
  cons_prop_match_expr(Tree) ->
      E = refac_syntax:match_expr_body(Tree),
      P = refac_syntax:match_expr_pattern(Tree),
      case refac_syntax:is_literal(E) orelse refac_syntax:type(E)==list of 
  
negative.code: 	end,
     lists:map(fun(T) ->map(F, T) end, Body).
  	   
  vann_clause(C, Env, Ms, VI, Pid) ->
      init_env_process(Pid),
      {Ps, {Bound1, Free1}} =
  	vann_patterns(refac_syntax:clause_patterns(C), Env, Ms, VI, Pid),
      Env1 = ordsets:union(Env, Bound1),
      %% Guards cannot add bindings
      {G1, _, Free2} = case refac_syntax:clause_guard(C) of
  		       none -> {none, [], []};
  		       G -> vann(G, Env1, Ms, VI, Pid)
  		     end,
      {Es, {Bound2, Free3}} =
  	vann_body(refac_syntax:clause_body(C), Env1, Ms, VI, Pid),
      Bound = ordsets:union(Bound1, Bound2),
      Free = ordsets:union(Free1,
  			 ordsets:subtract(ordsets:union(Free2, Free3), Bound1)),
      Tree1 = rewrite(C, refac_syntax:clause(Ps, G1, Es)),
      {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
  
  vann_fun_expr_clause(C, Env, Ms, VI, Pid) ->
      {Ps, {Bound1, Free1}} =
  	vann_fun_expr_patterns(refac_syntax:clause_patterns(C),
  			       Env, Ms, VI, Pid),
      Env0 = [{V, P} || {V, P} <- Env, lists:keysearch(V, 1, Bound1) == false],
      Env1 = ordsets:union(Env0, Bound1),
      %% Guards cannot add bindings
      {G1, _, Free2} = case refac_syntax:clause_guard(C) of
  		       none -> {none, [], []};
  		       G -> vann(G, Env1, Ms, VI, Pid)
  		     end,
      {Es, {Bound2, Free3}} =
  	vann_body(refac_syntax:clause_body(C), Env1, Ms, VI, Pid),
      Bound = ordsets:union(Bound1, Bound2),
      Free = ordsets:union(Free1,
  			 ordsets:subtract(ordsets:union(Free2, Free3), Bound1)),
      Tree1 = rewrite(C, refac_syntax:clause(Ps, G1, Es)),
      {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
  
  vann_clauses_join(Env, Ms, VI, Pid) ->
      fun (C, {Bound, Free}) ->
  	    {C1, Bound1, Free1} = vann_clause(C, Env, Ms, VI, Pid),
   	    {C1,{ordsets:union(Bound, Bound1), ordsets:union(Free, Free1)}};
  	(C, false) ->
  	    {C1, Bound, Free} = vann_clause(C, Env,Ms, VI, Pid),
  	    {C1, {Bound, Free}}
      end.
  
  vann_fun_expr_clauses_join(Env, Ms, VI, Pid) ->
      fun (C, {Bound, Free}) ->
  	    {C1, Bound1, Free1} = vann_fun_expr_clause(C, Env, Ms, VI, Pid),
  	    {C1,
  	     {ordsets:intersection(Bound, Bound1),
  	      ordsets:union(Free, Free1)}};
  	(C, false) ->
  	    {C1, Bound, Free} = vann_fun_expr_clause(C, Env, Ms, VI, Pid),
  	    {C1, {Bound, Free}}
      end.
  
  vann_clauses(Cs, Env, Ms, VI, Pid) ->
      lists:mapfoldl(vann_clauses_join(Env, Ms, VI, Pid), false, Cs).
  
  vann_fun_expr_clauses(Cs, Env, Ms, VI, Pid) ->
      lists:mapfoldl(vann_fun_expr_clauses_join(Env, Ms, VI, Pid), false,
  		   Cs).
  
  ann_bindings(Tree, Env, Bound, Free) ->
  