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.

6 files changed, 56 insertions, 58 deletions

diff --git a/lisp/org/org-agenda.el b/lisp/org/org-agenda.el
index e77b53aadca..fd5253ab1b7 100644
--- a/lisp/org/org-agenda.el
+++ b/lisp/org/org-agenda.el
@@ -3903,7 +3903,7 @@ functions do."
 
 (defvar org-agenda-markers nil
   "List of all currently active markers created by `org-agenda'.")
-(defvar org-agenda-last-marker-time (org-float-time)
+(defvar org-agenda-last-marker-time (float-time)
   "Creation time of the last agenda marker.")
 
 (defun org-agenda-new-marker (&optional pos)
@@ -3911,7 +3911,7 @@ functions do."
 Org-mode keeps a list of these markers and resets them when they are
 no longer in use."
   (let ((m (copy-marker (or pos (point)))))
-    (setq org-agenda-last-marker-time (org-float-time))
+    (setq org-agenda-last-marker-time (float-time))
     (if org-agenda-buffer
         (with-current-buffer org-agenda-buffer
           (push m org-agenda-markers))
@@ -5231,7 +5231,7 @@ So the example above may also be written as
 The function expects the lisp variables `entry' and `date' to be provided
 by the caller, because this is how the calendar works.  Don't use this
 function from a program - use `org-agenda-get-day-entries' instead."
-  (when (> (- (org-float-time)
+  (when (> (- (float-time)
               org-agenda-last-marker-time)
            5)
     ;; I am not sure if this works with sticky agendas, because the marker
@@ -5243,7 +5243,7 @@ function from a program - use `org-agenda-get-day-entries' instead."
   (let* ((files (if (and entry (stringp entry) (string-match "\\S-" entry))
                     (list entry)
                   (org-agenda-files t)))
-         (time (org-float-time))
+         (time (float-time))
          file rtn results)
     (when (or (not org-diary-last-run-time)
               (> (- time
@@ -5912,9 +5912,9 @@ See also the user option `org-agenda-clock-consistency-checks'."
               (throw 'next t))
             (setq ts (match-string 1)
                   te (match-string 3)
-                  ts (org-float-time
+                  ts (float-time
                       (apply 'encode-time (org-parse-time-string ts)))
-                  te (org-float-time
+                  te (float-time
                       (apply 'encode-time (org-parse-time-string te)))
                   dt (- te ts))))
         (cond
diff --git a/lisp/org/org-clock.el b/lisp/org/org-clock.el
index 9374f5fc3a3..1ec17f4daa1 100644
--- a/lisp/org/org-clock.el
+++ b/lisp/org/org-clock.el
@@ -658,8 +658,8 @@ If not, show simply the clocked time like 01:50."
 The time returned includes the time spent on this task in
 previous clocking intervals."
   (let ((currently-clocked-time
-         (floor (- (org-float-time)
-                   (org-float-time org-clock-start-time)) 60)))
+         (floor (- (float-time)
+                   (float-time org-clock-start-time)) 60)))
     (+ currently-clocked-time (or org-clock-total-time 0))))
 
 (defun org-clock-modify-effort-estimate (&optional value)
@@ -978,7 +978,7 @@ to be CLOCKED OUT."))))
                                    nil 45)))
                 (and (not (memq char-pressed '(?i ?q))) char-pressed)))))
          (default
-           (floor (/ (org-float-time
+           (floor (/ (float-time
                       (time-subtract (current-time) last-valid)) 60)))
          (keep
           (and (memq ch '(?k ?K))
@@ -987,8 +987,8 @@ to be CLOCKED OUT."))))
           (and (memq ch '(?g ?G))
                (read-number "Got back how many minutes ago? " default)))
          (subtractp (memq ch '(?s ?S)))
-         (barely-started-p (< (- (org-float-time last-valid)
-                                 (org-float-time (cdr clock))) 45))
+         (barely-started-p (< (- (float-time last-valid)
+                                 (float-time (cdr clock))) 45))
          (start-over (and subtractp barely-started-p)))
     (cond
      ((memq ch '(?j ?J))
@@ -1047,8 +1047,8 @@ If `only-dangling-p' is non-nil, only ask to resolve dangling
                         (lambda (clock)
                           (format
                            "Dangling clock started %d mins ago"
-                           (floor (- (org-float-time)
-                                     (org-float-time (cdr clock)))
+                           (floor (- (float-time)
+                                     (float-time (cdr clock)))
                                   60)))))
                    (or last-valid
                        (cdr clock)))))))))))
