anchor.diff:    [C1|Src1] = Src, % $< (product) or $( (arglist)
     [C2|RevSrc2] = lists:reverse(Src1),
     Src2 = lists:reverse(RevSrc2),
  -  exec(fun() ->
  -           Types = parse_types_and_literals(Src2),
  -           CommaInd = [$, | Ind],
  -           (indentation(?IND-1) ++
  -            [C1 | lists:join(CommaInd, [pp_type(Type) || Type <- Types])] ++
  -            [C2])
  -       end, Src).
  -
  --ifdef(DEBUG).
  -exec(F, R) ->
  -  try F() catch _:_ -> R end.
  --else.
  -exec(F, _) ->
  -  F().
  --endif.
  +  try
  +    Types = parse_types_and_literals(Src2),
  +    CommaInd = [$, | Ind],
  +    (indentation(?IND-1) ++
  +     [C1 | lists:join(CommaInd, [pp_type(Type) || Type <- Types])] ++
  +     [C2])
  +  catch
  +    _:_ -> Src
  +  end.
   
   indentation(I) ->
     [$\n | lists:duplicate(I, $\s)].
  
positive.code: sig(Src, false) ->
    Src;
  sig(Src, true) ->
    Str = lists:flatten(io_lib:format("-spec ~w:~tw~ts.", [a, b, Src])),
    {ok, Tokens, _EndLocation} = erl_scan:string(Str),
    exec(fun() ->
             {ok, {attribute, _, spec, {_MFA, Types}}} =
               erl_parse:parse_form(Tokens),
             indentation(?IND) ++ pp_spec(Types)
         end, Src).
  
  %% Argument(list)s are a mix of types and Erlang code. Note: sometimes
  %% (contract_range, call_without_opaque, opaque_type_test), the initial
  
negative.code: %% Functions that parse type strings, literal strings, and contract
  %% strings. Return strings formatted by erl_pp.
  
  %% Note we always have to catch any error when trying to parse
  %% the syntax because other BEAM languages may not emit an
  %% Erlang AST that transforms into valid Erlang Source Code.
  
  -define(IND, 10).
  
  