* lisp/org/org-{macs,list}.el: Fix lexical warnings

* lisp/org/org-list.el (org-list-struct): Remove unused var `ind'.
(org-list-get-next-item, org-list-get-prev-item)
(org-list-get-children): Mark unused arg `struct'.
(org-list-use-alpha-bul-p): Remove unused var `bul'.
(org-toggle-checkbox): Mark unused var.
(org-update-checkbox-count): Remove unused var `box-num'.
(org-adapt-indentation): Declare.
(org-list-parse-list): Declare var instead of adding a dummy duplicate.
(org-list-send-list): Remove unused var `txt'.
(org-list-to-latex, org-list-to-texinfo): Mark unused arg `params'.
(org-list-to-subtree): Add prefix to dyn-bind var, and declare them.

* lisp/org/org-macs.el: Use `declare'.
(org-with-limited-levels): Declare dyn-bound vars.

2 files changed, 63 insertions, 60 deletions

diff --git a/lisp/org/org-list.el b/lisp/org/org-list.el
index c8db77bc689..73f24ce7bd8 100644
--- a/lisp/org/org-list.el
+++ b/lisp/org/org-list.el
@@ -431,7 +431,7 @@ group 4: description tag")
            (context (org-list-context))
            (lim-up (car context))
            (drawers-re (concat "^[ \t]*:\\("
-                               (mapconcat 'regexp-quote org-drawers "\\|")
+                               (mapconcat #'regexp-quote org-drawers "\\|")
                                "\\):[ \t]*$"))
            (inlinetask-re (and (featurep 'org-inlinetask)
                                (org-inlinetask-outline-regexp)))
@@ -550,7 +550,7 @@ Contexts `block' and `invalid' refer to `org-list-forbidden-blocks'."
                ;; Can't use org-drawers-regexp as this function might
                ;; be called in buffers not in Org mode.
                (beg-re (concat "^[ \t]*:\\("
-                               (mapconcat 'regexp-quote org-drawers "\\|")
+                               (mapconcat #'regexp-quote org-drawers "\\|")
                                "\\):[ \t]*$")))
            (when (save-excursion
                    (and (not (looking-at beg-re))
@@ -636,12 +636,12 @@ Assume point is at an item."
            (text-min-ind 10000)
            (item-re (org-item-re))
            (drawers-re (concat "^[ \t]*:\\("
-                               (mapconcat 'regexp-quote org-drawers "\\|")
+                               (mapconcat #'regexp-quote org-drawers "\\|")
                                "\\):[ \t]*$"))
            (inlinetask-re (and (featurep 'org-inlinetask)
                                (org-inlinetask-outline-regexp)))
            (beg-cell (cons (point) (org-get-indentation)))
-           ind itm-lst itm-lst-2 end-lst end-lst-2 struct
+           itm-lst itm-lst-2 end-lst end-lst-2 struct
            (assoc-at-point
             (function
              ;; Return association at point.
@@ -926,13 +926,13 @@ Value returned is the position of the first child of ITEM."
                (< ind (org-list-get-ind child-maybe struct)))
       child-maybe)))
 
-(defun org-list-get-next-item (item struct prevs)
+(defun org-list-get-next-item (item _struct prevs)
   "Return next item in same sub-list as ITEM, or nil.
 STRUCT is the list structure.  PREVS is the alist of previous
 items, as returned by `org-list-prevs-alist'."
   (car (rassq item prevs)))
 
-(defun org-list-get-prev-item (item struct prevs)
+(defun org-list-get-prev-item (item _struct prevs)
   "Return previous item in same sub-list as ITEM, or nil.
 STRUCT is the list structure.  PREVS is the alist of previous
 items, as returned by `org-list-prevs-alist'."
@@ -964,7 +964,7 @@ items, as returned by `org-list-prevs-alist'."
       (push next-item after-item))
     (append before-item (list item) (nreverse after-item))))
 
