1.0.31.9: some PCL micro-optimizations

[sbcl.git] / src / pcl / defclass.lisp

diff --git a/src/pcl/defclass.lisp b/src/pcl/defclass.lisp
index 85d0fc3..d7870b7 100644 (file)
--- a/src/pcl/defclass.lisp
+++ b/src/pcl/defclass.lisp
@@ -53,7 +53,7 @@
           ;; DEFSTRUCT-P should be true if the class is defined
           ;; with a metaclass STRUCTURE-CLASS, so that a DEFSTRUCT
           ;; is compiled for the class.
-          (defstruct-p (and (eq *boot-state* 'complete)
+          (defstruct-p (and (eq **boot-state** 'complete)
                             (let ((mclass (find-class metaclass nil)))
                               (and mclass
                                    (*subtypep
@@ -72,7 +72,8 @@
                                 ',*readers-for-this-defclass*
                                 ',*writers-for-this-defclass*
                                 ',*slot-names-for-this-defclass*
-                                (sb-c:source-location)))))
+                                (sb-c:source-location)
+                                ',(safe-code-p env)))))
         (if defstruct-p
             (progn
               ;; FIXME: (YUK!) Why do we do this? Because in order
@@ -120,9 +121,10 @@
 (defun canonize-defclass-options (class-name options)
   (maplist (lambda (sublist)
              (let ((option-name (first (pop sublist))))
-               (when (member option-name sublist :key #'first)
-                 (error "Multiple ~S options in DEFCLASS ~S."
-                        option-name class-name))))
+               (when (member option-name sublist :key #'first :test #'eq)
+                 (error 'simple-program-error
+                        :format-control "Multiple ~S options in DEFCLASS ~S."
+                        :format-arguments (list option-name class-name)))))
            options)
   (let (metaclass
         default-initargs
@@ -135,14 +137,15 @@
           (:metaclass
            (let ((maybe-metaclass (second option)))
              (unless (and maybe-metaclass (legal-class-name-p maybe-metaclass))
-               (error "~@<The value of the :metaclass option (~S) ~
+               (error 'simple-program-error
+                      :format-control "~@<The value of the :metaclass option (~S) ~
                          is not a legal class name.~:@>"
-                      maybe-metaclass))
+                      :format-arguments (list maybe-metaclass)))
              (setf metaclass maybe-metaclass)))
           (:default-initargs
            (let (initargs arg-names)
              (doplist (key val) (cdr option)
-               (when (member key arg-names)
+               (when (member key arg-names :test #'eq)
                  (error 'simple-program-error
                         :format-control "~@<Duplicate initialization argument ~
                                            name ~S in :DEFAULT-INITARGS of ~
@@ -181,6 +184,7 @@
              (initargs ())
              (others ())
              (unsupplied (list nil))
+             (type t)
              (initform unsupplied))
         (check-slot-name-for-defclass name class-name env)
         (push name *slot-names-for-this-defclass*)
@@ -211,6 +215,8 @@
                (when (member key '(:initform :allocation :type :documentation))
                  (when (eq key :initform)
                    (setf initform val))
+                 (when (eq key :type)
+                   (setf type val))
                  (when (get-properties others (list key))
                    (error 'simple-program-error
                           :format-control "Duplicate slot option ~S for slot ~
@@ -223,8 +229,17 @@
             ((null head))
           (unless (cdr (second head))
             (setf (second head) (car (second head)))))
-        (let ((canon `(:name ',name :readers ',readers :writers ',writers
-                             :initargs ',initargs ',others)))
+        (let* ((type-check-function
+                (if (eq type t)
+                    nil
+                    `('type-check-function (lambda (value)
+                                             (declare (type ,type value)
+                                                      (optimize (sb-c:store-coverage-data 0)))
+                                             value))))
+               (canon `(:name ',name :readers ',readers :writers ',writers
+                              :initargs ',initargs
+                              ,@type-check-function
+                              ',others)))
           (push (if (eq initform unsupplied)
                     `(list* ,@canon)
                     `(list* :initfunction ,(make-initfunction initform)
@@ -246,7 +261,7 @@
            (slot-name-illegal "a keyword"))
           ((constantp name env)
            (slot-name-illegal "a constant"))
-          ((member name *slot-names-for-this-defclass*)
+          ((member name *slot-names-for-this-defclass* :test #'eq)
            (error 'simple-program-error
                   :format-control "Multiple slots named ~S in DEFCLASS ~S."
                   :format-arguments (list name class-name))))))
@@ -267,7 +282,10 @@
            (unless entry
              (setq entry (list initform
                                (gensym)
-                               `(function (lambda () ,initform))))
+                               `(function (lambda ()
+                                  (declare (optimize
+                                            (sb-c:store-coverage-data 0)))
+                                  ,initform))))
              (push entry *initfunctions-for-this-defclass*))
            (cadr entry)))))
 
@@ -463,20 +481,23 @@
 
 (declaim (notinline load-defclass))
 (defun load-defclass (name metaclass supers canonical-slots canonical-options
-                      readers writers slot-names source-location)
+                      readers writers slot-names source-location safe-p)
+  ;; SAFE-P is used by REAL-LOAD-DEFCLASS, but can be ignored here, since
+  ;; during the bootstrap we won't have (SAFETY 3).
+  (declare (ignore safe-p))
   (%compiler-defclass name readers writers slot-names)
   (setq supers  (copy-tree supers)
         canonical-slots   (copy-tree canonical-slots)
         canonical-options (copy-tree canonical-options))
   (let ((ecd
-          (make-early-class-definition name
-                                       source-location
-                                       metaclass
-                                       supers
-                                       canonical-slots
-                                       canonical-options))
+         (make-early-class-definition name
+                                      source-location
+                                      metaclass
+                                      supers
+                                      canonical-slots
+                                      canonical-options))
         (existing
-          (find name *early-class-definitions* :key #'ecd-class-name)))
+         (find name *early-class-definitions* :key #'ecd-class-name)))
     (setq *early-class-definitions*
           (cons ecd (remove existing *early-class-definitions*)))
     ecd))