Class origin classification no longer re-scans the whole classmap after

the fact

Author: AJenbo

docs/CHANGELOG.md

@@ -53,6 +53,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Faster whole-workspace class pre-resolution.** Resolving every known class in dependency order after indexing now spreads across multiple workers instead of running on a single one, substantially cutting the pause between indexing and diagnostics on large Laravel projects. The editor's post-startup pre-resolution goes through the same path, so a large project becomes fully warm sooner.
 - **Project startup is significantly faster.** Building the class index now reads files normally instead of memory-mapping them, and the work is parallelized more effectively across your CPU cores. This meaningfully cuts both startup time and CPU use on large Laravel projects, speeding up whole-project analysis and getting the editor ready sooner, with no change in results.
 - **The `analyze` and `fix` CLI subcommands no longer build the cross-file reference index.** That index only serves Find References, Rename, and reference-count inlay hints, none of which the CLI subcommands query, so skipping it removes wasted work from whole-project `analyze` and `fix` runs. The editor's LSP session is unaffected.
+- **Class origin classification no longer re-scans the whole classmap after the fact.** Startup used to look up each discovered class's completion-ranking origin (project, explicit dependency, transitive dependency, core stub) by re-reading and re-parsing `installed.json` a second time and prefix-matching every class's file path against the package list on a single thread. The origin is now attached to a class the moment it is discovered during the already-parallel vendor scan, the same way it already worked for functions and constants, removing both the duplicate parse and the serial pass.
 
 ### Removed
 
@@ -113,6 +114,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Generated return types and `@return` tags understand every kind of return expression, not just literals and variables.** Inferring a missing return type now resolves method/function calls, ternaries, matches, property access, and array literals split across multiple lines through the same type engine as hover, instead of degrading to `mixed` (or, for multi-line array literals, to a coarser `array<mixed>`) for anything beyond a simple literal, `new`, or a plain variable.
 - **Calls to functions declared in another `namespace` block of the same file resolve their return type.** In a file that declares more than one `namespace`, a call to a function from a later block used to leave the returned value untyped unless the function carried an `@return` docblock. The call and its return type now resolve regardless, so completion, hover, and diagnostics see the value's type.
 - **`@template` bindings resolve correctly when a call uses named arguments.** A generic function or method called with named arguments (for example `process(class: Product::class, flag: true, function ($p) { ... })`) previously bound its template parameter from the wrong argument whenever the named arguments were out of declaration order, leaving closure parameters untyped. Named arguments now route to the parameter they actually target.
+- **Vendor-provided functions and constants no longer rank as project-native in completion.** With the `self`, `full`, and `composer` indexing strategies, functions and constants discovered while scanning vendor packages lost their package origin when merged into the workspace scan, so they sorted ahead of other vendor symbols as if declared in the project itself instead of by their actual dependency tier.
 
 ## [0.9.0] - 2026-07-20
 

docs/todo.md

