* 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.

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.

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

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

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))

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.

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))))

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.

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))

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)

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.")

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)

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-...'

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