The inline lambda created for a call to a generic function with keyword arguments and calls to call-next-method with arguments.

fast-method-keyword-handling.lisp

(lambda
    (#:x-1 &key ((:y #:y-2) nil #:suppliedp-3) ((:z #:z-4) nil #:suppliedp-5))
  (declare (ignorable #:x-1 #:y-2 #:suppliedp-3 #:z-4 #:suppliedp-5))
  (let ((sealable-metaobjects::.gf. #'keyword-function))
    (declare (ignorable sealable-metaobjects::.gf.))
    (declare (sb-ext:disable-package-locks call-method))
    (declare (sb-ext:disable-package-locks make-method))
    (declare (sb-ext:disable-package-locks sb-pcl::check-applicable-keywords))
    (macrolet ((sb-pcl::check-applicable-keywords
                   (&rest sealable-metaobjects::args)
                 (declare (ignore sealable-metaobjects::args))
                 `(progn
                   sb-pcl::.valid-keys.
                   sb-pcl::.keyargs-start.
                   (values))))
      (macrolet ((call-method
                     (method &optional sealable-metaobjects::next-methods)
                   (sealable-metaobjects::expand-call-method method
                                                             sealable-metaobjects::next-methods
                                                             '(#:x-1 &key
                                                               ((:y #:y-2) nil
                                                                #:suppliedp-3)
                                                               ((:z #:z-4) nil
                                                                #:suppliedp-5))
                                                             'fast-method)))
        (flet ((sealable-metaobjects::reinitialize-arguments
                   (#:x-6
                    &key ((:y #:y-7) nil #:suppliedp-8)
                    ((:z #:z-9) nil #:suppliedp-10))
                 (setq #:x-1 #:x-6)
                 (setq #:y-2 #:y-7)
                 (setq #:suppliedp-3 #:suppliedp-8)
                 (setq #:z-4 #:z-9)
                 (setq #:suppliedp-5 #:suppliedp-10)))
          (declare
           (ignorable (function sealable-metaobjects::reinitialize-arguments)))
          (let ((sb-pcl::.valid-keys. '(:y :z)) (sb-pcl::.keyargs-start. '0))
            (progn sb-pcl::.valid-keys. sb-pcl::.keyargs-start. (values))
            (flet ((next-method-p ()
                     nil)
                   (call-next-method ()
                     (no-next-method sealable-metaobjects::.gf.
                                     (specializer-prototype
                                      (find-class 'fast-method)))))
              (declare
               (ignorable (function next-method-p)
                (function call-next-method)))
              (flet ((next-method-p ()
                       t)
                     (call-next-method (&rest sealable-metaobjects::args)
                       (if (null sealable-metaobjects::args)
                           nil
                           (apply
                            #'sealable-metaobjects::reinitialize-arguments
                            sealable-metaobjects::args))
                       (flet ((next-method-p ()
                                nil)
                              (call-next-method ()
                                (no-next-method sealable-metaobjects::.gf.
                                                (specializer-prototype
                                                 (find-class 'fast-method)))))
                         (declare
                          (ignorable (function next-method-p)
                           (function call-next-method)))
                         (funcall
                          (lambda (x y z)
                            (declare (ignorable x))
                            (block keyword-function (list x y z)))
                          #:x-1
                          (if #:suppliedp-3
                              #:y-2
                              3)
                          (if #:suppliedp-5
                              #:z-4
                              4)))))
                (declare
                 (ignorable (function next-method-p)
                  (function call-next-method)))
                (funcall
                 (lambda (x y z)
                   (declare (ignorable x))
                   (block keyword-function
                     (list x y z (call-next-method x :y y))))
                 #:x-1
                 (if #:suppliedp-3
                     #:y-2
                     nil)
                 (if #:suppliedp-5
                     #:z-4
                     nil))))))))))