Allow Relation<T> to be joined with Variable<(T, S)>

This case occurred in `Polonius`, where we had to create a separate
`Relation<(T, ())>` to make things work.

Implementing this required a change to the interface of `JoinInput`,
since we are not allowed to assume that a `Relation<T>` and a
`Relation<(T, ())>` are layout compatible. Now, `stable` takes a
callback instead of returning a slice directly.

Author: ecstatic-morse

src/join.rs

@@ -25,13 +25,13 @@ pub(crate) fn join_into<'me, Key: Ord, Val1: Ord, Val2: Ord, Result: Ord>(
 
         let mut closure = |k: &Key, v1: &Val1, v2: &Val2| results.push(logic(k, v1, v2));
 
-        for batch2 in input2.stable().iter() {
+        input2.for_each_stable_set(|batch2| {
             join_helper(&recent1, &batch2, &mut closure);
-        }
+        });
 
-        for batch1 in input1.stable().iter() {
+        input1.for_each_stable_set(|batch1| {
             join_helper(&batch1, &recent2, &mut closure);
-        }
+        });
 
         join_helper(&recent1, &recent2, &mut closure);
     }
@@ -141,40 +141,56 @@ pub trait JoinInput<'me, Tuple: Ord>: Copy {
     /// empty slice.)
     type RecentTuples: Deref<Target = [Tuple]>;
 
-    /// If we are on iteration N of the loop, these are the tuples
-    /// added on iteration N - 2 or before. (For a `Relation`, this is
-    /// just `self`.)
-    type StableTuples: Deref<Target = [Relation<Tuple>]>;
-
     /// Get the set of recent tuples.
     fn recent(self) -> Self::RecentTuples;
 
-    /// Get the set of stable tuples.
-    fn stable(self) -> Self::StableTuples;
+    /// Call a function for each set of stable tuples.
+    fn for_each_stable_set(self, f: impl FnMut(&[Tuple]));
 }
 
 impl<'me, Tuple: Ord> JoinInput<'me, Tuple> for &'me Variable<Tuple> {
     type RecentTuples = Ref<'me, [Tuple]>;
-    type StableTuples = Ref<'me, [Relation<Tuple>]>;
 
     fn recent(self) -> Self::RecentTuples {
         Ref::map(self.recent.borrow(), |r| &r.elements[..])
     }
 
-    fn stable(self) -> Self::StableTuples {
-        Ref::map(self.stable.borrow(), |v| &v[..])
+    fn for_each_stable_set(self, mut f: impl FnMut(&[Tuple])) {
+        for stable in self.stable.borrow().iter() {
+            f(stable)
+        }
     }
 }
 
 impl<'me, Tuple: Ord> JoinInput<'me, Tuple> for &'me Relation<Tuple> {
     type RecentTuples = &'me [Tuple];
-    type StableTuples = &'me [Relation<Tuple>];
 
     fn recent(self) -> Self::RecentTuples {
         &[]
     }
 
-    fn stable(self) -> Self::StableTuples {
-        std::slice::from_ref(self)
+    fn for_each_stable_set(self, mut f: impl FnMut(&[Tuple])) {
+        f(&self.elements)
+    }
+}
+
+impl<'me, Tuple: Ord> JoinInput<'me, (Tuple, ())> for &'me Relation<Tuple> {
+    type RecentTuples = &'me [(Tuple, ())];
+
+    fn recent(self) -> Self::RecentTuples {
+        &[]
+    }
+
+    fn for_each_stable_set(self, mut f: impl FnMut(&[(Tuple, ())])) {
+        use std::mem;
+        assert_eq!(mem::size_of::<(Tuple, ())>(), mem::size_of::<Tuple>());
+        assert_eq!(mem::align_of::<(Tuple, ())>(), mem::align_of::<Tuple>());
+
+        // SAFETY: https://rust-lang.github.io/unsafe-code-guidelines/layout/structs-and-tuples.html#structs-with-1-zst-fields
+        // guarantees that `T` is layout compatible with `(T, ())`, since `()` is a 1-ZST.
+        let elements: &'me [Tuple] = self.elements.as_slice();
+        let elements: &'me [(Tuple, ())] = unsafe { std::mem::transmute(elements) };
+
+        f(elements)
     }
 }