Merge pull request #9 from metaborg/name-resolution

Name resolution

Author: AZWN

.gitignore

@@ -15,5 +15,6 @@ Cargo.lock
 *.pdb
 
 .vscode/
+.idea/
 
 *.dot

scopegraphs-lib/Cargo.toml

@@ -6,7 +6,14 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-
+log = "0.4.20"
+prust-lib = {git="https://github.com/jdonszelmann/prust", branch = "main"}
+syn = { version = "2.0.29", features = ["full", "extra-traits"] }
+quote = { version = "1.0.33" , optional = true}
+scopegraphs-regular-expressions = {path = "../scopegraphs-regular-expressions"}
+scopegraphs-macros = {path = "../scopegraphs-macros"}
 
 [dev-dependencies]
-scopegraphs = {path = "../scopegraphs"}
+scopegraphs = {path = "../scopegraphs"}
+env_logger = "0.10.1"
+ctor = "0.2.5"

scopegraphs-lib/src/completeness/critical_edge.rs

@@ -0,0 +1,100 @@
+use crate::{completeness::Completeness, Scope, ScopeGraph};
+use std::{collections::HashSet, hash::Hash};
+
+pub(super) struct CriticalEdgeSet<LABEL> {
+    open_edges: Vec<HashSet<LABEL>>,
+}
+
+impl<LABEL> Default for CriticalEdgeSet<LABEL> {
+    fn default() -> Self {
+        Self {
+            open_edges: Default::default(),
+        }
+    }
+}
+
+impl<LABEL> CriticalEdgeSet<LABEL> {
+    pub(super) fn init_scope(&mut self, edges: HashSet<LABEL>) {
+        self.open_edges.push(edges)
+    }
+}
+
+impl<LABEL: Hash + Eq> CriticalEdgeSet<LABEL> {
+    pub fn is_open(&self, scope: Scope, lbl: &LABEL) -> bool {
+        self.open_edges[scope.0].contains(lbl)
+    }
+
+    pub(super) fn close(&mut self, scope: Scope, lbl: &LABEL) -> bool {
+        self.open_edges[scope.0].remove(lbl)
+    }
+}
+
+/// Sub-trait of [`Completeness`] that uses _critical edges_ (scope-label pairs) to manage completeness.
+///
+/// Provides utility function to create scopes with particular open edges.
+///
+/// Should not be called externally, but only from utility function on [`super::ScopeGraph`].
+pub trait CriticalEdgeBasedCompleteness<LABEL, DATA>: Completeness<LABEL, DATA> {
+    fn init_scope_with(&mut self, open_edges: HashSet<LABEL>);
+}
+
+/// Error returned when attempting to add an edge with a label that is already closed in that scope.
+#[derive(Debug)]
+pub struct EdgeClosedError<LABEL> {
+    pub scope: Scope,
+    pub label: LABEL,
+}
+
+/// Value returned when a query cannot yet be computed because some edge it depends on is still closed.
+#[derive(Debug, Copy, Clone)]
+pub struct Delay<LABEL> {
+    pub scope: Scope,
+    pub label: LABEL,
+}
+
+pub(crate) type EdgesOrDelay<EDGES, LABEL> = Result<EDGES, Delay<LABEL>>;
+
+impl<LABEL: Hash + Eq, DATA, CMPL> ScopeGraph<LABEL, DATA, CMPL>
+where
+    CMPL: CriticalEdgeBasedCompleteness<LABEL, DATA>,
+{
+    /// Adds a new scope with some open edges.
+    pub fn add_scope_with<I>(&mut self, data: DATA, open_edges: I) -> Scope
+    where
+        I: IntoIterator<Item = LABEL>,
+    {
+        let scope = self.inner_scope_graph.add_scope(data);
+        self.completeness
+            .borrow_mut()
+            .init_scope_with(HashSet::from_iter(open_edges.into_iter()));
+        scope
+    }
+
+    /// Adds a new scope with no open edges.
+    pub fn add_scope_closed(&mut self, data: DATA) -> Scope {
+        let scope = self.inner_scope_graph.add_scope(data);
+        self.completeness
+            .borrow_mut()
+            .init_scope_with(HashSet::new());
+        scope
+    }
+}
+
+impl<LABEL: Hash + Eq, DATA, CMPL> ScopeGraph<LABEL, DATA, CMPL>
+where
+    DATA: Default,
+    CMPL: CriticalEdgeBasedCompleteness<LABEL, DATA>,
+{
+    /// Adds a new scope with some open edges and default data.
+    pub fn add_scope_default_with<I>(&mut self, open_edges: I) -> Scope
+    where
+        I: IntoIterator<Item = LABEL>,
+    {
+        self.add_scope_with(DATA::default(), open_edges)
+    }
+
+    /// Adds a new scope with no open edges and default data.
+    pub fn add_scope_default_closed(&mut self) -> Scope {
+        self.add_scope_with(DATA::default(), HashSet::new())
+    }
+}

