;; A continuation that is the CONT of some node in BLOCK.
(kind :unused :type (member :unused :deleted :inside-block :block-start
:deleted-block-start))
- ;; The node which receives this value, if any. In a deleted continuation,
- ;; this is null even though the node that receives this continuation may not
- ;; yet be deleted.
+ ;; The node which receives this value, if any. In a deleted
+ ;; continuation, this is null even though the node that receives
+ ;; this continuation may not yet be deleted.
(dest nil :type (or node null))
;; If this is a NODE, then it is the node which is to be evaluated
;; next. This is always null in :DELETED and :UNUSED continuations,
;; Following the introduced forms is a representation of the
;; location of the enclosing original source form. This transition
;; is indicated by the magic ORIGINAL-SOURCE-START marker. The first
- ;; element of the orignal source is the "form number", which is the
+ ;; element of the original source is the "form number", which is the
;; ordinal number of this form in a depth-first, left-to-right walk
;; of the truly top-level form in which this appears.
;;
;;
;; The last element in the list is the top-level form number, which
;; is the ordinal number (in this call to the compiler) of the truly
- ;; top-level form containing the orignal source.
+ ;; top-level form containing the original source.
(source-path *current-path* :type list)
;; If this node is in a tail-recursive position, then this is set to
;; T. At the end of IR1 (in environment analysis) this is computed
;; :DECLARED, from a declaration.
;; :ASSUMED, from uses of the object.
;; :DEFINED, from examination of the definition.
- ;; FIXME: This should be a named type. (LEAF-WHERE-FROM?)
+ ;; FIXME: This should be a named type. (LEAF-WHERE-FROM? Or
+ ;; perhaps just WHERE-FROM, since it's not just used in LEAF,
+ ;; but also in various DEFINE-INFO-TYPEs in globaldb.lisp,
+ ;; and very likely elsewhere too.)
(where-from :assumed :type (member :declared :assumed :defined))
;; list of the REF nodes for this leaf
(refs () :type list)
;;; defined in the same compilation block, or that have inline
;;; expansions, or have a non-NIL INLINEP value. Whenever we change
;;; the INLINEP state (i.e. an inline proclamation) we copy the
-;;; structure so that former inlinep values are preserved.
+;;; structure so that former INLINEP values are preserved.
(def!struct (defined-function (:include global-var
(where-from :defined)
(kind :global-function)))
(arglist nil :type list)
;; true if &ALLOW-OTHER-KEYS was supplied
(allowp nil :type boolean)
- ;; true if &KEY was specified (doesn't necessarily mean that there
- ;; are any keyword arguments...)
+ ;; true if &KEY was specified (which doesn't necessarily mean that
+ ;; there are any &KEY arguments..)
(keyp nil :type boolean)
;; the number of required arguments. This is the smallest legal
;; number of arguments.
;; defaults even when there is no user-specified supplied-p var.
(supplied-p nil :type (or lambda-var null))
;; the default for a keyword or optional, represented as the
- ;; original Lisp code. This is set to NIL in keyword arguments that
- ;; are defaulted using the SUPPLIED-P arg.
+ ;; original Lisp code. This is set to NIL in &KEY arguments that are
+ ;; defaulted using the SUPPLIED-P arg.
(default nil :type t)
- ;; the actual keyword for a keyword argument
- (keyword nil :type (or keyword null)))
+ ;; the actual key for a &KEY argument. Note that in ANSI CL this is not
+ ;; necessarily a keyword: (DEFUN FOO (&KEY ((BAR BAR))) ..).
+ (key nil :type symbol))
(defprinter (arg-info)
(specialp :test specialp)
kind
(supplied-p :test supplied-p)
(default :test default)
- (keyword :test keyword))
+ (key :test key))
;;; The LAMBDA-VAR structure represents a lexical lambda variable.
;;; This structure is also used during IR1 conversion to describe
;; *UNDEFINED-WARNING-LIMIT* calls.
(warnings () :type list))
\f
+;;; a helper for the POLICY macro, defined late here so that the
+;;; various type tests can be inlined
+(declaim (ftype (function ((or list lexenv node functional)) list)
+ %coerce-to-policy))
+(defun %coerce-to-policy (thing)
+ (let ((result (etypecase thing
+ (list thing)
+ (lexenv (lexenv-policy thing))
+ (node (lexenv-policy (node-lexenv thing)))
+ (functional (lexenv-policy (functional-lexenv thing))))))
+ ;; Test the first element of the list as a rudimentary sanity
+ ;; that it really does look like a valid policy.
+ (aver (or (null result) (policy-quality-name-p (caar result))))
+ ;; Voila.
+ result))
+\f
;;;; Freeze some structure types to speed type testing.
#!-sb-fluid