anchor.diff:      ;; Magic.
       (update-instance-for-redefined-class instance added-slots discarded-slots property-list)))
   
  +(sys.int::defglobal *u-i-f-r-c-initargs-cache* (make-hash-table))
  +
   (defun check-update-instance-for-redefined-class-initargs (object added-slots discarded-slots property-list initargs)
     (check-initargs
  -   (class-of object)
  +   (class-of object) *u-i-f-r-c-initargs-cache*
      (list (list #'update-instance-for-redefined-class object added-slots discarded-slots property-list)
            (list #'shared-initialize object added-slots))
      initargs
  
positive.code: (defmethod initialize-instance ((instance standard-object) &rest initargs)
    (apply #'shared-initialize instance t initargs))
  
  (defun check-reinitialize-instance-initargs (object initargs)
    (check-initargs
     (class-of object)
     (list (list #'reinitialize-instance object)
           (list #'shared-initialize object t))
     initargs
  
negative.code: (defgeneric slot-missing (class object slot-name operation &optional new-value))
  (defmethod slot-missing ((class t) object slot-name operation &optional new-value)
    (error "Slot ~S missing from class ~S when performing ~S." slot-name class operation))
  
  ;;; Initarg cache maintenance
  
  (defclass initarg-cache-flusher ()
    ((%cache :initarg :cache :reader initarg-cache-flusher-cache)
     (%purge :initarg :purge :initform nil :reader initarg-cache-flusher-purge)))
  
  (defun flush-initarg-caches (class)
    "Remove the entries for CLASS from each cache.
  Does not handle subclasses."
    (remhash class *make-instance-initargs-cache*)
    (remhash class *reinitialize-instance-initargs-cache*)
    (remhash class *u-i-f-d-c-initargs-cache*)
    (remhash class *u-i-f-r-c-initargs-cache*))
  
  (defun flush-initarg-cache-recursively (cache class)
    "Remove CLASS and all subclasses from CACHE."
    (remhash class cache)
    (dolist (subclass (class-direct-subclasses class))
      (flush-initarg-cache-recursively cache subclass)))
  
  (defmethod update-dependent (metaobject (dependent initarg-cache-flusher) &key ((add-method added-method)) ((remove-method removed-method)) &allow-other-keys)
    (flet ((doit (method)
             (flush-initarg-cache-recursively (initarg-cache-flusher-cache dependent)
                                              (first (method-specializers method)))))
      (cond ((initarg-cache-flusher-purge dependent)
             (clrhash (initarg-cache-flusher-cache dependent)))
            (t
             (when added-method (doit added-method))
             (when removed-method (doit removed-method))))))
  
  ;; Make-instance
  (safe-add-dependent #'allocate-instance (make-instance 'initarg-cache-flusher :cache *make-instance-initargs-cache* :purge t))
  (safe-add-dependent #'initialize-instance (make-instance 'initarg-cache-flusher :cache *make-instance-initargs-cache*))
  (safe-add-dependent #'shared-initialize (make-instance 'initarg-cache-flusher :cache *make-instance-initargs-cache*))
  
  ;; Reinitialize-instance
  (safe-add-dependent #'reinitialize-instance (make-instance 'initarg-cache-flusher :cache *reinitialize-instance-initargs-cache*))
  (safe-add-dependent #'shared-initialize (make-instance 'initarg-cache-flusher :cache *reinitialize-instance-initargs-cache*))
  
  ;; Update-instance-for-different-class
  (safe-add-dependent #'update-instance-for-different-class (make-instance 'initarg-cache-flusher :cache *u-i-f-d-c-initargs-cache*))
  (safe-add-dependent #'shared-initialize (make-instance 'initarg-cache-flusher :cache *u-i-f-d-c-initargs-cache*))
  
  ;; Update-instance-for-redefined-class
  (safe-add-dependent #'update-instance-for-redefined-class (make-instance 'initarg-cache-flusher :cache *u-i-f-r-c-initargs-cache*))
  (safe-add-dependent #'shared-initialize (make-instance 'initarg-cache-flusher :cache *u-i-f-r-c-initargs-cache*))
  