Fliter completion of identifiers

Author: AJenbo

src/completion/builder.rs

@@ -334,22 +334,34 @@ impl Backend {
     /// 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
+    ///   3. Classes from the class_index (discovered during parsing)
     ///   4. Classes from the Composer classmap (`autoload_classmap.php`)
-    ///   5. Classes from the class_index (discovered during parsing)
+    ///   5. Built-in PHP classes from embedded stubs
     ///
     /// Each item uses the short class name as `label` and the
     /// fully-qualified name as `detail`.  Items are deduplicated by FQN.
+    ///
+    /// Returns `(items, is_incomplete)`.  When the total number of
+    /// matching classes exceeds [`MAX_CLASS_COMPLETIONS`], the result is
+    /// truncated and `is_incomplete` is `true`, signalling the client to
+    /// re-request as the user types more characters.
+    const MAX_CLASS_COMPLETIONS: usize = 100;
+
     pub(crate) fn build_class_name_completions(
         &self,
         file_use_map: &HashMap<String, String>,
         file_namespace: &Option<String>,
-    ) -> Vec<CompletionItem> {
+        prefix: &str,
+    ) -> (Vec<CompletionItem>, bool) {
+        let prefix_lower = prefix.to_lowercase();
         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 !short_name.to_lowercase().contains(&prefix_lower) {
+                continue;
+            }
             if !seen_fqns.insert(fqn.clone()) {
                 continue;
             }
@@ -385,6 +397,9 @@ impl Backend {
                 for uri in &same_ns_uris {
                     if let Some(classes) = amap.get(uri) {
                         for cls in classes {
+                            if !cls.name.to_lowercase().contains(&prefix_lower) {
+                                continue;
+                            }
                             let fqn = format!("{}\\{}", ns, cls.name);
                             if !seen_fqns.insert(fqn.clone()) {
                                 continue;
@@ -404,49 +419,38 @@ impl Backend {
             }
         }
 
-        // ── 3. Built-in PHP classes from stubs ──────────────────────
-        for &name in self.stub_index.keys() {
-            if !seen_fqns.insert(name.to_string()) {
-                continue;
-            }
-            let short_name = name.rsplit('\\').next().unwrap_or(name);
-            items.push(CompletionItem {
-                label: short_name.to_string(),
-                kind: Some(CompletionItemKind::CLASS),
-                detail: Some(name.to_string()),
-                insert_text: Some(short_name.to_string()),
-                filter_text: Some(short_name.to_string()),
-                sort_text: Some(format!("2_{}", short_name.to_lowercase())),
-                ..CompletionItem::default()
-            });
-        }
-
-        // ── 4. Composer classmap ────────────────────────────────────
-        if let Ok(cmap) = self.classmap.lock() {
-            for fqn in cmap.keys() {
+        // ── 3. class_index (discovered / interacted-with classes) ───
+        if let Ok(idx) = self.class_index.lock() {
+            for fqn in idx.keys() {
+                let short_name = fqn.rsplit('\\').next().unwrap_or(fqn);
+                if !short_name.to_lowercase().contains(&prefix_lower) {
+                    continue;
+                }
                 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())),
+                    sort_text: Some(format!("2_{}", short_name.to_lowercase())),
                     ..CompletionItem::default()
                 });
             }
         }
 
-        // ── 5. class_index (discovered classes) ─────────────────────
-        if let Ok(idx) = self.class_index.lock() {
-            for fqn in idx.keys() {
+        // ── 4. Composer classmap (all autoloaded classes) ───────────
+        if let Ok(cmap) = self.classmap.lock() {
+            for fqn in cmap.keys() {
+                let short_name = fqn.rsplit('\\').next().unwrap_or(fqn);
+                if !short_name.to_lowercase().contains(&prefix_lower) {
+                    continue;
+                }
                 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),
@@ -459,6 +463,36 @@ impl Backend {
             }
         }
 
-        items
+        // ── 5. Built-in PHP classes from stubs (lowest priority) ────
+        for &name in self.stub_index.keys() {
+            let short_name = name.rsplit('\\').next().unwrap_or(name);
+            if !short_name.to_lowercase().contains(&prefix_lower) {
+                continue;
+            }
+            if !seen_fqns.insert(name.to_string()) {
+                continue;
+            }
+            items.push(CompletionItem {
+                label: short_name.to_string(),
+                kind: Some(CompletionItemKind::CLASS),
+                detail: Some(name.to_string()),
+                insert_text: Some(short_name.to_string()),
+                filter_text: Some(short_name.to_string()),
+                sort_text: Some(format!("4_{}", short_name.to_lowercase())),
+                ..CompletionItem::default()
+            });
+        }
+
+        // Cap the result set so the client isn't overwhelmed.
+        // Sort by sort_text first so that higher-priority items
+        // (use-imports, same-namespace, user project classes) survive
+        // the truncation ahead of lower-priority SPL stubs.
+        let is_incomplete = items.len() > Self::MAX_CLASS_COMPLETIONS;
+        if is_incomplete {
+            items.sort_by(|a, b| a.sort_text.cmp(&b.sort_text));
+            items.truncate(Self::MAX_CLASS_COMPLETIONS);
+        }
+
+        (items, is_incomplete)
     }
 }

src/server.rs

@@ -456,10 +456,14 @@ impl LanguageServer for Backend {
             // user is typing a class name and offer completions from all
             // known sources (use-imports, same namespace, stubs, classmap,
             // class_index).
-            if Self::extract_partial_class_name(&content, position).is_some() {
-                let class_items = self.build_class_name_completions(&file_use_map, &file_namespace);
+            if let Some(partial) = Self::extract_partial_class_name(&content, position) {
+                let (class_items, is_incomplete) =
+                    self.build_class_name_completions(&file_use_map, &file_namespace, &partial);
                 if !class_items.is_empty() {
-                    return Ok(Some(CompletionResponse::Array(class_items)));
+                    return Ok(Some(CompletionResponse::List(CompletionList {
+                        is_incomplete,
+                        items: class_items,
+                    })));
                 }
             }
         }

tests/completion_class_names.rs

@@ -175,27 +175,33 @@ async fn test_class_name_completion_includes_stubs() {
     let backend = create_test_backend_with_stubs();
 
     let uri = Url::parse("file:///test.php").unwrap();
-    let text = concat!("<?php\n", "new Date\n",);
 
-    let items = complete_at(&backend, &uri, text, 1, 8).await;
-    let classes = class_items(&items);
+    // Check UnitEnum is found when typing "Unit"
+    let text_unit = concat!("<?php\n", "new Unit\n",);
+    let items_unit = complete_at(&backend, &uri, text_unit, 1, 8).await;
+    let classes_unit = class_items(&items_unit);
+    let labels_unit: Vec<&str> = classes_unit.iter().map(|i| i.label.as_str()).collect();
 
     assert!(
-        !classes.is_empty(),
+        !classes_unit.is_empty(),
         "Should return class name completions when typing a class name"
     );
-
-    // The stub backend has UnitEnum and BackedEnum
-    let class_labels: Vec<&str> = classes.iter().map(|i| i.label.as_str()).collect();
     assert!(
-        class_labels.contains(&"UnitEnum"),
+        labels_unit.contains(&"UnitEnum"),
         "Should include stub class 'UnitEnum', got: {:?}",
-        class_labels
+        labels_unit
     );
+
+    // Check BackedEnum is found when typing "Backed"
+    let text_backed = concat!("<?php\n", "new Backed\n",);
+    let items_backed = complete_at(&backend, &uri, text_backed, 1, 10).await;
+    let classes_backed = class_items(&items_backed);
+    let labels_backed: Vec<&str> = classes_backed.iter().map(|i| i.label.as_str()).collect();
+
     assert!(
-        class_labels.contains(&"BackedEnum"),
+        labels_backed.contains(&"BackedEnum"),
         "Should include stub class 'BackedEnum', got: {:?}",
-        class_labels
+        labels_backed
     );
 }
 
@@ -424,8 +430,9 @@ async fn test_class_name_completion_from_classmap() {
     }
 
     let uri = Url::parse("file:///app.php").unwrap();
-    let text = concat!("<?php\n", "new Coll\n",);
 
+    // Check Collection matches prefix "Coll"
+    let text = concat!("<?php\n", "new Coll\n",);
     let items = complete_at(&backend, &uri, text, 1, 8).await;
     let classes = class_items(&items);
     let class_labels: Vec<&str> = classes.iter().map(|i| i.label.as_str()).collect();
@@ -435,15 +442,27 @@ async fn test_class_name_completion_from_classmap() {
         "Should include classmap class 'Collection', got: {:?}",
         class_labels
     );
+
+    // Check Model matches prefix "Mo"
+    let text_mo = concat!("<?php\n", "new Mo\n",);
+    let items_mo = complete_at(&backend, &uri, text_mo, 1, 6).await;
+    let classes_mo = class_items(&items_mo);
+    let labels_mo: Vec<&str> = classes_mo.iter().map(|i| i.label.as_str()).collect();
     assert!(
-        class_labels.contains(&"Model"),
+        labels_mo.contains(&"Model"),
         "Should include classmap class 'Model', got: {:?}",
-        class_labels
+        labels_mo
     );
+
+    // Check Carbon matches prefix "Car"
+    let text_car = concat!("<?php\n", "new Car\n",);
+    let items_car = complete_at(&backend, &uri, text_car, 1, 7).await;
+    let classes_car = class_items(&items_car);
+    let labels_car: Vec<&str> = classes_car.iter().map(|i| i.label.as_str()).collect();
     assert!(
-        class_labels.contains(&"Carbon"),
+        labels_car.contains(&"Carbon"),
         "Should include classmap class 'Carbon', got: {:?}",
-        class_labels
+        labels_car
     );
 
     // Check that detail shows the FQN
@@ -480,8 +499,9 @@ async fn test_class_name_completion_from_class_index() {
     }
 
     let uri = Url::parse("file:///test.php").unwrap();
-    let text = concat!("<?php\n", "new Us\n",);
 
+    // Check User matches prefix "Us"
+    let text = concat!("<?php\n", "new Us\n",);
     let items = complete_at(&backend, &uri, text, 1, 6).await;
     let classes = class_items(&items);
     let class_labels: Vec<&str> = classes.iter().map(|i| i.label.as_str()).collect();
@@ -491,10 +511,17 @@ async fn test_class_name_completion_from_class_index() {
         "Should include class_index class 'User', got: {:?}",
         class_labels
     );
+
+    // Check Order matches prefix "Or"
+    let text_or = concat!("<?php\n", "new Or\n",);
+    let items_or = complete_at(&backend, &uri, text_or, 1, 6).await;
+    let classes_or = class_items(&items_or);
+    let labels_or: Vec<&str> = classes_or.iter().map(|i| i.label.as_str()).collect();
+
     assert!(
-        class_labels.contains(&"Order"),
+        labels_or.contains(&"Order"),
         "Should include class_index class 'Order', got: {:?}",
-        class_labels
+        labels_or
     );
 }
 
@@ -724,33 +751,43 @@ async fn test_class_name_completion_combines_all_sources() {
         );
     }
 
-    // Open a file with a use statement
+    // Open a file with a use statement — use a prefix that matches
+    // classes from all three sources.  All test class names end with
+    // "Class", so the prefix "Cl" only matches "ClassmapClass".
+    // Instead we use separate checks per source.
     let uri = Url::parse("file:///test.php").unwrap();
-    let text = concat!("<?php\n", "use App\\IndexedClass;\n", "new Cl\n",);
-
-    let items = complete_at(&backend, &uri, text, 2, 6).await;
-    let classes = class_items(&items);
-    let class_labels: Vec<&str> = classes.iter().map(|i| i.label.as_str()).collect();
 
-    // Should include from stubs
+    // Check stubs: "Stub" matches "StubClass"
+    let text_stub = concat!("<?php\n", "use App\\IndexedClass;\n", "new Stub\n",);
+    let items_stub = complete_at(&backend, &uri, text_stub, 2, 8).await;
+    let classes_stub = class_items(&items_stub);
+    let labels_stub: Vec<&str> = classes_stub.iter().map(|i| i.label.as_str()).collect();
     assert!(
-        class_labels.contains(&"StubClass"),
+        labels_stub.contains(&"StubClass"),
         "Should include stub class, got: {:?}",
-        class_labels
+        labels_stub
     );
 
-    // Should include from classmap
+    // Check classmap: "Classmap" matches "ClassmapClass"
+    let text_cm = concat!("<?php\n", "use App\\IndexedClass;\n", "new Classmap\n",);
+    let items_cm = complete_at(&backend, &uri, text_cm, 2, 12).await;
+    let classes_cm = class_items(&items_cm);
+    let labels_cm: Vec<&str> = classes_cm.iter().map(|i| i.label.as_str()).collect();
     assert!(
-        class_labels.contains(&"ClassmapClass"),
+        labels_cm.contains(&"ClassmapClass"),
         "Should include classmap class, got: {:?}",
-        class_labels
+        labels_cm
     );
 
-    // Should include from use-import (which is also in class_index)
+    // Check use-import / class_index: "Indexed" matches "IndexedClass"
+    let text_idx = concat!("<?php\n", "use App\\IndexedClass;\n", "new Indexed\n",);
+    let items_idx = complete_at(&backend, &uri, text_idx, 2, 11).await;
+    let classes_idx = class_items(&items_idx);
+    let labels_idx: Vec<&str> = classes_idx.iter().map(|i| i.label.as_str()).collect();
     assert!(
-        class_labels.contains(&"IndexedClass"),
+        labels_idx.contains(&"IndexedClass"),
         "Should include use-imported / class_index class, got: {:?}",
-        class_labels
+        labels_idx
     );
 }