Add missing stubs

Author: AJenbo

.github/workflows/release.yml

@@ -53,6 +53,20 @@ jobs:
         with:
           key: ${{ matrix.target }}
 
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: '8.4'
+          tools: composer
+
+      - name: Cache Composer stubs
+        uses: actions/cache@v4
+        with:
+          path: stubs
+          key: composer-stubs-${{ hashFiles('composer.lock') }}
+          restore-keys: composer-stubs-
+
+      - run: composer install --no-interaction --prefer-dist
+
       - name: Build
         run: cargo build --release --target ${{ matrix.target }}
 

src/lib.rs

@@ -149,6 +149,29 @@ impl Backend {
         }
     }
 
+    /// Create a `Backend` for tests with custom stub class index.
+    ///
+    /// This allows tests to inject minimal stub content (e.g. `UnitEnum`,
+    /// `BackedEnum`) without depending on `composer install` having been run.
+    pub fn new_test_with_stubs(stub_index: HashMap<&'static str, &'static str>) -> Self {
+        Self {
+            name: "PHPantomLSP".to_string(),
+            version: "0.1.0".to_string(),
+            open_files: Arc::new(Mutex::new(HashMap::new())),
+            ast_map: Arc::new(Mutex::new(HashMap::new())),
+            client: None,
+            workspace_root: Arc::new(Mutex::new(None)),
+            psr4_mappings: Arc::new(Mutex::new(Vec::new())),
+            use_map: Arc::new(Mutex::new(HashMap::new())),
+            namespace_map: Arc::new(Mutex::new(HashMap::new())),
+            global_functions: Arc::new(Mutex::new(HashMap::new())),
+            class_index: Arc::new(Mutex::new(HashMap::new())),
+            stub_index,
+            stub_function_index: stubs::build_stub_function_index(),
+            stub_constant_index: stubs::build_stub_constant_index(),
+        }
+    }
+
     /// Create a `Backend` for tests with a specific workspace root and PSR-4
     /// mappings pre-configured.
     pub fn new_test_with_workspace(

tests/common/mod.rs

@@ -1,12 +1,44 @@
 #![allow(dead_code)]
 
 use phpantom_lsp::Backend;
+use std::collections::HashMap;
 use std::fs;
 
 pub fn create_test_backend() -> Backend {
     Backend::new_test()
 }
 
+// Minimal PHP stubs for UnitEnum and BackedEnum so that tests exercising
+// the "embedded stub" code-path work without `composer install`.
+static UNIT_ENUM_STUB: &str = "\
+<?php
+interface UnitEnum
+{
+    public static function cases(): array;
+    public readonly string $name;
+}
+";
+
+static BACKED_ENUM_STUB: &str = "\
+<?php
+interface BackedEnum extends UnitEnum
+{
+    public static function from(int|string $value): static;
+    public static function tryFrom(int|string $value): ?static;
+    public readonly int|string $value;
+}
+";
+
+/// Create a test backend whose `stub_index` contains minimal `UnitEnum`
+/// and `BackedEnum` stubs.  This makes "embedded stub" tests fully
+/// self-contained — they no longer require a prior `composer install`.
+pub fn create_test_backend_with_stubs() -> Backend {
+    let mut stubs: HashMap<&'static str, &'static str> = HashMap::new();
+    stubs.insert("UnitEnum", UNIT_ENUM_STUB);
+    stubs.insert("BackedEnum", BACKED_ENUM_STUB);
+    Backend::new_test_with_stubs(stubs)
+}
+
 /// Helper: create a temp workspace with a composer.json and PHP files,
 /// then return a Backend configured with that workspace root + PSR-4 mappings.
 pub fn create_psr4_workspace(

tests/completion_enums.rs

@@ -1,6 +1,6 @@
 mod common;
 
-use common::{create_psr4_workspace, create_test_backend};
+use common::{create_psr4_workspace, create_test_backend, create_test_backend_with_stubs};
 
 use tower_lsp::LanguageServer;
 use tower_lsp::lsp_types::*;
@@ -11,7 +11,7 @@ use tower_lsp::lsp_types::*;
 /// just like `Priority::tryFrom($int)->` does.
 #[tokio::test]
 async fn test_completion_nullsafe_arrow_on_tryfrom() {
-    let backend = create_test_backend();
+    let backend = create_test_backend_with_stubs();
 
     let uri = Url::parse("file:///nullsafe_enum.php").unwrap();
     let text = concat!(
@@ -80,7 +80,7 @@ async fn test_completion_nullsafe_arrow_on_tryfrom() {
 /// Test: Verify that `->` (without `?`) on tryFrom still works (regression guard).
 #[tokio::test]
 async fn test_completion_regular_arrow_on_tryfrom() {
-    let backend = create_test_backend();
+    let backend = create_test_backend_with_stubs();
 
     let uri = Url::parse("file:///regular_arrow_enum.php").unwrap();
     let text = concat!(
@@ -1851,7 +1851,7 @@ async fn test_parser_enum_with_trait_also_has_implicit_interface() {
 /// `$name` without any manually opened stub files.
 #[tokio::test]
 async fn test_completion_unit_enum_gets_cases_from_embedded_stub() {
-    let backend = create_test_backend();
+    let backend = create_test_backend_with_stubs();
 
     let uri = Url::parse("file:///embedded_unit.php").unwrap();
     let text = concat!(
@@ -1938,7 +1938,7 @@ async fn test_completion_unit_enum_gets_cases_from_embedded_stub() {
 /// BackedEnum extends UnitEnum.
 #[tokio::test]
 async fn test_completion_backed_enum_gets_all_spl_members_from_embedded_stubs() {
-    let backend = create_test_backend();
+    let backend = create_test_backend_with_stubs();
 
     let uri = Url::parse("file:///embedded_backed.php").unwrap();
     let text = concat!(
@@ -2037,7 +2037,7 @@ async fn test_completion_backed_enum_gets_all_spl_members_from_embedded_stubs()
 /// (from UnitEnum) and `$value` (from BackedEnum) plus instance methods.
 #[tokio::test]
 async fn test_completion_backed_enum_arrow_gets_properties_from_embedded_stubs() {
-    let backend = create_test_backend();
+    let backend = create_test_backend_with_stubs();
 
     let uri = Url::parse("file:///embedded_arrow.php").unwrap();
     let text = concat!(
@@ -2124,7 +2124,7 @@ async fn test_completion_backed_enum_arrow_gets_properties_from_embedded_stubs()
 /// enum in the same session also gets the methods without re-parsing.
 #[tokio::test]
 async fn test_completion_embedded_stub_caching_across_files() {
-    let backend = create_test_backend();
+    let backend = create_test_backend_with_stubs();
 
     // First file: a unit enum
     let uri1 = Url::parse("file:///cache_test_1.php").unwrap();