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.

1 files changed, 62 insertions, 68 deletions

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