fix @slot-ref / @slot-set! compilation

* module/language/tree-il/compile-glil.scm: Add primcall compilers for
  @slot-ref and @slot-set.

* module/language/tree-il/optimize.scm (add-interesting-primitive!): New
  export. Creates an association between a variable in the current module
  and a primitive name.

* module/oop/goops.scm: Rework compiler hooks to work with tree-il and
  not ghil.

module/language/tree-il/compile-glil.scm

@@ -32,7 +32,6 @@
 ;;
 ;; call-with-values -> mv-bind
 ;; compile-time-environment
-;; GOOPS' @slot-ref, @slot-set
 ;; basic degenerate-case reduction
 
 ;; allocation:
@@ -81,7 +80,9 @@
    ((null? . 1) . null?)
    ((list? . 1) . list?)
    (list . list)
-   (vector . vector)))
+   (vector . vector)
+   ((@slot-ref . 2) . slot-ref)
+   ((@slot-set! . 3) . slot-set)))
 
 (define (make-label) (gensym ":L"))
 

module/language/tree-il/optimize.scm

@@ -23,7 +23,7 @@
   #:use-module (system base syntax)
   #:use-module (language tree-il)
   #:use-module (language tree-il inline)
-  #:export (optimize!))
+  #:export (optimize! add-interesting-primitive!))
 
 (define (env-module e)
   (if e (car e) (current-module)))
@@ -65,12 +65,13 @@
     caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
     cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr))
 
-(define *interesting-primitive-vars*
+(define (add-interesting-primitive! name)
-  (let ((h (make-hash-table)))
+  (hashq-set! *interesting-primitive-vars*
-    (for-each (lambda (x)
+              (module-variable (current-module) name) name))
-                (hashq-set! h (module-variable the-root-module x) x))
+
-              *interesting-primitive-names*)
+(define *interesting-primitive-vars* (make-hash-table))
-    h))
+
+(for-each add-interesting-primitive! *interesting-primitive-names*)
 
 (define (resolve-primitives! x mod)
   (post-order!

module/oop/goops.scm

@@ -1061,31 +1061,10 @@
 ;; the idea is to compile the index into the procedure, for fastest
 ;; lookup. Also, @slot-ref and @slot-set! have their own bytecodes.
 
-;; separate expression so that we affect the expansion of the subsequent
-;; expression
 (eval-when (compile)
-  (use-modules ((language scheme compile-ghil) :select (define-scheme-translator))
+  (use-modules ((language tree-il optimize) :select (add-interesting-primitive!)))
-               ((language ghil) :select (make-ghil-inline make-ghil-call))
+  (add-interesting-primitive! '@slot-ref)
-               (system base pmatch)))
+  (add-interesting-primitive! '@slot-set!))
-
-(eval-when (compile)
-  ;; unfortunately, can't use define-inline because these are primitive
-  ;; syntaxen.
-  (define-scheme-translator @slot-ref
-    ((,obj ,index) (guard (integer? index)
-                          (>= index 0) (< index max-fixnum))
-     (make-ghil-inline #f #f 'slot-ref
-                       (list (retrans obj) (retrans index))))
-    (else
-     (make-ghil-call e l (retrans (car exp)) (map retrans (cdr exp)))))
-
-  (define-scheme-translator @slot-set!
-    ((,obj ,index ,val) (guard (integer? index)
-                               (>= index 0) (< index max-fixnum))
-     (make-ghil-inline #f #f 'slot-set
-                       (list (retrans obj) (retrans index) (retrans val))))
-    (else
-     (make-ghil-call e l (retrans (car exp)) (map retrans (cdr exp))))))
 
 (eval-when (eval load compile)
   (define num-standard-pre-cache 20))