Class binding in the same compilation unit can't be used in type constructor

[shirok]

Precompiling the following code:

(define-class <foo> () ())

(define (foo x)
  (assume-type x (<?> <foo>))
  x)

raises an error:

*** ERROR: Can't use non-inlinable global variable `#<identifier #f#<foo>.e3ed6980>' in type constructor expression: (<?> <foo>)

However, if (define-class ...) is in a separate compilation unit, it works.

define-class creates an inlinable global binding. It can be that inlinability isn't handled correctly if the binding is in the transient module during compilation.

[shirok]

We need to insert inlinable binding into (cenv-module cenv) so that it will be visible from subsequent processing. Currently, it is only done when the inlinable bound value is a closure (pass1/mark-closure-inlinable).

The issue is that we can't use the same technique with classes. The bound value will be computed at runtime, but the lookup is done at the compile time. For inlinable closures, we use a dummy closure as the value---we only need to take procedure-inliner of the bound closure while compiling, so we create a dummy procedure and attach the inliner to it.

Currenctly the class is to be computed at runtime, so we don't have an object to insert into the (cenv-module cenv) to be available at the compile time. However, type constructor needs to compute types during compilation.

For the sake of type constructor computation, we don't really need a concrete class object, since we'll wrap it with a proxy type. So if we can figure out the expression in define-inline form will yield a class object, we may be able to insert a dummy class object in the compile-time module.

[shirok]

btw, the issue can be exhibited with a simpler expr in repl. This:

(begin (define-class <f> () ()) (define (f x) (assume-type f (<?> <f>))))

raises an error, while this:

(begin (define-inline (g x) (- x)) (define (f x) (g x)))

does not.

[shirok]

We could expand define-class and define-record-type into something like (define-inline (type-expr <type-info> <expr>)), where <expr> is the expression we currently use to create a class at runtime, and <type-info> is a type expression to be evaluated at compile time to give the compiler minimal information about the type. Then define-inline can bind the type info in the compiling module.

We cannot evaluate <expr> at compile-time, for it may contain references only available at runtime (e.g. init-value may call a procedure). But such info is not needed for the purpose of type expression.