@@ -1057,7 +1057,7 @@ If `only-dangling-p' is non-nil, only ask to resolve dangling
   "Return the current Emacs idle time in seconds, or nil if not idle."
   (let ((idle-time (current-idle-time)))
     (if idle-time
-        (org-float-time idle-time)
+        (float-time idle-time)
       0)))
 
 (defun org-mac-idle-seconds ()
@@ -1109,7 +1109,7 @@ so long."
            (function
             (lambda (clock)
               (format "Clocked in & idle for %.1f mins"
-                      (/ (org-float-time
+                      (/ (float-time
                           (time-subtract (current-time)
                                          org-clock-user-idle-start))
                          60.0))))
@@ -1271,9 +1271,9 @@ make this the default behavior.)"
                              (y-or-n-p
                               (format
                                "You stopped another clock %d mins ago; start this one from then? "
-                               (/ (- (org-float-time
+                               (/ (- (float-time
                                       (org-current-time org-clock-rounding-minutes t))
-                                     (org-float-time leftover)) 60)))
+                                     (float-time leftover)) 60)))
                              leftover)
                         start-time
                         (org-current-time org-clock-rounding-minutes t)))
@@ -1517,8 +1517,8 @@ to, overriding the existing value of `org-clock-out-switch-to-state'."
           (delete-region (point) (point-at-eol))
           (insert "--")
           (setq te (org-insert-time-stamp (or at-time now) 'with-hm 'inactive))
