anchor.diff:  -module(tester_collect_function_info).
   
   -author('schuett@zib.de').
  --vsn('$Id$').
  +-vsn('$Id$ ').
   
   -export([collect_fun_info/4]).
   
  
positive.code:              tester_parse_state:add_unknown_type(TypeModule, TypeName, ParseState)}
      end;
  % why is this here? function() is no official type
  parse_type({type, _Line, 'function', []}, _Module, ParseState) ->
      {{'function'}, ParseState};
  parse_type({type, _Line, 'fun', []}, _Module, ParseState) ->
      {{'function'}, ParseState};
  parse_type({type, _Line, record, [{atom, _Line2, TypeName}]}, Module, ParseState) ->
      {{record, Module, TypeName}, ParseState};
  parse_type({type, _Line, record, [{atom, _Line2, TypeName} | Fields]}, Module,
             ParseState) ->
      {RecordType, ParseState2} = parse_type_list(Fields, Module, ParseState),
      {{record, Module, TypeName, RecordType}, ParseState2};
  parse_type({typed_record_field, {record_field, _Line,
                                   {atom, _Line2, FieldName}}, Field}, Module,
             ParseState) ->
      {FieldType, ParseState2} = parse_type(Field, Module, ParseState),
      {{typed_record_field, FieldName, FieldType}, ParseState2};
  parse_type({typed_record_field, {record_field, _Line,
                                   {atom, _Line2, FieldName}, _Default}, Field},
             Module, ParseState) ->
      {FieldType, ParseState2} = parse_type(Field, Module, ParseState),
      {{typed_record_field, FieldName, FieldType}, ParseState2};
  parse_type({type, _, field_type, [{atom, _, FieldName}, Field]}, Module, ParseState) ->
      {FieldType, ParseState2} = parse_type(Field, Module, ParseState),
      {{field_type, FieldName, FieldType}, ParseState2};
  parse_type({record_field, _Line, {atom, _Line2, FieldName}}, _Module, ParseState) ->
      {{untyped_record_field, FieldName}, ParseState};
  parse_type({record_field, _Line, {atom, _Line2, FieldName}, _Default}, _Module,
             ParseState) ->
      {{untyped_record_field, FieldName}, ParseState};
  parse_type(TypeSpecs, Module, ParseState) when is_list(TypeSpecs) ->
      case hd(TypeSpecs) of
          {typed_record_field, _, _} ->
              {RecordType, ParseState2} = parse_type_list(TypeSpecs,
  
negative.code:             ct:pal("potentially unknown type2: ~p~n", [TypeSpecs]),
              unknown
      end;
  parse_type_({var, _Line, Atom}, _Module, ParseState) when is_atom(Atom) ->
      {{tuple, {typedef, tester, test_any}}, ParseState};
  parse_type_({type, _Line, constraint, _Constraint}, _Module, ParseState) ->
      {{constraint, nyi}, ParseState};
  parse_type_({type, _, bounded_fun, [FunType, ConstraintList]}, Module, ParseState) ->
      {InternalFunType, ParseState2} = parse_type(FunType, Module, ParseState),
      Foldl = fun (Constraint, {PartialConstraintList, ParseState2a}) ->
                      {InternalConstraint, ParseState2c} = parse_type(Constraint,
  