@@ -34,6 +34,7 @@ jobs:
             ${{ runner.OS }}-cargo-
       - name: Install cargo-valgrind
         run: |
+          sudo apt-get update
           sudo apt-get install -y valgrind
           cargo install cargo-valgrind
       - name: Build library
 
@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+### Added
+
+- The new `ForwardPartialPathStitcher::from_partial_paths` constructor lets you
+  seed a path stitching search with a specific list of partial paths (which need
+  not be in the `Database`).  This can be used, for instance, to implement “find
+  qualified definitions”, where we look for any definition of a fully qualified
+  name (expressed as a symbol stack).  There is a new test case that shows an
+  example implementation.
+
+### Changed
+
+- The `ForwardPartialPathStitcher::new` constructor has been renamed to
+  `from_nodes`, to be more consistent with the new `from_partial_paths`
+  constructor.
+
 ## stack-graphs 0.5.0 - 2022-02-17
 
 ### Added
 
@@ -1039,11 +1039,24 @@ void sg_forward_path_stitcher_free(struct sg_forward_path_stitcher *stitcher);
 // must ensure that `db` contains all possible extensions of any of those initial partial paths.
 // You can retrieve a list of those extensions via the `previous_phase_partial_paths` and
 // `previous_phase_partial_paths_length` fields.
-struct sg_forward_partial_path_stitcher *sg_forward_partial_path_stitcher_new(const struct sg_stack_graph *graph,
-                                                                              struct sg_partial_path_arena *partials,
-                                                                              struct sg_partial_path_database *db,
-                                                                              size_t count,
-                                                                              const sg_node_handle *starting_nodes);
+struct sg_forward_partial_path_stitcher *sg_forward_partial_path_stitcher_from_nodes(const struct sg_stack_graph *graph,
+                                                                                     struct sg_partial_path_arena *partials,
+                                                                                     struct sg_partial_path_database *db,
+                                                                                     size_t count,
+                                                                                     const sg_node_handle *starting_nodes);
+
+// Creates a new forward partial path stitcher that is "seeded" with a set of initial partial
+// paths.
+//
+// Before calling `sg_forward_partial_path_stitcher_process_next_phase` for the first time, you
+// must ensure that `db` contains all possible extensions of any of those initial partial paths.
+// You can retrieve a list of those extensions via the `previous_phase_partial_paths` and
+// `previous_phase_partial_paths_length` fields.
+struct sg_forward_partial_path_stitcher *sg_forward_partial_path_stitcher_from_partial_paths(const struct sg_stack_graph *_graph,
+                                                                                             struct sg_partial_path_arena *partials,
+                                                                                             struct sg_partial_path_database *_db,
+                                                                                             size_t count,
+                                                                                             const struct sg_partial_path *initial_partial_paths);
 
 // Sets the maximum amount of work that can be performed during each phase of the algorithm. By
 // bounding our work this way, you can ensure that it's not possible for our CPU-bound algorithm
 