-          (setq s (- (org-float-time (apply 'encode-time (org-parse-time-string te)))
-                     (org-float-time (apply 'encode-time (org-parse-time-string ts))))
+          (setq s (- (float-time (apply 'encode-time (org-parse-time-string te)))
+                     (float-time (apply 'encode-time (org-parse-time-string ts))))
                 h (floor (/ s 3600))
                 s (- s (* 3600 h))
                 m (floor (/ s 60))
@@ -1630,13 +1630,13 @@ Optional argument N tells to change by that many units."
         (let ((ts (if updatets1 ts2 ts1))
               (begts (if updatets1 begts1 begts2)))
           (setq tdiff
-                (subtract-time
+                (time-subtract
                  (org-time-string-to-time org-last-changed-timestamp)
                  (org-time-string-to-time ts)))
           (save-excursion
             (goto-char begts)
             (org-timestamp-change
-             (round (/ (org-float-time tdiff)
+             (round (/ (float-time tdiff)
                        (cond ((eq org-ts-what 'minute) 60)
                              ((eq org-ts-what 'hour) 3600)
                              ((eq org-ts-what 'day) (* 24 3600))
@@ -1739,8 +1739,8 @@ PROPNAME lets you set a custom text property instead of :org-clock-minutes."
           time)
      (if (stringp tstart) (setq tstart (org-time-string-to-seconds tstart)))
      (if (stringp tend) (setq tend (org-time-string-to-seconds tend)))
-     (if (consp tstart) (setq tstart (org-float-time tstart)))
-     (if (consp tend) (setq tend (org-float-time tend)))
+     (if (consp tstart) (setq tstart (float-time tstart)))
+     (if (consp tend) (setq tend (float-time tend)))
      (remove-text-properties (point-min) (point-max)
                              `(,(or propname :org-clock-minutes) t
                                :org-clock-force-headline-inclusion t))
@@ -1752,9 +1752,9 @@ PROPNAME lets you set a custom text property instead of :org-clock-minutes."
            ;; Two time stamps
            (setq ts (match-string 2)
                  te (match-string 3)
-                 ts (org-float-time
+                 ts (float-time
                      (apply 'encode-time (org-parse-time-string ts)))
-                 te (org-float-time
+                 te (float-time
                      (apply 'encode-time (org-parse-time-string te)))
                  ts (if tstart (max ts tstart) ts)
                  te (if tend (min te tend) te)
@@ -1771,10 +1771,10 @@ PROPNAME lets you set a custom text property instead of :org-clock-minutes."
                       (equal (marker-position org-clock-hd-marker) (point))
                       tstart
                       tend
-                      (>= (org-float-time org-clock-start-time) tstart)
-                      (<= (org-float-time org-clock-start-time) tend))
-             (let ((time (floor (- (org-float-time)
-                                   (org-float-time org-clock-start-time)) 60)))
+                      (>= (float-time org-clock-start-time) tstart)
+                      (<= (float-time org-clock-start-time) tend))
+             (let ((time (floor (- (float-time)
+                                   (float-time org-clock-start-time)) 60)))
                (setq t1 (+ t1 time))))
            (let* ((headline-forced
                    (get-text-property (point)
@@ -2584,17 +2584,17 @@ from the dynamic block definition."
      ((numberp ts)
       ;; If ts is a number, it's an absolute day number from org-agenda.
       (destructuring-bind (month day year) (calendar-gregorian-from-absolute ts)
-        (setq ts (org-float-time (encode-time 0 0 0 day month year)))))
+        (setq ts (float-time (encode-time 0 0 0 day month year)))))
      (ts
-      (setq ts (org-float-time
+      (setq ts (float-time
                 (apply 'encode-time (org-parse-time-string ts))))))
     (cond
      ((numberp te)
       ;; Likewise for te.
       (destructuring-bind (month day year) (calendar-gregorian-from-absolute te)
-        (setq te (org-float-time (encode-time 0 0 0 day month year)))))
+        (setq te (float-time (encode-time 0 0 0 day month year)))))
      (te
-      (setq te (org-float-time
+      (setq te (float-time
                 (apply 'encode-time (org-parse-time-string te))))))
     (setq tsb
           (if (eq step0 'week)
@@ -2788,9 +2788,9 @@ Otherwise, return nil."
           (end-of-line 1)
           (setq ts (match-string 1)
                 te (match-string 3))
-          (setq s (- (org-float-time
+          (setq s (- (float-time
                       (apply 'encode-time (org-parse-time-string te)))
-                     (org-float-time
+                     (float-time
                       (apply 'encode-time (org-parse-time-string ts))))
                 neg (< s 0)
                 s (abs s)
diff --git a/lisp/org/org-compat.el b/lisp/org/org-compat.el
index cf6aafc9854..9a79a4bc2b1 100644
--- a/lisp/org/org-compat.el
+++ b/lisp/org/org-compat.el
@@ -411,8 +411,7 @@ Pass BUFFER to the XEmacs version of `move-to-column'."
          (when focus-follows-mouse
            (set-mouse-position frame (1- (frame-width frame)) 0)))))
 
-(defalias 'org-float-time
-  (if (featurep 'xemacs) 'time-to-seconds 'float-time))
+(define-obsolete-function-alias 'org-float-time 'float-time "26.1")
 
 ;; `user-error' is only available from 24.2.50 on
 (unless (fboundp 'user-error)
diff --git a/lisp/org/org-list.el b/lisp/org/org-list.el
index 2c1e3775b0d..e119fbf3542 100644
--- a/lisp/org/org-list.el
+++ b/lisp/org/org-list.el
@@ -2884,7 +2884,7 @@ ignores hidden links."
                           (save-excursion (re-search-forward org-ts-regexp-both
                                                              (point-at-eol) t)))
                       (org-time-string-to-seconds (match-string 0)))
-                     (t (org-float-time now))))
+                     (t (float-time now))))
                    ((= dcst ?x) (or (and (stringp (match-string 1))
                                          (match-string 1))
                                     ""))
diff --git a/lisp/org/org-timer.el b/lisp/org/org-timer.el
index 667f6021b0d..079bed42d0d 100644
--- a/lisp/org/org-timer.el
+++ b/lisp/org/org-timer.el
@@ -123,7 +123,7 @@ the region 0:00:00."
           (setq delta (org-timer-hms-to-secs (org-timer-fix-incomplete s)))))
         (setq org-timer-start-time
               (seconds-to-time
-               (- (org-float-time) delta))))
+               (- (float-time) delta))))
       (org-timer-set-mode-line 'on)
       (message "Timer start time set to %s, current value is %s"
                (format-time-string "%T" org-timer-start-time)
@@ -142,9 +142,9 @@ With prefix arg STOP, stop it entirely."
     (setq org-timer-start-time
           (seconds-to-time
            (-
-            (org-float-time)
-            (- (org-float-time org-timer-pause-time)
-               (org-float-time org-timer-start-time))))
+            (float-time)
+            (- (float-time org-timer-pause-time)
+               (float-time org-timer-start-time))))
           org-timer-pause-time nil)
     (org-timer-set-mode-line 'on)
     (run-hooks 'org-timer-continue-hook)
@@ -194,10 +194,10 @@ it in the buffer."
 (defvar org-timer-timer-is-countdown nil)
 (defun org-timer-seconds ()
   (if org-timer-timer-is-countdown
-      (- (org-float-time org-timer-start-time)
-         (org-float-time))
-    (- (org-float-time org-timer-pause-time)
-       (org-float-time org-timer-start-time))))
+      (- (float-time org-timer-start-time)
+         (float-time))
+    (- (float-time org-timer-pause-time)
+       (float-time org-timer-start-time))))
 
 ;;;###autoload
 (defun org-timer-change-times-in-region (beg end delta)
diff --git a/lisp/org/org.el b/lisp/org/org.el
index 1921a59bbd0..e2fbf7bc314 100644
--- a/lisp/org/org.el
+++ b/lisp/org/org.el
@@ -5280,7 +5280,6 @@ This variable is set by `org-before-change-function'.
 
 ;; Other stuff we need.
 (require 'time-date)
-(unless (fboundp 'time-subtract) (defalias 'time-subtract 'subtract-time))
 (require 'easymenu)
 (require 'overlay)
 
@@ -5514,8 +5513,8 @@ the rounding returns a past time."
             (apply 'encode-time
                    (append (list 0 (* r (floor (+ .5 (/ (float (nth 1 time)) r)))))
                            (nthcdr 2 time))))
-      (if (and past (< (org-float-time (time-subtract (current-time) res)) 0))
-          (seconds-to-time (- (org-float-time res) (* r 60)))
+      (if (and past (< (float-time (time-subtract (current-time) res)) 0))
+          (seconds-to-time (- (float-time res) (* r 60)))
         res))))
 
 (defun org-today ()
@@ -8779,24 +8778,24 @@ links."
                (if (or (re-search-forward org-ts-regexp end t)
                        (re-search-forward org-ts-regexp-both end t))
                    (org-time-string-to-seconds (match-string 0))
-                 (org-float-time now))))
+                 (float-time now))))
             ((= dcst ?c)
              (let ((end (save-excursion (outline-next-heading) (point))))
                (if (re-search-forward
                     (concat "^[ \t]*\\[" org-ts-regexp1 "\\]")
                     end t)
                    (org-time-string-to-seconds (match-string 0))
-                 (org-float-time now))))
+                 (float-time now))))
             ((= dcst ?s)
              (let ((end (save-excursion (outline-next-heading) (point))))
                (if (re-search-forward org-scheduled-time-regexp end t)
                    (org-time-string-to-seconds (match-string 1))
-                 (org-float-time now))))
+                 (float-time now))))
             ((= dcst ?d)
              (let ((end (save-excursion (outline-next-heading) (point))))
                (if (re-search-forward org-deadline-time-regexp end t)
                    (org-time-string-to-seconds (match-string 1))
-                 (org-float-time now))))
+                 (float-time now))))
             ((= dcst ?p)
              (if (re-search-forward org-priority-regexp (point-at-eol) t)
                  (string-to-char (match-string 2))
@@ -8860,7 +8859,7 @@ If WITH-CASE is non-nil, the sorting will be case-sensitive."
             (lambda (x)
               (if (or (string-match org-ts-regexp x)
                       (string-match org-ts-regexp-both x))
-                  (org-float-time
+                  (float-time
                    (org-time-string-to-time (match-string 0 x)))
                 0))
             comparefun (if (= dcst sorting-type) '< '>)))
@@ -16886,7 +16885,7 @@ Don't touch the rest."
 (defun org-time-stamp-to-now (timestamp-string &optional seconds)
   "Difference between TIMESTAMP-STRING and now in days.
 If SECONDS is non-nil, return the difference in seconds."
-  (let ((fdiff (if seconds 'org-float-time 'time-to-days)))
+  (let ((fdiff (if seconds 'float-time 'time-to-days)))
     (- (funcall fdiff (org-time-string-to-time timestamp-string))
        (funcall fdiff (current-time)))))
 
@@ -17041,8 +17040,8 @@ days in order to avoid rounding problems."
           (match-end (match-end 0))
           (time1 (org-time-string-to-time ts1))
           (time2 (org-time-string-to-time ts2))
-          (t1 (org-float-time time1))
-          (t2 (org-float-time time2))
+          (t1 (float-time time1))
+          (t2 (float-time time2))
           (diff (abs (- t2 t1)))
           (negative (< (- t2 t1) 0))
           ;; (ys (floor (* 365 24 60 60)))
@@ -17107,7 +17106,7 @@ days in order to avoid rounding problems."
 
 (defun org-time-string-to-seconds (s)
   "Convert a timestamp string to a number of seconds."
-  (org-float-time (org-time-string-to-time s)))
+  (float-time (org-time-string-to-time s)))
 
 (defun org-time-string-to-absolute (s &optional daynr prefer show-all buffer pos)
   "Convert a time stamp to an absolute day number.