Add Interner

PiperOrigin-RevId: 715419261
Change-Id: I373096e898643d5bbb41151c8608cf75b72ccb23

Author: cramertj

common/BUILD

@@ -5,6 +5,7 @@ load(
     "@rules_rust//rust:defs.bzl",
     "rust_library",
     "rust_proc_macro",
+    "rust_test",
 )
 load("//common:crubit_wrapper_macros_oss.bzl", "crubit_cc_test", "crubit_rust_test")
 
@@ -127,6 +128,24 @@ cc_library(
     ],
 )
 
+rust_library(
+    name = "interner",
+    srcs = ["interner.rs"],
+    deps = [
+        "@crate_index//:bumpalo",
+    ],
+)
+
+rust_test(
+    name = "interner_test",
+    srcs = ["interner_test.rs"],
+    deps = [
+        ":interner",
+        "@crate_index//:bumpalo",
+        "@crate_index//:googletest",
+    ],
+)
+
 rust_library(
     name = "memoized",
     srcs = ["memoized.rs"],

common/interner.rs

@@ -0,0 +1,134 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+use bumpalo::Bump;
+use std::cell::RefCell;
+use std::collections::HashSet;
+use std::hash::Hash;
+
+/// An interned value which performs by-pointer comparison.
+///
+/// Note that all values for a given type must originate from the same interner
+/// or they will compare not-equal.
+pub struct Interned<'arena, T: ?Sized>(&'arena T);
+
+impl<T: ?Sized> Copy for Interned<'_, T> {}
+impl<T: ?Sized> Clone for Interned<'_, T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'arena, T: ?Sized + 'arena> Interned<'arena, T> {
+    /// Access the inner reference.
+    ///
+    /// Note that this can also be accessed using `*interned`.
+    #[inline(always)]
+    pub fn inner(&self) -> &'arena T {
+        self.0
+    }
+
+    #[inline(always)]
+    fn ptr(&self) -> *const () {
+        self.0 as *const T as *const ()
+    }
+}
+
+impl<T: ?Sized + std::fmt::Debug> std::fmt::Debug for Interned<'_, T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<'arena, T: ?Sized + 'arena> std::ops::Deref for Interned<'arena, T> {
+    type Target = &'arena T;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T: ?Sized> PartialEq for Interned<'_, T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.ptr() == other.ptr()
+    }
+}
+
+impl<T: ?Sized> Eq for Interned<'_, T> {}
+
+impl<T: ?Sized> std::cmp::PartialOrd for Interned<'_, T> {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<T: ?Sized> std::cmp::Ord for Interned<'_, T> {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.ptr().cmp(&other.ptr())
+    }
+}
+
+impl<T: ?Sized> std::hash::Hash for Interned<'_, T> {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: std::hash::Hasher,
+    {
+        std::ptr::hash(self.ptr(), state)
+    }
+}
+
+/// An interner for values of type `T`.
+pub struct Interner<'arena, T: ?Sized> {
+    alloc: &'arena Bump,
+    map: RefCell<HashSet<&'arena T>>,
+}
+
+impl<'arena, T: ?Sized> Interner<'arena, T> {
+    /// Create a new interner which will store interned values in `alloc`.
+    pub fn new(alloc: &'arena Bump) -> Self {
+        Self { alloc, map: Default::default() }
+    }
+}
+
+impl<'arena, T: Hash + Eq + Copy> Interner<'arena, T> {
+    /// Intern `value` or access the interned copy if one exists.
+    ///
+    /// Note: the `Copy` bound on this method is not strictly required, but
+    /// the interner will not run `Drop` glue for its contents, so users must
+    /// ensure that they do not store types which need to be dropped.
+    pub fn intern(&self, value: T) -> Interned<'arena, T> {
+        let mut map = self.map.borrow_mut();
+        if let Some(interned) = map.get(&value) {
+            return Interned(interned);
+        }
+        let v = self.alloc.alloc(value);
+        map.insert(v);
+        Interned(v)
+    }
+}
+
+impl<'arena, Elem: Hash + Eq + Copy> Interner<'arena, [Elem]> {
+    /// Intern `value` or access the interned copy if one exists.
+    pub fn intern_slice(&self, value: &[Elem]) -> Interned<'arena, [Elem]> {
+        let mut map = self.map.borrow_mut();
+        if let Some(interned) = map.get(value) {
+            return Interned(interned);
+        }
+        let v = self.alloc.alloc_slice_copy(value);
+        map.insert(v);
+        Interned(v)
+    }
+}
+
+impl<'arena> Interner<'arena, str> {
+    /// Intern `value` or access the interned copy if one exists.
+    pub fn intern_str(&self, value: &str) -> Interned<'arena, str> {
+        let mut map = self.map.borrow_mut();
+        if let Some(interned) = map.get(value) {
+            return Interned(interned);
+        }
+        let v = self.alloc.alloc_str(value);
+        map.insert(v);
+        Interned(v)
+    }
+}

common/interner_test.rs

@@ -0,0 +1,69 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+use bumpalo::Bump;
+use googletest::{expect_eq, expect_ne, gtest};
+use interner::Interner;
+
+#[gtest]
+fn test_intern_does_not_change_value() {
+    let bump = Bump::default();
+    let interner = Interner::new(&bump);
+    let values = [2, 4, 6, 0, 1, 2];
+    for value in values {
+        let interned = interner.intern(value);
+        expect_eq!(**interned, value);
+    }
+}
+
+#[gtest]
+fn test_multiple_intern_calls_with_same_value_return_same_reference() {
+    let bump = Bump::default();
+    let interner = Interner::new(&bump);
+    let entries = [1, 2, 3, 4, 5];
+    let interned = entries.map(|v| interner.intern(v));
+    let interned_again = entries.map(|v| interner.intern(v));
+    for (first, second) in interned.iter().zip(interned_again.iter()) {
+        expect_eq!(**first as *const i32, **second as *const i32);
+        expect_eq!(first, second);
+    }
+}
+
+#[gtest]
+fn test_intern_with_different_values_are_not_equal() {
+    let bump = Bump::default();
+    let interner = Interner::new(&bump);
+    let first = interner.intern(1);
+    let second = interner.intern(2);
+    expect_ne!(first, second);
+}
+
+#[gtest]
+fn test_multiple_intern_calls_with_same_slice_value_return_same_reference() {
+    let bump = Bump::default();
+    let interner = Interner::<[i32]>::new(&bump);
+
+    let data = [1, 2, 3, 1, 2];
+    expect_eq!(interner.intern_slice(&data[0..2]), interner.intern_slice(&data[3..5]));
+}
+
+#[gtest]
+fn test_intern_slice_with_same_data_but_different_length_returns_different_reference() {
+    let bump = Bump::default();
+    let interner = Interner::<[i32]>::new(&bump);
+
+    let data = [1, 2, 3, 1, 2];
+    expect_ne!(interner.intern_slice(&data[0..2]), interner.intern_slice(&data[0..3]));
+}
+
+#[gtest]
+fn test_multiple_intern_calls_with_same_str_return_same_reference() {
+    let bump = Bump::default();
+    let interner = Interner::<str>::new(&bump);
+    let matches: Vec<&str> = "aaaabcxxxabcyyyabcdef".matches("abc").collect();
+    for match_ in matches {
+        let interned = interner.intern_str(match_);
+        expect_eq!(interner.intern_str("abc"), interned);
+    }
+}