-(defun org-list-get-children (item struct parents)
+(defun org-list-get-children (item _struct parents)
   "List all children of ITEM, or nil.
 STRUCT is the list structure.  PARENTS is the alist of parents,
 as returned by `org-list-parents-alist'."
@@ -982,7 +982,7 @@ STRUCT is the list structure."
 (defun org-list-get-bottom-point (struct)
   "Return point at bottom of list.
 STRUCT is the list structure."
-  (apply 'max
+  (apply #'max
          (mapcar (lambda (e) (org-list-get-item-end (car e) struct)) struct)))
 
 (defun org-list-get-list-begin (item struct prevs)
@@ -1630,8 +1630,7 @@ as returned by `org-list-prevs-alist'."
            ;; Pretend that bullets are uppercase and check if alphabet
            ;; is sufficient, taking counters into account.
            (while item
-             (let ((bul (org-list-get-bullet item struct))
-                   (count (org-list-get-counter item struct)))
+             (let ((count (org-list-get-counter item struct)))
                ;; Virtually determine current bullet
                (if (and count (string-match "[a-zA-Z]" count))
                    ;; Counters are not case-sensitive.
@@ -1728,7 +1727,7 @@ This function modifies STRUCT."
                   (replace-match "1" nil nil bullet))
                  ;; Not an ordered list: keep bullet.
                  (t bullet)))))))))
-    (mapc fix-bul (mapcar 'car struct))))
+    (mapc fix-bul (mapcar #'car struct))))
 
 (defun org-list-struct-fix-ind (struct parents &optional bullet-size)
   "Verify and correct indentation in STRUCT.
@@ -1756,7 +1755,7 @@ This function modifies STRUCT."
                                   org-list-indent-offset))
                 ;; If no parent, indent like top-point.
                 (org-list-set-ind item struct top-ind))))))
