0.pre7.124:

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

diff --git a/src/compiler/ctype.lisp b/src/compiler/ctype.lisp
index 043a52a..8614e92 100644 (file)
--- a/src/compiler/ctype.lisp
+++ b/src/compiler/ctype.lisp
@@ -340,10 +340,10 @@
   ;; The keyword name of this argument. Although keyword names don't
   ;; have to be keywords, we only match on keywords when figuring an
   ;; approximate type.
-  (name (required-argument) :type keyword)
+  (name (missing-arg) :type keyword)
   ;; The position at which this keyword appeared. 0 if it appeared as the
   ;; first argument, etc.
-  (position (required-argument) :type fixnum)
+  (position (missing-arg) :type fixnum)
   ;; a list of all the argument types that have been used with this keyword
   (types nil :type list)
   ;; true if this keyword has appeared only in calls with an obvious
@@ -362,10 +362,10 @@
         (types (approximate-fun-type-types type))
         (args (combination-args call))
         (nargs (length args))
-        (allowp (some #'(lambda (x)
-                          (and (constant-continuation-p x)
-                               (eq (continuation-value x) :allow-other-keys)))
-                         args)))
+        (allowp (some (lambda (x)
+                        (and (constant-continuation-p x)
+                             (eq (continuation-value x) :allow-other-keys)))
+                      args)))
 
     (setf (approximate-fun-type-min-args type)
          (min (approximate-fun-type-min-args type) nargs))
@@ -377,8 +377,8 @@
        ((null old)
         (setf (approximate-fun-type-types type)
               (nconc types
-                     (mapcar #'(lambda (x)
-                                 (list (continuation-type x)))
+                     (mapcar (lambda (x)
+                               (list (continuation-type x)))
                              arg))))
       (when (null arg) (return))
       (pushnew (continuation-type (car arg))
@@ -396,10 +396,10 @@
            (let ((name (continuation-value key)))
              (when (keywordp name)
                (let ((old (find-if
-                           #'(lambda (x)
-                               (and (eq (approximate-key-info-name x) name)
-                                    (= (approximate-key-info-position x)
-                                       pos)))
+                           (lambda (x)
+                             (and (eq (approximate-key-info-name x) name)
+                                  (= (approximate-key-info-position x)
+                                     pos)))
                            (keys)))
                      (val-type (continuation-type val)))
                  (cond (old
@@ -552,8 +552,8 @@
               ((eq int *empty-type*)
                (note-lossage
                 "Definition's declared type for variable ~A:~%  ~S~@
-                  conflicts with this type from ~A:~%  ~S"
-                (leaf-name var) (type-specifier vtype)
+                 conflicts with this type from ~A:~%  ~S"
+                (leaf-debug-name var) (type-specifier vtype)
                 where (type-specifier type))
                (return-from try-type-intersections (values nil nil)))
               (t
@@ -664,10 +664,10 @@
 
        (dolist (key keys)
          (unless (find (key-info-name key) arglist
-                       :key #'(lambda (x)
-                                (let ((info (lambda-var-arg-info x)))
-                                  (when info
-                                    (arg-info-key info)))))
+                       :key (lambda (x)
+                              (let ((info (lambda-var-arg-info x)))
+                                (when info
+                                  (arg-info-key info)))))
            (note-lossage
             "The definition lacks the ~S key present in ~A."
             (key-info-name key) where))))
@@ -753,7 +753,9 @@
                              "Assignment to argument: ~S~%  ~
                               prevents use of assertion from function ~
                               type ~A:~%  ~S~%"
-                             (leaf-name var) where (type-specifier type))))
+                             (leaf-debug-name var)
+                             where
+                             (type-specifier type))))
                  (t
                   (setf (leaf-type var) type)
                   (dolist (ref (leaf-refs var))