Simplify now that float-time etc. are built-in

This was prompted by warnings about calls to now-obsolete functions.
* lisp/calendar/time-date.el (encode-time-value):
Use setq rather than a recursive call, to avoid a warning
about calling this obsolete function.
* lisp/calendar/time-date.el (encode-time-value)
(with-decoded-time-value, time-to-seconds, time-to-number-of-days):
* lisp/erc/erc.el (erc-emacs-time-to-erc-time):
* lisp/net/rcirc.el (rcirc-float-time):
* lisp/org/org-compat.el (org-float-time):
Simplify now that time-add and float-time are now built-in.
* lisp/calendar/time-date.el (time-add, time-subtract, time-less-p):
* lisp/net/newst-backend.el (time-add):
* lisp/org/org.el (time-subtract):
Remove backward-compatibility definitions; they are now built-in.
* lisp/calendar/timeclock.el (timeclock-time-to-seconds)
(timeclock-seconds-to-time):
* lisp/net/rcirc.el (rcirc-float-time):
* lisp/org/org-compat.el (org-float-time):
Now obsolete, since callers can just use float-time and
seconds-to-time.  All uses changed.
* lisp/emacs-lisp/ert.el (ert-results-pop-to-timings):
* lisp/gnus/gnus-art.el (article-lapsed-string):
* lisp/gnus/gnus-diary.el (gnus-user-format-function-d):
* lisp/gnus/gnus-group.el (gnus-group-timestamp-delta):
* lisp/gnus/nndiary.el (nndiary-compute-reminders):
* lisp/net/tramp.el (tramp-time-diff):
* lisp/org/org-clock.el (org-clock-timestamps-change):
Prefer the time-subtract builtin to the subtract-time alias.
* lisp/files.el (dir-locals-find-file, dir-locals-read-from-dir):
* test/lisp/character-fold-tests.el (character-fold--speed-test):
Prefer the float-time builtin to the time-to-seconds alias.
* lisp/org/org-agenda.el, lisp/org/org-clock.el, lisp/org/org-list.el:
* lisp/org/org-timer.el, lisp/org/org.el:
Adjust to org-float-time deprecation.

2 files changed, 38 insertions, 126 deletions

diff --git a/lisp/calendar/time-date.el b/lisp/calendar/time-date.el
index da3e2a267db..a1d946eac74 100644
--- a/lisp/calendar/time-date.el
+++ b/lisp/calendar/time-date.el
@@ -126,16 +126,17 @@ type 2 is (HIGH LOW MICRO), and type 3 is (HIGH LOW MICRO PICO).
 
 For backward compatibility, if only four arguments are given,
 it is assumed that PICO was omitted and should be treated as zero."
+  (when (null type)
+    (setq type pico)
+    (setq pico 0))
   (cond
    ((eq type 0) (cons high low))
    ((eq type 1) (list high low))
    ((eq type 2) (list high low micro))
-   ((eq type 3) (list high low micro pico))
-   ((null type) (encode-time-value high low micro 0 pico))))
+   ((eq type 3) (list high low micro pico))))
 
-(when (and (fboundp 'time-add) (subrp (symbol-function 'time-add)))
-  (make-obsolete 'encode-time-value nil "25.1")
-  (make-obsolete 'with-decoded-time-value nil "25.1"))
+(make-obsolete 'encode-time-value nil "25.1")
+(make-obsolete 'with-decoded-time-value nil "25.1")
 
 (autoload 'parse-time-string "parse-time")
 (autoload 'timezone-make-date-arpa-standard "timezone")
@@ -163,27 +164,8 @@ If DATE lacks timezone information, GMT is assumed."
 		(apply 'signal err)
 	      (error "Invalid date: %s" date)))))))))
 
