add another failing test

Author: ibraheemdev

tests/interned-revisions.rs

@@ -13,10 +13,17 @@ struct Input {
 }
 
 #[salsa::interned]
+#[derive(Debug)]
 struct Interned<'db> {
     field1: usize,
 }
 
+#[salsa::interned]
+#[derive(Debug)]
+struct NestedInterned<'db> {
+    interned: Interned<'db>,
+}
+
 #[test]
 fn test_intern_new() {
     #[salsa::tracked]
@@ -257,3 +264,72 @@ fn test_reuse_interned_input() {
     let result = use_interned(&db, interned);
     assert_eq!(result, 2);
 }
+
+#[test]
+fn test_reuse_multiple_interned_input() {
+    // A query that creates an interned value.
+    #[salsa::tracked]
+    fn create_interned<'db>(db: &'db dyn Database, input: Input) -> Interned<'db> {
+        Interned::new(db, input.field1(db))
+    }
+
+    // A query that creates an interned value.
+    #[salsa::tracked]
+    fn create_nested_interned<'db>(
+        db: &'db dyn Database,
+        interned: Interned<'db>,
+    ) -> NestedInterned<'db> {
+        NestedInterned::new(db, interned)
+    }
+
+    #[salsa::tracked]
+    fn use_interned<'db>(db: &'db dyn Database, interned: Interned<'db>) -> usize {
+        let field = interned.field1(db);
+        field
+    }
+
+    // A query that reads an interned value.
+    #[salsa::tracked]
+    fn use_nested_interned<'db>(
+        db: &'db dyn Database,
+        nested_interned: NestedInterned<'db>,
+    ) -> usize {
+        nested_interned.interned(db).field1(db)
+    }
+
+    let mut db = common::EventLoggerDatabase::default();
+    let input = Input::new(&db, 0);
+
+    // Create and use NI0, which wraps I0, in R0.
+    let interned = create_interned(&db, input);
+    let i0_id = salsa::plumbing::AsId::as_id(&interned);
+    let nested_interned = create_nested_interned(&db, interned);
+    let result = use_nested_interned(&db, nested_interned);
+    assert_eq!(result, 0);
+
+    // Create and use I1 in a number of revisions, marking I0 as stale.
+    input.set_field1(&mut db).to(1);
+    for _ in 0..10 {
+        let interned = create_interned(&db, input);
+        let result = use_interned(&db, interned);
+        assert_eq!(result, 1);
+
+        // Trigger a new revision.
+        input.set_field1(&mut db).to(1);
+    }
+
+    // Create I2, reusing the stale slot of I0.
+    input.set_field1(&mut db).to(2);
+    let interned = create_interned(&db, input);
+
+    let i2_id = salsa::plumbing::AsId::as_id(&interned);
+    assert_eq!(i0_id, i2_id);
+
+    // Create NI1 wrapping I2 instead of I0.
+    let nested_interned = create_nested_interned(&db, interned);
+
+    // Use NI1. The function should not be memoized with the value of NI0,
+    // despite I2 and I0 sharing the same ID.
+    let result = use_nested_interned(&db, nested_interned);
+    assert_eq!(result, 2);
+}