rubydex 0.4.0-aarch64-linux → 0.4.2-aarch64-linux

data/rust/rubydex-sys/src/name_api.rs

@@ -1,42 +1,105 @@
 use rubydex::model::{graph::Graph, ids::NameId, name::ParentScope};
 
-/// Takes a constant name and a nesting stack (e.g.: `["Foo", "Bar::Baz", "Qux"]`) and transforms it into a `NameId`,
-/// registering each required part in the graph. Returns the `NameId` and a list of name ids that need to be untracked
-/// afterwards. Returns `None` if the constant name contains no valid identifier parts (e.g.: `""`, `"::"`, `"Foo::"`).
-pub fn nesting_stack_to_name_id(
-    graph: &mut Graph,
+struct NameTracker<'graph> {
+    graph: &'graph mut Graph,
+    tracked_name_ids: Vec<NameId>,
+}
+
+impl<'graph> NameTracker<'graph> {
+    fn new(graph: &'graph mut Graph) -> Self {
+        Self {
+            graph,
+            tracked_name_ids: Vec::new(),
+        }
+    }
+
+    fn track_name(&mut self, string: &str, parent_scope: ParentScope, nesting: Option<NameId>) -> NameId {
+        let str_id = self.graph.intern_string(string.to_owned());
+        let name_id = self.graph.add_name(str_id, parent_scope, nesting);
+        self.tracked_name_ids.push(name_id);
+        name_id
+    }
+}
+
+impl Drop for NameTracker<'_> {
+    fn drop(&mut self) {
+        for name_id in self.tracked_name_ids.drain(..) {
+            self.graph.untrack_name(name_id);
+        }
+    }
+}
+
+/// A name temporarily tracked in a graph. Dropping this guard undoes every name and string reference-count increment
+/// made while building the name.
+pub struct TrackedName<'graph> {
+    tracker: NameTracker<'graph>,
+    name_id: NameId,
+}
+
+impl<'graph> TrackedName<'graph> {
+    fn new(tracker: NameTracker<'graph>, name_id: NameId) -> Self {
+        TrackedName { tracker, name_id }
+    }
+
+    #[must_use]
+    pub fn name_id(&self) -> NameId {
+        self.name_id
+    }
+
+    #[must_use]
+    pub fn graph(&self) -> &Graph {
+        &*self.tracker.graph
+    }
+
+    pub fn graph_mut(&mut self) -> &mut Graph {
+        &mut *self.tracker.graph
+    }
+}
+
+/// Takes a constant name and nesting names (e.g.: `["Foo", "Bar::Baz", "Qux"]`) and transforms them into a `NameId`,
+/// registering each required part in the graph. The names are untracked when the returned guard is dropped.
+/// Returns `None` if the constant name contains no valid identifier parts (e.g.: `""`, `"::"`, `"Foo::"`).
+pub fn name_from_nesting_names<'graph>(
+    graph: &'graph mut Graph,
     const_name: &str,
     nesting: Vec<String>,
-) -> Option<(NameId, Vec<NameId>)> {
+) -> Option<TrackedName<'graph>> {
     let mut current_nesting = None;
     let mut current_name = ParentScope::None;
-    let mut names_to_untrack = Vec::new();
+    let mut tracker = NameTracker::new(graph);
 
     for entry in nesting {
-        process_qualified_name(
-            graph,
-            &entry,
-            &mut current_name,
-            &mut current_nesting,
-            &mut names_to_untrack,
-        );
+        process_qualified_name(&mut tracker, &entry, current_nesting, &mut current_name);
         current_nesting = current_name.as_ref().copied();
         current_name = ParentScope::None;
     }
 
-    process_qualified_name(
-        graph,
-        const_name,
-        &mut current_name,
-        &mut current_nesting,
-        &mut names_to_untrack,
-    );
+    process_qualified_name(&mut tracker, const_name, current_nesting, &mut current_name);
 
     let (ParentScope::Some(name_id) | ParentScope::Attached(name_id)) = current_name else {
         return None;
     };
 
