hyperast 0.2.0

Temporal code analyses at scale
Documentation 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

use std::{borrow::Borrow, marker::PhantomData};

use crate::types::{SimpleHyperAST, TypeStore};

pub mod handle;
pub mod labels;
// pub mod mapped_world;
pub mod nodes;
// pub mod ecs; // TODO try a custom ecs ?
// pub mod radix_hash_store; // TODO yet another WIP store
// pub mod vec_map_store; // TODO yet another WIP store

pub struct SimpleStores<TS, NS = nodes::DefaultNodeStore, LS = labels::LabelStore> {
    pub label_store: LS,
    pub node_store: NS,
    pub type_store: PhantomData<TS>,
}

#[cfg(feature = "scripting")]
impl<TS> mlua::UserData for SimpleStores<TS> {}

impl<TS, NS, LS> SimpleStores<TS, NS, LS> {
    pub fn change_type_store<TS2>(self) -> SimpleStores<TS2, NS, LS> {
        SimpleStores {
            type_store: PhantomData,
            node_store: self.node_store,
            label_store: self.label_store,
        }
    }
}

/// Declare we can convert from Self to T,
/// e.g. from the git::types::TStore to the Java one, but not the contrary
pub trait TyDown<T> {}

impl<TS, NS, LS> SimpleStores<TS, NS, LS> {
    pub fn mut_with_ts<TS2>(&mut self) -> &mut SimpleStores<TS2, NS, LS>
    where
        TS: TyDown<TS2>,
    {
        unsafe { std::mem::transmute(self) }
    }
    pub fn with_ts<TS2>(&self) -> &SimpleStores<TS2, NS, LS>
    where
        TS: TyDown<TS2>,
    {
        unsafe { std::mem::transmute(self) }
    }
    pub unsafe fn erase_ts_unchecked(&self) -> &SimpleStores<(), NS, LS> {
        unsafe { std::mem::transmute(self) }
    }
}

impl<TS: Default, NS: Default, LS: Default> Default for SimpleStores<TS, NS, LS> {
    fn default() -> Self {
        Self {
            label_store: Default::default(),
            type_store: Default::default(),
            node_store: Default::default(),
        }
    }
}

impl<TS: Copy, NS: Copy, LS: Copy> Copy for SimpleStores<TS, NS, LS> {}
impl<TS: Clone, NS: Clone, LS: Clone> Clone for SimpleStores<TS, NS, LS> {
    fn clone(&self) -> Self {
        Self {
            label_store: self.label_store.clone(),
            node_store: self.node_store.clone(),
            type_store: self.type_store.clone(),
        }
    }
}

impl<'store, TS, NS, LS> crate::types::RoleStore for SimpleStores<TS, NS, LS>
where
    TS: crate::types::RoleStore,
{
    type IdF = TS::IdF;

    type Role = TS::Role;

    fn resolve_field(lang: crate::types::LangWrapper<Self::Ty>, field_id: Self::IdF) -> Self::Role {
        TS::resolve_field(lang, field_id)
    }
    fn intern_role(lang: crate::types::LangWrapper<Self::Ty>, role: Self::Role) -> Self::IdF {
        TS::intern_role(lang, role)
    }
}

impl<IdN, TS, NS, LS> crate::types::NodeStore<IdN> for SimpleStores<TS, NS, LS>
where
    for<'a> NS::R<'a>: crate::types::Tree<TreeId = IdN>,
    IdN: crate::types::NodeId<IdN = IdN>,
    NS: crate::types::NodeStore<IdN>,
{
    type R<'a>
        = NS::R<'a>
    where
        Self: 'a;

    fn resolve(&self, id: &IdN) -> Self::R<'_> {
        self.node_store.resolve(id)
    }
}

impl<IdN, TS, NS, LS> crate::types::NodeStoreLean<IdN> for SimpleStores<TS, NS, LS>
where
    NS::R: crate::types::Tree<TreeId = IdN>,
    IdN: crate::types::NodeId<IdN = IdN>,
    NS: crate::types::NodeStoreLean<IdN>,
{
    type R = NS::R;

    fn resolve(&self, id: &IdN) -> Self::R {
        self.node_store.resolve(id)
    }
}

impl<'store, TS, NS, LS> crate::types::LabelStore<str> for SimpleStores<TS, NS, LS>
where
    LS: crate::types::LabelStore<str>,
{
    type I = LS::I;

    fn get_or_insert<U: Borrow<str>>(&mut self, node: U) -> Self::I {
        self.label_store.get_or_insert(node)
    }

    fn get<U: Borrow<str>>(&self, node: U) -> Option<Self::I> {
        self.label_store.get(node)
    }

    fn resolve(&self, id: &Self::I) -> &str {
        self.label_store.resolve(id)
    }
}

impl<'store, TS, NS, LS> crate::types::TypeStore for SimpleStores<TS, NS, LS>
where
    TS::Ty: 'static + std::hash::Hash,
    TS: TypeStore,
{
    type Ty = TS::Ty;
}

pub mod defaults {
    pub type LabelIdentifier = super::labels::DefaultLabelIdentifier;
    pub type LabelValue = super::labels::DefaultLabelValue;
    pub type NodeIdentifier = super::nodes::DefaultNodeIdentifier;
}

impl<'store, T, TS, NS, LS> From<&'store SimpleStores<TS, NS, LS>>
    for SimpleHyperAST<T, &'store TS, &'store NS, &'store LS>
{
    fn from(value: &'store SimpleStores<TS, NS, LS>) -> Self {
        Self {
            node_store: &value.node_store,
            label_store: &value.label_store,
            _phantom: std::marker::PhantomData,
        }
    }
}