remove compile-time-environment

* module/ice-9/boot-9.scm (guile-user): Move the `compile' autoload to
  the guile-user module. Remove reference to compile-time-environment.

* module/language/scheme/compile-ghil.scm:
* module/language/tree-il/compile-glil.scm:
* module/language/tree-il/optimize.scm:
* module/system/base/compile.scm:
* test-suite/tests/compiler.test: Remove definition of and references to
  compile-time-environment. While I do think that recompilation based on
  a lexical environment can be useful, I think it needs to be implemented
  differently. So for now we've lost nothing if we take it away, as it
  doesn't work with syncase anyway.

module/ice-9/boot-9.scm

@@ -3007,19 +3007,6 @@ module '(ice-9 q) '(make-q q-length))}."
 
 (define load load-module)
 
-
-
-;;; {Compiler interface}
-;;;
-;;; The full compiler interface can be found in (system). Here we put a
-;;; few useful procedures into the global namespace.
-
-(module-autoload! the-scm-module
-                  '(system base compile)
-                  '(compile
-                    compile-time-environment))
-
-
 
 
 ;;; {Parameters}
@@ -3448,6 +3435,7 @@ module '(ice-9 q) '(make-q q-length))}."
 ;; 		 (module-eval-closure (current-module))))
 ;;     (deannotate/source-properties (sc-expand (annotate exp)))))
 
-(define-module (guile-user))
+(define-module (guile-user)
+  #:autoload (system base compile) (compile))
 
 ;;; boot-9.scm ends here

module/language/scheme/compile-ghil.scm

@@ -414,16 +414,6 @@
   (,args
    (-> (values (map retrans args)))))
 
-(define-scheme-translator compile-time-environment
-  ;; (compile-time-environment)
-  ;; => (MODULE LEXICALS . EXTERNALS)
-  (()
-   (-> (inline 'cons
-               (list (retrans '(current-module))
-                     (-> (inline 'cons
-                                 (list (-> (reified-env))
-                                       (-> (inline 'externals '()))))))))))
-
 (define (lookup-apply-transformer proc)
   (cond ((eq? proc values)
          (lambda (e l args)

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

@@ -31,7 +31,6 @@
 ;;; TODO:
 ;;
 ;; call-with-values -> mv-bind
-;; compile-time-environment
 ;; basic degenerate-case reduction
 
 ;; allocation:

module/language/tree-il/optimize.scm

@@ -46,7 +46,6 @@
     call-with-values @call-with-values
     call-with-current-continuation @call-with-current-continuation
     values
-    ;; compile-time-environment
     eq? eqv? equal?
     = < > <= >= zero?
     + * - / 1- 1+ quotient remainder modulo

module/system/base/compile.scm

@@ -29,7 +29,7 @@
   #:export (syntax-error 
             *current-language*
             compiled-file-name compile-file compile-and-load
-            compile compile-time-environment
+            compile
             decompile)
   #:export-syntax (call-with-compile-error-catch))
 
@@ -152,13 +152,6 @@
         (receive (x e new-cenv) ((car passes) x e opts)
           (lp (cdr passes) x e (if first? new-cenv cenv) #f)))))
 
-(define (compile-time-environment)
-  "A special function known to the compiler that, when compiled, will
-return a representation of the lexical environment in place at compile
-time. Useful for supporting some forms of dynamic compilation. Returns
-#f if called from the interpreter."
-  #f)
-
 (define (find-language-joint from to)
   (let lp ((in (reverse (or (lookup-compilation-order from to)
                             (error "no way to compile" from "to" to))))

test-suite/tests/compiler.test

@@ -18,45 +18,10 @@
 (define-module (test-suite tests compiler)
   :use-module (test-suite lib)
   :use-module (test-suite guile-test)
-  :use-module (system vm program))
+  :use-module (system base compile))
   
 
-(with-test-prefix "environments"
+(with-test-prefix "basic"
 
-  (pass-if "compile-time-environment in evaluator"
+  (pass-if "compile to value"
-    (eq? (primitive-eval '(compile-time-environment)) #f))
+    (equal? (compile 1) 1)))
-
-  (pass-if "compile-time-environment in compiler"
-    (equal? (compile '(compile-time-environment))
-            (cons (current-module)
-                  (cons '() '()))))
-
-  (let ((env (compile
-              '(let ((x 0)) (set! x 1) (compile-time-environment)))))
-    (pass-if "compile-time-environment in compiler, heap-allocated var"
-             (equal? env
-                     (cons (current-module)
-                           (cons '((x . 0)) '(1)))))
-
-    ;; fixme: compiling with #t or module
-    (pass-if "recompiling with environment"
-             (equal? ((compile '(lambda () x) #:env env))
-                     1))
-
-    (pass-if "recompiling with environment/2"
-             (equal? ((compile '(lambda () (set! x (1+ x)) x) #:env env))
-                     2))
-
-    (pass-if "recompiling with environment/3"
-             (equal? ((compile '(lambda () x) #:env env))
-                     2))
-    )
-
-  (pass-if "compile environment is #f"
-           (equal? ((compile '(lambda () 10)))
-                   10))
-
-  (pass-if "compile environment is a module"
-           (equal? ((compile '(lambda () 10) #:env (current-module)))
-                   10))
-  )