Be more agressive about when we do compleation

Author: AJenbo

src/completion/handler.rs

@@ -531,14 +531,8 @@ impl Backend {
             }
         }
 
-        // Fallback: return the default PHPantomLSP completion item
-        Ok(Some(CompletionResponse::Array(vec![CompletionItem {
-            label: "PHPantomLSP".to_string(),
-            kind: Some(CompletionItemKind::TEXT),
-            detail: Some("PHPantomLSP completion".to_string()),
-            insert_text: Some("PHPantomLSP".to_string()),
-            ..CompletionItem::default()
-        }])))
+        // Nothing matched — return no completions.
+        Ok(None)
     }
 
     /// Insert `);` at the given cursor position in `content`.

src/server.rs

@@ -40,6 +40,7 @@ impl LanguageServer for Backend {
                         "'".to_string(),
                         "\"".to_string(),
                         "[".to_string(),
+                        " ".to_string(),
                     ]),
                     all_commit_characters: None,
                     work_done_progress_options: WorkDoneProgressOptions {

tests/completion_basic.rs

@@ -142,7 +142,7 @@ async fn test_completion_interface_constant_via_double_colon() {
 // ─── Basic Completion Tests ─────────────────────────────────────────────────
 
 #[tokio::test]
-async fn test_completion_returns_phpantomlsp() {
+async fn test_completion_returns_none_when_nothing_matches() {
     let backend = create_test_backend();
 
     let uri = Url::parse("file:///test.php").unwrap();
@@ -172,15 +172,10 @@ async fn test_completion_returns_phpantomlsp() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    assert!(result.is_some(), "Completion should return results");
-
-    match result.unwrap() {
-        CompletionResponse::Array(items) => {
-            assert!(!items.is_empty(), "Should have at least one item");
-            assert_eq!(items[0].label, "PHPantomLSP");
-        }
-        _ => panic!("Expected CompletionResponse::Array"),
-    }
+    assert!(
+        result.is_none(),
+        "Completion should return None when nothing matches"
+    );
 }
 
 #[tokio::test]
@@ -306,15 +301,10 @@ async fn test_completion_outside_class_returns_fallback() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    assert!(result.is_some());
-
-    match result.unwrap() {
-        CompletionResponse::Array(items) => {
-            assert_eq!(items.len(), 1, "Should fall back to default item");
-            assert_eq!(items[0].label, "PHPantomLSP");
-        }
-        _ => panic!("Expected CompletionResponse::Array"),
-    }
+    assert!(
+        result.is_none(),
+        "Cursor outside class with no operator should return None"
+    );
 }
 
 #[tokio::test]
@@ -421,16 +411,11 @@ async fn test_completion_empty_class_falls_back() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    assert!(result.is_some());
-
-    // Empty class has no methods or properties, so should fall back to PHPantomLSP
-    match result.unwrap() {
-        CompletionResponse::Array(items) => {
-            assert_eq!(items.len(), 1);
-            assert_eq!(items[0].label, "PHPantomLSP");
-        }
-        _ => panic!("Expected CompletionResponse::Array"),
-    }
+    // Empty class has no methods or properties, so should return None
+    assert!(
+        result.is_none(),
+        "Empty class with no members should return None"
+    );
 }
 
 #[tokio::test]
@@ -475,14 +460,6 @@ async fn test_completion_no_access_operator_shows_fallback() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    assert!(result.is_some(), "Completion should return fallback");
-
-    // Without `->` or `::`, no class members should be suggested — only fallback
-    match result.unwrap() {
-        CompletionResponse::Array(items) => {
-            assert_eq!(items.len(), 1, "Should only have fallback item");
-            assert_eq!(items[0].label, "PHPantomLSP");
-        }
-        _ => panic!("Expected CompletionResponse::Array"),
-    }
+    // Without `->` or `::`, no class members should be suggested
+    assert!(result.is_none(), "No access operator should return None");
 }

tests/completion_cross_file.rs

@@ -411,15 +411,10 @@ async fn test_cross_file_no_psr4_mapping_falls_back() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    assert!(result.is_some());
-
-    match result.unwrap() {
-        CompletionResponse::Array(items) => {
-            assert_eq!(items.len(), 1, "Should fall back to default item");
-            assert_eq!(items[0].label, "PHPantomLSP");
-        }
-        _ => panic!("Expected CompletionResponse::Array"),
-    }
+    assert!(
+        result.is_none(),
+        "Should return None when no PSR-4 mapping resolves the class"
+    );
 }
 
 #[tokio::test]

tests/completion_object_shapes.rs