-    (mapc new-ind (mapcar 'car (cdr struct)))))
+    (mapc new-ind (mapcar #'car (cdr struct)))))
 
 (defun org-list-struct-fix-box (struct parents prevs &optional ordered)
   "Verify and correct checkboxes in STRUCT.
@@ -1771,7 +1770,7 @@ break this rule, the function will return the blocking item.  In
 all others cases, the return value will be nil.
 
 This function modifies STRUCT."
-  (let ((all-items (mapcar 'car struct))
+  (let ((all-items (mapcar #'car struct))
         (set-parent-box
          (function
           (lambda (item)
@@ -1942,8 +1941,8 @@ Initial position of cursor is restored after the changes."
       ;;    same amount of indentation.  Each slice follow the pattern
       ;;    (END BEG DELTA MAX-IND-OR-NIL).  Slices are returned in
       ;;    reverse order.
-      (setq all-ends (sort (append (mapcar 'car itm-shift)
-                                   (org-uniquify (mapcar 'car end-list)))
+      (setq all-ends (sort (append (mapcar #'car itm-shift)
+                                   (org-uniquify (mapcar #'car end-list)))
                            '<))
       (while (cdr all-ends)
         (let* ((up (pop all-ends))
@@ -2327,7 +2326,7 @@ in subtree, ignoring drawers."
            lim-up
            lim-down
            (drawer-re (concat "^[ \t]*:\\("
-                              (mapconcat 'regexp-quote org-drawers "\\|")
+                              (mapconcat #'regexp-quote org-drawers "\\|")
                               "\\):[ \t]*$"))
            (keyword-re (concat "^[ \t]*\\<\\(" org-scheduled-string
                                "\\|" org-deadline-string
@@ -2335,7 +2334,7 @@ in subtree, ignoring drawers."
                                "\\|" org-clock-string "\\)"
                                " *[[<]\\([^]>]+\\)[]>]"))
            (orderedp (org-entry-get nil "ORDERED"))
-           (bounds
+           (_bounds
             ;; In a region, start at first item in region.
             (cond
              ((org-region-active-p)
@@ -2391,7 +2390,7 @@ in subtree, ignoring drawers."
                (bottom (copy-marker (org-list-get-bottom-point struct)))
                (items-to-toggle (org-remove-if
                                  (lambda (e) (or (< e lim-up) (> e lim-down)))
-                                 (mapcar 'car struct))))
+                                 (mapcar #'car struct))))
           (mapc (lambda (e) (org-list-set-checkbox
                              e struct
                              ;; If there is no box at item, leave as-is
@@ -2473,7 +2472,7 @@ With optional prefix argument ALL, do this for the whole buffer."
                           (items
                            (cond
                             ((and recursivep item) (org-list-get-subtree item s))
-                            (recursivep (mapcar 'car s))
+                            (recursivep (mapcar #'car s))
                             (item (org-list-get-children item s par))
                             (t (org-list-get-all-items
                                 (org-list-get-top-point s) s pre))))
@@ -2486,7 +2485,7 @@ With optional prefix argument ALL, do this for the whole buffer."
                  structs)
                 (cons c-on c-all)))))
           (backup-end 1)
-          cookies-list structs-bak box-num)
+          cookies-list structs-bak)
       (goto-char (car bounds))
       ;; 1. Build an alist for each cookie found within BOUNDS.  The
       ;;    key will be position at beginning of cookie and values
@@ -2749,6 +2748,7 @@ If a region is active, all items inside will be moved."
      (t (error "Not at an item")))))
 
 (defvar org-tab-ind-state)
+(defvar org-adapt-indentation)
 (defun org-cycle-item-indentation ()
   "Cycle levels of indentation of an empty item.
 The first run indents the item, if applicable.  Subsequent runs
@@ -2940,13 +2940,13 @@ will be parsed as:
   \(3 \"last item\"\)\)
 
 Point is left at list end."
+  (defvar parse-item)                   ;FIXME: Or use `cl-labels' or `letrec'.
   (let* ((struct (org-list-struct))
          (prevs (org-list-prevs-alist struct))
          (parents (org-list-parents-alist struct))
          (top (org-list-get-top-point struct))
          (bottom (org-list-get-bottom-point struct))
          out
-         parse-item                     ; for byte-compiler
          (get-text
           (function
            ;; Return text between BEG and END, trimmed, with
@@ -3072,7 +3072,7 @@ for this list."
               (re-search-forward (org-item-beginning-re) bottom-point t)
               (match-beginning 0)))
            (plain-list (buffer-substring-no-properties top-point bottom-point))
-           beg txt)
+           beg)
       (unless (fboundp transform)
         (error "No such transformation function %s" transform))
       (let ((txt (funcall transform plain-list)))
@@ -3082,7 +3082,8 @@ for this list."
           (unless (re-search-forward
                    (concat "BEGIN RECEIVE ORGLST +"
                            name
-                           "\\([ \t]\\|$\\)") nil t)
+                           "\\([ \t]\\|$\\)")
+                   nil t)
             (error "Don't know where to insert translated list"))
           (goto-char (match-beginning 0))
           (beginning-of-line 2)
@@ -3230,7 +3231,7 @@ items."
                                       items (or (eval isep) ""))))))))
     (concat (funcall export-sublist list 0) "\n")))
 
-(defun org-list-to-latex (list &optional params)
+(defun org-list-to-latex (list &optional _params)
   "Convert LIST into a LaTeX list.
 LIST is as string representing the list to transform, as Org
 syntax.  Return converted list as a string."
@@ -3244,7 +3245,7 @@ syntax.  Return converted list as a string."
   (require 'ox-html)
   (org-export-string-as list 'html t))
 
-(defun org-list-to-texinfo (list &optional params)
+(defun org-list-to-texinfo (list &optional _params)
   "Convert LIST into a Texinfo list.
 LIST is as string representing the list to transform, as Org
 syntax.  Return converted list as a string."
@@ -3255,14 +3256,15 @@ syntax.  Return converted list as a string."
   "Convert LIST into an Org subtree.
 LIST is as returned by `org-list-parse-list'.  PARAMS is a property list
 with overruling parameters for `org-list-to-generic'."
+  (defvar get-stars) (defvar org--blankp)
   (let* ((rule (cdr (assq 'heading org-blank-before-new-entry)))
          (level (org-reduced-level (or (org-current-level) 0)))
-         (blankp (or (eq rule t)
+         (org--blankp (or (eq rule t)
                      (and (eq rule 'auto)
                           (save-excursion
                             (outline-previous-heading)
                             (org-previous-line-empty-p)))))
-         (get-stars
+         (get-stars ;FIXME: Can't rename without renaming it in org.el as well!
           (function
            ;; Return the string for the heading, depending on depth D
            ;; of current sub-list.
@@ -3277,12 +3279,12 @@ with overruling parameters for `org-list-to-generic'."
      list
      (org-combine-plists
       '(:splice t
-                :dtstart " " :dtend " "
-                :istart (funcall get-stars depth)
-                :icount (funcall get-stars depth)
-                :isep (if blankp "\n\n" "\n")
-                :csep (if blankp "\n\n" "\n")
-                :cbon "DONE" :cboff "TODO" :cbtrans "TODO")
+        :dtstart " " :dtend " "
+        :istart (funcall get-stars depth)
+        :icount (funcall get-stars depth)
+        :isep (if org--blankp "\n\n" "\n")
+        :csep (if org--blankp "\n\n" "\n")
+        :cbon "DONE" :cboff "TODO" :cbtrans "TODO")
       params))))
 
 (provide 'org-list)
diff --git a/lisp/org/org-macs.el b/lisp/org/org-macs.el
index 23c30178080..db09909f404 100644
--- a/lisp/org/org-macs.el
+++ b/lisp/org/org-macs.el
@@ -33,7 +33,7 @@
 
 (eval-and-compile
   (unless (fboundp 'declare-function)
-    (defmacro declare-function (fn file &optional arglist fileonly)
+    (defmacro declare-function (fn file &optional _arglist _fileonly)
       `(autoload ',fn ,file)))
 
   (if (>= emacs-major-version 23)
@@ -48,13 +48,14 @@
 (declare-function org-string-match-p "org-compat" (&rest args))
 
 (defmacro org-with-gensyms (symbols &rest body)
+  (declare (debug (sexp body)) (indent 1))
   `(let ,(mapcar (lambda (s)
-                   `(,s (make-symbol (concat "--" (symbol-name ',s))))) symbols)
+                   `(,s (make-symbol (concat "--" (symbol-name ',s)))))
+                 symbols)
      ,@body))
-(def-edebug-spec org-with-gensyms (sexp body))
-(put 'org-with-gensyms 'lisp-indent-function 1)
 
 (defmacro org-called-interactively-p (&optional kind)
+  (declare (debug (&optional ("quote" symbolp)))) ;Why not just `t'?
   (if (featurep 'xemacs)
       `(interactive-p)
     (if (or (> emacs-major-version 23)
@@ -63,12 +64,11 @@
         ;; defined with no argument in <=23.1
         `(with-no-warnings (called-interactively-p ,kind))
       `(interactive-p))))
-(def-edebug-spec org-called-interactively-p (&optional ("quote" symbolp)))
 
 (defmacro org-bound-and-true-p (var)
   "Return the value of symbol VAR if it is bound, else nil."
+  (declare (debug (symbolp)))
   `(and (boundp (quote ,var)) ,var))
-(def-edebug-spec org-bound-and-true-p (symbolp))
 
 (defun org-string-nw-p (s)
   "Is S a string with a non-white character?"
@@ -97,10 +97,11 @@ Otherwise return nil."
 
 (defmacro org-re (s)
   "Replace posix classes in regular expression."
+  (declare (debug (form)))
   (if (featurep 'xemacs) `(org-substitute-posix-classes ,s) s))
-(def-edebug-spec org-re (form))
 
 (defmacro org-preserve-lc (&rest body)
+  (declare (debug (body)))
   (org-with-gensyms (line col)
     `(let ((,line (org-current-line))
            (,col (current-column)))
@@ -108,12 +109,12 @@ Otherwise return nil."
            (progn ,@body)
          (org-goto-line ,line)
          (org-move-to-column ,col)))))
-(def-edebug-spec org-preserve-lc (body))
 
 ;; Use `org-with-silent-modifications' to ignore cosmetic changes and
 ;; `org-unmodified' to ignore real text modifications
 (defmacro org-unmodified (&rest body)
   "Run BODY while preserving the buffer's `buffer-modified-p' state."
+  (declare (debug (body)))
   (org-with-gensyms (was-modified)
     `(let ((,was-modified (buffer-modified-p)))
        (unwind-protect
@@ -121,9 +122,9 @@ Otherwise return nil."
                  (inhibit-modification-hooks t))
              ,@body)
          (set-buffer-modified-p ,was-modified)))))
-(def-edebug-spec org-unmodified (body))
 
 (defmacro org-without-partial-completion (&rest body)
+  (declare (debug (body)))
   `(if (and (boundp 'partial-completion-mode)
             partial-completion-mode
             (fboundp 'partial-completion-mode))
@@ -133,7 +134,6 @@ Otherwise return nil."
              ,@body)
          (partial-completion-mode 1))
      ,@body))
-(def-edebug-spec org-without-partial-completion (body))
 
 ;; FIXME: Slated for removal.  Current Org mode does not support Emacs < 22
 (defmacro org-maybe-intangible (props)
@@ -150,6 +150,7 @@ We use a macro so that the test can happen at compilation time."
 
 (defmacro org-with-point-at (pom &rest body)
   "Move to buffer and point of point-or-marker POM for the duration of BODY."
+  (declare (debug (form body)) (indent 1))
   (org-with-gensyms (mpom)
     `(let ((,mpom ,pom))
        (save-excursion
@@ -157,15 +158,14 @@ We use a macro so that the test can happen at compilation time."
          (org-with-wide-buffer
           (goto-char (or ,mpom (point)))
           ,@body)))))
-(def-edebug-spec org-with-point-at (form body))
-(put 'org-with-point-at 'lisp-indent-function 1)
 
 (defmacro org-no-warnings (&rest body)
+  (declare (debug (body)))
   (cons (if (fboundp 'with-no-warnings) 'with-no-warnings 'progn) body))
-(def-edebug-spec org-no-warnings (body))
 
 (defmacro org-with-remote-undo (buffer &rest body)
   "Execute BODY while recording undo information in two buffers."
+  (declare (debug (form body)) (indent 1))
   (org-with-gensyms (cline cmd buf1 buf2 undo1 undo2 c1 c2)
     `(let ((,cline (org-current-line))
            (,cmd this-command)
@@ -187,13 +187,11 @@ We use a macro so that the test can happen at compilation time."
            ;; remember which buffer to undo
            (push (list ,cmd ,cline ,buf1 ,c1 ,buf2 ,c2)
                  org-agenda-undo-list))))))
-(def-edebug-spec org-with-remote-undo (form body))
-(put 'org-with-remote-undo 'lisp-indent-function 1)
 
 (defmacro org-no-read-only (&rest body)
   "Inhibit read-only for BODY."
+  (declare (debug (body)))
   `(let ((inhibit-read-only t)) ,@body))
-(def-edebug-spec org-no-read-only (body))
 
 (defconst org-rm-props '(invisible t face t keymap t intangible t mouse-face t
                                    rear-nonsticky t mouse-map t fontified t
@@ -313,7 +311,7 @@ This means that the buffer may change while running BODY,
 but it also means that the buffer should stay alive
 during the operation, because otherwise all these markers will
 point nowhere."
-  (declare (indent 1))
+  (declare (debug (form body)) (indent 1))
   (org-with-gensyms (data rtn)
     `(let ((,data (org-outline-overlay-data ,use-markers))
            ,rtn)
@@ -327,24 +325,28 @@ point nowhere."
                    (and (markerp (cdr c)) (move-marker (cdr c) nil)))
                  ,data)))
        ,rtn)))
-(def-edebug-spec org-save-outline-visibility (form body))
 
 (defmacro org-with-wide-buffer (&rest body)
   "Execute body while temporarily widening the buffer."
+  (declare (debug (body)))
   `(save-excursion
      (save-restriction
        (widen)
        ,@body)))
-(def-edebug-spec org-with-wide-buffer (body))
 
 (defmacro org-with-limited-levels (&rest body)
   "Execute BODY with limited number of outline levels."
-  `(let* ((org-called-with-limited-levels t)
-          (org-outline-regexp (org-get-limited-outline-regexp))
-          (outline-regexp org-outline-regexp)
-          (org-outline-regexp-bol (concat "^" org-outline-regexp)))
-     ,@body))
-(def-edebug-spec org-with-limited-levels (body))
+  (declare (debug (body)))
+  `(progn
+     (defvar org-called-with-limited-levels)
+     (defvar org-outline-regexp)
+     (defvar outline-regexp)
+     (defvar org-outline-regexp-bol)
+     (let* ((org-called-with-limited-levels t)
+            (org-outline-regexp (org-get-limited-outline-regexp))
+            (outline-regexp org-outline-regexp)
+            (org-outline-regexp-bol (concat "^" org-outline-regexp)))
+       ,@body)))
 
 (defvar org-outline-regexp) ; defined in org.el
 (defvar org-odd-levels-only) ; defined in org.el
@@ -365,9 +367,8 @@ The number of levels is controlled by `org-inlinetask-min-level'"
     (format-time-string string (seconds-to-time seconds))))
 
 (defmacro org-eval-in-environment (environment form)
+  (declare (debug (form form)) (indent 1))
   `(eval (list 'let ,environment ',form)))
-(def-edebug-spec org-eval-in-environment (form form))
-(put 'org-eval-in-environment 'lisp-indent-function 1)
 
 (defun org-make-parameter-alist (flat)
   "Return alist based on FLAT.