macro_name: ADVISABLE-LAMBDA

library: cl-advice

call_form: (advisable-lambda)

status: expansion-error

error:
Error while parsing arguments to DEFMACRO ADVISABLE-LAMBDA:
  too few elements in
    ()
  to satisfy lambda list
    (ARGSLIST &BODY BODY):
  at least 1 expected, but got 0


call_form: (advisable-lambda nil)

expanded:
(make-instance 'advisable-function :main #'(lambda ()) :arguments 'nil
               :dispatcher-generator
               #'(lambda (#:fobj128)
                   #'(lambda ()
                       #A((29) base-char . "Advisable function dispatcher")
                       (let ((#:fixed129 (append)))
                         (apply-before #:fobj128 #:fixed129)
                         (multiple-value-prog1
                             (apply-around #:fobj128 #:fixed129)
                           (apply-after #:fobj128 #:fixed129))))))

status: verified


call_form:
(advisable-lambda nil
  nil)

expanded:
(make-instance 'advisable-function :main #'(lambda () nil) :arguments 'nil
               :dispatcher-generator
               #'(lambda (#:fobj130)
                   #'(lambda ()
                       #A((29) base-char . "Advisable function dispatcher")
                       (let ((#:fixed131 (append)))
                         (apply-before #:fobj130 #:fixed131)
                         (multiple-value-prog1
                             (apply-around #:fobj130 #:fixed131)
                           (apply-after #:fobj130 #:fixed131))))))


call_form:
(advisable-lambda nil
  (progn))

expanded:
(make-instance 'advisable-function :main #'(lambda () (progn)) :arguments 'nil
               :dispatcher-generator
               #'(lambda (#:fobj132)
                   #'(lambda ()
                       #A((29) base-char . "Advisable function dispatcher")
                       (let ((#:fixed133 (append)))
                         (apply-before #:fobj132 #:fixed133)
                         (multiple-value-prog1
                             (apply-around #:fobj132 #:fixed133)
                           (apply-after #:fobj132 #:fixed133))))))


call_form:
(advisable-lambda nil
  :key
  nil)

expanded:
(make-instance 'advisable-function :main #'(lambda () :key nil) :arguments 'nil
               :dispatcher-generator
               #'(lambda (#:fobj134)
                   #'(lambda ()
                       #A((29) base-char . "Advisable function dispatcher")
                       (let ((#:fixed135 (append)))
                         (apply-before #:fobj134 #:fixed135)
                         (multiple-value-prog1
                             (apply-around #:fobj134 #:fixed135)
                           (apply-after #:fobj134 #:fixed135))))))


call_form: (advisable-lambda 'lol-gen::some-name)

expanded:
(make-instance 'advisable-function :main #'(lambda (quote lol-gen::some-name))
               :arguments ''lol-gen::some-name :dispatcher-generator
               #'(lambda (#:fobj136)
                   #'(lambda (quote lol-gen::some-name)
                       #A((29) base-char . "Advisable function dispatcher")
                       (let ((#:fixed137
                              (append (list quote) (list lol-gen::some-name))))
                         (apply-before #:fobj136 #:fixed137)
                         (multiple-value-prog1
                             (apply-around #:fobj136 #:fixed137)
                           (apply-after #:fobj136 #:fixed137))))))


macro_name: WITH-IMPLICIT-CONVERSION

call_form: (with-implicit-conversion)

error:
Error while parsing arguments to DEFMACRO WITH-IMPLICIT-CONVERSION:
  too few elements in
    ()
  to satisfy lambda list
    ((ALLOW-OR-NOT &OPTIONAL ABORT-ON-IMPLICIT-CONVERSION RETURN-ON-ABORT)
     &BODY BODY):
  at least 1 expected, but got 0


call_form: (with-implicit-conversion nil)

error:
Error while parsing arguments to DEFMACRO WITH-IMPLICIT-CONVERSION:
  too few elements in
    ()
  to satisfy lambda list
    (ALLOW-OR-NOT &OPTIONAL ABORT-ON-IMPLICIT-CONVERSION RETURN-ON-ABORT):
  between 1 and 3 expected, but got 0


call_form:
(with-implicit-conversion nil
  nil)


call_form:
(with-implicit-conversion nil
  (progn))


call_form:
(with-implicit-conversion nil
  :key
  nil)


expanded:
(let ((*allow-implicit-conversion* (eql quote :allowed)))
  (block #:blockname138
    (handler-bind ((implicit-conversion-to-advisable-function
                    (lambda (#:c139)
                      (declare (ignore #:c139))
                      (return-from #:blockname138 nil))))
      (locally))))


macro_name: WITH-UNADVISABLE-FUNCTION

call_form: (with-unadvisable-function)

error:
Error while parsing arguments to DEFMACRO WITH-UNADVISABLE-FUNCTION:
  too few elements in
    ()
  to satisfy lambda list
    ((FUNCTION-SYMBOL &KEY (RESTORE-WITH-CHANGES)) &BODY BODY):
  at least 1 expected, but got 0


call_form: (with-unadvisable-function nil)

error:
Error while parsing arguments to DEFMACRO WITH-UNADVISABLE-FUNCTION:
  too few elements in
    ()
  to satisfy lambda list
    (FUNCTION-SYMBOL &KEY (RESTORE-WITH-CHANGES)):
  at least 1 expected, but got 0


call_form:
(with-unadvisable-function nil
  nil)


call_form:
(with-unadvisable-function nil
  (progn))


call_form:
(with-unadvisable-function nil
  :key
  nil)


error:
Error while parsing arguments to WITH-UNADVISABLE-FUNCTION DEFMACRO:
  odd number of elements in keyword/value list: (LOL-GEN::SOME-NAME)


macro_name: DEFUN-ADVISABLE

call_form: (defun-advisable)

error:
Error while parsing arguments to DEFMACRO DEFUN-ADVISABLE:
  too few elements in
    ()
  to satisfy lambda list
    (NAME ARGSLIST &BODY BODY):
  at least 2 expected, but got 0


call_form: (defun-advisable nil)

error:
Error while parsing arguments to DEFMACRO DEFUN-ADVISABLE:
  too few elements in
    (NIL)
  to satisfy lambda list
    (NAME ARGSLIST &BODY BODY):
  at least 2 expected, but got 1


call_form:
(defun-advisable nil
    nil)

expanded:
(let ((#:oldfn140
       (handler-case (symbol-function 'nil) (undefined-function nil nil))))
  (defun nil ())
  (make-advisable 'nil :arguments 'nil)
  (when
      (and #:oldfn140
           (not (eql (advisable-function-arguments #:oldfn140) :not-provided))
           (equal (advisable-function-arguments #:oldfn140) 'nil))
    (copy-advice #:oldfn140 (symbol-function 'nil))))


call_form:
(defun-advisable nil
    (progn))

expanded:
(let ((#:oldfn141
       (handler-case (symbol-function 'nil) (undefined-function nil nil))))
  (defun nil (progn))
  (make-advisable 'nil :arguments '(progn))
  (when
      (and #:oldfn141
           (not (eql (advisable-function-arguments #:oldfn141) :not-provided))
           (equal (advisable-function-arguments #:oldfn141) '(progn)))
    (copy-advice #:oldfn141 (symbol-function 'nil))))


call_form:
(defun-advisable nil
    :key
  nil)

expanded:
(let ((#:oldfn142
       (handler-case (symbol-function 'nil) (undefined-function nil nil))))
  (defun nil :key nil)
  (make-advisable 'nil :arguments ':key)
  (when
      (and #:oldfn142
           (not (eql (advisable-function-arguments #:oldfn142) :not-provided))
           (equal (advisable-function-arguments #:oldfn142) ':key))
    (copy-advice #:oldfn142 (symbol-function 'nil))))


call_form: (defun-advisable 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DEFUN-ADVISABLE:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (NAME ARGSLIST &BODY BODY):
  at least 2 expected, but got 1


macro_name: DEFINE-ADVISORY-FUNCTIONS

call_form: (define-advisory-functions)

error:
Error while parsing arguments to DEFMACRO DEFINE-ADVISORY-FUNCTIONS:
  too few elements in
    ()
  to satisfy lambda list
    ((TO-ADVISE &KEY (NEXT-ARG)) ARGS &BODY ADVICE):
  at least 2 expected, but got 0


call_form: (define-advisory-functions nil)

error:
Error while parsing arguments to DEFMACRO DEFINE-ADVISORY-FUNCTIONS:
  too few elements in
    (NIL)
  to satisfy lambda list
    ((TO-ADVISE &KEY (NEXT-ARG)) ARGS &BODY ADVICE):
  at least 2 expected, but got 1


call_form:
(define-advisory-functions nil
    nil)

error:
Error while parsing arguments to DEFMACRO DEFINE-ADVISORY-FUNCTIONS:
  too few elements in
    ()
  to satisfy lambda list
    (TO-ADVISE &KEY (NEXT-ARG)):
  at least 1 expected, but got 0


call_form:
(define-advisory-functions nil
    (progn))


call_form:
(define-advisory-functions nil
    :key
  nil)


error:
Error while parsing arguments to DEFMACRO DEFINE-ADVISORY-FUNCTIONS:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ((TO-ADVISE &KEY (NEXT-ARG)) ARGS &BODY ADVICE):
  at least 2 expected, but got 1