From bf1c3f6a14d41785416e89eaa909a674021e7727 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 26 Jan 2026 11:02:50 +0000
Subject: [PATCH 01/16] move `Types` from `with_api!` to `Server`

---
 .../rustc_expand/src/proc_macro_server.rs     |   4 +-
 library/proc_macro/src/bridge/client.rs       |  13 +-
 library/proc_macro/src/bridge/mod.rs          | 127 ++++++++----------
 library/proc_macro/src/bridge/server.rs       |  59 ++++----
 .../crates/proc-macro-srv/src/dylib.rs        |   2 +-
 .../src/server_impl/rust_analyzer_span.rs     |   4 +-
 .../src/server_impl/token_id.rs               |   4 +-
 7 files changed, 84 insertions(+), 129 deletions(-)

diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index a51aa90355bcd..12490880ab0eb 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -458,13 +458,11 @@ impl<'a, 'b> Rustc<'a, 'b> {
     }
 }
 
-impl server::Types for Rustc<'_, '_> {
+impl server::Server for Rustc<'_, '_> {
     type TokenStream = TokenStream;
     type Span = Span;
     type Symbol = Symbol;
-}
 
-impl server::Server for Rustc<'_, '_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {
             def_site: self.def_site,
diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index 0d87a727ae40b..381c8502c8538 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -67,12 +67,6 @@ impl<S> Decode<'_, '_, S> for Span {
     }
 }
 
-// FIXME(eddyb) generate these impls by pattern-matching on the
-// names of methods - also could use the presence of `fn drop`
-// to distinguish between 'owned and 'interned, above.
-// Alternatively, special "modes" could be listed of types in with_api
-// instead of pattern matching on methods, here and in server decl.
-
 impl Clone for TokenStream {
     fn clone(&self) -> Self {
         Methods::ts_clone(self)
@@ -104,10 +98,7 @@ pub(crate) use super::symbol::Symbol;
 
 macro_rules! define_client_side {
     (
-        Methods {
-            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
-        },
-        $($name:ident),* $(,)?
+        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
     ) => {
         impl Methods {
             $(pub(crate) fn $method($($arg: $arg_ty),*) $(-> $ret_ty)? {
@@ -130,7 +121,7 @@ macro_rules! define_client_side {
         }
     }
 }
-with_api!(self, self, define_client_side);
+with_api!(self, define_client_side);
 
 struct Bridge<'a> {
     /// Reusable buffer (only `clear`-ed, never shrunk), primarily
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 6f7c8726f9253..f454861be4ed1 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -18,87 +18,71 @@ use crate::{Delimiter, Level, Spacing};
 /// Higher-order macro describing the server RPC API, allowing automatic
 /// generation of type-safe Rust APIs, both client-side and server-side.
 ///
-/// `with_api!(MySelf, my_self, my_macro)` expands to:
+/// `with_api!(MySelf, my_macro)` expands to:
 /// ```rust,ignore (pseudo-code)
 /// my_macro! {
-///     Methods {
-///         // ...
-///         fn lit_character(ch: char) -> MySelf::Literal;
-///         // ...
-///         fn lit_span(my_self: &MySelf::Literal) -> MySelf::Span;
-///         fn lit_set_span(my_self: &mut MySelf::Literal, span: MySelf::Span);
-///     },
-///     Literal,
-///     Span,
+///     fn lit_character(ch: char) -> MySelf::Literal;
+///     fn lit_span(lit: &MySelf::Literal) -> MySelf::Span;
+///     fn lit_set_span(lit: &mut MySelf::Literal, span: MySelf::Span);
 ///     // ...
 /// }
 /// ```
 ///
-/// The first two arguments serve to customize the arguments names
-/// and argument/return types, to enable several different usecases:
-///
-/// If `my_self` is just `self`, then each `fn` signature can be used
-/// as-is for a method. If it's anything else (`self_` in practice),
-/// then the signatures don't have a special `self` argument, and
-/// can, therefore, have a different one introduced.
+/// The first argument serves to customize the argument/return types,
+/// to enable several different usecases:
 ///
 /// If `MySelf` is just `Self`, then the types are only valid inside
 /// a trait or a trait impl, where the trait has associated types
 /// for each of the API types. If non-associated types are desired,
 /// a module name (`self` in practice) can be used instead of `Self`.
 macro_rules! with_api {
-    ($S:ident, $self:ident, $m:ident) => {
+    ($S:ident, $m:ident) => {
         $m! {
-            Methods {
-                fn injected_env_var(var: &str) -> Option<String>;
-                fn track_env_var(var: &str, value: Option<&str>);
-                fn track_path(path: &str);
-                fn literal_from_str(s: &str) -> Result<Literal<$S::Span, $S::Symbol>, ()>;
-                fn emit_diagnostic(diagnostic: Diagnostic<$S::Span>);
-
-                fn ts_drop(stream: $S::TokenStream);
-                fn ts_clone(stream: &$S::TokenStream) -> $S::TokenStream;
-                fn ts_is_empty(stream: &$S::TokenStream) -> bool;
-                fn ts_expand_expr(stream: &$S::TokenStream) -> Result<$S::TokenStream, ()>;
-                fn ts_from_str(src: &str) -> $S::TokenStream;
-                fn ts_to_string(stream: &$S::TokenStream) -> String;
-                fn ts_from_token_tree(
-                    tree: TokenTree<$S::TokenStream, $S::Span, $S::Symbol>,
-                ) -> $S::TokenStream;
-                fn ts_concat_trees(
-                    base: Option<$S::TokenStream>,
-                    trees: Vec<TokenTree<$S::TokenStream, $S::Span, $S::Symbol>>,
-                ) -> $S::TokenStream;
-                fn ts_concat_streams(
-                    base: Option<$S::TokenStream>,
-                    streams: Vec<$S::TokenStream>,
-                ) -> $S::TokenStream;
-                fn ts_into_trees(
-                    stream: $S::TokenStream
-                ) -> Vec<TokenTree<$S::TokenStream, $S::Span, $S::Symbol>>;
-
-                fn span_debug(span: $S::Span) -> String;
-                fn span_parent(span: $S::Span) -> Option<$S::Span>;
-                fn span_source(span: $S::Span) -> $S::Span;
-                fn span_byte_range(span: $S::Span) -> Range<usize>;
-                fn span_start(span: $S::Span) -> $S::Span;
-                fn span_end(span: $S::Span) -> $S::Span;
-                fn span_line(span: $S::Span) -> usize;
-                fn span_column(span: $S::Span) -> usize;
-                fn span_file(span: $S::Span) -> String;
-                fn span_local_file(span: $S::Span) -> Option<String>;
-                fn span_join(span: $S::Span, other: $S::Span) -> Option<$S::Span>;
-                fn span_subspan(span: $S::Span, start: Bound<usize>, end: Bound<usize>) -> Option<$S::Span>;
-                fn span_resolved_at(span: $S::Span, at: $S::Span) -> $S::Span;
-                fn span_source_text(span: $S::Span) -> Option<String>;
-                fn span_save_span(span: $S::Span) -> usize;
-                fn span_recover_proc_macro_span(id: usize) -> $S::Span;
-
-                fn symbol_normalize_and_validate_ident(string: &str) -> Result<$S::Symbol, ()>;
-            },
-            TokenStream,
-            Span,
-            Symbol,
+            fn injected_env_var(var: &str) -> Option<String>;
+            fn track_env_var(var: &str, value: Option<&str>);
+            fn track_path(path: &str);
+            fn literal_from_str(s: &str) -> Result<Literal<$S::Span, $S::Symbol>, ()>;
+            fn emit_diagnostic(diagnostic: Diagnostic<$S::Span>);
+
+            fn ts_drop(stream: $S::TokenStream);
+            fn ts_clone(stream: &$S::TokenStream) -> $S::TokenStream;
+            fn ts_is_empty(stream: &$S::TokenStream) -> bool;
+            fn ts_expand_expr(stream: &$S::TokenStream) -> Result<$S::TokenStream, ()>;
+            fn ts_from_str(src: &str) -> $S::TokenStream;
+            fn ts_to_string(stream: &$S::TokenStream) -> String;
+            fn ts_from_token_tree(
+                tree: TokenTree<$S::TokenStream, $S::Span, $S::Symbol>,
+            ) -> $S::TokenStream;
+            fn ts_concat_trees(
+                base: Option<$S::TokenStream>,
+                trees: Vec<TokenTree<$S::TokenStream, $S::Span, $S::Symbol>>,
+            ) -> $S::TokenStream;
+            fn ts_concat_streams(
+                base: Option<$S::TokenStream>,
+                streams: Vec<$S::TokenStream>,
+            ) -> $S::TokenStream;
+            fn ts_into_trees(
+                stream: $S::TokenStream
+            ) -> Vec<TokenTree<$S::TokenStream, $S::Span, $S::Symbol>>;
+
+            fn span_debug(span: $S::Span) -> String;
+            fn span_parent(span: $S::Span) -> Option<$S::Span>;
+            fn span_source(span: $S::Span) -> $S::Span;
+            fn span_byte_range(span: $S::Span) -> Range<usize>;
+            fn span_start(span: $S::Span) -> $S::Span;
+            fn span_end(span: $S::Span) -> $S::Span;
+            fn span_line(span: $S::Span) -> usize;
+            fn span_column(span: $S::Span) -> usize;
+            fn span_file(span: $S::Span) -> String;
+            fn span_local_file(span: $S::Span) -> Option<String>;
+            fn span_join(span: $S::Span, other: $S::Span) -> Option<$S::Span>;
+            fn span_subspan(span: $S::Span, start: Bound<usize>, end: Bound<usize>) -> Option<$S::Span>;
+            fn span_resolved_at(span: $S::Span, at: $S::Span) -> $S::Span;
+            fn span_source_text(span: $S::Span) -> Option<String>;
+            fn span_save_span(span: $S::Span) -> usize;
+            fn span_recover_proc_macro_span(id: usize) -> $S::Span;
+
+            fn symbol_normalize_and_validate_ident(string: &str) -> Result<$S::Symbol, ()>;
         }
     };
 }
@@ -158,10 +142,7 @@ mod api_tags {
 
     macro_rules! declare_tags {
         (
-            Methods {
-                $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
-            },
-            $($name:ident),* $(,)?
+            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         ) => {
             pub(super) enum Method {
                 $($method),*
@@ -169,7 +150,7 @@ mod api_tags {
             rpc_encode_decode!(enum Method { $($method),* });
         }
     }
-    with_api!(self, self, declare_tags);
+    with_api!(self, declare_tags);
 }
 
 /// Helper to wrap associated types to allow trait impl dispatch.
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index b79de99844533..2fed45d3a0ab6 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -5,12 +5,12 @@ use std::marker::PhantomData;
 
 use super::*;
 
-pub(super) struct HandleStore<S: Types> {
+pub(super) struct HandleStore<S: Server> {
     token_stream: handle::OwnedStore<Marked<S::TokenStream, client::TokenStream>>,
     span: handle::InternedStore<Marked<S::Span, client::Span>>,
 }
 
-impl<S: Types> HandleStore<S> {
+impl<S: Server> HandleStore<S> {
     fn new(handle_counters: &'static client::HandleCounters) -> Self {
         HandleStore {
             token_stream: handle::OwnedStore::new(&handle_counters.token_stream),
@@ -19,19 +19,19 @@ impl<S: Types> HandleStore<S> {
     }
 }
 
-impl<S: Types> Encode<HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
+impl<S: Server> Encode<HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
     fn encode(self, w: &mut Writer, s: &mut HandleStore<S>) {
         s.token_stream.alloc(self).encode(w, s);
     }
 }
 
-impl<S: Types> Decode<'_, '_, HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
+impl<S: Server> Decode<'_, '_, HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
     fn decode(r: &mut Reader<'_>, s: &mut HandleStore<S>) -> Self {
         s.token_stream.take(handle::Handle::decode(r, &mut ()))
     }
 }
 
-impl<'s, S: Types> Decode<'_, 's, HandleStore<S>>
+impl<'s, S: Server> Decode<'_, 's, HandleStore<S>>
     for &'s Marked<S::TokenStream, client::TokenStream>
 {
     fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<S>) -> Self {
@@ -39,32 +39,32 @@ impl<'s, S: Types> Decode<'_, 's, HandleStore<S>>
     }
 }
 
-impl<S: Types> Encode<HandleStore<S>> for Marked<S::Span, client::Span> {
+impl<S: Server> Encode<HandleStore<S>> for Marked<S::Span, client::Span> {
     fn encode(self, w: &mut Writer, s: &mut HandleStore<S>) {
         s.span.alloc(self).encode(w, s);
     }
 }
 
-impl<S: Types> Decode<'_, '_, HandleStore<S>> for Marked<S::Span, client::Span> {
+impl<S: Server> Decode<'_, '_, HandleStore<S>> for Marked<S::Span, client::Span> {
     fn decode(r: &mut Reader<'_>, s: &mut HandleStore<S>) -> Self {
         s.span.copy(handle::Handle::decode(r, &mut ()))
     }
 }
 
-pub trait Types {
-    type TokenStream: 'static + Clone;
-    type Span: 'static + Copy + Eq + Hash;
-    type Symbol: 'static;
+struct Dispatcher<S: Server> {
+    handle_store: HandleStore<S>,
+    server: S,
 }
 
-macro_rules! declare_server_traits {
+macro_rules! define_server_dispatcher_impl {
     (
-        Methods {
-            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
-        },
-        $($name:ident),* $(,)?
+        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
     ) => {
-        pub trait Server: Types {
+        pub trait Server {
+            type TokenStream: 'static + Clone;
+            type Span: 'static + Copy + Eq + Hash;
+            type Symbol: 'static;
+
             fn globals(&mut self) -> ExpnGlobals<Self::Span>;
 
             /// Intern a symbol received from RPC
@@ -75,32 +75,21 @@ macro_rules! declare_server_traits {
 
             $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?;)*
         }
-    }
-}
-with_api!(Self, self_, declare_server_traits);
 
-struct Dispatcher<S: Types> {
-    handle_store: HandleStore<S>,
-    server: S,
-}
-
-macro_rules! define_dispatcher_impl {
-    (
-        Methods {
-            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
-        },
-        $($name:ident),* $(,)?
-    ) => {
         // FIXME(eddyb) `pub` only for `ExecutionStrategy` below.
         pub trait DispatcherTrait {
             // HACK(eddyb) these are here to allow `Self::$name` to work below.
-            $(type $name;)*
+            type TokenStream;
+            type Span;
+            type Symbol;
 
             fn dispatch(&mut self, buf: Buffer) -> Buffer;
         }
 
         impl<S: Server> DispatcherTrait for Dispatcher<S> {
-            $(type $name = Marked<S::$name, client::$name>;)*
+            type TokenStream = Marked<S::TokenStream, client::TokenStream>;
+            type Span = Marked<S::Span, client::Span>;
+            type Symbol = Marked<S::Symbol, client::Symbol>;
 
             fn dispatch(&mut self, mut buf: Buffer) -> Buffer {
                 let Dispatcher { handle_store, server } = self;
@@ -136,7 +125,7 @@ macro_rules! define_dispatcher_impl {
         }
     }
 }
-with_api!(Self, self_, define_dispatcher_impl);
+with_api!(Self, define_server_dispatcher_impl);
 
 pub trait ExecutionStrategy {
     fn run_bridge_and_client(
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib.rs
index 8680e9180e3ab..9a65538675fe9 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib.rs
@@ -48,7 +48,7 @@ impl Expander {
         callback: Option<ProcMacroClientHandle<'_>>,
     ) -> Result<TokenStream<S>, PanicMessage>
     where
-        <S::Server<'a> as bridge::server::Types>::TokenStream: Default,
+        <S::Server<'a> as bridge::server::Server>::TokenStream: Default,
     {
         self.inner
             .proc_macros
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
index ec30630c10bbe..eacb100fbc9fa 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
@@ -30,13 +30,11 @@ pub struct RaSpanServer<'a> {
     pub callback: Option<ProcMacroClientHandle<'a>>,
 }
 
-impl server::Types for RaSpanServer<'_> {
+impl server::Server for RaSpanServer<'_> {
     type TokenStream = crate::token_stream::TokenStream<Span>;
     type Span = Span;
     type Symbol = Symbol;
-}
 
-impl server::Server for RaSpanServer<'_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {
             def_site: self.def_site,
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
index 3bf07290c8c05..70484c4dc28fe 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
@@ -36,13 +36,11 @@ pub struct SpanIdServer<'a> {
     pub callback: Option<ProcMacroClientHandle<'a>>,
 }
 
-impl server::Types for SpanIdServer<'_> {
+impl server::Server for SpanIdServer<'_> {
     type TokenStream = crate::token_stream::TokenStream<Span>;
     type Span = Span;
     type Symbol = Symbol;
-}
 
-impl server::Server for SpanIdServer<'_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {
             def_site: self.def_site,

From 5fef797f6e8360b2457cb9a4133f59effb9c5d65 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 26 Jan 2026 14:00:39 +0000
Subject: [PATCH 02/16] inline `Writer` and `Reader` type aliases

---
 library/proc_macro/src/bridge/client.rs | 10 ++--
 library/proc_macro/src/bridge/mod.rs    |  5 +-
 library/proc_macro/src/bridge/rpc.rs    | 64 ++++++++++++-------------
 library/proc_macro/src/bridge/server.rs | 10 ++--
 library/proc_macro/src/bridge/symbol.rs |  8 ++--
 5 files changed, 48 insertions(+), 49 deletions(-)

diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index 381c8502c8538..83a3b21e35481 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -30,19 +30,19 @@ impl Drop for TokenStream {
 }
 
 impl<S> Encode<S> for TokenStream {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         mem::ManuallyDrop::new(self).handle.encode(w, s);
     }
 }
 
 impl<S> Encode<S> for &TokenStream {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.handle.encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for TokenStream {
-    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+    fn decode(r: &mut &[u8], s: &mut S) -> Self {
         TokenStream { handle: handle::Handle::decode(r, s) }
     }
 }
@@ -56,13 +56,13 @@ impl !Send for Span {}
 impl !Sync for Span {}
 
 impl<S> Encode<S> for Span {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.handle.encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for Span {
-    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+    fn decode(r: &mut &[u8], s: &mut S) -> Self {
         Span { handle: handle::Handle::decode(r, s) }
     }
 }
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index f454861be4ed1..006aa5f973fc5 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -113,7 +113,7 @@ mod symbol;
 
 use buffer::Buffer;
 pub use rpc::PanicMessage;
-use rpc::{Decode, Encode, Reader, Writer};
+use rpc::{Decode, Encode};
 
 /// Configuration for establishing an active connection between a server and a
 /// client.  The server creates the bridge config (`run_server` in `server.rs`),
@@ -138,7 +138,8 @@ impl !Sync for BridgeConfig<'_> {}
 #[forbid(unsafe_code)]
 #[allow(non_camel_case_types)]
 mod api_tags {
-    use super::rpc::{Decode, Encode, Reader, Writer};
+    use super::buffer::Buffer;
+    use super::rpc::{Decode, Encode};
 
     macro_rules! declare_tags {
         (
diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs
index ed67674a74ab7..254b176e19c59 100644
--- a/library/proc_macro/src/bridge/rpc.rs
+++ b/library/proc_macro/src/bridge/rpc.rs
@@ -4,28 +4,26 @@ use std::any::Any;
 use std::io::Write;
 use std::num::NonZero;
 
-pub(super) type Writer = super::buffer::Buffer;
+use super::buffer::Buffer;
 
 pub(super) trait Encode<S>: Sized {
-    fn encode(self, w: &mut Writer, s: &mut S);
+    fn encode(self, w: &mut Buffer, s: &mut S);
 }
 
-pub(super) type Reader<'a> = &'a [u8];
-
 pub(super) trait Decode<'a, 's, S>: Sized {
-    fn decode(r: &mut Reader<'a>, s: &'s mut S) -> Self;
+    fn decode(r: &mut &'a [u8], s: &'s mut S) -> Self;
 }
 
 macro_rules! rpc_encode_decode {
     (le $ty:ty) => {
         impl<S> Encode<S> for $ty {
-            fn encode(self, w: &mut Writer, _: &mut S) {
+            fn encode(self, w: &mut Buffer, _: &mut S) {
                 w.extend_from_array(&self.to_le_bytes());
             }
         }
 
         impl<S> Decode<'_, '_, S> for $ty {
-            fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
+            fn decode(r: &mut &[u8], _: &mut S) -> Self {
                 const N: usize = size_of::<$ty>();
 
                 let mut bytes = [0; N];
@@ -38,7 +36,7 @@ macro_rules! rpc_encode_decode {
     };
     (struct $name:ident $(<$($T:ident),+>)? { $($field:ident),* $(,)? }) => {
         impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {
-            fn encode(self, w: &mut Writer, s: &mut S) {
+            fn encode(self, w: &mut Buffer, s: &mut S) {
                 $(self.$field.encode(w, s);)*
             }
         }
@@ -46,7 +44,7 @@ macro_rules! rpc_encode_decode {
         impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>
             for $name $(<$($T),+>)?
         {
-            fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
+            fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
                 $name {
                     $($field: Decode::decode(r, s)),*
                 }
@@ -55,7 +53,7 @@ macro_rules! rpc_encode_decode {
     };
     (enum $name:ident $(<$($T:ident),+>)? { $($variant:ident $(($field:ident))*),* $(,)? }) => {
         impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {
-            fn encode(self, w: &mut Writer, s: &mut S) {
+            fn encode(self, w: &mut Buffer, s: &mut S) {
                 // HACK(eddyb): `Tag` enum duplicated between the
                 // two impls as there's no other place to stash it.
                 #[repr(u8)] enum Tag { $($variant),* }
@@ -72,7 +70,7 @@ macro_rules! rpc_encode_decode {
         impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>
             for $name $(<$($T),+>)?
         {
-            fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
+            fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
                 // HACK(eddyb): `Tag` enum duplicated between the
                 // two impls as there's no other place to stash it.
                 #[allow(non_upper_case_globals)]
@@ -95,21 +93,21 @@ macro_rules! rpc_encode_decode {
 }
 
 impl<S> Encode<S> for () {
-    fn encode(self, _: &mut Writer, _: &mut S) {}
+    fn encode(self, _: &mut Buffer, _: &mut S) {}
 }
 
 impl<S> Decode<'_, '_, S> for () {
-    fn decode(_: &mut Reader<'_>, _: &mut S) -> Self {}
+    fn decode(_: &mut &[u8], _: &mut S) -> Self {}
 }
 
 impl<S> Encode<S> for u8 {
-    fn encode(self, w: &mut Writer, _: &mut S) {
+    fn encode(self, w: &mut Buffer, _: &mut S) {
         w.push(self);
     }
 }
 
 impl<S> Decode<'_, '_, S> for u8 {
-    fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
+    fn decode(r: &mut &[u8], _: &mut S) -> Self {
         let x = r[0];
         *r = &r[1..];
         x
@@ -120,13 +118,13 @@ rpc_encode_decode!(le u32);
 rpc_encode_decode!(le usize);
 
 impl<S> Encode<S> for bool {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         (self as u8).encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for bool {
-    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+    fn decode(r: &mut &[u8], s: &mut S) -> Self {
         match u8::decode(r, s) {
             0 => false,
             1 => true,
@@ -136,31 +134,31 @@ impl<S> Decode<'_, '_, S> for bool {
 }
 
 impl<S> Encode<S> for char {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         (self as u32).encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for char {
-    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+    fn decode(r: &mut &[u8], s: &mut S) -> Self {
         char::from_u32(u32::decode(r, s)).unwrap()
     }
 }
 
 impl<S> Encode<S> for NonZero<u32> {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.get().encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for NonZero<u32> {
-    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+    fn decode(r: &mut &[u8], s: &mut S) -> Self {
         Self::new(u32::decode(r, s)).unwrap()
     }
 }
 
 impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.0.encode(w, s);
         self.1.encode(w, s);
     }
@@ -169,20 +167,20 @@ impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {
 impl<'a, S, A: for<'s> Decode<'a, 's, S>, B: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S>
     for (A, B)
 {
-    fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
+    fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
         (Decode::decode(r, s), Decode::decode(r, s))
     }
 }
 
 impl<S> Encode<S> for &[u8] {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.len().encode(w, s);
         w.write_all(self).unwrap();
     }
 }
 
 impl<'a, S> Decode<'a, '_, S> for &'a [u8] {
-    fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
+    fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
         let len = usize::decode(r, s);
         let xs = &r[..len];
         *r = &r[len..];
@@ -191,31 +189,31 @@ impl<'a, S> Decode<'a, '_, S> for &'a [u8] {
 }
 
 impl<S> Encode<S> for &str {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.as_bytes().encode(w, s);
     }
 }
 
 impl<'a, S> Decode<'a, '_, S> for &'a str {
-    fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
+    fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
         str::from_utf8(<&[u8]>::decode(r, s)).unwrap()
     }
 }
 
 impl<S> Encode<S> for String {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self[..].encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for String {
-    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+    fn decode(r: &mut &[u8], s: &mut S) -> Self {
         <&str>::decode(r, s).to_string()
     }
 }
 
 impl<S, T: Encode<S>> Encode<S> for Vec<T> {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.len().encode(w, s);
         for x in self {
             x.encode(w, s);
@@ -224,7 +222,7 @@ impl<S, T: Encode<S>> Encode<S> for Vec<T> {
 }
 
 impl<'a, S, T: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S> for Vec<T> {
-    fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
+    fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
         let len = usize::decode(r, s);
         let mut vec = Vec::with_capacity(len);
         for _ in 0..len {
@@ -278,13 +276,13 @@ impl PanicMessage {
 }
 
 impl<S> Encode<S> for PanicMessage {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.as_str().encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for PanicMessage {
-    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+    fn decode(r: &mut &[u8], s: &mut S) -> Self {
         match Option::<String>::decode(r, s) {
             Some(s) => PanicMessage::String(s),
             None => PanicMessage::Unknown,
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 2fed45d3a0ab6..8f31d7aa9f55f 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -20,13 +20,13 @@ impl<S: Server> HandleStore<S> {
 }
 
 impl<S: Server> Encode<HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
-    fn encode(self, w: &mut Writer, s: &mut HandleStore<S>) {
+    fn encode(self, w: &mut Buffer, s: &mut HandleStore<S>) {
         s.token_stream.alloc(self).encode(w, s);
     }
 }
 
 impl<S: Server> Decode<'_, '_, HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
-    fn decode(r: &mut Reader<'_>, s: &mut HandleStore<S>) -> Self {
+    fn decode(r: &mut &[u8], s: &mut HandleStore<S>) -> Self {
         s.token_stream.take(handle::Handle::decode(r, &mut ()))
     }
 }
@@ -34,19 +34,19 @@ impl<S: Server> Decode<'_, '_, HandleStore<S>> for Marked<S::TokenStream, client
 impl<'s, S: Server> Decode<'_, 's, HandleStore<S>>
     for &'s Marked<S::TokenStream, client::TokenStream>
 {
-    fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<S>) -> Self {
+    fn decode(r: &mut &[u8], s: &'s mut HandleStore<S>) -> Self {
         &s.token_stream[handle::Handle::decode(r, &mut ())]
     }
 }
 
 impl<S: Server> Encode<HandleStore<S>> for Marked<S::Span, client::Span> {
-    fn encode(self, w: &mut Writer, s: &mut HandleStore<S>) {
+    fn encode(self, w: &mut Buffer, s: &mut HandleStore<S>) {
         s.span.alloc(self).encode(w, s);
     }
 }
 
 impl<S: Server> Decode<'_, '_, HandleStore<S>> for Marked<S::Span, client::Span> {
-    fn decode(r: &mut Reader<'_>, s: &mut HandleStore<S>) -> Self {
+    fn decode(r: &mut &[u8], s: &mut HandleStore<S>) -> Self {
         s.span.copy(handle::Handle::decode(r, &mut ()))
     }
 }
diff --git a/library/proc_macro/src/bridge/symbol.rs b/library/proc_macro/src/bridge/symbol.rs
index edba142bad721..02b1d351ac161 100644
--- a/library/proc_macro/src/bridge/symbol.rs
+++ b/library/proc_macro/src/bridge/symbol.rs
@@ -94,25 +94,25 @@ impl fmt::Display for Symbol {
 }
 
 impl<S> Encode<S> for Symbol {
-    fn encode(self, w: &mut Writer, s: &mut S) {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
         self.with(|sym| sym.encode(w, s))
     }
 }
 
 impl<S: server::Server> Decode<'_, '_, server::HandleStore<S>> for Marked<S::Symbol, Symbol> {
-    fn decode(r: &mut Reader<'_>, s: &mut server::HandleStore<S>) -> Self {
+    fn decode(r: &mut &[u8], s: &mut server::HandleStore<S>) -> Self {
         Mark::mark(S::intern_symbol(<&str>::decode(r, s)))
     }
 }
 
 impl<S: server::Server> Encode<server::HandleStore<S>> for Marked<S::Symbol, Symbol> {
-    fn encode(self, w: &mut Writer, s: &mut server::HandleStore<S>) {
+    fn encode(self, w: &mut Buffer, s: &mut server::HandleStore<S>) {
         S::with_symbol_string(&self.unmark(), |sym| sym.encode(w, s))
     }
 }
 
 impl<S> Decode<'_, '_, S> for Symbol {
-    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+    fn decode(r: &mut &[u8], s: &mut S) -> Self {
         Symbol::new(<&str>::decode(r, s))
     }
 }

From f8d05b6c855f64e11dc9bdec4db21bd4c3c6a969 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 26 Jan 2026 14:43:50 +0000
Subject: [PATCH 03/16] flatten the `api_tags` module

---
 library/proc_macro/src/bridge/client.rs |  2 +-
 library/proc_macro/src/bridge/mod.rs    | 24 +++++++++---------------
 library/proc_macro/src/bridge/rpc.rs    |  6 ++++--
 library/proc_macro/src/bridge/server.rs |  4 ++--
 4 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index 83a3b21e35481..8f4a79b389f62 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -106,7 +106,7 @@ macro_rules! define_client_side {
                     let mut buf = bridge.cached_buffer.take();
 
                     buf.clear();
-                    api_tags::Method::$method.encode(&mut buf, &mut ());
+                    ApiTags::$method.encode(&mut buf, &mut ());
                     $($arg.encode(&mut buf, &mut ());)*
 
                     buf = bridge.dispatch.call(buf);
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 006aa5f973fc5..cf6ffd86f4144 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -135,24 +135,18 @@ pub struct BridgeConfig<'a> {
 impl !Send for BridgeConfig<'_> {}
 impl !Sync for BridgeConfig<'_> {}
 
-#[forbid(unsafe_code)]
-#[allow(non_camel_case_types)]
-mod api_tags {
-    use super::buffer::Buffer;
-    use super::rpc::{Decode, Encode};
-
-    macro_rules! declare_tags {
-        (
-            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
-        ) => {
-            pub(super) enum Method {
-                $($method),*
-            }
-            rpc_encode_decode!(enum Method { $($method),* });
+macro_rules! declare_tags {
+    (
+        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
+    ) => {
+        #[allow(non_camel_case_types)]
+        pub(super) enum ApiTags {
+            $($method),*
         }
+        rpc_encode_decode!(enum ApiTags { $($method),* });
     }
-    with_api!(self, declare_tags);
 }
+with_api!(self, declare_tags);
 
 /// Helper to wrap associated types to allow trait impl dispatch.
 /// That is, normally a pair of impls for `T::Foo` and `T::Bar`
diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs
index 254b176e19c59..5786c62d94643 100644
--- a/library/proc_macro/src/bridge/rpc.rs
+++ b/library/proc_macro/src/bridge/rpc.rs
@@ -56,7 +56,9 @@ macro_rules! rpc_encode_decode {
             fn encode(self, w: &mut Buffer, s: &mut S) {
                 // HACK(eddyb): `Tag` enum duplicated between the
                 // two impls as there's no other place to stash it.
-                #[repr(u8)] enum Tag { $($variant),* }
+                #[allow(non_camel_case_types)]
+                #[repr(u8)]
+                enum Tag { $($variant),* }
 
                 match self {
                     $($name::$variant $(($field))* => {
@@ -73,7 +75,7 @@ macro_rules! rpc_encode_decode {
             fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
                 // HACK(eddyb): `Tag` enum duplicated between the
                 // two impls as there's no other place to stash it.
-                #[allow(non_upper_case_globals)]
+                #[allow(non_upper_case_globals, non_camel_case_types)]
                 mod tag {
                     #[repr(u8)] enum Tag { $($variant),* }
 
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 8f31d7aa9f55f..f477fa28798d2 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -95,8 +95,8 @@ macro_rules! define_server_dispatcher_impl {
                 let Dispatcher { handle_store, server } = self;
 
                 let mut reader = &buf[..];
-                match api_tags::Method::decode(&mut reader, &mut ()) {
-                    $(api_tags::Method::$method => {
+                match ApiTags::decode(&mut reader, &mut ()) {
+                    $(ApiTags::$method => {
                         let mut call_method = || {
                             $(let $arg = <$arg_ty>::decode(&mut reader, handle_store).unmark();)*
                             let r = server.$method($($arg),*);

From d5328c545a0cad33053369ddbc0e5f27aa2924aa Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 26 Jan 2026 14:58:29 +0000
Subject: [PATCH 04/16] introduce `MarkedX` type aliases

---
 library/proc_macro/src/bridge/server.rs | 43 +++++++++++--------------
 library/proc_macro/src/bridge/symbol.rs |  4 +--
 2 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index f477fa28798d2..073ddb554994c 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -6,8 +6,8 @@ use std::marker::PhantomData;
 use super::*;
 
 pub(super) struct HandleStore<S: Server> {
-    token_stream: handle::OwnedStore<Marked<S::TokenStream, client::TokenStream>>,
-    span: handle::InternedStore<Marked<S::Span, client::Span>>,
+    token_stream: handle::OwnedStore<MarkedTokenStream<S>>,
+    span: handle::InternedStore<MarkedSpan<S>>,
 }
 
 impl<S: Server> HandleStore<S> {
@@ -19,33 +19,35 @@ impl<S: Server> HandleStore<S> {
     }
 }
 
-impl<S: Server> Encode<HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
+pub(super) type MarkedTokenStream<S> = Marked<<S as Server>::TokenStream, client::TokenStream>;
+pub(super) type MarkedSpan<S> = Marked<<S as Server>::Span, client::Span>;
+pub(super) type MarkedSymbol<S> = Marked<<S as Server>::Symbol, client::Symbol>;
+
+impl<S: Server> Encode<HandleStore<S>> for MarkedTokenStream<S> {
     fn encode(self, w: &mut Buffer, s: &mut HandleStore<S>) {
         s.token_stream.alloc(self).encode(w, s);
     }
 }
 
-impl<S: Server> Decode<'_, '_, HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
+impl<S: Server> Decode<'_, '_, HandleStore<S>> for MarkedTokenStream<S> {
     fn decode(r: &mut &[u8], s: &mut HandleStore<S>) -> Self {
         s.token_stream.take(handle::Handle::decode(r, &mut ()))
     }
 }
 
-impl<'s, S: Server> Decode<'_, 's, HandleStore<S>>
-    for &'s Marked<S::TokenStream, client::TokenStream>
-{
+impl<'s, S: Server> Decode<'_, 's, HandleStore<S>> for &'s MarkedTokenStream<S> {
     fn decode(r: &mut &[u8], s: &'s mut HandleStore<S>) -> Self {
         &s.token_stream[handle::Handle::decode(r, &mut ())]
     }
 }
 
-impl<S: Server> Encode<HandleStore<S>> for Marked<S::Span, client::Span> {
+impl<S: Server> Encode<HandleStore<S>> for MarkedSpan<S> {
     fn encode(self, w: &mut Buffer, s: &mut HandleStore<S>) {
         s.span.alloc(self).encode(w, s);
     }
 }
 
-impl<S: Server> Decode<'_, '_, HandleStore<S>> for Marked<S::Span, client::Span> {
+impl<S: Server> Decode<'_, '_, HandleStore<S>> for MarkedSpan<S> {
     fn decode(r: &mut &[u8], s: &mut HandleStore<S>) -> Self {
         s.span.copy(handle::Handle::decode(r, &mut ()))
     }
@@ -87,9 +89,9 @@ macro_rules! define_server_dispatcher_impl {
         }
 
         impl<S: Server> DispatcherTrait for Dispatcher<S> {
-            type TokenStream = Marked<S::TokenStream, client::TokenStream>;
-            type Span = Marked<S::Span, client::Span>;
-            type Symbol = Marked<S::Symbol, client::Symbol>;
+            type TokenStream = MarkedTokenStream<S>;
+            type Span = MarkedSpan<S>;
+            type Symbol = MarkedSymbol<S>;
 
             fn dispatch(&mut self, mut buf: Buffer) -> Buffer {
                 let Dispatcher { handle_store, server } = self;
@@ -292,7 +294,7 @@ fn run_server<
     let globals = dispatcher.server.globals();
 
     let mut buf = Buffer::new();
-    (<ExpnGlobals<Marked<S::Span, client::Span>> as Mark>::mark(globals), input)
+    (<ExpnGlobals<MarkedSpan<S>> as Mark>::mark(globals), input)
         .encode(&mut buf, &mut dispatcher.handle_store);
 
     buf = strategy.run_bridge_and_client(&mut dispatcher, buf, run_client, force_show_panics);
@@ -317,13 +319,11 @@ impl client::Client<crate::TokenStream, crate::TokenStream> {
             strategy,
             handle_counters,
             server,
-            <Marked<S::TokenStream, client::TokenStream>>::mark(input),
+            <MarkedTokenStream<S>>::mark(input),
             run,
             force_show_panics,
         )
-        .map(|s| {
-            <Option<Marked<S::TokenStream, client::TokenStream>>>::unmark(s).unwrap_or_default()
-        })
+        .map(|s| <Option<MarkedTokenStream<S>>>::unmark(s).unwrap_or_default())
     }
 }
 
@@ -345,15 +345,10 @@ impl client::Client<(crate::TokenStream, crate::TokenStream), crate::TokenStream
             strategy,
             handle_counters,
             server,
-            (
-                <Marked<S::TokenStream, client::TokenStream>>::mark(input),
-                <Marked<S::TokenStream, client::TokenStream>>::mark(input2),
-            ),
+            (<MarkedTokenStream<S>>::mark(input), <MarkedTokenStream<S>>::mark(input2)),
             run,
             force_show_panics,
         )
-        .map(|s| {
-            <Option<Marked<S::TokenStream, client::TokenStream>>>::unmark(s).unwrap_or_default()
-        })
+        .map(|s| <Option<MarkedTokenStream<S>>>::unmark(s).unwrap_or_default())
     }
 }
diff --git a/library/proc_macro/src/bridge/symbol.rs b/library/proc_macro/src/bridge/symbol.rs
index 02b1d351ac161..2a04f7d808bd5 100644
--- a/library/proc_macro/src/bridge/symbol.rs
+++ b/library/proc_macro/src/bridge/symbol.rs
@@ -99,13 +99,13 @@ impl<S> Encode<S> for Symbol {
     }
 }
 
-impl<S: server::Server> Decode<'_, '_, server::HandleStore<S>> for Marked<S::Symbol, Symbol> {
+impl<S: server::Server> Decode<'_, '_, server::HandleStore<S>> for server::MarkedSymbol<S> {
     fn decode(r: &mut &[u8], s: &mut server::HandleStore<S>) -> Self {
         Mark::mark(S::intern_symbol(<&str>::decode(r, s)))
     }
 }
 
-impl<S: server::Server> Encode<server::HandleStore<S>> for Marked<S::Symbol, Symbol> {
+impl<S: server::Server> Encode<server::HandleStore<S>> for server::MarkedSymbol<S> {
     fn encode(self, w: &mut Buffer, s: &mut server::HandleStore<S>) {
         S::with_symbol_string(&self.unmark(), |sym| sym.encode(w, s))
     }

From 356107e0b46182a080ab4876282cebbb97e33b1a Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 26 Jan 2026 14:27:18 +0000
Subject: [PATCH 05/16] remove some unneeded impls

---
 library/proc_macro/src/bridge/mod.rs | 17 +-------------
 library/proc_macro/src/bridge/rpc.rs | 35 +++++-----------------------
 2 files changed, 7 insertions(+), 45 deletions(-)

diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index cf6ffd86f4144..97e36a3d70c17 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -13,7 +13,7 @@ use std::ops::{Bound, Range};
 use std::sync::Once;
 use std::{fmt, marker, mem, panic, thread};
 
-use crate::{Delimiter, Level, Spacing};
+use crate::{Delimiter, Level};
 
 /// Higher-order macro describing the server RPC API, allowing automatic
 /// generation of type-safe Rust APIs, both client-side and server-side.
@@ -187,12 +187,6 @@ impl<'a, T, M> Unmark for &'a Marked<T, M> {
         &self.value
     }
 }
-impl<'a, T, M> Unmark for &'a mut Marked<T, M> {
-    type Unmarked = &'a mut T;
-    fn unmark(self) -> Self::Unmarked {
-        &mut self.value
-    }
-}
 
 impl<T: Mark> Mark for Vec<T> {
     type Unmarked = Vec<T::Unmarked>;
@@ -230,8 +224,6 @@ macro_rules! mark_noop {
 mark_noop! {
     (),
     bool,
-    char,
-    &'_ [u8],
     &'_ str,
     String,
     u8,
@@ -239,7 +231,6 @@ mark_noop! {
     Delimiter,
     LitKind,
     Level,
-    Spacing,
 }
 
 rpc_encode_decode!(
@@ -258,12 +249,6 @@ rpc_encode_decode!(
         Help,
     }
 );
-rpc_encode_decode!(
-    enum Spacing {
-        Alone,
-        Joint,
-    }
-);
 
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum LitKind {
diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs
index 5786c62d94643..63329c8c02601 100644
--- a/library/proc_macro/src/bridge/rpc.rs
+++ b/library/proc_macro/src/bridge/rpc.rs
@@ -135,18 +135,6 @@ impl<S> Decode<'_, '_, S> for bool {
     }
 }
 
-impl<S> Encode<S> for char {
-    fn encode(self, w: &mut Buffer, s: &mut S) {
-        (self as u32).encode(w, s);
-    }
-}
-
-impl<S> Decode<'_, '_, S> for char {
-    fn decode(r: &mut &[u8], s: &mut S) -> Self {
-        char::from_u32(u32::decode(r, s)).unwrap()
-    }
-}
-
 impl<S> Encode<S> for NonZero<u32> {
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self.get().encode(w, s);
@@ -174,31 +162,20 @@ impl<'a, S, A: for<'s> Decode<'a, 's, S>, B: for<'s> Decode<'a, 's, S>> Decode<'
     }
 }
 
-impl<S> Encode<S> for &[u8] {
+impl<S> Encode<S> for &str {
     fn encode(self, w: &mut Buffer, s: &mut S) {
-        self.len().encode(w, s);
-        w.write_all(self).unwrap();
+        let bytes = self.as_bytes();
+        bytes.len().encode(w, s);
+        w.write_all(bytes).unwrap();
     }
 }
 
-impl<'a, S> Decode<'a, '_, S> for &'a [u8] {
+impl<'a, S> Decode<'a, '_, S> for &'a str {
     fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
         let len = usize::decode(r, s);
         let xs = &r[..len];
         *r = &r[len..];
-        xs
-    }
-}
-
-impl<S> Encode<S> for &str {
-    fn encode(self, w: &mut Buffer, s: &mut S) {
-        self.as_bytes().encode(w, s);
-    }
-}
-
-impl<'a, S> Decode<'a, '_, S> for &'a str {
-    fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
-        str::from_utf8(<&[u8]>::decode(r, s)).unwrap()
+        str::from_utf8(xs).unwrap()
     }
 }
 

From 6e7a87c5c5a20d43e254986724e4d781556d8a53 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 26 Jan 2026 15:24:22 +0000
Subject: [PATCH 06/16] merge `Mark` and `Unmark` traits

---
 library/proc_macro/src/bridge/mod.rs | 31 ++++++----------------------
 1 file changed, 6 insertions(+), 25 deletions(-)

diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 97e36a3d70c17..244ab7d81b022 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -155,11 +155,6 @@ with_api!(self, declare_tags);
 trait Mark {
     type Unmarked;
     fn mark(unmarked: Self::Unmarked) -> Self;
-}
-
-/// Unwrap types wrapped by `Mark::mark` (see `Mark` for details).
-trait Unmark {
-    type Unmarked;
     fn unmark(self) -> Self::Unmarked;
 }
 
@@ -174,15 +169,15 @@ impl<T, M> Mark for Marked<T, M> {
     fn mark(unmarked: Self::Unmarked) -> Self {
         Marked { value: unmarked, _marker: marker::PhantomData }
     }
-}
-impl<T, M> Unmark for Marked<T, M> {
-    type Unmarked = T;
     fn unmark(self) -> Self::Unmarked {
         self.value
     }
 }
-impl<'a, T, M> Unmark for &'a Marked<T, M> {
+impl<'a, T, M> Mark for &'a Marked<T, M> {
     type Unmarked = &'a T;
+    fn mark(_: Self::Unmarked) -> Self {
+        unreachable!()
+    }
     fn unmark(self) -> Self::Unmarked {
         &self.value
     }
@@ -194,9 +189,6 @@ impl<T: Mark> Mark for Vec<T> {
         // Should be a no-op due to std's in-place collect optimizations.
         unmarked.into_iter().map(T::mark).collect()
     }
-}
-impl<T: Unmark> Unmark for Vec<T> {
-    type Unmarked = Vec<T::Unmarked>;
     fn unmark(self) -> Self::Unmarked {
         // Should be a no-op due to std's in-place collect optimizations.
         self.into_iter().map(T::unmark).collect()
@@ -211,9 +203,6 @@ macro_rules! mark_noop {
                 fn mark(unmarked: Self::Unmarked) -> Self {
                     unmarked
                 }
-            }
-            impl Unmark for $ty {
-                type Unmarked = Self;
                 fn unmark(self) -> Self::Unmarked {
                     self
                 }
@@ -294,13 +283,9 @@ macro_rules! mark_compound {
                     $($field: Mark::mark(unmarked.$field)),*
                 }
             }
-        }
-
-        impl<$($T: Unmark),+> Unmark for $name <$($T),+> {
-            type Unmarked = $name <$($T::Unmarked),+>;
             fn unmark(self) -> Self::Unmarked {
                 $name {
-                    $($field: Unmark::unmark(self.$field)),*
+                    $($field: Mark::unmark(self.$field)),*
                 }
             }
         }
@@ -315,14 +300,10 @@ macro_rules! mark_compound {
                     })*
                 }
             }
-        }
-
-        impl<$($T: Unmark),+> Unmark for $name <$($T),+> {
-            type Unmarked = $name <$($T::Unmarked),+>;
             fn unmark(self) -> Self::Unmarked {
                 match self {
                     $($name::$variant $(($field))? => {
-                        $name::$variant $((Unmark::unmark($field)))?
+                        $name::$variant $((Mark::unmark($field)))?
                     })*
                 }
             }

From 814d902c503920334e3b992cb3d208b9742e24f3 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 14:27:10 +0100
Subject: [PATCH 07/16] std: move time implementations to `sys` (preparation)

---
 library/std/src/sys/mod.rs      | 1 +
 library/std/src/sys/time/mod.rs | 4 ++++
 2 files changed, 5 insertions(+)
 create mode 100644 library/std/src/sys/time/mod.rs

diff --git a/library/std/src/sys/mod.rs b/library/std/src/sys/mod.rs
index c9035938cfdd3..5436c144d3330 100644
--- a/library/std/src/sys/mod.rs
+++ b/library/std/src/sys/mod.rs
@@ -26,6 +26,7 @@ pub mod stdio;
 pub mod sync;
 pub mod thread;
 pub mod thread_local;
+pub mod time;
 
 // FIXME(117276): remove this, move feature implementations into individual
 //                submodules.
diff --git a/library/std/src/sys/time/mod.rs b/library/std/src/sys/time/mod.rs
new file mode 100644
index 0000000000000..015871e6f1ec5
--- /dev/null
+++ b/library/std/src/sys/time/mod.rs
@@ -0,0 +1,4 @@
+cfg_select! {
+}
+
+pub use imp::{Instant, SystemTime, UNIX_EPOCH};

From 29b16c0a55e14504ec24eddc0a3ace7074687ce4 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 14:38:41 +0100
Subject: [PATCH 08/16] std: move time implementations to `sys` (small
 platforms)

Let's start with the easy ones:
* Motor just reexports its platform library
* The SGX code is just a trivial move
* Trusty, WASM and ZKVM are unsupported, this is very trivial. And we can get
  rid of some `#[path = ...]`s, yay!
---
 library/std/src/sys/pal/motor/mod.rs              |  1 -
 library/std/src/sys/pal/motor/time.rs             |  1 -
 library/std/src/sys/pal/sgx/mod.rs                |  1 -
 library/std/src/sys/pal/trusty/mod.rs             |  2 --
 library/std/src/sys/pal/unsupported/mod.rs        |  1 -
 library/std/src/sys/pal/wasm/mod.rs               |  2 --
 library/std/src/sys/pal/xous/mod.rs               |  1 -
 library/std/src/sys/pal/zkvm/mod.rs               |  2 --
 library/std/src/sys/time/mod.rs                   | 15 +++++++++++++++
 .../std/src/sys/{pal/sgx/time.rs => time/sgx.rs}  |  2 +-
 .../unsupported/time.rs => time/unsupported.rs}   |  0
 .../src/sys/{pal/xous/time.rs => time/xous.rs}    |  0
 12 files changed, 16 insertions(+), 12 deletions(-)
 delete mode 100644 library/std/src/sys/pal/motor/time.rs
 rename library/std/src/sys/{pal/sgx/time.rs => time/sgx.rs} (97%)
 rename library/std/src/sys/{pal/unsupported/time.rs => time/unsupported.rs} (100%)
 rename library/std/src/sys/{pal/xous/time.rs => time/xous.rs} (100%)

diff --git a/library/std/src/sys/pal/motor/mod.rs b/library/std/src/sys/pal/motor/mod.rs
index e5b99cea01d55..a520375a4bbff 100644
--- a/library/std/src/sys/pal/motor/mod.rs
+++ b/library/std/src/sys/pal/motor/mod.rs
@@ -1,7 +1,6 @@
 #![allow(unsafe_op_in_unsafe_fn)]
 
 pub mod os;
-pub mod time;
 
 pub use moto_rt::futex;
 
diff --git a/library/std/src/sys/pal/motor/time.rs b/library/std/src/sys/pal/motor/time.rs
deleted file mode 100644
index e917fd466c2e4..0000000000000
--- a/library/std/src/sys/pal/motor/time.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub use moto_rt::time::{Instant, SystemTime, UNIX_EPOCH};
diff --git a/library/std/src/sys/pal/sgx/mod.rs b/library/std/src/sys/pal/sgx/mod.rs
index 7f1c81a0ff7bf..1de3ca4a5d79c 100644
--- a/library/std/src/sys/pal/sgx/mod.rs
+++ b/library/std/src/sys/pal/sgx/mod.rs
@@ -12,7 +12,6 @@ pub mod abi;
 mod libunwind_integration;
 pub mod os;
 pub mod thread_parking;
-pub mod time;
 pub mod waitqueue;
 
 // SAFETY: must be called only once during runtime initialization.
diff --git a/library/std/src/sys/pal/trusty/mod.rs b/library/std/src/sys/pal/trusty/mod.rs
index 76a3a75b10c1a..b785c2dbb7892 100644
--- a/library/std/src/sys/pal/trusty/mod.rs
+++ b/library/std/src/sys/pal/trusty/mod.rs
@@ -5,7 +5,5 @@
 mod common;
 #[path = "../unsupported/os.rs"]
 pub mod os;
-#[path = "../unsupported/time.rs"]
-pub mod time;
 
 pub use common::*;
diff --git a/library/std/src/sys/pal/unsupported/mod.rs b/library/std/src/sys/pal/unsupported/mod.rs
index c33d2e5fb02a1..0f157819d5a66 100644
--- a/library/std/src/sys/pal/unsupported/mod.rs
+++ b/library/std/src/sys/pal/unsupported/mod.rs
@@ -1,7 +1,6 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 
 pub mod os;
-pub mod time;
 
 mod common;
 pub use common::*;
diff --git a/library/std/src/sys/pal/wasm/mod.rs b/library/std/src/sys/pal/wasm/mod.rs
index 80429a9aae18d..5f56eddd6a819 100644
--- a/library/std/src/sys/pal/wasm/mod.rs
+++ b/library/std/src/sys/pal/wasm/mod.rs
@@ -18,8 +18,6 @@
 
 #[path = "../unsupported/os.rs"]
 pub mod os;
-#[path = "../unsupported/time.rs"]
-pub mod time;
 
 #[cfg(target_feature = "atomics")]
 #[path = "atomics/futex.rs"]
diff --git a/library/std/src/sys/pal/xous/mod.rs b/library/std/src/sys/pal/xous/mod.rs
index 19575220b22ee..87c99068929c3 100644
--- a/library/std/src/sys/pal/xous/mod.rs
+++ b/library/std/src/sys/pal/xous/mod.rs
@@ -1,7 +1,6 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
 pub mod os;
-pub mod time;
 
 #[path = "../unsupported/common.rs"]
 mod common;
diff --git a/library/std/src/sys/pal/zkvm/mod.rs b/library/std/src/sys/pal/zkvm/mod.rs
index f09020820a031..1b18adb811d95 100644
--- a/library/std/src/sys/pal/zkvm/mod.rs
+++ b/library/std/src/sys/pal/zkvm/mod.rs
@@ -12,8 +12,6 @@ pub const WORD_SIZE: usize = size_of::<u32>();
 
 pub mod abi;
 pub mod os;
-#[path = "../unsupported/time.rs"]
-pub mod time;
 
 use crate::io as std_io;
 
diff --git a/library/std/src/sys/time/mod.rs b/library/std/src/sys/time/mod.rs
index 015871e6f1ec5..81c568bf93202 100644
--- a/library/std/src/sys/time/mod.rs
+++ b/library/std/src/sys/time/mod.rs
@@ -1,4 +1,19 @@
 cfg_select! {
+    target_os = "motor" => {
+        use moto_rt::time as imp;
+    }
+    all(target_vendor = "fortanix", target_env = "sgx") => {
+        mod sgx;
+        use sgx as imp;
+    }
+    target_os = "xous" => {
+        mod xous;
+        use xous as imp;
+    }
+    _ => {
+        mod unsupported;
+        use unsupported as imp;
+    }
 }
 
 pub use imp::{Instant, SystemTime, UNIX_EPOCH};
diff --git a/library/std/src/sys/pal/sgx/time.rs b/library/std/src/sys/time/sgx.rs
similarity index 97%
rename from library/std/src/sys/pal/sgx/time.rs
rename to library/std/src/sys/time/sgx.rs
index a9a448226619e..910e734c916e9 100644
--- a/library/std/src/sys/pal/sgx/time.rs
+++ b/library/std/src/sys/time/sgx.rs
@@ -1,4 +1,4 @@
-use super::abi::usercalls;
+use crate::sys::pal::abi::usercalls;
 use crate::time::Duration;
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
diff --git a/library/std/src/sys/pal/unsupported/time.rs b/library/std/src/sys/time/unsupported.rs
similarity index 100%
rename from library/std/src/sys/pal/unsupported/time.rs
rename to library/std/src/sys/time/unsupported.rs
diff --git a/library/std/src/sys/pal/xous/time.rs b/library/std/src/sys/time/xous.rs
similarity index 100%
rename from library/std/src/sys/pal/xous/time.rs
rename to library/std/src/sys/time/xous.rs

From 5978e194564d628afe2e54cc1068d0791a7e2e8d Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 14:57:03 +0100
Subject: [PATCH 09/16] std: move time implementations to `sys` (VEX)

Now that the `unsupported` module exists, we can use it for VEX. VEX actually
supports `Instant` though, so the implementation-select needs to combine that
with the `unsupported` module.
---
 library/std/src/sys/pal/vexos/mod.rs                   |  1 -
 library/std/src/sys/time/mod.rs                        | 10 ++++++++++
 .../std/src/sys/{pal/vexos/time.rs => time/vexos.rs}   |  5 -----
 3 files changed, 10 insertions(+), 6 deletions(-)
 rename library/std/src/sys/{pal/vexos/time.rs => time/vexos.rs} (83%)

diff --git a/library/std/src/sys/pal/vexos/mod.rs b/library/std/src/sys/pal/vexos/mod.rs
index 0abfc2fd79865..16aa3f088f04b 100644
--- a/library/std/src/sys/pal/vexos/mod.rs
+++ b/library/std/src/sys/pal/vexos/mod.rs
@@ -1,5 +1,4 @@
 pub mod os;
-pub mod time;
 
 #[expect(dead_code)]
 #[path = "../unsupported/common.rs"]
diff --git a/library/std/src/sys/time/mod.rs b/library/std/src/sys/time/mod.rs
index 81c568bf93202..0e3376e2f9106 100644
--- a/library/std/src/sys/time/mod.rs
+++ b/library/std/src/sys/time/mod.rs
@@ -6,6 +6,16 @@ cfg_select! {
         mod sgx;
         use sgx as imp;
     }
+    target_os = "vexos" => {
+        mod vexos;
+        #[expect(unused)]
+        mod unsupported;
+
+        mod imp {
+            pub use super::vexos::Instant;
+            pub use super::unsupported::{SystemTime, UNIX_EPOCH};
+        }
+    }
     target_os = "xous" => {
         mod xous;
         use xous as imp;
diff --git a/library/std/src/sys/pal/vexos/time.rs b/library/std/src/sys/time/vexos.rs
similarity index 83%
rename from library/std/src/sys/pal/vexos/time.rs
rename to library/std/src/sys/time/vexos.rs
index f95d96cd27ac0..966c239699cec 100644
--- a/library/std/src/sys/pal/vexos/time.rs
+++ b/library/std/src/sys/time/vexos.rs
@@ -1,10 +1,5 @@
 use crate::time::Duration;
 
-#[expect(dead_code)]
-#[path = "../unsupported/time.rs"]
-mod unsupported_time;
-pub use unsupported_time::{SystemTime, UNIX_EPOCH};
-
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 pub struct Instant(Duration);
 

From bd754c7119a73bfc5e9e0d23071ebffc2ebce245 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 14:47:05 +0100
Subject: [PATCH 10/16] std: move time implementations to `sys` (Solid)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On SOLID, the conversion functions are also used to implement helpers for
timeout conversion, so these stay in the PAL. The `Instant` (µITRON) and
`SystemTime` (SOLID-specific) implementations are merged into one. While it was
nice to have the µITRON parts in a separate module, there really isn't a need
for this currently, as there is no other µITRON target. Let's not worry about
this until such a target gets added...

Note that I've extracted the `get_tim` call from `Instant` into a wrapper
function in the PAL to avoid the need to make the inner `Instant` field public
for use in the PAL.
---
 library/std/src/sys/pal/itron/time.rs         | 47 +++++--------------
 library/std/src/sys/pal/solid/mod.rs          |  1 -
 library/std/src/sys/time/mod.rs               |  4 ++
 .../sys/{pal/solid/time.rs => time/solid.rs}  | 35 ++++++++++++--
 4 files changed, 47 insertions(+), 40 deletions(-)
 rename library/std/src/sys/{pal/solid/time.rs => time/solid.rs} (65%)

diff --git a/library/std/src/sys/pal/itron/time.rs b/library/std/src/sys/pal/itron/time.rs
index 7976c27f4952b..ff3cffd2069e9 100644
--- a/library/std/src/sys/pal/itron/time.rs
+++ b/library/std/src/sys/pal/itron/time.rs
@@ -3,38 +3,16 @@ use super::error::expect_success;
 use crate::mem::MaybeUninit;
 use crate::time::Duration;
 
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-pub struct Instant(abi::SYSTIM);
-
-impl Instant {
-    pub fn now() -> Instant {
-        // Safety: The provided pointer is valid
-        unsafe {
-            let mut out = MaybeUninit::uninit();
-            expect_success(abi::get_tim(out.as_mut_ptr()), &"get_tim");
-            Instant(out.assume_init())
-        }
-    }
-
-    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
-        self.0.checked_sub(other.0).map(|ticks| {
-            // `SYSTIM` is measured in microseconds
-            Duration::from_micros(ticks)
-        })
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-        // `SYSTIM` is measured in microseconds
-        let ticks = other.as_micros();
-
-        Some(Instant(self.0.checked_add(ticks.try_into().ok()?)?))
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
-        // `SYSTIM` is measured in microseconds
-        let ticks = other.as_micros();
+#[cfg(test)]
+mod tests;
 
-        Some(Instant(self.0.checked_sub(ticks.try_into().ok()?)?))
+#[inline]
+pub fn get_tim() -> abi::SYSTIM {
+    // Safety: The provided pointer is valid
+    unsafe {
+        let mut out = MaybeUninit::uninit();
+        expect_success(abi::get_tim(out.as_mut_ptr()), &"get_tim");
+        out.assume_init()
     }
 }
 
@@ -98,7 +76,7 @@ pub fn with_tmos_strong(dur: Duration, mut f: impl FnMut(abi::TMO) -> abi::ER) -
     // a problem in practice. (`u64::MAX` μs ≈ 584942 years)
     let ticks = dur.as_micros().min(abi::SYSTIM::MAX as u128) as abi::SYSTIM;
 
-    let start = Instant::now().0;
+    let start = get_tim();
     let mut elapsed = 0;
     let mut er = abi::E_TMOUT;
     while elapsed <= ticks {
@@ -106,11 +84,8 @@ pub fn with_tmos_strong(dur: Duration, mut f: impl FnMut(abi::TMO) -> abi::ER) -
         if er != abi::E_TMOUT {
             break;
         }
-        elapsed = Instant::now().0.wrapping_sub(start);
+        elapsed = get_tim().wrapping_sub(start);
     }
 
     er
 }
-
-#[cfg(test)]
-mod tests;
diff --git a/library/std/src/sys/pal/solid/mod.rs b/library/std/src/sys/pal/solid/mod.rs
index 4eec12dacd7ca..1376af8304cf6 100644
--- a/library/std/src/sys/pal/solid/mod.rs
+++ b/library/std/src/sys/pal/solid/mod.rs
@@ -21,7 +21,6 @@ pub mod itron {
 pub(crate) mod error;
 pub mod os;
 pub use self::itron::thread_parking;
-pub mod time;
 
 // SAFETY: must be called only once during runtime initialization.
 // NOTE: this is not guaranteed to run, for example when Rust code is called externally.
diff --git a/library/std/src/sys/time/mod.rs b/library/std/src/sys/time/mod.rs
index 0e3376e2f9106..e5b9a3a057f09 100644
--- a/library/std/src/sys/time/mod.rs
+++ b/library/std/src/sys/time/mod.rs
@@ -6,6 +6,10 @@ cfg_select! {
         mod sgx;
         use sgx as imp;
     }
+    target_os = "solid_asp3" => {
+        mod solid;
+        use solid as imp;
+    }
     target_os = "vexos" => {
         mod vexos;
         #[expect(unused)]
diff --git a/library/std/src/sys/pal/solid/time.rs b/library/std/src/sys/time/solid.rs
similarity index 65%
rename from library/std/src/sys/pal/solid/time.rs
rename to library/std/src/sys/time/solid.rs
index d5cf70f94c987..fa929c67241e3 100644
--- a/library/std/src/sys/pal/solid/time.rs
+++ b/library/std/src/sys/time/solid.rs
@@ -1,9 +1,38 @@
-use super::abi;
-use super::error::expect_success;
-pub use super::itron::time::Instant;
 use crate::mem::MaybeUninit;
+use crate::sys::pal::error::expect_success;
+use crate::sys::pal::{abi, itron};
 use crate::time::Duration;
 
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+pub struct Instant(itron::abi::SYSTIM);
+
+impl Instant {
+    pub fn now() -> Instant {
+        Instant(itron::time::get_tim())
+    }
+
+    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
+        self.0.checked_sub(other.0).map(|ticks| {
+            // `SYSTIM` is measured in microseconds
+            Duration::from_micros(ticks)
+        })
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+        // `SYSTIM` is measured in microseconds
+        let ticks = other.as_micros();
+
+        Some(Instant(self.0.checked_add(ticks.try_into().ok()?)?))
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        // `SYSTIM` is measured in microseconds
+        let ticks = other.as_micros();
+
+        Some(Instant(self.0.checked_sub(ticks.try_into().ok()?)?))
+    }
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 pub struct SystemTime(abi::time_t);
 

From 963f6029ce51ce1b0654620b80d7f8cb089b3142 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 14:53:52 +0100
Subject: [PATCH 11/16] std: move time implementations to `sys` (UEFI)

Next up: UEFI. Unfortunately the time conversion internals are also required by
the filesystem code, so I've left them in the PAL. The `Instant` internals
however are only used for the `Instant` implementation, so I've moved them to
`sys` (for now).
---
 library/std/src/sys/fs/uefi.rs                |   7 +-
 library/std/src/sys/pal/uefi/mod.rs           |   2 +-
 library/std/src/sys/pal/uefi/system_time.rs   | 151 +++++++++++++++
 library/std/src/sys/time/mod.rs               |   4 +
 .../sys/{pal/uefi/time.rs => time/uefi.rs}    | 172 +-----------------
 5 files changed, 168 insertions(+), 168 deletions(-)
 create mode 100644 library/std/src/sys/pal/uefi/system_time.rs
 rename library/std/src/sys/{pal/uefi/time.rs => time/uefi.rs} (52%)

diff --git a/library/std/src/sys/fs/uefi.rs b/library/std/src/sys/fs/uefi.rs
index a1bb0c6e828bd..8135519317a02 100644
--- a/library/std/src/sys/fs/uefi.rs
+++ b/library/std/src/sys/fs/uefi.rs
@@ -580,7 +580,8 @@ mod uefi_fs {
     use crate::path::Path;
     use crate::ptr::NonNull;
     use crate::sys::pal::helpers::{self, UefiBox};
-    use crate::sys::time::{self, SystemTime};
+    use crate::sys::pal::system_time;
+    use crate::sys::time::SystemTime;
 
     pub(crate) struct File {
         protocol: NonNull<file::Protocol>,
@@ -879,7 +880,7 @@ mod uefi_fs {
     /// conversion to SystemTime, we use the current time to get the timezone in such cases.
     pub(crate) fn uefi_to_systemtime(mut time: r_efi::efi::Time) -> Option<SystemTime> {
         time.timezone = if time.timezone == r_efi::efi::UNSPECIFIED_TIMEZONE {
-            time::system_time_internal::now().timezone
+            system_time::now().timezone
         } else {
             time.timezone
         };
@@ -888,7 +889,7 @@ mod uefi_fs {
 
     /// Convert to UEFI Time with the current timezone.
     pub(crate) fn systemtime_to_uefi(time: SystemTime) -> r_efi::efi::Time {
-        let now = time::system_time_internal::now();
+        let now = system_time::now();
         time.to_uefi_loose(now.timezone, now.daylight)
     }
 
diff --git a/library/std/src/sys/pal/uefi/mod.rs b/library/std/src/sys/pal/uefi/mod.rs
index b181d78c2345a..e4a8f50e4274d 100644
--- a/library/std/src/sys/pal/uefi/mod.rs
+++ b/library/std/src/sys/pal/uefi/mod.rs
@@ -15,7 +15,7 @@
 
 pub mod helpers;
 pub mod os;
-pub mod time;
+pub mod system_time;
 
 #[cfg(test)]
 mod tests;
diff --git a/library/std/src/sys/pal/uefi/system_time.rs b/library/std/src/sys/pal/uefi/system_time.rs
new file mode 100644
index 0000000000000..557a49b27c2d1
--- /dev/null
+++ b/library/std/src/sys/pal/uefi/system_time.rs
@@ -0,0 +1,151 @@
+use r_efi::efi::{RuntimeServices, Time};
+
+use super::helpers;
+use crate::mem::MaybeUninit;
+use crate::ptr::NonNull;
+use crate::time::Duration;
+
+const SECS_IN_MINUTE: u64 = 60;
+const SECS_IN_HOUR: u64 = SECS_IN_MINUTE * 60;
+const SECS_IN_DAY: u64 = SECS_IN_HOUR * 24;
+const SYSTEMTIME_TIMEZONE: i64 = -1440 * SECS_IN_MINUTE as i64;
+
+pub(crate) fn now() -> Time {
+    let runtime_services: NonNull<RuntimeServices> =
+        helpers::runtime_services().expect("Runtime services are not available");
+    let mut t: MaybeUninit<Time> = MaybeUninit::uninit();
+    let r =
+        unsafe { ((*runtime_services.as_ptr()).get_time)(t.as_mut_ptr(), crate::ptr::null_mut()) };
+    if r.is_error() {
+        panic!("time not implemented on this platform");
+    }
+
+    unsafe { t.assume_init() }
+}
+
+/// This algorithm is a modified form of the one described in the post
+/// https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.html
+///
+/// The changes are to use 1900-01-01-00:00:00 with timezone -1440 as anchor instead of UNIX
+/// epoch used in the original algorithm.
+pub(crate) const fn from_uefi(t: &Time) -> Option<Duration> {
+    if !(t.month <= 12
+        && t.month != 0
+        && t.year >= 1900
+        && t.year <= 9999
+        && t.day <= 31
+        && t.day != 0
+        && t.second < 60
+        && t.minute <= 60
+        && t.hour < 24
+        && t.nanosecond < 1_000_000_000
+        && ((t.timezone <= 1440 && t.timezone >= -1440)
+            || t.timezone == r_efi::efi::UNSPECIFIED_TIMEZONE))
+    {
+        return None;
+    }
+
+    const YEAR_BASE: u32 = 4800; /* Before min year, multiple of 400. */
+
+    // Calculate the number of days since 1/1/1900. This is the earliest supported date in UEFI
+    // time.
+    // Use 1 March as the start
+    let (m_adj, overflow): (u32, bool) = (t.month as u32).overflowing_sub(3);
+    let (carry, adjust): (u32, u32) = if overflow { (1, 12) } else { (0, 0) };
+    let y_adj: u32 = (t.year as u32) + YEAR_BASE - carry;
+    let month_days: u32 = (m_adj.wrapping_add(adjust) * 62719 + 769) / 2048;
+    let leap_days: u32 = y_adj / 4 - y_adj / 100 + y_adj / 400;
+    let days: u32 = y_adj * 365 + leap_days + month_days + (t.day as u32 - 1) - 2447065;
+
+    let localtime_epoch: u64 = (days as u64) * SECS_IN_DAY
+        + (t.second as u64)
+        + (t.minute as u64) * SECS_IN_MINUTE
+        + (t.hour as u64) * SECS_IN_HOUR;
+
+    let normalized_timezone = if t.timezone == r_efi::efi::UNSPECIFIED_TIMEZONE {
+        -SYSTEMTIME_TIMEZONE
+    } else {
+        (t.timezone as i64) * SECS_IN_MINUTE as i64 - SYSTEMTIME_TIMEZONE
+    };
+
+    // Calculate the offset from 1/1/1900 at timezone -1440 min
+    let epoch = localtime_epoch.checked_add_signed(normalized_timezone).unwrap();
+
+    Some(Duration::new(epoch, t.nanosecond))
+}
+
+/// This algorithm is a modified version of the one described in the post:
+/// https://howardhinnant.github.io/date_algorithms.html#clive_from_days
+///
+/// The changes are to use 1900-01-01-00:00:00 with timezone -1440 as anchor instead of UNIX
+/// epoch used in the original algorithm.
+pub(crate) const fn to_uefi(dur: &Duration, timezone: i16, daylight: u8) -> Result<Time, i16> {
+    const MIN_IN_HOUR: u64 = 60;
+    const MIN_IN_DAY: u64 = MIN_IN_HOUR * 24;
+
+    // Check timezone validity
+    assert!(timezone <= 1440 && timezone >= -1440);
+
+    // Convert to seconds since 1900-01-01-00:00:00 in timezone.
+    let Some(secs) = dur
+        .as_secs()
+        .checked_add_signed(SYSTEMTIME_TIMEZONE - (timezone as i64 * SECS_IN_MINUTE as i64))
+    else {
+        // If the current timezone cannot be used, find the closest timezone that will allow the
+        // conversion to succeed.
+        let new_tz = (dur.as_secs() / SECS_IN_MINUTE) as i16
+            + (SYSTEMTIME_TIMEZONE / SECS_IN_MINUTE as i64) as i16;
+        return Err(new_tz);
+    };
+
+    let days = secs / SECS_IN_DAY;
+    let remaining_secs = secs % SECS_IN_DAY;
+
+    let z = days + 693901;
+    let era = z / 146097;
+    let doe = z - (era * 146097);
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+    let mut y = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+
+    if m <= 2 {
+        y += 1;
+    }
+
+    let hour = (remaining_secs / SECS_IN_HOUR) as u8;
+    let minute = ((remaining_secs % SECS_IN_HOUR) / SECS_IN_MINUTE) as u8;
+    let second = (remaining_secs % SECS_IN_MINUTE) as u8;
+
+    // At this point, invalid time will be greater than MAX representable time. It cannot be less
+    // than minimum time since we already take care of that case above.
+    if y <= 9999 {
+        Ok(Time {
+            year: y as u16,
+            month: m as u8,
+            day: d as u8,
+            hour,
+            minute,
+            second,
+            nanosecond: dur.subsec_nanos(),
+            timezone,
+            daylight,
+            pad1: 0,
+            pad2: 0,
+        })
+    } else {
+        assert!(y == 10000);
+        assert!(m == 1);
+
+        let delta = ((d - 1) as u64 * MIN_IN_DAY
+            + hour as u64 * MIN_IN_HOUR
+            + minute as u64
+            + if second == 0 { 0 } else { 1 }) as i16;
+        let new_tz = timezone + delta;
+
+        assert!(new_tz <= 1440 && new_tz >= -1440);
+        Err(new_tz)
+    }
+}
diff --git a/library/std/src/sys/time/mod.rs b/library/std/src/sys/time/mod.rs
index e5b9a3a057f09..0275c91918fe4 100644
--- a/library/std/src/sys/time/mod.rs
+++ b/library/std/src/sys/time/mod.rs
@@ -10,6 +10,10 @@ cfg_select! {
         mod solid;
         use solid as imp;
     }
+    target_os = "uefi" => {
+        mod uefi;
+        use uefi as imp;
+    }
     target_os = "vexos" => {
         mod vexos;
         #[expect(unused)]
diff --git a/library/std/src/sys/pal/uefi/time.rs b/library/std/src/sys/time/uefi.rs
similarity index 52%
rename from library/std/src/sys/pal/uefi/time.rs
rename to library/std/src/sys/time/uefi.rs
index 3dccd03ff3fc8..5a7eab9031ecf 100644
--- a/library/std/src/sys/pal/uefi/time.rs
+++ b/library/std/src/sys/time/uefi.rs
@@ -1,7 +1,6 @@
+use crate::sys::pal::system_time;
 use crate::time::Duration;
 
-const SECS_IN_MINUTE: u64 = 60;
-
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 pub struct Instant(Duration);
 
@@ -88,7 +87,7 @@ impl SystemTime {
     .unwrap();
 
     pub(crate) const fn from_uefi(t: r_efi::efi::Time) -> Option<Self> {
-        match system_time_internal::from_uefi(&t) {
+        match system_time::from_uefi(&t) {
             Some(x) => Some(Self(x)),
             None => None,
         }
@@ -99,12 +98,12 @@ impl SystemTime {
         timezone: i16,
         daylight: u8,
     ) -> Result<r_efi::efi::Time, i16> {
-        // system_time_internal::to_uefi requires a valid timezone. In case of unspecified timezone,
+        // system_time::to_uefi requires a valid timezone. In case of unspecified timezone,
         // we just pass 0 since it is assumed that no timezone related adjustments are required.
         if timezone == r_efi::efi::UNSPECIFIED_TIMEZONE {
-            system_time_internal::to_uefi(&self.0, 0, daylight)
+            system_time::to_uefi(&self.0, 0, daylight)
         } else {
-            system_time_internal::to_uefi(&self.0, timezone, daylight)
+            system_time::to_uefi(&self.0, timezone, daylight)
         }
     }
 
@@ -118,8 +117,7 @@ impl SystemTime {
     }
 
     pub fn now() -> SystemTime {
-        Self::from_uefi(system_time_internal::now())
-            .expect("time incorrectly implemented on this platform")
+        Self::from_uefi(system_time::now()).expect("time incorrectly implemented on this platform")
     }
 
     pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
@@ -138,169 +136,15 @@ impl SystemTime {
     }
 }
 
-pub(crate) mod system_time_internal {
-    use r_efi::efi::{RuntimeServices, Time};
-
-    use super::super::helpers;
-    use super::*;
-    use crate::mem::MaybeUninit;
-    use crate::ptr::NonNull;
-
-    const SECS_IN_HOUR: u64 = SECS_IN_MINUTE * 60;
-    const SECS_IN_DAY: u64 = SECS_IN_HOUR * 24;
-    const SYSTEMTIME_TIMEZONE: i64 = -1440 * SECS_IN_MINUTE as i64;
-
-    pub(crate) fn now() -> Time {
-        let runtime_services: NonNull<RuntimeServices> =
-            helpers::runtime_services().expect("Runtime services are not available");
-        let mut t: MaybeUninit<Time> = MaybeUninit::uninit();
-        let r = unsafe {
-            ((*runtime_services.as_ptr()).get_time)(t.as_mut_ptr(), crate::ptr::null_mut())
-        };
-        if r.is_error() {
-            panic!("time not implemented on this platform");
-        }
-
-        unsafe { t.assume_init() }
-    }
-
-    /// This algorithm is a modified form of the one described in the post
-    /// https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.html
-    ///
-    /// The changes are to use 1900-01-01-00:00:00 with timezone -1440 as anchor instead of UNIX
-    /// epoch used in the original algorithm.
-    pub(crate) const fn from_uefi(t: &Time) -> Option<Duration> {
-        if !(t.month <= 12
-            && t.month != 0
-            && t.year >= 1900
-            && t.year <= 9999
-            && t.day <= 31
-            && t.day != 0
-            && t.second < 60
-            && t.minute <= 60
-            && t.hour < 24
-            && t.nanosecond < 1_000_000_000
-            && ((t.timezone <= 1440 && t.timezone >= -1440)
-                || t.timezone == r_efi::efi::UNSPECIFIED_TIMEZONE))
-        {
-            return None;
-        }
-
-        const YEAR_BASE: u32 = 4800; /* Before min year, multiple of 400. */
-
-        // Calculate the number of days since 1/1/1900. This is the earliest supported date in UEFI
-        // time.
-        // Use 1 March as the start
-        let (m_adj, overflow): (u32, bool) = (t.month as u32).overflowing_sub(3);
-        let (carry, adjust): (u32, u32) = if overflow { (1, 12) } else { (0, 0) };
-        let y_adj: u32 = (t.year as u32) + YEAR_BASE - carry;
-        let month_days: u32 = (m_adj.wrapping_add(adjust) * 62719 + 769) / 2048;
-        let leap_days: u32 = y_adj / 4 - y_adj / 100 + y_adj / 400;
-        let days: u32 = y_adj * 365 + leap_days + month_days + (t.day as u32 - 1) - 2447065;
-
-        let localtime_epoch: u64 = (days as u64) * SECS_IN_DAY
-            + (t.second as u64)
-            + (t.minute as u64) * SECS_IN_MINUTE
-            + (t.hour as u64) * SECS_IN_HOUR;
-
-        let normalized_timezone = if t.timezone == r_efi::efi::UNSPECIFIED_TIMEZONE {
-            -SYSTEMTIME_TIMEZONE
-        } else {
-            (t.timezone as i64) * SECS_IN_MINUTE as i64 - SYSTEMTIME_TIMEZONE
-        };
-
-        // Calculate the offset from 1/1/1900 at timezone -1440 min
-        let epoch = localtime_epoch.checked_add_signed(normalized_timezone).unwrap();
-
-        Some(Duration::new(epoch, t.nanosecond))
-    }
-
-    /// This algorithm is a modified version of the one described in the post:
-    /// https://howardhinnant.github.io/date_algorithms.html#clive_from_days
-    ///
-    /// The changes are to use 1900-01-01-00:00:00 with timezone -1440 as anchor instead of UNIX
-    /// epoch used in the original algorithm.
-    pub(crate) const fn to_uefi(dur: &Duration, timezone: i16, daylight: u8) -> Result<Time, i16> {
-        const MIN_IN_HOUR: u64 = 60;
-        const MIN_IN_DAY: u64 = MIN_IN_HOUR * 24;
-
-        // Check timezone validity
-        assert!(timezone <= 1440 && timezone >= -1440);
-
-        // Convert to seconds since 1900-01-01-00:00:00 in timezone.
-        let Some(secs) = dur
-            .as_secs()
-            .checked_add_signed(SYSTEMTIME_TIMEZONE - (timezone as i64 * SECS_IN_MINUTE as i64))
-        else {
-            // If the current timezone cannot be used, find the closest timezone that will allow the
-            // conversion to succeed.
-            let new_tz = (dur.as_secs() / SECS_IN_MINUTE) as i16
-                + (SYSTEMTIME_TIMEZONE / SECS_IN_MINUTE as i64) as i16;
-            return Err(new_tz);
-        };
-
-        let days = secs / SECS_IN_DAY;
-        let remaining_secs = secs % SECS_IN_DAY;
-
-        let z = days + 693901;
-        let era = z / 146097;
-        let doe = z - (era * 146097);
-        let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
-        let mut y = yoe + era * 400;
-        let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
-        let mp = (5 * doy + 2) / 153;
-        let d = doy - (153 * mp + 2) / 5 + 1;
-        let m = if mp < 10 { mp + 3 } else { mp - 9 };
-
-        if m <= 2 {
-            y += 1;
-        }
-
-        let hour = (remaining_secs / SECS_IN_HOUR) as u8;
-        let minute = ((remaining_secs % SECS_IN_HOUR) / SECS_IN_MINUTE) as u8;
-        let second = (remaining_secs % SECS_IN_MINUTE) as u8;
-
-        // At this point, invalid time will be greater than MAX representable time. It cannot be less
-        // than minimum time since we already take care of that case above.
-        if y <= 9999 {
-            Ok(Time {
-                year: y as u16,
-                month: m as u8,
-                day: d as u8,
-                hour,
-                minute,
-                second,
-                nanosecond: dur.subsec_nanos(),
-                timezone,
-                daylight,
-                pad1: 0,
-                pad2: 0,
-            })
-        } else {
-            assert!(y == 10000);
-            assert!(m == 1);
-
-            let delta = ((d - 1) as u64 * MIN_IN_DAY
-                + hour as u64 * MIN_IN_HOUR
-                + minute as u64
-                + if second == 0 { 0 } else { 1 }) as i16;
-            let new_tz = timezone + delta;
-
-            assert!(new_tz <= 1440 && new_tz >= -1440);
-            Err(new_tz)
-        }
-    }
-}
-
-pub(crate) mod instant_internal {
+mod instant_internal {
     use r_efi::protocols::timestamp;
 
-    use super::super::helpers;
     use super::*;
     use crate::mem::MaybeUninit;
     use crate::ptr::NonNull;
     use crate::sync::atomic::{Atomic, AtomicPtr, Ordering};
     use crate::sys::helpers::mul_div_u64;
+    use crate::sys::pal::helpers;
 
     const NS_PER_SEC: u64 = 1_000_000_000;
 

From 6cb343bfb2a5b9000cbccaa521f71a89e4a958c4 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 15:09:14 +0100
Subject: [PATCH 12/16] std: move time implementations to `sys` (Windows)

Windows has a similar problem as UEFI: some internals are also used for
implementing other things. Thus I've left everything except for the actual
`Instant` and `SystemTime` implementations inside the PAL.

I've also taken the liberty of improving the code clarity a bit: there were a
number of manual `SystemTime` conversions (including one that masked an `i64`
to 32-bits before casting to `u32`, yikes) that now just call `from_intervals`.
Also, defining a `PerformanceCounterInstant` just to convert it to a regular
`Instant` immediately doesn't really make sense to me. I've thus changed the
`perf_counter` module to contain only free functions that wrap system
functionality. The actual conversion now happens in `Instant::now`.
---
 library/std/src/sys/pal/windows/time.rs | 215 +++---------------------
 library/std/src/sys/time/mod.rs         |   4 +
 library/std/src/sys/time/windows.rs     | 156 +++++++++++++++++
 3 files changed, 182 insertions(+), 193 deletions(-)
 create mode 100644 library/std/src/sys/time/windows.rs

diff --git a/library/std/src/sys/pal/windows/time.rs b/library/std/src/sys/pal/windows/time.rs
index a555b2b546239..b4b1d50a88896 100644
--- a/library/std/src/sys/pal/windows/time.rs
+++ b/library/std/src/sys/pal/windows/time.rs
@@ -1,170 +1,12 @@
-use core::hash::{Hash, Hasher};
-use core::ops::Neg;
-
-use crate::cmp::Ordering;
+use crate::ops::Neg;
 use crate::ptr::null;
-use crate::sys::{IntoInner, c};
+use crate::sys::pal::c;
 use crate::time::Duration;
-use crate::{fmt, mem};
 
 const NANOS_PER_SEC: u64 = 1_000_000_000;
-const INTERVALS_PER_SEC: u64 = NANOS_PER_SEC / 100;
-
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
-pub struct Instant {
-    // This duration is relative to an arbitrary microsecond epoch
-    // from the winapi QueryPerformanceCounter function.
-    t: Duration,
-}
-
-#[derive(Copy, Clone)]
-pub struct SystemTime {
-    t: c::FILETIME,
-}
-
-const INTERVALS_TO_UNIX_EPOCH: u64 = 11_644_473_600 * INTERVALS_PER_SEC;
-
-pub const UNIX_EPOCH: SystemTime = SystemTime {
-    t: c::FILETIME {
-        dwLowDateTime: INTERVALS_TO_UNIX_EPOCH as u32,
-        dwHighDateTime: (INTERVALS_TO_UNIX_EPOCH >> 32) as u32,
-    },
-};
-
-impl Instant {
-    pub fn now() -> Instant {
-        // High precision timing on windows operates in "Performance Counter"
-        // units, as returned by the WINAPI QueryPerformanceCounter function.
-        // These relate to seconds by a factor of QueryPerformanceFrequency.
-        // In order to keep unit conversions out of normal interval math, we
-        // measure in QPC units and immediately convert to nanoseconds.
-        perf_counter::PerformanceCounterInstant::now().into()
-    }
-
-    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
-        // On windows there's a threshold below which we consider two timestamps
-        // equivalent due to measurement error. For more details + doc link,
-        // check the docs on epsilon.
-        let epsilon = perf_counter::PerformanceCounterInstant::epsilon();
-        if other.t > self.t && other.t - self.t <= epsilon {
-            Some(Duration::new(0, 0))
-        } else {
-            self.t.checked_sub(other.t)
-        }
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-        Some(Instant { t: self.t.checked_add(*other)? })
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
-        Some(Instant { t: self.t.checked_sub(*other)? })
-    }
-}
-
-impl SystemTime {
-    pub const MAX: SystemTime = SystemTime {
-        t: c::FILETIME {
-            dwLowDateTime: (i64::MAX & 0xFFFFFFFF) as u32,
-            dwHighDateTime: (i64::MAX >> 32) as u32,
-        },
-    };
-
-    pub const MIN: SystemTime =
-        SystemTime { t: c::FILETIME { dwLowDateTime: 0, dwHighDateTime: 0 } };
-
-    pub fn now() -> SystemTime {
-        unsafe {
-            let mut t: SystemTime = mem::zeroed();
-            c::GetSystemTimePreciseAsFileTime(&mut t.t);
-            t
-        }
-    }
-
-    fn from_intervals(intervals: i64) -> SystemTime {
-        SystemTime {
-            t: c::FILETIME {
-                dwLowDateTime: intervals as u32,
-                dwHighDateTime: (intervals >> 32) as u32,
-            },
-        }
-    }
-
-    fn intervals(&self) -> i64 {
-        (self.t.dwLowDateTime as i64) | ((self.t.dwHighDateTime as i64) << 32)
-    }
-
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        let me = self.intervals();
-        let other = other.intervals();
-        if me >= other {
-            Ok(intervals2dur((me - other) as u64))
-        } else {
-            Err(intervals2dur((other - me) as u64))
-        }
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;
-        Some(SystemTime::from_intervals(intervals))
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
-        // Windows does not support times before 1601, hence why we don't
-        // support negatives. In order to tackle this, we try to convert the
-        // resulting value into an u64, which should obviously fail in the case
-        // that the value is below zero.
-        let intervals: u64 =
-            self.intervals().checked_sub(checked_dur2intervals(other)?)?.try_into().ok()?;
-        Some(SystemTime::from_intervals(intervals as i64))
-    }
-}
-
-impl PartialEq for SystemTime {
-    fn eq(&self, other: &SystemTime) -> bool {
-        self.intervals() == other.intervals()
-    }
-}
-
-impl Eq for SystemTime {}
-
-impl PartialOrd for SystemTime {
-    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
+pub const INTERVALS_PER_SEC: u64 = NANOS_PER_SEC / 100;
 
-impl Ord for SystemTime {
-    fn cmp(&self, other: &SystemTime) -> Ordering {
-        self.intervals().cmp(&other.intervals())
-    }
-}
-
-impl fmt::Debug for SystemTime {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("SystemTime").field("intervals", &self.intervals()).finish()
-    }
-}
-
-impl From<c::FILETIME> for SystemTime {
-    fn from(t: c::FILETIME) -> SystemTime {
-        SystemTime { t }
-    }
-}
-
-impl IntoInner<c::FILETIME> for SystemTime {
-    fn into_inner(self) -> c::FILETIME {
-        self.t
-    }
-}
-
-impl Hash for SystemTime {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.intervals().hash(state)
-    }
-}
-
-fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
+pub fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
     dur.as_secs()
         .checked_mul(INTERVALS_PER_SEC)?
         .checked_add(dur.subsec_nanos() as u64 / 100)?
@@ -172,43 +14,23 @@ fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
         .ok()
 }
 
-fn intervals2dur(intervals: u64) -> Duration {
+pub fn intervals2dur(intervals: u64) -> Duration {
     Duration::new(intervals / INTERVALS_PER_SEC, ((intervals % INTERVALS_PER_SEC) * 100) as u32)
 }
 
-mod perf_counter {
+pub mod perf_counter {
     use super::NANOS_PER_SEC;
     use crate::sync::atomic::{Atomic, AtomicU64, Ordering};
-    use crate::sys::helpers::mul_div_u64;
     use crate::sys::{c, cvt};
     use crate::time::Duration;
 
-    pub struct PerformanceCounterInstant {
-        ts: i64,
-    }
-    impl PerformanceCounterInstant {
-        pub fn now() -> Self {
-            Self { ts: query() }
-        }
-
-        // Per microsoft docs, the margin of error for cross-thread time comparisons
-        // using QueryPerformanceCounter is 1 "tick" -- defined as 1/frequency().
-        // Reference: https://docs.microsoft.com/en-us/windows/desktop/SysInfo
-        //                   /acquiring-high-resolution-time-stamps
-        pub fn epsilon() -> Duration {
-            let epsilon = NANOS_PER_SEC / (frequency() as u64);
-            Duration::from_nanos(epsilon)
-        }
-    }
-    impl From<PerformanceCounterInstant> for super::Instant {
-        fn from(other: PerformanceCounterInstant) -> Self {
-            let freq = frequency() as u64;
-            let instant_nsec = mul_div_u64(other.ts as u64, NANOS_PER_SEC, freq);
-            Self { t: Duration::from_nanos(instant_nsec) }
-        }
+    pub fn now() -> i64 {
+        let mut qpc_value: i64 = 0;
+        cvt(unsafe { c::QueryPerformanceCounter(&mut qpc_value) }).unwrap();
+        qpc_value
     }
 
-    fn frequency() -> i64 {
+    pub fn frequency() -> i64 {
         // Either the cached result of `QueryPerformanceFrequency` or `0` for
         // uninitialized. Storing this as a single `AtomicU64` allows us to use
         // `Relaxed` operations, as we are only interested in the effects on a
@@ -230,10 +52,13 @@ mod perf_counter {
         frequency
     }
 
-    fn query() -> i64 {
-        let mut qpc_value: i64 = 0;
-        cvt(unsafe { c::QueryPerformanceCounter(&mut qpc_value) }).unwrap();
-        qpc_value
+    // Per microsoft docs, the margin of error for cross-thread time comparisons
+    // using QueryPerformanceCounter is 1 "tick" -- defined as 1/frequency().
+    // Reference: https://docs.microsoft.com/en-us/windows/desktop/SysInfo
+    //                   /acquiring-high-resolution-time-stamps
+    pub fn epsilon() -> Duration {
+        let epsilon = NANOS_PER_SEC / (frequency() as u64);
+        Duration::from_nanos(epsilon)
     }
 }
 
@@ -241,6 +66,7 @@ mod perf_counter {
 pub(crate) struct WaitableTimer {
     handle: c::HANDLE,
 }
+
 impl WaitableTimer {
     /// Creates a high-resolution timer. Will fail before Windows 10, version 1803.
     pub fn high_resolution() -> Result<Self, ()> {
@@ -254,6 +80,7 @@ impl WaitableTimer {
         };
         if !handle.is_null() { Ok(Self { handle }) } else { Err(()) }
     }
+
     pub fn set(&self, duration: Duration) -> Result<(), ()> {
         // Convert the Duration to a format similar to FILETIME.
         // Negative values are relative times whereas positive values are absolute.
@@ -262,11 +89,13 @@ impl WaitableTimer {
         let result = unsafe { c::SetWaitableTimer(self.handle, &time, 0, None, null(), c::FALSE) };
         if result != 0 { Ok(()) } else { Err(()) }
     }
+
     pub fn wait(&self) -> Result<(), ()> {
         let result = unsafe { c::WaitForSingleObject(self.handle, c::INFINITE) };
         if result != c::WAIT_FAILED { Ok(()) } else { Err(()) }
     }
 }
+
 impl Drop for WaitableTimer {
     fn drop(&mut self) {
         unsafe { c::CloseHandle(self.handle) };
diff --git a/library/std/src/sys/time/mod.rs b/library/std/src/sys/time/mod.rs
index 0275c91918fe4..810d16b19368b 100644
--- a/library/std/src/sys/time/mod.rs
+++ b/library/std/src/sys/time/mod.rs
@@ -24,6 +24,10 @@ cfg_select! {
             pub use super::unsupported::{SystemTime, UNIX_EPOCH};
         }
     }
+    target_os = "windows" => {
+        mod windows;
+        use windows as imp;
+    }
     target_os = "xous" => {
         mod xous;
         use xous as imp;
diff --git a/library/std/src/sys/time/windows.rs b/library/std/src/sys/time/windows.rs
new file mode 100644
index 0000000000000..2e38dbf5cf288
--- /dev/null
+++ b/library/std/src/sys/time/windows.rs
@@ -0,0 +1,156 @@
+use crate::cmp::Ordering;
+use crate::hash::{Hash, Hasher};
+use crate::sys::helpers::mul_div_u64;
+use crate::sys::pal::time::{
+    INTERVALS_PER_SEC, checked_dur2intervals, intervals2dur, perf_counter,
+};
+use crate::sys::{IntoInner, c};
+use crate::time::Duration;
+use crate::{fmt, mem};
+
+const NANOS_PER_SEC: u64 = 1_000_000_000;
+
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
+pub struct Instant {
+    // This duration is relative to an arbitrary microsecond epoch
+    // from the winapi QueryPerformanceCounter function.
+    t: Duration,
+}
+
+#[derive(Copy, Clone)]
+pub struct SystemTime {
+    t: c::FILETIME,
+}
+
+pub const UNIX_EPOCH: SystemTime =
+    SystemTime::from_intervals(11_644_473_600 * INTERVALS_PER_SEC as i64);
+
+impl Instant {
+    pub fn now() -> Instant {
+        // High precision timing on windows operates in "Performance Counter"
+        // units, as returned by the WINAPI QueryPerformanceCounter function.
+        // These relate to seconds by a factor of QueryPerformanceFrequency.
+        // In order to keep unit conversions out of normal interval math, we
+        // measure in QPC units and immediately convert to nanoseconds.
+
+        let freq = perf_counter::frequency() as u64;
+        let now = perf_counter::now();
+        let instant_nsec = mul_div_u64(now as u64, NANOS_PER_SEC, freq);
+        Self { t: Duration::from_nanos(instant_nsec) }
+    }
+
+    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
+        // On windows there's a threshold below which we consider two timestamps
+        // equivalent due to measurement error. For more details + doc link,
+        // check the docs on epsilon.
+        let epsilon = perf_counter::epsilon();
+        if other.t > self.t && other.t - self.t <= epsilon {
+            Some(Duration::new(0, 0))
+        } else {
+            self.t.checked_sub(other.t)
+        }
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant { t: self.t.checked_add(*other)? })
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant { t: self.t.checked_sub(*other)? })
+    }
+}
+
+impl SystemTime {
+    pub const MAX: SystemTime = SystemTime::from_intervals(i64::MAX);
+    pub const MIN: SystemTime = SystemTime::from_intervals(0);
+
+    pub fn now() -> SystemTime {
+        unsafe {
+            let mut t: SystemTime = mem::zeroed();
+            c::GetSystemTimePreciseAsFileTime(&mut t.t);
+            t
+        }
+    }
+
+    const fn from_intervals(intervals: i64) -> SystemTime {
+        SystemTime {
+            t: c::FILETIME {
+                dwLowDateTime: intervals as u32,
+                dwHighDateTime: (intervals >> 32) as u32,
+            },
+        }
+    }
+
+    fn intervals(&self) -> i64 {
+        (self.t.dwLowDateTime as i64) | ((self.t.dwHighDateTime as i64) << 32)
+    }
+
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        let me = self.intervals();
+        let other = other.intervals();
+        if me >= other {
+            Ok(intervals2dur((me - other) as u64))
+        } else {
+            Err(intervals2dur((other - me) as u64))
+        }
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+        let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;
+        Some(SystemTime::from_intervals(intervals))
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        // Windows does not support times before 1601, hence why we don't
+        // support negatives. In order to tackle this, we try to convert the
+        // resulting value into an u64, which should obviously fail in the case
+        // that the value is below zero.
+        let intervals: u64 =
+            self.intervals().checked_sub(checked_dur2intervals(other)?)?.try_into().ok()?;
+        Some(SystemTime::from_intervals(intervals as i64))
+    }
+}
+
+impl PartialEq for SystemTime {
+    fn eq(&self, other: &SystemTime) -> bool {
+        self.intervals() == other.intervals()
+    }
+}
+
+impl Eq for SystemTime {}
+
+impl PartialOrd for SystemTime {
+    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for SystemTime {
+    fn cmp(&self, other: &SystemTime) -> Ordering {
+        self.intervals().cmp(&other.intervals())
+    }
+}
+
+impl fmt::Debug for SystemTime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SystemTime").field("intervals", &self.intervals()).finish()
+    }
+}
+
+impl From<c::FILETIME> for SystemTime {
+    fn from(t: c::FILETIME) -> SystemTime {
+        SystemTime { t }
+    }
+}
+
+impl IntoInner<c::FILETIME> for SystemTime {
+    fn into_inner(self) -> c::FILETIME {
+        self.t
+    }
+}
+
+impl Hash for SystemTime {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.intervals().hash(state)
+    }
+}

From 05bbfa2593ca5cea5ffb6d53f838bed6f3ec3f46 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 15:17:41 +0100
Subject: [PATCH 13/16] std: move time implementations to `sys` (UNIX)

Now for UNIX: `Timespec` is also used for things like futex or `Condvar`
timeouts, so it stays in the PAL along with some related definitions.
Everything else is `SystemTime`- and `Instant`-specific, and is thus moved to
`sys::time`.
---
 library/std/src/sys/fs/unix.rs       |   4 +-
 library/std/src/sys/pal/unix/time.rs | 151 ++-------------------------
 library/std/src/sys/time/mod.rs      |   4 +
 library/std/src/sys/time/unix.rs     | 141 +++++++++++++++++++++++++
 4 files changed, 154 insertions(+), 146 deletions(-)
 create mode 100644 library/std/src/sys/time/unix.rs

diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index ca9d3fd592bf4..3ca84db0f47fc 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -1822,7 +1822,7 @@ impl File {
             _ => {
                 #[cfg(all(target_os = "linux", target_env = "gnu", target_pointer_width = "32", not(target_arch = "riscv32")))]
                 {
-                    use crate::sys::{time::__timespec64, weak::weak};
+                    use crate::sys::pal::{time::__timespec64, weak::weak};
 
                     // Added in glibc 2.34
                     weak!(
@@ -2258,7 +2258,7 @@ fn set_times_impl(p: &CStr, times: FileTimes, follow_symlinks: bool) -> io::Resu
             let flags = if follow_symlinks { 0 } else { libc::AT_SYMLINK_NOFOLLOW };
             #[cfg(all(target_os = "linux", target_env = "gnu", target_pointer_width = "32", not(target_arch = "riscv32")))]
             {
-                use crate::sys::{time::__timespec64, weak::weak};
+                use crate::sys::pal::{time::__timespec64, weak::weak};
 
                 // Added in glibc 2.34
                 weak!(
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
index 0021c013d3d9d..fbea94ec84e79 100644
--- a/library/std/src/sys/pal/unix/time.rs
+++ b/library/std/src/sys/pal/unix/time.rs
@@ -1,11 +1,10 @@
 use core::num::niche_types::Nanoseconds;
 
-use crate::sys::AsInner;
+use crate::io;
 use crate::time::Duration;
-use crate::{fmt, io};
 
 const NSEC_PER_SEC: u64 = 1_000_000_000;
-pub const UNIX_EPOCH: SystemTime = SystemTime { t: Timespec::zero() };
+
 #[allow(dead_code)] // Used for pthread condvar timeouts
 pub const TIMESPEC_MAX: libc::timespec =
     libc::timespec { tv_sec: <libc::time_t>::MAX, tv_nsec: 1_000_000_000 - 1 };
@@ -18,60 +17,19 @@ pub(in crate::sys) const TIMESPEC_MAX_CAPPED: libc::timespec = libc::timespec {
     tv_nsec: (u64::MAX % NSEC_PER_SEC) as i64,
 };
 
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct SystemTime {
-    pub(crate) t: Timespec,
-}
-
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub(crate) struct Timespec {
-    tv_sec: i64,
-    tv_nsec: Nanoseconds,
-}
-
-impl SystemTime {
-    pub const MAX: SystemTime = SystemTime { t: Timespec::MAX };
-
-    pub const MIN: SystemTime = SystemTime { t: Timespec::MIN };
-
-    #[cfg_attr(any(target_os = "horizon", target_os = "hurd"), allow(unused))]
-    pub fn new(tv_sec: i64, tv_nsec: i64) -> Result<SystemTime, io::Error> {
-        Ok(SystemTime { t: Timespec::new(tv_sec, tv_nsec)? })
-    }
-
-    pub fn now() -> SystemTime {
-        SystemTime { t: Timespec::now(libc::CLOCK_REALTIME) }
-    }
-
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        self.t.sub_timespec(&other.t)
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime { t: self.t.checked_add_duration(other)? })
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime { t: self.t.checked_sub_duration(other)? })
-    }
-}
-
-impl fmt::Debug for SystemTime {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("SystemTime")
-            .field("tv_sec", &self.t.tv_sec)
-            .field("tv_nsec", &self.t.tv_nsec)
-            .finish()
-    }
+    pub tv_sec: i64,
+    pub tv_nsec: Nanoseconds,
 }
 
 impl Timespec {
-    const MAX: Timespec = unsafe { Self::new_unchecked(i64::MAX, 1_000_000_000 - 1) };
+    pub const MAX: Timespec = unsafe { Self::new_unchecked(i64::MAX, 1_000_000_000 - 1) };
 
     // As described below, on Apple OS, dates before epoch are represented differently.
     // This is not an issue here however, because we are using tv_sec = i64::MIN,
     // which will cause the compatibility wrapper to not be executed at all.
-    const MIN: Timespec = unsafe { Self::new_unchecked(i64::MIN, 0) };
+    pub const MIN: Timespec = unsafe { Self::new_unchecked(i64::MIN, 0) };
 
     const unsafe fn new_unchecked(tv_sec: i64, tv_nsec: i64) -> Timespec {
         Timespec { tv_sec, tv_nsec: unsafe { Nanoseconds::new_unchecked(tv_nsec as u32) } }
@@ -81,7 +39,7 @@ impl Timespec {
         unsafe { Self::new_unchecked(0, 0) }
     }
 
-    const fn new(tv_sec: i64, tv_nsec: i64) -> Result<Timespec, io::Error> {
+    pub const fn new(tv_sec: i64, tv_nsec: i64) -> Result<Timespec, io::Error> {
         // On Apple OS, dates before epoch are represented differently than on other
         // Unix platforms: e.g. 1/10th of a second before epoch is represented as `seconds=-1`
         // and `nanoseconds=100_000_000` on other platforms, but is `seconds=0` and
@@ -263,98 +221,3 @@ impl __timespec64 {
         Self { tv_sec, tv_nsec, _padding: 0 }
     }
 }
-
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Instant {
-    t: Timespec,
-}
-
-impl Instant {
-    // CLOCK_UPTIME_RAW   clock that increments monotonically, in the same man-
-    //                    ner as CLOCK_MONOTONIC_RAW, but that does not incre-
-    //                    ment while the system is asleep.  The returned value
-    //                    is identical to the result of mach_absolute_time()
-    //                    after the appropriate mach_timebase conversion is
-    //                    applied.
-    //
-    // We use `CLOCK_UPTIME_RAW` instead of `CLOCK_MONOTONIC` since
-    // `CLOCK_UPTIME_RAW` is based on `mach_absolute_time`, which is the
-    // clock that all timeouts and deadlines are measured against inside
-    // the kernel.
-    #[cfg(target_vendor = "apple")]
-    pub(crate) const CLOCK_ID: libc::clockid_t = libc::CLOCK_UPTIME_RAW;
-
-    #[cfg(not(target_vendor = "apple"))]
-    pub(crate) const CLOCK_ID: libc::clockid_t = libc::CLOCK_MONOTONIC;
-
-    pub fn now() -> Instant {
-        // https://pubs.opengroup.org/onlinepubs/9799919799/functions/clock_getres.html
-        Instant { t: Timespec::now(Self::CLOCK_ID) }
-    }
-
-    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
-        self.t.sub_timespec(&other.t).ok()
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-        Some(Instant { t: self.t.checked_add_duration(other)? })
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
-        Some(Instant { t: self.t.checked_sub_duration(other)? })
-    }
-
-    #[cfg_attr(
-        not(target_os = "linux"),
-        allow(unused, reason = "needed by the `sleep_until` on some unix platforms")
-    )]
-    pub(crate) fn into_timespec(self) -> Timespec {
-        self.t
-    }
-
-    /// Returns `self` converted into units of `mach_absolute_time`, or `None`
-    /// if `self` is before the system boot time. If the conversion cannot be
-    /// performed precisely, this ceils the result up to the nearest
-    /// representable value.
-    #[cfg(target_vendor = "apple")]
-    pub fn into_mach_absolute_time_ceil(self) -> Option<u128> {
-        #[repr(C)]
-        struct mach_timebase_info {
-            numer: u32,
-            denom: u32,
-        }
-
-        unsafe extern "C" {
-            unsafe fn mach_timebase_info(info: *mut mach_timebase_info) -> libc::kern_return_t;
-        }
-
-        let secs = u64::try_from(self.t.tv_sec).ok()?;
-
-        let mut timebase = mach_timebase_info { numer: 0, denom: 0 };
-        assert_eq!(unsafe { mach_timebase_info(&mut timebase) }, libc::KERN_SUCCESS);
-
-        // Since `tv_sec` is 64-bit and `tv_nsec` is smaller than 1 billion,
-        // this cannot overflow. The resulting number needs at most 94 bits.
-        let nanos =
-            u128::from(secs) * u128::from(NSEC_PER_SEC) + u128::from(self.t.tv_nsec.as_inner());
-        // This multiplication cannot overflow since multiplying a 94-bit
-        // number by a 32-bit number yields a number that needs at most
-        // 126 bits.
-        Some((nanos * u128::from(timebase.denom)).div_ceil(u128::from(timebase.numer)))
-    }
-}
-
-impl AsInner<Timespec> for Instant {
-    fn as_inner(&self) -> &Timespec {
-        &self.t
-    }
-}
-
-impl fmt::Debug for Instant {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Instant")
-            .field("tv_sec", &self.t.tv_sec)
-            .field("tv_nsec", &self.t.tv_nsec)
-            .finish()
-    }
-}
diff --git a/library/std/src/sys/time/mod.rs b/library/std/src/sys/time/mod.rs
index 810d16b19368b..3efab78518c27 100644
--- a/library/std/src/sys/time/mod.rs
+++ b/library/std/src/sys/time/mod.rs
@@ -14,6 +14,10 @@ cfg_select! {
         mod uefi;
         use uefi as imp;
     }
+    target_family = "unix" => {
+        mod unix;
+        use unix as imp;
+    }
     target_os = "vexos" => {
         mod vexos;
         #[expect(unused)]
diff --git a/library/std/src/sys/time/unix.rs b/library/std/src/sys/time/unix.rs
new file mode 100644
index 0000000000000..21d246bc850a0
--- /dev/null
+++ b/library/std/src/sys/time/unix.rs
@@ -0,0 +1,141 @@
+use crate::sys::AsInner;
+use crate::sys::pal::time::Timespec;
+use crate::time::Duration;
+use crate::{fmt, io};
+
+pub const UNIX_EPOCH: SystemTime = SystemTime { t: Timespec::zero() };
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct SystemTime {
+    pub(crate) t: Timespec,
+}
+
+impl SystemTime {
+    pub const MAX: SystemTime = SystemTime { t: Timespec::MAX };
+
+    pub const MIN: SystemTime = SystemTime { t: Timespec::MIN };
+
+    #[cfg_attr(any(target_os = "horizon", target_os = "hurd"), allow(unused))]
+    pub fn new(tv_sec: i64, tv_nsec: i64) -> Result<SystemTime, io::Error> {
+        Ok(SystemTime { t: Timespec::new(tv_sec, tv_nsec)? })
+    }
+
+    pub fn now() -> SystemTime {
+        SystemTime { t: Timespec::now(libc::CLOCK_REALTIME) }
+    }
+
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        self.t.sub_timespec(&other.t)
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime { t: self.t.checked_add_duration(other)? })
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime { t: self.t.checked_sub_duration(other)? })
+    }
+}
+
+impl fmt::Debug for SystemTime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SystemTime")
+            .field("tv_sec", &self.t.tv_sec)
+            .field("tv_nsec", &self.t.tv_nsec)
+            .finish()
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Instant {
+    t: Timespec,
+}
+
+impl Instant {
+    // CLOCK_UPTIME_RAW   clock that increments monotonically, in the same man-
+    //                    ner as CLOCK_MONOTONIC_RAW, but that does not incre-
+    //                    ment while the system is asleep.  The returned value
+    //                    is identical to the result of mach_absolute_time()
+    //                    after the appropriate mach_timebase conversion is
+    //                    applied.
+    //
+    // We use `CLOCK_UPTIME_RAW` instead of `CLOCK_MONOTONIC` since
+    // `CLOCK_UPTIME_RAW` is based on `mach_absolute_time`, which is the
+    // clock that all timeouts and deadlines are measured against inside
+    // the kernel.
+    #[cfg(target_vendor = "apple")]
+    pub(crate) const CLOCK_ID: libc::clockid_t = libc::CLOCK_UPTIME_RAW;
+
+    #[cfg(not(target_vendor = "apple"))]
+    pub(crate) const CLOCK_ID: libc::clockid_t = libc::CLOCK_MONOTONIC;
+
+    pub fn now() -> Instant {
+        // https://pubs.opengroup.org/onlinepubs/9799919799/functions/clock_getres.html
+        Instant { t: Timespec::now(Self::CLOCK_ID) }
+    }
+
+    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
+        self.t.sub_timespec(&other.t).ok()
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant { t: self.t.checked_add_duration(other)? })
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant { t: self.t.checked_sub_duration(other)? })
+    }
+
+    #[cfg_attr(
+        not(target_os = "linux"),
+        allow(unused, reason = "needed by the `sleep_until` on some unix platforms")
+    )]
+    pub(crate) fn into_timespec(self) -> Timespec {
+        self.t
+    }
+
+    /// Returns `self` converted into units of `mach_absolute_time`, or `None`
+    /// if `self` is before the system boot time. If the conversion cannot be
+    /// performed precisely, this ceils the result up to the nearest
+    /// representable value.
+    #[cfg(target_vendor = "apple")]
+    pub fn into_mach_absolute_time_ceil(self) -> Option<u128> {
+        #[repr(C)]
+        struct mach_timebase_info {
+            numer: u32,
+            denom: u32,
+        }
+
+        unsafe extern "C" {
+            unsafe fn mach_timebase_info(info: *mut mach_timebase_info) -> libc::kern_return_t;
+        }
+
+        let secs = u64::try_from(self.t.tv_sec).ok()?;
+
+        let mut timebase = mach_timebase_info { numer: 0, denom: 0 };
+        assert_eq!(unsafe { mach_timebase_info(&mut timebase) }, libc::KERN_SUCCESS);
+
+        // Since `tv_sec` is 64-bit and `tv_nsec` is smaller than 1 billion,
+        // this cannot overflow. The resulting number needs at most 94 bits.
+        let nanos = 1_000_000_000 * u128::from(secs) + u128::from(self.t.tv_nsec.as_inner());
+        // This multiplication cannot overflow since multiplying a 94-bit
+        // number by a 32-bit number yields a number that needs at most
+        // 126 bits.
+        Some((nanos * u128::from(timebase.denom)).div_ceil(u128::from(timebase.numer)))
+    }
+}
+
+impl AsInner<Timespec> for Instant {
+    fn as_inner(&self) -> &Timespec {
+        &self.t
+    }
+}
+
+impl fmt::Debug for Instant {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Instant")
+            .field("tv_sec", &self.t.tv_sec)
+            .field("tv_nsec", &self.t.tv_nsec)
+            .finish()
+    }
+}

From eec058eacc1ba500aba4393dbec47a1acd6e2d2a Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 15:21:58 +0100
Subject: [PATCH 14/16] std: move time implementations to `sys` (WASI/TEEOS)

WASI and TEEOS share the UNIX implementation. Since `Timespec` lives in the
PAL, this means that the `#[path]` imports of `unix/time.rs` still remain for
these two, unfortunately. Maybe we'll solve that in the future by always
including the UNIX PAL for these remotely UNIXy platforms. But that's a story
for another time...
---
 library/std/src/sys/pal/teeos/mod.rs |  1 -
 library/std/src/sys/time/mod.rs      | 10 +++++++++-
 library/std/src/sys/time/unix.rs     |  2 +-
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/library/std/src/sys/pal/teeos/mod.rs b/library/std/src/sys/pal/teeos/mod.rs
index d40c10663fd17..f76c26d3c966c 100644
--- a/library/std/src/sys/pal/teeos/mod.rs
+++ b/library/std/src/sys/pal/teeos/mod.rs
@@ -7,7 +7,6 @@
 #![allow(dead_code)]
 
 pub mod os;
-#[allow(non_upper_case_globals)]
 #[path = "../unix/time.rs"]
 pub mod time;
 
diff --git a/library/std/src/sys/time/mod.rs b/library/std/src/sys/time/mod.rs
index 3efab78518c27..6cd1850e7cca1 100644
--- a/library/std/src/sys/time/mod.rs
+++ b/library/std/src/sys/time/mod.rs
@@ -1,4 +1,8 @@
 cfg_select! {
+    target_os = "hermit" => {
+        mod hermit;
+        use hermit as imp;
+    }
     target_os = "motor" => {
         use moto_rt::time as imp;
     }
@@ -14,7 +18,11 @@ cfg_select! {
         mod uefi;
         use uefi as imp;
     }
-    target_family = "unix" => {
+    any(
+        target_os = "teeos",
+        target_family = "unix",
+        target_os = "wasi",
+    ) => {
         mod unix;
         use unix as imp;
     }
diff --git a/library/std/src/sys/time/unix.rs b/library/std/src/sys/time/unix.rs
index 21d246bc850a0..944cb552cad9e 100644
--- a/library/std/src/sys/time/unix.rs
+++ b/library/std/src/sys/time/unix.rs
@@ -15,7 +15,7 @@ impl SystemTime {
 
     pub const MIN: SystemTime = SystemTime { t: Timespec::MIN };
 
-    #[cfg_attr(any(target_os = "horizon", target_os = "hurd"), allow(unused))]
+    #[cfg_attr(any(target_os = "horizon", target_os = "hurd", target_os = "teeos"), expect(unused))]
     pub fn new(tv_sec: i64, tv_nsec: i64) -> Result<SystemTime, io::Error> {
         Ok(SystemTime { t: Timespec::new(tv_sec, tv_nsec)? })
     }

From fe51f9debcaf35692bc1760850577f5e6846a009 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Thu, 15 Jan 2026 15:25:14 +0100
Subject: [PATCH 15/16] std: move time implementations to `sys` (Hermit)

Last on the list: Hermit. Since I anticipate that Hermit will share the UNIX
implementation in the future, I've left `Timespec` in the PAL to maintain a
similar structure. Also, I noticed that some public `Instant` methods were
redefined on the internal `Instant`. But the networking code can just use the
public `Instant`, so I've removed them.
---
 .../src/sys/net/connection/socket/hermit.rs   |   3 +-
 library/std/src/sys/pal/hermit/time.rs        | 154 ++----------------
 library/std/src/sys/time/hermit.rs            |  63 +++++++
 3 files changed, 75 insertions(+), 145 deletions(-)
 create mode 100644 library/std/src/sys/time/hermit.rs

diff --git a/library/std/src/sys/net/connection/socket/hermit.rs b/library/std/src/sys/net/connection/socket/hermit.rs
index d57a075eb42d5..59f515d31aff9 100644
--- a/library/std/src/sys/net/connection/socket/hermit.rs
+++ b/library/std/src/sys/net/connection/socket/hermit.rs
@@ -9,10 +9,9 @@ use crate::io::{self, BorrowedBuf, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::net::{Shutdown, SocketAddr};
 use crate::os::hermit::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, RawFd};
 use crate::sys::fd::FileDesc;
-use crate::sys::time::Instant;
 use crate::sys::{AsInner, FromInner, IntoInner};
 pub use crate::sys::{cvt, cvt_r};
-use crate::time::Duration;
+use crate::time::{Duration, Instant};
 use crate::{cmp, mem};
 
 #[expect(non_camel_case_types)]
diff --git a/library/std/src/sys/pal/hermit/time.rs b/library/std/src/sys/pal/hermit/time.rs
index 734ad2540a180..b9851eb6754d6 100644
--- a/library/std/src/sys/pal/hermit/time.rs
+++ b/library/std/src/sys/pal/hermit/time.rs
@@ -1,35 +1,32 @@
-#![allow(dead_code)]
+use hermit_abi::{self, timespec};
 
-use core::hash::{Hash, Hasher};
-
-use super::hermit_abi::{self, CLOCK_MONOTONIC, CLOCK_REALTIME, timespec};
 use crate::cmp::Ordering;
-use crate::ops::{Add, AddAssign, Sub, SubAssign};
+use crate::hash::{Hash, Hasher};
 use crate::time::Duration;
 
 const NSEC_PER_SEC: i32 = 1_000_000_000;
 
 #[derive(Copy, Clone, Debug)]
-struct Timespec {
-    t: timespec,
+pub struct Timespec {
+    pub t: timespec,
 }
 
 impl Timespec {
-    const MAX: Timespec = Self::new(i64::MAX, 1_000_000_000 - 1);
+    pub const MAX: Timespec = Self::new(i64::MAX, 1_000_000_000 - 1);
 
-    const MIN: Timespec = Self::new(i64::MIN, 0);
+    pub const MIN: Timespec = Self::new(i64::MIN, 0);
 
-    const fn zero() -> Timespec {
+    pub const fn zero() -> Timespec {
         Timespec { t: timespec { tv_sec: 0, tv_nsec: 0 } }
     }
 
-    const fn new(tv_sec: i64, tv_nsec: i32) -> Timespec {
+    pub const fn new(tv_sec: i64, tv_nsec: i32) -> Timespec {
         assert!(tv_nsec >= 0 && tv_nsec < NSEC_PER_SEC);
         // SAFETY: The assert above checks tv_nsec is within the valid range
         Timespec { t: timespec { tv_sec, tv_nsec } }
     }
 
-    fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
+    pub fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
         fn sub_ge_to_unsigned(a: i64, b: i64) -> u64 {
             debug_assert!(a >= b);
             a.wrapping_sub(b).cast_unsigned()
@@ -57,7 +54,7 @@ impl Timespec {
         }
     }
 
-    fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.t.tv_sec.checked_add_unsigned(other.as_secs())?;
 
         // Nano calculations can't overflow because nanos are <1B which fit
@@ -70,7 +67,7 @@ impl Timespec {
         Some(Timespec { t: timespec { tv_sec: secs, tv_nsec: nsec as _ } })
     }
 
-    fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.t.tv_sec.checked_sub_unsigned(other.as_secs())?;
 
         // Similar to above, nanos can't overflow.
@@ -111,132 +108,3 @@ impl Hash for Timespec {
         self.t.tv_nsec.hash(state);
     }
 }
-
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-pub struct Instant(Timespec);
-
-impl Instant {
-    pub fn now() -> Instant {
-        let mut time: Timespec = Timespec::zero();
-        let _ = unsafe { hermit_abi::clock_gettime(CLOCK_MONOTONIC, &raw mut time.t) };
-
-        Instant(time)
-    }
-
-    #[stable(feature = "time2", since = "1.8.0")]
-    pub fn elapsed(&self) -> Duration {
-        Instant::now() - *self
-    }
-
-    pub fn duration_since(&self, earlier: Instant) -> Duration {
-        self.checked_duration_since(earlier).unwrap_or_default()
-    }
-
-    pub fn checked_duration_since(&self, earlier: Instant) -> Option<Duration> {
-        self.checked_sub_instant(&earlier)
-    }
-
-    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
-        self.0.sub_timespec(&other.0).ok()
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-        Some(Instant(self.0.checked_add_duration(other)?))
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
-        Some(Instant(self.0.checked_sub_duration(other)?))
-    }
-
-    pub fn checked_add(&self, duration: Duration) -> Option<Instant> {
-        self.0.checked_add_duration(&duration).map(Instant)
-    }
-
-    pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
-        self.0.checked_sub_duration(&duration).map(Instant)
-    }
-}
-
-impl Add<Duration> for Instant {
-    type Output = Instant;
-
-    /// # Panics
-    ///
-    /// This function may panic if the resulting point in time cannot be represented by the
-    /// underlying data structure. See [`Instant::checked_add`] for a version without panic.
-    fn add(self, other: Duration) -> Instant {
-        self.checked_add(other).expect("overflow when adding duration to instant")
-    }
-}
-
-impl AddAssign<Duration> for Instant {
-    fn add_assign(&mut self, other: Duration) {
-        *self = *self + other;
-    }
-}
-
-impl Sub<Duration> for Instant {
-    type Output = Instant;
-
-    fn sub(self, other: Duration) -> Instant {
-        self.checked_sub(other).expect("overflow when subtracting duration from instant")
-    }
-}
-
-impl SubAssign<Duration> for Instant {
-    fn sub_assign(&mut self, other: Duration) {
-        *self = *self - other;
-    }
-}
-
-impl Sub<Instant> for Instant {
-    type Output = Duration;
-
-    /// Returns the amount of time elapsed from another instant to this one,
-    /// or zero duration if that instant is later than this one.
-    ///
-    /// # Panics
-    ///
-    /// Previous Rust versions panicked when `other` was later than `self`. Currently this
-    /// method saturates. Future versions may reintroduce the panic in some circumstances.
-    /// See [Monotonicity].
-    ///
-    /// [Monotonicity]: Instant#monotonicity
-    fn sub(self, other: Instant) -> Duration {
-        self.duration_since(other)
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub struct SystemTime(Timespec);
-
-pub const UNIX_EPOCH: SystemTime = SystemTime(Timespec::zero());
-
-impl SystemTime {
-    pub const MAX: SystemTime = SystemTime(Timespec::MAX);
-
-    pub const MIN: SystemTime = SystemTime(Timespec::MIN);
-
-    pub fn new(tv_sec: i64, tv_nsec: i32) -> SystemTime {
-        SystemTime(Timespec::new(tv_sec, tv_nsec))
-    }
-
-    pub fn now() -> SystemTime {
-        let mut time: Timespec = Timespec::zero();
-        let _ = unsafe { hermit_abi::clock_gettime(CLOCK_REALTIME, &raw mut time.t) };
-
-        SystemTime(time)
-    }
-
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        self.0.sub_timespec(&other.0)
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_add_duration(other)?))
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_sub_duration(other)?))
-    }
-}
diff --git a/library/std/src/sys/time/hermit.rs b/library/std/src/sys/time/hermit.rs
new file mode 100644
index 0000000000000..18ece2e3010d0
--- /dev/null
+++ b/library/std/src/sys/time/hermit.rs
@@ -0,0 +1,63 @@
+use hermit_abi::{self, CLOCK_MONOTONIC, CLOCK_REALTIME};
+
+use crate::hash::Hash;
+use crate::sys::pal::time::Timespec;
+use crate::time::Duration;
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+pub struct Instant(Timespec);
+
+impl Instant {
+    pub fn now() -> Instant {
+        let mut time: Timespec = Timespec::zero();
+        let _ = unsafe { hermit_abi::clock_gettime(CLOCK_MONOTONIC, &raw mut time.t) };
+
+        Instant(time)
+    }
+
+    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
+        self.0.sub_timespec(&other.0).ok()
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant(self.0.checked_add_duration(other)?))
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant(self.0.checked_sub_duration(other)?))
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub struct SystemTime(Timespec);
+
+pub const UNIX_EPOCH: SystemTime = SystemTime(Timespec::zero());
+
+impl SystemTime {
+    pub const MAX: SystemTime = SystemTime(Timespec::MAX);
+
+    pub const MIN: SystemTime = SystemTime(Timespec::MIN);
+
+    pub fn new(tv_sec: i64, tv_nsec: i32) -> SystemTime {
+        SystemTime(Timespec::new(tv_sec, tv_nsec))
+    }
+
+    pub fn now() -> SystemTime {
+        let mut time: Timespec = Timespec::zero();
+        let _ = unsafe { hermit_abi::clock_gettime(CLOCK_REALTIME, &raw mut time.t) };
+
+        SystemTime(time)
+    }
+
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        self.0.sub_timespec(&other.0)
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime(self.0.checked_add_duration(other)?))
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime(self.0.checked_sub_duration(other)?))
+    }
+}

From 5a98a51987c1fe3a1f6011754a436d4ca62f3cf0 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Fri, 16 Jan 2026 15:19:37 +0100
Subject: [PATCH 16/16] hardcode some Windows constants in miri

The `std` paths are subject to change, but the values themselves will never
change.
---
 src/tools/miri/src/shims/time.rs | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/src/tools/miri/src/shims/time.rs b/src/tools/miri/src/shims/time.rs
index c49aa9f20f6c0..865a80251e314 100644
--- a/src/tools/miri/src/shims/time.rs
+++ b/src/tools/miri/src/shims/time.rs
@@ -275,26 +275,23 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         interp_ok(Scalar::from_i32(-1)) // Return non-zero on success
     }
 
-    #[allow(non_snake_case, clippy::arithmetic_side_effects)]
+    #[allow(clippy::arithmetic_side_effects)]
     fn system_time_since_windows_epoch(&self, time: &SystemTime) -> InterpResult<'tcx, Duration> {
-        let this = self.eval_context_ref();
-
-        let INTERVALS_PER_SEC = this.eval_windows_u64("time", "INTERVALS_PER_SEC");
-        let INTERVALS_TO_UNIX_EPOCH = this.eval_windows_u64("time", "INTERVALS_TO_UNIX_EPOCH");
-        let SECONDS_TO_UNIX_EPOCH = INTERVALS_TO_UNIX_EPOCH / INTERVALS_PER_SEC;
+        // The amount of seconds between 1601/1/1 and 1970/1/1.
+        // See https://learn.microsoft.com/en-us/windows/win32/sysinfo/converting-a-time-t-value-to-a-file-time
+        // (just divide by the number of 100 ns intervals per second).
+        const SECONDS_TO_UNIX_EPOCH: u64 = 11_644_473_600;
 
         interp_ok(system_time_to_duration(time)? + Duration::from_secs(SECONDS_TO_UNIX_EPOCH))
     }
 
     #[allow(non_snake_case, clippy::arithmetic_side_effects)]
     fn windows_ticks_for(&self, duration: Duration) -> InterpResult<'tcx, u64> {
-        let this = self.eval_context_ref();
-
-        let NANOS_PER_SEC = this.eval_windows_u64("time", "NANOS_PER_SEC");
-        let INTERVALS_PER_SEC = this.eval_windows_u64("time", "INTERVALS_PER_SEC");
-        let NANOS_PER_INTERVAL = NANOS_PER_SEC / INTERVALS_PER_SEC;
+        // 1 interval = 100 ns.
+        // See https://learn.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
+        const NANOS_PER_INTERVAL: u128 = 100;
 
-        let ticks = u64::try_from(duration.as_nanos() / u128::from(NANOS_PER_INTERVAL))
+        let ticks = u64::try_from(duration.as_nanos() / NANOS_PER_INTERVAL)
             .map_err(|_| err_unsup_format!("programs running more than 2^64 Windows ticks after the Windows epoch are not supported"))?;
         interp_ok(ticks)
     }