Mark def* macros for indentation

* lisp/widget.el (define-widget-keywords):
* lisp/vc/pcvs.el (defun-cvs-mode):
* lisp/subr.el (defvar-local):
(defvar-keymap):
* lisp/skeleton.el (define-skeleton):
* lisp/simple.el (define-alternatives):
* lisp/progmodes/gud.el (gdb-script-mode):
* lisp/progmodes/gdb-mi.el (def-gdb-preempt-display-buffer):
(def-gdb-auto-update-trigger):
(def-gdb-auto-update-handler):
(def-gdb-trigger-and-handler):
(def-gdb-thread-buffer-command):
(def-gdb-thread-buffer-simple-command):
(def-gdb-thread-buffer-gud-command):
(def-gdb-set-positive-number):
(def-gdb-memory-format):
(def-gdb-memory-unit):
(def-gdb-memory-show-page):
* lisp/progmodes/compile.el (define-compilation-mode):
* lisp/progmodes/cc-vars.el (defcustom-c-stylevar):
* lisp/obsolete/cl.el (define-setf-expander):
(defsetf):
(define-modify-macro):
* lisp/obsolete/cl-compat.el (defkeyword):
* lisp/net/hmac-def.el (define-hmac-function):
* lisp/international/mule-conf.el (define-iso-single-byte-charset):
* lisp/international/ccl.el (define-ccl-program):
* lisp/image.el (defimage):
* lisp/gnus/gmm-utils.el (defun-gmm):
* lisp/ezimage.el (defezimage):
* lisp/erc/erc.el (define-erc-module):
* lisp/emacs-lisp/shortdoc.el (define-short-documentation-group):
* lisp/emacs-lisp/eieio.el (defclass):
* lisp/emacs-lisp/eieio-compat.el (defgeneric):
(defmethod):
* lisp/emacs-lisp/easy-mmode.el (define-minor-mode):
(define-globalized-minor-mode):
* lisp/emacs-lisp/derived.el (define-derived-mode):
* lisp/emacs-lisp/byte-run.el (defsubst):
(define-obsolete-function-alias):
(define-obsolete-variable-alias):
* lisp/custom.el (defcustom):
(defface):
(defgroup):
(deftheme):
* lisp/cedet/semantic/wisent.el (define-wisent-lexer):
* lisp/cedet/semantic/lex.el (define-lex):
(define-lex-analyzer):
(define-lex-regex-analyzer):
(define-lex-simple-regex-analyzer):
(define-lex-block-analyzer):
(define-lex-keyword-type-analyzer):
(define-lex-sexp-type-analyzer):
(define-lex-regex-type-analyzer):
(define-lex-string-type-analyzer):
(define-lex-block-type-analyzer):
* lisp/cedet/semantic/lex-spp.el
(define-lex-spp-macro-declaration-analyzer):
(define-lex-spp-macro-undeclaration-analyzer):
(define-lex-spp-include-analyzer):
* lisp/cedet/semantic/dep.el
(defcustom-mode-local-semantic-dependency-system-include-path):
* lisp/cedet/semantic/decorate/mode.el
(define-semantic-decoration-style):
* lisp/cedet/mode-local.el (define-child-mode):
(define-overloadable-function):
(define-mode-local-override):
* lisp/calc/calc.el (defcalcmodevar):
(defmath): Explicitly mark all macros that have names that start
with "def" that should indent defunly-like (bug#43329).

6 files changed, 24 insertions, 10 deletions

diff --git a/lisp/cedet/mode-local.el b/lisp/cedet/mode-local.el
index 18fb05e7eb4..e0717fbfe5a 100644
--- a/lisp/cedet/mode-local.el
+++ b/lisp/cedet/mode-local.el
@@ -156,7 +156,7 @@ local variables have been defined."
 DOCSTRING is optional and not used.
 To work properly, this should be put after PARENT mode local variables
 definition."
-  (declare (obsolete define-derived-mode "27.1"))
+  (declare (obsolete define-derived-mode "27.1") (indent 2))
   `(mode-local--set-parent ',mode ',parent))
 
 (defun mode-local-use-bindings-p (this-mode desired-mode)
@@ -567,6 +567,7 @@ appropriate arguments deduced from ARGS.
 OVERARGS is a list of arguments passed to the override and
 `NAME-default' function, in place of those deduced from ARGS."
   (declare (doc-string 3)
+           (indent defun)
            (debug (&define name lambda-list stringp def-body)))
   `(eval-and-compile
      (defun ,name ,args
@@ -595,6 +596,7 @@ DOCSTRING is the documentation string.
 BODY is the implementation of this function."
   ;; FIXME: Make this obsolete and use cl-defmethod with &context instead.
   (declare (doc-string 4)
+           (indent defun)
            (debug (&define name symbolp lambda-list stringp def-body)))
   (let ((newname (intern (format "%s-%s" name mode))))
     `(progn
diff --git a/lisp/cedet/semantic/decorate/mode.el b/lisp/cedet/semantic/decorate/mode.el
index 6271fb1ced6..0a234b3000d 100644
--- a/lisp/cedet/semantic/decorate/mode.el
+++ b/lisp/cedet/semantic/decorate/mode.el
@@ -391,6 +391,7 @@ etc., found in the semantic-decorate library.
 To add other kind of decorations on a tag, `NAME-highlight' must use
 `semantic-decorate-tag', and other functions of the semantic
 decoration API found in this library."
+  (declare (indent 1))
   (let ((predicate   (semantic-decorate-style-predicate   name))
         (highlighter (semantic-decorate-style-highlighter name))
 	(predicatedef   (semantic-decorate-style-predicate-default   name))
diff --git a/lisp/cedet/semantic/dep.el b/lisp/cedet/semantic/dep.el
index 0694b9c2329..cae38e6f111 100644
--- a/lisp/cedet/semantic/dep.el
+++ b/lisp/cedet/semantic/dep.el
@@ -82,6 +82,7 @@ users will customize.
 
 Creates a customizable variable users can customize that will
 keep semantic data structures up to date."
+  (declare (indent defun))
   `(progn
      ;; Create a variable users can customize.
      (defcustom ,name ,value
diff --git a/lisp/cedet/semantic/lex-spp.el b/lisp/cedet/semantic/lex-spp.el
index 8073640a8bd..3297367db90 100644
--- a/lisp/cedet/semantic/lex-spp.el
+++ b/lisp/cedet/semantic/lex-spp.el
@@ -1165,7 +1165,8 @@ of type `spp-macro-def' is to be created.
 VALFORM are forms that return the value to be saved for this macro, or nil.
 When implementing a macro, you can use `semantic-lex-spp-stream-for-macro'
 to convert text into a lexical stream for storage in the macro."
-  (declare (debug (&define name stringp stringp form def-body)))
+  (declare (debug (&define name stringp stringp form def-body))
+           (indent 1))
   (let ((start (make-symbol "start"))
 	(end (make-symbol "end"))
 	(val (make-symbol "val"))
@@ -1199,7 +1200,8 @@ REGEXP is a regular expression for the analyzer to match.
 See `define-lex-regex-analyzer' for more on regexp.
 TOKIDX is an index into REGEXP for which a new lexical token
 of type `spp-macro-undef' is to be created."
-  (declare (debug (&define name stringp stringp form)))
+  (declare (debug (&define name stringp stringp form))
+           (indent 1))
   (let ((start (make-symbol "start"))
 	(end (make-symbol "end")))
     `(define-lex-regex-analyzer ,name
@@ -1260,7 +1262,8 @@ type of include.  The return value should be of the form:
   (NAME . TYPE)
 where NAME is the name of the include, and TYPE is the type of the include,
 where a valid symbol is `system', or nil."
-  (declare (debug (&define name stringp stringp form def-body)))
+  (declare (debug (&define name stringp stringp form def-body))
+           (indent 1))
   (let ((start (make-symbol "start"))
 	(end (make-symbol "end"))
 	(val (make-symbol "val"))
diff --git a/lisp/cedet/semantic/lex.el b/lisp/cedet/semantic/lex.el
index 69f20deeb76..d524b733db5 100644
--- a/lisp/cedet/semantic/lex.el
+++ b/lisp/cedet/semantic/lex.el
@@ -760,7 +760,7 @@ If two analyzers can match the same text, it is important to order the
 analyzers so that the one you want to match first occurs first.  For
 example, it is good to put a number analyzer in front of a symbol
 analyzer which might mistake a number for a symbol."
-  (declare (debug (&define name stringp (&rest symbolp))))
+  (declare (debug (&define name stringp (&rest symbolp))) (indent 1))
   `(defun ,name  (start end &optional depth length)
      ,(concat doc "\nSee `semantic-lex' for more information.")
      ;; Make sure the state of block parsing starts over.
@@ -1096,7 +1096,7 @@ Proper action in FORMS is to move the value of `semantic-lex-end-point' to
 after the location of the analyzed entry, and to add any discovered tokens
 at the beginning of `semantic-lex-token-stream'.
 This can be done by using `semantic-lex-push-token'."
-  (declare (debug (&define name stringp form def-body)))
+  (declare (debug (&define name stringp form def-body)) (indent 1))
   `(eval-and-compile
      ;; This is the real info used by `define-lex' (via semantic-lex-one-token).
      (defconst ,name '(,condition ,@forms) ,doc)
@@ -1118,7 +1118,7 @@ This can be done by using `semantic-lex-push-token'."
   "Create a lexical analyzer with NAME and DOC that will match REGEXP.
 FORMS are evaluated upon a successful match.
 See `define-lex-analyzer' for more about analyzers."
-  (declare (debug (&define name stringp form def-body)))
+  (declare (debug (&define name stringp form def-body)) (indent 1))
   `(define-lex-analyzer ,name
      ,doc
      (looking-at ,regexp)
@@ -1137,7 +1137,8 @@ FORMS are evaluated upon a successful match BEFORE the new token is
 created.  It is valid to ignore FORMS.
 See `define-lex-analyzer' for more about analyzers."
   (declare (debug
-            (&define name stringp form symbolp [ &optional form ] def-body)))
+            (&define name stringp form symbolp [ &optional form ] def-body))
+           (indent 1))
   `(define-lex-analyzer ,name
      ,doc
      (looking-at ,regexp)
@@ -1162,7 +1163,8 @@ where BLOCK-SYM is the symbol returned in a block token.  OPEN-DELIM
 and CLOSE-DELIM are respectively the open and close delimiters
 identifying a block.  OPEN-SYM and CLOSE-SYM are respectively the
 symbols returned in open and close tokens."
-  (declare (debug (&define name stringp form (&rest form))))
+  (declare (debug (&define name stringp form (&rest form)))
+           (indent 1))
   (let ((specs (cons spec1 specs))
         spec open olist clist)
     (while specs
@@ -1471,6 +1473,7 @@ syntax as specified by the syntax table."
 (defmacro define-lex-keyword-type-analyzer (name doc syntax)
   "Define a keyword type analyzer NAME with DOC string.
 SYNTAX is the regexp that matches a keyword syntactic expression."
+  (declare (indent 1))
   (let ((key (make-symbol "key")))
     `(define-lex-analyzer ,name
        ,doc
@@ -1486,6 +1489,7 @@ SYNTAX is the regexp that matches a keyword syntactic expression."
   "Define a sexp type analyzer NAME with DOC string.
 SYNTAX is the regexp that matches the beginning of the s-expression.
 TOKEN is the lexical token returned when SYNTAX matches."
+  (declare (indent 1))
   `(define-lex-regex-analyzer ,name
      ,doc
      ,syntax
@@ -1504,6 +1508,7 @@ SYNTAX is the regexp that matches a syntactic expression.
 MATCHES is an alist of lexical elements used to refine the syntactic
 expression.
 DEFAULT is the default lexical token returned when no MATCHES."
+  (declare (indent 1))
   (if matches
       (let* ((val (make-symbol "val"))
              (lst (make-symbol "lst"))
@@ -1536,6 +1541,7 @@ SYNTAX is the regexp that matches a syntactic expression.
 MATCHES is an alist of lexical elements used to refine the syntactic
 expression.
 DEFAULT is the default lexical token returned when no MATCHES."
+  (declare (indent 1))
   (if matches
       (let* ((val (make-symbol "val"))
              (lst (make-symbol "lst"))
@@ -1633,6 +1639,7 @@ When the lexer encounters the open-paren delimiter \"(\":
  - If the maximum depth of parenthesis tracking is reached (current
    depth >= max depth), it returns the whole parenthesis block as
    a (PAREN_BLOCK start . end) token."
+  (declare (indent 1))
   (let* ((val (make-symbol "val"))
          (lst (make-symbol "lst"))
          (elt (make-symbol "elt")))
diff --git a/lisp/cedet/semantic/wisent.el b/lisp/cedet/semantic/wisent.el
index f5f381d4079..afcdd142822 100644
--- a/lisp/cedet/semantic/wisent.el
+++ b/lisp/cedet/semantic/wisent.el
@@ -66,7 +66,7 @@ Returned tokens must have the form:
   (TOKSYM VALUE START . END)
 
 where VALUE is the buffer substring between START and END positions."
-  (declare (debug (&define name stringp def-body)))
+  (declare (debug (&define name stringp def-body)) (indent 1))
   `(defun
      ,name () ,doc
      (cond