anchor.diff:      tester_parse_state:state().
   parse_chunk({attribute, _Line, type, {{record, TypeName}, ATypeSpec, List}},
               Module, ParseState) ->
  -    {TheTypeSpec, NewParseState} = parse_type(ATypeSpec, 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(ATypeSpec, 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(ATypeSpec, 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}},
  
positive.code:                   _ ->
                        TheFunSpec
                end || TheFunSpec <- AFunSpec],
      {CleanFunSpec, NewParseState} = parse_type({union_fun, FunSpec}, Module, ParseState),
      tester_parse_state:add_type_spec({'fun', Module, FunName, FunArity},
                                       CleanFunSpec, [], NewParseState);
  parse_chunk({attribute, _Line, record, {TypeName, TypeList}}, Module, ParseState) ->
      {TheTypeSpec, NewParseState} = parse_type(TypeList, Module, ParseState),
      tester_parse_state:add_type_spec({record, Module, TypeName}, TheTypeSpec, [],
                                       NewParseState);
  parse_chunk({attribute, _Line, _AttributeName, _AttributeValue}, _Module,
  
negative.code: %%     {{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()) ->
  