lisp/*.el: Remove lexical-binding warnings; additional small cleanups.

* calculator.el (calculator): Mark unused argument.
  (calculator-paste, calculator-quit, calculator-integer-p):
  Use ignore-errors.
  (calculator-string-to-number, calculator-decimal, calculator-exp)
  (calculator-op-or-exp): Use string-match-p.

* dired-aux.el (dired-compress): Use ignore-errors.
  (dired-do-chxxx, dired-do-chmod, dired-trample-file-versions)
  (dired-do-async-shell-command, dired-do-shell-command)
  (dired-shell-stuff-it, dired-compress-file, dired-insert-subdir)
  (dired-insert-subdir-validate): Use string-match-p.
  (dired-map-dired-file-lines, dired-subdir-hidden-p): Use looking-at-p.
  (dired-add-entry): Use string-match-p, looking-at-p.
  (dired-insert-subdir-newpos): Remove unused local variable.

* dired.el (dired-buffer-more-recently-used-p): Declare.
  (dired-insert-set-properties, dired-insert-old-subdirs):
  Use ignore-errors.

* filenotify.el (file-notify-callback): Remove unused local variable.

* filesets.el (filesets-error): Mark unused argument.
  (filesets-which-command-p, filesets-filter-dir-names)
  (filesets-directory-files, filesets-get-external-viewer)
  (filesets-ingroup-get-data): Use string-match-p.

* find-file.el (ff-other-file-name, ff-other-file-name)
  (ff-find-the-other-file, ff-cc-hh-converter):
  Remove unused local variables.
  (ff-get-file-name): Use string-match-p.
  (ff-all-dirs-under): Use ignore-errors.

* follow.el (follow-comint-scroll-to-bottom): Mark unused argument.
  (follow-select-if-visible): Remove unused local variable.

* forms.el (read-file-filter): Move declaration.
  (forms--make-format, forms--make-parser, forms-insert-record):
  Quote function with #'.
  (forms--update): Use string-match-p.  Quote function with #'.

* help-mode.el (help-dir-local-var-def): Mark unused argument.
  (help-make-xrefs): Use looking-at-p.
  (help-xref-on-pp): Use looking-at-p, ignore-errors.

* ibuffer.el (ibuffer-ext-visible-p): Declare.
  (ibuffer-confirm-operation-on): Use string-match-p.

* msb.el (msb-item-handler, msb-dired-item-handler):
  Mark unused arguments.

* ses.el (ses-decode-cell-symbol)
  (ses-kill-override): Remove unused local variable.
  (ses-create-cell-variable, ses-relocate-formula): Use string-match-p.
  (ses-load): Use ignore-errors, looking-at-p.
  (ses-jump-safe): Use ignore-errors.
  (ses-export-tsv, ses-export-tsf, ses-unsafe): Mark unused arguments.

* tabify.el (untabify, tabify): Mark unused arguments.

  * thingatpt.el (thing-at-point--bounds-of-well-formed-url):
  Mark unused argument.
  (bounds-of-thing-at-point, thing-at-point-bounds-of-list-at-point)
  (thing-at-point-newsgroup-p, form-at-point): Use ignore-errors.

15 files changed, 283 insertions, 253 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 15ff4e131a0..4c55452e5b4 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,5 +1,69 @@
 2013-08-10  Juanma Barranquero  <lekktu@gmail.com>
 
+        * calculator.el (calculator): Mark unused argument.
+        (calculator-paste, calculator-quit, calculator-integer-p):
+        Use ignore-errors.
+        (calculator-string-to-number, calculator-decimal, calculator-exp)
+        (calculator-op-or-exp): Use string-match-p.
+
+        * dired.el (dired-buffer-more-recently-used-p): Declare.
+        (dired-insert-set-properties, dired-insert-old-subdirs):
+        Use ignore-errors.
+
+        * dired-aux.el (dired-compress): Use ignore-errors.
+        (dired-do-chxxx, dired-do-chmod, dired-trample-file-versions)
+        (dired-do-async-shell-command, dired-do-shell-command)
+        (dired-shell-stuff-it, dired-compress-file, dired-insert-subdir)
+        (dired-insert-subdir-validate): Use string-match-p.
+        (dired-map-dired-file-lines, dired-subdir-hidden-p): Use looking-at-p.
+        (dired-add-entry): Use string-match-p, looking-at-p.
+        (dired-insert-subdir-newpos): Remove unused local variable.
+
+        * filenotify.el (file-notify-callback): Remove unused local variable.
+
+        * filesets.el (filesets-error): Mark unused argument.
+        (filesets-which-command-p, filesets-filter-dir-names)
+        (filesets-directory-files, filesets-get-external-viewer)
+        (filesets-ingroup-get-data): Use string-match-p.
+
+        * find-file.el (ff-other-file-name, ff-other-file-name)
+        (ff-find-the-other-file, ff-cc-hh-converter):
+        Remove unused local variables.
+        (ff-get-file-name): Use string-match-p.
+        (ff-all-dirs-under): Use ignore-errors.
+
+        * follow.el (follow-comint-scroll-to-bottom): Mark unused argument.
+        (follow-select-if-visible): Remove unused local variable.
+
+        * forms.el (read-file-filter): Move declaration.
+        (forms--make-format, forms--make-parser, forms-insert-record):
+        Quote function with #'.
+        (forms--update): Use string-match-p.  Quote function with #'.
+
+        * help-mode.el (help-dir-local-var-def): Mark unused argument.
+        (help-make-xrefs): Use looking-at-p.
+        (help-xref-on-pp): Use looking-at-p, ignore-errors.
+
+        * ibuffer.el (ibuffer-ext-visible-p): Declare.
+        (ibuffer-confirm-operation-on): Use string-match-p.
+
+        * msb.el (msb-item-handler, msb-dired-item-handler):
+        Mark unused arguments.
+
+        * ses.el (ses-decode-cell-symbol)
+        (ses-kill-override): Remove unused local variable.
+        (ses-create-cell-variable, ses-relocate-formula): Use string-match-p.
+        (ses-load): Use ignore-errors, looking-at-p.
+        (ses-jump-safe): Use ignore-errors.
+        (ses-export-tsv, ses-export-tsf, ses-unsafe): Mark unused arguments.
+
+        * tabify.el (untabify, tabify): Mark unused arguments.
+
+        * thingatpt.el (thing-at-point--bounds-of-well-formed-url):
+        Mark unused argument.
+        (bounds-of-thing-at-point, thing-at-point-bounds-of-list-at-point)
+        (thing-at-point-newsgroup-p, form-at-point): Use ignore-errors.
+
         * emacs-lisp/timer.el (timer--time): Define setter with
         gv-define-setter to avoid deprecation warning.
 
diff --git a/lisp/calculator.el b/lisp/calculator.el
index 8b253b810f5..c9a73054712 100644
--- a/lisp/calculator.el
+++ b/lisp/calculator.el
@@ -708,7 +708,7 @@ See the documentation for `calculator-mode' for more information."
                ;; can't use 'noprompt, bug in electric.el
                (lambda () 'noprompt)
                nil
-               (lambda (x y) (calculator-update-display))))
+               (lambda (_x _y) (calculator-update-display))))
           (and calculator-buffer
                (catch 'calculator-done (calculator-quit)))
           (use-local-map old-l-map)
@@ -905,9 +905,9 @@ The string is set not to exceed the screen width."
       value)
     (car (read-from-string
           (cond ((equal "." str) "0.0")
-                ((string-match "[eE][+-]?$" str) (concat str "0"))
-                ((string-match "\\.[0-9]\\|[eE]" str) str)
-                ((string-match "\\." str)
+                ((string-match-p "[eE][+-]?$" str) (concat str "0"))
+                ((string-match-p "\\.[0-9]\\|[eE]" str) str)
+                ((string-match-p "\\." str)
                  ;; do this because Emacs reads "23." as an integer
                  (concat str "0"))
                 ((stringp str) (concat str ".0"))
@@ -1366,7 +1366,7 @@ OP is the operator (if any) that caused this call."
            (or calculator-display-fragile
                (not (numberp (car calculator-stack))))
            (not (and calculator-curnum
-                     (string-match "[.eE]" calculator-curnum))))
+                     (string-match-p "[.eE]" calculator-curnum))))
     ;; enter the period on the same condition as a digit, only if no
     ;; period or exponent entered yet
     (progn
@@ -1382,7 +1382,7 @@ OP is the operator (if any) that caused this call."
     (if (and (or calculator-display-fragile
                  (not (numberp (car calculator-stack))))
              (not (and calculator-curnum
-                       (string-match "[eE]" calculator-curnum))))
+                       (string-match-p "[eE]" calculator-curnum))))
       ;; same condition as above, also no E so far
       (progn
         (calculator-clear-fragile)
@@ -1452,7 +1452,7 @@ no need for negative numbers since these are handled by unary operators)."
   (interactive)
   (if (and (not calculator-display-fragile)
            calculator-curnum
-           (string-match "[eE]$" calculator-curnum))
+           (string-match-p "[eE]$" calculator-curnum))
     (calculator-digit)
     (calculator-op)))
 
@@ -1661,8 +1661,7 @@ Used by `calculator-paste' and `get-register'."
           (setq str (concat (or (match-string 1 str) "0")
                             (or (match-string 2 str) ".0")
                             (or (match-string 3 str) ""))))
-     (condition-case nil (calculator-string-to-number str)
-       (error nil)))))
+     (ignore-errors (calculator-string-to-number str)))))
 
 (defun calculator-get-register (reg)
   "Get a value from a register REG."
@@ -1728,13 +1727,11 @@ Used by `calculator-paste' and `get-register'."
   (interactive)
   (set-buffer calculator-buffer)
   (let ((inhibit-read-only t)) (erase-buffer))
-  (if (not calculator-electric-mode)
-    (progn
-      (condition-case nil
-          (while (get-buffer-window calculator-buffer)
-            (delete-window (get-buffer-window calculator-buffer)))
-        (error nil))
-      (kill-buffer calculator-buffer)))
+  (unless calculator-electric-mode
+    (ignore-errors
+      (while (get-buffer-window calculator-buffer)
+        (delete-window (get-buffer-window calculator-buffer))))
+    (kill-buffer calculator-buffer))
   (setq calculator-buffer nil)
   (message "Calculator done.")
   (if calculator-electric-mode (throw 'calculator-done nil)))
@@ -1768,14 +1765,11 @@ To use this, apply a binary operator (evaluate it), then call this."
 
 (defun calculator-integer-p (x)
   "Non-nil if X is equal to an integer."
-  (condition-case nil
-      (= x (ftruncate x))
-    (error nil)))
+  (ignore-errors (= x (ftruncate x))))
 
 (defun calculator-expt (x y)
   "Compute X^Y, dealing with errors appropriately."
-  (condition-case
-      nil
+  (condition-case nil
       (expt x y)
     (domain-error 0.0e+NaN)
     (range-error
diff --git a/lisp/dired-aux.el b/lisp/dired-aux.el
index c12ac068689..31d0495175a 100644
--- a/lisp/dired-aux.el
+++ b/lisp/dired-aux.el
@@ -286,7 +286,7 @@ List has a form of (file-name full-file-name (attribute-list))."
                                 (if (eq op-symbol 'touch)
                                     (list "-t" new-attribute)
                                   (list new-attribute)))
-                              (if (string-match "gnu" system-configuration)
+                              (if (string-match-p "gnu" system-configuration)
                                   '("--") nil))
                              files))
     (dired-do-redisplay arg);; moves point if ARG is an integer
@@ -327,7 +327,7 @@ into the minibuffer."
            ;; We used to treat empty input as DEFAULT, but that is not
            ;; such a good idea (Bug#9361).
            (error "No file mode specified"))
-          ((string-match "^[0-7]+" modes)
+          ((string-match-p "^[0-7]+" modes)
            (setq num-modes (string-to-number modes 8))))
 
     (dolist (file files)
@@ -500,7 +500,7 @@ with a prefix argument."
       (goto-char (point-min))
       (while (not (eobp))
         (save-excursion
-          (and (not (looking-at dired-re-dir))
+          (and (not (looking-at-p dired-re-dir))
                (not (eolp))
                (setq file (dired-get-filename nil t)) ; nil on non-file
                (progn (end-of-line)
@@ -530,7 +530,7 @@ with a prefix argument."
                         dired-file-version-alist)))))))
 
 (defun dired-trample-file-versions (fn)
-  (let* ((start-vn (string-match "\\.~[0-9]+~$" fn))
+  (let* ((start-vn (string-match-p "\\.~[0-9]+~$" fn))
          base-version-list)
     (and start-vn
          (setq base-version-list        ; there was a base version to which
@@ -602,7 +602,7 @@ The output appears in the buffer `*Async Shell Command*'."
       (dired-read-shell-command "& on %s: " current-prefix-arg files)
       current-prefix-arg
       files)))
-  (unless (string-match "&[ \t]*\\'" command)
+  (unless (string-match-p "&[ \t]*\\'" command)
     (setq command (concat command " &")))
   (dired-do-shell-command command arg file-list))
 
@@ -663,10 +663,10 @@ can be produced by `dired-get-marked-files', for example."
       (dired-read-shell-command "! on %s: " current-prefix-arg files)
       current-prefix-arg
       files)))
-  (let* ((on-each (not (string-match dired-star-subst-regexp command)))
-         (no-subst (not (string-match dired-quark-subst-regexp command)))
-         (star (string-match "\\*" command))
-         (qmark (string-match "\\?" command)))
+  (let* ((on-each (not (string-match-p dired-star-subst-regexp command)))
+         (no-subst (not (string-match-p dired-quark-subst-regexp command)))
+         (star (string-match-p "\\*" command))
+         (qmark (string-match-p "\\?" command)))
     ;; Get confirmation for wildcards that may have been meant
     ;; to control substitution of a file name or the file name list.
     (if (cond ((not (or on-each no-subst))
@@ -713,8 +713,8 @@ can be produced by `dired-get-marked-files', for example."
                       (substring command 0 (match-beginning 0))
                     command))
          (stuff-it
-          (if (or (string-match dired-star-subst-regexp command)
-                  (string-match dired-quark-subst-regexp command))
+          (if (or (string-match-p dired-star-subst-regexp command)
+                  (string-match-p dired-quark-subst-regexp command))
               (lambda (x)
                 (let ((retval command))
                   (while (string-match
@@ -840,9 +840,7 @@ command with a prefix argument (the value does not matter)."
     (if new-file
         (let ((start (point)))
           ;; Remove any preexisting entry for the name NEW-FILE.
-          (condition-case nil
-              (dired-remove-entry new-file)
-            (error nil))
+          (ignore-errors (dired-remove-entry new-file))
           (goto-char start)
           ;; Now replace the current line with an entry for NEW-FILE.
           (dired-update-file-line new-file) nil)
@@ -883,7 +881,7 @@ Otherwise, the rule is a compression rule, and compression is done with gzip.")
     ;; See if any suffix rule matches this file name.
     (while suffixes
       (let (case-fold-search)
-        (if (string-match (car (car suffixes)) file)
+        (if (string-match-p (car (car suffixes)) file)
             (setq suffix (car suffixes) suffixes nil))
         (setq suffixes (cdr suffixes))))
     ;; If so, compute desired new name.
@@ -1143,16 +1141,16 @@ files matching `dired-omit-regexp'."
           ;; Avoid calling ls for files that are going to be omitted anyway.
           (let ((omit-re (dired-omit-regexp)))
             (or (string= omit-re "")
-                (not (string-match omit-re
-                                   (cond
-                                    ((eq 'no-dir dired-omit-localp)
-                                     filename)
-                                    ((eq t dired-omit-localp)
-                                     (dired-make-relative filename))
-                                    (t
-                                     (dired-make-absolute
-                                      filename
-                                      (file-name-directory filename)))))))))
+                (not (string-match-p omit-re
+                                     (cond
+                                      ((eq 'no-dir dired-omit-localp)
+                                       filename)
+                                      ((eq t dired-omit-localp)
+                                       (dired-make-relative filename))
+                                      (t
+                                       (dired-make-absolute
+                                        filename
+                                        (file-name-directory filename)))))))))
       ;; Do it!
       (progn
         (setq filename (directory-file-name filename))
@@ -1180,7 +1178,7 @@ files matching `dired-omit-regexp'."
                     ;; else try to find correct place to insert
                     (if (dired-goto-subdir directory)
                         (progn ;; unhide if necessary
-                          (if (looking-at "\r")
+                          (if (looking-at-p "\r")
                               ;; Point is at end of subdir line.
                               (dired-unhide-subdir))
                           ;; found - skip subdir and `total' line
@@ -2090,7 +2088,7 @@ This function takes some pains to conform to `ls -lR' output."
     (and (not switches) cons (setq switches (cdr cons)))
     (dired-insert-subdir-validate dirname switches)
     ;; case-fold-search is nil now, so we can test for capital `R':
-    (if (setq switches-have-R (and switches (string-match "R" switches)))
+    (if (setq switches-have-R (and switches (string-match-p "R" switches)))
         ;; avoid duplicated subdirs
         (setq mark-alist (dired-kill-tree dirname t)))
     (if elt
@@ -2128,8 +2126,8 @@ This function takes some pains to conform to `ls -lR' output."
         (mapcar
          (function
           (lambda (x)
-            (or (eq (null (string-match x real-switches))
-                    (null (string-match x dired-actual-switches)))
+            (or (eq (null (string-match-p x real-switches))
+                    (null (string-match-p x dired-actual-switches)))
                 (error
                  "Can't have dirs with and without -%s switches together" x))))
          ;; all switches that make a difference to dired-get-filename:
@@ -2170,7 +2168,7 @@ of marked files.  If KILL-ROOT is non-nil, kill DIRNAME as well."
 (defun dired-insert-subdir-newpos (new-dir)
   ;; Find pos for new subdir, according to tree order.
   ;;(goto-char (point-max))
-  (let ((alist dired-subdir-alist) elt dir pos new-pos)
+  (let ((alist dired-subdir-alist) elt dir new-pos)
     (while alist
       (setq elt (car alist)
             alist (cdr alist)
@@ -2421,7 +2419,7 @@ Lower levels are unaffected."
   (and selective-display
        (save-excursion
          (dired-goto-subdir dir)
-         (looking-at "\r"))))
+         (looking-at-p "\r"))))
 
 ;;;###autoload
 (defun dired-hide-subdir (arg)
diff --git a/lisp/dired.el b/lisp/dired.el
index 48f1b463f4a..f830623a255 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -34,6 +34,9 @@
 
 ;;; Code:
 
+(declare-function dired-buffer-more-recently-used-p
+                  "dired-x" (buffer1 buffer2))
+
 ;;; Customizable variables
 
 (defgroup dired nil
@@ -1242,26 +1245,25 @@ see `dired-use-ls-dired' for more details.")
   (save-excursion
     (goto-char beg)
     (while (< (point) end)
-      (condition-case nil
-          (if (not (dired-move-to-filename))
-              (put-text-property (line-beginning-position)
-                                 (1+ (line-end-position))
-                                 'invisible 'dired-hide-details-information)
-            (put-text-property (+ (line-beginning-position) 1) (1- (point))
-                               'invisible 'dired-hide-details-detail)
-            (add-text-properties
-             (point)
-             (progn
-               (dired-move-to-end-of-filename)
-               (point))
-             '(mouse-face
-               highlight
-               dired-filename t
-               help-echo "mouse-2: visit this file in other window"))
-            (when (< (+ (point) 4) (line-end-position))
-              (put-text-property (+ (point) 4) (line-end-position)
-                                 'invisible 'dired-hide-details-link)))
-        (error nil))
+      (ignore-errors
+        (if (not (dired-move-to-filename))
+            (put-text-property (line-beginning-position)
+                               (1+ (line-end-position))
+                               'invisible 'dired-hide-details-information)
+          (put-text-property (+ (line-beginning-position) 1) (1- (point))
+                             'invisible 'dired-hide-details-detail)
+          (add-text-properties
+           (point)
+           (progn
+             (dired-move-to-end-of-filename)
+             (point))
+           '(mouse-face
+             highlight
+             dired-filename t
+             help-echo "mouse-2: visit this file in other window"))
+          (when (< (+ (point) 4) (line-end-position))
+            (put-text-property (+ (point) 4) (line-end-position)
+                               'invisible 'dired-hide-details-link))))
       (forward-line 1))))
 
 ;; Reverting a dired buffer
@@ -1401,11 +1403,9 @@ Do so according to the former subdir alist OLD-SUBDIR-ALIST."
           (setq elt (car old-subdir-alist)
                 old-subdir-alist (cdr old-subdir-alist)
                 dir (car elt))
-          (condition-case ()
-              (progn
-                (dired-uncache dir)
-                (dired-insert-subdir dir))
-            (error nil))))))
+          (ignore-errors
+            (dired-uncache dir)
+            (dired-insert-subdir dir))))))
 
 (defun dired-uncache (dir)
   "Remove directory DIR from any directory cache."
@@ -3849,7 +3849,7 @@ Ask means pop up a menu for the user to select one of copy, move or link."
 
 ;;; Start of automatically extracted autoloads.
 
-;;;### (autoloads nil "dired-aux" "dired-aux.el" "555c067fcab27f5a377536db407803ab")
+;;;### (autoloads nil "dired-aux" "dired-aux.el" "04b4cb6bde3220f55574eb1d99ac0d29")
 ;;; Generated autoloads from dired-aux.el
 
 (autoload 'dired-diff "dired-aux" "\
diff --git a/lisp/filenotify.el b/lisp/filenotify.el
index d2f37b99107..5a5435bb4cb 100644
--- a/lisp/filenotify.el
+++ b/lisp/filenotify.el
@@ -92,7 +92,7 @@ car of that event, which is the symbol `file-notify'."
          (pending-event (assoc desc file-notify--pending-events))
          (actions (nth 1 event))
          (file (file-notify--event-file-name event))
-         file1 cookie callback)
+         file1 callback)
 
     ;; Make actions a list.
     (unless (consp actions) (setq actions (cons actions nil)))
diff --git a/lisp/filesets.el b/lisp/filesets.el
index fbf28dbecbc..82891770f12 100644
--- a/lisp/filesets.el
+++ b/lisp/filesets.el
@@ -214,8 +214,8 @@ key is supported."
 
 (defun filesets-which-command-p (cmd)
   "Call \"which CMD\" and return non-nil if the command was found."
-  (when (string-match (format "\\(/[^/]+\\)?/%s" cmd)
-                      (filesets-which-command cmd))
+  (when (string-match-p (format "\\(/[^/]+\\)?/%s" cmd)
+                        (filesets-which-command cmd))
     cmd))
 
 (defun filesets-message (level &rest args)
@@ -1082,7 +1082,7 @@ defined in `filesets-ingroup-patterns'."
 
     (require 'easymenu)
 
-    (defun filesets-error (class &rest args)
+    (defun filesets-error (_class &rest args)
       "`error' wrapper."
       (error "%s" (mapconcat 'identity args " ")))
 
@@ -1093,10 +1093,10 @@ defined in `filesets-ingroup-patterns'."
 If NEGATIVE is non-nil, remove all directory names."
   (filesets-filter-list lst
                         (lambda (x)
-                          (and (not (string-match "^\\.+/$" x))
+                          (and (not (string-match-p "^\\.+/$" x))
                                (if negative
-                                   (not (string-match "[:/\\]$" x))
-                                 (string-match "[:/\\]$" x))))))
+                                   (not (string-match-p "[:/\\]$" x))
+                                 (string-match-p "[:/\\]$" x))))))
 
 (defun filesets-conditional-sort (lst &optional access-fn)
   "Return a sorted copy of LST, LST being a list of strings.
@@ -1130,18 +1130,18 @@ Return full path if FULL-FLAG is non-nil."
           (dirs  nil))
       (dolist (this (file-name-all-completions "" dir))
         (cond
-         ((string-match "^\\.+/$" this)
+         ((string-match-p "^\\.+/$" this)
           nil)
-         ((string-match "[:/\\]$" this)
+         ((string-match-p "[:/\\]$" this)
           (when (or (not match-dirs-flag)
                     (not pattern)
-                    (string-match pattern this))
+                    (string-match-p pattern this))
             (filesets-message 5 "Filesets: matched dir %S with pattern %S"
                               this pattern)
             (setq dirs (cons this dirs))))
          (t
           (when (or (not pattern)
-                    (string-match pattern this))
+                    (string-match-p pattern this))
             (filesets-message 5 "Filesets: matched file %S with pattern %S"
                               this pattern)
             (setq files (cons (if full-flag
@@ -1249,7 +1249,7 @@ Return full path if FULL-FLAG is non-nil."
   (let ((filename (file-name-nondirectory file)))
     (filesets-some
      (lambda (entry)
-       (when (and (string-match (nth 0 entry) filename)
+       (when (and (string-match-p (nth 0 entry) filename)
                   (filesets-eviewer-constraint-p entry))
          entry))
      filesets-external-viewers)))
@@ -2004,7 +2004,7 @@ LOOKUP-NAME is used as lookup name for retrieving fileset specific settings."
         (fn (or fun (lambda (a b)
                       (and (stringp a)
                            (stringp b)
-                           (string-match a b))))))
+                           (string-match-p a b))))))
     (filesets-some (lambda (x)
                      (if (funcall fn (car x) masterfile)
                          (nth pos x)
diff --git a/lisp/find-file.el b/lisp/find-file.el
index 9f7d877ec3b..d9a9f08f19b 100644
--- a/lisp/find-file.el
+++ b/lisp/find-file.el
@@ -528,11 +528,9 @@ the `ff-ignore-include' variable."
         stub            ;; name of the file without extension
         alist           ;; working copy of the list of file extensions
         pathname        ;; the pathname of the file or the #include line
-        default-name    ;; file we should create if none found
         format          ;; what we have to match
         found           ;; name of the file or buffer found - nil if none
-        dirs            ;; local value of ff-search-directories
-        no-match)       ;; whether we know about this kind of file
+        dirs)           ;; local value of ff-search-directories
 
     (message "Working...")
 
@@ -545,7 +543,6 @@ the `ff-ignore-include' variable."
 
     (cond
      ((and (not ff-ignore-include) fname)
-      (setq default-name fname)
       (setq found (ff-get-file-name dirs fname nil)))
 
      ;; let's just get the corresponding file
@@ -558,7 +555,6 @@ the `ff-ignore-include' variable."
                        "/none.none"))
 
       (setq fname (file-name-nondirectory pathname)
-            no-match nil
             match (car alist))
 
       ;; find the table entry corresponding to this file
@@ -569,8 +565,7 @@ the `ff-ignore-include' variable."
         (setq pos (ff-string-match (car match) fname)))
 
       ;; no point going on if we haven't found anything
-      (if (not match)
-          (setq no-match t)
+      (when match
 
         ;; otherwise, suffixes contains what we need
         (setq suffixes (car (cdr match))
@@ -583,8 +578,7 @@ the `ff-ignore-include' variable."
             (progn
               (setq suffixes (funcall action (buffer-file-name))
                     match (cons (car match) (list suffixes))
-                    stub nil
-                    default-name (car suffixes)))
+                    stub nil))
 
           ;; otherwise build our filename stub
           (cond
@@ -599,11 +593,7 @@ the `ff-ignore-include' variable."
             (setq format (concat "\\(.+\\)" (car match)))
             (string-match format fname)
             (setq stub (substring fname (match-beginning 1) (match-end 1)))
-            ))
-
-          ;; if we find nothing, we should try to get a file like this one
-          (setq default-name
-                (concat stub (car (car (cdr match))))))
+            )))
 
         ;; do the real work - find the file
         (setq found
@@ -671,7 +661,7 @@ name of the first file found."
       (setq buf (buffer-name (car blist)))
       (while (and blist (not found))
 
-        (if (string-match (concat filename "<[0-9]+>") buf)
+        (if (string-match-p (concat filename "<[0-9]+>") buf)
             (setq found (buffer-file-name (car blist))))
 
         (setq blist (cdr blist))
@@ -797,20 +787,18 @@ See variable `ff-special-constructs'."
   "Get all the directory files under directory HERE.
 Exclude all files in the optional EXCLUDE list."
   (if (file-directory-p here)
-      (condition-case nil
-          (progn
-            (let ((files (directory-files here t))
-                  (dirlist (list))
-                  file)
-              (while files
-                (setq file (car files))
-                (if (and
-                     (file-directory-p file)
-                     (not (member (ff-basename file) exclude)))
-                    (setq dirlist (cons file dirlist)))
-                (setq files (cdr files)))
-              (setq dirlist (reverse dirlist))))
-        (error nil))
+      (ignore-errors
+        (let ((files (directory-files here t))
+              (dirlist (list))
+              file)
+          (while files
+            (setq file (car files))
+            (if (and
+                 (file-directory-p file)
+                 (not (member (ff-basename file) exclude)))
+                (setq dirlist (cons file dirlist)))
+            (setq files (cdr files)))
+          (setq dirlist (reverse dirlist))))
     nil))
 
 (defun ff-switch-file (f1 f2 file &optional in-other-window new-file)
@@ -892,9 +880,7 @@ Given START and/or END, checks between these characters."
 Build up a new file list based possibly on part of the directory name
 and the name of the file passed in."
   (ff-string-match "\\(.*\\)/\\([^/]+\\)/\\([^.]+\\).\\([^/]+\\)$" arg)
-  (let ((path (if (match-beginning 1)
-                  (substring arg (match-beginning 1) (match-end 1)) nil))
-        (dire (if (match-beginning 2)
+  (let ((dire (if (match-beginning 2)
                   (substring arg (match-beginning 2) (match-end 2)) nil))
         (file (if (match-beginning 3)
                   (substring arg (match-beginning 3) (match-end 3)) nil))
diff --git a/lisp/follow.el b/lisp/follow.el
index 53b32e57031..3fcdf24f4f2 100644
--- a/lisp/follow.el
+++ b/lisp/follow.el
@@ -515,7 +515,7 @@ Works like `scroll-up' when not in Follow mode."
 (declare-function comint-adjust-point "comint" (window))
 (defvar comint-scroll-show-maximum-output)
 
-(defun follow-comint-scroll-to-bottom (&optional window)
+(defun follow-comint-scroll-to-bottom (&optional _window)
   "Scroll the bottom-most window in the current Follow chain.
 This is to be called by `comint-postoutput-scroll-to-bottom'."
   (let* ((buffer (current-buffer))
@@ -883,15 +883,14 @@ returned by `follow-windows-start-end'."
 (defun follow-select-if-visible (dest win-start-end)
   "Select and return a window, if DEST is visible in it.
 Return the selected window."
-  (let (win win-end wse)
+  (let (win wse)
     (while (and (not win) win-start-end)
       ;; Don't select a window that was just moved. This makes it
       ;; possible to later select the last window after a
       ;; `end-of-buffer' command.
       (setq wse (car win-start-end))
       (when (follow-pos-visible dest (car wse) win-start-end)
-        (setq win (car wse)
-              win-end (nth 2 wse))
+        (setq win (car wse))
         (select-window win))
       (setq win-start-end (cdr win-start-end)))
     win))
diff --git a/lisp/forms.el b/lisp/forms.el
index 37914bf5465..38fc0b320dd 100644
--- a/lisp/forms.el
+++ b/lisp/forms.el
@@ -439,6 +439,8 @@ Also, initial position is at last record."
 (defvar forms--rw-face nil
   "Face used to represent read-write data on the screen.")
 
+(defvar read-file-filter) ; bound in forms--intuit-from-file
+
 ;;;###autoload
 (defun forms-mode (&optional primary)
   "Major mode to visit files in a field-structured manner using a form.
@@ -913,7 +915,7 @@ Commands:                        Equivalent keys in read-only mode:
          `(lambda (arg)
             (let ((inhibit-read-only t))
               ,@(apply 'append
-                       (mapcar 'forms--make-format-elt-using-text-properties
+                       (mapcar #'forms--make-format-elt-using-text-properties
                                forms-format-list))
               ;; Prevent insertion before the first text.
               ,@(if (numberp (car forms-format-list))
@@ -926,7 +928,7 @@ Commands:                        Equivalent keys in read-only mode:
             (setq forms--iif-start nil))
        `(lambda (arg)
           ,@(apply 'append
-                   (mapcar 'forms--make-format-elt forms-format-list)))))
+                   (mapcar #'forms--make-format-elt forms-format-list)))))
 
     ;; We have tallied the number of markers and dynamic texts,
     ;; so we can allocate the arrays now.
@@ -1098,7 +1100,7 @@ Commands:                        Equivalent keys in read-only mode:
             (goto-char (point-min))
             ,@(apply 'append
                      (mapcar
-                      'forms--make-parser-elt
+                      #'forms--make-parser-elt
                       (append forms-format-list (list nil)))))))))
 
   (forms--debug 'forms--parser))
@@ -1198,8 +1200,6 @@ Commands:                        Equivalent keys in read-only mode:
       (setq forms--field nil)))
    ))
 
-(defvar read-file-filter) ; bound in forms--intuit-from-file
-
 (defun forms--intuit-from-file ()
   "Get number of fields and a default form using the data file."
 
@@ -1569,10 +1569,10 @@ As a side effect: sets `forms--the-record-list'."
     ;; Build new record.
     (setq forms--the-record-list (forms--parse-form))
     (setq the-record
-          (mapconcat 'identity forms--the-record-list forms-field-sep))
+          (mapconcat #'identity forms--the-record-list forms-field-sep))
 
-    (if (string-match (regexp-quote forms-field-sep)
-                      (mapconcat 'identity forms--the-record-list ""))
+    (if (string-match-p (regexp-quote forms-field-sep)
+                        (mapconcat #'identity forms--the-record-list ""))
         (error "Field separator occurs in record - update refused"))
 
     ;; Handle multi-line fields, if allowed.
@@ -1580,7 +1580,7 @@ As a side effect: sets `forms--the-record-list'."
         (forms--trans the-record "\n" forms-multi-line))
 
     ;; A final sanity check before updating.
-    (if (string-match "\n" the-record)
+    (if (string-match-p "\n" the-record)
         (error "Multi-line fields in this record - update refused"))
 
     (with-current-buffer forms--file-buffer
@@ -1779,11 +1779,7 @@ after the current record."
           (setq the-list (cdr (append the-fields nil))))
       (setq the-list (make-list forms-number-of-fields "")))
 
-    (setq the-record
-          (mapconcat
-          'identity
-          the-list
-          forms-field-sep))
+    (setq the-record (mapconcat #'identity the-list forms-field-sep))
 
     (with-current-buffer forms--file-buffer
       (forms--goto-record ln)
diff --git a/lisp/help-mode.el b/lisp/help-mode.el
index b56adc2a4a9..5553556e03c 100644
--- a/lisp/help-mode.el
+++ b/lisp/help-mode.el
@@ -268,7 +268,7 @@ The format is (FUNCTION ARGS...).")
 
 (define-button-type 'help-dir-local-var-def
   :supertype 'help-xref
-  'help-function (lambda (var &optional file)
+  'help-function (lambda (_var &optional file)
                    ;; FIXME: this should go to the point where the
                    ;; local variable was defined.
                    (find-file file))
@@ -541,7 +541,7 @@ that."
                       (while
                           (and (not (eobp))
                                ;; Stop at a pair of blank lines.
-                               (not (looking-at "\n\\s-*\n")))
+                               (not (looking-at-p "\n\\s-*\n")))
                         ;; Skip a single blank line.
                         (and (eolp) (forward-line))
                         (end-of-line)
@@ -605,26 +605,25 @@ See `help-make-xrefs'."
         (save-restriction
           (narrow-to-region from to)
           (goto-char (point-min))
-          (condition-case nil
-              (while (not (eobp))
-                (cond
-                 ((looking-at "\"") (forward-sexp 1))
-                 ((looking-at "#<") (search-forward ">" nil 'move))
-                 ((looking-at "\\(\\(\\sw\\|\\s_\\)+\\)")
-                  (let* ((sym (intern-soft (match-string 1)))
-                         (type (cond ((fboundp sym) 'help-function)
-                                     ((or (memq sym '(t nil))
-                                          (keywordp sym))
-                                      nil)
-                                     ((and sym
-                                           (or (boundp sym)
-                                               (get sym
-                                                    'variable-documentation)))
-                                      'help-variable))))
-                    (when type (help-xref-button 1 type sym)))
-                  (goto-char (match-end 1)))
-                 (t (forward-char 1))))
-            (error nil)))))))
+          (ignore-errors
+            (while (not (eobp))
+              (cond
+               ((looking-at-p "\"") (forward-sexp 1))
+               ((looking-at-p "#<") (search-forward ">" nil 'move))
+               ((looking-at "\\(\\(\\sw\\|\\s_\\)+\\)")
+                (let* ((sym (intern-soft (match-string 1)))
+                       (type (cond ((fboundp sym) 'help-function)
+                                   ((or (memq sym '(t nil))
+                                        (keywordp sym))
+                                    nil)
+                                   ((and sym
+                                         (or (boundp sym)
+                                             (get sym
+                                                  'variable-documentation)))
+                                    'help-variable))))
+                  (when type (help-xref-button 1 type sym)))
+                (goto-char (match-end 1)))
+               (t (forward-char 1))))))))))
 
 
 ;; Additional functions for (re-)creating types of help buffers.
diff --git a/lisp/ibuffer.el b/lisp/ibuffer.el
index 09d7c143346..ce29505d6f2 100644
--- a/lisp/ibuffer.el
+++ b/lisp/ibuffer.el
@@ -53,6 +53,8 @@
 (defvar ibuffer-tmp-hide-regexps)
 (defvar ibuffer-tmp-show-regexps)
 
+(declare-function ibuffer-ext-visible-p "ibuf-ext"
+                  (buf all &optional ibuffer-buf))
 (declare-function ibuffer-mark-on-buffer "ibuf-ext"
                   (func &optional ibuffer-mark-on-buffer-mark group))
 (declare-function ibuffer-generate-filter-groups "ibuf-ext"
@@ -1198,7 +1200,7 @@ a new window in the current frame, splitting vertically."
                              (and (stringp (cadr err))
                                   ;; This definitely falls in the
                                   ;; ghetto hack category...
-                                  (not (string-match "too small" (cadr err)))))
+                                  (not (string-match-p "too small" (cadr err)))))
                          (signal (car err) (cdr err))
                        (enlarge-window 3))))))
               (select-window (next-window))
diff --git a/lisp/msb.el b/lisp/msb.el
index 4bde993ff84..110a4277376 100644
--- a/lisp/msb.el
+++ b/lisp/msb.el
@@ -386,7 +386,7 @@ This is instead of the groups in `msb-menu-cond'."
 ;;;
 ;;; Some example function to be used for `msb-item-handling-function'.
 ;;;
-(defun msb-item-handler (buffer &optional maxbuf)
+(defun msb-item-handler (_buffer &optional _maxbuf)
   "Create one string item, concerning BUFFER, for the buffer menu.
 The item looks like:
 *% <buffer-name>
@@ -410,7 +410,7 @@ Optional second argument MAXBUF is completely ignored."
          (error "Unknown type of `dired-directory' in buffer %s"
                 (buffer-name)))))
 
-(defun msb-dired-item-handler (buffer &optional maxbuf)
+(defun msb-dired-item-handler (_buffer &optional _maxbuf)
   "Create one string item, concerning a dired BUFFER, for the buffer menu.
 The item looks like:
 *% <buffer-name>
diff --git a/lisp/ses.el b/lisp/ses.el
index bf88364456f..5f48dd2f27e 100644
--- a/lisp/ses.el
+++ b/lisp/ses.el
@@ -703,7 +703,6 @@ for this spreadsheet."
     (and (string-match "\\`\\([A-Z]+\\)\\([0-9]+\\)\\'" str)
          (let* ((col-str (match-string-no-properties 1 str))
                (col 0)
-               (col-offset 0)
                (col-base 1)
                (col-idx (1- (length col-str)))
                (row (1- (string-to-number (match-string-no-properties 2 str)))))
@@ -740,7 +739,7 @@ row and column of the cell, with numbering starting from 0.
 Return nil in case of failure."
   (unless (local-variable-p sym)
     (make-local-variable  sym)
-    (if (let (case-fold-search) (string-match "\\`[A-Z]+[0-9]+\\'" (symbol-name sym)))
+    (if (let (case-fold-search) (string-match-p "\\`[A-Z]+[0-9]+\\'" (symbol-name sym)))
         (put sym 'ses-cell (cons row col))
       (put sym 'ses-cell :ses-named)
       (setq ses--named-cell-hashmap (or ses--named-cell-hashmap (make-hash-table :test 'eq)))
@@ -1474,7 +1473,7 @@ Sets `ses-relocate-return' to 'delete if cell-references were removed."
   (let (rowcol result)
     (if (or (atom formula) (eq (car formula) 'quote))
         (if (and (setq rowcol (ses-sym-rowcol formula))
-                 (string-match "\\`[A-Z]+[0-9]+\\'" (symbol-name formula)))
+                 (string-match-p "\\`[A-Z]+[0-9]+\\'" (symbol-name formula)))
             (ses-relocate-symbol formula rowcol
                                  startrow startcol rowincr colincr)
           formula) ; Pass through as-is.
@@ -1735,7 +1734,7 @@ Does not execute cell formulas or print functions."
   (search-backward ";; Local Variables:\n" nil t)
   (backward-list 1)
   (setq ses--params-marker (point-marker))
-  (let ((params (condition-case nil (read (current-buffer)) (error nil))))
+  (let ((params (ignore-errors (read (current-buffer)))))
     (or (and (= (safe-length params) 3)
              (numberp (car params))
              (numberp (cadr params))
@@ -1761,7 +1760,7 @@ Does not execute cell formulas or print functions."
   ;; Skip over print area, which we assume is correct.
   (goto-char (point-min))
   (forward-line ses--numrows)
-  (or (looking-at ses-print-data-boundary)
+  (or (looking-at-p ses-print-data-boundary)
       (error "Missing marker between print and data areas"))
   (forward-char 1)
   (setq ses--data-marker (point-marker))
@@ -1774,12 +1773,12 @@ Does not execute cell formulas or print functions."
     (dotimes (col ses--numcols)
       (let* ((x      (read (current-buffer)))
              (sym  (car-safe (cdr-safe x))))
-        (or (and (looking-at "\n")
+        (or (and (looking-at-p "\n")
                  (eq (car-safe x) 'ses-cell)
                  (ses-create-cell-variable sym row col))
             (error "Cell-def error"))
         (eval x)))
-    (or (looking-at "\n\n")
+    (or (looking-at-p "\n\n")
         (error "Missing blank line between rows")))
   ;; Load global parameters.
   (let ((widths      (read (current-buffer)))
@@ -1805,8 +1804,8 @@ Does not execute cell formulas or print functions."
     (1value (eval head-row)))
   ;; Should be back at global-params.
   (forward-char 1)
-  (or (looking-at (replace-regexp-in-string "1" "[0-9]+"
-                                            ses-initial-global-parameters))
+  (or (looking-at-p (replace-regexp-in-string "1" "[0-9]+"
+                                              ses-initial-global-parameters))
       (error "Problem with column-defs or global-params"))
   ;; Check for overall newline count in definitions area.
   (forward-line 3)
@@ -2077,9 +2076,8 @@ Based on the current set of columns and `window-hscroll' position."
 
 (defun ses-jump-safe (cell)
   "Like `ses-jump', but no error if invalid cell."
-  (condition-case nil
-      (ses-jump cell)
-    (error)))
+  (ignore-errors
+    (ses-jump cell)))
 
 (defun ses-reprint-all (&optional nonarrow)
   "Recreate the display area.  Calls all printer functions.  Narrows to
@@ -2789,7 +2787,7 @@ We clear the killed cells instead of deleting them."
   ;; For some reason, the text-read-only error is not caught by `delete-region',
   ;; so we have to use subterfuge.
   (let ((buffer-read-only t))
-    (1value (condition-case x
+    (1value (condition-case nil
                 (noreturn (funcall (lookup-key (current-global-map)
                                                (this-command-keys))
                                    beg end))
@@ -3014,13 +3012,13 @@ spot, or error signal if user requests cancel."
                              (ses-col-printer (1- ses--numcols)))))
     rowcol))
 
-(defun ses-export-tsv (beg end)
+(defun ses-export-tsv (_beg _end)
   "Export values from the current range, with tabs between columns and
 newlines between rows.  Result is placed in kill ring."
   (interactive "r")
   (ses-export-tab nil))
 
-(defun ses-export-tsf (beg end)
+(defun ses-export-tsf (_beg _end)
   "Export formulas from the current range, with tabs between columns and
 newlines between rows.  Result is placed in kill ring."
   (interactive "r")
@@ -3298,7 +3296,7 @@ highlighted range in the spreadsheet."
       (let* ((x (ses-sym-rowcol ref))
              (xcell (ses-get-cell (car x) (cdr x))))
         (ses-cell-references-aset xcell
-                                  (cons new-name (delq sym 
+                                  (cons new-name (delq sym
                                                        (ses-cell-references xcell))))))
     (push new-name ses--renamed-cell-symb-list)
     (set new-name (symbol-value sym))
@@ -3579,7 +3577,7 @@ current column and continues until the next nonblank column."
 current column and continues until the next nonblank column."
   (ses-center-span value ?~))
 
-(defun ses-unsafe (value)
+(defun ses-unsafe (_value)
   "Substitute for an unsafe formula or printer."
   (error "Unsafe formula or printer"))
 
diff --git a/lisp/tabify.el b/lisp/tabify.el
index a90bf801bcf..44a233717dd 100644
--- a/lisp/tabify.el
+++ b/lisp/tabify.el
@@ -28,7 +28,7 @@
 ;;; Code:
 
 ;;;###autoload
-(defun untabify (start end &optional arg)
+(defun untabify (start end &optional _arg)
   "Convert all tabs in region to multiple spaces, preserving columns.
 If called interactively with prefix ARG, convert for the entire
 buffer.
@@ -61,7 +61,7 @@ Usually this will be \" [ \\t]+\" to match a space followed by whitespace.
 \"^\\t* [ \\t]+\" is also useful, for tabifying only initial whitespace.")
 
 ;;;###autoload
-(defun tabify (start end &optional arg)
+(defun tabify (start end &optional _arg)
   "Convert multiple spaces in region to tabs when possible.
 A group of spaces is partially replaced by tabs
 when this can be done without changing the column they end at.
diff --git a/lisp/thingatpt.el b/lisp/thingatpt.el
index b7ecdb513f5..b67a32a24f7 100644
--- a/lisp/thingatpt.el
+++ b/lisp/thingatpt.el
@@ -84,48 +84,47 @@ positions of the thing found."
   (if (get thing 'bounds-of-thing-at-point)
       (funcall (get thing 'bounds-of-thing-at-point))
     (let ((orig (point)))
-      (condition-case nil
-          (save-excursion
-            ;; Try moving forward, then back.
-            (funcall ;; First move to end.
-             (or (get thing 'end-op)
-                 (lambda () (forward-thing thing 1))))
-            (funcall ;; Then move to beg.
-             (or (get thing 'beginning-op)
-                 (lambda () (forward-thing thing -1))))
-            (let ((beg (point)))
-              (if (<= beg orig)
-                  ;; If that brings us all the way back to ORIG,
-                  ;; it worked.  But END may not be the real end.
-                  ;; So find the real end that corresponds to BEG.
-                  ;; FIXME: in which cases can `real-end' differ from `end'?
-                  (let ((real-end
-                         (progn
-                           (funcall
-                            (or (get thing 'end-op)
-                                (lambda () (forward-thing thing 1))))
-                           (point))))
-                    (when (and (<= orig real-end) (< beg real-end))
-                      (cons beg real-end)))
-                (goto-char orig)
-                ;; Try a second time, moving backward first and then forward,
-                ;; so that we can find a thing that ends at ORIG.
-                (funcall ;; First, move to beg.
-                 (or (get thing 'beginning-op)
-                     (lambda () (forward-thing thing -1))))
-                (funcall ;; Then move to end.
-                 (or (get thing 'end-op)
-                     (lambda () (forward-thing thing 1))))
-                (let ((end (point))
-                      (real-beg
+      (ignore-errors
+        (save-excursion
+          ;; Try moving forward, then back.
+          (funcall ;; First move to end.
+           (or (get thing 'end-op)
+               (lambda () (forward-thing thing 1))))
+          (funcall ;; Then move to beg.
+           (or (get thing 'beginning-op)
+               (lambda () (forward-thing thing -1))))
+          (let ((beg (point)))
+            (if (<= beg orig)
+                ;; If that brings us all the way back to ORIG,
+                ;; it worked.  But END may not be the real end.
+                ;; So find the real end that corresponds to BEG.
+                ;; FIXME: in which cases can `real-end' differ from `end'?
+                (let ((real-end
                        (progn
                          (funcall
-                          (or (get thing 'beginning-op)
-                              (lambda () (forward-thing thing -1))))
+                          (or (get thing 'end-op)
+                              (lambda () (forward-thing thing 1))))
                          (point))))
-                  (if (and (<= real-beg orig) (<= orig end) (< real-beg end))
-                      (cons real-beg end))))))
-        (error nil)))))
+                  (when (and (<= orig real-end) (< beg real-end))
+                    (cons beg real-end)))
+              (goto-char orig)
+              ;; Try a second time, moving backward first and then forward,
+              ;; so that we can find a thing that ends at ORIG.
+              (funcall ;; First, move to beg.
+               (or (get thing 'beginning-op)
+                   (lambda () (forward-thing thing -1))))
+              (funcall ;; Then move to end.
+               (or (get thing 'end-op)
+                   (lambda () (forward-thing thing 1))))
+              (let ((end (point))
+                    (real-beg
+                     (progn
+                       (funcall
+                        (or (get thing 'beginning-op)
+                            (lambda () (forward-thing thing -1))))
+                       (point))))
+                (if (and (<= real-beg orig) (<= orig end) (< real-beg end))
+                    (cons real-beg end))))))))))
 
 ;;;###autoload
 (defun thing-at-point (thing &optional no-properties)
@@ -217,21 +216,19 @@ The bounds of THING are determined by `bounds-of-thing-at-point'."
 \[Internal function used by `bounds-of-thing-at-point'.]"
   (save-excursion
     (let ((opoint (point))
-          (beg (condition-case nil
-                   (progn (up-list -1)
-                          (point))
-                 (error nil))))
-      (condition-case nil
-          (if beg
-              (progn (forward-sexp)
-                     (cons beg (point)))
-            ;; Are we are at the beginning of a top-level sexp?
-            (forward-sexp)
-            (let ((end (point)))
-              (backward-sexp)
-              (if (>= opoint (point))
-                  (cons opoint end))))
-        (error nil)))))
+          (beg (ignore-errors
+                 (up-list -1)
+                 (point))))
+      (ignore-errors
+        (if beg
+            (progn (forward-sexp)
+                   (cons beg (point)))
+          ;; Are we are at the beginning of a top-level sexp?
+          (forward-sexp)
+          (let ((end (point)))
+            (backward-sexp)
+            (if (>= opoint (point))
+                (cons opoint end))))))))
 
 ;; Defuns
 
@@ -358,7 +355,7 @@ the bounds of a possible ill-formed URI (one lacking a scheme)."
       (if found
           (cons (match-beginning 1) (match-end 1))))))
 
-(defun thing-at-point--bounds-of-well-formed-url (beg end pt)
+(defun thing-at-point--bounds-of-well-formed-url (beg end _pt)
   (save-excursion
     (goto-char beg)
     (let (url-beg paren-end regexp)
@@ -453,16 +450,14 @@ looks like an email address, \"ftp://\" if it starts with
          htb ret)
      (while htbs
        (setq htb (car htbs) htbs (cdr htbs))
-       (condition-case nil
-           (progn
-             ;; errs: htb symbol may be unbound, or not a hash-table.
-             ;; gnus-gethash is just a macro for intern-soft.
-             (and (symbol-value htb)
-                  (intern-soft string (symbol-value htb))
-                  (setq ret string htbs nil))
-             ;; If we made it this far, gnus is running, so ignore "heads":
-             (setq heads nil))
-         (error nil)))
+       (ignore-errors
+         ;; errs: htb symbol may be unbound, or not a hash-table.
+         ;; gnus-gethash is just a macro for intern-soft.
+         (and (symbol-value htb)
+              (intern-soft string (symbol-value htb))
+              (setq ret string htbs nil))
+         ;; If we made it this far, gnus is running, so ignore "heads":
+         (setq heads nil)))
      (or ret (not heads)
          (let ((head (string-match "\\`\\([[:lower:]]+\\)\\." string)))
            (and head (setq head (substring string 0 (match-end 1)))
@@ -566,9 +561,8 @@ Signal an error if the entire string was not used."
       (car read-data))))
 
 (defun form-at-point (&optional thing pred)
-  (let ((sexp (condition-case nil
-                  (read-from-whole-string (thing-at-point (or thing 'sexp)))
-                (error nil))))
+  (let ((sexp (ignore-errors
+                (read-from-whole-string (thing-at-point (or thing 'sexp))))))
     (if (or (not pred) (funcall pred sexp)) sexp)))
 
 ;;;###autoload