anchor.diff:          {{x,c,1},
            [{['$1'],[{'==',['$1','$1'],{'++',['$1'],['$1']}}],[]}],
            [local]}})).
  +t49_test() ->
  +  ?assert(
  +     unit(
  +       {"x:c(Aw)hen [A,A] == [A]++[A]",
  +        syntax_error})).
   
   unit({Str,MS}) ->
  -  try MS = transform(Str),true
  -  catch _:{MS,_} -> Str,true
  +  try
  +    MS = transform(Str),true
  +  catch
  +    _:{MS,_}     -> Str,true
     end.
  
positive.code: %% returns {{Module,Function,Arity},[{Head,Cond,Body}],[Flag]}
  %% i.e. the args to erlang:trace_pattern/3
  
  compile({M,OF,As,Gs,Actions}) ->
    {F,A,Flags} = chk_fa(OF,As),
    {Vars,Args} = compile_args(As),
    {{M,F,A}, [{Args,compile_guards(Gs,Vars),compile_acts(Actions)}], Flags}.
  
  chk_fa(' ',_) -> {'_','_',[global]};
  chk_fa('_',_) -> {'_','_',[local]};
  chk_fa(F,'_') -> {F,'_',[local]};
  chk_fa(F,As)  -> {F,length(As),[local]}.
  
  compile_acts(As) ->
    [ac_fun(A)|| A <- As].
  
  ac_fun("stack") -> {message,{process_dump}};
  ac_fun("return")-> {exception_trace};
  ac_fun(X)       -> exit({unknown_action,X}).
  
  compile_guards(Gs,Vars) ->
    {Vars,O} = lists:foldr(fun gd_fun/2,{Vars,[]},Gs),
  
negative.code:         {ok,[{op,1,'/',{remote,1,{atom,1,M},{atom,1,F}},{integer,1,Ari}}]} ->
            {M,F,lists:duplicate(Ari,{var,'_'})}; % m:f/2
          {ok,[{call,1,{remote,1,{atom,1,M},{atom,1,F}},Args}]} ->
            {M,F,[arg(A) || A<-Args]};            % m:f(...)
          {ok,[{call,1,{remote,1,{atom,1,M},{var,1,'_'}},Args}]} ->
            {M,' ',[arg(A) || A<-Args]};          % m:_(...)
          {ok,[{call,1,{remote,1,{atom,1,M},{var,1,_}},Args}]} ->
            {M,' ',[arg(A) || A<-Args]};          % m:V(...)
          {ok,[{remote,1,{atom,1,M},{atom,1,F}}]} ->
            {M,F,'_'};                            % m:f
          {ok,[{remote,1,{atom,1,M},{var,1,'_'}}]} ->
            {M,' ','_'};                          % m:_
          {ok,[{remote,1,{atom,1,M},{var,1,_}}]} ->
            {M,' ','_'};                          % m:V
          {ok,[{atom,1,M}]} ->
            {M,'_','_'};                          % m
          {ok,C} ->
            exit({this_is_too_confusing,C})
       end
  