rustc_public: Make Id types !Send / !Sync

These types are Id's to a table stored in TLS, so using them from
another tread will either panic, or give wrong results.

Therefor, I've added a `ReferencesTls` marker type, which ensures types
arn't `Send`/`Sync`.

This is a breaking change for users of the `rustc_public` crate.

It also changes how `DefId` and similar are `Serialize`d.

Zulip Discussion: https://rust-lang.zulipchat.com/#narrow/channel/320896-project-stable-mir/topic/WDYM.20.22should.20not.20.20be.20shared.20across.20threads.22/with/547374171

Author: aDotInTheVoid

compiler/rustc_public/src/abi.rs

@@ -7,8 +7,8 @@ use serde::Serialize;
 use crate::compiler_interface::with;
 use crate::mir::FieldIdx;
 use crate::target::{MachineInfo, MachineSize as Size};
-use crate::ty::{Align, Ty, VariantIdx};
-use crate::{Error, Opaque, error};
+use crate::ty::{index_impl, Align, Ty, VariantIdx};
+use crate::{error, Error, Opaque, ReferencesTls};
 
 /// A function ABI definition.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
@@ -110,23 +110,15 @@ impl LayoutShape {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct Layout(usize);
+pub struct Layout(usize, ReferencesTls);
+index_impl!(Layout);
 
 impl Layout {
     pub fn shape(self) -> LayoutShape {
         with(|cx| cx.layout_shape(self))
     }
 }
 
-impl crate::IndexedVal for Layout {
-    fn to_val(index: usize) -> Self {
-        Layout(index)
-    }
-    fn to_index(&self) -> usize {
-        self.0
-    }
-}
-
 /// Describes how the fields of a type are shaped in memory.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
 pub enum FieldsShape {

compiler/rustc_public/src/compiler_interface.rs

@@ -25,7 +25,7 @@ use crate::ty::{
 use crate::unstable::{RustcInternal, Stable, new_item_kind};
 use crate::{
     AssocItems, Crate, CrateDef, CrateItem, CrateItems, CrateNum, DefId, Error, Filename,
-    ImplTraitDecls, ItemKind, Symbol, TraitDecls, alloc, mir,
+    ImplTraitDecls, ItemKind, ReferencesTls, Symbol, TraitDecls, alloc, mir,
 };
 
 pub struct BridgeTys;
@@ -1095,5 +1095,5 @@ fn smir_crate<'tcx>(
     let is_local = cx.crate_is_local(crate_num);
     let id = cx.crate_num_id(crate_num);
     debug!(?name, ?crate_num, "smir_crate");
-    Crate { id, name, is_local }
+    Crate { id, name, is_local, references_tls: ReferencesTLS }
 }

compiler/rustc_public/src/crate_def.rs

@@ -3,12 +3,13 @@
 
 use serde::Serialize;
 
-use crate::ty::{GenericArgs, Span, Ty};
-use crate::{AssocItems, Crate, Symbol, with};
+use crate::ty::{GenericArgs, Span, Ty, index_impl};
+use crate::{AssocItems, Crate, ReferencesTls, Symbol, with};
 
 /// A unique identification number for each item accessible for the current compilation unit.
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub struct DefId(pub(crate) usize);
+pub struct DefId(pub(crate) usize, ReferencesTls);
+index_impl!(DefId);
 
 impl DefId {
     /// Return fully qualified name of this definition

compiler/rustc_public/src/lib.rs

@@ -20,11 +20,12 @@
 //! [crates.io](https://crates.io).
 
 use std::fmt::Debug;
+use std::marker::PhantomData;
 use std::{fmt, io};
 
+use rustc_public_bridge::context::CompilerCtxt;
 pub(crate) use rustc_public_bridge::IndexedVal;
 use rustc_public_bridge::Tables;
-use rustc_public_bridge::context::CompilerCtxt;
 /// Export the rustc_internal APIs. Note that this module has no stability
 /// guarantees and it is not taken into account for semver.
 #[cfg(feature = "rustc_internal")]
@@ -56,6 +57,7 @@ pub mod visitor;
 pub type Symbol = String;
 
 /// The number that identifies a crate.
+// FIXME: Make this a newtype, so it can have a `ReferencesTls`
 pub type CrateNum = usize;
 
 impl Debug for DefId {
@@ -64,16 +66,6 @@ impl Debug for DefId {
     }
 }
 
-impl IndexedVal for DefId {
-    fn to_val(index: usize) -> Self {
-        DefId(index)
-    }
-
-    fn to_index(&self) -> usize {
-        self.0
-    }
-}
-
 /// A list of crate items.
 pub type CrateItems = Vec<CrateItem>;
 
@@ -92,6 +84,9 @@ pub struct Crate {
     pub id: CrateNum,
     pub name: Symbol,
     pub is_local: bool,
+    // FIXME: Remove this when `CrateNum` holds `ReferencesTLS`
+    #[serde(skip)]
+    references_tls: ReferencesTls,
 }
 
 impl Crate {
@@ -300,3 +295,26 @@ impl rustc_public_bridge::bridge::Allocation<compiler_interface::BridgeTys>
         }
     }
 }
+
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Default)]
+#[derive(serde::Serialize)] // TODO: Don't.
+/// Marker type for indexes into [`TLV`].
+///
+/// Makes things `!Send`/`!Sync`, so users don't move `rustc_public`` types to
+/// thread with no (or worse, different) `rustc_public` pointer.
+///
+/// Note. This doens't make it impossible to confuse TLS. You could return a
+/// `DefId` from one `run!` invocation, and then use it inside a different
+/// `run!` invocation with different tables.
+pub(crate) struct ReferencesTls {
+    _phantom: PhantomData<*const ()>,
+}
+#[expect(non_upper_case_globals)]
+/// Emulating unit struct `struct ReferencesTLS`;
+pub(crate) const ReferencesTLS: ReferencesTls = ReferencesTls { _phantom: PhantomData };
+
+impl fmt::Debug for ReferencesTls {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("ReferencesTLS").finish()
+    }
+}

