Add implicit interfaces on enums

Author: AJenbo

src/completion/builder.rs

@@ -89,6 +89,28 @@ impl Backend {
     ) -> Vec<CompletionItem> {
         let mut items: Vec<CompletionItem> = Vec::new();
 
+        // ─── Synthetic BackedEnum properties ────────────────────────────────
+        // If this is a BackedEnum, synthesize `name` and `value` for instance access.
+        let mut synthetic_properties: Vec<PropertyInfo> = Vec::new();
+        if target_class
+            .implemented_interfaces
+            .contains(&"\\BackedEnum".to_string())
+            && matches!(access_kind, AccessKind::Arrow | AccessKind::Other)
+        {
+            synthetic_properties.push(PropertyInfo {
+                name: "name".to_string(),
+                type_hint: Some("string".to_string()),
+                is_static: false,
+                visibility: Visibility::Public,
+            });
+            synthetic_properties.push(PropertyInfo {
+                name: "value".to_string(),
+                type_hint: Some("string|int".to_string()),
+                is_static: false,
+                visibility: Visibility::Public,
+            });
+        }
+
         // Methods — filtered by static / instance, excluding magic methods
         for method in &target_class.methods {
             if Self::is_magic_method(&method.name) {
@@ -125,7 +147,11 @@ impl Backend {
         }
 
         // Properties — filtered by static / instance
-        for property in &target_class.properties {
+        // First, add synthetic BackedEnum properties (if any)
+        for property in synthetic_properties
+            .iter()
+            .chain(target_class.properties.iter())
+        {
             // parent:: excludes private members
             if access_kind == AccessKind::ParentDoubleColon
                 && property.visibility == Visibility::Private

src/parser.rs

@@ -566,6 +566,7 @@ impl Backend {
                         parent_class,
                         used_traits,
                         mixins,
+                        implemented_interfaces: Vec::new(),
                     });
                 }
                 Statement::Interface(iface) => {
@@ -624,6 +625,7 @@ impl Backend {
                         parent_class,
                         used_traits,
                         mixins,
+                        implemented_interfaces: Vec::new(),
                     });
                 }
                 Statement::Trait(trait_def) => {
@@ -678,6 +680,7 @@ impl Backend {
                         parent_class: None,
                         used_traits,
                         mixins,
+                        implemented_interfaces: Vec::new(),
                     });
                 }
                 Statement::Enum(enum_def) => {
@@ -722,6 +725,13 @@ impl Backend {
                     let start_offset = enum_def.left_brace.start.offset;
                     let end_offset = enum_def.right_brace.end.offset;
 
+                    // Determine if the enum is backed (has a type) or is a unit enum.
+                    let implemented_interfaces = if enum_def.backing_type_hint.is_some() {
+                        vec!["\\BackedEnum".to_string()]
+                    } else {
+                        vec!["\\UnitEnum".to_string()]
+                    };
+
                     classes.push(ClassInfo {
                         name: enum_name,
                         methods,
@@ -732,6 +742,7 @@ impl Backend {
                         parent_class,
                         used_traits,
                         mixins,
+                        implemented_interfaces,
                     });
                 }
                 Statement::Namespace(namespace) => {

src/types.rs

@@ -210,4 +210,6 @@ pub struct ClassInfo {
     /// classes via magic methods (`__call`, `__get`, `__set`, etc.).
     /// Resolved to fully-qualified names during post-processing.
     pub mixins: Vec<String>,
+    /// Interfaces implemented by this class or enum (including implicit BackedEnum/UnitEnum for enums).
+    pub implemented_interfaces: Vec<String>,
 }

tests/completion_enums.rs

@@ -4,6 +4,73 @@ use common::{create_psr4_workspace, create_test_backend};
 use tower_lsp::LanguageServer;
 use tower_lsp::lsp_types::*;
 
+/// Test: BackedEnum completion includes `name` and `value` properties.
+#[tokio::test]
+async fn test_backed_enum_completion_includes_name_and_value() {
+    let backend = create_test_backend();
+
+    let uri = Url::parse("file:///backed_enum.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "enum Status: string {\n",
+        "    case Active = 'active';\n",
+        "    public function label(): string {\n",
+        "        $this->\n",
+        "    }\n",
+        "}\n",
+    );
+
+    backend
+        .did_open(DidOpenTextDocumentParams {
+            text_document: TextDocumentItem {
+                uri: uri.clone(),
+                language_id: "php".to_string(),
+                version: 1,
+                text: text.to_string(),
+            },
+        })
+        .await;
+
+    let result = backend
+        .completion(CompletionParams {
+            text_document_position: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri },
+                position: Position {
+                    line: 4,
+                    character: 15,
+                },
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+            context: None,
+        })
+        .await
+        .unwrap();
+
+    assert!(result.is_some(), "Completion should return results");
+    match result.unwrap() {
+        CompletionResponse::Array(items) => {
+            let property_names: Vec<&str> = items
+                .iter()
+                .filter(|i| i.kind == Some(CompletionItemKind::PROPERTY))
+                .map(|i| i.filter_text.as_deref().unwrap())
+                .collect();
+
+            assert!(
+                property_names.contains(&"name"),
+                "BackedEnum completion should include 'name' property, got: {:?}",
+                property_names
+            );
+            assert!(
+                property_names.contains(&"value"),
+                "BackedEnum completion should include 'value' property, got: {:?}",
+                property_names
+            );
+        }
+        _ => panic!("Expected CompletionResponse::Array"),
+    }
+}
+
 // ─── Basic enum case completion via :: ──────────────────────────────────────
 
 /// Test: Completing on `EnumName::` should show enum cases as constants.

tests/parser.rs

@@ -107,6 +107,64 @@ async fn test_parse_php_extracts_properties() {
     );
 }
 
+#[tokio::test]
+async fn test_enum_implemented_interfaces() {
+    let backend = create_test_backend();
+
+    // Backed enum (should implement \BackedEnum)
+    let php_backed = r#"
+        <?php
+        enum Status: int {
+            case Active = 1;
+            case Inactive = 2;
+        }
+    "#;
+
+    let classes = backend.parse_php(php_backed);
+    assert_eq!(classes.len(), 1);
+    let enum_info = &classes[0];
+    assert_eq!(enum_info.name, "Status");
+    assert!(
+        enum_info
+            .implemented_interfaces
+            .contains(&"\\BackedEnum".to_string()),
+        "Backed enum should implement \\BackedEnum"
+    );
+    assert!(
+        !enum_info
+            .implemented_interfaces
+            .contains(&"\\UnitEnum".to_string()),
+        "Backed enum should not implement \\UnitEnum"
+    );
+
+    // Unit enum (should implement \UnitEnum)
+    let php_unit = r#"
+        <?php
+        enum Color {
+            case Red;
+            case Green;
+            case Blue;
+        }
+    "#;
+
+    let classes = backend.parse_php(php_unit);
+    assert_eq!(classes.len(), 1);
+    let enum_info = &classes[0];
+    assert_eq!(enum_info.name, "Color");
+    assert!(
+        enum_info
+            .implemented_interfaces
+            .contains(&"\\UnitEnum".to_string()),
+        "Unit enum should implement \\UnitEnum"
+    );
+    assert!(
+        !enum_info
+            .implemented_interfaces
+            .contains(&"\\BackedEnum".to_string()),
+        "Unit enum should not implement \\BackedEnum"
+    );
+}
+
 #[tokio::test]
 async fn test_parse_php_extracts_static_properties() {
     let backend = create_test_backend();