* lisp/emacs-lisp/lisp-mode.el (doc-string-elt): Move those properties to

their respective macro declarations.
* lisp/skeleton.el (define-skeleton):
* lisp/progmodes/compile.el (define-compilation-mode):
* lisp/ibuf-macs.el (define-ibuffer-sorter, define-ibuffer-op)
(define-ibuffer-filter):
* lisp/emacs-lisp/generic.el (define-generic-mode):
* lisp/emacs-lisp/easy-mmode.el (define-minor-mode)
(define-globalized-minor-mode):
* lisp/emacs-lisp/cl-macs.el (defun*, defmacro*, defstruct, deftype):
* lisp/emacs-lisp/byte-run.el (defsubst):
* lisp/custom.el (deftheme): Add doc-string metadata.

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index fcdb2ce65b75a3f5254dcca95432ee2a26ce965c..e22b3d0798509cdcb7f89b4ed17387d419107a61 100644 (file)
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,18 @@
+2012-05-18  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+       * emacs-lisp/lisp-mode.el (doc-string-elt): Move those properties to
+       their respective macro declarations.
+       * skeleton.el (define-skeleton):
+       * progmodes/compile.el (define-compilation-mode):
+       * ibuf-macs.el (define-ibuffer-sorter, define-ibuffer-op)
+       (define-ibuffer-filter):
+       * emacs-lisp/generic.el (define-generic-mode):
+       * emacs-lisp/easy-mmode.el (define-minor-mode)
+       (define-globalized-minor-mode):
+       * emacs-lisp/cl-macs.el (defun*, defmacro*, defstruct, deftype):
+       * emacs-lisp/byte-run.el (defsubst):
+       * custom.el (deftheme): Add doc-string metadata.
+
 2012-05-17  Stefan Monnier  <monnier@iro.umontreal.ca>
 
        * emacs-lisp/cl-macs.el, emacs-lisp/cl.el: Move indent info.

diff --git a/lisp/cedet/mode-local.el b/lisp/cedet/mode-local.el
index 7346e88797d7badb5b991b34b15ee0ecc7923ff6..11968f3fa3513c40122b9261f06304063c320910 100644 (file)
--- a/lisp/cedet/mode-local.el
+++ b/lisp/cedet/mode-local.el
@@ -522,6 +522,9 @@ See also the function `define-overload'."
         (list (mode-local--override name args body))
       result)))
 
+;;;###autoload
+(put 'define-overloadable-function 'doc-string-elt 3)
+
 (defmacro define-overloadable-function (name args docstring &rest body)
   "Define a new function, as with `defun', which can be overloaded.
 NAME is the name of the function to create.
