New function time-convert

This replaces the awkward reuse of encode-time to both convert
calendrical timestamps to Lisp timestamps, and to convert Lisp
timestamps to other forms.  Now, encode-time does just the
former and the new function does just the latter.
The new function builds on a suggestion by Lars Ingebrigtsen in:
https://lists.gnu.org/r/emacs-devel/2019-07/msg00801.html
and refined by Stefan Monnier in:
https://lists.gnu.org/r/emacs-devel/2019-07/msg00803.html
* doc/lispref/os.texi (Time of Day, Time Conversion):
* doc/misc/emacs-mime.texi (time-date):
* etc/NEWS: Update documentation.
* lisp/calendar/cal-dst.el (calendar-next-time-zone-transition):
* lisp/calendar/time-date.el (seconds-to-time, days-to-time):
* lisp/calendar/timeclock.el (timeclock-seconds-to-time):
* lisp/cedet/ede/detect.el (ede-detect-qtest):
* lisp/completion.el (cmpl-hours-since-origin):
* lisp/ecomplete.el (ecomplete-add-item):
* lisp/emacs-lisp/cl-extra.el (cl--random-time):
* lisp/emacs-lisp/timer.el (timer--time-setter)
(timer-next-integral-multiple-of-time):
* lisp/find-lisp.el (find-lisp-format-time):
* lisp/gnus/gnus-diary.el (gnus-user-format-function-d):
* lisp/gnus/gnus-group.el (gnus-group-set-timestamp):
* lisp/gnus/gnus-icalendar.el (gnus-icalendar-show-org-agenda):
* lisp/gnus/nnrss.el (nnrss-normalize-date):
* lisp/gnus/nnspool.el (nnspool-request-newgroups):
* lisp/net/ntlm.el (ntlm-compute-timestamp):
* lisp/net/pop3.el (pop3-uidl-dele):
* lisp/obsolete/vc-arch.el (vc-arch-add-tagline):
* lisp/org/org-clock.el (org-clock-get-clocked-time)
(org-clock-resolve, org-resolve-clocks, org-clock-in)
(org-clock-out, org-clock-sum):
* lisp/org/org-id.el (org-id-uuid, org-id-time-to-b36):
* lisp/org/ox-publish.el (org-publish-cache-ctime-of-src):
* lisp/proced.el (proced-format-time):
* lisp/progmodes/cc-cmds.el (c-progress-init)
(c-progress-update):
* lisp/progmodes/cperl-mode.el (cperl-time-fontification):
* lisp/progmodes/flymake.el (flymake--schedule-timer-maybe):
* lisp/progmodes/vhdl-mode.el (vhdl-update-progress-info)
(vhdl-fix-case-region-1):
* lisp/tar-mode.el (tar-octal-time):
* lisp/time.el (emacs-uptime):
* lisp/url/url-auth.el (url-digest-auth-make-cnonce):
* lisp/url/url-util.el (url-lazy-message):
* lisp/vc/vc-cvs.el (vc-cvs-parse-entry):
* lisp/vc/vc-hg.el (vc-hg-state-fast):
* lisp/xt-mouse.el (xterm-mouse-event):
* test/lisp/emacs-lisp/timer-tests.el:
(timer-next-integral-multiple-of-time-2):
Use time-convert, not encode-time.
* lisp/calendar/icalendar.el (icalendar--decode-isodatetime):
Don’t use now-removed FORM argument for encode-time.
It wasn’t crucial anyway.
* lisp/emacs-lisp/byte-opt.el (side-effect-free-fns): Add time-convert.
* lisp/emacs-lisp/elint.el (elint-unknown-builtin-args):
Update encode-time signature to match current arg set.
* lisp/emacs-lisp/timer.el (timer-next-integral-multiple-of-time):
Use timer-convert with t rather than doing it by hand.
* src/timefns.c (time_hz_ticks, time_form_stamp, lisp_time_form_stamp):
Remove; no longer needed.
(decode_lisp_time): Rturn the form instead of having a *PFORM arg.
All uses changed.
(time_arith): Just return TICKS if HZ is 1.
(Fencode_time): Remove argument FORM.  All callers changed.
Do not attempt to encode time values; just encode
decoded (calendrical) times.
Unless CURRENT_TIME_LIST, just return VALUE since HZ is 1.
(Ftime_convert): New function, which does the time value
conversion that bleeding-edge encode-time formerly did.
Return TIME if it is easy to see that it is already
of the correct form.
(Fcurrent_time): Mention in doc that the form is planned to change.
* test/src/timefns-tests.el (decode-then-encode-time):
Don’t use (encode-time nil).

