* lisp/emacs-lisp/edebug.el (edebug-match-lambda-expr): Delete function

(lambda-expr): Define with `def-edebug-elem-spec` instead.
(edebug--handle-&-spec-op): Remove left over code.
(interactive): Re-add mistakenly removed spec elem.

* doc/lispref/edebug.texi (Specification List): Remove `function-form`.

doc/lispref/edebug.texi

@@ -1290,14 +1290,6 @@ Short for @code{&rest form}.  See @code{&rest} below.  If your macro
 wraps its body of code with @code{lambda} before it is evaluated, use
 @code{def-body} instead.  See @code{def-body} below.
 
-@item function-form
-A function form: either a quoted function symbol, a quoted lambda
-expression, or a form (that should evaluate to a function symbol or
-lambda expression).  This is useful when an argument that's a lambda
-expression might be quoted with @code{quote} rather than
-@code{function}, since it instruments the body of the lambda expression
-either way.
-
 @item lambda-expr
 A lambda expression with no quoting.
 
@@ -1452,7 +1444,7 @@ match @var{spec} against the code and then call @var{fun} with the
 concatenation of the current name, @var{args...}, @var{prestring},
 the code that matched @code{spec}, and @var{poststring}.  If @var{fun}
 is absent, it defaults to a function that concatenates the arguments
-(with an @code{@} between the previous name and the new).
+(with an @code{@@} between the previous name and the new).
 
 @item name
 The argument, a symbol, is the name of the defining form.

etc/NEWS

@@ -940,7 +940,9 @@ To customize obsolete user options, use 'customize-option' or
 **** 'get-edebug-spec' is obsolete, replaced by 'edebug-get-spec'.
 
 +++
-**** The Edebug spec operator ':name NAME' is obsolete.
+**** The spec operator ':name NAME' is obsolete, use '&name' instead.
++++
+**** The spec element 'function-form' is obsolete, use 'form' instead.
 
 +++
 *** New function 'def-edebug-elem-spec' to define Edebug spec elements.

lisp/emacs-lisp/edebug.el

@@ -1753,7 +1753,6 @@ contains a circular object."
 		(def-form . edebug-match-def-form)
 		;; Less frequently used:
 		;; (function . edebug-match-function)
-		(lambda-expr . edebug-match-lambda-expr)
                 (cl-macrolet-expr . edebug-match-cl-macrolet-expr)
                 (cl-macrolet-name . edebug-match-cl-macrolet-name)
                 (cl-macrolet-body . edebug-match-cl-macrolet-body)
@@ -1873,7 +1872,7 @@ and then matches the rest against the output of (FUN ARGS... HEAD)."
   (pcase-let*
       ((`(,spec ,fun . ,args) specs)
        (exps (edebug-cursor-expressions cursor))
-       (instrumented-head (edebug-match-one-spec cursor (or spec 'sexp)))
+       (instrumented-head (edebug-match-one-spec cursor spec))
        (consumed (- (length exps)
                     (length (edebug-cursor-expressions cursor))))
        (newspecs (apply fun (append args (seq-subseq exps 0 consumed)))))
@@ -2026,32 +2025,6 @@ and then matches the rest against the output of (FUN ARGS... HEAD)."
       offsets)
     specs))
 
-(defun edebug-match-lambda-expr (cursor)
-  ;; The expression must be a function.
-  ;; This will match any list form that begins with a symbol
-  ;; that has an edebug-form-spec beginning with &define.  In
-  ;; practice, only lambda expressions should be used.
-  ;; I could add a &lambda specification to avoid confusion.
-  (let* ((sexp (edebug-top-element-required
-		cursor "Expected lambda expression"))
-	 (offset (edebug-top-offset cursor))
-	 (head (and (consp sexp) (car sexp)))
-	 (spec (and (symbolp head) (edebug-get-spec head)))
-	 (edebug-inside-func nil))
-    ;; Find out if this is a defining form from first symbol.
-    (if (and (consp spec) (eq '&define (car spec)))
-	(prog1
-	    (list
-	     (edebug-defining-form
-	      (edebug-new-cursor sexp offset)
-	      (car offset);; before the sexp
-	      (edebug-after-offset cursor)
-	      (cons (symbol-name head) (cdr spec))))
-	  (edebug-move-cursor cursor))
-      (edebug-no-match cursor "Expected lambda expression")
-      )))
-
-
 (cl-defmethod edebug--handle-&-spec-op ((_ (eql &name)) cursor specs)
   "Compute the name for `&name SPEC FUN` spec operator.
 
@@ -2271,12 +2244,19 @@ into `edebug--cl-macrolet-defs' which is checked in `edebug-list-form-args'."
      &optional ["&rest" arg]
      )))
 
+(def-edebug-elem-spec 'lambda-expr
+  '(("lambda" &define lambda-list lambda-doc
+     [&optional ("interactive" interactive)]
+     def-body)))
+
 (def-edebug-elem-spec 'arglist '(lambda-list))  ;; deprecated - use lambda-list.
 
 (def-edebug-elem-spec 'lambda-doc
   '(&optional [&or stringp
                    (&define ":documentation" def-form)]))
 
+(def-edebug-elem-spec 'interactive '(&optional &or stringp def-form))
+
 ;; A function-form is for an argument that may be a function or a form.
 ;; This specially recognizes anonymous functions quoted with quote.
 (def-edebug-elem-spec 'function-form          ;Deprecated, use `form'!