@@ -546,6 +549,7 @@ defined.  The default is to call the function `NAME-default' with the
 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))
   `(eval-and-compile
      (defun ,name ,args
        ,docstring

diff --git a/lisp/custom.el b/lisp/custom.el
index d0eadcc23ff1bbb691a324a48c4a464ef07c8b4f..50481f2aa7f416d1d461d3cae644f4469b4175e8 100644 (file)
--- a/lisp/custom.el
+++ b/lisp/custom.el
@@ -1048,6 +1048,7 @@ The optional argument DOC is a doc string describing the theme.
 
 Any theme `foo' should be defined in a file called `foo-theme.el';
 see `custom-make-theme-feature' for more information."
+  (declare (doc-string 2))
   (let ((feature (custom-make-theme-feature theme)))
     ;; It is better not to use backquote in this file,
     ;; because that makes a bootstrapping problem

diff --git a/lisp/emacs-lisp/byte-run.el b/lisp/emacs-lisp/byte-run.el
index dc7166bc2ea775528a3f2b90221657d080bfe31f..7de3396f8edea5288a0af0eb169d45e9f949d7da 100644 (file)
--- a/lisp/emacs-lisp/byte-run.el
+++ b/lisp/emacs-lisp/byte-run.el
@@ -96,7 +96,7 @@ The return value of this function is not used."
 ;; This has a special byte-hunk-handler in bytecomp.el.
 (defmacro defsubst (name arglist &rest body)
   "Define an inline function.  The syntax is just like that of `defun'."
-  (declare (debug defun))
+  (declare (debug defun) (doc-string 3))
   (or (memq (get name 'byte-optimizer)
            '(nil byte-compile-inline-expand))
       (error "`%s' is a primitive" name))

diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el
index d16b98630c8c5aafb67d2e4c67b6c185ace68cec..a9380619e6a3a9b5c8682d4104d7d6ddfe9e696e 100644 (file)
--- a/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@ -286,7 +286,7 @@ This also does some trivial optimizations to make the form prettier.
 ;;;;;;  flet progv psetq do-all-symbols do-symbols dotimes dolist
 ;;;;;;  do* do loop return-from return block etypecase typecase ecase
 ;;;;;;  case load-time-value eval-when destructuring-bind function*
-;;;;;;  defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "ed94b3ba46080516e6ada69bdf617be5")
+;;;;;;  defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "c383ef0fa5f6d28796cd8e9cf65e1c5d")
 ;;; Generated autoloads from cl-macs.el
 
 (autoload 'gensym "cl-macs" "\
@@ -308,6 +308,10 @@ and BODY is implicitly surrounded by (block NAME ...).
 
 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro))
 
+(put 'defun* 'lisp-indent-function '2)
+
+(put 'defun* 'doc-string-elt '3)
+
 (autoload 'defmacro* "cl-macs" "\
 Define NAME as a macro.
 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
@@ -315,6 +319,10 @@ and BODY is implicitly surrounded by (block NAME ...).
 
 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro))
 
+(put 'defmacro* 'lisp-indent-function '2)
+
+(put 'defmacro* 'doc-string-elt '3)
+
 (autoload 'function* "cl-macs" "\
 Introduce a function.
 Like normal `function', except that if argument is a lambda form,
@@ -327,6 +335,8 @@ its argument list allows full Common Lisp conventions.
 
 \(fn ARGS EXPR &rest BODY)" nil (quote macro))
 
+(put 'destructuring-bind 'lisp-indent-function '2)
+
 (autoload 'eval-when "cl-macs" "\
 Control when BODY is evaluated.
 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
@@ -335,6 +345,8 @@ If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.
 
 \(fn (WHEN...) BODY...)" nil (quote macro))
 
+(put 'eval-when 'lisp-indent-function '1)
+
 (autoload 'load-time-value "cl-macs" "\
 Like `progn', but evaluates the body at load time.
 The result of the body appears to the compiler as a quoted constant.
@@ -352,12 +364,16 @@ Key values are compared by `eql'.
 
 \(fn EXPR (KEYLIST BODY...)...)" nil (quote macro))
 
+(put 'case 'lisp-indent-function '1)
+
 (autoload 'ecase "cl-macs" "\
 Like `case', but error if no case fits.
 `otherwise'-clauses are not allowed.
 
 \(fn EXPR (KEYLIST BODY...)...)" nil (quote macro))
 
+(put 'ecase 'lisp-indent-function '1)
+
 (autoload 'typecase "cl-macs" "\
 Evals EXPR, chooses among clauses on that value.
 Each clause looks like (TYPE BODY...).  EXPR is evaluated and, if it
@@ -367,12 +383,16 @@ final clause, and matches if no other keys match.
 
 \(fn EXPR (TYPE BODY...)...)" nil (quote macro))
 
+(put 'typecase 'lisp-indent-function '1)
+
 (autoload 'etypecase "cl-macs" "\
 Like `typecase', but error if no case fits.
 `otherwise'-clauses are not allowed.
 
 \(fn EXPR (TYPE BODY...)...)" nil (quote macro))
 
+(put 'etypecase 'lisp-indent-function '1)
+
 (autoload 'block "cl-macs" "\
 Define a lexically-scoped block named NAME.
 NAME may be any symbol.  Code inside the BODY forms can call `return-from'
@@ -385,6 +405,8 @@ called from BODY.
 
 \(fn NAME &rest BODY)" nil (quote macro))
 
+(put 'block 'lisp-indent-function '1)
+
 (autoload 'return "cl-macs" "\
 Return from the block named nil.
 This is equivalent to `(return-from nil RESULT)'.
@@ -400,6 +422,8 @@ This is compatible with Common Lisp, but note that `defun' and
 
 \(fn NAME &optional RESULT)" nil (quote macro))
 
+(put 'return-from 'lisp-indent-function '1)
+
 (autoload 'loop "cl-macs" "\
 The Common Lisp `loop' macro.
 Valid clauses are:
@@ -421,11 +445,15 @@ The Common Lisp `do' loop.
 
 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil (quote macro))
 
+(put 'do 'lisp-indent-function '2)
+
 (autoload 'do* "cl-macs" "\
 The Common Lisp `do*' loop.
 
 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil (quote macro))
 
+(put 'do* 'lisp-indent-function '2)
+
 (autoload 'dolist "cl-macs" "\
 Loop over a list.
 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
@@ -449,11 +477,15 @@ from OBARRAY.
 
 \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil (quote macro))
 
+(put 'do-symbols 'lisp-indent-function '1)
+
 (autoload 'do-all-symbols "cl-macs" "\
 
 
 \(fn SPEC &rest BODY)" nil (quote macro))
 
+(put 'do-all-symbols 'lisp-indent-function '1)
+
 (autoload 'psetq "cl-macs" "\
 Set SYMs to the values VALs in parallel.
 This is like `setq', except that all VAL forms are evaluated (in order)
@@ -471,6 +503,8 @@ a `let' form, except that the list of symbols can be computed at run-time.
 
 \(fn SYMBOLS VALUES &rest BODY)" nil (quote macro))
 
+(put 'progv 'lisp-indent-function '2)
+
 (autoload 'flet "cl-macs" "\
 Make temporary function definitions.
 This is an analogue of `let' that operates on the function cell of FUNC
@@ -480,6 +514,8 @@ go back to their previous definitions, or lack thereof).
 
 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil (quote macro))
 
+(put 'flet 'lisp-indent-function '1)
+
 (autoload 'labels "cl-macs" "\
 Make temporary function bindings.
 This is like `flet', except the bindings are lexical instead of dynamic.
@@ -487,12 +523,16 @@ Unlike `flet', this macro is fully compliant with the Common Lisp standard.
 
 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil (quote macro))
 
+(put 'labels 'lisp-indent-function '1)
+
 (autoload 'macrolet "cl-macs" "\
 Make temporary macro definitions.
 This is like `flet', but for macros instead of functions.
 
 \(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil (quote macro))
 
+(put 'macrolet 'lisp-indent-function '1)
+
 (autoload 'symbol-macrolet "cl-macs" "\
 Make symbol macro definitions.
 Within the body FORMs, references to the variable NAME will be replaced
@@ -500,6 +540,8 @@ by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).
 
 \(fn ((NAME EXPANSION) ...) FORM...)" nil (quote macro))
 
+(put 'symbol-macrolet 'lisp-indent-function '1)
+
 (autoload 'lexical-let "cl-macs" "\
 Like `let', but lexically scoped.
 The main visible difference is that lambdas inside BODY will create
@@ -507,6 +549,8 @@ lexical closures as in Common Lisp.
 
 \(fn BINDINGS BODY)" nil (quote macro))
 
+(put 'lexical-let 'lisp-indent-function '1)
+
 (autoload 'lexical-let* "cl-macs" "\
 Like `let*', but lexically scoped.
 The main visible difference is that lambdas inside BODY, and in
@@ -516,6 +560,8 @@ Common Lisp.
 
 \(fn BINDINGS BODY)" nil (quote macro))
 
+(put 'lexical-let* 'lisp-indent-function '1)
+
 (autoload 'multiple-value-bind "cl-macs" "\
 Collect multiple return values.
 FORM must return a list; the BODY is then executed with the first N elements
@@ -526,6 +572,8 @@ a synonym for (list A B C).
 
 \(fn (SYM...) FORM BODY)" nil (quote macro))
 
+(put 'multiple-value-bind 'lisp-indent-function '2)
+
 (autoload 'multiple-value-setq "cl-macs" "\
 Collect multiple return values.
 FORM must return a list; the first N elements of this list are stored in
@@ -535,6 +583,8 @@ values.  For compatibility, (values A B C) is a synonym for (list A B C).
 
 \(fn (SYM...) FORM)" nil (quote macro))
 
+(put 'multiple-value-setq 'lisp-indent-function '1)
+
 (autoload 'locally "cl-macs" "\
 
 
@@ -545,6 +595,8 @@ values.  For compatibility, (values A B C) is a synonym for (list A B C).
 
 \(fn TYPE FORM)" nil (quote macro))
 
+(put 'the 'lisp-indent-function '1)
+
 (autoload 'declare "cl-macs" "\
 Declare SPECS about the current function while compiling.
 For instance
@@ -649,6 +701,8 @@ the PLACE is not modified before executing BODY.
 
 \(fn ((PLACE VALUE) ...) BODY...)" nil (quote macro))
 
+(put 'letf 'lisp-indent-function '1)
+
 (autoload 'letf* "cl-macs" "\
 Temporarily bind to PLACEs.
 This is the analogue of `let*', but with generalized variables (in the
@@ -661,6 +715,8 @@ the PLACE is not modified before executing BODY.
 
 \(fn ((PLACE VALUE) ...) BODY...)" nil (quote macro))
 
+(put 'letf* 'lisp-indent-function '1)
+
 (autoload 'callf "cl-macs" "\
 Set PLACE to (FUNC PLACE ARGS...).
 FUNC should be an unquoted function name.  PLACE may be a symbol,
@@ -668,12 +724,16 @@ or any generalized variable allowed by `setf'.
 
 \(fn FUNC PLACE ARGS...)" nil (quote macro))
 
+(put 'callf 'lisp-indent-function '2)
+
 (autoload 'callf2 "cl-macs" "\
 Set PLACE to (FUNC ARG1 PLACE ARGS...).
 Like `callf', but PLACE is the second argument of FUNC, not the first.
 
 \(fn FUNC ARG1 PLACE ARGS...)" nil (quote macro))
 
+(put 'callf2 'lisp-indent-function '3)
+
 (autoload 'define-modify-macro "cl-macs" "\
 Define a `setf'-like modify macro.
 If NAME is called, it combines its PLACE argument with the other arguments
@@ -699,6 +759,8 @@ value, that slot cannot be set via `setf'.
 
 \(fn NAME SLOTS...)" nil (quote macro))
 
+(put 'defstruct 'doc-string-elt '2)
+
 (autoload 'cl-struct-setf-expander "cl-macs" "\
 
 
@@ -710,6 +772,8 @@ The type name can then be used in `typecase', `check-type', etc.
 
 \(fn NAME ARGLIST &rest BODY)" nil (quote macro))
 
+(put 'deftype 'doc-string-elt '3)
+
 (autoload 'typep "cl-macs" "\
 Check that OBJECT is of type TYPE.
 TYPE is a Common Lisp-style type specifier.

diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index 441ae55758cfe7e901b106b8b49d1a5a66964ecc..c547a4f646033c19aec7ca39667fc816be5d3e06 100644 (file)
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -227,6 +227,7 @@ and BODY is implicitly surrounded by (block NAME ...).
                      cl-declarations-or-string
                      [&optional ("interactive" interactive)]
                      def-body))
+           (doc-string 3)
            (indent 2))
   (let* ((res (cl-transform-lambda (cons args body) name))
         (form (list* 'defun name (cdr res))))
@@ -279,6 +280,7 @@ and BODY is implicitly surrounded by (block NAME ...).
 \(fn NAME ARGLIST [DOCSTRING] BODY...)"
   (declare (debug
             (&define name cl-macro-list cl-declarations-or-string def-body))
+           (doc-string 3)
            (indent 2))
   (let* ((res (cl-transform-lambda (cons args body) name))
         (form (list* 'defmacro name (cdr res))))
@@ -2587,7 +2589,8 @@ one keyword is supported, `:read-only'.  If this has a non-nil
 value, that slot cannot be set via `setf'.
 
 \(fn NAME SLOTS...)"
-  (declare (debug
+  (declare (doc-string 2)
+           (debug
             (&define                    ;Makes top-level form not be wrapped.
              [&or symbolp
                   (gate
@@ -2854,7 +2857,7 @@ value, that slot cannot be set via `setf'.
 (defmacro deftype (name arglist &rest body)
   "Define NAME as a new data type.
 The type name can then be used in `typecase', `check-type', etc."
-  (declare (debug defmacro*))
+  (declare (debug defmacro*) (doc-string 3))
   (list 'eval-when '(compile load eval)
        (cl-transform-function-property
         name 'cl-deftype-handler (cons (list* '&cl-defs ''('*) arglist) body))))

diff --git a/lisp/emacs-lisp/cl.el b/lisp/emacs-lisp/cl.el
index 7c486e17dcf3df52387b17c2e6a5270cab7f1ec6..137dd1bfb844c8dd458ee36b729a325b226fd0a0 100644 (file)
--- a/lisp/emacs-lisp/cl.el
+++ b/lisp/emacs-lisp/cl.el
@@ -656,6 +656,15 @@ If ALIST is non-nil, the new pairs are prepended to it."
 (fmakunbound 'dolist)
 (fmakunbound 'dotimes)
 (fmakunbound 'declare)
+;;;###autoload
+(progn
+  ;; Autoload, so autoload.el and font-lock can use it even when CL
+  ;; is not loaded.
+  (put 'defun*    'doc-string-elt 3)
+  (put 'defmacro* 'doc-string-elt 3)
+  (put 'defsubst 'doc-string-elt 3)
+  (put 'defstruct 'doc-string-elt 2))
+
 (load "cl-loaddefs" nil 'quiet)
 
 ;; This goes here so that cl-macs can find it if it loads right now.

diff --git a/lisp/emacs-lisp/easy-mmode.el b/lisp/emacs-lisp/easy-mmode.el
index 301947f0735ecbcc92ce5309d3f43b0080b77aa0..a11f213e646f8a278d88cdd49677f7d1bdf8e32d 100644 (file)
--- a/lisp/emacs-lisp/easy-mmode.el
+++ b/lisp/emacs-lisp/easy-mmode.el
@@ -142,7 +142,8 @@ For example, you could write
   (define-minor-mode foo-mode \"If enabled, foo on you!\"
     :lighter \" Foo\" :require 'foo :global t :group 'hassle :version \"27.5\"
     ...BODY CODE...)"
-  (declare (debug (&define name stringp
+  (declare (doc-string 2)
+           (debug (&define name stringp
                           [&optional [&not keywordp] sexp
                            &optional [&not keywordp] sexp
                            &optional [&not keywordp] sexp]
@@ -335,7 +336,7 @@ enabled, then disabling and reenabling MODE should make MODE work
 correctly with the current major mode.  This is important to
 prevent problems with derived modes, that is, major modes that
 call another major mode in their body."
-
+  (declare (doc-string 2))
   (let* ((global-mode-name (symbol-name global-mode))
         (pretty-name (easy-mmode-pretty-mode-name mode))
         (pretty-global-name (easy-mmode-pretty-mode-name global-mode))

diff --git a/lisp/emacs-lisp/generic.el b/lisp/emacs-lisp/generic.el
index b9db092fafc86354338a1f16a690c3e4997610ac..80b6122822e8b7cbeca320189a7304c9d5424183 100644 (file)
--- a/lisp/emacs-lisp/generic.el
+++ b/lisp/emacs-lisp/generic.el
@@ -151,7 +151,8 @@ mode hook `MODE-hook'.
 See the file generic-x.el for some examples of `define-generic-mode'."
   (declare (debug (sexp def-form def-form def-form form def-form
                        [&optional stringp] &rest [keywordp form]))
-          (indent 1))
+          (indent 1)
+           (doc-string 7))
 
   ;; Backward compatibility.
   (when (eq (car-safe mode) 'quote)

diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 95eb8c963be99bbcc99279d4e69d10dfb86213c7..dfdac92ae32eb19622cedd3c6a7086f2833d7dc9 100644 (file)
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -136,34 +136,14 @@ It has `lisp-mode-abbrev-table' as its parent."
 ;; This was originally in autoload.el and is still used there.
 (put 'autoload 'doc-string-elt 3)
 (put 'defun    'doc-string-elt 3)
-(put 'defun*    'doc-string-elt 3)
 (put 'defmethod 'doc-string-elt 3)
 (put 'defvar   'doc-string-elt 3)
-(put 'defcustom 'doc-string-elt 3)
-(put 'deftheme 'doc-string-elt 2)
-(put 'deftype 'doc-string-elt 3)
 (put 'defconst 'doc-string-elt 3)
 (put 'defmacro 'doc-string-elt 3)
-(put 'defmacro* 'doc-string-elt 3)
-(put 'defsubst 'doc-string-elt 3)
-(put 'defstruct 'doc-string-elt 2)
-(put 'define-skeleton 'doc-string-elt 2)
-(put 'define-derived-mode 'doc-string-elt 4)
-(put 'define-compilation-mode 'doc-string-elt 3)
-(put 'easy-mmode-define-minor-mode 'doc-string-elt 2)
-(put 'define-minor-mode 'doc-string-elt 2)
-(put 'easy-mmode-define-global-mode 'doc-string-elt 2)
-(put 'define-global-minor-mode 'doc-string-elt 2)
-(put 'define-globalized-minor-mode 'doc-string-elt 2)
-(put 'define-generic-mode 'doc-string-elt 7)
-(put 'define-ibuffer-filter 'doc-string-elt 2)
-(put 'define-ibuffer-op 'doc-string-elt 3)
-(put 'define-ibuffer-sorter 'doc-string-elt 2)
 (put 'lambda 'doc-string-elt 2)
 (put 'defalias 'doc-string-elt 3)
 (put 'defvaralias 'doc-string-elt 3)
 (put 'define-category 'doc-string-elt 2)
-(put 'define-overloadable-function 'doc-string-elt 3)
 
 (defvar lisp-doc-string-elt-property 'doc-string-elt
   "The symbol property that holds the docstring position info.")

diff --git a/lisp/ibuf-macs.el b/lisp/ibuf-macs.el
index f47592e82bb6cb724d491a5c700cd6f5c30efbdb..659b8e7d78c8b2400ddb6209d0154b5cbeab0fb6 100644 (file)
--- a/lisp/ibuf-macs.el
+++ b/lisp/ibuf-macs.el
@@ -143,7 +143,7 @@ buffer object, and `b' bound to another.  BODY should return a non-nil
 value if and only if `a' is \"less than\" `b'.
 
 \(fn NAME DOCUMENTATION (&key DESCRIPTION) &rest BODY)"
-  (declare (indent 1))
+  (declare (indent 1) (doc-string 2))
   `(progn
      (defun ,(intern (concat "ibuffer-do-sort-by-" (symbol-name name))) ()
        ,(or documentation "No :documentation specified for this sorting method.")
@@ -202,7 +202,7 @@ COMPLEX means this function is special; see the source code of this
 macro for exactly what it does.
 
 \(fn OP ARGS DOCUMENTATION (&key INTERACTIVE MARK MODIFIER-P DANGEROUS OPSTRING ACTIVE-OPSTRING COMPLEX) &rest BODY)"
-  (declare (indent 2))
+  (declare (indent 2) (doc-string 3))
   `(progn
      (defun ,(intern (concat (if (string-match "^ibuffer-do" (symbol-name op))
                                 "" "ibuffer-do-") (symbol-name op)))
@@ -280,7 +280,7 @@ will be evaluated with BUF bound to the buffer object, and QUALIFIER
 bound to the current value of the filter.
 
 \(fn NAME DOCUMENTATION (&key READER DESCRIPTION) &rest BODY)"
-  (declare (indent 2))
+  (declare (indent 2) (doc-string 2))
   (let ((fn-name (intern (concat "ibuffer-filter-by-" (symbol-name name)))))
     `(progn
        (defun ,fn-name (qualifier)

diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 7ffaddb2c49cf7891d74346c3a5b9866d58be5e6..fe1b63f3048275706d76410f447257c5bfb22a58 100644 (file)
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -1884,6 +1884,9 @@ Runs `compilation-mode-hook' with `run-mode-hooks' (which see).
   (setq buffer-read-only t)
   (run-mode-hooks 'compilation-mode-hook))
 
+;;;###autoload
+(put 'define-compilation-mode 'doc-string-elt 3)
+
 (defmacro define-compilation-mode (mode name doc &rest body)
   "This is like `define-derived-mode' without the PARENT argument.
 The parent is always `compilation-mode' and the customizable `compilation-...'

diff --git a/lisp/skeleton.el b/lisp/skeleton.el
index 328f795ecd293f9905953c3d7f87a94b698c9a36..34d69a74369ef6ebe4c574108774983d56339a26 100644 (file)
--- a/lisp/skeleton.el
+++ b/lisp/skeleton.el
@@ -121,7 +121,7 @@ are integer buffer positions in the reverse order of the insertion order.")
   "Define a user-configurable COMMAND that enters a statement skeleton.
 DOCUMENTATION is that of the command.
 SKELETON is as defined under `skeleton-insert'."
-  (declare (debug (&define name stringp skeleton-edebug-spec)))
+  (declare (doc-string 2) (debug (&define name stringp skeleton-edebug-spec)))
   (if skeleton-debug
       (set command skeleton))
   `(progn