async lookups

Author: jdonszelmann

scopegraphs-lib/src/completeness/future.rs

@@ -26,7 +26,7 @@ impl<LABEL> Default for FutureCompleteness<LABEL> {
 
 impl<LABEL> Sealed for FutureCompleteness<LABEL> {}
 
-impl<'sg, LABEL: Hash + Eq + Label + Copy, DATA> Completeness<LABEL, DATA>
+impl<LABEL: Hash + Eq + Label + Copy, DATA> Completeness<LABEL, DATA>
     for FutureCompleteness<LABEL>
 {
     fn cmpl_new_scope(&self, inner_scope_graph: &mut InnerScopeGraph<LABEL, DATA>, scope: Scope) {

scopegraphs-lib/src/containers/scope.rs

@@ -13,7 +13,7 @@ pub trait ScopeContainer<LABEL> {
     fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer;
 }
 
-impl<'a, LABEL: Copy> ScopeContainer<LABEL> for Vec<Scope> {
+impl<LABEL: Copy> ScopeContainer<LABEL> for Vec<Scope> {
     type PathContainer = Vec<Path<LABEL>>;
 
     fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer {
@@ -23,7 +23,7 @@ impl<'a, LABEL: Copy> ScopeContainer<LABEL> for Vec<Scope> {
     }
 }
 
-impl<'a, LABEL, SC: ScopeContainer<LABEL>, E> ScopeContainer<LABEL> for Result<SC, E> {
+impl<LABEL, SC: ScopeContainer<LABEL>, E> ScopeContainer<LABEL> for Result<SC, E> {
     type PathContainer = Result<SC::PathContainer, E>;
 
     fn lift_step(self, lbl: LABEL, prefix: Path<LABEL>) -> Self::PathContainer {

scopegraphs-lib/src/resolve/lookup.rs

@@ -192,7 +192,7 @@ where
                 env1.flat_map(move |agg_env| {
                     let mut merged_env = agg_env.clone();
                     env2.flat_map(move |new_env| {
-                        merged_env.merge(&new_env);
+                        merged_env.merge(new_env);
                         <EnvC<'sg, 'rslv, CMPL, LABEL, DATA> as From<Env<'sg, LABEL, DATA>>>::from(
                             merged_env,
                         )
@@ -301,7 +301,7 @@ where
     }
 
     /// Creates single-path environment if the data `path.target()` is matching, or an empty environment otherwise.
-    fn resolve_data<'env>(&self, path: Path<LABEL>) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
+    fn resolve_data(&self, path: Path<LABEL>) -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
         let data = self.sg.get_data(path.target());
         if self.data_wellformedness.data_wf(data) {
             log::info!("{:?} matched: return singleton env.", data);
@@ -340,7 +340,7 @@ where
         smaller
     }
 
-    fn empty_env_container<'env>() -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
+    fn empty_env_container() -> EnvC<'sg, 'rslv, CMPL, LABEL, DATA> {
         <EnvC<'sg, 'rslv, CMPL, LABEL, DATA> as EnvContainer<'sg, 'rslv, LABEL, DATA>>::empty()
     }
 }

scopegraphs-lib/src/resolve/mod.rs

@@ -3,7 +3,7 @@ use std::collections::HashSet;
 use std::fmt::{Debug, Formatter};
 use std::hash::Hash;
 use std::marker::PhantomData;
-use std::sync::Arc;
+use std::rc::Rc;
 
 use super::{Scope, ScopeGraph};
 
@@ -54,7 +54,7 @@ enum InnerPath<LABEL> {
 /// Path (alternating sequence of scopes and labels) in a scope graph.
 #[derive(Clone)]
 pub struct Path<LABEL> {
-    inner_path: Arc<InnerPath<LABEL>>,
+    inner_path: Rc<InnerPath<LABEL>>,
     /// Set of all scopes in this path.
     ///
     /// Paths are alternating sequences of scopes and labels.
@@ -64,7 +64,7 @@ pub struct Path<LABEL> {
     /// This is cheaper than traversing the [`Path::inner_path`], at the cost of some more memory usage.
     ///
     /// In order to make paths cheap to extend multiple times, we use a persistent data structure.
-    scopes: Arc<TrieSet<Scope>>,
+    scopes: Rc<TrieSet<Scope>>,
     // FIXME: put fields in same Arc
 }
 
@@ -139,8 +139,8 @@ impl<LABEL> Path<LABEL> {
     /// Creates a new path that contains of a single scope.
     pub fn new(source: Scope) -> Self {
         Self {
-            inner_path: Arc::new(InnerPath::Start { source }),
-            scopes: Arc::new(TrieSet::new().insert(source)),
+            inner_path: Rc::new(InnerPath::Start { source }),
+            scopes: Rc::new(TrieSet::new().insert(source)),
         }
     }
 
@@ -160,15 +160,15 @@ impl<LABEL> Path<LABEL> {
             None
         } else {
             Some(Self {
-                inner_path: Arc::new(InnerPath::Step {
+                inner_path: Rc::new(InnerPath::Step {
                     prefix: Self {
                         inner_path: self.inner_path.clone(),
                         scopes: self.scopes.clone(),
                     },
                     label,
                     target,
                 }),
-                scopes: Arc::new(self.scopes.insert(target)),
+                scopes: Rc::new(self.scopes.insert(target)),
             })
         }
     }

scopegraphs-lib/src/scopegraph.rs

@@ -140,7 +140,7 @@ where
     /// Get the targets of the outgoing edges of a scope with some label.
     ///
     /// Permission for this operation is checked by `CMPL`.
-    pub fn get_edges<'sg>(&'sg self, src: Scope, lbl: LABEL) -> CMPL::GetEdgesResult<'sg> {
+    pub fn get_edges(&self, src: Scope, lbl: LABEL) -> CMPL::GetEdgesResult<'_> {
         self.completeness
             .cmpl_get_edges(&self.inner_scope_graph, src, lbl)
     }