explicitly annotate lifetimes when unsafe is involved

Author: Radvendii

core/src/environment.rs

@@ -100,7 +100,7 @@ impl<K: Hash + Eq, V: PartialEq> Environment<K, V> {
 
     /// Creates an iterator that visits all layers from the most recent one to the oldest.
     /// The element iterator type is `Rc<HashMap<K, V>>`.
-    pub fn iter_layers(&self) -> EnvLayerIter<'_, K, V> {
+    pub fn iter_layers<'slf>(&'slf self) -> EnvLayerIter<'slf, K, V> {
         EnvLayerIter {
             env: if !self.was_cloned() {
                 Some(NonNull::from(self))
@@ -121,7 +121,7 @@ impl<K: Hash + Eq, V: PartialEq> Environment<K, V> {
     /// the most recent one. It uses this order, so calling `collect` on this iterator to create a
     /// hashmap would have the same values as the Environment. The element iterator type is `(&'env
     /// K, &'env V)`, with `'env` being the lifetime of the Environment.
-    pub fn iter_elems(&self) -> EnvElemIter<'_, K, V> {
+    pub fn iter_elems<'slf>(&'slf self) -> EnvElemIter<'slf, K, V> {
         let mut env: Vec<NonNull<HashMap<K, V>>> = self
             .iter_layers()
             // SAFETY: Rc::as_ptr never returnes null

core/src/identifier.rs

@@ -258,12 +258,12 @@ mod interner {
         ///
         /// This operation cannot fails since the only way to have a [Symbol] is to have
         /// [interned](Interner::intern) the corresponding string first.
-        pub(crate) fn lookup(&self, sym: Symbol) -> &str {
+        pub(crate) fn lookup<'slf>(&'slf self, sym: Symbol) -> &'slf str {
             // SAFETY: We are making the returned &str lifetime the same as our struct,
             // which is okay here since the InnerInterner uses a typed_arena which prevents
             // deallocations, so the reference will be valid while the InnerInterner exists,
             // hence while the struct exists.
-            unsafe { std::mem::transmute(self.0.read().unwrap().lookup(sym)) }
+            unsafe { std::mem::transmute::<&'_ str, &'slf str>(self.0.read().unwrap().lookup(sym)) }
         }
     }
 
@@ -300,8 +300,11 @@ mod interner {
             // It is also okay to use it from inside the mutex, since typed_arena does not allow
             // deallocation, so references are valid until the arena drop, which is tied to the
             // struct drop.
+            // XXX: we have to use &'a str here, not &'self str like the comment indicates. what's going on?
             let in_string = unsafe {
-                std::mem::transmute(self.arena.lock().unwrap().alloc_str(string.as_ref()))
+                std::mem::transmute::<&'_ str, &'a str>(
+                    self.arena.lock().unwrap().alloc_str(string.as_ref()),
+                )
             };
             let sym = Symbol(self.vec.len() as u32);
             self.vec.push(in_string);
@@ -312,7 +315,7 @@ mod interner {
         ///
         /// This operation cannot fails since the only way to have a [Symbol]
         /// is to have [interned](InnerInterner::intern) the corresponding string first.
-        fn lookup(&self, sym: Symbol) -> &str {
+        fn lookup<'slf>(&'slf self, sym: Symbol) -> &'slf str {
             self.vec[sym.0 as usize]
         }
     }

core/src/term/array.rs

@@ -155,7 +155,7 @@ impl IntoIterator for Array {
         // Otherwise, we clone everything.
 
         unsafe {
-            let mut inner: Rc<[ManuallyDrop<RichTerm>]> = transmute(self.inner);
+            let mut inner = transmute::<Rc<[RichTerm]>, Rc<[ManuallyDrop<RichTerm>]>>(self.inner);
             let idx = self.start;
             let end = self.end;