@@ -1918,7 +1918,7 @@ impl InternalForwardPartialPathStitcher {
 /// You can retrieve a list of those extensions via the `previous_phase_partial_paths` and
 /// `previous_phase_partial_paths_length` fields.
 #[no_mangle]
-pub extern "C" fn sg_forward_partial_path_stitcher_new(
+pub extern "C" fn sg_forward_partial_path_stitcher_from_nodes(
     graph: *const sg_stack_graph,
     partials: *mut sg_partial_path_arena,
     db: *mut sg_partial_path_database,
@@ -1929,7 +1929,7 @@ pub extern "C" fn sg_forward_partial_path_stitcher_new(
     let partials = unsafe { &mut (*partials).inner };
     let db = unsafe { &mut (*db).inner };
     let starting_nodes = unsafe { std::slice::from_raw_parts(starting_nodes, count) };
-    let stitcher = ForwardPartialPathStitcher::new(
+    let stitcher = ForwardPartialPathStitcher::from_nodes(
         graph,
         partials,
         db,
@@ -1940,6 +1940,30 @@ pub extern "C" fn sg_forward_partial_path_stitcher_new(
     ))) as *mut _
 }
 
+/// Creates a new forward partial path stitcher that is "seeded" with a set of initial partial
+/// paths.
+///
+/// Before calling `sg_forward_partial_path_stitcher_process_next_phase` for the first time, you
+/// must ensure that `db` contains all possible extensions of any of those initial partial paths.
+/// You can retrieve a list of those extensions via the `previous_phase_partial_paths` and
+/// `previous_phase_partial_paths_length` fields.
+#[no_mangle]
+pub extern "C" fn sg_forward_partial_path_stitcher_from_partial_paths(
+    _graph: *const sg_stack_graph,
+    partials: *mut sg_partial_path_arena,
+    _db: *mut sg_partial_path_database,
+    count: usize,
+    initial_partial_paths: *const sg_partial_path,
+) -> *mut sg_forward_partial_path_stitcher {
+    let partials = unsafe { &mut (*partials).inner };
+    let initial_partial_paths =
+        unsafe { std::slice::from_raw_parts(initial_partial_paths as *const PartialPath, count) };
+    let stitcher = ForwardPartialPathStitcher::from_partial_paths(initial_partial_paths.to_vec());
+    Box::into_raw(Box::new(InternalForwardPartialPathStitcher::new(
+        stitcher, partials,
+    ))) as *mut _
+}
+
 /// Sets the maximum amount of work that can be performed during each phase of the algorithm. By
 /// bounding our work this way, you can ensure that it's not possible for our CPU-bound algorithm
 /// to starve any worker threads or processes that you might be using.  If you don't call this
 
@@ -704,7 +704,7 @@ impl ForwardPartialPathStitcher {
     ///
     /// [`previous_phase_partial paths`]: #method.previous_phase_partial paths
     /// [`process_next_phase`]: #method.process_next_phase
-    pub fn new<I>(
+    pub fn from_nodes<I>(
         graph: &StackGraph,
         partials: &mut PartialPaths,
         db: &mut Database,
@@ -743,6 +743,31 @@ impl ForwardPartialPathStitcher {
         }
     }
 
+    /// Creates a new forward partial path stitcher that is "seeded" with a set of initial partial
+    /// paths.
+    ///
+    /// Before calling [`process_next_phase`][] for the first time, you must ensure that `db`
+    /// contains all possible extensions of any of those initial partial paths.  You can retrieve a
+    /// list of those extensions via [`previous_phase_partial paths`][].
+    ///
+    /// [`previous_phase_partial paths`]: #method.previous_phase_partial paths
+    /// [`process_next_phase`]: #method.process_next_phase
+    pub fn from_partial_paths(
+        initial_partial_paths: Vec<PartialPath>,
+    ) -> ForwardPartialPathStitcher {
+        let next_iteration = initial_partial_paths.into();
+        ForwardPartialPathStitcher {
+            candidate_partial_paths: Vec::new(),
+            queue: VecDeque::new(),
+            next_iteration,
+            cycle_detector: CycleDetector::new(),
+            // By default, there's no artificial bound on the amount of work done per phase
+            max_work_per_phase: usize::MAX,
+            #[cfg(feature = "copious-debugging")]
+            phase_number: 1,
+        }
+    }
+
     /// Returns an iterator of all of the (possibly incomplete) partial paths that were encountered
     /// during the most recent phase of the algorithm.
     pub fn previous_phase_partial_paths(&self) -> impl Iterator<Item = &PartialPath> + '_ {
@@ -822,8 +847,8 @@ impl ForwardPartialPathStitcher {
                     copious_debugging!("        is invalid: {:?}", err);
                     continue;
                 }
-                if !new_partial_path.starts_at_reference(graph) {
-                    copious_debugging!("        is invalid: slips off of reference");
+                if new_partial_path.start_node != partial_path.start_node {
+                    copious_debugging!("        is invalid: slips off of starting node");
                     continue;
                 }
                 if let Err(err) = new_partial_path.resolve(graph, partials) {
@@ -912,7 +937,8 @@ impl ForwardPartialPathStitcher {
         I: IntoIterator<Item = Handle<Node>>,
     {
         let mut result = Vec::new();
-        let mut stitcher = ForwardPartialPathStitcher::new(graph, partials, db, starting_nodes);
+        let mut stitcher =
+            ForwardPartialPathStitcher::from_nodes(graph, partials, db, starting_nodes);
         while !stitcher.is_complete() {
             let complete_partial_paths = stitcher
                 .previous_phase_partial_paths()