rubydex 0.2.7-aarch64-linux → 0.2.9-aarch64-linux

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_patterns())
+    });
 
     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;
@@ -125,16 +128,16 @@ impl Graph {
         &mut self.declarations
     }
 
-    /// Adds paths to exclude from file discovery during indexing. Excluded directories will be skipped entirely during
-    /// directory traversal.
-    pub fn exclude_paths(&mut self, paths: Vec<PathBuf>) {
-        self.config.exclude_paths(paths);
+    /// Adds glob patterns to exclude from file discovery during indexing. Excluded directories will be skipped entirely
+    /// during directory traversal.
+    pub fn exclude_patterns(&mut self, patterns: Vec<Box<str>>) {
+        self.config.exclude_patterns(patterns);
     }
 
-    /// Returns the set of paths excluded from file discovery.
+    /// Returns the set of exclusion patterns.
     #[must_use]
-    pub fn excluded_paths(&self) -> HashSet<PathBuf> {
-        self.config.excluded_paths()
+    pub fn excluded_patterns(&self) -> HashSet<Box<str>> {
+        self.config.excluded_patterns()
     }
 
     /// Returns the root directory of the workspace being indexed.
@@ -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

data/rust/rubydex/src/operation/applier.rs

@@ -116,9 +116,7 @@ impl OperationApplier {
             _ => {}
         }
     }
-}
 
-impl OperationApplier {
     fn apply_operation(&mut self, op: Operation) {
         match op {
             Operation::EnterClass(op) => self.apply_enter_class(op),

data/rust/rubydex/src/query.rs

@@ -27,12 +27,25 @@ pub enum MatchMode {
     Exact,
 }
 
+/// Searches all declarations in parallel based on fully qualified names. Accepts multiple queries in case the caller
+/// wants to find multiple patterns without having to re-traverse the graph and also accepts match mode.
+///
+/// Note: an empty query returns all declarations, so if any are included the rest of the queries will be ignored.
+///
 /// # Panics
 ///
 /// Will panic if any of the threads panic
-pub fn declaration_search(graph: &Graph, query: &str, match_mode: &MatchMode) -> Vec<DeclarationId> {
+pub fn declaration_search(graph: &Graph, queries: &[&str], match_mode: &MatchMode) -> Vec<DeclarationId> {
     let num_threads = thread::available_parallelism().map_or(4, std::num::NonZero::get);
     let declarations = graph.declarations();
+
+    // An empty query matches all declarations as per the LSP specification and is equivalent to fetching all of them
+    // directly. Since an empty query matches all, there's no point in checking the other queries or pay the price of
+    // spawning threads.
+    if queries.iter().any(|q| q.is_empty()) {
+        return declarations.keys().copied().collect();
+    }
+
     let ids: Vec<DeclarationId> = declarations.keys().copied().collect();
     let chunk_size = ids.len().div_ceil(num_threads);
 
@@ -48,16 +61,8 @@ pub fn declaration_search(graph: &Graph, query: &str, match_mode: &MatchMode) ->
                     chunk
                         .iter()
                         .filter(|id| {
-                            let declaration = declarations.get(id).unwrap();
-                            let name = declaration.name();
-                            match match_mode {
-                                MatchMode::Fuzzy => {
-                                    // When the query is empty, we return everything as per the LSP specification.
-                                    // Otherwise, we compute the match score and return anything with a score greater than zero
-                                    query.is_empty() || match_score(query, name) > 0
-                                }
-                                MatchMode::Exact => name.contains(query),
-                            }
+                            let name = declarations.get(id).unwrap().name();
+                            queries.iter().any(|query| matches_query(query, name, match_mode))
                         })
                         .copied()
                         .collect::<Vec<_>>()
@@ -69,6 +74,15 @@ pub fn declaration_search(graph: &Graph, query: &str, match_mode: &MatchMode) ->
     })
 }
 
+/// Returns whether a single `query` matches `name` under the given [`MatchMode`].
+#[must_use]
+fn matches_query(query: &str, name: &str, match_mode: &MatchMode) -> bool {
+    match match_mode {
+        MatchMode::Fuzzy => match_score(query, name) > 0,
+        MatchMode::Exact => name.contains(query),
+    }
+}
+
 #[must_use]
 fn match_score(query: &str, target: &str) -> usize {
     let mut query_chars = query.chars().peekable();
@@ -836,7 +850,7 @@ mod tests {
             assert_results_eq!($context, $query, &MatchMode::default(), $expected);
         };
         ($context:expr, $query:expr, $match_mode:expr, $expected:expr) => {
-            let actual = declaration_search(&$context.graph(), $query, $match_mode);
+            let actual = declaration_search(&$context.graph(), &[$query], $match_mode);
             assert_eq!(
                 actual,
                 $expected
@@ -945,8 +959,8 @@ mod tests {
             "
         });
         context.resolve();
-        let exact_results = declaration_search(context.graph(), "", &MatchMode::Exact);
-        let fuzzy_results = declaration_search(context.graph(), "", &MatchMode::Fuzzy);
+        let exact_results = declaration_search(context.graph(), &[""], &MatchMode::Exact);
+        let fuzzy_results = declaration_search(context.graph(), &[""], &MatchMode::Fuzzy);
 
         assert_eq!(exact_results.len(), fuzzy_results.len());
         assert_eq!(context.graph().declarations().len(), exact_results.len());
@@ -972,6 +986,51 @@ mod tests {
         assert_results_eq!(context, "#Is_A?()", ["Foo#is_a_foo?()", "Bar#is_a?()"]);
     }
 
+    #[test]
+    fn multiple_queries_return_union_of_matches() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", {
+            r"
+            class Foo
+              def foo_method; end
+              def bar_method; end
+              def other_method; end
+            end
+            "
+        });
+        context.resolve();
+
+        let results = declaration_search(context.graph(), &["#foo_method()", "#bar_method()"], &MatchMode::Exact);
+        let mut names: Vec<String> = results
+            .iter()
+            .map(|id| context.graph().declarations().get(id).unwrap().name().to_string())
+            .collect();
+        names.sort();
+
+        assert_eq!(names, ["Foo#bar_method()", "Foo#foo_method()"]);
+    }
+
+    #[test]
+    fn overlapping_queries_do_not_duplicate_results() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", {
+            r"
+            class Foo
+              def is_a_foo?; end
+            end
+            "
+        });
+        context.resolve();
+
+        let results = declaration_search(context.graph(), &["is_a", "foo?"], &MatchMode::Exact);
+        let matches = results
+            .iter()
+            .filter(|id| context.graph().declarations().get(id).unwrap().name() == "Foo#is_a_foo?()")
+            .count();
+
+        assert_eq!(matches, 1);
+    }
+
     fn test_root() -> PathBuf {
         let root = if cfg!(windows) { "C:\\" } else { "/" };
         PathBuf::from_str(root).unwrap()
@@ -2767,7 +2826,16 @@ mod tests {
                 self_decl_id: None,
                 nesting_name_id,
             },
-            ["Bar#@@bar_cvar"]
+            [
+                "Bar",
+                "Bar#@@bar_cvar",
+                "BasicObject",
+                "Class",
+                "Foo",
+                "Kernel",
+                "Module",
+                "Object"
+            ]
         );
     }