[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] /srv/bzr/emacs/emacs-24 r108272: * lisp/emacs-lisp/lisp-mo
From: |
Stefan Monnier |
Subject: |
[Emacs-diffs] /srv/bzr/emacs/emacs-24 r108272: * lisp/emacs-lisp/lisp-mode.el (doc-string-elt): Move those properties to |
Date: |
Fri, 02 Nov 2012 01:45:51 -0000 |
User-agent: |
Bazaar (2.5.0) |
------------------------------------------------------------
revno: 108272
committer: Stefan Monnier <address@hidden>
branch nick: trunk
timestamp: Thu 2012-05-17 21:46:20 -0400
message:
* 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.
modified:
lisp/ChangeLog
lisp/cedet/mode-local.el
lisp/custom.el
lisp/emacs-lisp/byte-run.el
lisp/emacs-lisp/cl-loaddefs.el
lisp/emacs-lisp/cl-macs.el
lisp/emacs-lisp/cl.el
lisp/emacs-lisp/easy-mmode.el
lisp/emacs-lisp/generic.el
lisp/emacs-lisp/lisp-mode.el
lisp/ibuf-macs.el
lisp/progmodes/compile.el
lisp/skeleton.el
=== modified file 'lisp/ChangeLog'
--- a/lisp/ChangeLog 2012-05-17 21:51:15 +0000
+++ b/lisp/ChangeLog 2012-05-18 01:46:20 +0000
@@ -1,3 +1,18 @@
+2012-05-18 Stefan Monnier <address@hidden>
+
+ * 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 <address@hidden>
* emacs-lisp/cl-macs.el, emacs-lisp/cl.el: Move indent info.
=== modified file 'lisp/cedet/mode-local.el'
--- a/lisp/cedet/mode-local.el 2012-01-19 07:21:25 +0000
+++ b/lisp/cedet/mode-local.el 2012-05-18 01:46:20 +0000
@@ -522,6 +522,9 @@
(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 @@
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
=== modified file 'lisp/custom.el'
--- a/lisp/custom.el 2012-05-03 02:39:23 +0000
+++ b/lisp/custom.el 2012-05-18 01:46:20 +0000
@@ -1048,6 +1048,7 @@
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
=== modified file 'lisp/emacs-lisp/byte-run.el'
--- a/lisp/emacs-lisp/byte-run.el 2012-01-19 07:21:25 +0000
+++ b/lisp/emacs-lisp/byte-run.el 2012-05-18 01:46:20 +0000
@@ -96,7 +96,7 @@
;; 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))
=== modified file 'lisp/emacs-lisp/cl-loaddefs.el'
--- a/lisp/emacs-lisp/cl-loaddefs.el 2012-05-17 21:39:36 +0000
+++ b/lisp/emacs-lisp/cl-loaddefs.el 2012-05-18 01:46:20 +0000
@@ -286,7 +286,7 @@
;;;;;; 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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(fn (SYM...) FORM)" nil (quote macro))
+(put 'multiple-value-setq 'lisp-indent-function '1)
+
(autoload 'locally "cl-macs" "\
@@ -545,6 +595,8 @@
\(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 @@
\(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 @@
\(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 @@
\(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 @@
\(fn NAME SLOTS...)" nil (quote macro))
+(put 'defstruct 'doc-string-elt '2)
+
(autoload 'cl-struct-setf-expander "cl-macs" "\
@@ -710,6 +772,8 @@
\(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.
=== modified file 'lisp/emacs-lisp/cl-macs.el'
--- a/lisp/emacs-lisp/cl-macs.el 2012-05-17 21:51:15 +0000
+++ b/lisp/emacs-lisp/cl-macs.el 2012-05-18 01:46:20 +0000
@@ -227,6 +227,7 @@
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 @@
\(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 @@
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 @@
(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))))
=== modified file 'lisp/emacs-lisp/cl.el'
--- a/lisp/emacs-lisp/cl.el 2012-05-17 21:51:15 +0000
+++ b/lisp/emacs-lisp/cl.el 2012-05-18 01:46:20 +0000
@@ -656,6 +656,15 @@
(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.
=== modified file 'lisp/emacs-lisp/easy-mmode.el'
--- a/lisp/emacs-lisp/easy-mmode.el 2012-05-04 23:16:47 +0000
+++ b/lisp/emacs-lisp/easy-mmode.el 2012-05-18 01:46:20 +0000
@@ -142,7 +142,8 @@
(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 [¬ keywordp] sexp
&optional [¬ keywordp] sexp
&optional [¬ keywordp] sexp]
@@ -335,7 +336,7 @@
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))
=== modified file 'lisp/emacs-lisp/generic.el'
--- a/lisp/emacs-lisp/generic.el 2012-05-13 03:05:06 +0000
+++ b/lisp/emacs-lisp/generic.el 2012-05-18 01:46:20 +0000
@@ -151,7 +151,8 @@
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)
=== modified file 'lisp/emacs-lisp/lisp-mode.el'
--- a/lisp/emacs-lisp/lisp-mode.el 2012-01-29 04:45:51 +0000
+++ b/lisp/emacs-lisp/lisp-mode.el 2012-05-18 01:46:20 +0000
@@ -136,34 +136,14 @@
;; 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.")
=== modified file 'lisp/ibuf-macs.el'
--- a/lisp/ibuf-macs.el 2012-01-19 07:21:25 +0000
+++ b/lisp/ibuf-macs.el 2012-05-18 01:46:20 +0000
@@ -143,7 +143,7 @@
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 @@
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 @@
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)
=== modified file 'lisp/progmodes/compile.el'
--- a/lisp/progmodes/compile.el 2012-05-14 11:59:28 +0000
+++ b/lisp/progmodes/compile.el 2012-05-18 01:46:20 +0000
@@ -1884,6 +1884,9 @@
(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-...'
=== modified file 'lisp/skeleton.el'
--- a/lisp/skeleton.el 2012-04-09 13:05:48 +0000
+++ b/lisp/skeleton.el 2012-05-18 01:46:20 +0000
@@ -121,7 +121,7 @@
"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
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] /srv/bzr/emacs/emacs-24 r108272: * lisp/emacs-lisp/lisp-mode.el (doc-string-elt): Move those properties to,
Stefan Monnier <=