scopegraphs-lib/src/completeness/explicit.rs

@@ -0,0 +1,185 @@
+use crate::{
+    completeness::private::Sealed,
+    completeness::{
+        Completeness, CriticalEdgeBasedCompleteness, CriticalEdgeSet, Delay, EdgeClosedError,
+        EdgesOrDelay,
+    },
+    label::Label,
+    InnerScopeGraph, Scope, ScopeGraph,
+};
+use std::{collections::HashSet, hash::Hash};
+
+/// Critical-edge based [`Completeness`] implementation.
+///
+/// Unlike [`ImplicitClose`], this implementation shifts responsibility of closing edges to the
+/// _type checker writer_. I.e., they have to insert `sg.close(scope, label)` statements at the
+/// appropriate positions in the code.
+///
+/// Returns [`EdgeClosedError`] when an edge is added to a scope in which the label is already
+/// closed (by an explicit close of the type checker writer).
+///
+/// Returns [`Delay`] when edges are retrieved (e.g. during query resolution) for an edge that is
+/// not yet closed.
+pub struct ExplicitClose<LABEL> {
+    critical_edges: CriticalEdgeSet<LABEL>,
+}
+
+impl<LABEL> Default for ExplicitClose<LABEL> {
+    fn default() -> Self {
+        ExplicitClose {
+            critical_edges: CriticalEdgeSet::default(),
+        }
+    }
+}
+
+impl<LABEL> Sealed for ExplicitClose<LABEL> {}
+
+impl<LABEL: Hash + Eq + Label, DATA> Completeness<LABEL, DATA> for ExplicitClose<LABEL> {
+    fn cmpl_new_scope(&mut self, _: &InnerScopeGraph<LABEL, DATA>, _: Scope) {
+        <ExplicitClose<LABEL> as CriticalEdgeBasedCompleteness<LABEL, DATA>>::init_scope_with(
+            self,
+            LABEL::iter().collect(), // init with all labels: programmer is responsible for closing edges
+        )
+    }
+
+    fn cmpl_new_complete_scope(&mut self, _: &InnerScopeGraph<LABEL, DATA>, _: Scope) {
+        <ExplicitClose<LABEL> as CriticalEdgeBasedCompleteness<LABEL, DATA>>::init_scope_with(
+            self,
+            HashSet::new(), // init with empty label set to prevent extension
+        )
+    }
+
+    type NewEdgeResult = Result<(), EdgeClosedError<LABEL>>;
+
+    fn cmpl_new_edge(
+        &mut self,
+        inner_scope_graph: &mut InnerScopeGraph<LABEL, DATA>,
+        src: Scope,
+        lbl: LABEL,
+        dst: Scope,
+    ) -> Self::NewEdgeResult {
+        if self.critical_edges.is_open(src, &lbl) {
+            inner_scope_graph.add_edge(src, lbl, dst);
+            Ok(())
+        } else {
+            Err(EdgeClosedError {
+                scope: src,
+                label: lbl,
+            })
+        }
+    }
+
+    type GetEdgesResult = EdgesOrDelay<Vec<Scope>, LABEL>;
+
+    fn cmpl_get_edges(
+        &mut self,
+        inner_scope_graph: &InnerScopeGraph<LABEL, DATA>,
+        src: Scope,
+        lbl: LABEL,
+    ) -> Self::GetEdgesResult {
+        if self.critical_edges.is_open(src, &lbl) {
+            Err(Delay {
+                scope: src,
+                label: lbl,
+            })
+        } else {
+            Ok(inner_scope_graph.get_edges(src, lbl))
+        }
+    }
+}
+
+impl<LABEL: Hash + Eq + Label, DATA> CriticalEdgeBasedCompleteness<LABEL, DATA>
+    for ExplicitClose<LABEL>
+{
+    fn init_scope_with(&mut self, open_labels: HashSet<LABEL>) {
+        self.critical_edges.init_scope(open_labels)
+    }
+}
+
+impl<LABEL: Hash + Eq> ExplicitClose<LABEL> {
+    fn close(&mut self, scope: Scope, label: &LABEL) {
+        self.critical_edges.close(scope, label);
+    }
+}
+
+impl<LABEL: Hash + Eq, DATA> ScopeGraph<LABEL, DATA, ExplicitClose<LABEL>> {
+    /// Closes an edge, (i.e., prohibit future new
+    ///
+    /// For example, the following program will return an error.
+    /// ```
+    /// # use scopegraphs_lib::completeness::ExplicitClose;
+    /// # use scopegraphs_lib::ScopeGraph;
+    /// # use scopegraphs_macros::Label;
+    /// # #[derive(Eq, Hash, PartialEq, Label)] enum Lbl { Def }
+    /// # use Lbl::*;
+    /// let mut sg = ScopeGraph::<Lbl, usize, _>::new(ExplicitClose::default());
+    ///
+    /// let s1 = sg.add_scope_with(0, [Def]);
+    /// let s2 = sg.add_scope_closed(42);
+    ///
+    /// sg.close(s1, &Def);
+    /// sg.add_edge(s1, Def, s2).expect_err("cannot add edge after closing edge");
+    /// ```
+    ///
+    /// Closing is required to permit queries to traverse these edges:
+    /// ```
+    ///
+    /// # use scopegraphs_lib::completeness::ExplicitClose;
+    /// # use scopegraphs_lib::ScopeGraph;
+    /// # use scopegraphs_lib::resolve::{DefaultDataEquiv, DefaultLabelOrder, EdgeOrData, Resolve};
+    /// # use scopegraphs_macros::{compile_regex, Label};
+    /// #
+    /// # #[derive(Eq, Hash, PartialEq, Label, Debug, Copy, Clone)]
+    /// # enum Lbl { Def }
+    /// # use Lbl::*;
+    /// # type LblD = EdgeOrData<Lbl>;
+    /// #
+    /// # compile_regex!(type Regex<Lbl> = Def);
+    /// let mut sg = ScopeGraph::<Lbl, usize, _>::new(ExplicitClose::default());
+    ///
+    /// let s1 = sg.add_scope_with(0, [Def]);
+    /// let s2 = sg.add_scope_closed(42);
+    ///
+    /// // Note: not calling `sg.close(s1, &Def)`
+    ///
+    /// let query_result = sg.query()
+    ///     .with_path_wellformedness(Regex::new()) // regex: `Def`
+    ///     .with_data_wellformedness(|x: &usize| *x == 42) // match `42`
+    ///     .resolve(s1);
+    ///
+    /// query_result.expect_err("require s1/Def to be closed");
+    /// ```
+    ///
+    /// Closing allows queries to resolve:
+    /// ```
+    ///
+    /// # use scopegraphs_lib::completeness::ExplicitClose;
+    /// # use scopegraphs_lib::ScopeGraph;
+    /// # use scopegraphs_lib::resolve::{DefaultDataEquiv, DefaultLabelOrder, EdgeOrData, Resolve};
+    /// # use scopegraphs_macros::{compile_regex, Label};
+    /// #
+    /// # #[derive(Eq, Hash, PartialEq, Label, Debug, Copy, Clone)]
+    /// # enum Lbl { Def }
+    /// # use Lbl::*;
+    /// # type LblD = EdgeOrData<Lbl>;
+    /// #
+    /// # compile_regex!(type Regex<Lbl> = Def);
+    /// let mut sg = ScopeGraph::<Lbl, usize, _>::new(ExplicitClose::default());
+    ///
+    /// let s1 = sg.add_scope_with(0, [Def]);
+    /// let s2 = sg.add_scope_closed(42);
+    ///
+    /// // Note: closing the edge *after* creating all edges, *before* doing the query
+    /// sg.close(s1, &Def);
+    ///
+    /// let query_result = sg.query()
+    ///     .with_path_wellformedness(Regex::new()) // regex: `Def`
+    ///     .with_data_wellformedness(|x: &usize| *x == 42) // match `42`
+    ///     .resolve(s1);
+    ///
+    /// query_result.expect("query should return result");
+    /// ```
+    pub fn close(&self, scope: Scope, label: &LABEL) {
+        self.completeness.borrow_mut().close(scope, label)
+    }
+}