35 files changed, 53 insertions, 56 deletions

diff --git a/lisp/calendar/cal-dst.el b/lisp/calendar/cal-dst.el
index 510cd6808e4..2d3b1f8c818 100644
--- a/lisp/calendar/cal-dst.el
+++ b/lisp/calendar/cal-dst.el
@@ -127,7 +127,7 @@ after midnight UTC on absolute date ABS-DATE."
   "Return the time of the next time zone transition after TIME.
 Both TIME and the result are acceptable arguments to `current-time-zone'.
 Return nil if no such transition can be found."
-  (let* ((time (encode-time time 'integer))
+  (let* ((time (time-convert time 'integer))
          (time-zone (current-time-zone time))
          (time-utc-diff (car time-zone))
          hi
diff --git a/lisp/calendar/icalendar.el b/lisp/calendar/icalendar.el
index cf3315b45db..c2688705e30 100644
--- a/lisp/calendar/icalendar.el
+++ b/lisp/calendar/icalendar.el
@@ -646,7 +646,7 @@ FIXME: multiple comma-separated values should be allowed!"
 	(let ((decoded-time (list second minute hour day month year
 				  nil -1 zone)))
 	  (condition-case nil
-	      (decode-time (encode-time decoded-time 'integer))
+	      (decode-time (encode-time decoded-time))
 	    (error
 	     (message "Cannot decode \"%s\"" isodatetimestring)
 	     ;; Hope for the best....
diff --git a/lisp/calendar/time-date.el b/lisp/calendar/time-date.el
index c0565b3cfb7..7505332011b 100644
--- a/lisp/calendar/time-date.el
+++ b/lisp/calendar/time-date.el
@@ -171,14 +171,14 @@ If DATE lacks timezone information, GMT is assumed."
 (defalias 'time-to-seconds 'float-time)
 
 ;;;###autoload
-(defalias 'seconds-to-time 'encode-time)
+(defalias 'seconds-to-time 'time-convert)
 
 ;;;###autoload
 (defun days-to-time (days)
   "Convert DAYS into a time value."
-  (let ((time (encode-time (* 86400 days))))
+  (let ((time (time-convert (* 86400 days))))
     ;; Traditionally, this returned a two-element list if DAYS was an integer.
-    ;; Keep that tradition if encode-time outputs timestamps in list form.
+    ;; Keep that tradition if time-convert outputs timestamps in list form.
     (if (and (integerp days) (consp (cdr time)))
 	(setcdr (cdr time) nil))
     time))
diff --git a/lisp/calendar/timeclock.el b/lisp/calendar/timeclock.el
index 60586e7aced..ee7cf17b042 100644
--- a/lisp/calendar/timeclock.el
+++ b/lisp/calendar/timeclock.el
@@ -515,7 +515,7 @@ non-nil, the amount returned will be relative to past time worked."
       string)))
 
 (define-obsolete-function-alias 'timeclock-time-to-seconds 'float-time "26.1")
-(define-obsolete-function-alias 'timeclock-seconds-to-time 'encode-time "26.1")
+(define-obsolete-function-alias 'timeclock-seconds-to-time 'time-convert "26.1")
 
 ;; Should today-only be removed in favor of timeclock-relative? - gm
 (defsubst timeclock-when-to-leave (&optional today-only)
diff --git a/lisp/cedet/ede/detect.el b/lisp/cedet/ede/detect.el
index d65abce4b3c..f65481b0c8d 100644
--- a/lisp/cedet/ede/detect.el
+++ b/lisp/cedet/ede/detect.el
@@ -200,7 +200,7 @@ Return a cons cell:
 	(ans (ede-detect-directory-for-project default-directory)))
     (if ans
 	(message "Project found in %d sec @ %s of type %s"
-		 (encode-time (time-since start) 'integer)
+		 (time-convert (time-since start) 'integer)
 		 (car ans)
 		 (eieio-object-name-string (cdr ans)))
       (message "No Project found.") )))
diff --git a/lisp/completion.el b/lisp/completion.el
index b9c3a21f5ea..77761d695bf 100644
--- a/lisp/completion.el
+++ b/lisp/completion.el
@@ -432,7 +432,7 @@ Used to decide whether to save completions.")
 
 
 (defun cmpl-hours-since-origin ()
-  (floor (encode-time nil 'integer) 3600))
+  (floor (time-convert nil 'integer) 3600))
 
 ;;---------------------------------------------------------------------------
 ;; "Symbol" parsing functions
diff --git a/lisp/ecomplete.el b/lisp/ecomplete.el
index d9f34ef0c00..1cacd473508 100644
--- a/lisp/ecomplete.el
+++ b/lisp/ecomplete.el
@@ -96,7 +96,7 @@ string that was matched."
 (defun ecomplete-add-item (type key text)
   "Add item TEXT of TYPE to the database, using KEY as the identifier."
   (let ((elems (assq type ecomplete-database))
-	(now (encode-time nil 'integer))
+	(now (time-convert nil 'integer))
 	entry)
     (unless elems
       (push (setq elems (list type)) ecomplete-database))
diff --git a/lisp/emacs-lisp/byte-opt.el b/lisp/emacs-lisp/byte-opt.el
index ecaa845fd3e..22fea1b8da9 100644
--- a/lisp/emacs-lisp/byte-opt.el
+++ b/lisp/emacs-lisp/byte-opt.el
@@ -1234,7 +1234,7 @@
 	 symbol-function symbol-name symbol-plist symbol-value string-make-unibyte
 	 string-make-multibyte string-as-multibyte string-as-unibyte
 	 string-to-multibyte
-	 tan truncate
+	 tan time-convert truncate
 	 unibyte-char-to-multibyte upcase user-full-name
 	 user-login-name user-original-login-name custom-variable-p
 	 vconcat
diff --git a/lisp/emacs-lisp/cl-extra.el b/lisp/emacs-lisp/cl-extra.el
index ca33c56a958..4dc2e9de58f 100644
--- a/lisp/emacs-lisp/cl-extra.el
+++ b/lisp/emacs-lisp/cl-extra.el
@@ -437,7 +437,7 @@ as an integer unless JUNK-ALLOWED is non-nil."
 ;; Random numbers.
 
 (defun cl--random-time ()
-  (car (encode-time nil t)))
+  (car (time-convert nil t)))
 
 ;;;###autoload (autoload 'cl-random-state-p "cl-extra")
 (cl-defstruct (cl--random-state
diff --git a/lisp/emacs-lisp/elint.el b/lisp/emacs-lisp/elint.el
index 6927921bdac..b7ef6eeb2ae 100644
--- a/lisp/emacs-lisp/elint.el
+++ b/lisp/emacs-lisp/elint.el
@@ -141,7 +141,7 @@ Set by `elint-initialize', if `elint-scan-preloaded' is non-nil.")
 (defconst elint-unknown-builtin-args
   ;; encode-time allows extra arguments for use with decode-time.
   ;; For some reason, some people seem to like to use them in other cases.
-  '((encode-time second minute hour day month year &rest zone))
+  '((encode-time time &rest obsolescent-arguments))
   "Those built-ins for which we can't find arguments, if any.")
 
 (defvar elint-extra-errors '(file-locked file-supersession ftp-error)
diff --git a/lisp/emacs-lisp/timer.el b/lisp/emacs-lisp/timer.el
index 400f00a85b5..561cc70078f 100644
--- a/lisp/emacs-lisp/timer.el
+++ b/lisp/emacs-lisp/timer.el
@@ -57,7 +57,7 @@
 
 (defun timer--time-setter (timer time)
   (timer--check timer)
-  (let ((lt (encode-time time 'list)))
+  (let ((lt (time-convert time 'list)))
     (setf (timer--high-seconds timer) (nth 0 lt))
     (setf (timer--low-seconds timer) (nth 1 lt))
     (setf (timer--usecs timer) (nth 2 lt))
@@ -96,10 +96,7 @@ fire each time Emacs is idle for that many seconds."
   "Yield the next value after TIME that is an integral multiple of SECS.
 More precisely, the next value, after TIME, that is an integral multiple
 of SECS seconds since the epoch.  SECS may be a fraction."
-  (let* ((ticks-hz (if (and (consp time) (integerp (car time))
-			    (integerp (cdr time)) (< 0 (cdr time)))
-		       time
-		     (encode-time time 1000000000000)))
+  (let* ((ticks-hz (time-convert time t))
 	 (ticks (car ticks-hz))
 	 (hz (cdr ticks-hz))
 	 trunc-s-ticks)
@@ -109,7 +106,7 @@ of SECS seconds since the epoch.  SECS may be a fraction."
       (setq ticks (ash ticks 1))
       (setq hz (ash hz 1)))
     (let ((more-ticks (+ ticks trunc-s-ticks)))
-      (encode-time (cons (- more-ticks (% more-ticks trunc-s-ticks)) hz)))))
+      (time-convert (cons (- more-ticks (% more-ticks trunc-s-ticks)) hz)))))
 
 (defun timer-relative-time (time secs &optional usecs psecs)
   "Advance TIME by SECS seconds and optionally USECS microseconds
diff --git a/lisp/find-lisp.el b/lisp/find-lisp.el
index 073e2bc573f..5a10ec3b47c 100644
--- a/lisp/find-lisp.el
+++ b/lisp/find-lisp.el
@@ -342,7 +342,7 @@ list of ls option letters of which c and u are recognized).  Use
 the same method as \"ls\" to decide whether to show time-of-day or
 year, depending on distance between file date and NOW."
   (let* ((time (nth (find-lisp-time-index switches) file-attr))
-	 (diff (encode-time (time-subtract time now) 'integer))
+	 (diff (time-convert (time-subtract time now) 'integer))
 	 (past-cutoff -15778476)		; 1/2 of a Gregorian year
 	 (future-cutoff (* 60 60)))		; 1 hour
     (format-time-string
diff --git a/lisp/gnus/gnus-diary.el b/lisp/gnus/gnus-diary.el
index 0e78f2b8992..16973074be4 100644
--- a/lisp/gnus/gnus-diary.el
+++ b/lisp/gnus/gnus-diary.el
@@ -161,7 +161,7 @@ There are currently two built-in format functions:
 	 (now (current-time))
 	 (occur (nndiary-next-occurrence sched now))
 	 (real-time (time-subtract occur now)))
-    (let* ((sec (encode-time real-time 'integer))
+    (let* ((sec (time-convert real-time 'integer))
 	   (past (< sec 0))
 	   delay)
       (and past (setq sec (- sec)))
diff --git a/lisp/gnus/gnus-group.el b/lisp/gnus/gnus-group.el
index 7e0ceec17b6..b40379c4f5c 100644
--- a/lisp/gnus/gnus-group.el
+++ b/lisp/gnus/gnus-group.el
@@ -4533,7 +4533,7 @@ and the second element is the address."
 This function can be used in hooks like `gnus-select-group-hook'
 or `gnus-group-catchup-group-hook'."
   (when gnus-newsgroup-name
-    (let ((time (encode-time nil 'integer)))
+    (let ((time (time-convert nil 'integer)))
       (gnus-group-set-parameter gnus-newsgroup-name 'timestamp time))))
 
 (defsubst gnus-group-timestamp (group)
diff --git a/lisp/gnus/gnus-icalendar.el b/lisp/gnus/gnus-icalendar.el
index 529cafe23e8..7d11b5699bb 100644
--- a/lisp/gnus/gnus-icalendar.el
+++ b/lisp/gnus/gnus-icalendar.el
@@ -650,7 +650,7 @@ is searched."
 (defun gnus-icalendar-show-org-agenda (event)
   (let* ((time-delta (time-subtract (gnus-icalendar-event:end-time event)
                                     (gnus-icalendar-event:start-time event)))
-         (duration-days (1+ (floor (encode-time time-delta 'integer) 86400))))
+         (duration-days (1+ (floor (time-convert time-delta 'integer) 86400))))
     (org-agenda-list nil (gnus-icalendar-event:start event) duration-days)))
 
 (cl-defmethod gnus-icalendar-event:sync-to-org ((event gnus-icalendar-event-request) reply-status)
diff --git a/lisp/gnus/nnrss.el b/lisp/gnus/nnrss.el
index 958745d5790..955432764e6 100644
--- a/lisp/gnus/nnrss.el
+++ b/lisp/gnus/nnrss.el
@@ -455,7 +455,7 @@ which RSS 2.0 allows."
     (cond ((null date))			; do nothing for this case
 	  ;; if the date is just digits (unix time stamp):
 	  ((string-match "^[0-9]+$" date)
-	   (setq given (encode-time (string-to-number date))))
+	   (setq given (time-convert (string-to-number date))))
 	  ;; RFC 822
 	  ((string-match " [0-9]+ " date)
 	   (setq vector (timezone-parse-date date)
diff --git a/lisp/gnus/nnspool.el b/lisp/gnus/nnspool.el
index 767631c6859..31ed3e97ef9 100644
--- a/lisp/gnus/nnspool.el
+++ b/lisp/gnus/nnspool.el
@@ -305,7 +305,7 @@ there.")
 	(while (and (not (looking-at
 			  "\\([^ ]+\\) +\\([0-9]+\\)[0-9][0-9][0-9] "))
 		    (zerop (forward-line -1))))
-	(let ((seconds (encode-time (date-to-time date) 'integer))
+	(let ((seconds (time-convert (date-to-time date) 'integer))
 	      groups)
 	  ;; Go through lines and add the latest groups to a list.
 	  (while (and (looking-at "\\([^ ]+\\) +[0-9]+ ")
diff --git a/lisp/net/ntlm.el b/lisp/net/ntlm.el
index 88c561910cb..aae77006202 100644
--- a/lisp/net/ntlm.el
+++ b/lisp/net/ntlm.el
@@ -151,7 +151,7 @@ signed integer."
 				    ;; tenths of microseconds between
 				    ;; 1601-01-01 and 1970-01-01
 				    "116444736000000000)")
-		 'rawnum (encode-time nil 'list)))
+		 'rawnum (time-convert nil 'list)))
 	 result-bytes)
     (dotimes (_byte 8)
       (push (calc-eval "and($1,16#FF)" 'rawnum tenths-of-us-since-jan-1-1601)
diff --git a/lisp/net/pop3.el b/lisp/net/pop3.el
index 4bf50c0d226..5f1cd94eb60 100644
--- a/lisp/net/pop3.el
+++ b/lisp/net/pop3.el
@@ -379,7 +379,7 @@ Use streaming commands."
 (defun pop3-uidl-dele (process)
   "Delete messages according to `pop3-leave-mail-on-server'.
 Return non-nil if it is necessary to update the local UIDL file."
-  (let* ((ctime (encode-time nil 'list))
+  (let* ((ctime (time-convert nil 'list))
 	 (age-limit (and (numberp pop3-leave-mail-on-server)
 			 (* 86400 pop3-leave-mail-on-server)))
 	 (srvr (assoc pop3-mailhost pop3-uidl-saved))
diff --git a/lisp/obsolete/vc-arch.el b/lisp/obsolete/vc-arch.el
index 925289102c1..1d41052037b 100644
--- a/lisp/obsolete/vc-arch.el
+++ b/lisp/obsolete/vc-arch.el
@@ -133,7 +133,7 @@ If nil, use the value of `vc-diff-switches'.  If t, use no switches."
 	(file-error (insert (format "%s <%s> %s"
 				    (current-time-string)
 				    user-mail-address
-				    (+ (% (car (encode-time nil 1000000))
+				    (+ (% (car (time-convert nil 1000000))
 					  1000000)
 				       (buffer-size)))))))
     (comment-region beg (point))))
diff --git a/lisp/org/org-clock.el b/lisp/org/org-clock.el
index 62c7cd92d12..4667890b421 100644
--- a/lisp/org/org-clock.el
+++ b/lisp/org/org-clock.el
@@ -723,7 +723,7 @@ menu\nmouse-2 will jump to task"))
 The time returned includes the time spent on this task in
 previous clocking intervals."
   (let ((currently-clocked-time
-	 (floor (encode-time (time-since org-clock-start-time) 'integer)
+	 (floor (time-convert (time-since org-clock-start-time) 'integer)
 		60)))
     (+ currently-clocked-time (or org-clock-total-time 0))))
 
@@ -1033,7 +1033,7 @@ to be CLOCKED OUT."))))
 				   nil 45)))
 		(and (not (memq char-pressed '(?i ?q))) char-pressed)))))
 	 (default
-	   (floor (encode-time (time-since last-valid) 'integer)
+	   (floor (time-convert (time-since last-valid) 'integer)
 		  60))
 	 (keep
 	  (and (memq ch '(?k ?K))
@@ -1102,8 +1102,8 @@ If `only-dangling-p' is non-nil, only ask to resolve dangling
 			(lambda (clock)
 			  (format
 			   "Dangling clock started %d mins ago"
-			   (floor (encode-time (time-since (cdr clock))
-					       'integer)
+			   (floor (time-convert (time-since (cdr clock))
+						'integer)
 				  60)))))
 		   (or last-valid
 		       (cdr clock)))))))))))
@@ -1321,7 +1321,7 @@ the default behavior."
 			  (y-or-n-p
 			   (format
 			    "You stopped another clock %d mins ago; start this one from then? "
-			    (/ (encode-time
+			    (/ (time-convert
 				(time-subtract
 				 (org-current-time org-clock-rounding-minutes t)
 				 leftover)
@@ -1576,10 +1576,10 @@ 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 (encode-time (time-subtract
-				(org-time-string-to-time te)
-				(org-time-string-to-time ts))
-			       'integer)
+	  (setq s (time-convert (time-subtract
+				 (org-time-string-to-time te)
+				 (org-time-string-to-time ts))
+				'integer)
 		h (floor s 3600)
 		m (floor (mod s 3600) 60))
 	  (insert " => " (format "%2d:%02d" h m))
@@ -1833,7 +1833,7 @@ PROPNAME lets you set a custom text property instead of :org-clock-minutes."
 		      tend
 		      (>= (float-time org-clock-start-time) tstart)
 		      (<= (float-time org-clock-start-time) tend))
-	     (let ((time (floor (encode-time
+	     (let ((time (floor (time-convert
 				 (time-since org-clock-start-time)
 				 'integer)
 				60)))
diff --git a/lisp/org/org-id.el b/lisp/org/org-id.el
index fe439a7b89d..34084bfa109 100644
--- a/lisp/org/org-id.el
+++ b/lisp/org/org-id.el
@@ -356,7 +356,7 @@ So a typical ID could look like \"Org:4nd91V40HI\"."
   "Return string with random (version 4) UUID."
   (let ((rnd (md5 (format "%s%s%s%s%s%s%s"
 			  (random)
-			  (encode-time nil 'list)
+			  (time-convert nil 'list)
 			  (user-uid)
 			  (emacs-pid)
 			  (user-full-name)
@@ -418,7 +418,7 @@ using `org-id-decode'."
   ;; FIXME: If TIME represents N seconds after the epoch, then
   ;; this encoding assumes 0 <= N < 110075314176 = (* (expt 36 4) 65536),
   ;; i.e., that TIME is from 1970-01-01 00:00:00 to 5458-02-23 20:09:36 UTC.
-  (setq time (encode-time time 'list))
+  (setq time (time-convert time 'list))
   (concat (org-id-int-to-b36 (nth 0 time) 4)
 	  (org-id-int-to-b36 (nth 1 time) 4)
 	  (org-id-int-to-b36 (nth 2 time) 4)))
diff --git a/lisp/org/ox-publish.el b/lisp/org/ox-publish.el
index 9126647e7c3..237b2ff8163 100644
--- a/lisp/org/ox-publish.el
+++ b/lisp/org/ox-publish.el
@@ -1348,7 +1348,7 @@ does not exist."
 	       (expand-file-name (or (file-symlink-p file) file)
 				 (file-name-directory file)))))
     (if (not attr) (error "No such file: \"%s\"" file)
-      (encode-time (file-attribute-modification-time attr) 'integer))))
+      (time-convert (file-attribute-modification-time attr) 'integer))))
 
 
 (provide 'ox-publish)
diff --git a/lisp/proced.el b/lisp/proced.el
index 5f35fa34a07..db8bdb5ac80 100644
--- a/lisp/proced.el
+++ b/lisp/proced.el
@@ -1348,7 +1348,7 @@ Prefix ARG controls sort order, see `proced-sort-interactive'."
 
 (defun proced-format-time (time)
   "Format time interval TIME."
-  (let* ((ftime (encode-time time 'integer))
+  (let* ((ftime (time-convert time 'integer))
          (days (truncate ftime 86400))
          (ftime (mod ftime 86400))
          (hours (truncate ftime 3600))
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 2ccdc1d0bc8..acf4c4ad158 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -3611,7 +3611,7 @@ Otherwise reindent just the current line."
 				    (save-excursion
 				      (goto-char end)
 				      (point-marker))
-				    (encode-time nil 'integer)
+				    (time-convert nil 'integer)
 				    context))
       (message "Indenting region..."))
    ))
@@ -3619,7 +3619,7 @@ Otherwise reindent just the current line."
 (defun c-progress-update ()
   (if (not (and c-progress-info c-progress-interval))
       nil
-    (let ((now (encode-time nil 'integer))
+    (let ((now (time-convert nil 'integer))
 	  (start (aref c-progress-info 0))
 	  (end (aref c-progress-info 1))
 	  (lastsecs (aref c-progress-info 2)))
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index d5c404c7d2f..8e94da082a3 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -8600,7 +8600,7 @@ start with default arguments, then refine the slowdown regions."
   (or l (setq l 1))
   (or step (setq step 500))
   (or lim (setq lim 40))
-  (let* ((timems (function (lambda () (car (encode-time nil 1000)))))
+  (let* ((timems (function (lambda () (car (time-convert nil 1000)))))
 	 (tt (funcall timems)) (c 0) delta tot)
     (goto-char (point-min))
     (forward-line (1- l))
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index e8a4334fe96..6d47c8bb170 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -1022,7 +1022,7 @@ Do it only if `flymake-no-changes-timeout' is non-nil."
     (setq
      flymake-timer
      (run-with-idle-timer
-      ;; This can use encode-time instead of seconds-to-time,
+      ;; This can use time-convert instead of seconds-to-time,
       ;; once we can assume Emacs 27 or later.
       (seconds-to-time flymake-no-changes-timeout)
       nil
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 9eedbf9cbc9..2c947f3b050 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -7403,7 +7403,7 @@ only-lines."
 		   100
                  (floor (* 100.0 (- pos (aref vhdl-progress-info 0)))
                         delta))))
-    (aset vhdl-progress-info 2 (encode-time nil 'integer))))
+    (aset vhdl-progress-info 2 (time-convert nil 'integer))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Indentation commands
@@ -8149,7 +8149,7 @@ depending on parameter UPPER-CASE."
 	   (message "Fixing case... (%2d%s)"
 		    (+ (* count 20) (/ (* 20 (- (point) beg)) (- end beg)))
 		    "%")
-	   (setq last-update (encode-time nil 'integer))))
+	   (setq last-update (time-convert nil 'integer))))
        (goto-char end)))))
 
 (defun vhdl-fix-case-region (beg end &optional arg)
diff --git a/lisp/tar-mode.el b/lisp/tar-mode.el
index cf777817666..713f3d944bc 100644
--- a/lisp/tar-mode.el
+++ b/lisp/tar-mode.el
@@ -1271,7 +1271,7 @@ for this to be permanent."
 
 (defun tar-octal-time (timeval)
   ;; Format a timestamp as 11 octal digits.
-  (format "%011o" (encode-time timeval 'integer)))
+  (format "%011o" (time-convert timeval 'integer)))
 
 (defun tar-subfile-save-buffer ()
   "In tar subfile mode, save this buffer into its parent tar-file buffer.
diff --git a/lisp/time.el b/lisp/time.el
index 35157c5e807..95e095af5dd 100644
--- a/lisp/time.el
+++ b/lisp/time.el
@@ -572,7 +572,7 @@ For example, the Unix uptime command format is \"%D, %z%2h:%.2m\"."
   (interactive)
   (let ((str
          (format-seconds (or format "%Y, %D, %H, %M, %z%S")
-			 (encode-time
+			 (time-convert
 			  (time-since before-init-time)
 			  'integer))))
     (if (called-interactively-p 'interactive)
diff --git a/lisp/url/url-auth.el b/lisp/url/url-auth.el
index b78544e3f37..b9643c279ff 100644
--- a/lisp/url/url-auth.el
+++ b/lisp/url/url-auth.el
@@ -193,7 +193,7 @@ key cache `url-digest-auth-storage'."
 (defun url-digest-auth-make-cnonce ()
   "Compute a new unique client nonce value."
   (base64-encode-string
-   (format "%016x%016x" (random) (car (encode-time nil t)))
+   (format "%016x%016x" (random) (car (time-convert nil t)))
    t))
 
 (defun url-digest-auth-nonce-count (_nonce)
diff --git a/lisp/url/url-util.el b/lisp/url/url-util.el
index a46e7bb3855..0b3c2839266 100644
--- a/lisp/url/url-util.el
+++ b/lisp/url/url-util.el
@@ -181,7 +181,7 @@ Will not do anything if `url-show-status' is nil."
 	  (null url-show-status)
 	  (active-minibuffer-window)
 	  (= url-lazy-message-time
-	     (setq url-lazy-message-time (encode-time nil 'integer))))
+	     (setq url-lazy-message-time (time-convert nil 'integer))))
       nil
     (apply 'message args)))
 
diff --git a/lisp/vc/vc-cvs.el b/lisp/vc/vc-cvs.el
index b33a106f3a9..d84700fc176 100644
--- a/lisp/vc/vc-cvs.el
+++ b/lisp/vc/vc-cvs.el
@@ -1183,8 +1183,8 @@ is non-nil."
                   (decoded-time-second parsed-time)
                   ;; Compare just the seconds part of the file time,
                   ;; since CVS file time stamp resolution is just 1 second.
-		  (= (encode-time mtime 'integer)
-		     (encode-time parsed-time 'integer)))
+		  (= (time-convert mtime 'integer)
+		     (time-convert (encode-time parsed-time) 'integer)))
              (vc-file-setprop file 'vc-checkout-time mtime)
              (if set-state (vc-file-setprop file 'vc-state 'up-to-date)))
             (t
diff --git a/lisp/vc/vc-hg.el b/lisp/vc/vc-hg.el
index 876d824ceac..f287adf2423 100644
--- a/lisp/vc/vc-hg.el
+++ b/lisp/vc/vc-hg.el
@@ -1043,7 +1043,7 @@ hg binary."
                (let ((vc-hg-size (nth 2 dirstate-entry))
                      (vc-hg-mtime (nth 3 dirstate-entry))
                      (fs-size (file-attribute-size stat))
-		     (fs-mtime (encode-time
+		     (fs-mtime (time-convert
 				(file-attribute-modification-time stat)
 				'integer)))
                  (if (and (eql vc-hg-size fs-size) (eql vc-hg-mtime fs-mtime))
diff --git a/lisp/xt-mouse.el b/lisp/xt-mouse.el
index 5ff718292d3..b53174b7bd5 100644
--- a/lisp/xt-mouse.el
+++ b/lisp/xt-mouse.el
@@ -245,8 +245,8 @@ which is the \"1006\" extension implemented in Xterm >= 277."
              ;; for default value of mouse-1-click-follows-link (450msec).
 	     (timestamp (if (not xt-mouse-epoch)
 			    (progn (setq xt-mouse-epoch (float-time)) 0)
-			  (car (encode-time (time-since xt-mouse-epoch)
-					    1000))))
+			  (car (time-convert (time-since xt-mouse-epoch)
+					     1000))))
              (w (window-at x y))
              (ltrb (window-edges w))
              (left (nth 0 ltrb))