anchor.diff:          [] ->
               ParseState3;
           NewUnknownTypes ->
  -            collect_unknown_type_infos(NewUnknownTypes, ParseState3)
  +            collect_unknown_type_infos(NewUnknownTypes, ParseState3, Counter - 1)
       end.
   
   -spec collect_type_info/3 :: (module(), atom(), #parse_state{}) -> #parse_state{}.
  
positive.code:         [] ->
              ParseState2;
          UnknownTypes ->
              collect_unknown_type_infos(UnknownTypes, ParseState2)
      end,
      case tester_parse_state:lookup_type({'fun', Module, Func, Arity}, ParseState3) of
          {value, _} ->
  
negative.code:             ?ct_fail("unknown function ~p:~p/~p~n", [Module, Func, Arity])
      end.
  
  -spec collect_unknown_type_infos/3 :: (list(type_name()), #parse_state{}, non_neg_integer()) -> #parse_state{}.
  collect_unknown_type_infos(UnknownTypes, ParseState, 0) ->
      ct:pal("warning still looking for unknown types: ~p~n", [tester_parse_state:get_unknown_types(ParseState)]),
      collect_unknown_type_infos(UnknownTypes, ParseState, 100);
  collect_unknown_type_infos(UnknownTypes, ParseState, Counter) ->
      ParseState2 = tester_parse_state:reset_unknown_types(ParseState),
      ParseState3 = lists:foldl(fun ({type, Module, TypeName}, InnerParseState) ->
                                          collect_type_info(Module, TypeName, InnerParseState)
  