* lisp/gnus: Misc simplifications found during conversion to lexical

* lisp/gnus/nnoo.el (noo-import-1, nnoo-define-skeleton-1): Use `dolist`.
(noo-map-functions, nnoo-define-basics): Directly emit the code rather than
going through an intermediate function; this also avoids the use of `eval`.
(noo-map-functions-1, nnoo-define-basics-1): Delete functions,
folded into their corresponding macro.

* lisp/gnus/gmm-utils.el (gmm-tool-bar-from-list): Demote `eval` to
`symbol-value`.

* lisp/gnus/gnus-art.el (gnus-button-handle-describe-key): Avoid `eval`
since `kbd` is a function nowadays.
(gnus-treat-part-number): Rename from `part-number`.
(gnus-treat-total-parts): Rename from `total-parts`.
(gnus-treat-article, gnus-treat-predicate): Adjust accordingly.

* lisp/gnus/gnus-cache.el (gnus-agent-load-alist): Use `declare-function`.

* lisp/gnus/gnus-group.el (gnus-cache-active-hashtb): Use `defvar`.
(gnus-group-iterate): Make it a normal function since lexical scoping
avoids the risk of name capture anyway.
(gnus-group-delete-articles): Actually use the `oldp` arg.

* lisp/gnus/gnus-html.el (gnus-html-wash-images): Fix debug message so
it's emitted after the `url` var it prints is actually initialized.
And avoid `setq` while we're at it.

* lisp/gnus/gnus-msg.el (gnus-group-mail, gnus-group-news)
(gnus-summary-mail-other-window, gnus-summary-news-other-window):
Merge `let`s using `let*`.

* lisp/gnus/gnus-spec.el (gnus-update-format-specifications):
Tighten the scope of `buffer`, and tighten a regexp.
(gnus-parse-simple-format): Reduce code duplication.

* lisp/gnus/gnus-start.el (gnus-child-mode): Don't `defvar` it since we
never use that variable and accordingly don't define it as a minor mode.

* lisp/gnus/gnus-util.el (gnus-byte-compile): Simplify so it obeys
`gnus-use-byte-compile` not just on the first call.
(iswitchb-minibuffer-setup): Declare.

* lisp/gnus/mail-source.el (mail-source-bind-1)
(mail-source-bind-common-1): Use `mapcar`.
(mail-source-set-common-1): Use `dolist`.
(display-time-event-handler): Declare.

* lisp/gnus/mml-smime.el (mml-smime-epg-verify): Reduce code duplication.

* lisp/gnus/mml.el (mml-parse-1): Reduce code duplication.

* lisp/gnus/mml2015.el (mml2015-epg-verify): Reduce code duplication.

* lisp/gnus/nnmail.el (nnmail-get-split-group): Tighten regexp.
(nnmail-split-it): Reduce code duplication.

* lisp/gnus/nnweb.el (nnweb-request-article): Avoid `setq`.

* lisp/gnus/spam.el (BBDB): Use the `noerror` arg of `require`, and
define all the functions for BBDB regardless if the require succeeded.
(spam-exists-in-BBDB-p): Don't inline, not worth it.

23 files changed, 374 insertions, 398 deletions

diff --git a/lisp/gnus/gmm-utils.el b/lisp/gnus/gmm-utils.el
index c64bfea7caf..3542587319d 100644
--- a/lisp/gnus/gmm-utils.el
+++ b/lisp/gnus/gmm-utils.el
@@ -231,7 +231,7 @@ DEFAULT-MAP specifies the default key map for ICON-LIST."
                             props)))
               t))
           (if (symbolp icon-list)
-              (eval icon-list)
+              (symbol-value icon-list)
             icon-list))
     map))
 
diff --git a/lisp/gnus/gnus-agent.el b/lisp/gnus/gnus-agent.el
index cb679b849f5..9af19bd02ca 100644
--- a/lisp/gnus/gnus-agent.el
+++ b/lisp/gnus/gnus-agent.el
@@ -735,7 +735,7 @@ be a select method."
   (interactive "P")
   (unless gnus-plugged
     (error "Groups can't be fetched when Gnus is unplugged"))