@@ -197,7 +197,7 @@ unlikely to move the needle for most users.
 |     | **[Performance](todo/performance.md)**                                                                                       |             |             |
 | P46 | [`mago-phpdoc-syntax` cannot parse `@method static (…) name()`](todo/performance.md#p46-mago-phpdoc-syntax-cannot-parse-method-static--name)                                | Low         | Low         |
 | P30 | [Evaluate migrating parse/resolve/docblock pipeline to `mago-hir`](todo/performance.md#p30-evaluate-migrating-parseresolvedocblock-pipeline-to-mago-hir) (parked — re-evaluated at mago 1.45.0, still no `mago-hir` consumers upstream) | Medium-High | High        |
-| P48 | [Project init's remaining serial stretches](todo/performance.md#p48-project-inits-remaining-serial-stretches)                                                                | Low-Medium  | Medium      |
+| P49 | [Project init's remaining serial stretches](todo/performance.md#p49-project-inits-remaining-serial-stretches)                                                                | Low-Medium  | Medium      |
 | P47 | [The resolved-class cache lock caps concurrent class resolution](todo/performance.md#p47-the-resolved-class-cache-lock-caps-concurrent-class-resolution)                     | Medium      | Medium-High |
 | P16 | [Pre-parsed stub format (eliminate raw PHP embedding)](todo/performance.md#p16-pre-parsed-stub-format-eliminate-raw-php-embedding)                                          | High        | Medium-High |
 | P25 | [`type_mismatch_argument` / `argument_count_mismatch` slow on large single files](todo/performance.md#p25-type_mismatch_argument-argument_count_mismatch-slow-on-large-single-files) | Medium      | Medium      |

docs/todo/performance.md

@@ -1049,7 +1049,7 @@ real ceiling than the hashing was.
 
 ---
 
-## P48. Project init's remaining serial stretches
+## P49. Project init's remaining serial stretches
 
 **Impact: Low-Medium · Effort: Medium**
 
@@ -1065,9 +1065,7 @@ large Laravel project (32-core machine, release build, warm page cache,
 | vendor package collection (`collect_package_files`) | 0.060 s | 6.8 |
 | vendor file scan (`scan_files_parallel_full`) | 0.033 s | 20.5 |
 | `scan_autoload_files` | 0.038 s | 3.9 |
-| `classify_class_origin` + `fqn_uri_index` fill | 0.019 s | 1.6 |
 | workspace walk (`ignore` crate) | 0.018 s | 1.1 |
-| `vendor_package_roots` | 0.006 s | 1.0 |
 
 Each is small on its own; together they are most of what is left:
 
@@ -1077,18 +1075,6 @@ Each is small on its own; together they are most of what is left:
   roots (or its subdirectories) into separate work items would even it
   out, but the concatenation has to stay in `installed.json` order for
   duplicate FQNs to resolve to the same file.
-- **Class origins are derived twice.** The vendor scan knows which
-  package each file came from, and records it for functions and constants
-  (`WorkspaceScanResult::function_origins` / `constant_origins`), but not
-  for classes. Init then re-derives every vendor class's origin by
-  prefix-matching its path against ~400 package roots, single-threaded.
-  Carrying class origins out of the scan the way the other two already
-  are would delete the step. The Composer-classmap path (`strategy =
-  "composer"`) has no origin for its entries, so the prefix match has to
-  stay as the fallback there.
-- **`vendor_package_roots` re-reads and re-parses `installed.json`**
-  moments after `scan_vendor_packages_with_skip` parsed the same file,
-  and canonicalizes every package path a second time.
 - **The workspace walk is single-threaded.** `ignore::WalkBuilder` has
   `build_parallel`, but the walk order feeds the duplicate-FQN
   tie-break, so a parallel walk needs its results sorted to stay

src/classmap_scanner/discovery.rs

@@ -257,6 +257,10 @@ struct PackageFiles {
     /// Files from `autoload.files` and `autoload.classmap`, plus the full
     /// package tree when a `files` entry registers its own autoloader.
     plain: Vec<(PathBuf, crate::ClassCompletionOrigin)>,
+    /// The package's own root (path, origin, package name), resolved
+    /// once here so `vendor_package_roots` doesn't need to re-read and
+    /// re-parse `installed.json` to get the same information.
+    root: Option<(PathBuf, crate::ClassCompletionOrigin, String)>,
 }
 
 /// Walk one `installed.json` entry and return the PHP files it exposes.
@@ -272,9 +276,8 @@ fn collect_package_files(
     explicit_deps: &HashSet<String>,
 ) -> PackageFiles {
     let mut out = PackageFiles::default();
-    let origin = package
-        .get("name")
-        .and_then(|n| n.as_str())
+    let pkg_name = package.get("name").and_then(|n| n.as_str());
+    let origin = pkg_name
         .map(|name| classify_package_origin(name, explicit_deps))
         .unwrap_or(crate::ClassCompletionOrigin::VendorTransitive);
     // Locate the package on disk.  Composer 2's installed.json
@@ -287,7 +290,7 @@ fn collect_package_files(
     let pkg_path = if let Some(install_path) = package.get("install-path").and_then(|p| p.as_str())
     {
         composer_dir.join(install_path)
-    } else if let Some(pkg_name) = package.get("name").and_then(|n| n.as_str()) {
+    } else if let Some(pkg_name) = pkg_name {
         vendor_path.join(pkg_name)
     } else {
         return out;
@@ -308,6 +311,12 @@ fn collect_package_files(
         return out;
     }
 
+    out.root = Some((
+        pkg_path.clone(),
+        origin,
+        pkg_name.unwrap_or("unknown/unknown").to_string(),
+    ));
+
     // Extract autoload section
     let Some(autoload) = package.get("autoload") else {
         return out;
@@ -459,7 +468,10 @@ pub fn scan_vendor_packages_with_skip(
                                 skip_paths,
                                 explicit_deps,
                             );
-                            if !files.psr4.is_empty() || !files.plain.is_empty() {
+                            if !files.psr4.is_empty()
+                                || !files.plain.is_empty()
+                                || files.root.is_some()
+                            {
                                 out.push((i, files));
                             }
                         }
@@ -482,10 +494,17 @@ pub fn scan_vendor_packages_with_skip(
 
     let mut psr4_files: Vec<(PathBuf, String, crate::ClassCompletionOrigin)> = Vec::new();
     let mut plain_files: Vec<(PathBuf, crate::ClassCompletionOrigin)> = Vec::new();
+    let mut package_roots: Vec<(PathBuf, crate::ClassCompletionOrigin, String)> = Vec::new();
     for (_, files) in collected {
         psr4_files.extend(files.psr4);
         plain_files.extend(files.plain);
+        if let Some(root) = files.root {
+            package_roots.push(root);
+        }
     }
+    // Match `vendor_package_roots`'s ordering: longest path first, so a
+    // nested package's root wins a prefix match before its parent's.
+    package_roots.sort_by_key(|(p, _, _)| std::cmp::Reverse(p.components().count()));
 
     // Phase 2: scan all collected files in parallel. Each file's origin is
     // already known from the package it was collected under (phase 1), so
@@ -500,7 +519,9 @@ pub fn scan_vendor_packages_with_skip(
 
     progress_add_total(progress, all_files.len());
 
-    scan_files_parallel_full(&all_files, progress)
+    let mut result = scan_files_parallel_full(&all_files, progress);
+    result.package_roots = package_roots;
+    result
 }
 
 /// Scan all `.php` files under the workspace root using the PSR-4
@@ -688,18 +709,26 @@ fn scan_files_parallel_full(
                 let scan = super::find_symbols(&content);
                 for fqcn in scan.classes {
                     let class_short_name = fqcn_short_name(&fqcn).to_owned();
+                    let mut origin_wins = false;
                     result
                         .classmap
-                        .entry(fqcn)
+                        .entry(fqcn.clone())
                         .and_modify(|existing| {
                             let existing_stem =
                                 existing.file_stem().and_then(|s| s.to_str()).unwrap_or("");
                             let new_stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
                             if existing_stem != class_short_name && new_stem == class_short_name {
                                 *existing = path.clone();
+                                origin_wins = true;
                             }
                         })
-                        .or_insert_with(|| path.clone());
+                        .or_insert_with(|| {
+                            origin_wins = true;
+                            path.clone()
+                        });
+                    if origin_wins {
+                        result.class_origins.insert(fqcn, *origin);
+                    }
                 }
                 for fqn in scan.functions {
                     result
@@ -780,9 +809,10 @@ fn scan_files_parallel_full(
         for (scan, path, origin) in batch {
             for fqcn in scan.classes {
                 let class_short_name = fqcn_short_name(&fqcn).to_owned();
+                let mut origin_wins = false;
                 result
                     .classmap
-                    .entry(fqcn)
+                    .entry(fqcn.clone())
                     .and_modify(|existing| {
                         // When two files declare the same FQN, prefer the one
                         // whose filename matches the class's short name (PSR-4
@@ -795,9 +825,16 @@ fn scan_files_parallel_full(
                         let new_stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
                         if existing_stem != class_short_name && new_stem == class_short_name {
                             *existing = path.clone();
+                            origin_wins = true;
                         }
                     })
-                    .or_insert_with(|| path.clone());
+                    .or_insert_with(|| {
+                        origin_wins = true;
+                        path.clone()
+                    });
+                if origin_wins {
+                    result.class_origins.insert(fqcn, origin);
+                }
             }
             for fqn in scan.functions {
                 result

src/classmap_scanner/mod.rs

@@ -162,6 +162,10 @@ pub struct ScanResult {
 pub struct WorkspaceScanResult {
     /// FQN → file path for classes, interfaces, traits, and enums.
     pub classmap: HashMap<String, PathBuf>,
+    /// FQN → completion origin tier for classes, interfaces, traits, and
+    /// enums. Populated from the package a file was collected under, so
+    /// no second pass over the classmap is needed to classify origins.
+    pub(crate) class_origins: HashMap<String, crate::ClassCompletionOrigin>,
     /// FQN → file path for standalone functions.
     pub function_index: HashMap<String, PathBuf>,
     /// FQN → completion origin tier for standalone functions.
@@ -170,6 +174,11 @@ pub struct WorkspaceScanResult {
     pub constant_index: HashMap<String, PathBuf>,
     /// Constant name → completion origin tier.
     pub(crate) constant_origins: HashMap<String, crate::ClassCompletionOrigin>,
+    /// Vendor package roots discovered while parsing `installed.json`
+    /// during this scan (path, origin, package name), sorted
+    /// longest-path-first for prefix-match origin lookups. Empty for
+    /// scans that never touch a vendor tree.
+    pub(crate) package_roots: Vec<(PathBuf, crate::ClassCompletionOrigin, String)>,
 }
 
 // ─── Public API ─────────────────────────────────────────────────────────────