-    Some((name_id, names_to_untrack))
+    Some(TrackedName::new(tracker, name_id))
+}
+
+/// Takes a constant name and an existing lexical nesting and transforms them into a `NameId`, registering each required
+/// part in the graph. The names are untracked when the returned guard is dropped.
+pub fn name_from_lexical_nesting<'graph>(
+    graph: &'graph mut Graph,
+    const_name: &str,
+    nesting: Option<NameId>,
+) -> Option<TrackedName<'graph>> {
+    let mut current_name = ParentScope::None;
+    let mut tracker = NameTracker::new(graph);
+
+    process_qualified_name(&mut tracker, const_name, nesting, &mut current_name);
+
+    let (ParentScope::Some(name_id) | ParentScope::Attached(name_id)) = current_name else {
+        return None;
+    };
+
+    Some(TrackedName::new(tracker, name_id))
 }
 
 /// Processes a qualified name (e.g., `"Foo::Bar"` or `"<Foo>"`) by splitting on `"::"` and registering each part in the
@@ -45,11 +108,10 @@ pub fn nesting_stack_to_name_id(
 /// When a singleton is the first part (i.e., `current_name` has no parent), `current_nesting` is used as the attachment
 /// point.
 fn process_qualified_name(
-    graph: &mut Graph,
+    tracker: &mut NameTracker<'_>,
     qualified_name: &str,
+    current_nesting: Option<NameId>,
     current_name: &mut ParentScope,
-    current_nesting: &mut Option<NameId>,
-    names_to_untrack: &mut Vec<NameId>,
 ) {
     for part in qualified_name.split("::") {
         if part.is_empty() {
@@ -60,18 +122,16 @@ fn process_qualified_name(
         let (parent_scope, nesting_for_part) = if part.starts_with('<') {
             let attached_id = match *current_name {
                 ParentScope::Some(id) | ParentScope::Attached(id) => Some(id),
-                _ => *current_nesting,
+                _ => current_nesting,
             };
 
             let attached = attached_id.map_or(ParentScope::None, ParentScope::Attached);
             (attached, attached_id)
         } else {
-            (*current_name, *current_nesting)
+            (*current_name, current_nesting)
         };
 
-        let str_id = graph.intern_string(part.to_owned());
-        let name_id = graph.add_name(str_id, parent_scope, nesting_for_part);
-        names_to_untrack.push(name_id);
+        let name_id = tracker.track_name(part, parent_scope, nesting_for_part);
         *current_name = ParentScope::Some(name_id);
     }
 }
@@ -86,38 +146,41 @@ mod tests {
     fn nesting_is_converted_to_name_id() {
         let mut graph = Graph::new();
 
-        let (name_id, _) = nesting_stack_to_name_id(
+        let tracked_name = name_from_nesting_names(
             &mut graph,
             "Some::CONST",
             vec!["Foo".into(), "Bar::Zip".into(), "Qux".into()],
         )
         .unwrap();
+        let name_id = tracked_name.name_id();
 
-        let const_name = graph.names().get(&name_id).unwrap();
+        let const_name = tracked_name.graph().names().get(&name_id).unwrap();
         assert_eq!(StringId::from("CONST"), *const_name.str());
 
-        let some_name = graph
+        let some_name = tracked_name
+            .graph()
             .names()
             .get(&const_name.parent_scope().expect("Parent scope should exist"))
             .unwrap();
         assert_eq!(StringId::from("Some"), *some_name.str());
         assert_eq!(const_name.nesting(), some_name.nesting());
 
-        let qux_name = graph.names().get(&some_name.nesting().unwrap()).unwrap();
+        let qux_name = tracked_name.graph().names().get(&some_name.nesting().unwrap()).unwrap();
         assert_eq!(StringId::from("Qux"), *qux_name.str());
         assert!(qux_name.parent_scope().is_none());
 
-        let zip_name = graph.names().get(&qux_name.nesting().unwrap()).unwrap();
+        let zip_name = tracked_name.graph().names().get(&qux_name.nesting().unwrap()).unwrap();
         assert_eq!(StringId::from("Zip"), *zip_name.str());
 
-        let bar_name = graph
+        let bar_name = tracked_name
+            .graph()
             .names()
             .get(&zip_name.parent_scope().expect("Parent scope should exist"))
             .unwrap();
         assert_eq!(StringId::from("Bar"), *bar_name.str());
         assert_eq!(zip_name.nesting(), bar_name.nesting());
 
-        let foo_name = graph.names().get(&bar_name.nesting().unwrap()).unwrap();
+        let foo_name = tracked_name.graph().names().get(&bar_name.nesting().unwrap()).unwrap();
         assert_eq!(StringId::from("Foo"), *foo_name.str());
         assert!(foo_name.parent_scope().is_none());
         assert!(foo_name.nesting().is_none());
@@ -127,13 +190,18 @@ mod tests {
     fn top_level_reference_is_converted_to_name_id() {
         let mut graph = Graph::new();
 
-        let (name_id, _) = nesting_stack_to_name_id(&mut graph, "::CONST", vec!["Foo".into()]).unwrap();
+        let tracked_name = name_from_nesting_names(&mut graph, "::CONST", vec!["Foo".into()]).unwrap();
+        let name_id = tracked_name.name_id();
 
-        let const_name = graph.names().get(&name_id).unwrap();
+        let const_name = tracked_name.graph().names().get(&name_id).unwrap();
         assert_eq!(StringId::from("CONST"), *const_name.str());
         assert!(const_name.parent_scope().is_top_level());
 
-        let foo_name = graph.names().get(&const_name.nesting().unwrap()).unwrap();
+        let foo_name = tracked_name
+            .graph()
+            .names()
+            .get(&const_name.nesting().unwrap())
+            .unwrap();
         assert_eq!(StringId::from("Foo"), *foo_name.str());
         assert!(foo_name.nesting().is_none());
         assert!(foo_name.parent_scope().is_none());
@@ -143,13 +211,18 @@ mod tests {
     fn singleton_class_names_use_attached_parent_scope() {
         let mut graph = Graph::new();
 
-        let (name_id, _) = nesting_stack_to_name_id(&mut graph, "CONST", vec!["Foo".into(), "<Foo>".into()]).unwrap();
+        let tracked_name = name_from_nesting_names(&mut graph, "CONST", vec!["Foo".into(), "<Foo>".into()]).unwrap();
+        let name_id = tracked_name.name_id();
 
-        let const_name = graph.names().get(&name_id).unwrap();
+        let const_name = tracked_name.graph().names().get(&name_id).unwrap();
         assert_eq!(StringId::from("CONST"), *const_name.str());
 
         // The nesting should be <Foo> with an Attached parent scope
-        let singleton_name = graph.names().get(&const_name.nesting().unwrap()).unwrap();
+        let singleton_name = tracked_name
+            .graph()
+            .names()
+            .get(&const_name.nesting().unwrap())
+            .unwrap();
         assert_eq!(StringId::from("<Foo>"), *singleton_name.str());
         assert!(
             matches!(singleton_name.parent_scope(), ParentScope::Attached(_)),
@@ -159,7 +232,7 @@ mod tests {
 
         // The attached parent should be Foo
         let foo_id = singleton_name.parent_scope().expect("Attached should have an id");
-        let foo_name = graph.names().get(&foo_id).unwrap();
+        let foo_name = tracked_name.graph().names().get(&foo_id).unwrap();
         assert_eq!(StringId::from("Foo"), *foo_name.str());
     }
 
@@ -167,19 +240,117 @@ mod tests {
     fn top_level_nesting_is_converted_to_name_id() {
         let mut graph = Graph::new();
 
-        let (name_id, _) = nesting_stack_to_name_id(&mut graph, "CONST", vec!["Foo".into(), "::Bar".into()]).unwrap();
+        let tracked_name = name_from_nesting_names(&mut graph, "CONST", vec!["Foo".into(), "::Bar".into()]).unwrap();
+        let name_id = tracked_name.name_id();
 
-        let const_name = graph.names().get(&name_id).unwrap();
+        let const_name = tracked_name.graph().names().get(&name_id).unwrap();
         assert_eq!(StringId::from("CONST"), *const_name.str());
         assert!(const_name.parent_scope().is_none());
 
-        let bar_name = graph.names().get(&const_name.nesting().unwrap()).unwrap();
+        let bar_name = tracked_name
+            .graph()
+            .names()
+            .get(&const_name.nesting().unwrap())
+            .unwrap();
         assert_eq!(StringId::from("Bar"), *bar_name.str());
         assert!(bar_name.parent_scope().is_top_level());
 
-        let foo_name = graph.names().get(&bar_name.nesting().unwrap()).unwrap();
+        let foo_name = tracked_name.graph().names().get(&bar_name.nesting().unwrap()).unwrap();
         assert_eq!(StringId::from("Foo"), *foo_name.str());
         assert!(foo_name.parent_scope().is_none());
         assert!(foo_name.nesting().is_none());
     }
+
+    #[test]
+    fn invalid_names_restore_name_and_string_counts() {
+        let mut graph = Graph::new();
+        let name_count = graph.names().len();
+        let string_count = graph.strings().len();
+
+        assert!(name_from_nesting_names(&mut graph, "", vec!["Foo".into()]).is_none());
+        assert_eq!(name_count, graph.names().len());
+        assert_eq!(string_count, graph.strings().len());
+
+        assert!(name_from_nesting_names(&mut graph, "Foo::", vec!["Bar".into()]).is_none());
+        assert_eq!(name_count, graph.names().len());
+        assert_eq!(string_count, graph.strings().len());
+
+        assert!(name_from_lexical_nesting(&mut graph, "Foo::", None).is_none());
+        assert_eq!(name_count, graph.names().len());
+        assert_eq!(string_count, graph.strings().len());
+    }
+
+    #[test]
+    fn invalid_name_restores_existing_name_reference_counts() {
+        let mut graph = Graph::new();
+        let string_id = graph.intern_string("Foo".to_owned());
+        let name_id = graph.add_name(string_id, ParentScope::None, None);
+        let name_ref_count = graph.names().get(&name_id).unwrap().ref_count();
+        let string_ref_count = graph.strings().get(&string_id).unwrap().ref_count();
+
+        assert!(name_from_nesting_names(&mut graph, "", vec!["Foo".into()]).is_none());
+
+        assert_eq!(name_ref_count, graph.names().get(&name_id).unwrap().ref_count());
+        assert_eq!(string_ref_count, graph.strings().get(&string_id).unwrap().ref_count());
+    }
+
+    #[test]
+    fn tracker_preserves_duplicate_name_ids() {
+        let mut graph = Graph::new();
+        let name_count = graph.names().len();
+        let string_count = graph.strings().len();
+
+        {
+            let mut tracker = NameTracker::new(&mut graph);
+            let first_id = tracker.track_name("Foo", ParentScope::None, None);
+            let second_id = tracker.track_name("Foo", ParentScope::None, None);
+
+            assert_eq!(first_id, second_id);
+            assert_eq!(2, tracker.graph.names().get(&first_id).unwrap().ref_count());
+        }
+
+        assert_eq!(name_count, graph.names().len());
+        assert_eq!(string_count, graph.strings().len());
+    }
+
+    #[test]
+    fn tracked_name_is_untracked_when_scope_ends() {
+        let mut graph = Graph::new();
+        let name_count = graph.names().len();
+        let string_count = graph.strings().len();
+
+        {
+            let tracked_name = name_from_nesting_names(&mut graph, "Bar::CONST", vec!["Foo".into()]).unwrap();
+            let name_id = tracked_name.name_id();
+            let const_name = tracked_name.graph().names().get(&name_id).unwrap();
+
+            assert_eq!(
+                "CONST",
+                tracked_name.graph().strings().get(const_name.str()).unwrap().as_str()
+            );
+            assert_eq!(name_count + 3, tracked_name.graph().names().len());
+            assert_eq!(string_count + 3, tracked_name.graph().strings().len());
+        }
+
+        assert_eq!(name_count, graph.names().len());
+        assert_eq!(string_count, graph.strings().len());
+    }
+
+    #[test]
+    fn tracked_name_is_untracked_during_unwind() {
+        let mut graph = Graph::new();
+        let name_count = graph.names().len();
+        let string_count = graph.strings().len();
+
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            let tracked_name = name_from_nesting_names(&mut graph, "Bar::CONST", vec!["Foo".into()]).unwrap();
+
+            assert_eq!(name_count + 3, tracked_name.graph().names().len());
+            panic!("unwind tracked name");
+        }));
+
+        assert!(result.is_err());
+        assert_eq!(name_count, graph.names().len());
+        assert_eq!(string_count, graph.strings().len());
+    }
 }