Add support for promoted properties

Author: AJenbo

src/parser.rs

@@ -388,6 +388,30 @@ impl Backend {
                     let is_static = method.modifiers.iter().any(|m| m.is_static());
                     let visibility = Self::extract_visibility(method.modifiers.iter());
 
+                    // Extract promoted properties from constructor parameters.
+                    // A promoted property is a constructor parameter with a
+                    // visibility modifier (e.g. `public`, `private`, `protected`).
+                    if name == "__construct" {
+                        for param in method.parameter_list.parameters.iter() {
+                            if param.is_promoted_property() {
+                                let raw_name = param.variable.name.to_string();
+                                let prop_name =
+                                    raw_name.strip_prefix('$').unwrap_or(&raw_name).to_string();
+                                let type_hint =
+                                    param.hint.as_ref().map(|h| Self::extract_hint_string(h));
+                                let prop_visibility =
+                                    Self::extract_visibility(param.modifiers.iter());
+
+                                properties.push(PropertyInfo {
+                                    name: prop_name,
+                                    type_hint,
+                                    is_static: false,
+                                    visibility: prop_visibility,
+                                });
+                            }
+                        }
+                    }
+
                     methods.push(MethodInfo {
                         name,
                         parameters,
@@ -401,8 +425,7 @@ impl Backend {
                     properties.append(&mut prop_infos);
                 }
                 ClassLikeMember::Constant(constant) => {
-                    let type_hint =
-                        constant.hint.as_ref().map(|h| Self::extract_hint_string(h));
+                    let type_hint = constant.hint.as_ref().map(|h| Self::extract_hint_string(h));
                     let visibility = Self::extract_visibility(constant.modifiers.iter());
                     for item in constant.items.iter() {
                         constants.push(ConstantInfo {

tests/completion_properties.rs

@@ -285,3 +285,138 @@ async fn test_completion_constant_detail_with_type_hint() {
         _ => panic!("Expected CompletionResponse::Array"),
     }
 }
+
+#[tokio::test]
+async fn test_completion_promoted_properties_appear_in_this() {
+    let backend = create_test_backend();
+
+    let uri = Url::parse("file:///promoted.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "class ShoppingCartService {\n",
+        "    private IShoppingCart $regular;\n",
+        "\n",
+        "    public function __construct(\n",
+        "        private IShoppingCart $promoted,\n",
+        "    ) {}\n",
+        "\n",
+        "    public function doWork(): void {\n",
+        "        $this->\n",
+        "    }\n",
+        "}\n",
+    );
+
+    let open_params = DidOpenTextDocumentParams {
+        text_document: TextDocumentItem {
+            uri: uri.clone(),
+            language_id: "php".to_string(),
+            version: 1,
+            text: text.to_string(),
+        },
+    };
+    backend.did_open(open_params).await;
+
+    // Cursor right after `$this->` on line 9
+    let completion_params = CompletionParams {
+        text_document_position: TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri },
+            position: Position {
+                line: 9,
+                character: 15,
+            },
+        },
+        work_done_progress_params: WorkDoneProgressParams::default(),
+        partial_result_params: PartialResultParams::default(),
+        context: None,
+    };
+
+    let result = backend.completion(completion_params).await.unwrap();
+    assert!(result.is_some(), "Completion should return results");
+
+    match result.unwrap() {
+        CompletionResponse::Array(items) => {
+            let names: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
+            assert!(
+                names.contains(&"regular"),
+                "Should contain regular property 'regular', got: {:?}",
+                names
+            );
+            assert!(
+                names.contains(&"promoted"),
+                "Should contain promoted property 'promoted', got: {:?}",
+                names
+            );
+        }
+        _ => panic!("Expected CompletionResponse::Array"),
+    }
+}
+
+#[tokio::test]
+async fn test_completion_promoted_property_type_resolves_for_chaining() {
+    let backend = create_test_backend();
+
+    let uri = Url::parse("file:///promoted_chain.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "class Logger {\n",
+        "    public function info(string $msg): void {}\n",
+        "    public function error(string $msg): void {}\n",
+        "}\n",
+        "class Service {\n",
+        "    public function __construct(\n",
+        "        private Logger $logger,\n",
+        "    ) {}\n",
+        "\n",
+        "    public function run(): void {\n",
+        "        $this->logger->\n",
+        "    }\n",
+        "}\n",
+    );
+
+    let open_params = DidOpenTextDocumentParams {
+        text_document: TextDocumentItem {
+            uri: uri.clone(),
+            language_id: "php".to_string(),
+            version: 1,
+            text: text.to_string(),
+        },
+    };
+    backend.did_open(open_params).await;
+
+    // Cursor right after `$this->logger->` on line 11
+    let completion_params = CompletionParams {
+        text_document_position: TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri },
+            position: Position {
+                line: 11,
+                character: 24,
+            },
+        },
+        work_done_progress_params: WorkDoneProgressParams::default(),
+        partial_result_params: PartialResultParams::default(),
+        context: None,
+    };
+
+    let result = backend.completion(completion_params).await.unwrap();
+    assert!(
+        result.is_some(),
+        "Completion should resolve promoted property type for chaining"
+    );
+
+    match result.unwrap() {
+        CompletionResponse::Array(items) => {
+            let names: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
+            assert!(
+                names.iter().any(|n| n.starts_with("info(")),
+                "Should contain Logger method 'info', got: {:?}",
+                names
+            );
+            assert!(
+                names.iter().any(|n| n.starts_with("error(")),
+                "Should contain Logger method 'error', got: {:?}",
+                names
+            );
+        }
+        _ => panic!("Expected CompletionResponse::Array"),
+    }
+}

tests/parser.rs

@@ -613,10 +613,173 @@ interface Factory {
     assert_eq!(classes[0].name, "Factory");
     assert_eq!(classes[0].methods.len(), 2);
 
-    let create = classes[0].methods.iter().find(|m| m.name == "create").unwrap();
+    let create = classes[0]
+        .methods
+        .iter()
+        .find(|m| m.name == "create")
+        .unwrap();
     assert!(create.is_static);
     assert_eq!(create.return_type.as_deref(), Some("static"));
 
-    let build = classes[0].methods.iter().find(|m| m.name == "build").unwrap();
+    let build = classes[0]
+        .methods
+        .iter()
+        .find(|m| m.name == "build")
+        .unwrap();
     assert!(!build.is_static);
 }
+
+// ─── Promoted Property Tests ────────────────────────────────────────────────
+
+#[tokio::test]
+async fn test_parse_php_promoted_properties_basic() {
+    let backend = create_test_backend();
+    let php = r#"<?php
+class Service {
+    public function __construct(
+        private IShoppingCart $cart,
+        protected Logger $logger,
+    ) {}
+}
+"#;
+
+    let classes = backend.parse_php(php);
+    assert_eq!(classes.len(), 1);
+
+    let cls = &classes[0];
+    assert_eq!(
+        cls.properties.len(),
+        2,
+        "Should extract 2 promoted properties"
+    );
+
+    let cart = cls.properties.iter().find(|p| p.name == "cart").unwrap();
+    assert_eq!(cart.type_hint.as_deref(), Some("IShoppingCart"));
+    assert_eq!(cart.visibility, Visibility::Private);
+    assert!(!cart.is_static);
+
+    let logger = cls.properties.iter().find(|p| p.name == "logger").unwrap();
+    assert_eq!(logger.type_hint.as_deref(), Some("Logger"));
+    assert_eq!(logger.visibility, Visibility::Protected);
+    assert!(!logger.is_static);
+}
+
+#[tokio::test]
+async fn test_parse_php_promoted_properties_mixed_with_regular() {
+    let backend = create_test_backend();
+    let php = r#"<?php
+class ShoppingCartService {
+    private IShoppingCart $regular;
+
+    public function __construct(
+        private IShoppingCart $promoted,
+    ) {}
+}
+"#;
+
+    let classes = backend.parse_php(php);
+    assert_eq!(classes.len(), 1);
+
+    let cls = &classes[0];
+    assert_eq!(
+        cls.properties.len(),
+        2,
+        "Should have regular + promoted property"
+    );
+
+    let regular = cls.properties.iter().find(|p| p.name == "regular").unwrap();
+    assert_eq!(regular.type_hint.as_deref(), Some("IShoppingCart"));
+    assert_eq!(regular.visibility, Visibility::Private);
+
+    let promoted = cls
+        .properties
+        .iter()
+        .find(|p| p.name == "promoted")
+        .unwrap();
+    assert_eq!(promoted.type_hint.as_deref(), Some("IShoppingCart"));
+    assert_eq!(promoted.visibility, Visibility::Private);
+}
+
+#[tokio::test]
+async fn test_parse_php_promoted_property_public_visibility() {
+    let backend = create_test_backend();
+    let php = r#"<?php
+class Config {
+    public function __construct(
+        public string $name,
+        public int $value,
+    ) {}
+}
+"#;
+
+    let classes = backend.parse_php(php);
+    assert_eq!(classes.len(), 1);
+
+    let cls = &classes[0];
+    assert_eq!(cls.properties.len(), 2);
+
+    for prop in &cls.properties {
+        assert_eq!(prop.visibility, Visibility::Public);
+    }
+
+    let name = cls.properties.iter().find(|p| p.name == "name").unwrap();
+    assert_eq!(name.type_hint.as_deref(), Some("string"));
+
+    let value = cls.properties.iter().find(|p| p.name == "value").unwrap();
+    assert_eq!(value.type_hint.as_deref(), Some("int"));
+}
+
+#[tokio::test]
+async fn test_parse_php_non_promoted_constructor_params_ignored() {
+    let backend = create_test_backend();
+    let php = r#"<?php
+class Service {
+    public function __construct(
+        private string $promoted,
+        string $regularParam,
+    ) {}
+}
+"#;
+
+    let classes = backend.parse_php(php);
+    assert_eq!(classes.len(), 1);
+
+    let cls = &classes[0];
+    assert_eq!(
+        cls.properties.len(),
+        1,
+        "Only promoted params (with visibility) should become properties"
+    );
+    assert_eq!(cls.properties[0].name, "promoted");
+}
+
+#[tokio::test]
+async fn test_parse_php_promoted_property_readonly() {
+    let backend = create_test_backend();
+    let php = r#"<?php
+class User {
+    public function __construct(
+        public readonly string $name,
+        private readonly int $id,
+    ) {}
+}
+"#;
+
+    let classes = backend.parse_php(php);
+    assert_eq!(classes.len(), 1);
+
+    let cls = &classes[0];
+    assert_eq!(
+        cls.properties.len(),
+        2,
+        "readonly promoted params are still promoted"
+    );
+
+    let name = cls.properties.iter().find(|p| p.name == "name").unwrap();
+    assert_eq!(name.visibility, Visibility::Public);
+    assert_eq!(name.type_hint.as_deref(), Some("string"));
+
+    let id = cls.properties.iter().find(|p| p.name == "id").unwrap();
+    assert_eq!(id.visibility, Visibility::Private);
+    assert_eq!(id.type_hint.as_deref(), Some("int"));
+}