0.pre7.125:

[sbcl.git] / src / compiler / knownfun.lisp

diff --git a/src/compiler/knownfun.lisp b/src/compiler/knownfun.lisp
index ea4157d..9e3d53a 100644 (file)
--- a/src/compiler/knownfun.lisp
+++ b/src/compiler/knownfun.lisp
@@ -66,7 +66,7 @@
 
 (defstruct (function-info #-sb-xc-host (:pure t))
   ;; Boolean attributes of this function.
-  (attributes (required-argument) :type attributes)
+  (attributes (missing-arg) :type attributes)
   ;; A list of Transform structures describing transforms for this function.
   (transforms () :type list)
   ;; A function which computes the derived type for a call to this function by
@@ -122,12 +122,12 @@
   ;; itself, are represented as BUILT-IN-TYPE, and at least as of
   ;; sbcl-0.pre7.54 or so, that's inconsistent with being a
   ;; FUN-TYPE.)
-  (type (required-argument) :type ctype)
+  (type (missing-arg) :type ctype)
   ;; the transformation function. Takes the COMBINATION node and returns a
   ;; lambda, or throws out.
-  (function (required-argument) :type function)
+  (function (missing-arg) :type function)
   ;; string used in efficiency notes
-  (note (required-argument) :type string)
+  (note (missing-arg) :type string)
   ;; T if we should emit a failure note even if SPEED=INHIBIT-WARNINGS.
   (important nil :type (member t nil))
   ;; usable for byte code, native code, or both?
@@ -239,17 +239,17 @@
 ;;; argument. If arg is a list, result is a list. If arg is a vector, result
 ;;; is a vector with the same element type.
 (defun sequence-result-nth-arg (n)
-  #'(lambda (call)
-      (declare (type combination call))
-      (let ((cont (nth (1- n) (combination-args call))))
-       (when cont
-         (let ((type (continuation-type cont)))
-           (if (array-type-p type)
-               (specifier-type
-                `(vector ,(type-specifier (array-type-element-type type))))
-               (let ((ltype (specifier-type 'list)))
-                 (when (csubtypep type ltype)
-                   ltype))))))))
+  (lambda (call)
+    (declare (type combination call))
+    (let ((cont (nth (1- n) (combination-args call))))
+      (when cont
+       (let ((type (continuation-type cont)))
+         (if (array-type-p type)
+             (specifier-type
+              `(vector ,(type-specifier (array-type-element-type type))))
+             (let ((ltype (specifier-type 'list)))
+               (when (csubtypep type ltype)
+                 ltype))))))))
 
 ;;; Derive the type to be the type specifier which is the N'th arg.
 (defun result-type-specifier-nth-arg (n)