system records expanded types from declarations

[Nikodemus Siivola]

  CL-USER> (deftype foo () `(integer 0 12938))
  FOO
  CL-USER> (declaim (ftype (function (foo) *) bar))
  ; no value
  CL-USER> (defun bar (x) x)
  BAR
  CL-USER> (describe 'bar)
  COMMON-LISP-USER::BAR
    [symbol]

  BAR names a compiled function:
    Lambda-list: (X)
    Declared type: (FUNCTION ((MOD 12939)) *)
    Derived type: (FUNCTION ((MOD 12939)) (VALUES (MOD 12939) &OPTIONAL))
    Source form:
      (SB-INT:NAMED-LAMBDA BAR
          (X)
        (BLOCK BAR X))

...whereas

  Declared type: (FUNCTION (FOO) *)

would seem preferable.

[Nikodemus Siivola (nikodemus)]

Same applies to variables, etc.

We currently record the parsed type into globaldb. Possibly we should either record both, or make type objects able to carry the unparsed form with them.

[Nikodemus Siivola (nikodemus)]

Note also:

CL-USER> (deftype xtype () `(member :x))
XTYPE
CL-USER> (declaim (xtype *x*))
; No value
CL-USER> (deftype xtype () `(member :x 'x))
XTYPE
CL-USER> (defvar *x*)
*X*
CL-USER> (describe '*x*)
COMMON-LISP-USER::*X*
  [symbol]

*X* names a special variable:
  Declared type: (MEMBER :X)
  Currently unbound.

[Douglas Katzman (dougk)]

forcing CTYPEs to carry their unparsed form would pessimize all the type operators, notably TYPE=, since there would multiple spellings of the same CTYPE, which is precisely the thing that the caching and interning of types is designed to avoid.
We most definitely don't want that.
I have some ideas about this, I'll probably work on it.