Add support for Composer classmap and basic class name completion

Author: AJenbo

example.php

@@ -646,4 +646,4 @@ function handleIntersection(User&Loggable $entity): void
     $l->getEmail();              // negated → User
 } else {
     $l->grantPermission('y');    // negated else → AdminUser
-}
+}

src/completion/builder.rs

@@ -2,7 +2,10 @@
 ///
 /// This module contains the logic for constructing LSP `CompletionItem`s from
 /// resolved `ClassInfo`, filtered by the `AccessKind` (arrow, double-colon,
-/// or parent double-colon).
+/// or parent double-colon), as well as class name completion when no member
+/// access operator is present.
+use std::collections::{HashMap, HashSet};
+
 use tower_lsp::lsp_types::*;
 
 use crate::Backend;
@@ -248,4 +251,195 @@ impl Backend {
 
         items
     }
+
+    // ─── Class name completion ──────────────────────────────────────────
+
+    /// Extract the partial identifier (class name fragment) that the user
+    /// is currently typing at the given cursor position.
+    ///
+    /// Walks backward from the cursor through alphanumeric characters,
+    /// underscores, and backslashes (namespace separators).  Returns
+    /// `None` if the resulting text starts with `$` (variable context)
+    /// or is empty.
+    pub fn extract_partial_class_name(
+        content: &str,
+        position: Position,
+    ) -> Option<String> {
+        let lines: Vec<&str> = content.lines().collect();
+        if position.line as usize >= lines.len() {
+            return None;
+        }
+
+        let line = lines[position.line as usize];
+        let chars: Vec<char> = line.chars().collect();
+        let col = (position.character as usize).min(chars.len());
+
+        // Walk backwards through identifier characters (including `\`)
+        let mut i = col;
+        while i > 0
+            && (chars[i - 1].is_alphanumeric() || chars[i - 1] == '_' || chars[i - 1] == '\\')
+        {
+            i -= 1;
+        }
+
+        if i == col {
+            // Nothing typed — no partial identifier
+            return None;
+        }
+
+        // If preceded by `$`, this is a variable, not a class name
+        if i > 0 && chars[i - 1] == '$' {
+            return None;
+        }
+
+        // If preceded by `->` or `::`, member completion handles this
+        if i >= 2 && chars[i - 2] == '-' && chars[i - 1] == '>' {
+            return None;
+        }
+        if i >= 2 && chars[i - 2] == ':' && chars[i - 1] == ':' {
+            return None;
+        }
+
+        let partial: String = chars[i..col].iter().collect();
+        if partial.is_empty() {
+            return None;
+        }
+
+        Some(partial)
+    }
+
+    /// Build completion items for class names from all known sources.
+    ///
+    /// Sources (in priority order):
+    ///   1. Classes imported via `use` statements in the current file
+    ///   2. Classes in the same namespace (from the ast_map)
+    ///   3. Built-in PHP classes from embedded stubs
+    ///   4. Classes from the Composer classmap (`autoload_classmap.php`)
+    ///   5. Classes from the class_index (discovered during parsing)
+    ///
+    /// Each item uses the short class name as `label` and the
+    /// fully-qualified name as `detail`.  Items are deduplicated by FQN.
+    pub(crate) fn build_class_name_completions(
+        &self,
+        file_use_map: &HashMap<String, String>,
+        file_namespace: &Option<String>,
+    ) -> Vec<CompletionItem> {
+        let mut seen_fqns: HashSet<String> = HashSet::new();
+        let mut items: Vec<CompletionItem> = Vec::new();
+
+        // ── 1. Use-imported classes (highest priority) ──────────────
+        for (short_name, fqn) in file_use_map {
+            if !seen_fqns.insert(fqn.clone()) {
+                continue;
+            }
+            items.push(CompletionItem {
+                label: short_name.clone(),
+                kind: Some(CompletionItemKind::CLASS),
+                detail: Some(fqn.clone()),
+                insert_text: Some(short_name.clone()),
+                filter_text: Some(short_name.clone()),
+                sort_text: Some(format!("0_{}", short_name.to_lowercase())),
+                ..CompletionItem::default()
+            });
+        }
+
+        // ── 2. Same-namespace classes (from ast_map) ────────────────
+        if let Some(ns) = file_namespace {
+            if let Ok(nmap) = self.namespace_map.lock() {
+                // Find all URIs that share the same namespace
+                let same_ns_uris: Vec<String> = nmap
+                    .iter()
+                    .filter_map(|(uri, opt_ns)| {
+                        if opt_ns.as_deref() == Some(ns.as_str()) {
+                            Some(uri.clone())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+                drop(nmap);
+
+                if let Ok(amap) = self.ast_map.lock() {
+                    for uri in &same_ns_uris {
+                        if let Some(classes) = amap.get(uri) {
+                            for cls in classes {
+                                let fqn = format!("{}\\{}", ns, cls.name);
+                                if !seen_fqns.insert(fqn.clone()) {
+                                    continue;
+                                }
+                                items.push(CompletionItem {
+                                    label: cls.name.clone(),
+                                    kind: Some(CompletionItemKind::CLASS),
+                                    detail: Some(fqn),
+                                    insert_text: Some(cls.name.clone()),
+                                    filter_text: Some(cls.name.clone()),
+                                    sort_text: Some(format!(
+                                        "1_{}",
+                                        cls.name.to_lowercase()
+                                    )),
+                                    ..CompletionItem::default()
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // ── 3. Built-in PHP classes from stubs ──────────────────────
+        for &name in self.stub_index.keys() {
+            if !seen_fqns.insert(name.to_string()) {
+                continue;
+            }
+            items.push(CompletionItem {
+                label: name.to_string(),
+                kind: Some(CompletionItemKind::CLASS),
+                detail: Some(name.to_string()),
+                insert_text: Some(name.to_string()),
+                filter_text: Some(name.to_string()),
+                sort_text: Some(format!("2_{}", name.to_lowercase())),
+                ..CompletionItem::default()
+            });
+        }
+
+        // ── 4. Composer classmap ────────────────────────────────────
+        if let Ok(cmap) = self.classmap.lock() {
+            for fqn in cmap.keys() {
+                if !seen_fqns.insert(fqn.clone()) {
+                    continue;
+                }
+                let short_name = fqn.rsplit('\\').next().unwrap_or(fqn);
+                items.push(CompletionItem {
+                    label: short_name.to_string(),
+                    kind: Some(CompletionItemKind::CLASS),
+                    detail: Some(fqn.clone()),
+                    insert_text: Some(short_name.to_string()),
+                    filter_text: Some(short_name.to_string()),
+                    sort_text: Some(format!("3_{}", short_name.to_lowercase())),
+                    ..CompletionItem::default()
+                });
+            }
+        }
+
+        // ── 5. class_index (discovered classes) ─────────────────────
+        if let Ok(idx) = self.class_index.lock() {
+            for fqn in idx.keys() {
+                if !seen_fqns.insert(fqn.clone()) {
+                    continue;
+                }
+                let short_name = fqn.rsplit('\\').next().unwrap_or(fqn);
+                items.push(CompletionItem {
+                    label: short_name.to_string(),
+                    kind: Some(CompletionItemKind::CLASS),
+                    detail: Some(fqn.clone()),
+                    insert_text: Some(short_name.to_string()),
+                    filter_text: Some(short_name.to_string()),
+                    sort_text: Some(format!("3_{}", short_name.to_lowercase())),
+                    ..CompletionItem::default()
+                });
+            }
+        }
+
+        items
+    }
 }

src/composer.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::fs;
 /// Composer autoload support.
 ///
@@ -160,6 +161,70 @@ pub fn parse_vendor_autoload_psr4(workspace_root: &Path, vendor_dir: &str) -> Ve
     mappings
 }
 
+/// Parse `<vendor>/composer/autoload_classmap.php` and return a mapping
+/// from fully-qualified class name to file path (relative to the workspace
+/// root).
+///
+/// This file is generated by `composer install` / `composer dump-autoload`
+/// and maps class names directly to their defining files.  When the user
+/// runs `composer install -o` (optimised autoloader), Composer converts
+/// all PSR-0 and PSR-4 mappings into a classmap, giving us complete
+/// coverage of every loadable class.
+///
+/// The file contains lines like:
+/// ```text
+///     'AWS\\CRT\\Auth\\AwsCredentials' => $vendorDir . '/aws/aws-crt-php/src/AWS/CRT/Auth/AwsCredentials.php',
+///     'App\\Models\\User' => $baseDir . '/app/Models/User.php',
+/// ```
+///
+/// `$vendorDir` is resolved relative to the workspace root using the
+/// configured vendor directory.  `$baseDir` is the workspace root itself.
+///
+/// Returns an empty `HashMap` if the file does not exist or cannot be
+/// parsed.
+pub fn parse_autoload_classmap(
+    workspace_root: &Path,
+    vendor_dir: &str,
+) -> HashMap<String, PathBuf> {
+    let autoload_path = workspace_root
+        .join(vendor_dir)
+        .join("composer")
+        .join("autoload_classmap.php");
+
+    let content = match fs::read_to_string(&autoload_path) {
+        Ok(c) => c,
+        Err(_) => return HashMap::new(),
+    };
+
+    let mut classmap = HashMap::new();
+
+    for line in content.lines() {
+        let trimmed = line.trim();
+
+        // Match lines of the form:
+        //   'Fully\\Qualified\\ClassName' => $vendorDir . '/path/to/File.php',
+        //   'Fully\\Qualified\\ClassName' => $baseDir . '/path/to/File.php',
+        if let Some(rest) = trimmed.strip_prefix('\'') {
+            if let Some(arrow_pos) = rest.find("' => ") {
+                // Unescape PHP single-quoted string escapes:
+                //   \\  →  \
+                //   \'  →  '
+                let class_name = rest[..arrow_pos]
+                    .replace("\\\\'", "'")
+                    .replace("\\\\", "\\");
+
+                let rhs = rest[arrow_pos + "' => ".len()..].trim().trim_end_matches(',');
+
+                if let Some(relative_path) = resolve_autoload_path_entry(rhs, vendor_dir) {
+                    classmap.insert(class_name, workspace_root.join(&relative_path));
+                }
+            }
+        }
+    }
+
+    classmap
+}
+
 /// Resolve a single path entry from `autoload_psr4.php`.
 ///
 /// Handles `$vendorDir . '/path'` and `$baseDir . '/path'`.

src/lib.rs

@@ -5,7 +5,7 @@
 //! - [`types`]: Data structures for extracted PHP information (classes, methods, functions, etc.)
 //! - [`parser`]: PHP parsing and AST extraction using mago_syntax
 //! - [`completion`]: Completion logic (target extraction, type resolution, item building)
-//! - [`composer`]: Composer autoload (PSR-4) parsing and class-to-file resolution
+//! - [`composer`]: Composer autoload (PSR-4, classmap) parsing and class-to-file resolution
 //! - [`server`]: The LSP `LanguageServer` trait implementation
 //! - [`util`]: Utility helpers (position conversion, class lookup, logging)
 //! - [`definition`]: Go-to-definition support for classes, members, and functions
@@ -85,6 +85,17 @@ pub struct Backend {
     /// Populated during `update_ast` (using the file's namespace + class
     /// short name) and during server initialization for autoload files.
     pub class_index: Arc<Mutex<HashMap<String, String>>>,
+    /// Composer classmap: fully-qualified class name → file path on disk.
+    ///
+    /// Parsed from `<vendor>/composer/autoload_classmap.php` during server
+    /// initialization.  This provides a direct FQN-to-file lookup that
+    /// covers classes not discoverable via PSR-4 — and when the user runs
+    /// `composer install -o`, Composer converts *all* PSR-0/PSR-4
+    /// mappings into a classmap, giving complete class coverage.
+    ///
+    /// Consulted by `find_or_load_class` as a resolution step between
+    /// the ast_map scan (Phase 1) and PSR-4 resolution (Phase 2).
+    pub classmap: Arc<Mutex<HashMap<String, PathBuf>>>,
     /// Embedded PHP stubs for built-in classes/interfaces (e.g. `UnitEnum`,
     /// `BackedEnum`, `Iterator`, `Countable`, …).
     /// Maps class short name → raw PHP source code.
@@ -123,6 +134,7 @@ impl Backend {
             namespace_map: Arc::new(Mutex::new(HashMap::new())),
             global_functions: Arc::new(Mutex::new(HashMap::new())),
             class_index: Arc::new(Mutex::new(HashMap::new())),
+            classmap: Arc::new(Mutex::new(HashMap::new())),
             stub_index: stubs::build_stub_class_index(),
             stub_function_index: stubs::build_stub_function_index(),
             stub_constant_index: stubs::build_stub_constant_index(),
@@ -143,6 +155,7 @@ impl Backend {
             namespace_map: Arc::new(Mutex::new(HashMap::new())),
             global_functions: Arc::new(Mutex::new(HashMap::new())),
             class_index: Arc::new(Mutex::new(HashMap::new())),
+            classmap: Arc::new(Mutex::new(HashMap::new())),
             stub_index: stubs::build_stub_class_index(),
             stub_function_index: stubs::build_stub_function_index(),
             stub_constant_index: stubs::build_stub_constant_index(),
@@ -166,6 +179,7 @@ impl Backend {
             namespace_map: Arc::new(Mutex::new(HashMap::new())),
             global_functions: Arc::new(Mutex::new(HashMap::new())),
             class_index: Arc::new(Mutex::new(HashMap::new())),
+            classmap: Arc::new(Mutex::new(HashMap::new())),
             stub_index,
             stub_function_index: stubs::build_stub_function_index(),
             stub_constant_index: stubs::build_stub_constant_index(),
@@ -194,6 +208,7 @@ impl Backend {
             namespace_map: Arc::new(Mutex::new(HashMap::new())),
             global_functions: Arc::new(Mutex::new(HashMap::new())),
             class_index: Arc::new(Mutex::new(HashMap::new())),
+            classmap: Arc::new(Mutex::new(HashMap::new())),
             stub_index,
             stub_function_index,
             stub_constant_index,
@@ -218,6 +233,7 @@ impl Backend {
             namespace_map: Arc::new(Mutex::new(HashMap::new())),
             global_functions: Arc::new(Mutex::new(HashMap::new())),
             class_index: Arc::new(Mutex::new(HashMap::new())),
+            classmap: Arc::new(Mutex::new(HashMap::new())),
             stub_index: stubs::build_stub_class_index(),
             stub_function_index: stubs::build_stub_function_index(),
             stub_constant_index: stubs::build_stub_constant_index(),