X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fir1tran.lisp;h=b5ad3def4f3da8be5008002091d4dacc47067ed8;hb=c7638557b3c7b34267daba188d345f5d284f4ac3;hp=c4029446bce4cee76adc6a70be225864b3fa8b10;hpb=f392742d2781f42b3bb15b637e5008e10fbbe092;p=sbcl.git

diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp
index c402944..b5ad3de 100644
--- a/src/compiler/ir1tran.lisp
+++ b/src/compiler/ir1tran.lisp
@@ -18,12 +18,12 @@
 ;;; taken through the source to reach the form. This provides a way to
 ;;; keep track of the location of original source forms, even when
 ;;; macroexpansions and other arbitary permutations of the code
-;;; happen. This table is initialized by calling Find-Source-Paths on
+;;; happen. This table is initialized by calling FIND-SOURCE-PATHS on
 ;;; the original source.
 (declaim (hash-table *source-paths*))
 (defvar *source-paths*)
 
-;;; *CURRENT-COMPONENT* is the Component structure which we link
+;;; *CURRENT-COMPONENT* is the COMPONENT structure which we link
 ;;; blocks into as we generate them. This just serves to glue the
 ;;; emitted blocks together until local call analysis and flow graph
 ;;; canonicalization figure out what is really going on. We need to
@@ -33,86 +33,102 @@
 ;;; FIXME: It's confusing having one variable named *CURRENT-COMPONENT*
 ;;; and another named *COMPONENT-BEING-COMPILED*. (In CMU CL they
 ;;; were called *CURRENT-COMPONENT* and *COMPILE-COMPONENT* respectively,
-;;; which also confusing.)
+;;; which was also confusing.)
 (declaim (type (or component null) *current-component*))
 (defvar *current-component*)
 
 ;;; *CURRENT-PATH* is the source path of the form we are currently
 ;;; translating. See NODE-SOURCE-PATH in the NODE structure.
 (declaim (list *current-path*))
