0.pre8.6:

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

diff --git a/src/pcl/dfun.lisp b/src/pcl/dfun.lisp
index 9d59ea8..4d81f4b 100644 (file)
--- a/src/pcl/dfun.lisp
+++ b/src/pcl/dfun.lisp
@@ -628,8 +628,7 @@ And so, we are saved.
     (maphash (lambda (classes value)
               (setq cache (fill-cache cache
                                       (class-wrapper classes)
-                                      value
-                                      t)))
+                                      value)))
             table)
     cache))
 
@@ -689,7 +688,7 @@ And so, we are saved.
 
 (defun make-initial-dfun (gf)
   (let ((initial-dfun
-        #'(sb-kernel:instance-lambda (&rest args)
+        #'(instance-lambda (&rest args)
             (initial-dfun gf args))))
     (multiple-value-bind (dfun cache info)
        (if (and (eq *boot-state* 'complete)
@@ -725,17 +724,17 @@ And so, we are saved.
   (let* ((methods (early-gf-methods gf))
         (slot-name (early-method-standard-accessor-slot-name (car methods))))
     (ecase type
-      (reader #'(sb-kernel:instance-lambda (instance)
+      (reader #'(instance-lambda (instance)
                  (let* ((class (class-of instance))
                         (class-name (!bootstrap-get-slot 'class class 'name)))
                    (!bootstrap-get-slot class-name instance slot-name))))
-      (boundp #'(sb-kernel:instance-lambda (instance)
+      (boundp #'(instance-lambda (instance)
                  (let* ((class (class-of instance))
                         (class-name (!bootstrap-get-slot 'class class 'name)))
                    (not (eq +slot-unbound+
                             (!bootstrap-get-slot class-name
                                                  instance slot-name))))))
-      (writer #'(sb-kernel:instance-lambda (new-value instance)
+      (writer #'(instance-lambda (new-value instance)
                  (let* ((class (class-of instance))
                         (class-name (!bootstrap-get-slot 'class class 'name)))
                    (!bootstrap-set-slot class-name instance slot-name new-value)))))))
@@ -829,7 +828,7 @@ And so, we are saved.
        specls all-same-p)
     (cond ((null methods)
           (values
-           #'(sb-kernel:instance-lambda (&rest args)
+           #'(instance-lambda (&rest args)
                (apply #'no-applicable-method gf args))
            nil
            (no-methods-dfun-info)))
@@ -1474,7 +1473,7 @@ And so, we are saved.
       (if function-p
          (lambda (method-alist wrappers)
            (declare (ignore method-alist wrappers))
-           #'(sb-kernel:instance-lambda (&rest args)
+           #'(instance-lambda (&rest args)
                (apply #'no-applicable-method gf args)))
          (lambda (method-alist wrappers)
            (declare (ignore method-alist wrappers))
@@ -1539,15 +1538,13 @@ And so, we are saved.
   (let* ((early-p (early-gf-p generic-function))
         (gf-name (if early-p
                      (!early-gf-name generic-function)
-                     (generic-function-name generic-function)))
-        (ocache (gf-dfun-cache generic-function)))
+                     (generic-function-name generic-function))))
     (set-dfun generic-function dfun cache info)
     (let ((dfun (if early-p
                    (or dfun (make-initial-dfun generic-function))
                    (compute-discriminating-function generic-function))))
-      (set-funcallable-instance-fun generic-function dfun)
+      (set-funcallable-instance-function generic-function dfun)
       (set-fun-name generic-function gf-name)
-      (when (and ocache (not (eq ocache cache))) (free-cache ocache))
       dfun)))
 \f
 (defvar *dfun-count* nil)