-;; Bit of a mess.  Emacs has float-time since at least 21.1.
-;; This file is synced to Gnus, and XEmacs packages may have been written
-;; using time-to-seconds from the Gnus library.
-;;;###autoload(if (or (featurep 'emacs)
-;;;###autoload        (and (fboundp 'float-time)
-;;;###autoload             (subrp (symbol-function 'float-time))))
-;;;###autoload    (defalias 'time-to-seconds 'float-time)
-;;;###autoload  (autoload 'time-to-seconds "time-date"))
-
-(eval-when-compile
-  (or (featurep 'emacs)
-      (and (fboundp 'float-time)
-           (subrp (symbol-function 'float-time)))
-      (defun time-to-seconds (&optional time)
-        "Convert optional value TIME to a floating point number.
-TIME defaults to the current time."
-        (with-decoded-time-value ((high low micro pico _type
-				   (or time (current-time))))
-          (+ (* high 65536.0)
-             low
-	     (/ (+ (* micro 1e6) pico) 1e12))))))
+;;;###autoload
+(defalias 'time-to-seconds 'float-time)
 
 ;;;###autoload
 (defun seconds-to-time (seconds)
@@ -209,68 +191,7 @@ TIME should be either a time value or a date-time string."
   (time-subtract nil time))
 
 ;;;###autoload
-(defalias 'subtract-time 'time-subtract)
-
-;; These autoloads do nothing in Emacs 25, where the functions are builtin.
-;;;###autoload(autoload 'time-add "time-date")
-;;;###autoload(autoload 'time-subtract "time-date")
-;;;###autoload(autoload 'time-less-p "time-date")
-
-(eval-and-compile
-  (when (not (and (fboundp 'time-add) (subrp (symbol-function 'time-add))))
-
-    (defun time-add (t1 t2)
-      "Add two time values T1 and T2.  One should represent a time difference."
-      (with-decoded-time-value ((high low micro pico type t1)
-				(high2 low2 micro2 pico2 type2 t2))
-	(setq high (+ high high2)
-	      low (+ low low2)
-	      micro (+ micro micro2)
-	      pico (+ pico pico2)
-	      type (max type type2))
-	(when (>= pico 1000000)
-	  (setq micro (1+ micro)
-		pico (- pico 1000000)))
-	(when (>= micro 1000000)
-	  (setq low (1+ low)
-		micro (- micro 1000000)))
-	(when (>= low 65536)
-	  (setq high (1+ high)
-		low (- low 65536)))
-	(encode-time-value high low micro pico type)))
-
-    (defun time-subtract (t1 t2)
-      "Subtract two time values, T1 minus T2.
-Return the difference in the format of a time value."
-      (with-decoded-time-value ((high low micro pico type t1)
-				(high2 low2 micro2 pico2 type2 t2))
-	(setq high (- high high2)
-	      low (- low low2)
-	      micro (- micro micro2)
-	      pico (- pico pico2)
-	      type (max type type2))
-	(when (< pico 0)
-	  (setq micro (1- micro)
-		pico (+ pico 1000000)))
-	(when (< micro 0)
-	  (setq low (1- low)
-		micro (+ micro 1000000)))
-	(when (< low 0)
-	  (setq high (1- high)
-		low (+ low 65536)))
-	(encode-time-value high low micro pico type)))
-
-    (defun time-less-p (t1 t2)
-      "Return non-nil if time value T1 is earlier than time value T2."
-      (with-decoded-time-value ((high1 low1 micro1 pico1 _type1 t1)
-				(high2 low2 micro2 pico2 _type2 t2))
-	(or (< high1 high2)
-	    (and (= high1 high2)
-		 (or (< low1 low2)
-		     (and (= low1 low2)
-			  (or (< micro1 micro2)
-			      (and (= micro1 micro2)
-				   (< pico1 pico2)))))))))))
+(define-obsolete-function-alias 'subtract-time 'time-subtract "26.1")
 
 ;;;###autoload
 (defun date-to-day (date)
@@ -324,12 +245,7 @@ The Gregorian date Sunday, December 31, 1bce is imaginary."
 (defun time-to-number-of-days (time)
   "Return the number of days represented by TIME.
 Returns a floating point number."
-  (/ (funcall (eval-when-compile
-                (if (or (featurep 'emacs)
-                        (and (fboundp 'float-time)
-                             (subrp (symbol-function 'float-time))))
-                    'float-time
-                  'time-to-seconds)) time) (* 60 60 24)))
+  (/ (float-time time) (* 60 60 24)))
 
 ;;;###autoload
 (defun safe-date-to-time (date)
diff --git a/lisp/calendar/timeclock.el b/lisp/calendar/timeclock.el
index 2bdfd98344a..3d9e2462224 100644
--- a/lisp/calendar/timeclock.el
+++ b/lisp/calendar/timeclock.el
@@ -532,18 +532,17 @@ non-nil, the amount returned will be relative to past time worked."
 	(message "%s" string)
       string)))
 
-(defalias 'timeclock-time-to-seconds (if (fboundp 'float-time) 'float-time
-				       'time-to-seconds))
-
-(defalias 'timeclock-seconds-to-time 'seconds-to-time)
+(define-obsolete-function-alias 'timeclock-time-to-seconds 'float-time "26.1")
+(define-obsolete-function-alias 'timeclock-seconds-to-time 'seconds-to-time
+  "26.1")
 
 ;; Should today-only be removed in favor of timeclock-relative? - gm
 (defsubst timeclock-when-to-leave (&optional today-only)
   "Return a time value representing the end of today's workday.
 If TODAY-ONLY is non-nil, the value returned will be relative only to
 the time worked today, and not to past time."
-  (timeclock-seconds-to-time
-   (- (timeclock-time-to-seconds)
+  (seconds-to-time
+   (- (float-time)
       (let ((discrep (timeclock-find-discrep)))
 	(if discrep
 	    (if today-only
@@ -686,9 +685,8 @@ being logged for.  Normally only \"in\" events specify a project."
 		    "\n")
 	    (if (equal (downcase code) "o")
 		(setq timeclock-last-period
-		      (- (timeclock-time-to-seconds now)
-			 (timeclock-time-to-seconds
-			  (cadr timeclock-last-event)))
+		      (- (float-time now)
+			 (float-time (cadr timeclock-last-event)))
 		      timeclock-discrepancy
 		      (+ timeclock-discrepancy
 			 timeclock-last-period)))
@@ -723,14 +721,14 @@ recorded to disk.  If MOMENT is non-nil, use that as the current time.
 This is only provided for coherency when used by
 `timeclock-discrepancy'."
   (if (equal (car timeclock-last-event) "i")
-      (- (timeclock-time-to-seconds moment)
-	 (timeclock-time-to-seconds (cadr timeclock-last-event)))
+      (- (float-time moment)
+	 (float-time (cadr timeclock-last-event)))
     timeclock-last-period))
 
 (defsubst timeclock-entry-length (entry)
   "Return the length of ENTRY in seconds."
-  (- (timeclock-time-to-seconds (cadr entry))
-     (timeclock-time-to-seconds (car entry))))
+  (- (float-time (cadr entry))
+     (float-time (car entry))))
 
 (defsubst timeclock-entry-begin (entry)
   "Return the start time of ENTRY."
@@ -765,8 +763,8 @@ This is only provided for coherency when used by
 
 (defsubst timeclock-entry-list-span (entry-list)
   "Return the total time in seconds spanned by ENTRY-LIST."
-  (- (timeclock-time-to-seconds (timeclock-entry-list-end entry-list))
-     (timeclock-time-to-seconds (timeclock-entry-list-begin entry-list))))
+  (- (float-time (timeclock-entry-list-end entry-list))
+     (float-time (timeclock-entry-list-begin entry-list))))
 
 (defsubst timeclock-entry-list-break (entry-list)
   "Return the total break time (span - length) in ENTRY-LIST."
@@ -1137,7 +1135,7 @@ discrepancy, today's discrepancy, and the time worked today."
 			   last-date-limited nil)
 		     (if beg
 			 (error "Error in format of timelog file!")
-		       (setq beg (timeclock-time-to-seconds (cadr event))))))
+		       (setq beg (float-time (cadr event))))))
 		  ((equal (downcase (car event)) "o")
 		   (if (and (nth 2 event)
 			    (> (length (nth 2 event)) 0))
@@ -1145,7 +1143,7 @@ discrepancy, today's discrepancy, and the time worked today."
 		   (if (not beg)
 		       (error "Error in format of timelog file!")
 		     (setq timeclock-last-period
-			   (- (timeclock-time-to-seconds (cadr event)) beg)
+			   (- (float-time (cadr event)) beg)
 			   accum (+ timeclock-last-period accum)
 			   beg nil))
 		   (if (equal last-date todays-date)
@@ -1225,8 +1223,8 @@ HTML-P is non-nil, HTML markup is added."
 	    (insert project "</b><br>\n")
 	  (insert project "*\n"))
 	(let ((proj-data (cdr (assoc project (timeclock-project-alist log))))
-	      (two-weeks-ago (timeclock-seconds-to-time
-			      (- (timeclock-time-to-seconds today)
+	      (two-weeks-ago (seconds-to-time
+			      (- (float-time today)
 				 (* 2 7 24 60 60))))
 	      two-week-len today-len)
 	  (while proj-data
@@ -1278,17 +1276,17 @@ HTML-P is non-nil, HTML markup is added."
     <th>-1 year</th>
 </tr>")
 	(let* ((day-list (timeclock-day-list))
-	       (thirty-days-ago (timeclock-seconds-to-time
-				 (- (timeclock-time-to-seconds today)
+	       (thirty-days-ago (seconds-to-time
+				 (- (float-time today)
 				    (* 30 24 60 60))))
-	       (three-months-ago (timeclock-seconds-to-time
-				  (- (timeclock-time-to-seconds today)
+	       (three-months-ago (seconds-to-time
+				  (- (float-time today)
 				     (* 90 24 60 60))))
-	       (six-months-ago (timeclock-seconds-to-time
-				(- (timeclock-time-to-seconds today)
+	       (six-months-ago (seconds-to-time
+				(- (float-time today)
 				   (* 180 24 60 60))))
-	       (one-year-ago (timeclock-seconds-to-time
-			      (- (timeclock-time-to-seconds today)
+	       (one-year-ago (seconds-to-time
+			      (- (float-time today)
 				 (* 365 24 60 60))))
 	       (time-in  (vector (list t) (list t) (list t) (list t) (list t)))
 	       (time-out (vector (list t) (list t) (list t) (list t) (list t)))
@@ -1303,12 +1301,11 @@ HTML-P is non-nil, HTML markup is added."
 		(unless (time-less-p
 			 (timeclock-day-begin day)
 			 (aref lengths i))
-		  (let ((base (timeclock-time-to-seconds
+		  (let ((base (float-time
 			       (timeclock-day-base
 				(timeclock-day-begin day)))))
 		    (nconc (aref time-in i)
-			   (list (- (timeclock-time-to-seconds
-				     (timeclock-day-begin day))
+			   (list (- (float-time (timeclock-day-begin day))
 				    base)))
 		    (let ((span (timeclock-day-span day))
 			  (len (timeclock-day-length day))
@@ -1320,8 +1317,7 @@ HTML-P is non-nil, HTML markup is added."
 		      (when (and (> span 0)
 				 (> (/ (float len) (float span)) 0.70))
 			(nconc (aref time-out i)
-			       (list (- (timeclock-time-to-seconds
-					 (timeclock-day-end day))
+			       (list (- (float-time (timeclock-day-end day))
 					base)))
 			(nconc (aref breaks i) (list (- span len))))
 		      (if req