From 7c92bc248ea420ed1ab76881c625de62fa0e35f0 Mon Sep 17 00:00:00 2001
From: Andrew Lilley Brinker <alilleybrinker@gmail.com>
Date: Tue, 18 Nov 2025 09:57:45 -0800
Subject: [PATCH 1/2] Fully qualify std Result type

The prior macro expansion could produce errors if the macros were
called in a context where `Result` is redefined, for example in a
crate with its own `Result` type which pre-fills the error type. This
replaces existing `Result` uses with `std::result::Result` to avoid
the compilation error in that case.

Signed-off-by: Andrew Lilley Brinker <alilleybrinker@gmail.com>
---
 .../salsa-macro-rules/src/setup_input_struct.rs   |  8 ++++----
 .../src/setup_interned_struct.rs                  |  8 ++++----
 .../salsa-macro-rules/src/setup_tracked_fn.rs     |  8 ++++----
 .../salsa-macro-rules/src/setup_tracked_struct.rs |  8 ++++----
 .../redefine-result-input-struct-derive.rs        | 15 +++++++++++++++
 tests/compile_pass.rs                             |  8 ++++++++
 6 files changed, 39 insertions(+), 16 deletions(-)
 create mode 100644 tests/compile-pass/redefine-result-input-struct-derive.rs
 create mode 100644 tests/compile_pass.rs