-  (gnus-group-iterate n 'gnus-agent-fetch-group))
+  (gnus-group-iterate n #'gnus-agent-fetch-group))
 
 (defun gnus-agent-fetch-group (&optional group)
   "Put all new articles in GROUP into the Agent."
diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el
index 7e5439a217e..4034d362af4 100644
--- a/lisp/gnus/gnus-art.el
+++ b/lisp/gnus/gnus-art.el
@@ -7617,7 +7617,7 @@ Calls `describe-variable' or `describe-function'."
   "Call `describe-key' when pushing the corresponding URL button."
   (let* ((key-string
           (replace-regexp-in-string gnus-button-handle-describe-prefix "" url))
-         (keys (ignore-errors (eval `(kbd ,key-string)))))
+         (keys (ignore-errors (kbd key-string))))
     (if keys
         (describe-key keys)
       (gnus-message 3 "Invalid key sequence in button: %s" key-string))))
@@ -8516,8 +8516,8 @@ For example:
 (defvar gnus-inhibit-article-treatments nil)
 
 ;; Dynamic variables.
-(defvar part-number)                    ;FIXME: Lacks a "gnus-" prefix.
-(defvar total-parts)                    ;FIXME: Lacks a "gnus-" prefix.
+(defvar gnus-treat-part-number)
+(defvar gnus-treat-total-parts)
 (defvar gnus-treat-type)
 (defvar gnus-treat-condition)
 (defvar gnus-treat-length)
@@ -8525,8 +8525,8 @@ For example:
 (defun gnus-treat-article (condition
                            &optional part-num total type)
   (let ((gnus-treat-condition condition)
-        (part-number part-num)
-        (total-parts total)
+        (gnus-treat-part-number part-num)
+        (gnus-treat-total-parts total)
         (gnus-treat-type type)
         (gnus-treat-length (- (point-max) (point-min)))
         (alist gnus-treatment-function-alist)
@@ -8586,9 +8586,9 @@ For example:
    ((eq val 'head)
     nil)
    ((eq val 'first)
-    (eq part-number 1))
+    (eq gnus-treat-part-number 1))
    ((eq val 'last)
-    (eq part-number total-parts))
+    (eq gnus-treat-part-number gnus-treat-total-parts))
    ((numberp val)
     (< gnus-treat-length val))
    (t
diff --git a/lisp/gnus/gnus-cache.el b/lisp/gnus/gnus-cache.el
index bea3d3bf03f..b17a11276c2 100644
--- a/lisp/gnus/gnus-cache.el
+++ b/lisp/gnus/gnus-cache.el
@@ -29,9 +29,7 @@
 (require 'gnus)
 (require 'gnus-sum)
 
-(eval-when-compile
-  (unless (fboundp 'gnus-agent-load-alist)
-    (defun gnus-agent-load-alist (group))))
+(declare-function gnus-agent-load-alist "gnus-agent" (group))
 
 (defcustom gnus-cache-active-file
   (expand-file-name "active" gnus-cache-directory)
@@ -55,7 +53,7 @@
 If you only want to cache your nntp groups, you could set this
 variable to \"^nntp\".
 
-If a group matches both gnus-cacheable-groups and gnus-uncacheable-groups
+If a group matches both `gnus-cacheable-groups' and `gnus-uncacheable-groups'
 it's not cached."
   :group 'gnus-cache
   :type '(choice (const :tag "off" nil)
diff --git a/lisp/gnus/gnus-group.el b/lisp/gnus/gnus-group.el
index a165752881a..0444b05450b 100644
--- a/lisp/gnus/gnus-group.el
+++ b/lisp/gnus/gnus-group.el
@@ -40,9 +40,9 @@
   (require 'mm-url)
   (require 'subr-x)
   (let ((features (cons 'gnus-group features)))
-    (require 'gnus-sum))
-  (unless (boundp 'gnus-cache-active-hashtb)
-    (defvar gnus-cache-active-hashtb nil)))
+    (require 'gnus-sum)))
+
+(defvar gnus-cache-active-hashtb)
 
 (defvar tool-bar-mode)
 
@@ -505,7 +505,8 @@ simple manner."
                 (+ number
                    (gnus-range-length (cdr (assq 'dormant gnus-tmp-marked)))
                    (gnus-range-length (cdr (assq 'tick gnus-tmp-marked))))))
-              (t number)) ?s)
+              (t number))
+        ?s)
     (?R gnus-tmp-number-of-read ?s)
     (?U (if (gnus-active gnus-tmp-group)
             (gnus-number-of-unseen-articles-in-group gnus-tmp-group)
@@ -516,7 +517,8 @@ simple manner."
     (?I (gnus-range-length (cdr (assq 'dormant gnus-tmp-marked))) ?d)
     (?T (gnus-range-length (cdr (assq 'tick gnus-tmp-marked))) ?d)
     (?i (+ (gnus-range-length (cdr (assq 'dormant gnus-tmp-marked)))
-           (gnus-range-length (cdr (assq 'tick gnus-tmp-marked)))) ?d)
+           (gnus-range-length (cdr (assq 'tick gnus-tmp-marked))))
+        ?d)
     (?g gnus-tmp-group ?s)
     (?G gnus-tmp-qualified-group ?s)
     (?c (gnus-short-group-name gnus-tmp-group)
@@ -1541,7 +1543,8 @@ if it is a string, only list groups matching REGEXP."
          (gnus-tmp-news-method-string
           (if gnus-tmp-method
               (format "(%s:%s)" (car gnus-tmp-method)
-                      (cadr gnus-tmp-method)) ""))
+                      (cadr gnus-tmp-method))
+            ""))
          (gnus-tmp-marked-mark
           (if (and (numberp number)
                    (zerop number)
@@ -1985,31 +1988,18 @@ Take into consideration N (the prefix) and the list of marked groups."
     (let ((group (gnus-group-group-name)))
       (and group (list group))))))
 
-;;; !!!Surely gnus-group-iterate should be a macro instead?  I can't
-;;; imagine why I went through these contortions...
-(eval-and-compile
-  (let ((function (make-symbol "gnus-group-iterate-function"))
-        (window (make-symbol "gnus-group-iterate-window"))
-        (groups (make-symbol "gnus-group-iterate-groups"))
-        (group (make-symbol "gnus-group-iterate-group")))
-    (eval
-     `(defun gnus-group-iterate (arg ,function)
-        "Iterate FUNCTION over all process/prefixed groups.
+(defun gnus-group-iterate (arg function)
+  "Iterate FUNCTION over all process/prefixed groups.
 FUNCTION will be called with the group name as the parameter
 and with point over the group in question."
-        (let ((,groups (gnus-group-process-prefix arg))
-              (,window (selected-window))
-              ,group)
-          (while ,groups
-            (setq ,group (car ,groups)
-                  ,groups (cdr ,groups))
-            (select-window ,window)
-            (gnus-group-remove-mark ,group)
-            (save-selected-window
-              (save-excursion
-                (funcall ,function ,group)))))))))
-
-(put 'gnus-group-iterate 'lisp-indent-function 1)
+  (declare (indent 1))
+  (let ((window (selected-window)))
+    (dolist (group (gnus-group-process-prefix arg))
+      (select-window window)
+      (gnus-group-remove-mark group)
+      (save-selected-window
+        (save-excursion
+          (funcall function group))))))
 
 ;; Selecting groups.
 
@@ -2807,7 +2797,7 @@ not-expirable articles, too."
            (format "Do you really want to delete these %d articles forever? "
                    (length articles)))
       (gnus-request-expire-articles articles group
-                                    (if current-prefix-arg
+                                    (if oldp
                                         nil
                                       'force)))))
 
diff --git a/lisp/gnus/gnus-html.el b/lisp/gnus/gnus-html.el
index 855d085c3a9..6a0cc0b47dc 100644
--- a/lisp/gnus/gnus-html.el
+++ b/lisp/gnus/gnus-html.el
@@ -151,7 +151,7 @@ fit these criteria."
 
 (defun gnus-html-wash-images ()
   "Run through current buffer and replace img tags by images."
-  (let (tag parameters string start end images url alt-text
+  (let (tag parameters string start end images
             inhibit-images blocked-images)
     (if (buffer-live-p gnus-summary-buffer)
         (with-current-buffer gnus-summary-buffer
@@ -169,65 +169,65 @@ fit these criteria."
         (delete-region (match-beginning 0) (match-end 0)))
       (setq end (point))
       (when (string-match "src=\"\\([^\"]+\\)" parameters)
-        (gnus-message 8 "gnus-html-wash-tags: fetching image URL %s" url)
-        (setq url (gnus-html-encode-url (match-string 1 parameters))
-              alt-text (when (string-match "\\(alt\\|title\\)=\"\\([^\"]+\\)"
-                                           parameters)
-                         (xml-substitute-special (match-string 2 parameters))))
-        (add-text-properties
-         start end
-         (list 'image-url url
-               'image-displayer `(lambda (url start end)
-                                   (gnus-html-display-image url start end
-                                                            ,alt-text))
-               'help-echo alt-text
-               'button t
-               'keymap gnus-html-image-map
-               'gnus-image (list url start end alt-text)))
-        (if (string-match "\\`cid:" url)
-            ;; URLs with cid: have their content stashed in other
-            ;; parts of the MIME structure, so just insert them
-            ;; immediately.
-            (let* ((handle (mm-get-content-id (substring url (match-end 0))))
-                   (image (when (and handle
-                                     (not inhibit-images))
-                            (gnus-create-image
-                             (mm-with-part handle (buffer-string))
-                             nil t))))
-              (if image
-                  (gnus-add-image
-                   'cid
-                   (gnus-put-image
-                    (gnus-rescale-image
-                     image (gnus-html-maximum-image-size))
-                    (gnus-string-or (prog1
-                                        (buffer-substring start end)
-                                      (delete-region start end))
-                                    "*")
-                    'cid))
+        (let ((url (gnus-html-encode-url (match-string 1 parameters)))
+              (alt-text (when (string-match "\\(alt\\|title\\)=\"\\([^\"]+\\)"
+                                            parameters)
+                          (xml-substitute-special (match-string 2 parameters)))))
+          (gnus-message 8 "gnus-html-wash-tags: fetching image URL %s" url)
+          (add-text-properties
+           start end
+           (list 'image-url url
+                 'image-displayer `(lambda (url start end)
+                                     (gnus-html-display-image url start end
+                                                              ,alt-text))
+                 'help-echo alt-text
+                 'button t
+                 'keymap gnus-html-image-map
+                 'gnus-image (list url start end alt-text)))
+          (if (string-match "\\`cid:" url)
+              ;; URLs with cid: have their content stashed in other
+              ;; parts of the MIME structure, so just insert them
+              ;; immediately.
+              (let* ((handle (mm-get-content-id (substring url (match-end 0))))
+                     (image (when (and handle
+                                       (not inhibit-images))
+                              (gnus-create-image
+                               (mm-with-part handle (buffer-string))
+                               nil t))))
+                (if image
+                    (gnus-add-image
+                     'cid
+                     (gnus-put-image
+                      (gnus-rescale-image
+                       image (gnus-html-maximum-image-size))
+                      (gnus-string-or (prog1
+                                          (buffer-substring start end)
+                                        (delete-region start end))
+                                      "*")
+                      'cid))
+                  (make-text-button start end
+                                    'help-echo url
+                                    'keymap gnus-html-image-map)))
+            ;; Normal, external URL.
+            (if (or inhibit-images
+                    (gnus-html-image-url-blocked-p url blocked-images))
                 (make-text-button start end
                                   'help-echo url
-                                  'keymap gnus-html-image-map)))
-          ;; Normal, external URL.
-          (if (or inhibit-images
-                  (gnus-html-image-url-blocked-p url blocked-images))
-              (make-text-button start end
-                                'help-echo url
-                                'keymap gnus-html-image-map)
-            ;; Non-blocked url
-            (let ((width
-                   (when (string-match "width=\"?\\([0-9]+\\)" parameters)
-                     (string-to-number (match-string 1 parameters))))
-                  (height
-                   (when (string-match "height=\"?\\([0-9]+\\)" parameters)
-                     (string-to-number (match-string 1 parameters)))))
-              ;; Don't fetch images that are really small.  They're
-              ;; probably tracking pictures.
-              (when (and (or (null height)
-                             (> height 4))
-                         (or (null width)
-                             (> width 4)))
-                (gnus-html-display-image url start end alt-text)))))))))
+                                  'keymap gnus-html-image-map)
+              ;; Non-blocked url
+              (let ((width
+                     (when (string-match "width=\"?\\([0-9]+\\)" parameters)
+                       (string-to-number (match-string 1 parameters))))
+                    (height
+                     (when (string-match "height=\"?\\([0-9]+\\)" parameters)
+                       (string-to-number (match-string 1 parameters)))))
+                ;; Don't fetch images that are really small.  They're
+                ;; probably tracking pictures.
+                (when (and (or (null height)
+                               (> height 4))
+                           (or (null width)
+                               (> width 4)))
+                  (gnus-html-display-image url start end alt-text))))))))))
 
 (defun gnus-html-display-image (url start end &optional alt-text)
   "Display image at URL on text from START to END.
diff --git a/lisp/gnus/gnus-msg.el b/lisp/gnus/gnus-msg.el
index 9ca82f881a8..49be7047855 100644
--- a/lisp/gnus/gnus-msg.el
+++ b/lisp/gnus/gnus-msg.el
@@ -610,19 +610,19 @@ If ARG is 1, prompt for a group name to find the posting style."
   (interactive "P")
   ;; We can't `let' gnus-newsgroup-name here, since that leads
   ;; to local variables leaking.
-  (let ((group gnus-newsgroup-name)
-        ;; make sure last viewed article doesn't affect posting styles:
-        (gnus-article-copy)
-        (buffer (current-buffer)))
-    (let ((gnus-newsgroup-name
-           (if arg
-               (if (= 1 (prefix-numeric-value arg))
-                   (gnus-group-completing-read
-                    "Use posting style of group"
-                    nil (gnus-read-active-file-p))
-                 (gnus-group-group-name))
-             "")))
-      (gnus-setup-message 'message (message-mail)))))
+  (let* ((group gnus-newsgroup-name)
+         ;; make sure last viewed article doesn't affect posting styles:
+         (gnus-article-copy)
+         (buffer (current-buffer))
+         (gnus-newsgroup-name
+          (if arg
+              (if (= 1 (prefix-numeric-value arg))
+                  (gnus-group-completing-read
+                   "Use posting style of group"
+                   nil (gnus-read-active-file-p))
+                (gnus-group-group-name))
+            "")))
+    (gnus-setup-message 'message (message-mail))))
 
 (defun gnus-group-news (&optional arg)
   "Start composing a news.
@@ -635,21 +635,21 @@ network.  The corresponding back end must have a `request-post' method."
   (interactive "P")
   ;; We can't `let' gnus-newsgroup-name here, since that leads
   ;; to local variables leaking.
-  (let ((group gnus-newsgroup-name)
-        ;; make sure last viewed article doesn't affect posting styles:
-        (gnus-article-copy)
-        (buffer (current-buffer)))
-    (let ((gnus-newsgroup-name
-           (if arg
-               (if (= 1 (prefix-numeric-value arg))
-                   (gnus-group-completing-read "Use group"
-                                               nil
-                                               (gnus-read-active-file-p))
-                 (gnus-group-group-name))
-             "")))
-      (gnus-setup-message
-       'message
-       (message-news (gnus-group-real-name gnus-newsgroup-name))))))
+  (let* ((group gnus-newsgroup-name)
+         ;; make sure last viewed article doesn't affect posting styles:
+         (gnus-article-copy)
+         (buffer (current-buffer))
+         (gnus-newsgroup-name
+          (if arg
+              (if (= 1 (prefix-numeric-value arg))
+                  (gnus-group-completing-read "Use group"
+                                              nil
+                                              (gnus-read-active-file-p))
+                (gnus-group-group-name))
+            "")))
+    (gnus-setup-message
+     'message
+     (message-news (gnus-group-real-name gnus-newsgroup-name)))))
 
 (defun gnus-group-post-news (&optional arg)
   "Start composing a message (a news by default).
@@ -678,19 +678,19 @@ posting style."
   (interactive "P")
   ;; We can't `let' gnus-newsgroup-name here, since that leads
   ;; to local variables leaking.
-  (let ((group gnus-newsgroup-name)
-        ;; make sure last viewed article doesn't affect posting styles:
-        (gnus-article-copy)
-        (buffer (current-buffer)))
-    (let ((gnus-newsgroup-name
-           (if arg
-               (if (= 1 (prefix-numeric-value arg))
-                   (gnus-group-completing-read "Use group"
-                                               nil
-                                               (gnus-read-active-file-p))
-                 "")
-             gnus-newsgroup-name)))
-      (gnus-setup-message 'message (message-mail)))))
+  (let* ((group gnus-newsgroup-name)
+         ;; make sure last viewed article doesn't affect posting styles:
+         (gnus-article-copy)
+         (buffer (current-buffer))
+         (gnus-newsgroup-name
+          (if arg
+              (if (= 1 (prefix-numeric-value arg))
+                  (gnus-group-completing-read "Use group"
+                                              nil
+                                              (gnus-read-active-file-p))
+                "")
+            gnus-newsgroup-name)))
+    (gnus-setup-message 'message (message-mail))))
 
 (defun gnus-summary-news-other-window (&optional arg)
   "Start composing a news in another window.
@@ -703,26 +703,26 @@ network.  The corresponding back end must have a `request-post' method."
   (interactive "P")
   ;; We can't `let' gnus-newsgroup-name here, since that leads
   ;; to local variables leaking.
-  (let ((group gnus-newsgroup-name)
-        ;; make sure last viewed article doesn't affect posting styles:
-        (gnus-article-copy)
-        (buffer (current-buffer)))
-    (let ((gnus-newsgroup-name
-           (if arg
-               (if (= 1 (prefix-numeric-value arg))
-                   (gnus-group-completing-read "Use group"
-                                               nil
-                                               (gnus-read-active-file-p))
-                 "")
-             gnus-newsgroup-name)))
-      (gnus-setup-message
-       'message
-       (progn
-         (message-news (gnus-group-real-name gnus-newsgroup-name))
-         (setq-local gnus-discouraged-post-methods
-                     (remove
-                      (car (gnus-find-method-for-group gnus-newsgroup-name))
-                      gnus-discouraged-post-methods)))))))
+  (let* ((group gnus-newsgroup-name)
+         ;; make sure last viewed article doesn't affect posting styles:
+         (gnus-article-copy)
+         (buffer (current-buffer))
+         (gnus-newsgroup-name
+          (if arg
+              (if (= 1 (prefix-numeric-value arg))
+                  (gnus-group-completing-read "Use group"
+                                              nil
+                                              (gnus-read-active-file-p))
+                "")
+            gnus-newsgroup-name)))
+    (gnus-setup-message
+     'message
+     (progn
+       (message-news (gnus-group-real-name gnus-newsgroup-name))
+       (setq-local gnus-discouraged-post-methods
+                   (remove
+                    (car (gnus-find-method-for-group gnus-newsgroup-name))
+                    gnus-discouraged-post-methods))))))
 
 (defun gnus-summary-post-news (&optional arg)
   "Start composing a message.  Post to the current group by default.
diff --git a/lisp/gnus/gnus-spec.el b/lisp/gnus/gnus-spec.el
index 0dfa9f99d35..a50d9f3a5f4 100644
--- a/lisp/gnus/gnus-spec.el
+++ b/lisp/gnus/gnus-spec.el
@@ -151,9 +151,9 @@ Return a list of updated types."
           (when (and (boundp buffer)
                      (setq val (symbol-value buffer))
                      (gnus-buffer-live-p val))
-            (set-buffer val))
-          (setq new-format (symbol-value
-                            (intern (format "gnus-%s-line-format" type)))))
+            (set-buffer val)))
+        (setq new-format (symbol-value
+                          (intern (format "gnus-%s-line-format" type))))
         (setq entry (cdr (assq type gnus-format-specs)))
         (if (and (car entry)
                  (equal (car entry) new-format))
@@ -170,7 +170,7 @@ Return a list of updated types."
                    new-format
                    (symbol-value
                     (intern (format "gnus-%s-line-format-alist" type)))
-                   (not (string-match "mode$" (symbol-name type))))))
+                   (not (string-match "mode\\'" (symbol-name type))))))
           ;; Enter the new format spec into the list.
           (if entry
               (progn
@@ -526,13 +526,13 @@ or to characters when given a pad value."
         (if (eq spec ?%)
             ;; "%%" just results in a "%".
             (insert "%")
-          (cond
-           ;; Do tilde forms.
-           ((eq spec ?@)
-            (setq elem (list tilde-form ?s)))
-           ;; Treat user defined format specifiers specially.
-           (user-defined
-            (setq elem
+          (setq elem
+                (cond
+                 ;; Do tilde forms.
+                 ((eq spec ?@)
+                  (list tilde-form ?s))
+                 ;; Treat user defined format specifiers specially.
+                 (user-defined
                   (list
                    (list (intern (format
                                   (if (stringp user-defined)
@@ -540,14 +540,14 @@ or to characters when given a pad value."
                                     "gnus-user-format-function-%c")
                                   user-defined))
                          'gnus-tmp-header)
-                   ?s)))
-           ;; Find the specification from `spec-alist'.
-           ((setq elem (cdr (assq (or extended-spec spec) spec-alist))))
-           ;; We used to use "%l" for displaying the grouplens score.
-           ((eq spec ?l)
-            (setq elem '("" ?s)))
-           (t
-            (setq elem '("*" ?s))))
+                   ?s))
+                 ;; Find the specification from `spec-alist'.
+                 ((cdr (assq (or extended-spec spec) spec-alist)))
+                 ;; We used to use "%l" for displaying the grouplens score.
+                 ((eq spec ?l)
+                  '("" ?s))
+                 (t
+                  '("*" ?s))))
           (setq elem-type (cadr elem))
           ;; Insert the new format elements.
           (when pad-width
diff --git a/lisp/gnus/gnus-start.el b/lisp/gnus/gnus-start.el
index a3159595c45..1554635a3f2 100644
--- a/lisp/gnus/gnus-start.el
+++ b/lisp/gnus/gnus-start.el
@@ -2337,7 +2337,7 @@ If FORCE is non-nil, the .newsrc file is read."
                            gnus-newsrc-file-version gnus-version)))))))
 
 (defun gnus-convert-mark-converter-prompt (converter no-prompt)
-  "Indicate whether CONVERTER requires gnus-convert-old-newsrc to
+  "Indicate whether CONVERTER requires `gnus-convert-old-newsrc' to
   display the conversion prompt.  NO-PROMPT may be nil (prompt),
   t (no prompt), or any form that can be called as a function.
   The form should return either t or nil."
@@ -2989,13 +2989,12 @@ SPECIFIC-VARIABLES, or those in `gnus-variable-list'."
 ;;; Child functions.
 ;;;
 
-(defvar gnus-child-mode nil)
+;; (defvar gnus-child-mode nil)
 
 (defun gnus-child-mode ()
   "Minor mode for child Gnusae."
-  ;; FIXME: gnus-child-mode appears to never be set (i.e. it'll always be nil):
-  ;; Remove, or fix and use define-minor-mode.
-  (add-minor-mode 'gnus-child-mode " Child" (make-sparse-keymap))
+  ;; FIXME: gnus-child-mode appears to never be set (i.e. it'll always be nil).
+  ;; (add-minor-mode 'gnus-child-mode " Child" (make-sparse-keymap))
   (gnus-run-hooks 'gnus-child-mode-hook))
 
 (define-obsolete-function-alias 'gnus-slave-mode #'gnus-child-mode "28.1")
diff --git a/lisp/gnus/gnus-util.el b/lisp/gnus/gnus-util.el
index b8451028d1e..408293f1a16 100644
--- a/lisp/gnus/gnus-util.el
+++ b/lisp/gnus/gnus-util.el
@@ -1203,9 +1203,7 @@ ARG is passed to the first function."
            (string-equal (downcase x) (downcase y)))))
 
 (defcustom gnus-use-byte-compile t
-  "If non-nil, byte-compile crucial run-time code.
-Setting it to nil has no effect after the first time `gnus-byte-compile'
-is run."
+  "If non-nil, byte-compile crucial run-time code."
   :type 'boolean
   :version "22.1"
   :group 'gnus-various)
@@ -1213,13 +1211,8 @@ is run."
 (defun gnus-byte-compile (form)
   "Byte-compile FORM if `gnus-use-byte-compile' is non-nil."
   (if gnus-use-byte-compile
-      (progn
-        (require 'bytecomp)
-        (defalias 'gnus-byte-compile
-          (lambda (form)
-            (let ((byte-compile-warnings '(unresolved callargs redefine)))
-              (byte-compile form))))
-        (gnus-byte-compile form))
+      (let ((byte-compile-warnings '(unresolved callargs redefine)))
+        (byte-compile form))
     form))
 
 (defun gnus-remassoc (key alist)
@@ -1385,6 +1378,7 @@ SPEC is a predicate specifier that contains stuff like `or', `and',
 (declare-function iswitchb-read-buffer "iswitchb"
                   (prompt &optional default require-match
                           _predicate start matches-set))
+(declare-function iswitchb-minibuffer-setup "iswitchb")
 (defvar iswitchb-temp-buflist)
 (defvar iswitchb-mode)
 
@@ -1449,7 +1443,8 @@ CHOICE is a list of the choice char and help message at IDX."
                    prompt
                    (concat
                     (mapconcat (lambda (s) (char-to-string (car s)))
-                               choice ", ") ", ?"))
+                               choice ", ")
+                    ", ?"))
           (setq tchar (read-char))
           (when (not (assq tchar choice))
             (setq tchar nil)
diff --git a/lisp/gnus/gnus-uu.el b/lisp/gnus/gnus-uu.el
index 2bc1f864deb..e4aaf92c89c 100644
--- a/lisp/gnus/gnus-uu.el
+++ b/lisp/gnus/gnus-uu.el
@@ -1949,6 +1949,7 @@ The user will be asked for a file name."
                   (gnus-uu-choose-action file-name gnus-uu-ext-to-mime-list)
                   file-name))
   (insert (format "Content-Transfer-Encoding: %s\n\n" encoding))
+  ;; FIXME: Shouldn't we set-buffer before saving the restriction?  --Stef
   (save-restriction
     (set-buffer gnus-message-buffer)
     (goto-char (point-min))
diff --git a/lisp/gnus/mail-source.el b/lisp/gnus/mail-source.el
index 212657aec26..4f02d86f441 100644
--- a/lisp/gnus/mail-source.el
+++ b/lisp/gnus/mail-source.el
@@ -380,13 +380,10 @@ All keywords that can be used must be listed here."))
 ;; suitable for usage in a `let' form
 (eval-and-compile
   (defun mail-source-bind-1 (type)
-    (let* ((defaults (cdr (assq type mail-source-keyword-map)))
-           default bind)
-      (while (setq default (pop defaults))
-        (push (list (mail-source-strip-keyword (car default))
-                    nil)
-              bind))
-      bind)))
+    (mapcar (lambda (default)
+              (list (mail-source-strip-keyword (car default))
+                    nil))
+            (cdr (assq type mail-source-keyword-map)))))
 
 (defmacro mail-source-bind (type-source &rest body)
   "Return a `let' form that binds all variables in source TYPE.
@@ -476,20 +473,16 @@ the `mail-source-keyword-map' variable."
 
 (eval-and-compile
   (defun mail-source-bind-common-1 ()
-    (let* ((defaults mail-source-common-keyword-map)
-           default bind)
-      (while (setq default (pop defaults))
-        (push (list (mail-source-strip-keyword (car default))
-                    nil)
-              bind))
-      bind)))
+    (mapcar (lambda (default)
+              (list (mail-source-strip-keyword (car default))
+                    nil))
+            mail-source-common-keyword-map)))
 
 (defun mail-source-set-common-1 (source)
   (let* ((type (pop source))
-         (defaults mail-source-common-keyword-map)
          (defaults-1 (cdr (assq type mail-source-keyword-map)))
-         default value keyword)
-    (while (setq default (pop defaults))
+         value keyword)
+    (dolist (default mail-source-common-keyword-map)
       (set (mail-source-strip-keyword (setq keyword (car default)))
            (if (setq value (plist-get source keyword))
                (mail-source-value value)
@@ -919,7 +912,7 @@ authentication.  To do that, you need to set the
 `message-send-mail-function' variable as `message-smtpmail-send-it'
 and put the following line in your ~/.gnus.el file:
 
-\(add-hook \\='message-send-mail-hook \\='mail-source-touch-pop)
+\(add-hook \\='message-send-mail-hook #\\='mail-source-touch-pop)
 
 See the Gnus manual for details."
   (let ((sources (if mail-source-primary-source
@@ -963,6 +956,8 @@ See the Gnus manual for details."
     ;; (element 0 of the vector is nil if the timer is active).
     (aset mail-source-report-new-mail-idle-timer 0 nil)))
 
+(declare-function display-time-event-handler "time" ())
+
 (defun mail-source-report-new-mail (arg)
   "Toggle whether to report when new mail is available.
 This only works when `display-time' is enabled."
@@ -1075,7 +1070,8 @@ This only works when `display-time' is enabled."
       (if (and (imap-open server port stream authentication buf)
                (imap-authenticate
                 user (or (cdr (assoc from mail-source-password-cache))
-                         password) buf))
+                         password)
+                buf))
           (let ((mailbox-list (if (listp mailbox) mailbox (list mailbox))))
             (dolist (mailbox mailbox-list)
               (when (imap-mailbox-select mailbox nil buf)
diff --git a/lisp/gnus/mm-partial.el b/lisp/gnus/mm-partial.el
index 165c19139ce..8d4913e6fbd 100644
--- a/lisp/gnus/mm-partial.el
+++ b/lisp/gnus/mm-partial.el
@@ -39,7 +39,8 @@
                                             gnus-newsgroup-name)
           (when (search-forward id nil t)
             (let ((nhandles (mm-dissect-buffer
-                             nil gnus-article-loose-mime)) nid)
+                             nil gnus-article-loose-mime))
+                  nid)
               (if (consp (car nhandles))
                   (mm-destroy-parts nhandles)
                 (setq nid (cdr (assq 'id
@@ -90,7 +91,7 @@ If NO-DISPLAY is nil, display it.  Otherwise, do nothing after replacing."
           (if ntotal
               (if total
                   (unless (eq total ntotal)
-                  (error "The numbers of total are different"))
+                    (error "The numbers of total are different"))
                 (setq total ntotal)))
           (unless (< nn n)
             (unless (eq nn n)
diff --git a/lisp/gnus/mm-util.el b/lisp/gnus/mm-util.el
index 329b9e8884d..be279b6cf1f 100644
--- a/lisp/gnus/mm-util.el
+++ b/lisp/gnus/mm-util.el
@@ -144,9 +144,9 @@ is not available."
    ;; on there being some coding system matching each `mime-charset'
    ;; property defined, as there should be.)
    ((and (mm-coding-system-p charset)
-;;; Doing this would potentially weed out incorrect charsets.
-;;;      charset
-;;;      (eq charset (coding-system-get charset 'mime-charset))
+         ;; Doing this would potentially weed out incorrect charsets.
+         ;;      charset
+         ;;      (eq charset (coding-system-get charset 'mime-charset))
          )
     charset)
    ;; Use coding system Emacs knows.
diff --git a/lisp/gnus/mml-smime.el b/lisp/gnus/mml-smime.el
index e97e3e9a06e..eabb56b3038 100644
--- a/lisp/gnus/mml-smime.el
+++ b/lisp/gnus/mml-smime.el
@@ -369,7 +369,7 @@ Content-Disposition: attachment; filename=smime.p7s
       (goto-char (point-max)))))
 
 (defun mml-smime-epg-encrypt (cont)
-  (let* ((inhibit-redisplay t)
+  (let* ((inhibit-redisplay t)        ;FIXME: Why?
          (boundary (mml-compute-boundary cont))
          (cipher (mml-secure-epg-encrypt 'CMS cont)))
     (delete-region (point-min) (point-max))
@@ -410,9 +410,9 @@ Content-Disposition: attachment; filename=smime.p7m
           (setq plain (epg-verify-string context (mm-get-part signature) part))
         (error
          (mm-sec-error 'gnus-info "Failed")
-         (if (eq (car error) 'quit)
-             (mm-sec-status 'gnus-details "Quit.")
-           (mm-sec-status 'gnus-details (format "%S" error)))
+         (mm-sec-status 'gnus-details (if (eq (car error) 'quit)
+                                          "Quit."
+                                        (format "%S" error)))
          (throw 'error handle)))
       (mm-sec-status
        'gnus-info
diff --git a/lisp/gnus/mml.el b/lisp/gnus/mml.el
index acde958c05b..54f8715baf0 100644
--- a/lisp/gnus/mml.el
+++ b/lisp/gnus/mml.el
@@ -241,22 +241,24 @@ part.  This is for the internal use, you should never modify the value.")
                (method (cdr (assq 'method taginfo)))
                tags)
           (save-excursion
-            (if (re-search-forward
-                 "<#/?\\(multipart\\|part\\|external\\|mml\\)." nil t)
-                (setq secure-mode "multipart")
-              (setq secure-mode "part")))
+            (setq secure-mode
+                  (if (re-search-forward
+                       "<#/?\\(multipart\\|part\\|external\\|mml\\)."
+                       nil t)
+                      "multipart"
+                    "part")))
           (save-excursion
             (goto-char location)
             (re-search-forward "<#secure[^\n]*>\n"))
           (delete-region (match-beginning 0) (match-end 0))
-          (cond ((string= mode "sign")
-                 (setq tags (list "sign" method)))
-                ((string= mode "encrypt")
-                 (setq tags (list "encrypt" method)))
-                ((string= mode "signencrypt")
-                 (setq tags (list "sign" method "encrypt" method)))
-                (t
-                 (error "Unknown secure mode %s" mode)))
+          (setq tags (cond ((string= mode "sign")
+                            (list "sign" method))
+                           ((string= mode "encrypt")
+                            (list "encrypt" method))
+                           ((string= mode "signencrypt")
+                            (list "sign" method "encrypt" method))
+                           (t
+                            (error "Unknown secure mode %s" mode))))
           (eval `(mml-insert-tag ,secure-mode
                                  ,@tags
                                  ,(if keyfile "keyfile")
@@ -1598,7 +1600,8 @@ or the `pop-to-buffer' function."
   (interactive "P")
   (setq mml-preview-buffer (generate-new-buffer
                             (concat (if raw "*Raw MIME preview of "
-                                      "*MIME preview of ") (buffer-name))))
+                                      "*MIME preview of ")
+                                    (buffer-name))))
   (require 'gnus-msg)                 ; for gnus-setup-posting-charset
   (save-excursion
     (let* ((buf (current-buffer))
@@ -1655,7 +1658,8 @@ or the `pop-to-buffer' function."
       (use-local-map nil)
       (add-hook 'kill-buffer-hook
                 (lambda ()
-                  (mm-destroy-parts gnus-article-mime-handles)) nil t)
+                  (mm-destroy-parts gnus-article-mime-handles))
+                nil t)
       (setq buffer-read-only t)
       (local-set-key "q" (lambda () (interactive) (kill-buffer nil)))
       (local-set-key "=" (lambda () (interactive) (delete-other-windows)))
diff --git a/lisp/gnus/mml2015.el b/lisp/gnus/mml2015.el
index 8eda59372fb..53454bf16d8 100644
--- a/lisp/gnus/mml2015.el
+++ b/lisp/gnus/mml2015.el
@@ -869,9 +869,9 @@ If set, it overrides the setting of `mml2015-sign-with-sender'."
           (setq plain (epg-verify-string context signature part))
         (error
          (mm-sec-error 'gnus-info "Failed")
-         (if (eq (car error) 'quit)
-             (mm-sec-status 'gnus-details "Quit.")
-           (mm-sec-status 'gnus-details (mml2015-format-error error)))
+         (mm-sec-status 'gnus-details (if (eq (car error) 'quit)
+                                          "Quit."
+                                        (mml2015-format-error error)))
          (throw 'error handle)))
       (mm-sec-status 'gnus-info
        (mml2015-epg-verify-result-to-string
diff --git a/lisp/gnus/nnbabyl.el b/lisp/gnus/nnbabyl.el
index 5149acc0e72..41f7f62fae6 100644
--- a/lisp/gnus/nnbabyl.el
+++ b/lisp/gnus/nnbabyl.el
@@ -263,7 +263,8 @@
                     (nnmail-expired-article-p
                      newsgroup
                      (buffer-substring
-                      (point) (progn (end-of-line) (point))) force))
+                      (point) (progn (end-of-line) (point)))
+                     force))
               (progn
                 (unless (eq nnmail-expiry-target 'delete)
                   (with-temp-buffer
diff --git a/lisp/gnus/nnmail.el b/lisp/gnus/nnmail.el
index 59d61379f14..251ae657bbf 100644
--- a/lisp/gnus/nnmail.el
+++ b/lisp/gnus/nnmail.el
@@ -712,7 +712,7 @@ If SOURCE is a directory spec, try to return the group name component."
   (if (eq (car source) 'directory)
       (let ((file (file-name-nondirectory file)))
         (mail-source-bind (directory source)
-          (if (string-match (concat (regexp-quote suffix) "$") file)
+          (if (string-match (concat (regexp-quote suffix) "\\'") file)
               (substring file 0 (match-beginning 0))
             nil)))
     nil))
@@ -1339,7 +1339,8 @@ to actually put the message in the right group."
   (let ((success t))
     (dolist (mbx (message-unquote-tokens
                   (message-tokenize-header
-                   (message-fetch-field "Newsgroups") ", ")) success)
+                   (message-fetch-field "Newsgroups") ", "))
+                 success)
       (let ((to-newsgroup (gnus-group-prefixed-name mbx gnus-command-method)))
         (or (gnus-active to-newsgroup)
             (gnus-activate-group to-newsgroup)
@@ -1433,11 +1434,11 @@ See the documentation for the variable `nnmail-split-fancy' for details."
               ;; we do not exclude foo.list just because
               ;; the header is: ``To: x-foo, foo''
               (goto-char end)
-              (if (and (re-search-backward (cadr split-rest)
-                                           after-header-name t)
-                       (> (match-end 0) start-of-value))
-                  (setq split-rest nil)
-                (setq split-rest (cddr split-rest))))
+              (setq split-rest
+                    (unless (and (re-search-backward (cadr split-rest)
+                                                     after-header-name t)
+                                 (> (match-end 0) start-of-value))
+                      (cddr split-rest))))
             (when split-rest
               (goto-char end)
               ;; Someone might want to do a \N sub on this match, so
diff --git a/lisp/gnus/nnmairix.el b/lisp/gnus/nnmairix.el
index 5e8ad4fa9ae..8b3ab40e225 100644
--- a/lisp/gnus/nnmairix.el
+++ b/lisp/gnus/nnmairix.el
@@ -676,9 +676,9 @@ Other back ends might or might not work.")
 (autoload 'nnimap-request-update-info-internal "nnimap")
 
 (deffoo nnmairix-request-marks (group info &optional server)
-;; propagate info from underlying IMAP folder to nnmairix group
-;; This is currently experimental and must be explicitly activated
-;; with nnmairix-propagate-marks-to-nnmairix-group
+  ;; propagate info from underlying IMAP folder to nnmairix group
+  ;; This is currently experimental and must be explicitly activated
+  ;; with nnmairix-propagate-marks-to-nnmairix-group
   (when server
     (nnmairix-open-server server))
   (let* ((qualgroup (gnus-group-prefixed-name
diff --git a/lisp/gnus/nnoo.el b/lisp/gnus/nnoo.el
index cd0a5e6de99..39469d140d9 100644
--- a/lisp/gnus/nnoo.el
+++ b/lisp/gnus/nnoo.el
@@ -85,20 +85,14 @@
 
 (defun nnoo-import-1 (backend imports)
   (let ((call-function
-         (if (symbolp (car imports)) (pop imports) 'nnoo-parent-function))
-        imp functions function)
-    (while (setq imp (pop imports))
-      (setq functions
-            (or (cdr imp)
-                (nnoo-functions (car imp))))
-      (while functions
-        (unless (fboundp
-                 (setq function
-                       (nnoo-symbol backend
-                                    (nnoo-rest-symbol (car functions)))))
-          (eval `(deffoo ,function (&rest args)
-                   (,call-function ',backend ',(car functions) args))))
-        (pop functions)))))
+         (if (symbolp (car imports)) (pop imports) #'nnoo-parent-function)))
+    (dolist (imp imports)
+      (dolist (fun (or (cdr imp) (nnoo-functions (car imp))))
+        (let ((function (nnoo-symbol backend (nnoo-rest-symbol fun))))
+          (unless (fboundp function)
+            ;; FIXME: Use `defalias' and closures to avoid `eval'.
+            (eval `(deffoo ,function (&rest args)
+                     (,call-function ',backend ',fun args)))))))))
 
 (defun nnoo-parent-function (backend function args)
   (let ((pbackend (nnoo-backend function))
@@ -131,22 +125,21 @@
 
 (defmacro nnoo-map-functions (backend &rest maps)
   (declare (indent 1))
-  `(nnoo-map-functions-1 ',backend ',maps))
-
-(defun nnoo-map-functions-1 (backend maps)
-  (let (m margs i)
-    (while (setq m (pop maps))
-      (setq i 0
-            margs nil)
-      (while (< i (length (cdr m)))
-        (if (numberp (nth i (cdr m)))
-            (push `(nth ,i args) margs)
-          (push (nth i (cdr m)) margs))
-        (cl-incf i))
-      (eval `(deffoo ,(nnoo-symbol backend (nnoo-rest-symbol (car m)))
+  `(progn
+     ,@(mapcar
+        (lambda (m)
+          (let ((margs nil))
+            (dotimes (i (length (cdr m)))
+              (push (if (numberp (nth i (cdr m)))
+                        `(nth ,i args)
+                      (nth i (cdr m)))
+                    margs))
+            `(deffoo ,(nnoo-symbol backend (nnoo-rest-symbol (car m)))
                  (&rest args)
+               (ignore args) ;; Not always used!
                (nnoo-parent-function ',backend ',(car m)
-                                     ,(cons 'list (nreverse margs))))))))
+                                     ,(cons 'list (nreverse margs))))))
+        maps)))
 
 (defun nnoo-backend (symbol)
   (string-match "^[^-]+-" (symbol-name symbol))
@@ -273,19 +266,27 @@
 
 (defmacro nnoo-define-basics (backend)
   "Define `close-server', `server-opened' and `status-message'."
-  `(eval-and-compile
-     (nnoo-define-basics-1 ',backend)))
-
-(defun nnoo-define-basics-1 (backend)
-  (dolist (function '(server-opened status-message))
-    (eval `(deffoo ,(nnoo-symbol backend function) (&optional server)
-             (,(nnoo-symbol 'nnoo function) ',backend server))))
-  (dolist (function '(close-server))
-    (eval `(deffoo ,(nnoo-symbol backend function) (&optional server defs)
-             (,(nnoo-symbol 'nnoo function) ',backend server))))
-  (eval `(deffoo ,(nnoo-symbol backend 'open-server)
-             (server &optional defs)
-           (nnoo-change-server ',backend server defs))))
+  (let ((form
+         ;; We wrap the definitions in `when t' here so that a subsequent
+         ;; "real" definition of one those doesn't trigger a "defined multiple
+         ;; times" warning.
+         `(when t
+            ,@(mapcar (lambda (fun)
+                       `(deffoo ,(nnoo-symbol backend fun) (&optional server)
+                          (,(nnoo-symbol 'nnoo fun) ',backend server)))
+                     '(server-opened status-message))
+           (deffoo ,(nnoo-symbol backend 'close-server) (&optional server _defs)
+             (,(nnoo-symbol 'nnoo 'close-server) ',backend server))
+           (deffoo ,(nnoo-symbol backend 'open-server) (server &optional defs)
+             (nnoo-change-server ',backend server defs)))))
+    ;; Wrapping with `when' has the downside that the compiler now doesn't
+    ;; "know" that these functions are defined, so to avoid "not known to be
+    ;; defined" warnings we eagerly define them during the compilation.
+    ;; This is fairly nasty since it will override previous "real" definitions
+    ;; (e.g. when compiling this in an Emacs instance that's running Gnus), but
+    ;; that's also what the previous code did, so it sucks but is not worse.
+    (eval form t)
+    form))
 
 (defmacro nnoo-define-skeleton (backend)
   "Define all required backend functions for BACKEND.
@@ -294,17 +295,17 @@ All functions will return nil and report an error."
      (nnoo-define-skeleton-1 ',backend)))
 
 (defun nnoo-define-skeleton-1 (backend)
-  (let ((functions '(retrieve-headers
-                     request-close request-article
-                     request-group close-group
-                     request-list request-post request-list-newsgroups))
-        function fun)
-    (while (setq function (pop functions))
-      (when (not (fboundp (setq fun (nnoo-symbol backend function))))
+  (dolist (op '(retrieve-headers
+                request-close request-article
+                request-group close-group
+                request-list request-post request-list-newsgroups))
+    (let ((fun (nnoo-symbol backend op)))
+      (unless (fboundp fun)
+        ;; FIXME: Use `defalias' and closures to avoid `eval'.
         (eval `(deffoo ,fun
-                   (&rest args)
-                 (nnheader-report ',backend ,(format "%s-%s not implemented"
-                                                     backend function))))))))
+                   (&rest _args)
+                 (nnheader-report ',backend ,(format "%s-%s not implemented"
+                                                     backend op))))))))
 
 (defun nnoo-set (server &rest args)
   (let ((parents (nnoo-parents (car server)))
diff --git a/lisp/gnus/nnweb.el b/lisp/gnus/nnweb.el
index 2a948254717..dd71bea72e2 100644
--- a/lisp/gnus/nnweb.el
+++ b/lisp/gnus/nnweb.el
@@ -154,17 +154,17 @@ Valid types include `google', `dejanews', and `gmane'.")
                 (and (stringp article)
                      (nnweb-definition 'id t)
                      (let ((fetch (nnweb-definition 'id))
-                           art active)
-                       (when (string-match "^<\\(.*\\)>$" article)
-                         (setq art (match-string 1 article)))
+                           (art (when (string-match "^<\\(.*\\)>$" article)
+                                  (match-string 1 article)))
+                           active)
                        (when (and fetch art)
                          (setq url (format fetch
                                            (mm-url-form-encode-xwfu art)))
                          (mm-url-insert url)
                          (if (nnweb-definition 'reference t)
                              (setq article
-                                   (funcall (nnweb-definition
-                                             'reference) article)))))))
+                                   (funcall (nnweb-definition 'reference)
+                                            article)))))))
         (unless nnheader-callback-function
           (funcall (nnweb-definition 'article)))
         (nnheader-report 'nnweb "Fetched article %s" article)
diff --git a/lisp/gnus/spam.el b/lisp/gnus/spam.el
index 3f4fd3614ee..00dcd00ceab 100644
--- a/lisp/gnus/spam.el
+++ b/lisp/gnus/spam.el
@@ -321,8 +321,8 @@ Default to t if one of the spam-use-* variables is set."
   :type 'string
   :group 'spam)
 
-;;; TODO: deprecate this variable, it's confusing since it's a list of strings,
-;;; not regular expressions
+;; TODO: deprecate this variable, it's confusing since it's a list of strings,
+;; not regular expressions
 (defcustom spam-junk-mailgroups (cons
                                  spam-split-group
                                  '("mail.junk" "poste.pourriel"))
@@ -1836,7 +1836,7 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
       ;; return the number of articles processed
       (length articles))))
 
-;;; log a ham- or spam-processor invocation to the registry
+;; log a ham- or spam-processor invocation to the registry
 (defun spam-log-processing-to-registry (id type classification backend group)
   (when spam-log-to-registry
     (if (and (stringp id)
@@ -1855,7 +1855,7 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
         "%s call with bad ID, type, classification, spam-backend, or group"
         "spam-log-processing-to-registry")))))
 
-;;; check if a ham- or spam-processor registration has been done
+;; check if a ham- or spam-processor registration has been done
 (defun spam-log-registered-p (id type)
   (when spam-log-to-registry
     (if (and (stringp id)
@@ -1868,8 +1868,8 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
                  "spam-log-registered-p"))
         nil))))
 
-;;; check what a ham- or spam-processor registration says
-;;; returns nil if conflicting registrations are found
+;; check what a ham- or spam-processor registration says
+;; returns nil if conflicting registrations are found
 (defun spam-log-registration-type (id type)
   (let ((count 0)
         decision)
@@ -1885,7 +1885,7 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
       decision)))
 
 
-;;; check if a ham- or spam-processor registration needs to be undone
+;; check if a ham- or spam-processor registration needs to be undone
 (defun spam-log-unregistration-needed-p (id type classification backend)
   (when spam-log-to-registry
     (if (and (stringp id)
@@ -1908,7 +1908,7 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
         nil))))
 
 
-;;; undo a ham- or spam-processor registration (the group is not used)
+;; undo a ham- or spam-processor registration (the group is not used)
 (defun spam-log-undo-registration (id type classification backend
                                       &optional group)
   (when (and spam-log-to-registry
@@ -2034,94 +2034,83 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
 
 ;;{{{ BBDB
 
-;;; original idea for spam-check-BBDB from Alexander Kotelnikov
-;;; <sacha@giotto.sj.ru>
+;; original idea for spam-check-BBDB from Alexander Kotelnikov
+;; <sacha@giotto.sj.ru>
 
 ;; all this is done inside a condition-case to trap errors
 
 ;; Autoloaded in message, which we require.
 (declare-function gnus-extract-address-components "gnus-util" (from))
 
-(eval-and-compile
-  (condition-case nil
-      (progn
-        (require 'bbdb)
-        (require 'bbdb-com))
-    (file-error
-     ;; `bbdb-records' should not be bound as an autoload function
-     ;; before loading bbdb because of `bbdb-hashtable-size'.
-     (defalias 'bbdb-buffer 'ignore)
-     (defalias 'bbdb-create-internal 'ignore)
-     (defalias 'bbdb-records 'ignore)
-     (defalias 'spam-BBDB-register-routine 'ignore)
-     (defalias 'spam-enter-ham-BBDB 'ignore)
-     (defalias 'spam-exists-in-BBDB-p 'ignore)
-     (defalias 'bbdb-gethash 'ignore)
-     nil)))
-
-(eval-and-compile
-  (when (featurep 'bbdb-com)
-    ;; when the BBDB changes, we want to clear out our cache
-    (defun spam-clear-cache-BBDB (&rest immaterial)
-      (spam-clear-cache 'spam-use-BBDB))
-
-    (add-hook 'bbdb-change-hook 'spam-clear-cache-BBDB)
-
-    (defun spam-enter-ham-BBDB (addresses &optional remove)
-      "Enter an address into the BBDB; implies ham (non-spam) sender"
-      (dolist (from addresses)
-        (when (stringp from)
-          (let* ((parsed-address (gnus-extract-address-components from))
-                 (name (or (nth 0 parsed-address) "Ham Sender"))
-                 (remove-function (if remove
-                                      'bbdb-delete-record-internal
-                                    'ignore))
-                 (net-address (nth 1 parsed-address))
-                 (record (and net-address
-                              (spam-exists-in-BBDB-p net-address))))
-            (when net-address
-              (gnus-message 6 "%s address %s %s BBDB"
-                            (if remove "Deleting" "Adding")
-                            from
-                            (if remove "from" "to"))
-              (if record
-                  (funcall remove-function record)
-                (bbdb-create-internal name nil net-address nil nil
-                                      "ham sender added by spam.el")))))))
-
-    (defun spam-BBDB-register-routine (articles &optional unregister)
-      (let (addresses)
-        (dolist (article articles)
-          (when (stringp (spam-fetch-field-from-fast article))
-            (push (spam-fetch-field-from-fast article) addresses)))
-        ;; now do the register/unregister action
-        (spam-enter-ham-BBDB addresses unregister)))
-
-    (defun spam-BBDB-unregister-routine (articles)
-      (spam-BBDB-register-routine articles t))
-
-    (defsubst spam-exists-in-BBDB-p (net)
-      (when (and (stringp net) (not (zerop (length net))))
-        (bbdb-records)
-        (bbdb-gethash (downcase net))))
-
-    (defun spam-check-BBDB ()
-      "Mail from people in the BBDB is classified as ham or non-spam"
-      (let ((net (message-fetch-field "from")))
-        (when net
-          (setq net (nth 1 (gnus-extract-address-components net)))
-          (if (spam-exists-in-BBDB-p net)
-              t
-            (if spam-use-BBDB-exclusive
-                spam-split-group
-              nil)))))))
+(require 'bbdb nil 'noerror)
+(require 'bbdb-com nil 'noerror)
+
+(declare-function bbdb-records "bbdb" ())
+(declare-function bbdb-gethash "bbdb" (key &optional predicate))
+(declare-function bbdb-create-internal "bbdb-com" (&rest spec))
+
+;; when the BBDB changes, we want to clear out our cache
+(defun spam-clear-cache-BBDB (&rest immaterial)
+  (spam-clear-cache 'spam-use-BBDB))
+
+(when (featurep 'bbdb-com)
+  (add-hook 'bbdb-change-hook #'spam-clear-cache-BBDB))
+
+(defun spam-enter-ham-BBDB (addresses &optional remove)
+  "Enter an address into the BBDB; implies ham (non-spam) sender"
+  (dolist (from addresses)
+    (when (stringp from)
+      (let* ((parsed-address (gnus-extract-address-components from))
+             (name (or (nth 0 parsed-address) "Ham Sender"))
+             (remove-function (if remove
+                                  'bbdb-delete-record-internal
+                                'ignore))
+             (net-address (nth 1 parsed-address))
+             (record (and net-address
+                          (spam-exists-in-BBDB-p net-address))))
+        (when net-address
+          (gnus-message 6 "%s address %s %s BBDB"
+                        (if remove "Deleting" "Adding")
+                        from
+                        (if remove "from" "to"))
+          (if record
+              (funcall remove-function record)
+            (bbdb-create-internal name nil net-address nil nil
+                                  "ham sender added by spam.el")))))))
+
+(defun spam-BBDB-register-routine (articles &optional unregister)
+  (let (addresses)
+    (dolist (article articles)
+      (when (stringp (spam-fetch-field-from-fast article))
+        (push (spam-fetch-field-from-fast article) addresses)))
+    ;; now do the register/unregister action
+    (spam-enter-ham-BBDB addresses unregister)))
+
+(defun spam-BBDB-unregister-routine (articles)
+  (spam-BBDB-register-routine articles t))
+
+(defun spam-exists-in-BBDB-p (net)
+  (when (and (stringp net) (not (zerop (length net))))
+    (bbdb-records)
+    (bbdb-gethash (downcase net))))
+
+(defun spam-check-BBDB ()
+  "Mail from people in the BBDB is classified as ham or non-spam"
+  (let ((net (message-fetch-field "from")))
+    (when net
+      (setq net (nth 1 (gnus-extract-address-components net)))
+      (if (spam-exists-in-BBDB-p net)
+          t
+        (if spam-use-BBDB-exclusive
+            spam-split-group
+          nil)))))
 
 ;;}}}
 
 ;;{{{ ifile
 
-;;; check the ifile backend; return nil if the mail was NOT classified
-;;; as spam
+;; check the ifile backend; return nil if the mail was NOT classified
+;; as spam
 
 
 (defun spam-get-ifile-database-parameter ()
@@ -2240,7 +2229,7 @@ Uses `gnus-newsgroup-name' if category is nil (for ham registration)."
   (let ((kill-whole-line t))
     (kill-line)))
 
-;;; address can be a list, too
+;; address can be a list, too
 (defun spam-enter-whitelist (address &optional remove)
   "Enter ADDRESS (list or single) into the whitelist.
 With a non-nil REMOVE, remove them."
@@ -2249,7 +2238,7 @@ With a non-nil REMOVE, remove them."
   (setq spam-whitelist-cache nil)
   (spam-clear-cache 'spam-use-whitelist))
 
-;;; address can be a list, too
+;; address can be a list, too
 (defun spam-enter-blacklist (address &optional remove)
   "Enter ADDRESS (list or single) into the blacklist.
 With a non-nil REMOVE, remove them."
@@ -2310,8 +2299,8 @@ With a non-nil REMOVE, remove the ADDRESSES."
           (cl-return)))
       found)))
 
-;;; returns t if the sender is in the whitelist, nil or
-;;; spam-split-group otherwise
+;; returns t if the sender is in the whitelist, nil or
+;; spam-split-group otherwise
 (defun spam-check-whitelist ()
   ;; FIXME!  Should it detect when file timestamps change?
   (unless spam-whitelist-cache