anchor.diff:  %%     {{ann_type, [Left, Right]}, ParseState};
   parse_type(TypeSpec, Module, ParseState) ->
       ct:pal("unknown type ~p in module ~p~n", [TypeSpec, Module]),
  +    throw(unkown_type),
       {unkown, ParseState}.
   
   -spec parse_type_list/3 :: (list(type_spec()), module(), tester_parse_state:state()) ->
  
positive.code:     tester_value_collector:parse_expression(FunCode, ParseState);
  parse_chunk({eof, _Line}, _Module, ParseState) ->
      ParseState.
  
  -spec parse_type/3 :: (any(), module(), tester_parse_state:state()) ->
      {type_spec() , tester_parse_state:state()}.
  
negative.code:     tester_parse_state:state().
  parse_chunk({attribute, _Line, type, {{record, TypeName}, ATypeSpec, List}},
              Module, ParseState) ->
      {TheTypeSpec, NewParseState} = parse_type_log(ATypeSpec, Module, ParseState,
                                                    {record_type_attribute, TypeName}),
      tester_parse_state:add_type_spec({record, Module, TypeName}, TheTypeSpec, List,
                                       NewParseState);
  parse_chunk({attribute, _Line, type, {TypeName, ATypeSpec, List}},
              Module, ParseState) ->
      {TheTypeSpec, NewParseState} = parse_type_log(ATypeSpec, Module, ParseState,
                                                    {type_attribute, TypeName}),
      tester_parse_state:add_type_spec({type, Module, TypeName, length(List)}, TheTypeSpec, List,
                                       NewParseState);
  parse_chunk({attribute, _Line, opaque, {TypeName, ATypeSpec, List}},
              Module, ParseState) ->
      {TheTypeSpec, NewParseState} = parse_type_log(ATypeSpec, Module, ParseState,
                                                    {opaque_type_attribute, TypeName}),
      tester_parse_state:add_type_spec({type, Module, TypeName, length(List)}, TheTypeSpec, List,
                                       NewParseState);
  parse_chunk({attribute, _Line, 'spec', {{FunName, FunArity}, AFunSpec}},
  