-(defvar *current-path* nil)
-
-;;; *CONVERTING-FOR-INTERPRETER* is true when we are creating IR1 to
-;;; be interpreted rather than compiled. This inhibits source
-;;; tranformations and stuff.
-(defvar *converting-for-interpreter* nil)
-;;; FIXME: Rename to *IR1-FOR-INTERPRETER-NOT-COMPILER-P*.
-
-;;; FIXME: This nastiness was one of my original motivations to start
-;;; hacking CMU CL. The non-ANSI behavior can be useful, but it should
-;;; be made not the default, and perhaps should be controlled by
-;;; DECLAIM instead of a variable like this. And whether or not this
-;;; kind of checking is on, declarations should be assertions to the
-;;; extent practical, and code which can't be compiled efficiently
-;;; while adhering to that principle should give warnings.
-(defvar *derive-function-types* t
-  #!+sb-doc
-  "(Caution: Soon, this might change its semantics somewhat, or even go away.)
-  If true, argument and result type information derived from compilation of
-  DEFUNs is used when compiling calls to that function. If false, only
-  information from FTYPE proclamations will be used.")
+(defvar *current-path*)
+
+(defvar *derive-function-types* nil
+  "Should the compiler assume that function types will never change,
+  so that it can use type information inferred from current definitions
+  to optimize code which uses those definitions? Setting this true
+  gives non-ANSI, early-CMU-CL behavior. It can be useful for improving
+  the efficiency of stable code.")
 
 ;;;; namespace management utilities
 
 ;;; Return a GLOBAL-VAR structure usable for referencing the global
 ;;; function NAME.
-(defun find-free-really-function (name)
+(defun find-free-really-fun (name)
   (unless (info :function :kind name)
     (setf (info :function :kind name) :function)
     (setf (info :function :where-from name) :assumed))
 
   (let ((where (info :function :where-from name)))
-    (when (eq where :assumed)
+    (when (and (eq where :assumed)
+	       ;; In the ordinary target Lisp, it's silly to report
+	       ;; undefinedness when the function is defined in the
+	       ;; running Lisp. But at cross-compile time, the current
+	       ;; definedness of a function is irrelevant to the
+	       ;; definedness at runtime, which is what matters.
+	       #-sb-xc-host (not (fboundp name)))
       (note-undefined-reference name :function))
     (make-global-var :kind :global-function
-		     :name name
+		     :%source-name name
 		     :type (if (or *derive-function-types*
 				   (eq where :declared))
 			       (info :function :type name)
 			       (specifier-type 'function))
 		     :where-from where)))
 
-;;; Return a SLOT-ACCESSOR structure usable for referencing the slot
-;;; accessor NAME. CLASS is the structure class.
-(defun find-structure-slot-accessor (class name)
-  (declare (type sb!xc:class class))
-  (let* ((info (layout-info
-		(or (info :type :compiler-layout (sb!xc:class-name class))
-		    (class-layout class))))
-	 (accessor (if (listp name) (cadr name) name))
-	 (slot (find accessor (dd-slots info) :key #'sb!kernel:dsd-accessor))
-	 (type (dd-name info))
-	 (slot-type (dsd-type slot)))
-    (assert slot () "Can't find slot ~S." type)
-    (make-slot-accessor
-     :name name
-     :type (specifier-type
-	    (if (listp name)
-		`(function (,slot-type ,type) ,slot-type)
-		`(function (,type) ,slot-type)))
-     :for class
-     :slot slot)))
-
-;;; If NAME is already entered in *FREE-FUNCTIONS*, then return the
-;;; value. Otherwise, make a new GLOBAL-VAR using information from the
-;;; global environment and enter it in *FREE-FUNCTIONS*. If NAME names
-;;; a macro or special form, then we error out using the supplied
-;;; context which indicates what we were trying to do that demanded a
-;;; function.
-(defun find-free-function (name context)
-  (declare (string context))
-  (declare (values global-var))
-  (or (gethash name *free-functions*)
+;;; Has the *FREE-FUNS* entry FREE-FUN become invalid?
+;;;
+;;; In CMU CL, the answer was implicitly always true, so this 
+;;; predicate didn't exist.
+;;;
+;;; This predicate was added to fix bug 138 in SBCL. In some obscure
+;;; circumstances, it was possible for a *FREE-FUNS* entry to contain a
+;;; DEFINED-FUN whose DEFINED-FUN-FUNCTIONAL object contained IR1
+;;; stuff (NODEs, BLOCKs...) referring to an already compiled (aka
+;;; "dead") component. When this IR1 stuff was reused in a new
+;;; component, under further obscure circumstances it could be used by
+;;; WITH-IR1-ENVIRONMENT-FROM-NODE to generate a binding for
+;;; *CURRENT-COMPONENT*. At that point things got all confused, since
+;;; IR1 conversion was sending code to a component which had already
+;;; been compiled and would never be compiled again.
+(defun invalid-free-fun-p (free-fun)
+  ;; There might be other reasons that *FREE-FUN* entries could
+  ;; become invalid, but the only one we've been bitten by so far
+  ;; (sbcl-0.pre7.118) is this one:
+  (and (defined-fun-p free-fun)
+       (let ((functional (defined-fun-functional free-fun)))
+	 (or (and functional
+		  (eql (functional-kind functional) :deleted))
+	     (and (lambda-p functional)
+		  (or
+		   ;; (The main reason for this first test is to bail
+		   ;; out early in cases where the LAMBDA-COMPONENT
+		   ;; call in the second test would fail because links
+		   ;; it needs are uninitialized or invalid.)
+		   ;;
+		   ;; If the BIND node for this LAMBDA is null, then
+		   ;; according to the slot comments, the LAMBDA has
+		   ;; been deleted or its call has been deleted. In
+		   ;; that case, it seems rather questionable to reuse
+		   ;; it, and certainly it shouldn't be necessary to
+		   ;; reuse it, so we cheerfully declare it invalid.
+		   (null (lambda-bind functional))
+		   ;; If this IR1 stuff belongs to a dead component,
+		   ;; then we can't reuse it without getting into
+		   ;; bizarre confusion.
+		   (eql (component-info (lambda-component functional))
+			:dead)))))))
+
+;;; If NAME already has a valid entry in *FREE-FUNS*, then return
+;;; the value. Otherwise, make a new GLOBAL-VAR using information from
+;;; the global environment and enter it in *FREE-FUNS*. If NAME
+;;; names a macro or special form, then we error out using the
+;;; supplied context which indicates what we were trying to do that
+;;; demanded a function.
+(declaim (ftype (function (t string) global-var) find-free-fun))
+(defun find-free-fun (name context)
+  (or (let ((old-free-fun (gethash name *free-funs*)))
+	(and (not (invalid-free-fun-p old-free-fun))
+	     old-free-fun))
       (ecase (info :function :kind name)
 	;; FIXME: The :MACRO and :SPECIAL-FORM cases could be merged.
 	(:macro
@@ -122,82 +138,81 @@
 			 name
 			 context))
 	((:function nil)
-	 (check-function-name name)
-	 (note-if-setf-function-and-macro name)
-	 (let ((expansion (info :function :inline-expansion name))
+	 (check-fun-name name)
+	 (note-if-setf-fun-and-macro name)
+	 (let ((expansion (fun-name-inline-expansion name))
 	       (inlinep (info :function :inlinep name)))
-	   (setf (gethash name *free-functions*)
+	   (setf (gethash name *free-funs*)
 		 (if (or expansion inlinep)
-		     (make-defined-function
-		      :name name
+		     (make-defined-fun
+		      :%source-name name
 		      :inline-expansion expansion
 		      :inlinep inlinep
 		      :where-from (info :function :where-from name)
 		      :type (info :function :type name))
-		     (let ((info (info :function :accessor-for name)))
-		       (etypecase info
-			 (null
-			  (find-free-really-function name))
-			 (sb!xc:structure-class
-			  (find-structure-slot-accessor info name))
-			 (sb!xc:class
-			  (if (typep (layout-info (info :type :compiler-layout
-							(sb!xc:class-name
-							 info)))
-				     'defstruct-description)
-			      (find-structure-slot-accessor info name)
-			      (find-free-really-function name))))))))))))
+		     (find-free-really-fun name))))))))
 
 ;;; Return the LEAF structure for the lexically apparent function
 ;;; definition of NAME.
-(declaim (ftype (function (t string) leaf) find-lexically-apparent-function))
-(defun find-lexically-apparent-function (name context)
-  (let ((var (lexenv-find name functions :test #'equal)))
+(declaim (ftype (function (t string) leaf) find-lexically-apparent-fun))
+(defun find-lexically-apparent-fun (name context)
+  (let ((var (lexenv-find name funs :test #'equal)))
     (cond (var
 	   (unless (leaf-p var)
-	     (assert (and (consp var) (eq (car var) 'macro)))
+	     (aver (and (consp var) (eq (car var) 'macro)))
 	     (compiler-error "found macro name ~S ~A" name context))
 	   var)
 	  (t
-	   (find-free-function name context)))))
+	   (find-free-fun name context)))))
 
 ;;; Return the LEAF node for a global variable reference to NAME. If
-;;; NAME is already entered in *FREE-VARIABLES*, then we just return
-;;; the corresponding value. Otherwise, we make a new leaf using
+;;; NAME is already entered in *FREE-VARS*, then we just return the
+;;; corresponding value. Otherwise, we make a new leaf using
 ;;; information from the global environment and enter it in
-;;; *FREE-VARIABLES*. If the variable is unknown, then we emit a
-;;; warning.
-(defun find-free-variable (name)
-  (declare (values (or leaf heap-alien-info)))
+;;; *FREE-VARS*. If the variable is unknown, then we emit a warning.
+(declaim (ftype (function (t) (or leaf cons heap-alien-info)) find-free-var))
+(defun find-free-var (name)
   (unless (symbolp name)
     (compiler-error "Variable name is not a symbol: ~S." name))
-  (or (gethash name *free-variables*)
+  (or (gethash name *free-vars*)
       (let ((kind (info :variable :kind name))
 	    (type (info :variable :type name))
 	    (where-from (info :variable :where-from name)))
 	(when (and (eq where-from :assumed) (eq kind :global))
 	  (note-undefined-reference name :variable))
-
-	(setf (gethash name *free-variables*)
-	      (if (eq kind :alien)
-		  (info :variable :alien-info name)
-		  (multiple-value-bind (val valp)
-		      (info :variable :constant-value name)
-		    (if (and (eq kind :constant) valp)
-			(make-constant :value val
-				       :name name
-				       :type (ctype-of val)
-				       :where-from where-from)
-			(make-global-var :kind kind
-					 :name name
-					 :type type
-					 :where-from where-from))))))))
+	(setf (gethash name *free-vars*)
+	      (case kind
+		(:alien
+		 (info :variable :alien-info name))
+                ;; FIXME: The return value in this case should really be
+                ;; of type SB!C::LEAF.  I don't feel too badly about it,
+                ;; because the MACRO idiom is scattered throughout this
+                ;; file, but it should be cleaned up so we're not
+                ;; throwing random conses around.  --njf 2002-03-23
+                (:macro
+                 (let ((expansion (info :variable :macro-expansion name))
+                       (type (type-specifier (info :variable :type name))))
+                   `(MACRO . (the ,type ,expansion))))
+		(:constant
+		 (let ((value (info :variable :constant-value name)))
+		   (make-constant :value value
+				  :%source-name name
+				  :type (ctype-of value)
+				  :where-from where-from)))
+		(t
+		 (make-global-var :kind kind
+				  :%source-name name
+				  :type type
+				  :where-from where-from)))))))
 
 ;;; Grovel over CONSTANT checking for any sub-parts that need to be
 ;;; processed with MAKE-LOAD-FORM. We have to be careful, because
 ;;; CONSTANT might be circular. We also check that the constant (and
 ;;; any subparts) are dumpable at all.
-(defconstant list-to-hash-table-threshold 32)
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  ;; The EVAL-WHEN is necessary for #.(1+ LIST-TO-HASH-TABLE-THRESHOLD) 
+  ;; below. -- AL 20010227
+  (def!constant list-to-hash-table-threshold 32))
 (defun maybe-emit-make-load-forms (constant)
   (let ((things-processed nil)
 	(count 0))
@@ -270,10 +285,9 @@
 
 ;;; This function sets up the back link between the node and the
 ;;; continuation which continues at it.
-#!-sb-fluid (declaim (inline prev-link))
-(defun prev-link (node cont)
+(defun link-node-to-previous-continuation (node cont)
   (declare (type node node) (type continuation cont))
-  (assert (not (continuation-next cont)))
+  (aver (not (continuation-next cont)))
   (setf (continuation-next cont) node)
   (setf (node-prev node) cont))
 
@@ -282,7 +296,7 @@
 ;;; the continuation has no block, then we make it be in the block
 ;;; that the node is in. If the continuation heads its block, we end
 ;;; our block and link it to that block. If the continuation is not
-;;; currently used, then we set the derived-type for the continuation
+;;; currently used, then we set the DERIVED-TYPE for the continuation
 ;;; to that of the node, so that a little type propagation gets done.
 ;;;
 ;;; We also deal with a bit of THE's semantics here: we weaken the
@@ -304,15 +318,15 @@
   (declare (type node node) (type continuation cont) (inline member))
   (let ((block (continuation-block cont))
 	(node-block (continuation-block (node-prev node))))
-    (assert (eq (continuation-kind cont) :block-start))
-    (assert (not (block-last node-block)) () "~S has already ended."
-	    node-block)
+    (aver (eq (continuation-kind cont) :block-start))
+    (when (block-last node-block)
+      (error "~S has already ended." node-block))
     (setf (block-last node-block) node)
-    (assert (null (block-succ node-block)) () "~S already has successors."
-	    node-block)
+    (when (block-succ node-block)
+      (error "~S already has successors." node-block))
     (setf (block-succ node-block) (list block))
-    (assert (not (member node-block (block-pred block) :test #'eq)) ()
-	    "~S is already a predecessor of ~S." node-block block)
+    (when (memq node-block (block-pred block))
+      (error "~S is already a predecessor of ~S." node-block block))
     (push node-block (block-pred block))
     (add-continuation-use node cont)
     (unless (eq (continuation-asserted-type cont) *wild-type*)
@@ -325,20 +339,19 @@
 
 ;;;; exported functions
 
-;;; This function takes a form and the top-level form number for that
+;;; This function takes a form and the top level form number for that
 ;;; form, and returns a lambda representing the translation of that
-;;; form in the current global environment. The lambda is top-level
-;;; lambda that can be called to cause evaluation of the forms. This
-;;; lambda is in the initial component. If FOR-VALUE is T, then the
-;;; value of the form is returned from the function, otherwise NIL is
-;;; returned.
+;;; form in the current global environment. The returned lambda is a
+;;; top level lambda that can be called to cause evaluation of the
+;;; forms. This lambda is in the initial component. If FOR-VALUE is T,
+;;; then the value of the form is returned from the function,
+;;; otherwise NIL is returned.
 ;;;
 ;;; This function may have arbitrary effects on the global environment
-;;; due to processing of PROCLAIMs and EVAL-WHENs. All syntax error
-;;; checking is done, with erroneous forms being replaced by a proxy
-;;; which signals an error if it is evaluated. Warnings about possibly
-;;; inconsistent or illegal changes to the global environment will
-;;; also be given.
+;;; due to processing of EVAL-WHENs. All syntax error checking is
+;;; done, with erroneous forms being replaced by a proxy which signals
+;;; an error if it is evaluated. Warnings about possibly inconsistent
+;;; or illegal changes to the global environment will also be given.
 ;;;
 ;;; We make the initial component and convert the form in a PROGN (and
 ;;; an optional NIL tacked on the end.) We then return the lambda. We
@@ -349,7 +362,7 @@
 ;;; The hashtables used to hold global namespace info must be
 ;;; reallocated elsewhere. Note also that *LEXENV* is not bound, so
 ;;; that local macro definitions can be introduced by enclosing code.
-(defun ir1-top-level (form path for-value)
+(defun ir1-toplevel (form path for-value)
   (declare (list path))
   (let* ((*current-path* path)
 	 (component (make-empty-component))
@@ -357,23 +370,25 @@
     (setf (component-name component) "initial component")
     (setf (component-kind component) :initial)
     (let* ((forms (if for-value `(,form) `(,form nil)))
-	   (res (ir1-convert-lambda-body forms ())))
-      (setf (leaf-name res) "top-level form")
-      (setf (functional-entry-function res) res)
-      (setf (functional-arg-documentation res) ())
-      (setf (functional-kind res) :top-level)
+	   (res (ir1-convert-lambda-body
+		 forms ()
+		 :debug-name (debug-namify "top level form ~S" form))))
+      (setf (functional-entry-fun res) res
+	    (functional-arg-documentation res) ()
+	    (functional-kind res) :toplevel)
       res)))
 
 ;;; *CURRENT-FORM-NUMBER* is used in FIND-SOURCE-PATHS to compute the
 ;;; form number to associate with a source path. This should be bound
-;;; to 0 around the processing of each truly top-level form.
+;;; to an initial value of 0 before the processing of each truly
+;;; top level form.
 (declaim (type index *current-form-number*))
 (defvar *current-form-number*)
 
 ;;; This function is called on freshly read forms to record the
 ;;; initial location of each form (and subform.) Form is the form to
-;;; find the paths in, and TLF-Num is the top-level form number of the
-;;; truly top-level form.
+;;; find the paths in, and TLF-NUM is the top level form number of the
+;;; truly top level form.
 ;;;
 ;;; This gets a bit interesting when the source code is circular. This
 ;;; can (reasonably?) happen in the case of circular list constants.
@@ -413,15 +428,16 @@
 				cont
 				form
 				&optional
-				(proxy ``(error "execution of a form compiled with errors:~% ~S"
-						',,form)))
+				(proxy ``(error 'simple-program-error
+					  :format-control "execution of a form compiled with errors:~% ~S"
+					  :format-arguments (list ',,form))))
 			       &body body)
 			      (let ((skip (gensym "SKIP")))
 				`(block ,skip
 				   (catch 'ir1-error-abort
 				     (let ((*compiler-error-bailout*
-					    #'(lambda ()
-						(throw 'ir1-error-abort nil))))
+					    (lambda ()
+					      (throw 'ir1-error-abort nil))))
 				       ,@body
 				       (return-from ,skip nil)))
 				   (ir1-convert ,start ,cont ,proxy)))))
@@ -443,126 +459,161 @@
 				(cons form *current-path*))))
 	(if (atom form)
 	    (cond ((and (symbolp form) (not (keywordp form)))
-		   (ir1-convert-variable start cont form))
+		   (ir1-convert-var start cont form))
 		  ((leaf-p form)
 		   (reference-leaf start cont form))
 		  (t
 		   (reference-constant start cont form)))
-	    (let ((fun (car form)))
-	      (cond
-	       ((symbolp fun)
-		(let ((lexical-def (lexenv-find fun functions)))
-		  (typecase lexical-def
-		    (null (ir1-convert-global-functoid start cont form))
-		    (functional
-		     (ir1-convert-local-combination start
-						    cont
-						    form
-						    lexical-def))
-		    (global-var
-		     (ir1-convert-srctran start cont lexical-def form))
+	    (let ((opname (car form)))
+	      (cond ((symbolp opname)
+		     (let ((lexical-def (lexenv-find opname funs)))
+		       (typecase lexical-def
+			 (null (ir1-convert-global-functoid start cont form))
+			 (functional
+			  (ir1-convert-local-combination start
+							 cont
+							 form
+							 lexical-def))
+			 (global-var
+			  (ir1-convert-srctran start cont lexical-def form))
+			 (t
+			  (aver (and (consp lexical-def)
+				     (eq (car lexical-def) 'macro)))
+			  (ir1-convert start cont
+				       (careful-expand-macro (cdr lexical-def)
+							     form))))))
+		    ((or (atom opname) (not (eq (car opname) 'lambda)))
+		     (compiler-error "illegal function call"))
 		    (t
-		     (assert (and (consp lexical-def)
-				  (eq (car lexical-def) 'macro)))
-		     (ir1-convert start cont
-				  (careful-expand-macro (cdr lexical-def)
-							form))))))
-	       ((or (atom fun) (not (eq (car fun) 'lambda)))
-		(compiler-error "illegal function call"))
-	       (t
-		(ir1-convert-combination start
-					 cont
-					 form
-					 (ir1-convert-lambda fun))))))))
+		     ;; implicitly (LAMBDA ..) because the LAMBDA
+		     ;; expression is the CAR of an executed form
+		     (ir1-convert-combination start
+					      cont
+					      form
+					      (ir1-convert-lambda
+					       opname
+					       :debug-name (debug-namify
+							    "LAMBDA CAR ~S"
+							    opname)))))))))
     (values))
 
   ;; Generate a reference to a manifest constant, creating a new leaf
-  ;; if necessary. If we are producing a fasl-file, make sure that
+  ;; if necessary. If we are producing a fasl file, make sure that
   ;; MAKE-LOAD-FORM gets used on any parts of the constant that it
   ;; needs to be.
   (defun reference-constant (start cont value)
     (declare (type continuation start cont)
 	     (inline find-constant))
     (ir1-error-bailout
-     (start cont value
-	    '(error "attempt to reference undumpable constant"))
+     (start cont value '(error "attempt to reference undumpable constant"))
      (when (producing-fasl-file)
        (maybe-emit-make-load-forms value))
      (let* ((leaf (find-constant value))
 	    (res (make-ref (leaf-type leaf) leaf)))
        (push res (leaf-refs leaf))
-       (prev-link res start)
+       (link-node-to-previous-continuation res start)
        (use-continuation res cont)))
     (values)))
 
-;;; Add Fun to the COMPONENT-REANALYZE-FUNCTIONS. Fun is returned.
- (defun maybe-reanalyze-function (fun)
-  (declare (type functional fun))
-  (when (typep fun '(or optional-dispatch clambda))
-    (pushnew fun (component-reanalyze-functions *current-component*)))
-  fun)
+;;; Add FUNCTIONAL to the COMPONENT-REANALYZE-FUNCTIONALS, unless it's
+;;; some trivial type for which reanalysis is a trivial no-op, or
+;;; unless it doesn't belong in this component at all.
+;;;
+;;; FUNCTIONAL is returned.
+(defun maybe-reanalyze-functional (functional)
+
+  (aver (not (eql (functional-kind functional) :deleted))) ; bug 148
+  (aver-live-component *current-component*)
+
+  ;; When FUNCTIONAL is of a type for which reanalysis isn't a trivial
+  ;; no-op
+  (when (typep functional '(or optional-dispatch clambda))
+
+    ;; When FUNCTIONAL knows its component
+    (when (lambda-p functional) 
+      (aver (eql (lambda-component functional) *current-component*)))
 
-;;; Generate a Ref node for LEAF, frobbing the LEAF structure as
+    (pushnew functional
+	     (component-reanalyze-functionals *current-component*)))
+
+  functional)
+
+;;; Generate a REF node for LEAF, frobbing the LEAF structure as
 ;;; needed. If LEAF represents a defined function which has already
 ;;; been converted, and is not :NOTINLINE, then reference the
 ;;; functional instead.
 (defun reference-leaf (start cont leaf)
   (declare (type continuation start cont) (type leaf leaf))
-  (let* ((leaf (or (and (defined-function-p leaf)
-			(not (eq (defined-function-inlinep leaf)
+  (let* ((leaf (or (and (defined-fun-p leaf)
+			(not (eq (defined-fun-inlinep leaf)
 				 :notinline))
-			(let ((fun (defined-function-functional leaf)))
-			  (when (and fun (not (functional-kind fun)))
-			    (maybe-reanalyze-function fun))))
+			(let ((functional (defined-fun-functional leaf)))
+			  (when (and functional
+				     (not (functional-kind functional)))
+			    (maybe-reanalyze-functional functional))))
 		   leaf))
 	 (res (make-ref (or (lexenv-find leaf type-restrictions)
 			    (leaf-type leaf))
 			leaf)))
     (push res (leaf-refs leaf))
     (setf (leaf-ever-used leaf) t)
-    (prev-link res start)
+    (link-node-to-previous-continuation res start)
     (use-continuation res cont)))
 
 ;;; Convert a reference to a symbolic constant or variable. If the
-;;; symbol is entered in the LEXENV-VARIABLES we use that definition,
+;;; symbol is entered in the LEXENV-VARS we use that definition,
 ;;; otherwise we find the current global definition. This is also
-;;; where we pick off symbol macro and Alien variable references.
-(defun ir1-convert-variable (start cont name)
+;;; where we pick off symbol macro and alien variable references.
+(defun ir1-convert-var (start cont name)
   (declare (type continuation start cont) (symbol name))
-  (let ((var (or (lexenv-find name variables) (find-free-variable name))))
+  (let ((var (or (lexenv-find name vars) (find-free-var name))))
     (etypecase var
       (leaf
-       (when (and (lambda-var-p var) (lambda-var-ignorep var))
-	 ;; (ANSI's specification for the IGNORE declaration requires
-	 ;; that this be a STYLE-WARNING, not a full WARNING.)
-	 (compiler-style-warning "reading an ignored variable: ~S" name))
+       (when (lambda-var-p var)
+	 (let ((home (continuation-home-lambda-or-null start)))
+	   (when home
+	     (pushnew var (lambda-calls-or-closes home))))
+	 (when (lambda-var-ignorep var)
+	   ;; (ANSI's specification for the IGNORE declaration requires
+	   ;; that this be a STYLE-WARNING, not a full WARNING.)
+	   (compiler-style-warn "reading an ignored variable: ~S" name)))
        (reference-leaf start cont var))
       (cons
-       (assert (eq (car var) 'MACRO))
+       (aver (eq (car var) 'MACRO))
        (ir1-convert start cont (cdr var)))
       (heap-alien-info
        (ir1-convert start cont `(%heap-alien ',var)))))
   (values))
 
 ;;; Convert anything that looks like a special form, global function
-;;; or macro call.
+;;; or compiler-macro call.
 (defun ir1-convert-global-functoid (start cont form)
   (declare (type continuation start cont) (list form))
-  (let* ((fun (first form))
-	 (translator (info :function :ir1-convert fun))
-	 (cmacro (info :function :compiler-macro-function fun)))
-    (cond (translator (funcall translator start cont form))
-	  ((and cmacro (not *converting-for-interpreter*)
-		(not (eq (info :function :inlinep fun) :notinline)))
-	   (let ((res (careful-expand-macro cmacro form)))
+  (let* ((fun-name (first form))
+	 (translator (info :function :ir1-convert fun-name))
+	 (cmacro-fun (sb!xc:compiler-macro-function fun-name *lexenv*)))
+    (cond (translator
+	   (when cmacro-fun
+	     (compiler-warn "ignoring compiler macro for special form"))
+	   (funcall translator start cont form))
+	  ((and cmacro-fun
+		;; gotcha: If you look up the DEFINE-COMPILER-MACRO
+		;; macro in the ANSI spec, you might think that
+		;; suppressing compiler-macro expansion when NOTINLINE
+		;; is some pre-ANSI hack. However, if you look up the
+		;; NOTINLINE declaration, you'll find that ANSI
+		;; requires this behavior after all.
+		(not (eq (info :function :inlinep fun-name) :notinline)))
+	   (let ((res (careful-expand-macro cmacro-fun form)))
 	     (if (eq res form)
-		 (ir1-convert-global-functoid-no-cmacro start cont form fun)
+		 (ir1-convert-global-functoid-no-cmacro
+		  start cont form fun-name)
 		 (ir1-convert start cont res))))
 	  (t
-	   (ir1-convert-global-functoid-no-cmacro start cont form fun)))))
+	   (ir1-convert-global-functoid-no-cmacro start cont form fun-name)))))
 
-;;; Handle the case of where the call was not a compiler macro, or was a
-;;; compiler macro and passed.
+;;; Handle the case of where the call was not a compiler macro, or was
+;;; a compiler macro and passed.
 (defun ir1-convert-global-functoid-no-cmacro (start cont form fun)
   (declare (type continuation start cont) (list form))
   ;; FIXME: Couldn't all the INFO calls here be converted into
@@ -576,71 +627,90 @@
 		  (careful-expand-macro (info :function :macro-function fun)
 					form)))
     ((nil :function)
-     (ir1-convert-srctran start cont (find-free-function fun "Eh?") form))))
+     (ir1-convert-srctran start
+			  cont
+			  (find-free-fun fun "shouldn't happen! (no-cmacro)")
+			  form))))
 
 (defun muffle-warning-or-die ()
   (muffle-warning)
-  (error "internal error -- no MUFFLE-WARNING restart"))
+  (bug "no MUFFLE-WARNING restart"))
 
-;;; Trap errors during the macroexpansion.
+;;; Expand FORM using the macro whose MACRO-FUNCTION is FUN, trapping
+;;; errors which occur during the macroexpansion.
 (defun careful-expand-macro (fun form)
-  (handler-bind (;; When cross-compiling, we can get style warnings
-		 ;; about e.g. undefined functions. An unhandled
-		 ;; CL:STYLE-WARNING (as opposed to a
-		 ;; SB!C::COMPILER-NOTE) would cause FAILURE-P to be
-		 ;; set on the return from #'SB!XC:COMPILE-FILE, which
-		 ;; would falsely indicate an error sufficiently
-		 ;; serious that we should stop the build process. To
-		 ;; avoid this, we translate CL:STYLE-WARNING
-		 ;; conditions from the host Common Lisp into
-		 ;; cross-compiler SB!C::COMPILER-NOTE calls. (It
-		 ;; might be cleaner to just make Python use
-		 ;; CL:STYLE-WARNING internally, so that the
-		 ;; significance of any host Common Lisp
-		 ;; CL:STYLE-WARNINGs is understood automatically. But
-		 ;; for now I'm not motivated to do this. -- WHN
-		 ;; 19990412)
-		 (style-warning (lambda (c)
-				  (compiler-note "(during macroexpansion)~%~A"
-						 c)
-				  (muffle-warning-or-die)))
-		 ;; KLUDGE: CMU CL in its wisdom (version 2.4.6 for
-		 ;; Debian Linux, anyway) raises a CL:WARNING
-		 ;; condition (not a CL:STYLE-WARNING) for undefined
-		 ;; symbols when converting interpreted functions,
-		 ;; causing COMPILE-FILE to think the file has a real
-		 ;; problem, causing COMPILE-FILE to return FAILURE-P
-		 ;; set (not just WARNINGS-P set). Since undefined
-		 ;; symbol warnings are often harmless forward
-		 ;; references, and since it'd be inordinately painful
-		 ;; to try to eliminate all such forward references,
-		 ;; these warnings are basically unavoidable. Thus, we
-		 ;; need to coerce the system to work through them,
-		 ;; and this code does so, by crudely suppressing all
-		 ;; warnings in cross-compilation macroexpansion. --
-		 ;; WHN 19990412
-		 #+cmu
-		 (warning (lambda (c)
-			    (compiler-note
-			     "(during macroexpansion)~%~
-			      ~A~%~
-			      (KLUDGE: That was a non-STYLE WARNING.~%~
-			      Ordinarily that would cause compilation to~%~
-			      fail. However, since we're running under~%~
-			      CMU CL, and since CMU CL emits non-STYLE~%~
-			      warnings for safe, hard-to-fix things (e.g.~%~
-			      references to not-yet-defined functions)~%~
-			      we're going to have to ignore it and proceed~%~
-			      anyway. Hopefully we're not ignoring anything~%~
-			      horrible here..)~%"
-			     c)
-			    (muffle-warning-or-die)))
-		 (error (lambda (c)
-			  (compiler-error "(during macroexpansion)~%~A" c))))
-    (funcall sb!xc:*macroexpand-hook*
-	     fun
-	     form
-	     *lexenv*)))
+  (let (;; a hint I (WHN) wish I'd known earlier
+	(hint "(hint: For more precise location, try *BREAK-ON-SIGNALS*.)"))
+    (flet (;; Return a string to use as a prefix in error reporting,
+	   ;; telling something about which form caused the problem.
+	   (wherestring ()
+	     (let ((*print-pretty* nil)
+		   ;; We rely on the printer to abbreviate FORM. 
+		   (*print-length* 3)
+		   (*print-level* 1))
+	       (format
+		nil
+		#-sb-xc-host "(in macroexpansion of ~S)"
+		;; longer message to avoid ambiguity "Was it the xc host
+		;; or the cross-compiler which encountered the problem?"
+		#+sb-xc-host "(in cross-compiler macroexpansion of ~S)"
+		form))))
+      (handler-bind (;; When cross-compiling, we can get style warnings
+                     ;; about e.g. undefined functions. An unhandled
+                     ;; CL:STYLE-WARNING (as opposed to a
+                     ;; SB!C::COMPILER-NOTE) would cause FAILURE-P to be
+                     ;; set on the return from #'SB!XC:COMPILE-FILE, which
+                     ;; would falsely indicate an error sufficiently
+                     ;; serious that we should stop the build process. To
+                     ;; avoid this, we translate CL:STYLE-WARNING
+                     ;; conditions from the host Common Lisp into
+                     ;; cross-compiler SB!C::COMPILER-NOTE calls. (It
+                     ;; might be cleaner to just make Python use
+                     ;; CL:STYLE-WARNING internally, so that the
+                     ;; significance of any host Common Lisp
+                     ;; CL:STYLE-WARNINGs is understood automatically. But
+                     ;; for now I'm not motivated to do this. -- WHN
+                     ;; 19990412)
+                     (style-warning (lambda (c)
+                                      (compiler-note "~@<~A~:@_~A~:@_~A~:>"
+						     (wherestring) hint c)
+                                      (muffle-warning-or-die)))
+                     ;; KLUDGE: CMU CL in its wisdom (version 2.4.6 for
+                     ;; Debian Linux, anyway) raises a CL:WARNING
+                     ;; condition (not a CL:STYLE-WARNING) for undefined
+                     ;; symbols when converting interpreted functions,
+                     ;; causing COMPILE-FILE to think the file has a real
+                     ;; problem, causing COMPILE-FILE to return FAILURE-P
+                     ;; set (not just WARNINGS-P set). Since undefined
+                     ;; symbol warnings are often harmless forward
+                     ;; references, and since it'd be inordinately painful
+                     ;; to try to eliminate all such forward references,
+                     ;; these warnings are basically unavoidable. Thus, we
+                     ;; need to coerce the system to work through them,
+                     ;; and this code does so, by crudely suppressing all
+                     ;; warnings in cross-compilation macroexpansion. --
+                     ;; WHN 19990412
+                     #+cmu
+                     (warning (lambda (c)
+                                (compiler-note
+                                 "~@<~A~:@_~
+                                  ~A~:@_~
+                                  ~@<(KLUDGE: That was a non-STYLE WARNING. ~
+                                  Ordinarily that would cause compilation to ~
+                                  fail. However, since we're running under ~
+                                  CMU CL, and since CMU CL emits non-STYLE ~
+                                  warnings for safe, hard-to-fix things (e.g. ~
+                                  references to not-yet-defined functions) ~
+                                  we're going to have to ignore it and ~
+                                  proceed anyway. Hopefully we're not ~
+                                  ignoring anything  horrible here..)~:@>~:>"
+                                 (wherestring)
+                                 c)
+                                (muffle-warning-or-die)))
+                     (error (lambda (c)
+                              (compiler-error "~@<~A~:@_~A~@:_~A~:>"
+                                              (wherestring) hint c))))
+        (funcall sb!xc:*macroexpand-hook* fun form *lexenv*)))))
 
 ;;;; conversion utilities
 
@@ -660,13 +730,15 @@
 	      (return))
 	    (let ((this-cont (make-continuation)))
 	      (ir1-convert this-start this-cont form)
-	      (setq this-start this-cont  forms (cdr forms)))))))
+	      (setq this-start this-cont
+		    forms (cdr forms)))))))
   (values))
 
 ;;;; converting combinations
 
-;;; Convert a function call where the function (Fun) is a Leaf. We
-;;; return the Combination node so that we can poke at it if we want to.
+;;; Convert a function call where the function FUN is a LEAF. FORM is
+;;; the source for the call. We return the COMBINATION node so that
+;;; the caller can poke at it if it wants to.
 (declaim (ftype (function (continuation continuation list leaf) combination)
 		ir1-convert-combination))
 (defun ir1-convert-combination (start cont form fun)
@@ -674,10 +746,10 @@
     (reference-leaf start fun-cont fun)
     (ir1-convert-combination-args fun-cont cont (cdr form))))
 
-;;; Convert the arguments to a call and make the Combination node. Fun-Cont
-;;; is the continuation which yields the function to call. Form is the source
-;;; for the call. Args is the list of arguments for the call, which defaults
-;;; to the cdr of source. We return the Combination node.
+;;; Convert the arguments to a call and make the COMBINATION
+;;; node. FUN-CONT is the continuation which yields the function to
+;;; call. ARGS is the list of arguments for the call, which defaults
+;;; to the cdr of source. We return the COMBINATION node.
 (defun ir1-convert-combination-args (fun-cont cont args)
   (declare (type continuation fun-cont cont) (list args))
   (let ((node (make-combination fun-cont)))
@@ -691,47 +763,43 @@
 	    (ir1-convert this-start this-cont arg)
 	    (setq this-start this-cont)
 	    (arg-conts this-cont)))
-	(prev-link node this-start)
+	(link-node-to-previous-continuation node this-start)
 	(use-continuation node cont)
 	(setf (combination-args node) (arg-conts))))
     node))
 
 ;;; Convert a call to a global function. If not :NOTINLINE, then we do
 ;;; source transforms and try out any inline expansion. If there is no
-;;; expansion, but is :INLINE, then give an efficiency note (unless a known
-;;; function which will quite possibly be open-coded.)   Next, we go to
-;;; ok-combination conversion.
+;;; expansion, but is :INLINE, then give an efficiency note (unless a
+;;; known function which will quite possibly be open-coded.) Next, we
+;;; go to ok-combination conversion.
 (defun ir1-convert-srctran (start cont var form)
   (declare (type continuation start cont) (type global-var var))
-  (let ((inlinep (when (defined-function-p var)
-		   (defined-function-inlinep var))))
-    (cond
-     ((eq inlinep :notinline)
-      (ir1-convert-combination start cont form var))
-     (*converting-for-interpreter*
-      (ir1-convert-combination-checking-type start cont form var))
-     (t
-      (let ((transform (info :function :source-transform (leaf-name var))))
-	(cond
-	 (transform
-	  (multiple-value-bind (result pass) (funcall transform form)
-	    (if pass
-		(ir1-convert-maybe-predicate start cont form var)
-		(ir1-convert start cont result))))
-	 (t
-	  (ir1-convert-maybe-predicate start cont form var))))))))
-
-;;; If the function has the Predicate attribute, and the CONT's DEST isn't
-;;; an IF, then we convert (IF <form> T NIL), ensuring that a predicate always
-;;; appears in a conditional context.
+  (let ((inlinep (when (defined-fun-p var)
+		   (defined-fun-inlinep var))))
+    (if (eq inlinep :notinline)
+	(ir1-convert-combination start cont form var)
+	(let ((transform (info :function
+			       :source-transform
+			       (leaf-source-name var))))
+	  (if transform
+	      (multiple-value-bind (result pass) (funcall transform form)
+		(if pass
+		    (ir1-convert-maybe-predicate start cont form var)
+		    (ir1-convert start cont result)))
+	      (ir1-convert-maybe-predicate start cont form var))))))
+
+;;; If the function has the PREDICATE attribute, and the CONT's DEST
+;;; isn't an IF, then we convert (IF <form> T NIL), ensuring that a
+;;; predicate always appears in a conditional context.
 ;;;
 ;;; If the function isn't a predicate, then we call
 ;;; IR1-CONVERT-COMBINATION-CHECKING-TYPE.
 (defun ir1-convert-maybe-predicate (start cont form var)
   (declare (type continuation start cont) (list form) (type global-var var))
-  (let ((info (info :function :info (leaf-name var))))
+  (let ((info (info :function :info (leaf-source-name var))))
     (if (and info
-	     (ir1-attributep (function-info-attributes info) predicate)
+	     (ir1-attributep (fun-info-attributes info) predicate)
 	     (not (if-p (continuation-dest cont))))
 	(ir1-convert start cont `(if ,form t nil))
 	(ir1-convert-combination-checking-type start cont form var))))
@@ -759,24 +827,48 @@
       (setf (continuation-%derived-type fun-cont) type)
       (setf (continuation-reoptimize fun-cont) nil)
       (setf (continuation-%type-check fun-cont) nil)))
-
   (values))
 
-;;; Convert a call to a local function. If the function has already
-;;; been let converted, then throw FUN to LOCAL-CALL-LOSSAGE. This
-;;; should only happen when we are converting inline expansions for
-;;; local functions during optimization.
-(defun ir1-convert-local-combination (start cont form fun)
-  (if (functional-kind fun)
-      (throw 'local-call-lossage fun)
-      (ir1-convert-combination start cont form
-			       (maybe-reanalyze-function fun))))
+;;; Convert a call to a local function, or if the function has already
+;;; been LET converted, then throw FUNCTIONAL to
+;;; LOCALL-ALREADY-LET-CONVERTED. The THROW should only happen when we
+;;; are converting inline expansions for local functions during
+;;; optimization.
+(defun ir1-convert-local-combination (start cont form functional)
+
+  ;; The test here is for "when LET converted", as a translation of
+  ;; the old CMU CL comments into code. Unfortunately, the old CMU CL
+  ;; comments aren't specific enough to tell whether the correct
+  ;; translation is FUNCTIONAL-SOMEWHAT-LETLIKE-P or
+  ;; FUNCTIONAL-LETLIKE-P or what. The old CMU CL code assumed that
+  ;; any non-null FUNCTIONAL-KIND meant that the function "had been
+  ;; LET converted", which might even be right, but seems fragile, so
+  ;; we try to be pickier.
+  (when (or
+	 ;; looks LET-converted
+	 (functional-somewhat-letlike-p functional)
+	 ;; It's possible for a LET-converted function to end up
+	 ;; deleted later. In that case, for the purposes of this
+	 ;; analysis, it is LET-converted: LET-converted functionals
+	 ;; are too badly trashed to expand them inline, and deleted
+	 ;; LET-converted functionals are even worse.
+	 (eql (functional-kind functional) :deleted))
+    (throw 'locall-already-let-converted functional))
+  ;; Any other non-NIL KIND value is a case we haven't found a
+  ;; justification for, and at least some such values (e.g. :EXTERNAL
+  ;; and :TOPLEVEL) seem obviously wrong.
+  (aver (null (functional-kind functional)))
+
+  (ir1-convert-combination start
+			   cont
+			   form
+			   (maybe-reanalyze-functional functional)))
 
 ;;;; PROCESS-DECLS
 
-;;; Given a list of Lambda-Var structures and a variable name, return
-;;; the structure for that name, or NIL if it isn't found. We return
-;;; the *last* variable with that name, since LET* bindings may be
+;;; Given a list of LAMBDA-VARs and a variable name, return the
+;;; LAMBDA-VAR for that name, or NIL if it isn't found. We return the
+;;; *last* variable with that name, since LET* bindings may be
 ;;; duplicated, and declarations always apply to the last.
 (declaim (ftype (function (list symbol) (or lambda-var list))
 		find-in-bindings))
@@ -784,23 +876,23 @@
   (let ((found nil))
     (dolist (var vars)
       (cond ((leaf-p var)
-	     (when (eq (leaf-name var) name)
+	     (when (eq (leaf-source-name var) name)
 	       (setq found var))
 	     (let ((info (lambda-var-arg-info var)))
 	       (when info
 		 (let ((supplied-p (arg-info-supplied-p info)))
 		   (when (and supplied-p
-			      (eq (leaf-name supplied-p) name))
+			      (eq (leaf-source-name supplied-p) name))
 		     (setq found supplied-p))))))
 	    ((and (consp var) (eq (car var) name))
 	     (setf found (cdr var)))))
     found))
 
-;;; Called by Process-Decls to deal with a variable type declaration.
-;;; If a lambda-var being bound, we intersect the type with the vars
-;;; type, otherwise we add a type-restriction on the var. If a symbol
+;;; Called by PROCESS-DECLS to deal with a variable type declaration.
+;;; If a LAMBDA-VAR being bound, we intersect the type with the var's
+;;; type, otherwise we add a type restriction on the var. If a symbol
 ;;; macro, we just wrap a THE around the expansion.
-(defun process-type-declaration (decl res vars)
+(defun process-type-decl (decl res vars)
   (declare (list decl vars) (type lexenv res))
   (let ((type (specifier-type (first decl))))
     (collect ((restr nil cons)
@@ -808,19 +900,19 @@
       (dolist (var-name (rest decl))
 	(let* ((bound-var (find-in-bindings vars var-name))
 	       (var (or bound-var
-			(lexenv-find var-name variables)
-			(find-free-variable var-name))))
+			(lexenv-find var-name vars)
+			(find-free-var var-name))))
 	  (etypecase var
 	    (leaf
 	     (let* ((old-type (or (lexenv-find var type-restrictions)
 				  (leaf-type var)))
-		    (int (if (or (function-type-p type)
-				 (function-type-p old-type))
+		    (int (if (or (fun-type-p type)
+				 (fun-type-p old-type))
 			     type
-			     (type-intersection old-type type))))
+			     (type-approx-intersection2 old-type type))))
 	       (cond ((eq int *empty-type*)
-		      (unless (policy nil (= inhibit-warnings 3))
-			(compiler-warning
+		      (unless (policy *lexenv* (= inhibit-warnings 3))
+			(compiler-warn
 			 "The type declarations ~S and ~S for ~S conflict."
 			 (type-specifier old-type) (type-specifier type)
 			 var-name)))
@@ -829,7 +921,7 @@
 		      (restr (cons var int))))))
 	    (cons
 	     ;; FIXME: non-ANSI weirdness
-	     (assert (eq (car var) 'MACRO))
+	     (aver (eq (car var) 'MACRO))
 	     (new-vars `(,var-name . (MACRO . (the ,(first decl)
 						   ,(cdr var))))))
 	    (heap-alien-info
@@ -840,28 +932,30 @@
       (if (or (restr) (new-vars))
 	  (make-lexenv :default res
 		       :type-restrictions (restr)
-		       :variables (new-vars))
+		       :vars (new-vars))
 	  res))))
 
-;;; Somewhat similar to Process-Type-Declaration, but handles
+;;; This is somewhat similar to PROCESS-TYPE-DECL, but handles
 ;;; declarations for function variables. In addition to allowing
 ;;; declarations for functions being bound, we must also deal with
 ;;; declarations that constrain the type of lexically apparent
 ;;; functions.
-(defun process-ftype-declaration (spec res names fvars)
+(defun process-ftype-decl (spec res names fvars)
   (declare (list spec names fvars) (type lexenv res))
   (let ((type (specifier-type spec)))
     (collect ((res nil cons))
       (dolist (name names)
-	(let ((found (find name fvars :key #'leaf-name :test #'equal)))
+	(let ((found (find name fvars
+			   :key #'leaf-source-name
+			   :test #'equal)))
 	  (cond
 	   (found
 	    (setf (leaf-type found) type)
 	    (assert-definition-type found type
-				    :warning-function #'compiler-note
+				    :unwinnage-fun #'compiler-note
 				    :where "FTYPE declaration"))
 	   (t
-	    (res (cons (find-lexically-apparent-function
+	    (res (cons (find-lexically-apparent-fun
 			name "in a function type declaration")
 		       type))))))
       (if (res)
@@ -871,14 +965,14 @@
 ;;; Process a special declaration, returning a new LEXENV. A non-bound
 ;;; special declaration is instantiated by throwing a special variable
 ;;; into the variables.
-(defun process-special-declaration (spec res vars)
+(defun process-special-decl (spec res vars)
   (declare (list spec vars) (type lexenv res))
   (collect ((new-venv nil cons))
     (dolist (name (cdr spec))
       (let ((var (find-in-bindings vars name)))
 	(etypecase var
 	  (cons
-	   (assert (eq (car var) 'MACRO))
+	   (aver (eq (car var) 'MACRO))
 	   (compiler-error
 	    "~S is a symbol-macro and thus can't be declared special."
 	    name))
@@ -886,7 +980,7 @@
 	   (when (lambda-var-ignorep var)
 	     ;; ANSI's definition for "Declaration IGNORE, IGNORABLE"
 	     ;; requires that this be a STYLE-WARNING, not a full WARNING.
-	     (compiler-style-warning
+	     (compiler-style-warn
 	      "The ignored variable ~S is being declared special."
 	      name))
 	   (setf (lambda-var-specvar var)
@@ -895,39 +989,41 @@
 	   (unless (assoc name (new-venv) :test #'eq)
 	     (new-venv (cons name (specvar-for-binding name))))))))
     (if (new-venv)
-	(make-lexenv :default res :variables (new-venv))
+	(make-lexenv :default res :vars (new-venv))
 	res)))
 
-;;; Return a DEFINED-FUNCTION which copies a global-var but for its inlinep.
+;;; Return a DEFINED-FUN which copies a GLOBAL-VAR but for its INLINEP.
 (defun make-new-inlinep (var inlinep)
   (declare (type global-var var) (type inlinep inlinep))
-  (let ((res (make-defined-function
-	      :name (leaf-name var)
+  (let ((res (make-defined-fun
+	      :%source-name (leaf-source-name var)
 	      :where-from (leaf-where-from var)
 	      :type (leaf-type var)
 	      :inlinep inlinep)))
-    (when (defined-function-p var)
-      (setf (defined-function-inline-expansion res)
-	    (defined-function-inline-expansion var))
-      (setf (defined-function-functional res)
-	    (defined-function-functional var)))
+    (when (defined-fun-p var)
+      (setf (defined-fun-inline-expansion res)
+	    (defined-fun-inline-expansion var))
+      (setf (defined-fun-functional res)
+	    (defined-fun-functional var)))
     res))
 
 ;;; Parse an inline/notinline declaration. If it's a local function we're
 ;;; defining, set its INLINEP. If a global function, add a new FENV entry.
-(defun process-inline-declaration (spec res fvars)
+(defun process-inline-decl (spec res fvars)
   (let ((sense (cdr (assoc (first spec) *inlinep-translations* :test #'eq)))
 	(new-fenv ()))
     (dolist (name (rest spec))
-      (let ((fvar (find name fvars :key #'leaf-name :test #'equal)))
+      (let ((fvar (find name fvars
+			:key #'leaf-source-name
+			:test #'equal)))
 	(if fvar
 	    (setf (functional-inlinep fvar) sense)
 	    (let ((found
-		   (find-lexically-apparent-function
+		   (find-lexically-apparent-fun
 		    name "in an inline or notinline declaration")))
 	      (etypecase found
 		(functional
-		 (when (policy nil (>= speed inhibit-warnings))
+		 (when (policy *lexenv* (>= speed inhibit-warnings))
 		   (compiler-note "ignoring ~A declaration not at ~
 				   definition of local function:~%  ~S"
 				  sense name)))
@@ -936,10 +1032,10 @@
 		       new-fenv)))))))
 
     (if new-fenv
-	(make-lexenv :default res :functions new-fenv)
+	(make-lexenv :default res :funs new-fenv)
 	res)))
 
-;;; Like FIND-IN-BINDINGS, but looks for #'foo in the fvars.
+;;; like FIND-IN-BINDINGS, but looks for #'FOO in the FVARS
 (defun find-in-bindings-or-fbindings (name vars fvars)
   (declare (list vars fvars))
   (if (consp name)
@@ -947,12 +1043,12 @@
 	(unless (eq wot 'function)
 	  (compiler-error "The function or variable name ~S is unrecognizable."
 			  name))
-	(find fn-name fvars :key #'leaf-name :test #'equal))
+	(find fn-name fvars :key #'leaf-source-name :test #'equal))
       (find-in-bindings vars name)))
 
 ;;; Process an ignore/ignorable declaration, checking for various losing
 ;;; conditions.
-(defun process-ignore-declaration (spec vars fvars)
+(defun process-ignore-decl (spec vars fvars)
   (declare (list spec vars fvars))
   (dolist (name (rest spec))
     (let ((var (find-in-bindings-or-fbindings name vars fvars)))
@@ -960,19 +1056,19 @@
        ((not var)
 	;; ANSI's definition for "Declaration IGNORE, IGNORABLE"
 	;; requires that this be a STYLE-WARNING, not a full WARNING.
-	(compiler-style-warning "declaring unknown variable ~S to be ignored"
-				name))
+	(compiler-style-warn "declaring unknown variable ~S to be ignored"
+			     name))
        ;; FIXME: This special case looks like non-ANSI weirdness.
        ((and (consp var) (consp (cdr var)) (eq (cadr var) 'macro))
 	;; Just ignore the IGNORE decl.
 	)
        ((functional-p var)
 	(setf (leaf-ever-used var) t))
-       ((lambda-var-specvar var)
+       ((and (lambda-var-specvar var) (eq (first spec) 'ignore))
 	;; ANSI's definition for "Declaration IGNORE, IGNORABLE"
 	;; requires that this be a STYLE-WARNING, not a full WARNING.
-	(compiler-style-warning "declaring special variable ~S to be ignored"
-				name))
+	(compiler-style-warn "declaring special variable ~S to be ignored"
+			     name))
        ((eq (first spec) 'ignorable)
 	(setf (leaf-ever-used var) t))
        (t
@@ -985,71 +1081,51 @@
   #!+sb-doc
   "If true, processing of the VALUES declaration is inhibited.")
 
-;;; Process a single declaration spec, agumenting the specified LEXENV
-;;; Res and returning it as a result. Vars and Fvars are as described in
+;;; Process a single declaration spec, augmenting the specified LEXENV
+;;; RES and returning it as a result. VARS and FVARS are as described in
 ;;; PROCESS-DECLS.
-(defun process-1-declaration (spec res vars fvars cont)
-  (declare (list spec vars fvars) (type lexenv res) (type continuation cont))
-  (case (first spec)
-    (special (process-special-declaration spec res vars))
-    (ftype
-     (unless (cdr spec)
-       (compiler-error "No type specified in FTYPE declaration: ~S" spec))
-     (process-ftype-declaration (second spec) res (cddr spec) fvars))
-    (function
-     ;; Handle old style FUNCTION declaration, which is an abbreviation for
-     ;; FTYPE. Args are name, arglist, result type.
-     (cond ((and (proper-list-of-length-p spec 3 4)
-		 (listp (third spec)))
-	    (process-ftype-declaration `(function ,@(cddr spec)) res
-				       (list (second spec))
-				       fvars))
-	   (t
-	    (process-type-declaration spec res vars))))
-    ((inline notinline maybe-inline)
-     (process-inline-declaration spec res fvars))
-    ((ignore ignorable)
-     (process-ignore-declaration spec vars fvars)
-     res)
-    (optimize
-     (make-lexenv
-      :default res
-      :policy (process-optimize-declaration spec (lexenv-policy res))))
-    (optimize-interface
-     (make-lexenv
-      :default res
-      :interface-policy (process-optimize-declaration
-			 spec
-			 (lexenv-interface-policy res))))
-    (type
-     (process-type-declaration (cdr spec) res vars))
-    (values
-     (if *suppress-values-declaration*
-	 res
-	 (let ((types (cdr spec)))
-	   (do-the-stuff (if (eql (length types) 1)
-			     (car types)
-			     `(values ,@types))
-			 cont res 'values))))
-    (dynamic-extent
-     (when (policy nil (> speed inhibit-warnings))
-       (compiler-note
-	"The DYNAMIC-EXTENT declaration is not implemented (ignored)."))
-     res)
-    (t
-     (let ((what (first spec)))
-       (cond ((member what *standard-type-names*)
-	      (process-type-declaration spec res vars))
-	     ((and (not (and (symbolp what)
-			     (string= (symbol-name what) "CLASS"))) ; pcl hack
-		   (or (info :type :kind what)
-		       (and (consp what) (info :type :translator (car what)))))
-	      (process-type-declaration spec res vars))
-	     ((info :declaration :recognized what)
-	      res)
-	     (t
-	      (compiler-warning "unrecognized declaration ~S" spec)
-	      res))))))
+(defun process-1-decl (raw-spec res vars fvars cont)
+  (declare (type list raw-spec vars fvars))
+  (declare (type lexenv res))
+  (declare (type continuation cont))
+  (let ((spec (canonized-decl-spec raw-spec)))
+    (case (first spec)
+      (special (process-special-decl spec res vars))
+      (ftype
+       (unless (cdr spec)
+	 (compiler-error "no type specified in FTYPE declaration: ~S" spec))
+       (process-ftype-decl (second spec) res (cddr spec) fvars))
+      ((inline notinline maybe-inline)
+       (process-inline-decl spec res fvars))
+      ((ignore ignorable)
+       (process-ignore-decl spec vars fvars)
+       res)
+      (optimize
+       (make-lexenv
+	:default res
+	:policy (process-optimize-decl spec (lexenv-policy res))))
+      (type
+       (process-type-decl (cdr spec) res vars))
+      (values
+       (if *suppress-values-declaration*
+	   res
+	   (let ((types (cdr spec)))
+	     (ir1ize-the-or-values (if (eql (length types) 1)
+				       (car types)
+				       `(values ,@types))
+				   cont
+				   res
+				   'values))))
+      (dynamic-extent
+       (when (policy *lexenv* (> speed inhibit-warnings))
+	 (compiler-note
+	  "compiler limitation: ~
+        ~%  There's no special support for DYNAMIC-EXTENT (so it's ignored)."))
+       res)
+      (t
+       (unless (info :declaration :recognized (first spec))
+	 (compiler-warn "unrecognized declaration ~S" raw-spec))
+       res))))
 
 ;;; Use a list of DECLARE forms to annotate the lists of LAMBDA-VAR
 ;;; and FUNCTIONAL structures which are being bound. In addition to
@@ -1065,32 +1141,29 @@
   (dolist (decl decls)
     (dolist (spec (rest decl))
       (unless (consp spec)
-	(compiler-error "malformed declaration specifier ~S in ~S"
-			spec
-			decl))
-      (setq env (process-1-declaration spec env vars fvars cont))))
+	(compiler-error "malformed declaration specifier ~S in ~S" spec decl))
+      (setq env (process-1-decl spec env vars fvars cont))))
   env)
 
-;;; Return the Specvar for Name to use when we see a local SPECIAL
+;;; Return the SPECVAR for NAME to use when we see a local SPECIAL
 ;;; declaration. If there is a global variable of that name, then
 ;;; check that it isn't a constant and return it. Otherwise, create an
 ;;; anonymous GLOBAL-VAR.
 (defun specvar-for-binding (name)
   (cond ((not (eq (info :variable :where-from name) :assumed))
-	 (let ((found (find-free-variable name)))
+	 (let ((found (find-free-var name)))
 	   (when (heap-alien-info-p found)
 	     (compiler-error
 	      "~S is an alien variable and so can't be declared special."
 	      name))
-	   (when (or (not (global-var-p found))
-		     (eq (global-var-kind found) :constant))
+	   (unless (global-var-p found)
 	     (compiler-error
 	      "~S is a constant and so can't be declared special."
 	      name))
 	   found))
 	(t
 	 (make-global-var :kind :special
-			  :name name
+			  :%source-name name
 			  :where-from :declared))))
 
 ;;;; LAMBDA hackery
@@ -1099,78 +1172,78 @@
 ;;;; function representation" before you seriously mess with this
 ;;;; stuff.
 
-;;; Verify that a thing is a legal name for a variable and return a
-;;; Var structure for it, filling in info if it is globally special.
-;;; If it is losing, we punt with a Compiler-Error. Names-So-Far is an
-;;; alist of names which have previously been bound. If the name is in
+;;; Verify that the NAME is a legal name for a variable and return a
+;;; VAR structure for it, filling in info if it is globally special.
+;;; If it is losing, we punt with a COMPILER-ERROR. NAMES-SO-FAR is a
+;;; list of names which have previously been bound. If the NAME is in
 ;;; this list, then we error out.
 (declaim (ftype (function (t list) lambda-var) varify-lambda-arg))
 (defun varify-lambda-arg (name names-so-far)
   (declare (inline member))
   (unless (symbolp name)
-    (compiler-error "The lambda-variable ~S is not a symbol." name))
+    (compiler-error "The lambda variable ~S is not a symbol." name))
   (when (member name names-so-far :test #'eq)
-    (compiler-error "The variable ~S occurs more than once in the lambda-list."
+    (compiler-error "The variable ~S occurs more than once in the lambda list."
 		    name))
   (let ((kind (info :variable :kind name)))
     (when (or (keywordp name) (eq kind :constant))
-      (compiler-error "The name of the lambda-variable ~S is a constant."
+      (compiler-error "The name of the lambda variable ~S is already in use to name a constant."
 		      name))
     (cond ((eq kind :special)
-	   (let ((specvar (find-free-variable name)))
-	     (make-lambda-var :name name
+	   (let ((specvar (find-free-var name)))
+	     (make-lambda-var :%source-name name
 			      :type (leaf-type specvar)
 			      :where-from (leaf-where-from specvar)
 			      :specvar specvar)))
 	  (t
-	   (note-lexical-binding name)
-	   (make-lambda-var :name name)))))
+	   (make-lambda-var :%source-name name)))))
 
-;;; Make the keyword for a keyword arg, checking that the keyword
-;;; isn't already used by one of the Vars. We also check that the
-;;; keyword isn't the magical :allow-other-keys.
+;;; Make the default keyword for a &KEY arg, checking that the keyword
+;;; isn't already used by one of the VARS. We also check that the
+;;; keyword isn't the magical :ALLOW-OTHER-KEYS.
 (declaim (ftype (function (symbol list t) keyword) make-keyword-for-arg))
 (defun make-keyword-for-arg (symbol vars keywordify)
   (let ((key (if (and keywordify (not (keywordp symbol)))
-		 (intern (symbol-name symbol) "KEYWORD")
+		 (keywordicate symbol)
 		 symbol)))
     (when (eq key :allow-other-keys)
-      (compiler-error "No keyword arg can be called :ALLOW-OTHER-KEYS."))
+      (compiler-error "No &KEY arg can be called :ALLOW-OTHER-KEYS."))
     (dolist (var vars)
       (let ((info (lambda-var-arg-info var)))
 	(when (and info
 		   (eq (arg-info-kind info) :keyword)
-		   (eq (arg-info-keyword info) key))
+		   (eq (arg-info-key info) key))
 	  (compiler-error
-	   "The keyword ~S appears more than once in the lambda-list."
+	   "The keyword ~S appears more than once in the lambda list."
 	   key))))
     key))
 
-;;; Parse a lambda-list into a list of Var structures, stripping off
-;;; any aux bindings. Each arg name is checked for legality, and
+;;; Parse a lambda list into a list of VAR structures, stripping off
+;;; any &AUX bindings. Each arg name is checked for legality, and
 ;;; duplicate names are checked for. If an arg is globally special,
-;;; the var is marked as :special instead of :lexical. Keyword,
-;;; optional and rest args are annotated with an arg-info structure
+;;; the var is marked as :SPECIAL instead of :LEXICAL. &KEY,
+;;; &OPTIONAL and &REST args are annotated with an ARG-INFO structure
 ;;; which contains the extra information. If we hit something losing,
-;;; we bug out with Compiler-Error. These values are returned:
-;;;  1. A list of the var structures for each top-level argument.
-;;;  2. A flag indicating whether &key was specified.
-;;;  3. A flag indicating whether other keyword args are allowed.
-;;;  4. A list of the &aux variables.
-;;;  5. A list of the &aux values.
+;;; we bug out with COMPILER-ERROR. These values are returned:
+;;;  1. a list of the var structures for each top level argument;
+;;;  2. a flag indicating whether &KEY was specified;
+;;;  3. a flag indicating whether other &KEY args are allowed;
+;;;  4. a list of the &AUX variables; and
+;;;  5. a list of the &AUX values.
 (declaim (ftype (function (list) (values list boolean boolean list list))
-		find-lambda-vars))
-(defun find-lambda-vars (list)
-  (multiple-value-bind (required optional restp rest keyp keys allowp aux
+		make-lambda-vars))
+(defun make-lambda-vars (list)
+  (multiple-value-bind (required optional restp rest keyp keys allowp auxp aux
 			morep more-context more-count)
       (parse-lambda-list list)
+    (declare (ignore auxp)) ; since we just iterate over AUX regardless
     (collect ((vars)
 	      (names-so-far)
 	      (aux-vars)
 	      (aux-vals))
-      ;; Parse-Default deals with defaults and supplied-p args for optionals
-      ;; and keywords args.
-      (flet ((parse-default (spec info)
+      (flet (;; PARSE-DEFAULT deals with defaults and supplied-p args
+	     ;; for optionals and keywords args.
+	     (parse-default (spec info)
 	       (when (consp (cdr spec))
 		 (setf (arg-info-default info) (second spec))
 		 (when (consp (cddr spec))
@@ -1192,7 +1265,8 @@
 	(dolist (spec optional)
 	  (if (atom spec)
 	      (let ((var (varify-lambda-arg spec (names-so-far))))
-		(setf (lambda-var-arg-info var) (make-arg-info :kind :optional))
+		(setf (lambda-var-arg-info var)
+		      (make-arg-info :kind :optional))
 		(vars var)
 		(names-so-far spec))
 	      (let* ((name (first spec))
@@ -1227,9 +1301,9 @@
 	    (let ((var (varify-lambda-arg spec (names-so-far))))
 	      (setf (lambda-var-arg-info var)
 		    (make-arg-info :kind :keyword
-				   :keyword (make-keyword-for-arg spec
-								  (vars)
-								  t)))
+				   :key (make-keyword-for-arg spec
+							      (vars)
+							      t)))
 	      (vars var)
 	      (names-so-far spec)))
 	   ((atom (first spec))
@@ -1237,7 +1311,7 @@
 		   (var (varify-lambda-arg name (names-so-far)))
 		   (info (make-arg-info
 			  :kind :keyword
-			  :keyword (make-keyword-for-arg name (vars) t))))
+			  :key (make-keyword-for-arg name (vars) t))))
 	      (setf (lambda-var-arg-info var) info)
 	      (vars var)
 	      (names-so-far name)
@@ -1245,14 +1319,14 @@
 	   (t
 	    (let ((head (first spec)))
 	      (unless (proper-list-of-length-p head 2)
-		(error "malformed keyword arg specifier: ~S" spec))
+		(error "malformed &KEY argument specifier: ~S" spec))
 	      (let* ((name (second head))
 		     (var (varify-lambda-arg name (names-so-far)))
 		     (info (make-arg-info
 			    :kind :keyword
-			    :keyword (make-keyword-for-arg (first head)
-							   (vars)
-							   nil))))
+			    :key (make-keyword-for-arg (first head)
+						       (vars)
+						       nil))))
 		(setf (lambda-var-arg-info var) info)
 		(vars var)
 		(names-so-far name)
@@ -1281,25 +1355,24 @@
 ;;; converting the body. If there are no bindings, just convert the
 ;;; body, otherwise do one binding and recurse on the rest.
 ;;;
-;;; If INTERFACE is true, then we convert bindings with the interface
-;;; policy. For real &AUX bindings, and implicit aux bindings
-;;; introduced by keyword bindings, this is always true. It is only
-;;; false when LET* directly calls this function.
-(defun ir1-convert-aux-bindings (start cont body aux-vars aux-vals interface)
+;;; FIXME: This could and probably should be converted to use
+;;; SOURCE-NAME and DEBUG-NAME. But I (WHN) don't use &AUX bindings,
+;;; so I'm not motivated. Patches will be accepted...
+(defun ir1-convert-aux-bindings (start cont body aux-vars aux-vals)
   (declare (type continuation start cont) (list body aux-vars aux-vals))
   (if (null aux-vars)
       (ir1-convert-progn-body start cont body)
       (let ((fun-cont (make-continuation))
-	    (fun (ir1-convert-lambda-body body (list (first aux-vars))
-					  (rest aux-vars) (rest aux-vals)
-					  interface)))
+	    (fun (ir1-convert-lambda-body body
+					  (list (first aux-vars))
+					  :aux-vars (rest aux-vars)
+					  :aux-vals (rest aux-vals)
+					  :debug-name (debug-namify
+						       "&AUX bindings ~S"
+						       aux-vars))))
 	(reference-leaf start fun-cont fun)
-	(let ((*lexenv* (if interface
-			    (make-lexenv
-			     :policy (make-interface-policy *lexenv*))
-			    *lexenv*)))
-	  (ir1-convert-combination-args fun-cont cont
-					(list (first aux-vals))))))
+	(ir1-convert-combination-args fun-cont cont
+				      (list (first aux-vals)))))
   (values))
 
 ;;; This is similar to IR1-CONVERT-PROGN-BODY except that code to bind
@@ -1313,13 +1386,12 @@
 ;;; will end up being the innermost one. We force CONT to start a
 ;;; block outside of this cleanup, causing cleanup code to be emitted
 ;;; when the scope is exited.
-(defun ir1-convert-special-bindings (start cont body aux-vars aux-vals
-					   interface svars)
+(defun ir1-convert-special-bindings (start cont body aux-vars aux-vals svars)
   (declare (type continuation start cont)
 	   (list body aux-vars aux-vals svars))
   (cond
    ((null svars)
-    (ir1-convert-aux-bindings start cont body aux-vars aux-vals interface))
+    (ir1-convert-aux-bindings start cont body aux-vars aux-vals))
    (t
     (continuation-starts-block cont)
     (let ((cleanup (make-cleanup :kind :special-bind))
@@ -1332,14 +1404,14 @@
       (let ((*lexenv* (make-lexenv :cleanup cleanup)))
 	(ir1-convert next-cont nnext-cont '(%cleanup-point))
 	(ir1-convert-special-bindings nnext-cont cont body aux-vars aux-vals
-				      interface (rest svars))))))
+				      (rest svars))))))
   (values))
 
 ;;; Create a lambda node out of some code, returning the result. The
 ;;; bindings are specified by the list of VAR structures VARS. We deal
-;;; with adding the names to the LEXENV-VARIABLES for the conversion.
-;;; The result is added to the NEW-FUNCTIONS in the
-;;; *CURRENT-COMPONENT* and linked to the component head and tail.
+;;; with adding the names to the LEXENV-VARS for the conversion. The
+;;; result is added to the NEW-FUNCTIONALS in the *CURRENT-COMPONENT*
+;;; and linked to the component head and tail.
 ;;;
 ;;; We detect special bindings here, replacing the original VAR in the
 ;;; lambda list with a temporary variable. We then pass a list of the
@@ -1351,31 +1423,54 @@
 ;;;
 ;;; AUX-VARS is a list of VAR structures for variables that are to be
 ;;; sequentially bound. Each AUX-VAL is a form that is to be evaluated
-;;; to get the initial value for the corresponding AUX-VAR. Interface
-;;; is a flag as T when there are real aux values (see LET* and
-;;; IR1-CONVERT-AUX-BINDINGS.)
-(defun ir1-convert-lambda-body (body vars &optional aux-vars aux-vals
-				     interface result)
+;;; to get the initial value for the corresponding AUX-VAR. 
+(defun ir1-convert-lambda-body (body
+				vars
+				&key
+				aux-vars
+				aux-vals
+				result
+				(source-name '.anonymous.)
+				debug-name)
   (declare (list body vars aux-vars aux-vals)
 	   (type (or continuation null) result))
+
+  ;; We're about to try to put new blocks into *CURRENT-COMPONENT*.
+  (aver-live-component *current-component*)
+
   (let* ((bind (make-bind))
-	 (lambda (make-lambda :vars vars :bind bind))
+	 (lambda (make-lambda :vars vars
+			      :bind bind
+			      :%source-name source-name
+			      :%debug-name debug-name))
 	 (result (or result (make-continuation))))
+
+    ;; just to check: This function should fail internal assertions if
+    ;; we didn't set up a valid debug name above.
+    ;;
+    ;; (In SBCL we try to make everything have a debug name, since we
+    ;; lack the omniscient perspective the original implementors used
+    ;; to decide which things didn't need one.)
+    (functional-debug-name lambda)
+
     (setf (lambda-home lambda) lambda)
     (collect ((svars)
 	      (new-venv nil cons))
 
       (dolist (var vars)
+	;; As far as I can see, LAMBDA-VAR-HOME should never have
+	;; been set before. Let's make sure. -- WHN 2001-09-29
+	(aver (null (lambda-var-home var)))
 	(setf (lambda-var-home var) lambda)
 	(let ((specvar (lambda-var-specvar var)))
 	  (cond (specvar
 		 (svars var)
-		 (new-venv (cons (leaf-name specvar) specvar)))
+		 (new-venv (cons (leaf-source-name specvar) specvar)))
 		(t
-		 (note-lexical-binding (leaf-name var))
-		 (new-venv (cons (leaf-name var) var))))))
+		 (note-lexical-binding (leaf-source-name var))
+		 (new-venv (cons (leaf-source-name var) var))))))
 
-      (let ((*lexenv* (make-lexenv :variables (new-venv)
+      (let ((*lexenv* (make-lexenv :vars (new-venv)
 				   :lambda lambda
 				   :cleanup nil)))
 	(setf (bind-lambda bind) lambda)
@@ -1384,26 +1479,27 @@
 	(let ((cont1 (make-continuation))
 	      (cont2 (make-continuation)))
 	  (continuation-starts-block cont1)
-	  (prev-link bind cont1)
+	  (link-node-to-previous-continuation bind cont1)
 	  (use-continuation bind cont2)
-	  (ir1-convert-special-bindings cont2 result body aux-vars aux-vals
-					interface (svars)))
+	  (ir1-convert-special-bindings cont2 result body
+					aux-vars aux-vals (svars)))
 
 	(let ((block (continuation-block result)))
 	  (when block
 	    (let ((return (make-return :result result :lambda lambda))
-		  (tail-set (make-tail-set :functions (list lambda)))
+		  (tail-set (make-tail-set :funs (list lambda)))
 		  (dummy (make-continuation)))
 	      (setf (lambda-tail-set lambda) tail-set)
 	      (setf (lambda-return lambda) return)
 	      (setf (continuation-dest result) return)
 	      (setf (block-last block) return)
-	      (prev-link return result)
+	      (link-node-to-previous-continuation return result)
 	      (use-continuation return dummy))
 	    (link-blocks block (component-tail *current-component*))))))
 
     (link-blocks (component-head *current-component*) (node-block bind))
-    (push lambda (component-new-functions *current-component*))
+    (push lambda (component-new-functionals *current-component*))
+
     lambda))
 
 ;;; Create the actual entry-point function for an optional entry
@@ -1415,28 +1511,26 @@
 ;;; then we mark the corresponding var as EVER-USED to inhibit
 ;;; "defined but not read" warnings for arguments that are only used
 ;;; by default forms.
-;;;
-;;; We bind *LEXENV* to change the policy to the interface policy.
 (defun convert-optional-entry (fun vars vals defaults)
   (declare (type clambda fun) (list vars vals defaults))
   (let* ((fvars (reverse vars))
 	 (arg-vars (mapcar (lambda (var)
 			     (unless (lambda-var-specvar var)
-			       (note-lexical-binding (leaf-name var)))
+			       (note-lexical-binding (leaf-source-name var)))
 			     (make-lambda-var
-			      :name (leaf-name var)
+			      :%source-name (leaf-source-name var)
 			      :type (leaf-type var)
 			      :where-from (leaf-where-from var)
 			      :specvar (lambda-var-specvar var)))
 			   fvars))
-	 (*lexenv* (make-lexenv :policy (make-interface-policy *lexenv*)))
-	 (fun
-	  (ir1-convert-lambda-body
-	   `((%funcall ,fun ,@(reverse vals) ,@defaults))
-	   arg-vars)))
-    (mapc #'(lambda (var arg-var)
-	      (when (cdr (leaf-refs arg-var))
-		(setf (leaf-ever-used var) t)))
+	 (fun (ir1-convert-lambda-body `((%funcall ,fun
+						   ,@(reverse vals)
+						   ,@defaults))
+				       arg-vars
+				       :debug-name "&OPTIONAL processor")))
+    (mapc (lambda (var arg-var)
+	    (when (cdr (leaf-refs arg-var))
+	      (setf (leaf-ever-used var) t)))
 	  fvars arg-vars)
     fun))
 
@@ -1449,62 +1543,63 @@
 (defun generate-optional-default-entry (res default-vars default-vals
 					    entry-vars entry-vals
 					    vars supplied-p-p body
-					    aux-vars aux-vals cont)
+					    aux-vars aux-vals cont
+					    source-name debug-name)
   (declare (type optional-dispatch res)
 	   (list default-vars default-vals entry-vars entry-vals vars body
 		 aux-vars aux-vals)
 	   (type (or continuation null) cont))
   (let* ((arg (first vars))
-	 (arg-name (leaf-name arg))
+	 (arg-name (leaf-source-name arg))
 	 (info (lambda-var-arg-info arg))
 	 (supplied-p (arg-info-supplied-p info))
 	 (ep (if supplied-p
 		 (ir1-convert-hairy-args
 		  res
 		  (list* supplied-p arg default-vars)
-		  (list* (leaf-name supplied-p) arg-name default-vals)
+		  (list* (leaf-source-name supplied-p) arg-name default-vals)
 		  (cons arg entry-vars)
 		  (list* t arg-name entry-vals)
-		  (rest vars) t body aux-vars aux-vals cont)
+		  (rest vars) t body aux-vars aux-vals cont
+		  source-name debug-name)
 		 (ir1-convert-hairy-args
 		  res
 		  (cons arg default-vars)
 		  (cons arg-name default-vals)
 		  (cons arg entry-vars)
 		  (cons arg-name entry-vals)
-		  (rest vars) supplied-p-p body aux-vars aux-vals cont))))
+		  (rest vars) supplied-p-p body aux-vars aux-vals cont
+		  source-name debug-name))))
 
     (convert-optional-entry ep default-vars default-vals
 			    (if supplied-p
 				(list (arg-info-default info) nil)
 				(list (arg-info-default info))))))
 
-;;; Create the More-Entry function for the Optional-Dispatch Res.
-;;; Entry-Vars and Entry-Vals describe the fixed arguments. Rest is the var
-;;; for any Rest arg. Keys is a list of the keyword arg vars.
+;;; Create the MORE-ENTRY function for the OPTIONAL-DISPATCH RES.
+;;; ENTRY-VARS and ENTRY-VALS describe the fixed arguments. REST is
+;;; the var for any &REST arg. KEYS is a list of the &KEY arg vars.
 ;;;
-;;; The most interesting thing that we do is parse keywords. We create a
-;;; bunch of temporary variables to hold the result of the parse, and then loop
-;;; over the supplied arguments, setting the appropriate temps for the supplied
-;;; keyword. Note that it is significant that we iterate over the keywords in
-;;; reverse order --- this implements the CL requirement that (when a keyword
-;;; appears more than once) the first value is used.
+;;; The most interesting thing that we do is parse keywords. We create
+;;; a bunch of temporary variables to hold the result of the parse,
+;;; and then loop over the supplied arguments, setting the appropriate
+;;; temps for the supplied keyword. Note that it is significant that
+;;; we iterate over the keywords in reverse order --- this implements
+;;; the CL requirement that (when a keyword appears more than once)
+;;; the first value is used.
 ;;;
 ;;; If there is no supplied-p var, then we initialize the temp to the
-;;; default and just pass the temp into the main entry. Since non-constant
-;;; keyword args are forcibly given a supplied-p var, we know that the default
-;;; is constant, and thus safe to evaluate out of order.
-;;;
-;;; If there is a supplied-p var, then we create temps for both the value
-;;; and the supplied-p, and pass them into the main entry, letting it worry
-;;; about defaulting.
+;;; default and just pass the temp into the main entry. Since
+;;; non-constant &KEY args are forcibly given a supplied-p var, we
+;;; know that the default is constant, and thus safe to evaluate out
+;;; of order.
 ;;;
-;;; We deal with :allow-other-keys by delaying unknown keyword errors until
-;;; we have scanned all the keywords.
+;;; If there is a supplied-p var, then we create temps for both the
+;;; value and the supplied-p, and pass them into the main entry,
+;;; letting it worry about defaulting.
 ;;;
-;;; When converting the function, we bind *LEXENV* to change the
-;;; compilation policy over to the interface policy, so that keyword
-;;; args will be checked even when type checking isn't on in general.
+;;; We deal with :ALLOW-OTHER-KEYS by delaying unknown keyword errors
+;;; until we have scanned all the keywords.
 (defun convert-more-entry (res entry-vars entry-vals rest morep keys)
   (declare (type optional-dispatch res) (list entry-vars entry-vals keys))
   (collect ((arg-vars)
@@ -1513,16 +1608,15 @@
 	    (body))
 
     (dolist (var (reverse entry-vars))
-      (arg-vars (make-lambda-var :name (leaf-name var)
+      (arg-vars (make-lambda-var :%source-name (leaf-source-name var)
 				 :type (leaf-type var)
 				 :where-from (leaf-where-from var))))
 
     (let* ((n-context (gensym "N-CONTEXT-"))
-	   (context-temp (make-lambda-var :name n-context))
+	   (context-temp (make-lambda-var :%source-name n-context))
 	   (n-count (gensym "N-COUNT-"))
-	   (count-temp (make-lambda-var :name n-count
-					:type (specifier-type 'index)))
-	   (*lexenv* (make-lexenv :policy (make-interface-policy *lexenv*))))
+	   (count-temp (make-lambda-var :%source-name n-count
+					:type (specifier-type 'index))))
 
       (arg-vars context-temp count-temp)
 
@@ -1539,7 +1633,7 @@
 	      (n-allowp (gensym "N-ALLOWP-"))
 	      (n-losep (gensym "N-LOSEP-"))
 	      (allowp (or (optional-dispatch-allowp res)
-			  (policy nil (zerop safety)))))
+			  (policy *lexenv* (zerop safety)))))
 
 	  (temps `(,n-index (1- ,n-count)) n-key n-value-temp)
 	  (body `(declare (fixnum ,n-index) (ignorable ,n-key ,n-value-temp)))
@@ -1548,7 +1642,7 @@
 	    (dolist (key keys)
 	      (let* ((info (lambda-var-arg-info key))
 		     (default (arg-info-default info))
-		     (keyword (arg-info-keyword info))
+		     (keyword (arg-info-key info))
 		     (supplied-p (arg-info-supplied-p info))
 		     (n-value (gensym "N-VALUE-")))
 		(temps `(,n-value ,default))
@@ -1573,7 +1667,7 @@
 
 	    (body
 	     `(when (oddp ,n-count)
-		(%odd-keyword-arguments-error)))
+		(%odd-key-args-error)))
 
 	    (body
 	     `(locally
@@ -1588,29 +1682,30 @@
 
 	    (unless allowp
 	      (body `(when (and ,n-losep (not ,n-allowp))
-		       (%unknown-keyword-argument-error ,n-losep)))))))
+		       (%unknown-key-arg-error ,n-losep)))))))
 
       (let ((ep (ir1-convert-lambda-body
 		 `((let ,(temps)
 		     ,@(body)
 		     (%funcall ,(optional-dispatch-main-entry res)
 			       . ,(arg-vals)))) ; FIXME: What is the '.'? ,@?
-		 (arg-vars))))
+		 (arg-vars)
+		 :debug-name (debug-namify "~S processing" '&more))))
 	(setf (optional-dispatch-more-entry res) ep))))
 
   (values))
 
-;;; Called by IR1-Convert-Hairy-Args when we run into a rest or
-;;; keyword arg. The arguments are similar to that function, but we
-;;; split off any rest arg and pass it in separately. Rest is the rest
-;;; arg var, or NIL if there is no rest arg. Keys is a list of the
-;;; keyword argument vars.
+;;; This is called by IR1-CONVERT-HAIRY-ARGS when we run into a &REST
+;;; or &KEY arg. The arguments are similar to that function, but we
+;;; split off any &REST arg and pass it in separately. REST is the
+;;; &REST arg var, or NIL if there is no &REST arg. KEYS is a list of
+;;; the &KEY argument vars.
 ;;;
-;;; When there are keyword arguments, we introduce temporary gensym
+;;; When there are &KEY arguments, we introduce temporary gensym
 ;;; variables to hold the values while keyword defaulting is in
 ;;; progress to get the required sequential binding semantics.
 ;;;
-;;; This gets interesting mainly when there are keyword arguments with
+;;; This gets interesting mainly when there are &KEY arguments with
 ;;; supplied-p vars or non-constant defaults. In either case, pass in
 ;;; a supplied-p var. If the default is non-constant, we introduce an
 ;;; IF in the main entry that tests the supplied-p var and decides
@@ -1619,7 +1714,8 @@
 ;;; type when computing the type for the main entry's argument.
 (defun ir1-convert-more (res default-vars default-vals entry-vars entry-vals
 			     rest more-context more-count keys supplied-p-p
-			     body aux-vars aux-vals cont)
+			     body aux-vars aux-vals cont
+			     source-name debug-name)
   (declare (type optional-dispatch res)
 	   (list default-vars default-vals entry-vars entry-vals keys body
 		 aux-vars aux-vals)
@@ -1644,10 +1740,10 @@
 	     (supplied-p (arg-info-supplied-p info))
 	     (n-val (make-symbol (format nil
 					 "~A-DEFAULTING-TEMP"
-					 (leaf-name key))))
+					 (leaf-source-name key))))
 	     (key-type (leaf-type key))
 	     (val-temp (make-lambda-var
-			:name n-val
+			:%source-name n-val
 			:type (if hairy-default
 				  (type-union key-type (specifier-type 'null))
 				  key-type))))
@@ -1655,7 +1751,8 @@
 	(bind-vars key)
 	(cond ((or hairy-default supplied-p)
 	       (let* ((n-supplied (gensym "N-SUPPLIED-"))
-		      (supplied-temp (make-lambda-var :name n-supplied)))
+		      (supplied-temp (make-lambda-var
+				      :%source-name n-supplied)))
 		 (unless supplied-p
 		   (setf (arg-info-supplied-p info) supplied-temp))
 		 (when hairy-default
@@ -1674,11 +1771,14 @@
 	       (main-vals (arg-info-default info))
 	       (bind-vals n-val)))))
 
-    (let* ((main-entry (ir1-convert-lambda-body body (main-vars)
-						(append (bind-vars) aux-vars)
-						(append (bind-vals) aux-vals)
-						t
-						cont))
+    (let* ((main-entry (ir1-convert-lambda-body
+			body (main-vars)
+			:aux-vars (append (bind-vars) aux-vars)
+			:aux-vals (append (bind-vals) aux-vals)
+			:result cont
+			:debug-name (debug-namify "varargs entry for ~A"
+						  (as-debug-name source-name
+								 debug-name))))
 	   (last-entry (convert-optional-entry main-entry default-vars
 					       (main-vals) ())))
       (setf (optional-dispatch-main-entry res) main-entry)
@@ -1691,110 +1791,131 @@
       last-entry)))
 
 ;;; This function generates the entry point functions for the
-;;; optional-dispatch Res. We accomplish this by recursion on the list of
-;;; arguments, analyzing the arglist on the way down and generating entry
-;;; points on the way up.
+;;; OPTIONAL-DISPATCH RES. We accomplish this by recursion on the list
+;;; of arguments, analyzing the arglist on the way down and generating
+;;; entry points on the way up.
 ;;;
-;;; Default-Vars is a reversed list of all the argument vars processed so
-;;; far, including supplied-p vars. Default-Vals is a list of the names of the
-;;; Default-Vars.
+;;; DEFAULT-VARS is a reversed list of all the argument vars processed
+;;; so far, including supplied-p vars. DEFAULT-VALS is a list of the
+;;; names of the DEFAULT-VARS.
 ;;;
-;;; Entry-Vars is a reversed list of processed argument vars, excluding
-;;; supplied-p vars. Entry-Vals is a list things that can be evaluated to get
-;;; the values for all the vars from the Entry-Vars. It has the var name for
-;;; each required or optional arg, and has T for each supplied-p arg.
+;;; ENTRY-VARS is a reversed list of processed argument vars,
+;;; excluding supplied-p vars. ENTRY-VALS is a list things that can be
+;;; evaluated to get the values for all the vars from the ENTRY-VARS.
+;;; It has the var name for each required or optional arg, and has T
+;;; for each supplied-p arg.
 ;;;
-;;; Vars is a list of the Lambda-Var structures for arguments that haven't
-;;; been processed yet. Supplied-p-p is true if a supplied-p argument has
-;;; already been processed; only in this case are the Default-XXX and Entry-XXX
-;;; different.
+;;; VARS is a list of the LAMBDA-VAR structures for arguments that
+;;; haven't been processed yet. SUPPLIED-P-P is true if a supplied-p
+;;; argument has already been processed; only in this case are the
+;;; DEFAULT-XXX and ENTRY-XXX different.
 ;;;
-;;; The result at each point is a lambda which should be called by the above
-;;; level to default the remaining arguments and evaluate the body. We cause
-;;; the body to be evaluated by converting it and returning it as the result
-;;; when the recursion bottoms out.
+;;; The result at each point is a lambda which should be called by the
+;;; above level to default the remaining arguments and evaluate the
+;;; body. We cause the body to be evaluated by converting it and
+;;; returning it as the result when the recursion bottoms out.
 ;;;
-;;; Each level in the recursion also adds its entry point function to the
-;;; result Optional-Dispatch. For most arguments, the defaulting function and
-;;; the entry point function will be the same, but when supplied-p args are
-;;; present they may be different.
+;;; Each level in the recursion also adds its entry point function to
+;;; the result OPTIONAL-DISPATCH. For most arguments, the defaulting
+;;; function and the entry point function will be the same, but when
+;;; SUPPLIED-P args are present they may be different.
 ;;;
-;;; When we run into a rest or keyword arg, we punt out to
-;;; IR1-Convert-More, which finishes for us in this case.
+;;; When we run into a &REST or &KEY arg, we punt out to
+;;; IR1-CONVERT-MORE, which finishes for us in this case.
 (defun ir1-convert-hairy-args (res default-vars default-vals
-				   entry-vars entry-vals
-				   vars supplied-p-p body aux-vars
-				   aux-vals cont)
+                                   entry-vars entry-vals
+                                   vars supplied-p-p body aux-vars
+                                   aux-vals cont
+				   source-name debug-name)
   (declare (type optional-dispatch res)
-	   (list default-vars default-vals entry-vars entry-vals vars body
-		 aux-vars aux-vals)
-	   (type (or continuation null) cont))
+           (list default-vars default-vals entry-vars entry-vals vars body
+                 aux-vars aux-vals)
+           (type (or continuation null) cont))
   (cond ((not vars)
-	 (if (optional-dispatch-keyp res)
-	     ;; Handle &KEY with no keys...
-	     (ir1-convert-more res default-vars default-vals
-			       entry-vars entry-vals
-			       nil nil nil vars supplied-p-p body aux-vars
-			       aux-vals cont)
-	     (let ((fun (ir1-convert-lambda-body body (reverse default-vars)
-						 aux-vars aux-vals t cont)))
-	       (setf (optional-dispatch-main-entry res) fun)
-	       (push (if supplied-p-p
-			 (convert-optional-entry fun entry-vars entry-vals ())
-			 fun)
-		     (optional-dispatch-entry-points res))
-	       fun)))
-	((not (lambda-var-arg-info (first vars)))
-	 (let* ((arg (first vars))
-		(nvars (cons arg default-vars))
-		(nvals (cons (leaf-name arg) default-vals)))
-	   (ir1-convert-hairy-args res nvars nvals nvars nvals
-				   (rest vars) nil body aux-vars aux-vals
-				   cont)))
-	(t
-	 (let* ((arg (first vars))
-		(info (lambda-var-arg-info arg))
-		(kind (arg-info-kind info)))
-	   (ecase kind
-	     (:optional
-	      (let ((ep (generate-optional-default-entry
-			 res default-vars default-vals
-			 entry-vars entry-vals vars supplied-p-p body
-			 aux-vars aux-vals cont)))
-		(push (if supplied-p-p
-			  (convert-optional-entry ep entry-vars entry-vals ())
-			  ep)
-		      (optional-dispatch-entry-points res))
-		ep))
-	     (:rest
-	      (ir1-convert-more res default-vars default-vals
-				entry-vars entry-vals
-				arg nil nil (rest vars) supplied-p-p body
-				aux-vars aux-vals cont))
-	     (:more-context
-	      (ir1-convert-more res default-vars default-vals
-				entry-vars entry-vals
-				nil arg (second vars) (cddr vars) supplied-p-p
-				body aux-vars aux-vals cont))
-	     (:keyword
-	      (ir1-convert-more res default-vars default-vals
-				entry-vars entry-vals
-				nil nil nil vars supplied-p-p body aux-vars
-				aux-vals cont)))))))
+         (if (optional-dispatch-keyp res)
+             ;; Handle &KEY with no keys...
+             (ir1-convert-more res default-vars default-vals
+                               entry-vars entry-vals
+                               nil nil nil vars supplied-p-p body aux-vars
+                               aux-vals cont source-name debug-name)
+             (let ((fun (ir1-convert-lambda-body
+			 body (reverse default-vars)
+			 :aux-vars aux-vars
+			 :aux-vals aux-vals
+			 :result cont
+			 :debug-name (debug-namify
+				      "hairy arg processor for ~A"
+				      (as-debug-name source-name
+						     debug-name)))))
+               (setf (optional-dispatch-main-entry res) fun)
+               (push (if supplied-p-p
+                         (convert-optional-entry fun entry-vars entry-vals ())
+                         fun)
+                     (optional-dispatch-entry-points res))
+               fun)))
+        ((not (lambda-var-arg-info (first vars)))
+         (let* ((arg (first vars))
+                (nvars (cons arg default-vars))
+                (nvals (cons (leaf-source-name arg) default-vals)))
+           (ir1-convert-hairy-args res nvars nvals nvars nvals
+                                   (rest vars) nil body aux-vars aux-vals
+                                   cont
+				   source-name debug-name)))
+        (t
+         (let* ((arg (first vars))
+                (info (lambda-var-arg-info arg))
+                (kind (arg-info-kind info)))
+           (ecase kind
+             (:optional
+              (let ((ep (generate-optional-default-entry
+                         res default-vars default-vals
+                         entry-vars entry-vals vars supplied-p-p body
+                         aux-vars aux-vals cont
+			 source-name debug-name)))
+                (push (if supplied-p-p
+                          (convert-optional-entry ep entry-vars entry-vals ())
+                          ep)
+                      (optional-dispatch-entry-points res))
+                ep))
+             (:rest
+              (ir1-convert-more res default-vars default-vals
+                                entry-vars entry-vals
+                                arg nil nil (rest vars) supplied-p-p body
+                                aux-vars aux-vals cont
+				source-name debug-name))
+             (:more-context
+              (ir1-convert-more res default-vars default-vals
+                                entry-vars entry-vals
+                                nil arg (second vars) (cddr vars) supplied-p-p
+                                body aux-vars aux-vals cont
+				source-name debug-name))
+             (:keyword
+              (ir1-convert-more res default-vars default-vals
+                                entry-vars entry-vals
+                                nil nil nil vars supplied-p-p body aux-vars
+                                aux-vals cont source-name debug-name)))))))
 
 ;;; This function deals with the case where we have to make an
-;;; Optional-Dispatch to represent a lambda. We cons up the result and call
-;;; IR1-Convert-Hairy-Args to do the work. When it is done, we figure out the
-;;; min-args and max-args.
-(defun ir1-convert-hairy-lambda (body vars keyp allowp aux-vars aux-vals cont)
+;;; OPTIONAL-DISPATCH to represent a LAMBDA. We cons up the result and
+;;; call IR1-CONVERT-HAIRY-ARGS to do the work. When it is done, we
+;;; figure out the MIN-ARGS and MAX-ARGS.
+(defun ir1-convert-hairy-lambda (body vars keyp allowp aux-vars aux-vals cont
+				      &key
+				      (source-name '.anonymous.)
+				      (debug-name (debug-namify
+						   "OPTIONAL-DISPATCH ~S"
+						   vars)))
   (declare (list body vars aux-vars aux-vals) (type continuation cont))
   (let ((res (make-optional-dispatch :arglist vars
 				     :allowp allowp
-				     :keyp keyp))
+				     :keyp keyp
+				     :%source-name source-name
+				     :%debug-name debug-name))
 	(min (or (position-if #'lambda-var-arg-info vars) (length vars))))
-    (push res (component-new-functions *current-component*))
+    (aver-live-component *current-component*)
+    (push res (component-new-functionals *current-component*))
     (ir1-convert-hairy-args res () () () () vars nil body aux-vars aux-vals
-			    cont)
+			    cont source-name debug-name)
     (setf (optional-dispatch-min-args res) min)
     (setf (optional-dispatch-max-args res)
 	  (+ (1- (length (optional-dispatch-entry-points res))) min))
@@ -1810,8 +1931,9 @@
 
     res))
 
-;;; Convert a Lambda into a Lambda or Optional-Dispatch leaf.
-(defun ir1-convert-lambda (form &optional name)
+;;; Convert a LAMBDA form into a LAMBDA leaf or an OPTIONAL-DISPATCH leaf.
+(defun ir1-convert-lambda (form &key (source-name '.anonymous.) debug-name)
+
   (unless (consp form)
     (compiler-error "A ~S was found when expecting a lambda expression:~%  ~S"
 		    (type-of form)
@@ -1823,1388 +1945,185 @@
 		    form))
   (unless (and (consp (cdr form)) (listp (cadr form)))
     (compiler-error
-     "The lambda expression has a missing or non-list lambda-list:~%  ~S"
+     "The lambda expression has a missing or non-list lambda list:~%  ~S"
      form))
 
   (multiple-value-bind (vars keyp allow-other-keys aux-vars aux-vals)
-      (find-lambda-vars (cadr form))
-    (multiple-value-bind (forms decls) (sb!sys:parse-body (cddr form))
-      (let* ((cont (make-continuation))
+      (make-lambda-vars (cadr form))
+    (multiple-value-bind (forms decls) (parse-body (cddr form))
+      (let* ((result-cont (make-continuation))
 	     (*lexenv* (process-decls decls
 				      (append aux-vars vars)
-				      nil cont))
+				      nil result-cont))
 	     (res (if (or (find-if #'lambda-var-arg-info vars) keyp)
 		      (ir1-convert-hairy-lambda forms vars keyp
 						allow-other-keys
-						aux-vars aux-vals cont)
-		      (ir1-convert-lambda-body forms vars aux-vars aux-vals
-					       t cont))))
+						aux-vars aux-vals result-cont
+						:source-name source-name
+						:debug-name debug-name)
+		      (ir1-convert-lambda-body forms vars
+					       :aux-vars aux-vars
+					       :aux-vals aux-vals
+					       :result result-cont
+					       :source-name source-name
+					       :debug-name debug-name))))
 	(setf (functional-inline-expansion res) form)
 	(setf (functional-arg-documentation res) (cadr form))
-	(setf (leaf-name res) name)
 	res))))
 
-;;; FIXME: This file is rather long, and contains two distinct sections,
-;;; transform machinery above this point and transforms themselves below this
-;;; point. Why not split it in two? (ir1translate.lisp and
-;;; ir1translators.lisp?) Then consider byte-compiling the translators, too.
-
-;;;; control special forms
-
-(def-ir1-translator progn ((&rest forms) start cont)
-  #!+sb-doc
-  "Progn Form*
-  Evaluates each Form in order, returning the values of the last form. With no
-  forms, returns NIL."
-  (ir1-convert-progn-body start cont forms))
-
-(def-ir1-translator if ((test then &optional else) start cont)
-  #!+sb-doc
-  "If Predicate Then [Else]
-  If Predicate evaluates to non-null, evaluate Then and returns its values,
-  otherwise evaluate Else and return its values. Else defaults to NIL."
-  (let* ((pred (make-continuation))
-	 (then-cont (make-continuation))
-	 (then-block (continuation-starts-block then-cont))
-	 (else-cont (make-continuation))
-	 (else-block (continuation-starts-block else-cont))
-	 (dummy-cont (make-continuation))
-	 (node (make-if :test pred
-			:consequent then-block
-			:alternative else-block)))
-    (setf (continuation-dest pred) node)
-    (ir1-convert start pred test)
-    (prev-link node pred)
-    (use-continuation node dummy-cont)
-
-    (let ((start-block (continuation-block pred)))
-      (setf (block-last start-block) node)
-      (continuation-starts-block cont)
-
-      (link-blocks start-block then-block)
-      (link-blocks start-block else-block)
-
-      (ir1-convert then-cont cont then)
-      (ir1-convert else-cont cont else))))
-
-;;;; BLOCK and TAGBODY
-
-;;;; We make an Entry node to mark the start and a :Entry cleanup to
-;;;; mark its extent. When doing GO or RETURN-FROM, we emit an Exit
-;;;; node.
-
-;;; Make a :entry cleanup and emit an Entry node, then convert the
-;;; body in the modified environment. We make Cont start a block now,
-;;; since if it was done later, the block would be in the wrong
-;;; environment.
-(def-ir1-translator block ((name &rest forms) start cont)
-  #!+sb-doc
-  "Block Name Form*
-  Evaluate the Forms as a PROGN. Within the lexical scope of the body,
-  (RETURN-FROM Name Value-Form) can be used to exit the form, returning the
-  result of Value-Form."
-  (unless (symbolp name)
-    (compiler-error "The block name ~S is not a symbol." name))
-  (continuation-starts-block cont)
-  (let* ((dummy (make-continuation))
-	 (entry (make-entry))
-	 (cleanup (make-cleanup :kind :block
-				:mess-up entry)))
-    (push entry (lambda-entries (lexenv-lambda *lexenv*)))
-    (setf (entry-cleanup entry) cleanup)
-    (prev-link entry start)
-    (use-continuation entry dummy)
-    
-    (let* ((env-entry (list entry cont))
-           (*lexenv* (make-lexenv :blocks (list (cons name env-entry))
-				  :cleanup cleanup)))
-      (push env-entry (continuation-lexenv-uses cont))
-      (ir1-convert-progn-body dummy cont forms))))
-
-
-;;; We make Cont start a block just so that it will have a block
-;;; assigned. People assume that when they pass a continuation into
-;;; IR1-Convert as Cont, it will have a block when it is done.
-(def-ir1-translator return-from ((name &optional value)
-				 start cont)
-  #!+sb-doc
-  "Return-From Block-Name Value-Form
-  Evaluate the Value-Form, returning its values from the lexically enclosing
-  BLOCK Block-Name. This is constrained to be used only within the dynamic
-  extent of the BLOCK."
-  (continuation-starts-block cont)
-  (let* ((found (or (lexenv-find name blocks)
-		    (compiler-error "return for unknown block: ~S" name)))
-	 (value-cont (make-continuation))
-	 (entry (first found))
-	 (exit (make-exit :entry entry
-			  :value value-cont)))
-    (push exit (entry-exits entry))
-    (setf (continuation-dest value-cont) exit)
-    (ir1-convert start value-cont value)
-    (prev-link exit value-cont)
-    (use-continuation exit (second found))))
-
-;;; Return a list of the segments of a tagbody. Each segment looks
-;;; like (<tag> <form>* (go <next tag>)). That is, we break up the
-;;; tagbody into segments of non-tag statements, and explicitly
-;;; represent the drop-through with a GO. The first segment has a
-;;; dummy NIL tag, since it represents code before the first tag. The
-;;; last segment (which may also be the first segment) ends in NIL
-;;; rather than a GO.
-(defun parse-tagbody (body)
-  (declare (list body))
-  (collect ((segments))
-    (let ((current (cons nil body)))
-      (loop
-	(let ((tag-pos (position-if-not #'listp current :start 1)))
-	  (unless tag-pos
-	    (segments `(,@current nil))
-	    (return))
-	  (let ((tag (elt current tag-pos)))
-	    (when (assoc tag (segments))
-	      (compiler-error
-	       "The tag ~S appears more than once in the tagbody."
-	       tag))
-	    (unless (or (symbolp tag) (integerp tag))
-	      (compiler-error "~S is not a legal tagbody statement." tag))
-	    (segments `(,@(subseq current 0 tag-pos) (go ,tag))))
-	  (setq current (nthcdr tag-pos current)))))
-    (segments)))
-
-;;; Set up the cleanup, emitting the entry node. Then make a block for
-;;; each tag, building up the tag list for LEXENV-TAGS as we go.
-;;; Finally, convert each segment with the precomputed Start and Cont
-;;; values.
-(def-ir1-translator tagbody ((&rest statements) start cont)
-  #!+sb-doc
-  "Tagbody {Tag | Statement}*
-  Define tags for used with GO. The Statements are evaluated in order
-  (skipping Tags) and NIL is returned. If a statement contains a GO to a
-  defined Tag within the lexical scope of the form, then control is transferred
-  to the next statement following that tag. A Tag must an integer or a
-  symbol. A statement must be a list. Other objects are illegal within the
-  body."
-  (continuation-starts-block cont)
-  (let* ((dummy (make-continuation))
-	 (entry (make-entry))
-	 (segments (parse-tagbody statements))
-	 (cleanup (make-cleanup :kind :tagbody
-				:mess-up entry)))
-    (push entry (lambda-entries (lexenv-lambda *lexenv*)))
-    (setf (entry-cleanup entry) cleanup)
-    (prev-link entry start)
-    (use-continuation entry dummy)
-
-    (collect ((tags)
-	      (starts)
-	      (conts))
-      (starts dummy)
-      (dolist (segment (rest segments))
-	(let* ((tag-cont (make-continuation))
-               (tag (list (car segment) entry tag-cont)))          
-	  (conts tag-cont)
-	  (starts tag-cont)
-	  (continuation-starts-block tag-cont)
-          (tags tag)
-          (push (cdr tag) (continuation-lexenv-uses tag-cont))))
-      (conts cont)
-
-      (let ((*lexenv* (make-lexenv :cleanup cleanup :tags (tags))))
-	(mapc #'(lambda (segment start cont)
-		  (ir1-convert-progn-body start cont (rest segment)))
-	      segments (starts) (conts))))))
-
-;;; Emit an Exit node without any value.
-(def-ir1-translator go ((tag) start cont)
-  #!+sb-doc
-  "Go Tag
-  Transfer control to the named Tag in the lexically enclosing TAGBODY. This
-  is constrained to be used only within the dynamic extent of the TAGBODY."
-  (continuation-starts-block cont)
-  (let* ((found (or (lexenv-find tag tags :test #'eql)
-		    (compiler-error "Go to nonexistent tag: ~S." tag)))
-	 (entry (first found))
-	 (exit (make-exit :entry entry)))
-    (push exit (entry-exits entry))
-    (prev-link exit start)
-    (use-continuation exit (second found))))
-
-;;;; translators for compiler-magic special forms
-
-;;; Do stuff to do an EVAL-WHEN. This is split off from the IR1
-;;; convert method so that it can be shared by the special-case
-;;; top-level form processing code. We play with the dynamic
-;;; environment and eval stuff, then call Fun with a list of forms to
-;;; be processed at load time.
-;;;
-;;; Note: the EVAL situation is always ignored: this is conceptually a
-;;; compile-only implementation.
-;;;
-;;; We have to interact with the interpreter to ensure that the forms
-;;; get EVAL'ed exactly once. We bind *ALREADY-EVALED-THIS* to true to
-;;; inhibit evaluation of any enclosed EVAL-WHENs, either by IR1
-;;; conversion done by EVAL, or by conversion of the body for
-;;; load-time processing. If *ALREADY-EVALED-THIS* is true then we *do
-;;; not* EVAL since some enclosing EVAL-WHEN already did.
-;;;
-;;; We know we are EVAL'ing for LOAD since we wouldn't get called
-;;; otherwise. If LOAD is a situation we call FUN on body. If we
-;;; aren't evaluating for LOAD, then we call FUN on NIL for the result
-;;; of the EVAL-WHEN.
-(defun do-eval-when-stuff (situations body fun)
-
-  (when (or (not (listp situations))
-	    (set-difference situations
-			    '(compile load eval
-			      :compile-toplevel :load-toplevel :execute)))
-    (compiler-error "bad EVAL-WHEN situation list: ~S" situations))
-
-  (let ((deprecated-names (intersection situations '(compile load eval))))
-    (when deprecated-names
-      (style-warn "using deprecated EVAL-WHEN situation names ~S"
-		  deprecated-names)))
-
-  (let* ((do-eval (and (intersection '(compile :compile-toplevel) situations)
-		       (not sb!eval::*already-evaled-this*)))
-	 (sb!eval::*already-evaled-this* t))
-    (when do-eval
-
-      ;; This is the natural way to do it.
-      #-(and sb-xc-host (or sbcl cmu))
-      (eval `(progn ,@body))
-
-      ;; This is a disgusting hack to work around bug IR1-3 when using
-      ;; SBCL (or CMU CL, for that matter) as a cross-compilation
-      ;; host. When we go from the cross-compiler (where we bound
-      ;; SB!EVAL::*ALREADY-EVALED-THIS*) to the host compiler (which
-      ;; has a separate SB-EVAL::*ALREADY-EVALED-THIS* variable), EVAL
-      ;; would go and execute nested EVAL-WHENs even when they're not
-      ;; toplevel forms. Using EVAL-WHEN instead of bare EVAL causes
-      ;; the cross-compilation host to bind its own
-      ;; *ALREADY-EVALED-THIS* variable, so that the problem is
-      ;; suppressed.
-      ;;
-      ;; FIXME: Once bug IR1-3 is fixed, this hack can go away. (Or if
-      ;; CMU CL doesn't fix the bug, then this hack can be made
-      ;; conditional on #+CMU.)
-      #+(and sb-xc-host (or sbcl cmu))
-      (let (#+sbcl (sb-eval::*already-evaled-this* t)
-	    #+cmu (common-lisp::*already-evaled-this* t))
-	(eval `(eval-when (:compile-toplevel :load-toplevel :execute)
-		 ,@body))))
-
-    (if (or (intersection '(:load-toplevel load) situations)
-	    (and *converting-for-interpreter*
-		 (intersection '(:execute eval) situations)))
-	(funcall fun body)
-	(funcall fun '(nil)))))
-
-(def-ir1-translator eval-when ((situations &rest body) start cont)
-  #!+sb-doc
-  "EVAL-WHEN (Situation*) Form*
-  Evaluate the Forms in the specified Situations, any of COMPILE, LOAD, EVAL.
-  This is conceptually a compile-only implementation, so EVAL is a no-op."
-
-  ;; It's difficult to handle EVAL-WHENs completely correctly in the
-  ;; cross-compiler. (Common Lisp is not a cross-compiler-friendly
-  ;; language..) Since we, the system implementors, control not only
-  ;; the cross-compiler but also the code that it processes, we can
-  ;; handle this either by making the cross-compiler smarter about
-  ;; handling EVAL-WHENs (hard) or by avoiding the use of difficult
-  ;; EVAL-WHEN constructs (relatively easy). However, since EVAL-WHENs
-  ;; can be generated by many macro expansions, it's not always easy
-  ;; to detect problems by skimming the source code, so we'll try to
-  ;; add some code here to help out.
-  ;;
-  ;; Nested EVAL-WHENs are tricky.
-  #+sb-xc-host
-  (labels ((contains-toplevel-eval-when-p (body-part)
-	     (and (consp body-part)
-		  (or (eq (first body-part) 'eval-when)
-		      (and (member (first body-part)
-				   '(locally macrolet progn symbol-macrolet))
-			   (some #'contains-toplevel-eval-when-p
-				 (rest body-part)))))))
-    (/show "testing for nested EVAL-WHENs" body)
-    (when (some #'contains-toplevel-eval-when-p body)
-      (compiler-style-warning "nested EVAL-WHENs in cross-compilation")))
-
-  (do-eval-when-stuff situations
-		      body
-		      (lambda (forms)
-			(ir1-convert-progn-body start cont forms))))
-
-;;; Like DO-EVAL-WHEN-STUFF, only do a MACROLET. FUN is not passed any
-;;; arguments.
-(defun do-macrolet-stuff (definitions fun)
-  (declare (list definitions) (type function fun))
-  (let ((whole (gensym "WHOLE"))
-	(environment (gensym "ENVIRONMENT")))
-    (collect ((new-fenv))
-      (dolist (def definitions)
-	(let ((name (first def))
-	      (arglist (second def))
-	      (body (cddr def)))
-	  (unless (symbolp name)
-	    (compiler-error "The local macro name ~S is not a symbol." name))
-	  (when (< (length def) 2)
-	    (compiler-error
-	     "The list ~S is too short to be a legal local macro definition."
-	     name))
-	  (multiple-value-bind (body local-decs)
-	      (parse-defmacro arglist whole body name 'macrolet
-			      :environment environment)
-	    (new-fenv `(,(first def) macro .
-			,(coerce `(lambda (,whole ,environment)
-				    ,@local-decs (block ,name ,body))
-				 'function))))))
-
-      (let ((*lexenv* (make-lexenv :functions (new-fenv))))
-	(funcall fun))))
-
-  (values))
-
-(def-ir1-translator macrolet ((definitions &rest body) start cont)
-  #!+sb-doc
-  "MACROLET ({(Name Lambda-List Form*)}*) Body-Form*
-  Evaluate the Body-Forms in an environment with the specified local macros
-  defined. Name is the local macro name, Lambda-List is the DEFMACRO style
-  destructuring lambda list, and the Forms evaluate to the expansion. The
-  Forms are evaluated in the null environment."
-  (do-macrolet-stuff definitions
-		     #'(lambda ()
-			 (ir1-convert-progn-body start cont body))))
-
-;;; not really a special form, but..
-(def-ir1-translator declare ((&rest stuff) start cont)
-  (declare (ignore stuff))
-  ;; We ignore START and CONT too, but we can't use DECLARE IGNORE to
-  ;; tell the compiler about it here, because the DEF-IR1-TRANSLATOR
-  ;; macro would put the DECLARE in the wrong place, so..
-  start cont
-  (compiler-error "misplaced declaration"))
-
-;;;; %PRIMITIVE
-;;;;
-;;;; Uses of %PRIMITIVE are either expanded into Lisp code or turned
-;;;; into a funny function.
-
-;;; Carefully evaluate a list of forms, returning a list of the results.
-(defun eval-info-args (args)
-  (declare (list args))
-  (handler-case (mapcar #'eval args)
-    (error (condition)
-      (compiler-error "Lisp error during evaluation of info args:~%~A"
-		      condition))))
-
-;;; a hashtable that translates from primitive names to translation functions
-(defvar *primitive-translators* (make-hash-table :test 'eq))
-
-;;; If there is a primitive translator, then we expand the call.
-;;; Otherwise, we convert to the %%PRIMITIVE funny function. The first
-;;; argument is the template, the second is a list of the results of
-;;; any codegen-info args, and the remaining arguments are the runtime
-;;; arguments.
-;;;
-;;; We do a bunch of error checking now so that we don't bomb out with
-;;; a fatal error during IR2 conversion.
-;;;
-;;; KLUDGE: It's confusing having multiple names floating around for
-;;; nearly the same concept: PRIMITIVE, TEMPLATE, VOP. Might it be
-;;; possible to reimplement BYTE-BLT (the only use of
-;;; *PRIMITIVE-TRANSLATORS*) some other way, then get rid of primitive
-;;; translators altogether, so that there would be no distinction
-;;; between primitives and vops? Then we could call primitives vops,
-;;; rename TEMPLATE to VOP-TEMPLATE, rename BACKEND-TEMPLATE-NAMES to
-;;; BACKEND-VOPS, and rename %PRIMITIVE to VOP.. -- WHN 19990906
-;;; FIXME: Look at doing this ^, it doesn't look too hard actually. I
-;;; think BYTE-BLT could probably just become an inline function.
-(def-ir1-translator %primitive ((&whole form name &rest args) start cont)
-
-  (unless (symbolp name)
-    (compiler-error "The primitive name ~S is not a symbol." name))
-
-  (let* ((translator (gethash name *primitive-translators*)))
-    (if translator
-	(ir1-convert start cont (funcall translator (cdr form)))
-	(let* ((template (or (gethash name *backend-template-names*)
-			     (compiler-error
-			      "The primitive name ~A is not defined."
-			      name)))
-	       (required (length (template-arg-types template)))
-	       (info (template-info-arg-count template))
-	       (min (+ required info))
-	       (nargs (length args)))
-	  (if (template-more-args-type template)
-	      (when (< nargs min)
-		(compiler-error "Primitive ~A was called with ~R argument~:P, ~
-	    			 but wants at least ~R."
-				name
-				nargs
-				min))
-	      (unless (= nargs min)
-		(compiler-error "Primitive ~A was called with ~R argument~:P, ~
-				 but wants exactly ~R."
-				name
-				nargs
-				min)))
-
-	  (when (eq (template-result-types template) :conditional)
-	    (compiler-error
-	     "%PRIMITIVE was used with a conditional template."))
-
-	  (when (template-more-results-type template)
-	    (compiler-error
-	     "%PRIMITIVE was used with an unknown values template."))
-
-	  (ir1-convert start
-		       cont
-		      `(%%primitive ',template
-				    ',(eval-info-args
-				       (subseq args required min))
-				    ,@(subseq args 0 required)
-				    ,@(subseq args min)))))))
-
-;;;; QUOTE and FUNCTION
-
-(def-ir1-translator quote ((thing) start cont)
-  #!+sb-doc
-  "QUOTE Value
-  Return Value without evaluating it."
-  (reference-constant start cont thing))
-
-(def-ir1-translator function ((thing) start cont)
-  #!+sb-doc
-  "FUNCTION Name
-  Return the lexically apparent definition of the function Name. Name may also
-  be a lambda."
-  (if (consp thing)
-      (case (car thing)
-	((lambda)
-	 (reference-leaf start cont (ir1-convert-lambda thing)))
-	((setf)
-	 (let ((var (find-lexically-apparent-function
-		     thing "as the argument to FUNCTION")))
-	   (reference-leaf start cont var)))
-	((instance-lambda)
-	 (let ((res (ir1-convert-lambda `(lambda ,@(cdr thing)))))
-	   (setf (getf (functional-plist res) :fin-function) t)
-	   (reference-leaf start cont res)))
-	(t
-	 (compiler-error "~S is not a legal function name." thing)))
-      (let ((var (find-lexically-apparent-function
-		  thing "as the argument to FUNCTION")))
-	(reference-leaf start cont var))))
-
-;;;; FUNCALL
-
-;;; FUNCALL is implemented on %FUNCALL, which can only call functions
-;;; (not symbols). %FUNCALL is used directly in some places where the
-;;; call should always be open-coded even if FUNCALL is :NOTINLINE.
-(deftransform funcall ((function &rest args) * * :when :both)
-  (let ((arg-names (make-gensym-list (length args))))
-    `(lambda (function ,@arg-names)
-       (%funcall ,(if (csubtypep (continuation-type function)
-				 (specifier-type 'function))
-		      'function
-		      '(%coerce-callable-to-function function))
-		 ,@arg-names))))
-
-(def-ir1-translator %funcall ((function &rest args) start cont)
-  (let ((fun-cont (make-continuation)))
-    (ir1-convert start fun-cont function)
-    (assert-continuation-type fun-cont (specifier-type 'function))
-    (ir1-convert-combination-args fun-cont cont args)))
-
-;;; This source transform exists to reduce the amount of work for the
-;;; compiler. If the called function is a FUNCTION form, then convert
-;;; directly to %FUNCALL, instead of waiting around for type
-;;; inference.
-(def-source-transform funcall (function &rest args)
-  (if (and (consp function) (eq (car function) 'function))
-      `(%funcall ,function ,@args)
-      (values nil t)))
-
-(deftransform %coerce-callable-to-function ((thing) (function) *
-					    :when :both
-					    :important t)
-  "optimize away possible call to FDEFINITION at runtime"
-  'thing)
-
-;;;; symbol macros
-
-(def-ir1-translator symbol-macrolet ((specs &body body) start cont)
-  #!+sb-doc
-  "SYMBOL-MACROLET ({(Name Expansion)}*) Decl* Form*
-  Define the Names as symbol macros with the given Expansions. Within the
-  body, references to a Name will effectively be replaced with the Expansion."
-  (multiple-value-bind (forms decls) (sb!sys:parse-body body nil)
-    (collect ((res))
-      (dolist (spec specs)
-	(unless (proper-list-of-length-p spec 2)
-	  (compiler-error "The symbol macro binding ~S is malformed." spec))
-	(let ((name (first spec))
-	      (def (second spec)))
-	  (unless (symbolp name)
-	    (compiler-error "The symbol macro name ~S is not a symbol." name))
-	  (when (assoc name (res) :test #'eq)
-	    (compiler-style-warning
-	     "The name ~S occurs more than once in SYMBOL-MACROLET."
-	     name))
-	  (res `(,name . (MACRO . ,def)))))
-
-      (let* ((*lexenv* (make-lexenv :variables (res)))
-	     (*lexenv* (process-decls decls (res) nil cont)))
-	(ir1-convert-progn-body start cont forms)))))
-
-;;; This is a frob that DEFSTRUCT expands into to establish the compiler
-;;; semantics. The other code in the expansion and %%COMPILER-DEFSTRUCT do
-;;; most of the work, we just clear all of the functions out of
-;;; *FREE-FUNCTIONS* to keep things in synch. %%COMPILER-DEFSTRUCT is also
-;;; called at load-time.
-(def-ir1-translator %compiler-defstruct ((info) start cont :kind :function)
-  (let* ((info (eval info)))
-    (%%compiler-defstruct info)
-    (dolist (slot (dd-slots info))
-      (let ((fun (dsd-accessor slot)))
-	(remhash fun *free-functions*)
-	(unless (dsd-read-only slot)
-	  (remhash `(setf ,fun) *free-functions*))))
-    (remhash (dd-predicate info) *free-functions*)
-    (remhash (dd-copier info) *free-functions*)
-    (ir1-convert start cont `(%%compiler-defstruct ',info))))
-
-;;; Return the contents of a quoted form.
-(defun unquote (x)
-  (if (and (consp x)
-	   (= 2 (length x))
-	   (eq 'quote (first x)))
-    (second x)
-    (error "not a quoted form")))
-
-;;; Don't actually compile anything, instead call the function now.
-(def-ir1-translator %compiler-only-defstruct
-		    ((info inherits) start cont :kind :function)
-  (function-%compiler-only-defstruct (unquote info) (unquote inherits))
-  (reference-constant start cont nil))
-
-;;;; LET and LET*
-;;;;
-;;;; (LET and LET* can't be implemented as macros due to the fact that
-;;;; any pervasive declarations also affect the evaluation of the
-;;;; arguments.)
-
-;;; Given a list of binding specifiers in the style of Let, return:
-;;;  1. The list of var structures for the variables bound.
-;;;  2. The initial value form for each variable.
-;;;
-;;; The variable names are checked for legality and globally special
-;;; variables are marked as such. Context is the name of the form, for
-;;; error reporting purposes.
-(declaim (ftype (function (list symbol) (values list list list))
-		extract-let-variables))
-(defun extract-let-variables (bindings context)
-  (collect ((vars)
-	    (vals)
-	    (names))
-    (flet ((get-var (name)
-	     (varify-lambda-arg name
-				(if (eq context 'let*)
-				    nil
-				    (names)))))
-      (dolist (spec bindings)
-	(cond ((atom spec)
-	       (let ((var (get-var spec)))
-		 (vars var)
-		 (names (cons spec var))
-		 (vals nil)))
-	      (t
-	       (unless (proper-list-of-length-p spec 1 2)
-		 (compiler-error "The ~S binding spec ~S is malformed."
-				 context
-				 spec))
-	       (let* ((name (first spec))
-		      (var (get-var name)))
-		 (vars var)
-		 (names name)
-		 (vals (second spec)))))))
-
-    (values (vars) (vals) (names))))
-
-(def-ir1-translator let ((bindings &body body)
-			 start cont)
-  #!+sb-doc
-  "LET ({(Var [Value]) | Var}*) Declaration* Form*
-  During evaluation of the Forms, bind the Vars to the result of evaluating the
-  Value forms. The variables are bound in parallel after all of the Values are
-  evaluated."
-  (multiple-value-bind (forms decls) (sb!sys:parse-body body nil)
-    (multiple-value-bind (vars values) (extract-let-variables bindings 'let)
-      (let* ((*lexenv* (process-decls decls vars nil cont))
-	     (fun-cont (make-continuation))
-	     (fun (ir1-convert-lambda-body forms vars)))
-	(reference-leaf start fun-cont fun)
-	(ir1-convert-combination-args fun-cont cont values)))))
-
-(def-ir1-translator let* ((bindings &body body)
-			  start cont)
-  #!+sb-doc
-  "LET* ({(Var [Value]) | Var}*) Declaration* Form*
-  Similar to LET, but the variables are bound sequentially, allowing each Value
-  form to reference any of the previous Vars."
-  (multiple-value-bind (forms decls) (sb!sys:parse-body body nil)
-    (multiple-value-bind (vars values) (extract-let-variables bindings 'let*)
-      (let ((*lexenv* (process-decls decls vars nil cont)))
-	(ir1-convert-aux-bindings start cont forms vars values nil)))))
-
-;;; This is a lot like a LET* with no bindings. Unlike LET*, LOCALLY
-;;; has to preserves top-level-formness, but we don't need to worry
-;;; about that here, because special logic in the compiler main loop
-;;; grabs top-level LOCALLYs and takes care of them before this
-;;; transform ever sees them.
-(def-ir1-translator locally ((&body body)
-			     start cont)
-  #!+sb-doc
-  "LOCALLY Declaration* Form*
-  Sequentially evaluate the Forms in a lexical environment where the
-  the Declarations have effect. If LOCALLY is a top-level form, then
-  the Forms are also processed as top-level forms."
-  (multiple-value-bind (forms decls) (sb!sys:parse-body body nil)
-    (let ((*lexenv* (process-decls decls nil nil cont)))
-      (ir1-convert-aux-bindings start cont forms nil nil nil))))
-
-;;;; FLET and LABELS
-
-;;; Given a list of local function specifications in the style of
-;;; Flet, return lists of the function names and of the lambdas which
-;;; are their definitions.
-;;;
-;;; The function names are checked for legality. Context is the name
-;;; of the form, for error reporting.
-(declaim (ftype (function (list symbol) (values list list))
-		extract-flet-variables))
-(defun extract-flet-variables (definitions context)
-  (collect ((names)
-	    (defs))
-    (dolist (def definitions)
-      (when (or (atom def) (< (length def) 2))
-	(compiler-error "The ~S definition spec ~S is malformed." context def))
-
-      (let ((name (check-function-name (first def))))
-	(names name)
-	(multiple-value-bind (forms decls) (sb!sys:parse-body (cddr def))
-	  (defs `(lambda ,(second def)
-		   ,@decls
-		   (block ,(function-name-block-name name)
-		     . ,forms))))))
-    (values (names) (defs))))
-
-(def-ir1-translator flet ((definitions &body body)
-			  start cont)
-  #!+sb-doc
-  "FLET ({(Name Lambda-List Declaration* Form*)}*) Declaration* Body-Form*
-  Evaluate the Body-Forms with some local function definitions. The bindings
-  do not enclose the definitions; any use of Name in the Forms will refer to
-  the lexically apparent function definition in the enclosing environment."
-  (multiple-value-bind (forms decls) (sb!sys:parse-body body nil)
-    (multiple-value-bind (names defs)
-	(extract-flet-variables definitions 'flet)
-      (let* ((fvars (mapcar (lambda (n d)
-  			      (ir1-convert-lambda d n))
-			    names defs))
-	     (*lexenv* (make-lexenv
-			:default (process-decls decls nil fvars cont)
-			:functions (pairlis names fvars))))
-	(ir1-convert-progn-body start cont forms)))))
-
-;;; For LABELS, we have to create dummy function vars and add them to
-;;; the function namespace while converting the functions. We then
-;;; modify all the references to these leaves so that they point to
-;;; the real functional leaves. We also backpatch the FENV so that if
-;;; the lexical environment is used for inline expansion we will get
-;;; the right functions.
-(def-ir1-translator labels ((definitions &body body) start cont)
-  #!+sb-doc
-  "LABELS ({(Name Lambda-List Declaration* Form*)}*) Declaration* Body-Form*
-  Evaluate the Body-Forms with some local function definitions. The bindings
-  enclose the new definitions, so the defined functions can call themselves or
-  each other."
-  (multiple-value-bind (forms decls) (sb!sys:parse-body body nil)
-    (multiple-value-bind (names defs)
-	(extract-flet-variables definitions 'labels)
-      (let* ((new-fenv (loop for name in names
-			     collect (cons name (make-functional :name name))))
-	     (real-funs
-	      (let ((*lexenv* (make-lexenv :functions new-fenv)))
-		(mapcar (lambda (n d)
-			  (ir1-convert-lambda d n))
-			names defs))))
-
-	(loop for real in real-funs and env in new-fenv do
-	      (let ((dum (cdr env)))
-		(substitute-leaf real dum)
-		(setf (cdr env) real)))
-
-	(let ((*lexenv* (make-lexenv
-			 :default (process-decls decls nil real-funs cont)
-			 :functions (pairlis names real-funs))))
-	  (ir1-convert-progn-body start cont forms))))))
-
-;;;; THE
-
-;;; Do stuff to recognize a THE or VALUES declaration. CONT is the
-;;; continuation that the assertion applies to, TYPE is the type
-;;; specifier and Lexenv is the current lexical environment. NAME is
-;;; the name of the declaration we are doing, for use in error
-;;; messages.
-;;;
-;;; This is somewhat involved, since a type assertion may only be made
-;;; on a continuation, not on a node. We can't just set the
-;;; continuation asserted type and let it go at that, since there may
-;;; be parallel THE's for the same continuation, i.e.:
-;;;     (if ...
-;;;	 (the foo ...)
-;;;	 (the bar ...))
-;;;
-;;; In this case, our representation can do no better than the union
-;;; of these assertions. And if there is a branch with no assertion,
-;;; we have nothing at all. We really need to recognize scoping, since
-;;; we need to be able to discern between parallel assertions (which
-;;; we union) and nested ones (which we intersect).
-;;;
-;;; We represent the scoping by throwing our innermost (intersected)
-;;; assertion on CONT into the TYPE-RESTRICTIONS. As we go down, we
-;;; intersect our assertions together. If CONT has no uses yet, we
-;;; have not yet bottomed out on the first COND branch; in this case
-;;; we optimistically assume that this type will be the one we end up
-;;; with, and set the ASSERTED-TYPE to it. We can never get better
-;;; than the type that we have the first time we bottom out. Later
-;;; THE's (or the absence thereof) can only weaken this result.
-;;;
-;;; We make this work by getting USE-CONTINUATION to do the unioning
-;;; across COND branches. We can't do it here, since we don't know how
-;;; many branches there are going to be.
-(defun do-the-stuff (type cont lexenv name)
-  (declare (type continuation cont) (type lexenv lexenv))
-  (let* ((ctype (values-specifier-type type))
-	 (old-type (or (lexenv-find cont type-restrictions)
-		       *wild-type*))
-	 (intersects (values-types-intersect old-type ctype))
-	 (int (values-type-intersection old-type ctype))
-	 (new (if intersects int old-type)))
-    (when (null (find-uses cont))
-      (setf (continuation-asserted-type cont) new))
-    (when (and (not intersects)
-	       (not (policy nil (= inhibit-warnings 3)))) ;FIXME: really OK to suppress?
-      (compiler-warning
-       "The type ~S in ~S declaration conflicts with an enclosing assertion:~%   ~S"
-       (type-specifier ctype)
-       name
-       (type-specifier old-type)))
-    (make-lexenv :type-restrictions `((,cont . ,new))
-		 :default lexenv)))
-
-;;; Assert that FORM evaluates to the specified type (which may be a
-;;; VALUES type).
-;;;
-;;; FIXME: In a version of CMU CL that I used at Cadabra ca. 20000101,
-;;; this didn't seem to expand into an assertion, at least for ALIEN
-;;; values. Check that SBCL doesn't have this problem.
-(def-ir1-translator the ((type value) start cont)
-  (let ((*lexenv* (do-the-stuff type cont *lexenv* 'the)))
-    (ir1-convert start cont value)))
-
-;;; This is like the THE special form, except that it believes
-;;; whatever you tell it. It will never generate a type check, but
-;;; will cause a warning if the compiler can prove the assertion is
-;;; wrong.
-;;;
-;;; Since the CONTINUATION-DERIVED-TYPE is computed as the union of
-;;; its uses's types, setting it won't work. Instead we must intersect
-;;; the type with the uses's DERIVED-TYPE.
-(def-ir1-translator truly-the ((type value) start cont)
-  #!+sb-doc
-  (declare (inline member))
-  (let ((type (values-specifier-type type))
-	(old (find-uses cont)))
-    (ir1-convert start cont value)
-    (do-uses (use cont)
-      (unless (member use old :test #'eq)
-	(derive-node-type use type)))))
-
-;;;; SETQ
-
-;;; If there is a definition in LEXENV-VARIABLES, just set that,
-;;; otherwise look at the global information. If the name is for a
-;;; constant, then error out.
-(def-ir1-translator setq ((&whole source &rest things) start cont)
-  (let ((len (length things)))
-    (when (oddp len)
-      (compiler-error "odd number of args to SETQ: ~S" source))
-    (if (= len 2)
-	(let* ((name (first things))
-	       (leaf (or (lexenv-find name variables)
-			 (find-free-variable name))))
-	  (etypecase leaf
-	    (leaf
-	     (when (or (constant-p leaf)
-		       (and (global-var-p leaf)
-			    (eq (global-var-kind leaf) :constant)))
-	       (compiler-error "~S is a constant and thus can't be set." name))
-	     (when (and (lambda-var-p leaf)
-			(lambda-var-ignorep leaf))
-	       ;; ANSI's definition of "Declaration IGNORE, IGNORABLE"
-	       ;; requires that this be a STYLE-WARNING, not a full warning.
-	       (compiler-style-warning
-		"~S is being set even though it was declared to be ignored."
-		name))
-	     (set-variable start cont leaf (second things)))
-	    (cons
-	     (assert (eq (car leaf) 'MACRO))
-	     (ir1-convert start cont `(setf ,(cdr leaf) ,(second things))))
-	    (heap-alien-info
-	     (ir1-convert start cont
-			  `(%set-heap-alien ',leaf ,(second things))))))
-	(collect ((sets))
-	  (do ((thing things (cddr thing)))
-	      ((endp thing)
-	       (ir1-convert-progn-body start cont (sets)))
-	    (sets `(setq ,(first thing) ,(second thing))))))))
-
-;;; This is kind of like REFERENCE-LEAF, but we generate a SET node.
-;;; This should only need to be called in SETQ.
-(defun set-variable (start cont var value)
-  (declare (type continuation start cont) (type basic-var var))
-  (let ((dest (make-continuation)))
-    (setf (continuation-asserted-type dest) (leaf-type var))
-    (ir1-convert start dest value)
-    (let ((res (make-set :var var :value dest)))
-      (setf (continuation-dest dest) res)
-      (setf (leaf-ever-used var) t)
-      (push res (basic-var-sets var))
-      (prev-link res dest)
-      (use-continuation res cont))))
-
-;;;; CATCH, THROW and UNWIND-PROTECT
-
-;;; We turn THROW into a multiple-value-call of a magical function,
-;;; since as as far as IR1 is concerned, it has no interesting
-;;; properties other than receiving multiple-values.
-(def-ir1-translator throw ((tag result) start cont)
-  #!+sb-doc
-  "Throw Tag Form
-  Do a non-local exit, return the values of Form from the CATCH whose tag
-  evaluates to the same thing as Tag."
-  (ir1-convert start cont
-	       `(multiple-value-call #'%throw ,tag ,result)))
-
-;;; This is a special special form used to instantiate a cleanup as
-;;; the current cleanup within the body. KIND is a the kind of cleanup
-;;; to make, and MESS-UP is a form that does the mess-up action. We
-;;; make the MESS-UP be the USE of the MESS-UP form's continuation,
-;;; and introduce the cleanup into the lexical environment. We
-;;; back-patch the ENTRY-CLEANUP for the current cleanup to be the new
-;;; cleanup, since this inner cleanup is the interesting one.
-(def-ir1-translator %within-cleanup ((kind mess-up &body body) start cont)
-  (let ((dummy (make-continuation))
-	(dummy2 (make-continuation)))
-    (ir1-convert start dummy mess-up)
-    (let* ((mess-node (continuation-use dummy))
-	   (cleanup (make-cleanup :kind kind
-				  :mess-up mess-node))
-	   (old-cup (lexenv-cleanup *lexenv*))
-	   (*lexenv* (make-lexenv :cleanup cleanup)))
-      (setf (entry-cleanup (cleanup-mess-up old-cup)) cleanup)
-      (ir1-convert dummy dummy2 '(%cleanup-point))
-      (ir1-convert-progn-body dummy2 cont body))))
-
-;;; This is a special special form that makes an "escape function"
-;;; which returns unknown values from named block. We convert the
-;;; function, set its kind to :ESCAPE, and then reference it. The
-;;; :Escape kind indicates that this function's purpose is to
-;;; represent a non-local control transfer, and that it might not
-;;; actually have to be compiled.
-;;;
-;;; Note that environment analysis replaces references to escape
-;;; functions with references to the corresponding NLX-INFO structure.
-(def-ir1-translator %escape-function ((tag) start cont)
-  (let ((fun (ir1-convert-lambda
-	      `(lambda ()
-		 (return-from ,tag (%unknown-values))))))
-    (setf (functional-kind fun) :escape)
-    (reference-leaf start cont fun)))
-
-;;; Yet another special special form. This one looks up a local
-;;; function and smashes it to a :CLEANUP function, as well as
-;;; referencing it.
-(def-ir1-translator %cleanup-function ((name) start cont)
-  (let ((fun (lexenv-find name functions)))
-    (assert (lambda-p fun))
-    (setf (functional-kind fun) :cleanup)
-    (reference-leaf start cont fun)))
-
-;;; We represent the possibility of the control transfer by making an
-;;; "escape function" that does a lexical exit, and instantiate the
-;;; cleanup using %WITHIN-CLEANUP.
-(def-ir1-translator catch ((tag &body body) start cont)
-  #!+sb-doc
-  "Catch Tag Form*
-  Evaluates Tag and instantiates it as a catcher while the body forms are
-  evaluated in an implicit PROGN. If a THROW is done to Tag within the dynamic
-  scope of the body, then control will be transferred to the end of the body
-  and the thrown values will be returned."
-  (ir1-convert
-   start cont
-   (let ((exit-block (gensym "EXIT-BLOCK-")))
-     `(block ,exit-block
-	(%within-cleanup
-	    :catch
-	    (%catch (%escape-function ,exit-block) ,tag)
-	  ,@body)))))
-
-;;; UNWIND-PROTECT is similar to CATCH, but more hairy. We make the
-;;; cleanup forms into a local function so that they can be referenced
-;;; both in the case where we are unwound and in any local exits. We
-;;; use %CLEANUP-FUNCTION on this to indicate that reference by
-;;; %UNWIND-PROTECT ISN'T "real", and thus doesn't cause creation of
-;;; an XEP.
-(def-ir1-translator unwind-protect ((protected &body cleanup) start cont)
-  #!+sb-doc
-  "Unwind-Protect Protected Cleanup*
-  Evaluate the form Protected, returning its values. The cleanup forms are
-  evaluated whenever the dynamic scope of the Protected form is exited (either
-  due to normal completion or a non-local exit such as THROW)."
-  (ir1-convert
-   start cont
-   (let ((cleanup-fun (gensym "CLEANUP-FUN-"))
-	 (drop-thru-tag (gensym "DROP-THRU-TAG-"))
-	 (exit-tag (gensym "EXIT-TAG-"))
-	 (next (gensym "NEXT"))
-	 (start (gensym "START"))
-	 (count (gensym "COUNT")))
-     `(flet ((,cleanup-fun () ,@cleanup nil))
-	;; FIXME: If we ever get DYNAMIC-EXTENT working, then
-	;; ,CLEANUP-FUN should probably be declared DYNAMIC-EXTENT,
-	;; and something can be done to make %ESCAPE-FUNCTION have
-	;; dynamic extent too.
-	(block ,drop-thru-tag
-	  (multiple-value-bind (,next ,start ,count)
-	      (block ,exit-tag
-		(%within-cleanup
-		    :unwind-protect
-		    (%unwind-protect (%escape-function ,exit-tag)
-				     (%cleanup-function ,cleanup-fun))
-		  (return-from ,drop-thru-tag ,protected)))
-	    (,cleanup-fun)
-	    (%continue-unwind ,next ,start ,count)))))))
-
-;;;; multiple-value stuff
-
-;;; If there are arguments, MULTIPLE-VALUE-CALL turns into an
-;;; MV-COMBINATION.
-;;;
-;;; If there are no arguments, then we convert to a normal
-;;; combination, ensuring that a MV-COMBINATION always has at least
-;;; one argument. This can be regarded as an optimization, but it is
-;;; more important for simplifying compilation of MV-COMBINATIONS.
-(def-ir1-translator multiple-value-call ((fun &rest args) start cont)
-  #!+sb-doc
-  "MULTIPLE-VALUE-CALL Function Values-Form*
-  Call Function, passing all the values of each Values-Form as arguments,
-  values from the first Values-Form making up the first argument, etc."
-  (let* ((fun-cont (make-continuation))
-	 (node (if args
-		   (make-mv-combination fun-cont)
-		   (make-combination fun-cont))))
-    (ir1-convert start fun-cont
-		 (if (and (consp fun) (eq (car fun) 'function))
-		     fun
-		     `(%coerce-callable-to-function ,fun)))
-    (setf (continuation-dest fun-cont) node)
-    (assert-continuation-type fun-cont
-			      (specifier-type '(or function symbol)))
-    (collect ((arg-conts))
-      (let ((this-start fun-cont))
-	(dolist (arg args)
-	  (let ((this-cont (make-continuation node)))
-	    (ir1-convert this-start this-cont arg)
-	    (setq this-start this-cont)
-	    (arg-conts this-cont)))
-	(prev-link node this-start)
-	(use-continuation node cont)
-	(setf (basic-combination-args node) (arg-conts))))))
-
-;;; MULTIPLE-VALUE-PROG1 is represented implicitly in IR1 by having a
-;;; the result code use result continuation (CONT), but transfer
-;;; control to the evaluation of the body. In other words, the result
-;;; continuation isn't IMMEDIATELY-USED-P by the nodes that compute
-;;; the result.
-;;;
-;;; In order to get the control flow right, we convert the result with
-;;; a dummy result continuation, then convert all the uses of the
-;;; dummy to be uses of CONT. If a use is an EXIT, then we also
-;;; substitute CONT for the dummy in the corresponding ENTRY node so
-;;; that they are consistent. Note that this doesn't amount to
-;;; changing the exit target, since the control destination of an exit
-;;; is determined by the block successor; we are just indicating the
-;;; continuation that the result is delivered to.
-;;;
-;;; We then convert the body, using another dummy continuation in its
-;;; own block as the result. After we are done converting the body, we
-;;; move all predecessors of the dummy end block to CONT's block.
-;;;
-;;; Note that we both exploit and maintain the invariant that the CONT
-;;; to an IR1 convert method either has no block or starts the block
-;;; that control should transfer to after completion for the form.
-;;; Nested MV-PROG1's work because during conversion of the result
-;;; form, we use dummy continuation whose block is the true control
-;;; destination.
-(def-ir1-translator multiple-value-prog1 ((result &rest forms) start cont)
-  #!+sb-doc
-  "MULTIPLE-VALUE-PROG1 Values-Form Form*
-  Evaluate Values-Form and then the Forms, but return all the values of
-  Values-Form."
-  (continuation-starts-block cont)
-  (let* ((dummy-result (make-continuation))
-	 (dummy-start (make-continuation))
-	 (cont-block (continuation-block cont)))
-    (continuation-starts-block dummy-start)
-    (ir1-convert start dummy-start result)
-
-    (substitute-continuation-uses cont dummy-start)
-
-    (continuation-starts-block dummy-result)
-    (ir1-convert-progn-body dummy-start dummy-result forms)
-    (let ((end-block (continuation-block dummy-result)))
-      (dolist (pred (block-pred end-block))
-	(unlink-blocks pred end-block)
-	(link-blocks pred cont-block))
-      (assert (not (continuation-dest dummy-result)))
-      (delete-continuation dummy-result)
-      (remove-from-dfo end-block))))
-
-;;;; interface to defining macros
-
-;;;; FIXME:
-;;;;   classic CMU CL comment:
-;;;;     DEFMACRO and DEFUN expand into calls to %DEFxxx functions
-;;;;     so that we get a chance to see what is going on. We define
-;;;;     IR1 translators for these functions which look at the
-;;;;     definition and then generate a call to the %%DEFxxx function.
-;;;; Alas, this implementation doesn't do the right thing for
-;;;; non-toplevel uses of these forms, so this should probably
-;;;; be changed to use EVAL-WHEN instead.
-
-;;; Return a new source path with any stuff intervening between the
-;;; current path and the first form beginning with NAME stripped off.
-;;; This is used to hide the guts of DEFmumble macros to prevent
-;;; annoying error messages.
-(defun revert-source-path (name)
-  (do ((path *current-path* (cdr path)))
-      ((null path) *current-path*)
-    (let ((first (first path)))
-      (when (or (eq first name)
-		(eq first 'original-source-start))
-	(return path)))))
-
-;;; Warn about incompatible or illegal definitions and add the macro
-;;; to the compiler environment.
-;;;
-;;; Someday we could check for macro arguments being incompatibly
-;;; redefined. Doing this right will involve finding the old macro
-;;; lambda-list and comparing it with the new one.
-(def-ir1-translator %defmacro ((qname qdef lambda-list doc) start cont
-			       :kind :function)
-  (let (;; QNAME is typically a quoted name. I think the idea is to let
-	;; %DEFMACRO work as an ordinary function when interpreting. Whatever
-	;; the reason it's there, we don't want it any more. -- WHN 19990603
-	(name (eval qname))
-	;; QDEF should be a sharp-quoted definition. We don't want to make a
-	;; function of it just yet, so we just drop the sharp-quote.
-	(def (progn
-	       (assert (eq 'function (first qdef)))
-	       (assert (proper-list-of-length-p qdef 2))
-	       (second qdef))))
-
-    (unless (symbolp name)
-      (compiler-error "The macro name ~S is not a symbol." name))
-
-    (ecase (info :function :kind name)
-      ((nil))
-      (:function
-       (remhash name *free-functions*)
-       (undefine-function-name name)
-       (compiler-warning
-	"~S is being redefined as a macro when it was previously ~(~A~) to be a function."
-	name
-	(info :function :where-from name)))
-      (:macro)
-      (:special-form
-       (compiler-error "The special form ~S can't be redefined as a macro."
-		       name)))
-
-    (setf (info :function :kind name) :macro
-	  (info :function :where-from name) :defined
-	  (info :function :macro-function name) (coerce def 'function))
-
-    (let* ((*current-path* (revert-source-path 'defmacro))
-	   (fun (ir1-convert-lambda def name)))
-      (setf (leaf-name fun)
-	    (concatenate 'string "DEFMACRO " (symbol-name name)))
-      (setf (functional-arg-documentation fun) (eval lambda-list))
-
-      (ir1-convert start cont `(%%defmacro ',name ,fun ,doc)))
-
-    (when sb!xc:*compile-print*
-      ;; FIXME: It would be nice to convert this, and the other places
-      ;; which create compiler diagnostic output prefixed by
-      ;; semicolons, to use some common utility which automatically
-      ;; prefixes all its output with semicolons. (The addition of
-      ;; semicolon prefixes was introduced ca. sbcl-0.6.8.10 as the
-      ;; "MNA compiler message patch", and implemented by modifying a
-      ;; bunch of output statements on a case-by-case basis, which
-      ;; seems unnecessarily error-prone and unclear, scattering
-      ;; implicit information about output style throughout the
-      ;; system.) Starting by rewriting COMPILER-MUMBLE to add
-      ;; semicolon prefixes would be a good start, and perhaps also:
-      ;;   * Add semicolon prefixes for "FOO assembled" messages emitted 
-      ;;     when e.g. src/assembly/x86/assem-rtns.lisp is processed.
-      ;;   * At least some debugger output messages deserve semicolon
-      ;;     prefixes too:
-      ;;     ** restarts table
-      ;;     ** "Within the debugger, you can type HELP for help."
-      (compiler-mumble "~&; converted ~S~%" name))))
-
-(def-ir1-translator %define-compiler-macro ((name def lambda-list doc)
-					    start cont
-					    :kind :function)
-  (let ((name (eval name))
-	(def (second def))) ; We don't want to make a function just yet...
-
-    (when (eq (info :function :kind name) :special-form)
-      (compiler-error "attempt to define a compiler-macro for special form ~S"
-		      name))
-
-    (setf (info :function :compiler-macro-function name)
-	  (coerce def 'function))
-
-    (let* ((*current-path* (revert-source-path 'define-compiler-macro))
-	   (fun (ir1-convert-lambda def name)))
-      (setf (leaf-name fun)
-	    (let ((*print-case* :upcase))
-	      (format nil "DEFINE-COMPILER-MACRO ~S" name)))
-      (setf (functional-arg-documentation fun) (eval lambda-list))
-
-      (ir1-convert start cont `(%%define-compiler-macro ',name ,fun ,doc)))
-
-    (when sb!xc:*compile-print*
-      (compiler-mumble "~&; converted ~S~%" name))))
-
 ;;;; defining global functions
 
 ;;; Convert FUN as a lambda in the null environment, but use the
 ;;; current compilation policy. Note that FUN may be a
-;;; LAMBDA-WITH-ENVIRONMENT, so we may have to augment the environment
-;;; to reflect the state at the definition site.
-(defun ir1-convert-inline-lambda (fun &optional name)
+;;; LAMBDA-WITH-LEXENV, so we may have to augment the environment to
+;;; reflect the state at the definition site.
+(defun ir1-convert-inline-lambda (fun &key
+				      (source-name '.anonymous.)
+				      debug-name)
   (destructuring-bind (decls macros symbol-macros &rest body)
-		      (if (eq (car fun) 'lambda-with-environment)
+		      (if (eq (car fun) 'lambda-with-lexenv)
 			  (cdr fun)
 			  `(() () () . ,(cdr fun)))
     (let ((*lexenv* (make-lexenv
 		     :default (process-decls decls nil nil
 					     (make-continuation)
 					     (make-null-lexenv))
-		     :variables (copy-list symbol-macros)
-		     :functions
-		     (mapcar #'(lambda (x)
-				 `(,(car x) .
-				   (macro . ,(coerce (cdr x) 'function))))
-			     macros)
-		     :policy (lexenv-policy *lexenv*)
-		     :interface-policy (lexenv-interface-policy *lexenv*))))
-      (ir1-convert-lambda `(lambda ,@body) name))))
-
-;;; Return a lambda that has been "closed" with respect to ENV,
-;;; returning a LAMBDA-WITH-ENVIRONMENT if there are interesting
-;;; macros or declarations. If there is something too complex (like a
-;;; lexical variable) in the environment, then we return NIL.
-(defun inline-syntactic-closure-lambda (lambda &optional (env *lexenv*))
-  (let ((variables (lexenv-variables env))
-	(functions (lexenv-functions env))
-	(decls ())
-	(symmacs ())
-	(macros ()))
-    (cond ((or (lexenv-blocks env) (lexenv-tags env)) nil)
-	  ((and (null variables) (null functions))
-	   lambda)
-	  ((dolist (x variables nil)
-	     (let ((name (car x))
-		   (what (cdr x)))
-	       (when (eq x (assoc name variables :test #'eq))
-		 (typecase what
-		   (cons
-		    (assert (eq (car what) 'macro))
-		    (push x symmacs))
-		   (global-var
-		    (assert (eq (global-var-kind what) :special))
-		    (push `(special ,name) decls))
-		   (t (return t))))))
-	   nil)
-	  ((dolist (x functions nil)
-	     (let ((name (car x))
-		   (what (cdr x)))
-	       (when (eq x (assoc name functions :test #'equal))
-		 (typecase what
-		   (cons
-		    (push (cons name
-				(function-lambda-expression (cdr what)))
-			  macros))
-		   (global-var
-		    (when (defined-function-p what)
-		      (push `(,(car (rassoc (defined-function-inlinep what)
-					    *inlinep-translations*))
-			      ,name)
-			    decls)))
-		   (t (return t))))))
-	   nil)
-	  (t
-	   `(lambda-with-environment ,decls
-				     ,macros
-				     ,symmacs
-				     . ,(rest lambda))))))
-
-;;; Get a DEFINED-FUNCTION object for a function we are about to
-;;; define. If the function has been forward referenced, then
-;;; substitute for the previous references.
-(defun get-defined-function (name)
-  (let* ((name (proclaim-as-function-name name))
-	 (found (find-free-function name "Eh?")))
+		     :vars (copy-list symbol-macros)
+		     :funs (mapcar (lambda (x)
+				     `(,(car x) .
+				       (macro . ,(coerce (cdr x) 'function))))
+				   macros)
+		     :policy (lexenv-policy *lexenv*))))
+      (ir1-convert-lambda `(lambda ,@body)
+			  :source-name source-name
+			  :debug-name debug-name))))
+
+;;; Get a DEFINED-FUN object for a function we are about to define. If
+;;; the function has been forward referenced, then substitute for the
+;;; previous references.
+(defun get-defined-fun (name)
+  (proclaim-as-fun-name name)
+  (let ((found (find-free-fun name "shouldn't happen! (defined-fun)")))
     (note-name-defined name :function)
-    (cond ((not (defined-function-p found))
-	   (assert (not (info :function :inlinep name)))
+    (cond ((not (defined-fun-p found))
+	   (aver (not (info :function :inlinep name)))
 	   (let* ((where-from (leaf-where-from found))
-		  (res (make-defined-function
-			:name name
+		  (res (make-defined-fun
+			:%source-name name
 			:where-from (if (eq where-from :declared)
 					:declared :defined)
 			:type (leaf-type found))))
 	     (substitute-leaf res found)
-	     (setf (gethash name *free-functions*) res)))
-	  ;; If *FREE-FUNCTIONS* has a previously converted definition for this
-	  ;; name, then blow it away and try again.
-	  ((defined-function-functional found)
-	   (remhash name *free-functions*)
-	   (get-defined-function name))
+	     (setf (gethash name *free-funs*) res)))
+	  ;; If *FREE-FUNS* has a previously converted definition
+	  ;; for this name, then blow it away and try again.
+	  ((defined-fun-functional found)
+	   (remhash name *free-funs*)
+	   (get-defined-fun name))
 	  (t found))))
 
 ;;; Check a new global function definition for consistency with
 ;;; previous declaration or definition, and assert argument/result
-;;; types if appropriate. This this assertion is suppressed by the
+;;; types if appropriate. This assertion is suppressed by the
 ;;; EXPLICIT-CHECK attribute, which is specified on functions that
 ;;; check their argument types as a consequence of type dispatching.
-;;; This avoids redundant checks such as NUMBERP on the args to +,
-;;; etc.
+;;; This avoids redundant checks such as NUMBERP on the args to +, etc.
 (defun assert-new-definition (var fun)
   (let ((type (leaf-type var))
 	(for-real (eq (leaf-where-from var) :declared))
-	(info (info :function :info (leaf-name var))))
+	(info (info :function :info (leaf-source-name var))))
     (assert-definition-type
      fun type
-     :error-function #'compiler-warning
-     :warning-function (cond (info #'compiler-warning)
-			     (for-real #'compiler-note)
-			     (t nil))
+     ;; KLUDGE: Common Lisp is such a dynamic language that in general
+     ;; all we can do here in general is issue a STYLE-WARNING. It
+     ;; would be nice to issue a full WARNING in the special case of
+     ;; of type mismatches within a compilation unit (as in section
+     ;; 3.2.2.3 of the spec) but at least as of sbcl-0.6.11, we don't
+     ;; keep track of whether the mismatched data came from the same
+     ;; compilation unit, so we can't do that. -- WHN 2001-02-11
+     :lossage-fun #'compiler-style-warn
+     :unwinnage-fun (cond (info #'compiler-style-warn)
+			  (for-real #'compiler-note)
+			  (t nil))
      :really-assert
      (and for-real
 	  (not (and info
-		    (ir1-attributep (function-info-attributes info)
+		    (ir1-attributep (fun-info-attributes info)
 				    explicit-check))))
      :where (if for-real
 		"previous declaration"
 		"previous definition"))))
 
 ;;; Convert a lambda doing all the basic stuff we would do if we were
-;;; converting a DEFUN. This is used both by the %DEFUN translator and
-;;; for global inline expansion.
+;;; converting a DEFUN. In the old CMU CL system, this was used both
+;;; by the %DEFUN translator and for global inline expansion, but
+;;; since sbcl-0.pre7.something %DEFUN does things differently.
+;;; FIXME: And now it's probably worth rethinking whether this
+;;; function is a good idea.
 ;;;
 ;;; Unless a :INLINE function, we temporarily clobber the inline
 ;;; expansion. This prevents recursive inline expansion of
 ;;; opportunistic pseudo-inlines.
 (defun ir1-convert-lambda-for-defun (lambda var expansion converter)
-  (declare (cons lambda) (function converter) (type defined-function var))
-  (let ((var-expansion (defined-function-inline-expansion var)))
-    (unless (eq (defined-function-inlinep var) :inline)
-      (setf (defined-function-inline-expansion var) nil))
-    (let* ((name (leaf-name var))
-	   (fun (funcall converter lambda name))
-	   (function-info (info :function :info name)))
-      (setf (functional-inlinep fun) (defined-function-inlinep var))
+  (declare (cons lambda) (function converter) (type defined-fun var))
+  (let ((var-expansion (defined-fun-inline-expansion var)))
+    (unless (eq (defined-fun-inlinep var) :inline)
+      (setf (defined-fun-inline-expansion var) nil))
+    (let* ((name (leaf-source-name var))
+	   (fun (funcall converter lambda
+			 :source-name name))
+	   (fun-info (info :function :info name)))
+      (setf (functional-inlinep fun) (defined-fun-inlinep var))
       (assert-new-definition var fun)
-      (setf (defined-function-inline-expansion var) var-expansion)
-      ;; If definitely not an interpreter stub, then substitute for any
-      ;; old references.
-      (unless (or (eq (defined-function-inlinep var) :notinline)
+      (setf (defined-fun-inline-expansion var) var-expansion)
+      ;; If definitely not an interpreter stub, then substitute for
+      ;; any old references.
+      (unless (or (eq (defined-fun-inlinep var) :notinline)
 		  (not *block-compile*)
-		  (and function-info
-		       (or (function-info-transforms function-info)
-			   (function-info-templates function-info)
-			   (function-info-ir2-convert function-info))))
+		  (and fun-info
+		       (or (fun-info-transforms fun-info)
+			   (fun-info-templates fun-info)
+			   (fun-info-ir2-convert fun-info))))
 	(substitute-leaf fun var)
 	;; If in a simple environment, then we can allow backward
-	;; references to this function from following top-level forms.
-	(when expansion (setf (defined-function-functional var) fun)))
+	;; references to this function from following top level forms.
+	(when expansion (setf (defined-fun-functional var) fun)))
       fun)))
 
-;;; Convert the definition and install it in the global environment
-;;; with a LABELS-like effect. If the lexical environment is not null,
-;;; then we only install the definition during the processing of this
-;;; DEFUN, ensuring that the function cannot be called outside of the
-;;; correct environment. If the function is globally NOTINLINE, then
-;;; that inhibits even local substitution. Also, emit top-level code
-;;; to install the definition.
+;;; the even-at-compile-time part of DEFUN
 ;;;
-;;; This is one of the major places where the semantics of block
-;;; compilation is handled. Substitution for global names is totally
-;;; inhibited if *BLOCK-COMPILE* is NIL. And if *BLOCK-COMPILE* is
-;;; true and entry points are specified, then we don't install global
-;;; definitions for non-entry functions (effectively turning them into
-;;; local lexical functions.)
-(def-ir1-translator %defun ((name def doc source) start cont
-			    :kind :function)
-  (declare (ignore source))
-  (let* ((name (eval name))
-	 (lambda (second def))
-	 (*current-path* (revert-source-path 'defun))
-	 (expansion (unless (eq (info :function :inlinep name) :notinline)
-		      (inline-syntactic-closure-lambda lambda))))
-    ;; If not in a simple environment or NOTINLINE, then discard any
-    ;; forward references to this function.
-    (unless expansion (remhash name *free-functions*))
-
-    (let* ((var (get-defined-function name))
-	   (save-expansion (and (member (defined-function-inlinep var)
-					'(:inline :maybe-inline))
-				expansion)))
-      (setf (defined-function-inline-expansion var) expansion)
-      (setf (info :function :inline-expansion name) save-expansion)
-      ;; If there is a type from a previous definition, blast it,
-      ;; since it is obsolete.
-      (when (eq (leaf-where-from var) :defined)
-	(setf (leaf-type var) (specifier-type 'function)))
-
-      (let ((fun (ir1-convert-lambda-for-defun lambda
-					       var
-					       expansion
-					       #'ir1-convert-lambda)))
-	(ir1-convert
-	 start cont
-	 (if (and *block-compile* *entry-points*
-		  (not (member name *entry-points* :test #'equal)))
-	     `',name
-	     `(%%defun ',name ,fun ,doc
-		       ,@(when save-expansion `(',save-expansion)))))
-
-	(when sb!xc:*compile-print*
-	  (compiler-mumble "~&; converted ~S~%" name))))))
+;;; The INLINE-EXPANSION is a LAMBDA-WITH-LEXENV, or NIL if there is
+;;; no inline expansion.
+(defun %compiler-defun (name lambda-with-lexenv)
+
+  (let ((defined-fun nil)) ; will be set below if we're in the compiler
+    
+    (when (boundp '*lexenv*) ; when in the compiler
+      (when sb!xc:*compile-print*
+	(compiler-mumble "~&; recognizing DEFUN ~S~%" name))
+      (remhash name *free-funs*)
+      (setf defined-fun (get-defined-fun name)))
+
+    (become-defined-fun-name name)
+
+    (cond (lambda-with-lexenv
+	   (setf (info :function :inline-expansion-designator name)
+		 lambda-with-lexenv)
+	   (when defined-fun 
+	     (setf (defined-fun-inline-expansion defined-fun)
+		   lambda-with-lexenv)))
+	  (t
+	   (clear-info :function :inline-expansion-designator name)))
+
+    ;; old CMU CL comment:
+    ;;   If there is a type from a previous definition, blast it,
+    ;;   since it is obsolete.
+    (when (and defined-fun
+	       (eq (leaf-where-from defined-fun) :defined))
+      (setf (leaf-type defined-fun)
+	    ;; FIXME: If this is a block compilation thing, shouldn't
+	    ;; we be setting the type to the full derived type for the
+	    ;; definition, instead of this most general function type?
+	    (specifier-type 'function))))
+
+  (values))