rubydex 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fe9d5528801028a40419f3e7b35f5b74406ae2c24f6ce6252270fe15c2b9b77
-  data.tar.gz: 92595d6014a20544bdace0135d4aeea060ee969ab3a10544d02de6796ff9f84e
+  metadata.gz: 6b27fe66d59bdafd3b040278baaca0607a87861d132d70cc7ad65f9edb75c049
+  data.tar.gz: 1036e909678edd8183e1359ba9b45323d1e7a26ad99847d3382583a3f97d1f61
 SHA512:
-  metadata.gz: d43a2e6d81744f688d12ab483b8b4539a7a56144f0d7c7cf20540506bb376903c5d309c255b743ba77277fc82e03f86b70e0416149fdd490743844e913c24be6
-  data.tar.gz: 18f6195b18761efdafbe0b9ae7fb9c1ab64bbb607a080fb58792b9f574d17cb6ed25560ff957c5b925186019abbbe509396c2f88dd903c2e625d0265fbb10efa
+  metadata.gz: 884a896d38505cdb97ddc2a83b96364dc918f7f449349bf37e0d54675d630750300856df10dc6ab13e80b20d03979cbef5122ca2cc7ed20a160e64cf8ec421bd
+  data.tar.gz: cfd66ff47db6ac89e6f5514d307e48dcb5f252c5132eeb17328cf067365c1d764b6f9f87609483135815bf5760502992a9de107322e9445b2a99deacc9dcf7a5

data/ext/rubydex/graph.c

