rust-analyzer - Unnamed repository; edit this file 'description' to name the repository.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

//! Test that you can implement a query using a `dyn Trait` setup.

use salsa::InternId;

#[salsa::database(InternStorage)]
#[derive(Default)]
struct Database {
    storage: salsa::Storage<Self>,
}

impl salsa::Database for Database {}

impl salsa::ParallelDatabase for Database {
    fn snapshot(&self) -> salsa::Snapshot<Self> {
        salsa::Snapshot::new(Database { storage: self.storage.snapshot() })
    }
}

#[salsa::query_group(InternStorage)]
trait Intern {
    #[salsa::interned]
    fn intern1(&self, x: String) -> InternId;

    #[salsa::interned]
    fn intern2(&self, x: String, y: String) -> InternId;

    #[salsa::interned]
    fn intern_key(&self, x: String) -> InternKey;
}

#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct InternKey(InternId);

impl salsa::InternKey for InternKey {
    fn from_intern_id(v: InternId) -> Self {
        InternKey(v)
    }

    fn as_intern_id(&self) -> InternId {
        self.0
    }
}

#[test]
fn test_intern1() {
    let db = Database::default();
    let foo0 = db.intern1("foo".to_owned());
    let bar0 = db.intern1("bar".to_owned());
    let foo1 = db.intern1("foo".to_owned());
    let bar1 = db.intern1("bar".to_owned());

    assert_eq!(foo0, foo1);
    assert_eq!(bar0, bar1);
    assert_ne!(foo0, bar0);

    assert_eq!("foo".to_owned(), db.lookup_intern1(foo0));
    assert_eq!("bar".to_owned(), db.lookup_intern1(bar0));
}

#[test]
fn test_intern2() {
    let db = Database::default();
    let foo0 = db.intern2("x".to_owned(), "foo".to_owned());
    let bar0 = db.intern2("x".to_owned(), "bar".to_owned());
    let foo1 = db.intern2("x".to_owned(), "foo".to_owned());
    let bar1 = db.intern2("x".to_owned(), "bar".to_owned());

    assert_eq!(foo0, foo1);
    assert_eq!(bar0, bar1);
    assert_ne!(foo0, bar0);

    assert_eq!(("x".to_owned(), "foo".to_owned()), db.lookup_intern2(foo0));
    assert_eq!(("x".to_owned(), "bar".to_owned()), db.lookup_intern2(bar0));
}

#[test]
fn test_intern_key() {
    let db = Database::default();
    let foo0 = db.intern_key("foo".to_owned());
    let bar0 = db.intern_key("bar".to_owned());
    let foo1 = db.intern_key("foo".to_owned());
    let bar1 = db.intern_key("bar".to_owned());

    assert_eq!(foo0, foo1);
    assert_eq!(bar0, bar1);
    assert_ne!(foo0, bar0);

    assert_eq!("foo".to_owned(), db.lookup_intern_key(foo0));
    assert_eq!("bar".to_owned(), db.lookup_intern_key(bar0));
}