diff --git a/components/salsa-macro-rules/src/setup_input_struct.rs b/components/salsa-macro-rules/src/setup_input_struct.rs
index 741f9393e..837f5d3aa 100644
--- a/components/salsa-macro-rules/src/setup_input_struct.rs
+++ b/components/salsa-macro-rules/src/setup_input_struct.rs
@@ -123,7 +123,7 @@ macro_rules! setup_input_struct {
                 fn serialize<S: $zalsa::serde::Serializer>(
                     fields: &Self::Fields,
                     serializer: S,
-                ) -> Result<S::Ok, S::Error> {
+                ) -> std::result::Result<S::Ok, S::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($serialize_fn(fields, serializer))?
@@ -135,7 +135,7 @@ macro_rules! setup_input_struct {
 
                 fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                     deserializer: D,
-                ) -> Result<Self::Fields, D::Error> {
+                ) -> std::result::Result<Self::Fields, D::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($deserialize_fn(deserializer))?
@@ -241,7 +241,7 @@ macro_rules! setup_input_struct {
 
             $zalsa::macro_if! { $persist =>
                 impl $zalsa::serde::Serialize for $Struct {
-                    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                     where
                         S: $zalsa::serde::Serializer,
                     {
@@ -250,7 +250,7 @@ macro_rules! setup_input_struct {
                 }
 
                 impl<'de> $zalsa::serde::Deserialize<'de> for $Struct {
-                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                     where
                         D: $zalsa::serde::Deserializer<'de>,
                     {
diff --git a/components/salsa-macro-rules/src/setup_interned_struct.rs b/components/salsa-macro-rules/src/setup_interned_struct.rs
index 1d27a33a2..ed439bb4a 100644
--- a/components/salsa-macro-rules/src/setup_interned_struct.rs
+++ b/components/salsa-macro-rules/src/setup_interned_struct.rs
@@ -171,7 +171,7 @@ macro_rules! setup_interned_struct {
                 fn serialize<S: $zalsa::serde::Serializer>(
                     fields: &Self::Fields<'_>,
                     serializer: S,
-                ) -> Result<S::Ok, S::Error> {
+                ) -> std::result::Result<S::Ok, S::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($serialize_fn(fields, serializer))?
@@ -183,7 +183,7 @@ macro_rules! setup_interned_struct {
 
                 fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                     deserializer: D,
-                ) -> Result<Self::Fields<'static>, D::Error> {
+                ) -> std::result::Result<Self::Fields<'static>, D::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($deserialize_fn(deserializer))?
@@ -269,7 +269,7 @@ macro_rules! setup_interned_struct {
 
             $zalsa::macro_if! { $persist =>
                 impl<$($db_lt_arg)?> $zalsa::serde::Serialize for $Struct<$($db_lt_arg)?> {
-                    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                     where
                         S: $zalsa::serde::Serializer,
                     {
@@ -278,7 +278,7 @@ macro_rules! setup_interned_struct {
                 }
 
                 impl<'de, $($db_lt_arg)?> $zalsa::serde::Deserialize<'de> for $Struct<$($db_lt_arg)?> {
-                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                     where
                         D: $zalsa::serde::Deserializer<'de>,
                     {
diff --git a/components/salsa-macro-rules/src/setup_tracked_fn.rs b/components/salsa-macro-rules/src/setup_tracked_fn.rs
index 1c3312372..2bbf0338f 100644
--- a/components/salsa-macro-rules/src/setup_tracked_fn.rs
+++ b/components/salsa-macro-rules/src/setup_tracked_fn.rs
@@ -181,7 +181,7 @@ macro_rules! setup_tracked_fn {
                         fn serialize<S: $zalsa::serde::Serializer>(
                             fields: &Self::Fields<'_>,
                             serializer: S,
-                        ) -> Result<S::Ok, S::Error> {
+                        ) -> std::result::Result<S::Ok, S::Error> {
                             $zalsa::macro_if! {
                                 if $persist {
                                     $zalsa::serde::Serialize::serialize(fields, serializer)
@@ -193,7 +193,7 @@ macro_rules! setup_tracked_fn {
 
                         fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                             deserializer: D,
-                        ) -> Result<Self::Fields<'static>, D::Error> {
+                        ) -> std::result::Result<Self::Fields<'static>, D::Error> {
                             $zalsa::macro_if! {
                                 if $persist {
                                     $zalsa::serde::Deserialize::deserialize(deserializer)
@@ -330,7 +330,7 @@ macro_rules! setup_tracked_fn {
                 fn serialize<S: $zalsa::serde::Serializer>(
                     value: &Self::Output<'_>,
                     serializer: S,
-                ) -> Result<S::Ok, S::Error> {
+                ) -> std::result::Result<S::Ok, S::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $zalsa::serde::Serialize::serialize(value, serializer)
@@ -342,7 +342,7 @@ macro_rules! setup_tracked_fn {
 
                 fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                     deserializer: D,
-                ) -> Result<Self::Output<'static>, D::Error> {
+                ) -> std::result::Result<Self::Output<'static>, D::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $zalsa::serde::Deserialize::deserialize(deserializer)
diff --git a/components/salsa-macro-rules/src/setup_tracked_struct.rs b/components/salsa-macro-rules/src/setup_tracked_struct.rs
index 92dc25974..68a512126 100644
--- a/components/salsa-macro-rules/src/setup_tracked_struct.rs
+++ b/components/salsa-macro-rules/src/setup_tracked_struct.rs
@@ -209,7 +209,7 @@ macro_rules! setup_tracked_struct {
                 fn serialize<S: $zalsa::serde::Serializer>(
                     fields: &Self::Fields<'_>,
                     serializer: S,
-                ) -> Result<S::Ok, S::Error> {
+                ) -> std::result::Result<S::Ok, S::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($serialize_fn(fields, serializer))?
@@ -221,7 +221,7 @@ macro_rules! setup_tracked_struct {
 
                 fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                     deserializer: D,
-                ) -> Result<Self::Fields<'static>, D::Error> {
+                ) -> std::result::Result<Self::Fields<'static>, D::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($deserialize_fn(deserializer))?
@@ -307,7 +307,7 @@ macro_rules! setup_tracked_struct {
 
             $zalsa::macro_if! { $persist =>
                 impl $zalsa::serde::Serialize for $Struct<'_> {
-                    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                     where
                         S: $zalsa::serde::Serializer,
                     {
@@ -316,7 +316,7 @@ macro_rules! setup_tracked_struct {
                 }
 
                 impl<'de> $zalsa::serde::Deserialize<'de> for $Struct<'_> {
-                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                     where
                         D: $zalsa::serde::Deserializer<'de>,
                     {
diff --git a/tests/compile-pass/redefine-result-input-struct-derive.rs b/tests/compile-pass/redefine-result-input-struct-derive.rs
new file mode 100644
index 000000000..7615cb286
--- /dev/null
+++ b/tests/compile-pass/redefine-result-input-struct-derive.rs
@@ -0,0 +1,15 @@
+// Ensure the `salsa::tracked` attribute macro doesn't conflict with local
+// redefinition of the `Result` type.
+//
+// See: https://github.com/salsa-rs/salsa/pull/1025
+
+type Result<T> = std::result::Result<T, String>;
+
+#[salsa::tracked]
+fn example_query(_db: &dyn salsa::Database) -> Result<()> {
+    Ok(())
+}
+
+fn main() {
+    println!("Hello, world!");
+}
diff --git a/tests/compile_pass.rs b/tests/compile_pass.rs
new file mode 100644
index 000000000..d6a5265a3
--- /dev/null
+++ b/tests/compile_pass.rs
@@ -0,0 +1,8 @@
+#![cfg(all(feature = "inventory", feature = "persistence"))]
+
+#[rustversion::all(stable, since(1.90))]
+#[test]
+fn compile_pass() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/compile-pass/*.rs");
+}

From 868f63730d5635c377c2501a5d8dac0ae7e77bff Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@reiser.io>
Date: Wed, 26 Nov 2025 08:23:37 +0100
Subject: [PATCH 2/2] Use qualified names

---
 .../src/setup_input_struct.rs                 | 32 +++++++--------
 .../src/setup_interned_struct.rs              | 40 +++++++++----------
 .../salsa-macro-rules/src/setup_tracked_fn.rs | 32 +++++++--------
 .../src/setup_tracked_struct.rs               | 28 ++++++-------
 4 files changed, 66 insertions(+), 66 deletions(-)

diff --git a/components/salsa-macro-rules/src/setup_input_struct.rs b/components/salsa-macro-rules/src/setup_input_struct.rs
index 837f5d3aa..d3c897045 100644
--- a/components/salsa-macro-rules/src/setup_input_struct.rs
+++ b/components/salsa-macro-rules/src/setup_input_struct.rs
@@ -81,7 +81,7 @@ macro_rules! setup_input_struct {
         #[allow(clippy::all)]
         #[allow(dead_code)]
         const _: () = {
-            use salsa::plumbing as $zalsa;
+            use ::salsa::plumbing as $zalsa;
             use $zalsa::input as $zalsa_struct;
 
             type $Configuration = $Struct;
@@ -123,7 +123,7 @@ macro_rules! setup_input_struct {
                 fn serialize<S: $zalsa::serde::Serializer>(
                     fields: &Self::Fields,
                     serializer: S,
-                ) -> std::result::Result<S::Ok, S::Error> {
+                ) -> ::std::result::Result<S::Ok, S::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($serialize_fn(fields, serializer))?
@@ -135,7 +135,7 @@ macro_rules! setup_input_struct {
 
                 fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                     deserializer: D,
-                ) -> std::result::Result<Self::Fields, D::Error> {
+                ) -> ::std::result::Result<Self::Fields, D::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($deserialize_fn(deserializer))?
@@ -198,8 +198,8 @@ macro_rules! setup_input_struct {
             }
 
             $zalsa::macro_if! { $generate_debug_impl =>
-                impl std::fmt::Debug for $Struct {
-                    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                impl ::std::fmt::Debug for $Struct {
+                    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                         Self::default_debug_fmt(*self, f)
                     }
                 }
@@ -241,7 +241,7 @@ macro_rules! setup_input_struct {
 
             $zalsa::macro_if! { $persist =>
                 impl $zalsa::serde::Serialize for $Struct {
-                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+                    fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
                     where
                         S: $zalsa::serde::Serializer,
                     {
@@ -250,7 +250,7 @@ macro_rules! setup_input_struct {
                 }
 
                 impl<'de> $zalsa::serde::Deserialize<'de> for $Struct {
-                    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+                    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
                     where
                         D: $zalsa::serde::Deserializer<'de>,
                     {
@@ -310,7 +310,7 @@ macro_rules! setup_input_struct {
                             self,
                             $field_index,
                             ingredient,
-                            |fields, f| std::mem::replace(&mut fields.$field_index, f),
+                            |fields, f| ::std::mem::replace(&mut fields.$field_index, f),
                         )
                     }
                 )*
@@ -336,11 +336,11 @@ macro_rules! setup_input_struct {
                 }
 
                 /// Default debug formatting for this struct (may be useful if you define your own `Debug` impl)
-                pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+                pub fn default_debug_fmt(this: Self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result
                 where
                     // rustc rejects trivial bounds, but it cannot see through higher-ranked bounds
                     // with its check :^)
-                    $(for<'__trivial_bounds> $field_ty: std::fmt::Debug),*
+                    $(for<'__trivial_bounds> $field_ty: ::std::fmt::Debug),*
                 {
                     $zalsa::with_attached_database(|db| {
                         let zalsa = db.zalsa();
@@ -371,7 +371,7 @@ macro_rules! setup_input_struct {
                 pub fn new<$Db>(self, db: &$Db) -> $Struct
                 where
                     // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
-                    $Db: ?Sized + salsa::Database
+                    $Db: ?Sized + ::salsa::Database
                 {
                     let (zalsa, zalsa_local) = db.zalsas();
                     let current_revision = zalsa.current_revision();
@@ -384,7 +384,7 @@ macro_rules! setup_input_struct {
             mod builder {
                 use super::*;
 
-                use salsa::plumbing as $zalsa;
+                use ::salsa::plumbing as $zalsa;
                 use $zalsa::input as $zalsa_struct;
 
                 // These are standalone functions instead of methods on `Builder` to prevent
@@ -392,7 +392,7 @@ macro_rules! setup_input_struct {
                 pub(super) fn new_builder($($field_id: $field_ty),*) -> $Builder {
                     $Builder {
                         fields: ($($field_id,)*),
-                        durabilities: [salsa::Durability::default(); $N],
+                        durabilities: [::salsa::Durability::default(); $N],
                     }
                 }
 
@@ -406,14 +406,14 @@ macro_rules! setup_input_struct {
                     fields: ($($field_ty,)*),
 
                     /// The durabilities per field.
-                    durabilities: [salsa::Durability; $N],
+                    durabilities: [::salsa::Durability; $N],
                 }
 
                 impl $Builder {
                     /// Sets the durability of all fields.
                     ///
                     /// Overrides any previously set durabilities.
-                    pub fn durability(mut self, durability: salsa::Durability) -> Self {
+                    pub fn durability(mut self, durability: ::salsa::Durability) -> Self {
                         self.durabilities = [durability; $N];
                         self
                     }
@@ -431,7 +431,7 @@ macro_rules! setup_input_struct {
                     $(
                         /// Sets the durability for the field `$field_id`.
                         #[must_use]
-                        pub fn $field_durability_id(mut self, durability: salsa::Durability) -> Self
+                        pub fn $field_durability_id(mut self, durability: ::salsa::Durability) -> Self
                         {
                             self.durabilities[$field_index] = durability;
                             self
diff --git a/components/salsa-macro-rules/src/setup_interned_struct.rs b/components/salsa-macro-rules/src/setup_interned_struct.rs
index ed439bb4a..b069bcac9 100644
--- a/components/salsa-macro-rules/src/setup_interned_struct.rs
+++ b/components/salsa-macro-rules/src/setup_interned_struct.rs
@@ -99,7 +99,7 @@ macro_rules! setup_interned_struct {
         #[allow(clippy::all)]
         #[allow(dead_code)]
         const _: () = {
-            use salsa::plumbing as $zalsa;
+            use ::salsa::plumbing as $zalsa;
             use $zalsa::interned as $zalsa_struct;
 
             type $Configuration = $StructWithStatic;
@@ -120,7 +120,7 @@ macro_rules! setup_interned_struct {
             #[derive(Hash)]
             struct StructKey<$db_lt, $($indexed_ty),*>(
                 $($indexed_ty,)*
-                std::marker::PhantomData<&$db_lt ()>,
+                ::std::marker::PhantomData<&$db_lt ()>,
             );
 
             impl<$db_lt, $($indexed_ty,)*> $zalsa::interned::HashEqLike<StructKey<$db_lt, $($indexed_ty),*>>
@@ -129,7 +129,7 @@ macro_rules! setup_interned_struct {
                 $($field_ty: $zalsa::interned::HashEqLike<$indexed_ty>),*
                 {
 
-                fn hash<H: std::hash::Hasher>(&self, h: &mut H) {
+                fn hash<H: ::std::hash::Hasher>(&self, h: &mut H) {
                     $($zalsa::interned::HashEqLike::<$indexed_ty>::hash(&self.$field_index, &mut *h);)*
                 }
 
@@ -147,7 +147,7 @@ macro_rules! setup_interned_struct {
                 }
             }
 
-            impl salsa::plumbing::interned::Configuration for $StructWithStatic {
+            impl $zalsa::interned::Configuration for $StructWithStatic {
                 const LOCATION: $zalsa::Location = $zalsa::Location {
                     file: file!(),
                     line: line!(),
@@ -171,7 +171,7 @@ macro_rules! setup_interned_struct {
                 fn serialize<S: $zalsa::serde::Serializer>(
                     fields: &Self::Fields<'_>,
                     serializer: S,
-                ) -> std::result::Result<S::Ok, S::Error> {
+                ) -> ::std::result::Result<S::Ok, S::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($serialize_fn(fields, serializer))?
@@ -183,7 +183,7 @@ macro_rules! setup_interned_struct {
 
                 fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                     deserializer: D,
-                ) -> std::result::Result<Self::Fields<'static>, D::Error> {
+                ) -> ::std::result::Result<Self::Fields<'static>, D::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($deserialize_fn(deserializer))?
@@ -210,14 +210,14 @@ macro_rules! setup_interned_struct {
             }
 
             impl< $($db_lt_arg)? > $zalsa::AsId for $Struct< $($db_lt_arg)? > {
-                fn as_id(&self) -> salsa::Id {
+                fn as_id(&self) -> ::salsa::Id {
                     self.0.as_id()
                 }
             }
 
             impl< $($db_lt_arg)? > $zalsa::FromId for $Struct< $($db_lt_arg)? > {
-                fn from_id(id: salsa::Id) -> Self {
-                    Self(<$Id>::from_id(id), std::marker::PhantomData)
+                fn from_id(id: ::salsa::Id) -> Self {
+                    Self(<$Id>::from_id(id), ::std::marker::PhantomData)
                 }
             }
 
@@ -226,8 +226,8 @@ macro_rules! setup_interned_struct {
             unsafe impl< $($db_lt_arg)? > Sync for $Struct< $($db_lt_arg)? > {}
 
             $zalsa::macro_if! { $generate_debug_impl =>
-                impl< $($db_lt_arg)? > std::fmt::Debug for $Struct< $($db_lt_arg)? > {
-                    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                impl< $($db_lt_arg)? > ::std::fmt::Debug for $Struct< $($db_lt_arg)? > {
+                    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                         Self::default_debug_fmt(*self, f)
                     }
                 }
@@ -269,7 +269,7 @@ macro_rules! setup_interned_struct {
 
             $zalsa::macro_if! { $persist =>
                 impl<$($db_lt_arg)?> $zalsa::serde::Serialize for $Struct<$($db_lt_arg)?> {
-                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+                    fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
                     where
                         S: $zalsa::serde::Serializer,
                     {
@@ -278,7 +278,7 @@ macro_rules! setup_interned_struct {
                 }
 
                 impl<'de, $($db_lt_arg)?> $zalsa::serde::Deserialize<'de> for $Struct<$($db_lt_arg)?> {
-                    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+                    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
                     where
                         D: $zalsa::serde::Deserializer<'de>,
                     {
@@ -301,17 +301,17 @@ macro_rules! setup_interned_struct {
             }
 
             impl<$db_lt> $Struct< $($db_lt_arg)? >  {
-                pub fn $new_fn<$Db, $($indexed_ty: $zalsa::interned::Lookup<$field_ty> + std::hash::Hash,)*>(db: &$db_lt $Db,  $($field_id: $indexed_ty),*) -> Self
+                pub fn $new_fn<$Db, $($indexed_ty: $zalsa::interned::Lookup<$field_ty> + ::std::hash::Hash,)*>(db: &$db_lt $Db,  $($field_id: $indexed_ty),*) -> Self
                 where
                     // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
-                    $Db: ?Sized + salsa::Database,
+                    $Db: ?Sized + ::salsa::Database,
                     $(
                         $field_ty: $zalsa::interned::HashEqLike<$indexed_ty>,
                     )*
                 {
                     let (zalsa, zalsa_local) = db.zalsas();
                     $Configuration::ingredient(zalsa).intern(zalsa, zalsa_local,
-                        StructKey::<$db_lt>($($field_id,)* std::marker::PhantomData::default()), |_, data| ($($zalsa::interned::Lookup::into_owned(data.$field_index),)*))
+                        StructKey::<$db_lt>($($field_id,)* ::std::marker::PhantomData::default()), |_, data| ($($zalsa::interned::Lookup::into_owned(data.$field_index),)*))
                 }
 
                 $(
@@ -337,11 +337,11 @@ macro_rules! setup_interned_struct {
                 iftt ($($db_lt_arg)?) {
                     impl $Struct<'_> {
                         /// Default debug formatting for this struct (may be useful if you define your own `Debug` impl)
-                        pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+                        pub fn default_debug_fmt(this: Self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result
                         where
                             // rustc rejects trivial bounds, but it cannot see through higher-ranked bounds
                             // with its check :^)
-                            $(for<$db_lt> $field_ty: std::fmt::Debug),*
+                            $(for<$db_lt> $field_ty: ::std::fmt::Debug),*
                         {
                             $zalsa::with_attached_database(|db| {
                                 let zalsa = db.zalsa();
@@ -361,11 +361,11 @@ macro_rules! setup_interned_struct {
                 } else {
                     impl $Struct {
                         /// Default debug formatting for this struct (may be useful if you define your own `Debug` impl)
-                        pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+                        pub fn default_debug_fmt(this: Self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result
                         where
                             // rustc rejects trivial bounds, but it cannot see through higher-ranked bounds
                             // with its check :^)
-                            $(for<$db_lt> $field_ty: std::fmt::Debug),*
+                            $(for<$db_lt> $field_ty: ::std::fmt::Debug),*
                         {
                             $zalsa::with_attached_database(|db| {
                                 let zalsa = db.zalsa();
diff --git a/components/salsa-macro-rules/src/setup_tracked_fn.rs b/components/salsa-macro-rules/src/setup_tracked_fn.rs
index 2bbf0338f..6e9ef9f2f 100644
--- a/components/salsa-macro-rules/src/setup_tracked_fn.rs
+++ b/components/salsa-macro-rules/src/setup_tracked_fn.rs
@@ -89,8 +89,8 @@ macro_rules! setup_tracked_fn {
         $vis fn $fn_name<$db_lt>(
             $db: &$db_lt dyn $Db,
             $($input_id: $input_ty,)*
-        ) -> salsa::plumbing::return_mode_ty!(($return_mode, __, __), $db_lt, $output_ty) {
-            use salsa::plumbing as $zalsa;
+        ) -> ::salsa::plumbing::return_mode_ty!(($return_mode, __, __), $db_lt, $output_ty) {
+            use ::salsa::plumbing as $zalsa;
 
             struct $Configuration;
 
@@ -111,8 +111,8 @@ macro_rules! setup_tracked_fn {
                 if $needs_interner {
                     #[derive(Copy, Clone)]
                     struct $InternedData<$db_lt>(
-                        salsa::Id,
-                        std::marker::PhantomData<fn() -> &$db_lt ()>,
+                        ::salsa::Id,
+                        ::std::marker::PhantomData<fn() -> &$db_lt ()>,
                     );
 
                     static $INTERN_CACHE: $zalsa::IngredientCache<$zalsa::interned::IngredientImpl<$Configuration>> =
@@ -154,14 +154,14 @@ macro_rules! setup_tracked_fn {
 
                     impl $zalsa::AsId for $InternedData<'_> {
                         #[inline]
-                        fn as_id(&self) -> salsa::Id {
+                        fn as_id(&self) -> ::salsa::Id {
                             self.0
                         }
                     }
 
                     impl $zalsa::FromId for $InternedData<'_> {
                         #[inline]
-                        fn from_id(id: salsa::Id) -> Self {
+                        fn from_id(id: ::salsa::Id) -> Self {
                             Self(id, ::core::marker::PhantomData)
                         }
                     }
@@ -181,7 +181,7 @@ macro_rules! setup_tracked_fn {
                         fn serialize<S: $zalsa::serde::Serializer>(
                             fields: &Self::Fields<'_>,
                             serializer: S,
-                        ) -> std::result::Result<S::Ok, S::Error> {
+                        ) -> ::std::result::Result<S::Ok, S::Error> {
                             $zalsa::macro_if! {
                                 if $persist {
                                     $zalsa::serde::Serialize::serialize(fields, serializer)
@@ -193,7 +193,7 @@ macro_rules! setup_tracked_fn {
 
                         fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                             deserializer: D,
-                        ) -> std::result::Result<Self::Fields<'static>, D::Error> {
+                        ) -> ::std::result::Result<Self::Fields<'static>, D::Error> {
                             $zalsa::macro_if! {
                                 if $persist {
                                     $zalsa::serde::Deserialize::deserialize(deserializer)
@@ -302,13 +302,13 @@ macro_rules! setup_tracked_fn {
                     $inner($db, $($input_id),*)
                 }
 
-                fn cycle_initial<$db_lt>(db: &$db_lt Self::DbView, id: salsa::Id, ($($input_id),*): ($($interned_input_ty),*)) -> Self::Output<$db_lt> {
+                fn cycle_initial<$db_lt>(db: &$db_lt Self::DbView, id: ::salsa::Id, ($($input_id),*): ($($interned_input_ty),*)) -> Self::Output<$db_lt> {
                     $($cycle_recovery_initial)*(db, id, $($input_id),*)
                 }
 
                 fn recover_from_cycle<$db_lt>(
                     db: &$db_lt dyn $Db,
-                    id: salsa::Id,
+                    id: ::salsa::Id,
                     last_provisional_value: &Self::Output<$db_lt>,
                     value: Self::Output<$db_lt>,
                     iteration_count: u32,
@@ -317,7 +317,7 @@ macro_rules! setup_tracked_fn {
                     $($cycle_recovery_fn)*(db, id, last_provisional_value, value, iteration_count, $($input_id),*)
                 }
 
-                fn id_to_input<$db_lt>(zalsa: &$db_lt $zalsa::Zalsa, key: salsa::Id) -> Self::Input<$db_lt> {
+                fn id_to_input<$db_lt>(zalsa: &$db_lt $zalsa::Zalsa, key: ::salsa::Id) -> Self::Input<$db_lt> {
                     $zalsa::macro_if! {
                         if $needs_interner {
                             $Configuration::intern_ingredient_(zalsa).data(zalsa, key).clone()
@@ -330,7 +330,7 @@ macro_rules! setup_tracked_fn {
                 fn serialize<S: $zalsa::serde::Serializer>(
                     value: &Self::Output<'_>,
                     serializer: S,
-                ) -> std::result::Result<S::Ok, S::Error> {
+                ) -> ::std::result::Result<S::Ok, S::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $zalsa::serde::Serialize::serialize(value, serializer)
@@ -342,7 +342,7 @@ macro_rules! setup_tracked_fn {
 
                 fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                     deserializer: D,
-                ) -> std::result::Result<Self::Output<'static>, D::Error> {
+                ) -> ::std::result::Result<Self::Output<'static>, D::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $zalsa::serde::Deserialize::deserialize(deserializer)
@@ -420,11 +420,11 @@ macro_rules! setup_tracked_fn {
             #[allow(non_local_definitions)]
             impl $fn_name {
                 $zalsa::gate_accumulated! {
-                    pub fn accumulated<$db_lt, A: salsa::Accumulator>(
+                    pub fn accumulated<$db_lt, A: ::salsa::Accumulator>(
                         $db: &$db_lt dyn $Db,
                         $($input_id: $interned_input_ty,)*
                     ) -> Vec<&$db_lt A> {
-                        use salsa::plumbing as $zalsa;
+                        use ::salsa::plumbing as $zalsa;
                         let key = $zalsa::macro_if! {
                             if $needs_interner {{
                                 let (zalsa, zalsa_local) = $db.zalsas();
@@ -492,7 +492,7 @@ macro_rules! setup_tracked_fn {
         #[doc(hidden)]
         #[allow(non_camel_case_types)]
         $vis struct $fn_name {
-            _priv: std::convert::Infallible,
+            _priv: ::std::convert::Infallible,
         }
     };
 }
diff --git a/components/salsa-macro-rules/src/setup_tracked_struct.rs b/components/salsa-macro-rules/src/setup_tracked_struct.rs
index 68a512126..970cb31d6 100644
--- a/components/salsa-macro-rules/src/setup_tracked_struct.rs
+++ b/components/salsa-macro-rules/src/setup_tracked_struct.rs
@@ -115,14 +115,14 @@ macro_rules! setup_tracked_struct {
         $(#[$attr])*
         #[derive(Copy, Clone, PartialEq, Eq, Hash)]
         $vis struct $Struct<$db_lt>(
-            salsa::Id,
-            std::marker::PhantomData<fn() -> &$db_lt ()>
+            ::salsa::Id,
+            ::std::marker::PhantomData<fn() -> &$db_lt ()>
         );
 
         #[allow(dead_code)]
         #[allow(clippy::all)]
         const _: () = {
-            use salsa::plumbing as $zalsa;
+            use ::salsa::plumbing as $zalsa;
             use $zalsa::tracked_struct as $zalsa_struct;
             use $zalsa::Revision as $Revision;
 
@@ -160,7 +160,7 @@ macro_rules! setup_tracked_struct {
 
                 type Struct<$db_lt> = $Struct<$db_lt>;
 
-                fn untracked_fields(fields: &Self::Fields<'_>) -> impl std::hash::Hash {
+                fn untracked_fields(fields: &Self::Fields<'_>) -> impl ::std::hash::Hash {
                     ( $( &fields.$absolute_untracked_index ),* )
                 }
 
@@ -209,7 +209,7 @@ macro_rules! setup_tracked_struct {
                 fn serialize<S: $zalsa::serde::Serializer>(
                     fields: &Self::Fields<'_>,
                     serializer: S,
-                ) -> std::result::Result<S::Ok, S::Error> {
+                ) -> ::std::result::Result<S::Ok, S::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($serialize_fn(fields, serializer))?
@@ -221,7 +221,7 @@ macro_rules! setup_tracked_struct {
 
                 fn deserialize<'de, D: $zalsa::serde::Deserializer<'de>>(
                     deserializer: D,
-                ) -> std::result::Result<Self::Fields<'static>, D::Error> {
+                ) -> ::std::result::Result<Self::Fields<'static>, D::Error> {
                     $zalsa::macro_if! {
                         if $persist {
                             $($deserialize_fn(deserializer))?
@@ -253,8 +253,8 @@ macro_rules! setup_tracked_struct {
 
             impl<$db_lt> $zalsa::FromId for $Struct<$db_lt> {
                 #[inline]
-                fn from_id(id: salsa::Id) -> Self {
-                    $Struct(id, std::marker::PhantomData)
+                fn from_id(id: ::salsa::Id) -> Self {
+                    $Struct(id, ::std::marker::PhantomData)
                 }
             }
 
@@ -307,7 +307,7 @@ macro_rules! setup_tracked_struct {
 
             $zalsa::macro_if! { $persist =>
                 impl $zalsa::serde::Serialize for $Struct<'_> {
-                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+                    fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
                     where
                         S: $zalsa::serde::Serializer,
                     {
@@ -316,7 +316,7 @@ macro_rules! setup_tracked_struct {
                 }
 
                 impl<'de> $zalsa::serde::Deserialize<'de> for $Struct<'_> {
-                    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+                    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
                     where
                         D: $zalsa::serde::Deserializer<'de>,
                     {
@@ -332,8 +332,8 @@ macro_rules! setup_tracked_struct {
             unsafe impl Sync for $Struct<'_> {}
 
             $zalsa::macro_if! { $generate_debug_impl =>
-                impl std::fmt::Debug for $Struct<'_> {
-                    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                impl ::std::fmt::Debug for $Struct<'_> {
+                    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                         Self::default_debug_fmt(*self, f)
                     }
                 }
@@ -401,13 +401,13 @@ macro_rules! setup_tracked_struct {
             #[allow(unused_lifetimes)]
             impl<'_db> $Struct<'_db> {
                 /// Default debug formatting for this struct (may be useful if you define your own `Debug` impl)
-                pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+                pub fn default_debug_fmt(this: Self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result
                 where
                     // `zalsa::with_attached_database` has a local lifetime for the database
                     // so we need this function to be higher-ranked over the db lifetime
                     // Thus the actual lifetime of `Self` does not matter here so we discard
                     // it with the `'_db` lifetime name as we cannot shadow lifetimes.
-                    $(for<$db_lt> $field_ty: std::fmt::Debug),*
+                    $(for<$db_lt> $field_ty: ::std::fmt::Debug),*
                 {
                     $zalsa::with_attached_database(|db| {
                         let zalsa = db.zalsa();