@@ -196,40 +196,54 @@ static VALUE rdxr_graph_yield_search_results(VALUE self, void *iter) {
 
 /*
  * call-seq:
- *   search(query) -> Enumerator[Rubydex::Declaration]
+ *   search(*queries) -> Enumerator[Rubydex::Declaration]
  *
- * Returns an enumerator that yields declarations matching the query exactly by substring.
+ * Returns an enumerator that yields declarations whose name matches any of the queries exactly by substring.
  */
-static VALUE rdxr_graph_search(VALUE self, VALUE query) {
-    Check_Type(query, T_STRING);
+static VALUE rdxr_graph_search(int argc, VALUE *argv, VALUE self) {
+    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+    VALUE queries = rb_ary_new_from_values(argc, argv);
+    rdxi_check_array_of_strings(queries);
 
     if (!rb_block_given_p()) {
-        return rb_enumeratorize(self, rb_str_new2("search"), 1, &query);
+        return rb_enumeratorize(self, rb_str_new2("search"), argc, argv);
     }
 
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    return rdxr_graph_yield_search_results(self, rdx_graph_declarations_search(graph, StringValueCStr(query)));
+    size_t length = (size_t)argc;
+    char **converted = rdxi_str_array_to_char(queries, length);
+    void *iter = rdx_graph_declarations_search(graph, (const char *const *)converted, length);
+    rdxi_free_str_array(converted, length);
+
+    return rdxr_graph_yield_search_results(self, iter);
 }
 
 /*
  * call-seq:
- *   fuzzy_search(query) -> Enumerator[Rubydex::Declaration]
+ *   fuzzy_search(*queries) -> Enumerator[Rubydex::Declaration]
  *
- * Returns an enumerator that yields declarations matching the query fuzzily.
+ * Returns an enumerator that yields declarations whose name matches any of the queries fuzzily.
  */
-static VALUE rdxr_graph_fuzzy_search(VALUE self, VALUE query) {
-    Check_Type(query, T_STRING);
+static VALUE rdxr_graph_fuzzy_search(int argc, VALUE *argv, VALUE self) {
+    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+    VALUE queries = rb_ary_new_from_values(argc, argv);
+    rdxi_check_array_of_strings(queries);
 
     if (!rb_block_given_p()) {
-        return rb_enumeratorize(self, rb_str_new2("fuzzy_search"), 1, &query);
+        return rb_enumeratorize(self, rb_str_new2("fuzzy_search"), argc, argv);
     }
 
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    return rdxr_graph_yield_search_results(self, rdx_graph_declarations_fuzzy_search(graph, StringValueCStr(query)));
+    size_t length = (size_t)argc;
+    char **converted = rdxi_str_array_to_char(queries, length);
+    void *iter = rdx_graph_declarations_fuzzy_search(graph, (const char *const *)converted, length);
+    rdxi_free_str_array(converted, length);
+
+    return rdxr_graph_yield_search_results(self, iter);
 }
 
 // Body function for rb_ensure in Graph#documents
@@ -942,8 +956,8 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     rb_define_method(cGraph, "diagnostics", rdxr_graph_diagnostics, 0);
     rb_define_method(cGraph, "check_integrity", rdxr_graph_check_integrity, 0);
     rb_define_method(cGraph, "[]", rdxr_graph_aref, 1);
-    rb_define_method(cGraph, "search", rdxr_graph_search, 1);
-    rb_define_method(cGraph, "fuzzy_search", rdxr_graph_fuzzy_search, 1);
+    rb_define_method(cGraph, "search", rdxr_graph_search, -1);
+    rb_define_method(cGraph, "fuzzy_search", rdxr_graph_fuzzy_search, -1);
     rb_define_method(cGraph, "encoding=", rdxr_graph_set_encoding, 1);
     rb_define_method(cGraph, "resolve_require_path", rdxr_graph_resolve_require_path, 2);
     rb_define_method(cGraph, "require_paths", rdxr_graph_require_paths, 1);

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

data/rbi/rubydex.rbi

@@ -335,11 +335,11 @@ class Rubydex::Graph
   sig { params(require_path: String, load_paths: T::Array[String]).returns(T.nilable(Rubydex::Document)) }
   def resolve_require_path(require_path, load_paths); end
 
-  sig { params(query: String).returns(T::Enumerable[Rubydex::Declaration]) }
-  def search(query); end
+  sig { params(queries: String).returns(T::Enumerable[Rubydex::Declaration]) }
+  def search(*queries); end
 
-  sig { params(query: String).returns(T::Enumerable[Rubydex::Declaration]) }
-  def fuzzy_search(query); end
+  sig { params(queries: String).returns(T::Enumerable[Rubydex::Declaration]) }
+  def fuzzy_search(*queries); end
 
   sig { params(encoding: String).void }
   def encoding=(encoding); end

data/rust/rubydex/src/main.rs

@@ -1,9 +1,13 @@
 use clap::{Parser, ValueEnum};
-use std::{collections::HashSet, mem};
+use std::{
+    fs, mem,
+    path::{Path, PathBuf},
+    time::{Duration, Instant},
+};
 
 use rubydex::{
     dot,
-    indexing::{self, IndexerBackend},
+    indexing::{self, IndexerBackend, LanguageId, build_local_graph},
     integrity, listing,
     model::graph::Graph,
     resolution::Resolver,
@@ -12,12 +16,17 @@ use rubydex::{
         timer::{Timer, time_it},
     },
 };
+use url::Url;
 
 #[derive(Parser, Debug)]
 #[command(name = "rubydex_cli", about = "A Static Analysis Toolkit for Ruby", version)]
 #[allow(clippy::struct_excessive_bools)]
 struct Args {
-    #[arg(value_name = "PATHS", default_value = ".")]
+    #[arg(
+        value_name = "PATHS",
+        default_value = ".",
+        help = "Path(s) to index. If the first path is a directory, it is used as the workspace root for rubydex.toml"
+    )]
     paths: Vec<String>,
 
     #[arg(long = "stop-after", help = "Stop after the given stage")]
@@ -52,6 +61,21 @@ struct Args {
         help = "Write orphan definitions report to specified file"
     )]
     report_orphans: Option<String>,
+
+    #[arg(
+        long = "incremental_cycle",
+        value_name = "N",
+        help = "After the initial build, run N incremental resolution cycles and report their timings"
+    )]
+    incremental_cycle: Option<usize>,
+
+    #[arg(
+        long = "incremental_files",
+        value_name = "N",
+        default_value_t = 1,
+        help = "Number of files to re-index per incremental cycle"
+    )]
+    incremental_files: usize,
 }
 
 #[derive(Debug, Clone, ValueEnum)]
@@ -85,6 +109,11 @@ fn exit(print_stats: bool) {
     std::process::exit(0);
 }
 
