anchor.diff:  vann_list_comp_body_join(Ms, VI) ->
       fun (T, {Env, Bound, Free}) ->
   	    {T1, Bound1, Free1} = case refac_syntax:type(T) of
  -				      generator -> vann_generator(T, Env, Ms, VI);
  +				    generator -> vann_generator(T, Env, Ms, VI);
   				    _ ->
  -					  {T2, _, Free2} = vann(T, Env, Ms, VI),
  -					  {T2, [], Free2}
  +					{T2, _, Free2} = vann(T, Env, Ms, VI),
  +					{T2, [], Free2}
   				  end,
  -	    F=fun(V, Bs) -> lists:keysearch(V, 1,  Bs)==false end,
  -	    Env0 = ([{V, P}||{V,P}<-Env, F(V, Bound1)]),
  +	    F = fun (V, Bs) -> lists:keysearch(V, 1, Bs) == false end,
  +	    Env0 = [{V, P} || {V, P} <- Env, F(V, Bound1)],
   	    Env1 = ordsets:union(Env0, Bound1),
  -	    Bound2 = ordsets:from_list([{V, P}|| {V,P} <- Bound, F(V, ordsets:to_list(Bound1))]),
  +	    Bound2 = ordsets:from_list([{V, P} || {V, P} <- Bound, F(V, ordsets:to_list(Bound1))]),
   	    {T1, {Env1, ordsets:union(Bound2, Bound1),
   		  ordsets:union(Free, ordsets:subtract(Free1, Bound))}}
       end.
  
positive.code: cons_prop_match_expr(Tree) ->
      E = refac_syntax:match_expr_body(Tree),
      P = refac_syntax:match_expr_pattern(Tree),
      case refac_syntax:type(E)== atom orelse (refac_syntax:type(E)==list) of 
  	true ->
  	    case is_bound_var(P) of
  		true ->
  		    case lists:keysearch(def, 1, refac_syntax:get_ann(P)) of
  			{value, {def, DefPos}} ->
  			    add_value({DefPos, {atom_value_or_length(E), refac_syntax:get_pos(E)}}),
  			    P1 =refac_syntax:add_ann({value, {atom_value_or_length(E), refac_syntax:get_pos(E)}}, P),	    
  			    rewrite(Tree, refac_syntax:match_expr(P1, E));
  			false ->
  			    Tree
  		    end;			
  		_ -> Tree
  	    end;
  	false ->
  	    case refac_syntax:type(E) of
  		match_expr ->
  		    E1 = cons_prop_match_expr(E),
  		    P1 = refac_syntax:match_expr_pattern(E1),
  		    case lists:keysearch(value, 1, refac_syntax:get_ann(P1)) of
  			{value, {value,V}} ->
  			    P2 =refac_syntax:add_ann({value, V},P),
  			    rewrite(Tree, refac_syntax:match_expr(P2, E));
  			_ -> Tree
  		    end;
  		_ ->
  		    Tree
  	    end
      end.
  	
  
  
negative.code: 		end
  	end,
      fold(F, [], Tree).
  %% Adjust the locations of F and A in an implicit function application (fun F/A)
  %% to their actual occurrence locations. Originally, both of their locations refer
  %% to that of the keyword 'fun'.
  