anchor.diff:             ((instance standard-object) (new-class symbol) &rest initargs)
     (apply #'change-class instance (find-class new-class) initargs))
   
  +(sys.int::defglobal *u-i-f-d-c-initargs-cache* (make-hash-table))
  +
   (defun check-update-instance-for-different-class-initargs (old new initargs)
     (check-initargs
  -   (class-of new)
  +   (class-of new) *u-i-f-d-c-initargs-cache*
      (list (list #'update-instance-for-different-class old new)
            (list #'shared-initialize new t))
      initargs
  
positive.code:   ;; Refinalize any subclasses.
    (dolist (subclass (safe-class-direct-subclasses class))
      (std-after-reinitialization-for-classes subclass))
    ;; Update dependents
    (safe-map-dependents class (lambda (dep)
                                 (apply #'update-dependent class dep args))))
  
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*))
  