+fn workspace_path_for(paths: &[String]) -> Option<PathBuf> {
+    let first_path = paths.first()?;
+    fs::canonicalize(first_path).ok().filter(|path| path.is_dir())
+}
+
 fn main() {
     let args = Args::parse();
 
@@ -92,9 +121,21 @@ fn main() {
         Timer::set_global_timer(Timer::new());
     }
 
+    let mut graph = Graph::new();
+
+    if let Some(workspace_path) = workspace_path_for(&args.paths) {
+        graph.set_workspace_path(workspace_path);
+        if let Err(error) = graph.load_config(None) {
+            eprintln!("{error}");
+            std::process::exit(1);
+        }
+    }
+
     // Listing
 
-    let (file_paths, errors) = time_it!(listing, { listing::collect_file_paths(args.paths, &HashSet::new()) });
+    let (file_paths, errors) = time_it!(listing, {
+        listing::collect_file_paths(args.paths, &graph.excluded_paths())
+    });
 
     for error in errors {
         eprintln!("{error}");
@@ -106,8 +147,16 @@ fn main() {
 
     // Indexing
 
-    let mut graph = Graph::new();
     let backend = IndexerBackend::from(&args.indexer);
+
+    // The incremental benchmark re-indexes files after the initial build, so keep a copy of the
+    // paths before `index_files` consumes them.
+    let incremental_paths = if args.incremental_cycle.is_some() {
+        file_paths.clone()
+    } else {
+        Vec::new()
+    };
+
     let errors = time_it!(indexing, { indexing::index_files(&mut graph, file_paths, backend) });
 
     for error in errors {
@@ -125,6 +174,12 @@ fn main() {
         resolver.resolve();
     });
 
+    // Incremental resolution benchmark. Runs before the stop-after check so it can be combined with
+    // `--stop-after=resolution`.
+    if let Some(cycles) = args.incremental_cycle {
+        run_incremental_resolution(&mut graph, &incremental_paths, cycles, args.incremental_files, backend);
+    }
+
     if let Some(StopAfter::Resolution) = args.stop_after {
         return exit(args.stats);
     }
@@ -186,3 +241,91 @@ fn main() {
     // Forget the graph so we don't have to wait for deallocation and let the system reclaim the memory at exit
     mem::forget(graph);
 }
+
+/// Simulates incremental editing to measure incremental resolution cost. For each cycle it
+/// re-indexes a rotating window of `files_per_cycle` files (parsing plus the same invalidation the
+/// LSP performs on save) and then re-runs resolution over the resulting pending work, reporting
+/// per-cycle and aggregate `resolve()` timings.
+///
+/// With `--stats`, the `compute_descendants` breakdown printed in the timing summary reflects the
+/// last incremental cycle, since it is recorded on every `resolve()`.
+fn run_incremental_resolution(
+    graph: &mut Graph,
+    paths: &[PathBuf],
+    cycles: usize,
+    files_per_cycle: usize,
+    backend: IndexerBackend,
+) {
+    if paths.is_empty() || cycles == 0 || files_per_cycle == 0 {
+        eprintln!("Skipping incremental resolution: nothing to re-index");
+        return;
+    }
+
+    let files_per_cycle = files_per_cycle.min(paths.len());
+
+    let mut reindex_total = Duration::ZERO;
+    let mut resolve_total = Duration::ZERO;
+    let mut resolve_min = Duration::MAX;
+    let mut resolve_max = Duration::ZERO;
+
+    println!();
+    println!("Incremental resolution ({cycles} cycle(s), {files_per_cycle} file(s)/cycle)");
+    println!("  Scenario: no-op reindex; files are indexed again without changing their contents.");
+    println!("  This should be the fastest incremental resolution path.");
+    println!("  Add scenario-based benchmarks before optimizing incremental resolution.");
+
+    for cycle in 0..cycles {
+        // Re-index the window of files for this cycle. Rotating the window across cycles samples
+        // different parts of the codebase rather than measuring the same delta repeatedly.
+        let reindex_start = Instant::now();
+        for i in 0..files_per_cycle {
+            let path = &paths[(cycle * files_per_cycle + i) % paths.len()];
+            reindex_file(graph, path, backend);
+        }
+        reindex_total += reindex_start.elapsed();
+
+        let resolve_start = Instant::now();
+        Resolver::new(graph).resolve();
+        let elapsed = resolve_start.elapsed();
+
+        resolve_total += elapsed;
+        resolve_min = resolve_min.min(elapsed);
+        resolve_max = resolve_max.max(elapsed);
+
+        println!(
+            "  cycle {:>3}: resolve {:9.3}ms",
+            cycle + 1,
+            elapsed.as_secs_f64() * 1000.0
+        );
+    }
+
+    let avg = resolve_total / u32::try_from(cycles).expect("cycle count fits in u32");
+
+    println!(
+        "  resolve total {:.3}ms  avg {:.3}ms  min {:.3}ms  max {:.3}ms",
+        resolve_total.as_secs_f64() * 1000.0,
+        avg.as_secs_f64() * 1000.0,
+        resolve_min.as_secs_f64() * 1000.0,
+        resolve_max.as_secs_f64() * 1000.0,
+    );
+    println!(
+        "  reindex+invalidate total {:.3}ms (parse + document merge, excluded from resolve above)",
+        reindex_total.as_secs_f64() * 1000.0,
+    );
+}
+
+/// Re-indexes a single file into the graph, running the same invalidation the LSP performs on save.
+fn reindex_file(graph: &mut Graph, path: &Path, backend: IndexerBackend) {
+    let Ok(source) = fs::read_to_string(path) else {
+        eprintln!("Failed to read file `{}`", path.display());
+        return;
+    };
+    let Ok(url) = Url::from_file_path(path) else {
+        eprintln!("Couldn't build URI from path `{}`", path.display());
+        return;
+    };
+
+    let language = path.extension().map_or(LanguageId::Ruby, LanguageId::from);
+    let local_graph = build_local_graph(url.to_string(), &source, &language, backend);
+    graph.consume_document_changes(local_graph);
+}

data/rust/rubydex/src/model/declaration.rs

@@ -91,7 +91,7 @@ macro_rules! namespace_declaration {
         #[derive(Debug)]
         pub struct $name {
             /// The fully qualified name of this declaration
-            name: String,
+            name: Box<str>,
             /// The list of definition IDs that compose this declaration
             definition_ids: Vec<DefinitionId>,
             /// The set of references that are made to this declaration
@@ -116,7 +116,7 @@ macro_rules! namespace_declaration {
             #[must_use]
             pub fn new(name: String, owner_id: DeclarationId) -> Self {
                 Self {
-                    name,
+                    name: name.into_boxed_str(),
                     definition_ids: Vec::new(),
                     members: IdentityHashMap::default(),
                     references: IdentityHashSet::default(),
@@ -231,7 +231,7 @@ macro_rules! simple_declaration {
         #[derive(Debug)]
         pub struct $name {
             /// The fully qualified name of this declaration
-            name: String,
+            name: Box<str>,
             /// The list of definition IDs that compose this declaration
             definition_ids: Vec<DefinitionId>,
             /// The set of references that are made to this declaration
@@ -244,7 +244,7 @@ macro_rules! simple_declaration {
             #[must_use]
             pub fn new(name: String, owner_id: DeclarationId) -> Self {
                 Self {
-                    name,
+                    name: name.into_boxed_str(),
                     definition_ids: Vec::new(),
                     references: IdentityHashSet::default(),
                     owner_id,
@@ -608,25 +608,25 @@ impl Namespace {
 }
 
 namespace_declaration!(Class, ClassDeclaration);
-assert_mem_size!(ClassDeclaration, 192);
+assert_mem_size!(ClassDeclaration, 184);
 namespace_declaration!(Module, ModuleDeclaration);
-assert_mem_size!(ModuleDeclaration, 192);
+assert_mem_size!(ModuleDeclaration, 184);
 namespace_declaration!(SingletonClass, SingletonClassDeclaration);
-assert_mem_size!(SingletonClassDeclaration, 192);
+assert_mem_size!(SingletonClassDeclaration, 184);
 namespace_declaration!(Todo, TodoDeclaration);
-assert_mem_size!(TodoDeclaration, 192);
+assert_mem_size!(TodoDeclaration, 184);
 simple_declaration!(ConstantDeclaration, ConstantReferenceId);
-assert_mem_size!(ConstantDeclaration, 88);
+assert_mem_size!(ConstantDeclaration, 80);
 simple_declaration!(MethodDeclaration, MethodReferenceId);
-assert_mem_size!(MethodDeclaration, 88);
+assert_mem_size!(MethodDeclaration, 80);
 simple_declaration!(GlobalVariableDeclaration, GlobalVariableReferenceId);
-assert_mem_size!(GlobalVariableDeclaration, 88);
+assert_mem_size!(GlobalVariableDeclaration, 80);
 simple_declaration!(InstanceVariableDeclaration, InstanceVariableReferenceId);
-assert_mem_size!(InstanceVariableDeclaration, 88);
+assert_mem_size!(InstanceVariableDeclaration, 80);
 simple_declaration!(ClassVariableDeclaration, ClassVariableReferenceId);
-assert_mem_size!(ClassVariableDeclaration, 88);
+assert_mem_size!(ClassVariableDeclaration, 80);
 simple_declaration!(ConstantAliasDeclaration, ConstantReferenceId);
-assert_mem_size!(ConstantAliasDeclaration, 88);
+assert_mem_size!(ConstantAliasDeclaration, 80);
 
 #[cfg(test)]
 mod tests {

data/rust/rubydex/src/model/graph.rs

@@ -13,7 +13,10 @@ use crate::model::definitions::{Definition, MethodVisibilityDefinition, Receiver
 use crate::model::document::Document;
 use crate::model::encoding::Encoding;
 use crate::model::identity_maps::{IdentityHashMap, IdentityHashSet};
-use crate::model::ids::{ConstantReferenceId, DeclarationId, DefinitionId, MethodReferenceId, NameId, StringId, UriId};
+use crate::model::ids::{
+    ConstantReferenceId, DeclarationId, DefinitionId, MethodReferenceId, NameId, StringId, UriId,
+    declaration_id_from_lookup_name,
+};
 use crate::model::name::{Name, NameRef, ParentScope, ResolvedName};
 use crate::model::references::{ConstantReference, MethodRef};
 use crate::model::string_ref::StringRef;
@@ -578,7 +581,7 @@ impl Graph {
 
     #[must_use]
     pub fn get(&self, name: &str) -> Option<Vec<&Definition>> {
-        let declaration_id = DeclarationId::from(name);
+        let declaration_id = declaration_id_from_lookup_name(name);
         let declaration = self.declarations.get(&declaration_id)?;
 
         Some(
@@ -1270,6 +1273,10 @@ impl Graph {
                 let unqualified_str_id = StringId::from(&decl.unqualified_name());
                 let owner_id = *decl.owner_id();
                 let is_singleton_class = matches!(decl, Declaration::Namespace(Namespace::SingletonClass(_)));
+                let ancestors_to_detach: Vec<Ancestor> = decl
+                    .as_namespace()
+                    .map(|ns| ns.ancestors().iter().copied().collect())
+                    .unwrap_or_default();
 
                 for def_id in def_ids {
                     self.push_work(Unit::Definition(def_id));
@@ -1284,6 +1291,16 @@ impl Graph {
                         ns.remove_member(&unqualified_str_id);
                     }
                 }
+
+                // Detach from each complete ancestor's descendant set so we don't leave a stale id in descendants
+                for ancestor in ancestors_to_detach {
+                    if let Ancestor::Complete(ancestor_id) = ancestor
+                        && let Some(anc_decl) = self.declarations.get_mut(&ancestor_id)
+                        && let Some(ns) = anc_decl.as_namespace_mut()
+                    {
+                        ns.remove_descendant(&decl_id);
+                    }
+                }
             }
 
             self.declarations.remove(&decl_id);
@@ -1570,6 +1587,10 @@ mod tests {
         assert_members_eq, assert_no_diagnostics, assert_no_members,
     };
 
+    fn definition_ids(definitions: Vec<&Definition>) -> Vec<DefinitionId> {
+        definitions.into_iter().map(Definition::id).collect()
+    }
+
     #[test]
     fn deleting_a_uri() {
         let mut context = GraphTest::new();
@@ -1992,6 +2013,34 @@ mod tests {
         assert_eq!(definitions[0].offset().start(), 6);
     }
 
+    #[test]
+    fn get_accepts_leading_double_colon() {
+        let mut context = GraphTest::new();
+
+        context.index_uri("file:///foo.rb", "module Foo; module Bar; end; end");
+        context.resolve();
+
+        // Built-in declarations (root-scoped):
+        let unqualified = context.graph().get("Object").expect("unqualified `Object` lookup");
+        let qualified = context.graph().get("::Object").expect("qualified `::Object` lookup");
+        assert_eq!(definition_ids(unqualified), definition_ids(qualified));
+
+        // Indexed declarations, top-level and nested:
+        let unqualified = context.graph().get("Foo").expect("unqualified `Foo` lookup");
+        let qualified = context.graph().get("::Foo").expect("qualified `::Foo` lookup");
+        assert_eq!(definition_ids(unqualified), definition_ids(qualified));
+
+        let unqualified = context.graph().get("Foo::Bar").expect("unqualified `Foo::Bar` lookup");
+        let qualified = context
+            .graph()
+            .get("::Foo::Bar")
+            .expect("qualified `::Foo::Bar` lookup");
+        assert_eq!(definition_ids(unqualified), definition_ids(qualified));
+
+        // Unknown names still return None when prefixed:
+        assert!(context.graph().get("::DoesNotExist").is_none());
+    }
+
     #[test]
     fn adding_another_definition_from_a_different_uri() {
         let mut context = GraphTest::new();
@@ -2499,6 +2548,7 @@ mod tests {
 
 #[cfg(test)]
 mod incremental_resolution_tests {
+    use crate::model::ids::DeclarationId;
     use crate::model::name::NameRef;
     use crate::test_utils::GraphTest;
     use crate::{
@@ -4126,4 +4176,37 @@ mod incremental_resolution_tests {
         assert_declaration_exists!(context, "Foo::<Foo>");
         assert_declaration_exists!(context, "Bar::<Bar>");
     }
+
+    #[test]
+    fn constant_references_through_object_inheritance_are_invalidated() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///a.rb", "class Foo; end");
+        context.index_uri(
+            "file:///b.rb",
+            r"
+            module Wrap
+              class Foo; end
+              ::Foo
+              Foo
+            end
+            ",
+        );
+        context.resolve();
+
+        context.delete_uri("file:///a.rb");
+        context.resolve();
+
+        let kernel = context
+            .graph()
+            .declarations()
+            .get(&DeclarationId::from("Kernel"))
+            .unwrap();
+
+        for id in kernel.as_namespace().unwrap().descendants() {
+            assert!(
+                context.graph().declarations().contains_key(id),
+                "Kernel has stale descendant id {id:?} with no backing declaration"
+            );
+        }
+    }
 } // mod incremental_resolution_tests

data/rust/rubydex/src/model/ids.rs

@@ -9,6 +9,15 @@ pub struct DeclarationMarker;
 /// `DeclarationId` represents the ID of a fully qualified name. For example, `Foo::Bar` or `Foo#my_method`
 pub type DeclarationId = Id<DeclarationMarker>;
 
+/// Creates a `DeclarationId` from a user-facing lookup name.
+///
+/// Declaration names are stored without the root-scope marker, so `"::Object"`
+/// and `"Object"` must resolve to the same declaration ID.
+#[must_use]
+pub fn declaration_id_from_lookup_name(name: &str) -> DeclarationId {
+    DeclarationId::from(name.strip_prefix("::").unwrap_or(name))
+}
+
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
 pub struct DefinitionMarker;
 
@@ -84,3 +93,24 @@ assert_mem_size!(ClassVariableReferenceId, 8);
 pub struct InstanceVariableMarker;
 pub type InstanceVariableReferenceId = Id<InstanceVariableMarker>;
 assert_mem_size!(InstanceVariableReferenceId, 8);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn declaration_id_from_lookup_name_accepts_root_scope_marker() {
+        assert_eq!(
+            DeclarationId::from("Object"),
+            declaration_id_from_lookup_name("::Object")
+        );
+        assert_eq!(
+            DeclarationId::from("Foo::Bar"),
+            declaration_id_from_lookup_name("::Foo::Bar")
+        );
+        assert_ne!(
+            DeclarationId::from("Object"),
+            declaration_id_from_lookup_name("::::Object")
+        );
+    }
+}

data/rust/rubydex/src/model/string_ref.rs

@@ -9,15 +9,23 @@ use std::ops::Deref;
 /// graph when its count reaches zero.
 #[derive(Debug)]
 pub struct StringRef {
-    value: String,
+    value: Box<str>,
     ref_count: u32,
 }
-assert_mem_size!(StringRef, 32);
+assert_mem_size!(StringRef, 24);
 
 impl StringRef {
     #[must_use]
     pub fn new(value: String) -> Self {
-        Self { value, ref_count: 1 }
+        Self {
+            value: value.into_boxed_str(),
+            ref_count: 1,
+        }
+    }
+
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        &self.value
     }
 
     #[must_use]
@@ -44,7 +52,7 @@ impl StringRef {
 }
 
 impl Deref for StringRef {
-    type Target = String;
+    type Target = str;
 
     fn deref(&self) -> &Self::Target {
         &self.value