@@ -778,9 +778,12 @@ async fn test_bare_object_no_completions() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    // Bare `object` has no properties — result may be None or contain only
-    // the fallback PHPantomLSP item.
-    if let Some(CompletionResponse::Array(items)) = result {
+    // Bare `object` has no properties — result should be None.
+    if let Some(resp) = result {
+        let items = match resp {
+            CompletionResponse::Array(items) => items,
+            CompletionResponse::List(list) => list.items,
+        };
         let class_members: Vec<&str> = items
             .iter()
             .filter(|i| {

tests/completion_parent.rs

@@ -503,16 +503,11 @@ async fn test_completion_parent_double_colon_no_parent_falls_back() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    assert!(result.is_some());
-
-    // Should fall back to the default PHPantomLSP item since there's no parent
-    match result.unwrap() {
-        CompletionResponse::Array(items) => {
-            assert_eq!(items.len(), 1, "Should fall back to default completion");
-            assert_eq!(items[0].label, "PHPantomLSP");
-        }
-        _ => panic!("Expected CompletionResponse::Array"),
-    }
+    // Should return None since there's no parent class
+    assert!(
+        result.is_none(),
+        "parent:: with no parent class should return None"
+    );
 }
 
 #[tokio::test]
@@ -627,21 +622,11 @@ async fn test_completion_static_double_colon_suppressed_on_final_class() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    assert!(result.is_some());
-
-    // Should fall back to the default PHPantomLSP item since the class is final
-    match result.unwrap() {
-        CompletionResponse::Array(items) => {
-            assert_eq!(
-                items.len(),
-                1,
-                "static:: in a final class should fall back to default, got: {:?}",
-                items.iter().map(|i| &i.label).collect::<Vec<_>>()
-            );
-            assert_eq!(items[0].label, "PHPantomLSP");
-        }
-        _ => panic!("Expected CompletionResponse::Array"),
-    }
+    // Should return None since the class is final — static:: is suppressed
+    assert!(
+        result.is_none(),
+        "static:: in a final class should return None"
+    );
 }
 
 /// `static::` inside a non-final class should work as normal.
@@ -744,20 +729,10 @@ async fn test_completion_static_double_colon_suppressed_on_enum() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    assert!(result.is_some());
-
-    match result.unwrap() {
-        CompletionResponse::Array(items) => {
-            assert_eq!(
-                items.len(),
-                1,
-                "static:: in an enum should fall back to default (enums are final), got: {:?}",
-                items.iter().map(|i| &i.label).collect::<Vec<_>>()
-            );
-            assert_eq!(items[0].label, "PHPantomLSP");
-        }
-        _ => panic!("Expected CompletionResponse::Array"),
-    }
+    assert!(
+        result.is_none(),
+        "static:: in an enum should return None (enums are final)"
+    );
 }
 
 /// `self::` should still work on final classes (only `static::` is suppressed).

tests/completion_properties.rs

@@ -1238,22 +1238,11 @@ async fn test_completion_promoted_property_param_scalar_not_overridden() {
 
     let result = backend.completion(completion_params).await.unwrap();
     // Scalar `int` should not be overridden — no class members to complete.
-    match result {
-        None => {} // acceptable
-        Some(CompletionResponse::Array(items)) => {
-            let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
-            let meaningful: Vec<&&str> = labels
-                .iter()
-                .filter(|l| !l.contains("PHPantomLSP"))
-                .collect();
-            assert!(
-                meaningful.is_empty(),
-                "Scalar promoted property should not resolve to class. Got: {:?}",
-                labels
-            );
-        }
-        Some(CompletionResponse::List(_)) => panic!("Expected Array response"),
-    }
+    assert!(
+        result.is_none(),
+        "Scalar promoted property should not resolve to class, got: {:?}",
+        result
+    );
 }
 
 /// Property chain on non-$this variable with promoted property @param override.

tests/completion_property_chains.rs

@@ -950,25 +950,12 @@ async fn test_var_property_chain_nonexistent_property() {
     };
 
     let result = backend.completion(completion_params).await.unwrap();
-    // Should either return None, an empty list, or only the default
-    // "PHPantomLSP" placeholder — no crash, no wrong results.
-    match result {
-        None => {} // acceptable
-        Some(CompletionResponse::Array(items)) => {
-            let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
-            // The only acceptable items are none or the default placeholder.
-            let meaningful: Vec<&&str> = labels
-                .iter()
-                .filter(|l| !l.contains("PHPantomLSP"))
-                .collect();
-            assert!(
-                meaningful.is_empty(),
-                "Should return no meaningful results for nonexistent property chain. Got: {:?}",
-                labels
-            );
-        }
-        Some(CompletionResponse::List(_)) => panic!("Expected Array response"),
-    }
+    // Should return None — no crash, no wrong results.
+    assert!(
+        result.is_none(),
+        "Should return None for nonexistent property chain, got: {:?}",
+        result
+    );
 }
 
 // ─── Foreach variable property chain ────────────────────────────────────────