compiler/rustc_public/src/mir/alloc.rs

@@ -6,8 +6,8 @@ use serde::Serialize;
 
 use crate::mir::mono::{Instance, StaticDef};
 use crate::target::{Endian, MachineInfo};
-use crate::ty::{Allocation, Binder, ExistentialTraitRef, Ty};
-use crate::{Error, IndexedVal, with};
+use crate::ty::{index_impl, Allocation, Binder, ExistentialTraitRef, Ty};
+use crate::{with, Error, ReferencesTls};
 
 /// An allocation in the rustc_public's IR global memory can be either a function pointer,
 /// a static, or a "real" allocation with some data in it.
@@ -48,16 +48,8 @@ impl GlobalAlloc {
 
 /// A unique identification number for each provenance
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
-pub struct AllocId(usize);
-
-impl IndexedVal for AllocId {
-    fn to_val(index: usize) -> Self {
-        AllocId(index)
-    }
-    fn to_index(&self) -> usize {
-        self.0
-    }
-}
+pub struct AllocId(usize, ReferencesTls);
+index_impl!(AllocId);
 
 /// Utility function used to read an allocation data into a unassigned integer.
 pub(crate) fn read_target_uint(mut bytes: &[u8]) -> Result<u128, Error> {

compiler/rustc_public/src/mir/mono.rs

@@ -7,8 +7,8 @@ use serde::Serialize;
 use crate::abi::FnAbi;
 use crate::crate_def::CrateDef;
 use crate::mir::Body;
-use crate::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, Ty};
-use crate::{CrateItem, DefId, Error, IndexedVal, ItemKind, Opaque, Symbol, with};
+use crate::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, Ty, index_impl};
+use crate::{CrateItem, DefId, Error, ItemKind, Opaque, ReferencesTls, Symbol, with};
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
 pub enum MonoItem {
@@ -242,7 +242,8 @@ impl From<StaticDef> for CrateItem {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct InstanceDef(usize);
+pub struct InstanceDef(usize, ReferencesTls);
+index_impl!(InstanceDef);
 
 impl CrateDef for InstanceDef {
     fn def_id(&self) -> DefId {
@@ -294,12 +295,3 @@ impl StaticDef {
         with(|cx| cx.eval_static_initializer(*self))
     }
 }
-
-impl IndexedVal for InstanceDef {
-    fn to_val(index: usize) -> Self {
-        InstanceDef(index)
-    }
-    fn to_index(&self) -> usize {
-        self.0
-    }
-}

compiler/rustc_public/src/ty.rs

@@ -11,10 +11,10 @@ use crate::crate_def::{CrateDef, CrateDefItems, CrateDefType};
 use crate::mir::alloc::{AllocId, read_target_int, read_target_uint};
 use crate::mir::mono::StaticDef;
 use crate::target::MachineInfo;
-use crate::{Filename, IndexedVal, Opaque};
+use crate::{Filename, IndexedVal, Opaque, ReferencesTls};
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Serialize)]
-pub struct Ty(usize);
+pub struct Ty(usize, ReferencesTls);
 
 impl Debug for Ty {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
@@ -152,7 +152,7 @@ pub enum TyConstKind {
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize)]
-pub struct TyConstId(usize);
+pub struct TyConstId(usize, ReferencesTls);
 
 /// Represents a constant in MIR
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
@@ -213,7 +213,7 @@ impl MirConst {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct MirConstId(usize);
+pub struct MirConstId(usize, ReferencesTls);
 
 type Ident = Opaque;
 
@@ -256,7 +256,7 @@ pub struct Placeholder<T> {
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub struct Span(usize);
+pub struct Span(usize, ReferencesTls);
 
 impl Debug for Span {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
@@ -1560,14 +1560,15 @@ macro_rules! index_impl {
     ($name:ident) => {
         impl crate::IndexedVal for $name {
             fn to_val(index: usize) -> Self {
-                $name(index)
+                $name(index, $crate::ReferencesTLS)
             }
             fn to_index(&self) -> usize {
                 self.0
             }
         }
     };
 }
+pub(crate) use index_impl;
 
 index_impl!(TyConstId);
 index_impl!(MirConstId);
@@ -1588,7 +1589,7 @@ index_impl!(Span);
 /// `c` is in the variant with the `VariantIdx` of `1`, and
 /// `g` is in the variant with the `VariantIdx` of `0`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct VariantIdx(usize);
+pub struct VariantIdx(usize, ReferencesTls);
 
 index_impl!(VariantIdx);