avoid thunking trivial values

fix-ir/src/lib.rs

@@ -14,14 +14,16 @@ pub mod downgrade;
 
 pub type HashMap<'ir, K, V> = hashbrown::HashMap<K, V, hashbrown::DefaultHashBuilder, &'ir Bump>;
 
-pub type IrRef<'id, 'ir> = <GhostRef<'id, 'ir> as RefExt<'ir>>::IrRef;
+pub type GhostIrRef<'id, 'ir> = <GhostRef<'id, 'ir> as RefExt<'ir>>::IrRef;
+pub type GhostRoIrRef<'id, 'ir> = <GhostRoRef<'id, 'ir> as RefExt<'ir>>::IrRef;
 pub type RawIrRef<'ir> = <RawRef<'ir> as RefExt<'ir>>::IrRef;
 pub type GhostMaybeThunkRef<'id, 'ir> = <GhostRef<'id, 'ir> as RefExt<'ir>>::MaybeThunkRef;
+pub type GhostRoMaybeThunkRef<'id, 'ir> = <GhostRoRef<'id, 'ir> as RefExt<'ir>>::MaybeThunkRef;
 
-impl<'id, 'ir> Ir<'ir, GhostRef<'id, 'ir>> {
+impl<'id, 'ir> Ir<'ir, GhostRoRef<'id, 'ir>> {
     /// Freeze a mutable IR reference into a read-only one, consuming the
     /// `GhostToken` to prevent any further mutation.
-    pub fn freeze(this: IrRef<'id, 'ir>, _: GhostToken<'id>) -> RawIrRef<'ir> {
+    pub fn freeze(this: GhostRoIrRef<'id, 'ir>, _: GhostToken<'id>) -> RawIrRef<'ir> {
         // SAFETY: The transmute is sound because:
         // - `GhostCell<'id, T>` is `#[repr(transparent)]` over `T`, so
         //   `&'ir GhostCell<'id, T>` and `&'ir T` have identical layout.
@@ -39,7 +41,39 @@ impl<'id, 'ir> Ir<'ir, GhostRef<'id, 'ir>> {
         // Consuming the `GhostToken` guarantees no `borrow_mut` calls can
         // occur afterwards, so the shared `&Ir` references reachable from a
         // `RawIrRef<'ir>` can never alias with mutable references.
-        unsafe { std::mem::transmute::<IrRef<'id, 'ir>, RawIrRef<'ir>>(this) }
+        unsafe { std::mem::transmute::<GhostRoIrRef<'id, 'ir>, RawIrRef<'ir>>(this) }
+    }
+}
+
+#[repr(transparent)]
+pub struct GhostRoCell<'id, T: ?Sized>(GhostCell<'id, T>);
+
+impl<'id, T> From<GhostCell<'id, T>> for GhostRoCell<'id, T> {
+    fn from(value: GhostCell<'id, T>) -> Self {
+        Self(value)
+    }
+}
+
+impl<'id, T: ?Sized> From<&GhostCell<'id, T>> for &GhostRoCell<'id, T> {
+    fn from(value: &GhostCell<'id, T>) -> Self {
+        // SAFETY: `GhostRoCell` is `#[repr(transparent)]` over `GhostCell`
+        // TODO: document mutability
+        unsafe { std::mem::transmute(value) }
+    }
+}
+
+impl<'id, T: ?Sized> From<&T> for &GhostRoCell<'id, T> {
+    fn from(value: &T) -> Self {
+        // SAFETY: `GhostRoCell` is `#[repr(transparent)]` over `GhostCell`,
+        //         which is `#[repr(transparent)]` over `T`
+        // TODO: document mutability
+        unsafe { std::mem::transmute(value) }
+    }
+}
+
+impl<'id, T: ?Sized> GhostRoCell<'id, T> {
+    pub fn borrow<'a>(&'a self, token: &'a GhostToken<'id>) -> &'a T {
+        self.0.borrow(token)
     }
 }
 
@@ -55,13 +89,13 @@ pub enum MaybeThunk {
     Thunk(ThunkId),
     Arg { layer: u8 },
     Builtin(BuiltinId),
+    BuiltinConst(StringId),
     Builtins,
     ReplBinding(StringId),
     ScopedImportBinding(StringId),
     WithLookup(StringId),
 }
 
-
 pub trait Ref<'ir> {
     type Ref<T>
     where
@@ -80,11 +114,15 @@ impl<'ir, T: Ref<'ir> + 'ir> RefExt<'ir> for T {
 }
 
 pub struct GhostRef<'id, 'ir>(PhantomData<&'ir GhostCell<'id, ()>>);
+pub struct GhostRoRef<'id, 'ir>(PhantomData<&'ir GhostRoCell<'id, ()>>);
 pub struct RawRef<'ir>(PhantomData<&'ir ()>);
 
 impl<'id, 'ir> Ref<'ir> for GhostRef<'id, 'ir> {
     type Ref<T: 'ir> = &'ir GhostCell<'id, T>;
 }
+impl<'id, 'ir> Ref<'ir> for GhostRoRef<'id, 'ir> {
+    type Ref<T: 'ir> = &'ir GhostRoCell<'id, T>;
+}
 impl<'ir> Ref<'ir> for RawRef<'ir> {
     type Ref<T: 'ir> = &'ir T;
 }
@@ -285,38 +323,38 @@ pub struct Param<'ir> {
 
 pub fn new_global_env(
     strings: &mut DefaultStringInterner,
-) -> hashbrown::HashMap<StringId, Ir<'static, RawRef<'static>>> {
+) -> hashbrown::HashMap<StringId, MaybeThunk> {
     let mut global_env = hashbrown::HashMap::new();
     let builtins_sym = StringId(strings.get_or_intern("builtins"));
-    global_env.insert(builtins_sym, Ir::Builtins);
+    global_env.insert(builtins_sym, MaybeThunk::Builtins);
 
     for (idx, &(name, _)) in BUILTINS.iter().enumerate() {
         let id = BuiltinId::try_from_primitive(idx as u8).expect("infallible");
         let name = StringId(strings.get_or_intern(name));
-        global_env.insert(name, Ir::Builtin(id));
+        global_env.insert(name, MaybeThunk::Builtin(id));
     }
 
     let consts = [
         (
             "__currentSystem",
-            Ir::BuiltinConst(StringId(strings.get_or_intern("currentSystem"))),
+            MaybeThunk::BuiltinConst(StringId(strings.get_or_intern("currentSystem"))),
         ),
-        ("__langVersion", Ir::Int(6)),
+        ("__langVersion", MaybeThunk::Int(6)),
         (
             "__nixVersion",
-            Ir::BuiltinConst(StringId(strings.get_or_intern("nixVersion"))),
+            MaybeThunk::BuiltinConst(StringId(strings.get_or_intern("nixVersion"))),
         ),
         (
             "__storeDir",
-            Ir::BuiltinConst(StringId(strings.get_or_intern("storeDir"))),
+            MaybeThunk::BuiltinConst(StringId(strings.get_or_intern("storeDir"))),
         ),
         (
             "__nixPath",
-            Ir::BuiltinConst(StringId(strings.get_or_intern("nixPath"))),
+            MaybeThunk::BuiltinConst(StringId(strings.get_or_intern("nixPath"))),
         ),
-        ("null", Ir::Null),
-        ("true", Ir::Bool(true)),
-        ("false", Ir::Bool(false)),
+        ("null", MaybeThunk::Null),
+        ("true", MaybeThunk::Bool(true)),
+        ("false", MaybeThunk::Bool(false)),
     ];
 
     for (name, ir) in consts {