fix(completion,rename): preserve PHPDoc virtual property details and reject rename for virtual members

Implement property-shaped completion details for PHPDoc virtual properties and
enforce stricter validation for rename operations on virtual members.

Changes:
- Extract symbol_completion_detail to handle property vs callable formatting
- Add property_symbol_completion_detail to format PHPDoc properties as
  `@property-read type` instead of callable signature
- Filter member completions by PHPDoc property access (read/write)
- Refactor rename validation to use should_reject_phpdoc_virtual_member_rename
  helper that checks both resolved symbol kind and owner match
- Add packaged extension stubs path discovery for `/extension/bin/<platform>/php-lsp`
  layout used by VS Code bundled binaries
- Add test coverage for packaged extension stubs path resolution

Fixes regression where indexed PHPDoc virtual properties were displayed with
callable details and could be renamed despite being virtual members.

Author: Anton Panov

TASKS.md

@@ -5528,3 +5528,18 @@ change.
   - Files:
     /home/apanov/ForTesting/monica/app/Domains/Contact/DavClient/Services/Utils/AddressBookGetter.php
     /home/apanov/ForTesting/monica/app/Domains/Contact/DavClient/Services/Utils/Dav/DavClient.php
+
+- [x] **H-DIAGNOSTICS-PACKAGED-STUBS-PATH-2026-06-09** Resolve bundled stubs from packaged VS Code binary layout *(done 2026-06-09)*
+  - False positives include `Unknown function: App\\Actions\\is_null` when running the packaged extension binary against Monica; the same source checkout binary reports no diagnostics.
+  - Root cause: CLI/server candidate stubs path discovery for `/extension/bin/linux-x64/php-lsp` misses `/extension/stubs` unless VS Code passes `bundledStubsPath`.
+  - Implemented: packaged binary stubs discovery now includes the VS Code extension layout `/extension/bin/<platform>/php-lsp` -> `/extension/stubs`, and the installed extension binary was rebuilt/replaced.
+  - Validation: `cargo fmt --all --check`; `git diff --check`; `cargo clippy --all-targets -- -D warnings`; `cargo test --all`; installed extension binary analyze for `AttemptToAuthenticateSocialite.php` reports `No diagnostics found`; Verifier subagent `GO`.
+  - Files:
+    /home/apanov/ForTesting/monica/app/Actions/AttemptToAuthenticateSocialite.php
+
+- [x] **H-COMPLETION-PHPDOC-PROPERTY-DETAIL-REGRESSION-2026-06-09** Keep PHPDoc virtual property completion details property-shaped *(done 2026-06-09)*
+  - Regression: indexed PHPDoc virtual properties can be emitted through the generic symbol completion path and displayed as callable details like `(): int` instead of `@property-read int`.
+  - Implemented: generic symbol completion now formats properties as property types, preserves PHPDoc virtual property access tags, applies PHPDoc read/write access filtering to indexed virtual properties, and rejects rename/prepareRename for resolved PHPDoc virtual members.
+  - Validation: `cargo test -p php-lsp-server --test e2e_completion test_phpdoc_fixture_hover_completion_definition_and_diagnostics`; `cargo test -p php-lsp-completion test_member_completion_includes_phpdoc_virtual_members`; `cargo test --all`; Verifier subagent `GO`.
+  - Files:
+    /home/apanov/Projects/php-lsp/server/crates/php-lsp-server/tests/e2e_completion.rs

server/crates/php-lsp-completion/src/provider.rs

@@ -228,6 +228,11 @@ fn provide_member_completions(
             if !member_is_visible(&member, object_expr == "$this", current_class_fqn) {
                 continue;
             }
+            if let Some(property_access) = phpdoc_property_access_for_symbol(&member) {
+                if !phpdoc_property_matches_access(property_access, access_mode) {
+                    continue;
+                }
+            }
 
             items.push(symbol_to_completion_item(
                 &member,
@@ -689,27 +694,7 @@ fn symbol_to_completion_item(
 ) -> CompletionItem {
     let kind = symbol_kind_to_completion_kind(sym.kind);
 
-    let detail = sym.signature.as_ref().map(|sig| {
-        let params_str: Vec<String> = sig
-            .params
-            .iter()
-            .map(|p| {
-                let mut s = String::new();
-                if let Some(ref t) = p.type_info {
-                    s.push_str(&t.to_string());
-                    s.push(' ');
-                }
-                s.push('$');
-                s.push_str(&p.name);
-                s
-            })
-            .collect();
-        let mut detail = format!("({})", params_str.join(", "));
-        if let Some(ref ret) = sig.return_type {
-            detail.push_str(&format!(": {}", ret));
-        }
-        detail
-    });
+    let detail = symbol_completion_detail(sym);
 
     let label =
         if sym.kind == PhpSymbolKind::Property && is_static_access && !sym.name.starts_with('$') {
@@ -751,6 +736,70 @@ fn symbol_to_completion_item(
     item
 }
 
+fn symbol_completion_detail(sym: &SymbolInfo) -> Option<String> {
+    if sym.kind == PhpSymbolKind::Property {
+        return property_symbol_completion_detail(sym);
+    }
+
+    sym.signature.as_ref().map(|sig| {
+        let params_str: Vec<String> = sig
+            .params
+            .iter()
+            .map(|p| {
+                let mut s = String::new();
+                if let Some(ref t) = p.type_info {
+                    s.push_str(&t.to_string());
+                    s.push(' ');
+                }
+                s.push('$');
+                s.push_str(&p.name);
+                s
+            })
+            .collect();
+        let mut detail = format!("({})", params_str.join(", "));
+        if let Some(ref ret) = sig.return_type {
+            detail.push_str(&format!(": {}", ret));
+        }
+        detail
+    })
+}
+
+fn property_symbol_completion_detail(sym: &SymbolInfo) -> Option<String> {
+    let property_name = sym.name.trim_start_matches('$');
+    if let Some(ref doc_comment) = sym.doc_comment {
+        let phpdoc = parse_phpdoc(doc_comment);
+        if let Some(property) = phpdoc
+            .properties
+            .iter()
+            .find(|property| property.name == property_name)
+        {
+            let access = phpdoc_property_tag(property.access);
+            return Some(match &property.type_info {
+                Some(type_info) => format!("{} {}", access, type_info),
+                None => access.to_string(),
+            });
+        }
+    }
+
+    sym.signature
+        .as_ref()
+        .and_then(|sig| sig.return_type.as_ref())
+        .map(|return_type| return_type.to_string())
+}
+
+fn phpdoc_property_access_for_symbol(sym: &SymbolInfo) -> Option<PhpDocPropertyAccess> {
+    if sym.kind != PhpSymbolKind::Property {
+        return None;
+    }
+    let property_name = sym.name.trim_start_matches('$');
+    let phpdoc = parse_phpdoc(sym.doc_comment.as_ref()?);
+    phpdoc
+        .properties
+        .iter()
+        .find(|property| property.name == property_name)
+        .map(|property| property.access)
+}
+
 fn completion_prefix_rank(label: &str, member_prefix: Option<&str>) -> &'static str {
     let Some(prefix) = member_prefix
         .map(str::trim)

server/crates/php-lsp-server/src/indexing/stubs.rs

@@ -58,6 +58,7 @@ fn candidate_stubs_paths_for_exe(
     if let Some(dir) = exe.and_then(Path::parent) {
         push_candidate_path(&mut candidate_paths, dir.join("data/stubs"));
         push_candidate_path(&mut candidate_paths, dir.join("../stubs"));
+        push_candidate_path(&mut candidate_paths, dir.join("../../stubs"));
         push_candidate_path(&mut candidate_paths, dir.join("../../data/stubs"));
     }
 
@@ -318,6 +319,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_candidate_stubs_paths_include_packaged_extension_stubs_from_platform_binary() {
+        let root = Path::new("/tmp/project");
+        let exe = Path::new(
+            "/home/user/.vscode/extensions/hightemp.ht-php-lsp-0.6.0/bin/linux-x64/php-lsp",
+        );
+        let paths = candidate_stubs_paths_for_exe(root, None, Some(exe));
+
+        assert!(
+            paths.iter().any(|path| {
+                path == Path::new("/home/user/.vscode/extensions/hightemp.ht-php-lsp-0.6.0/stubs")
+            }),
+            "expected packaged extension stubs path in {paths:?}"
+        );
+    }
+
     #[test]
     fn test_load_configured_stubs_exposes_standard_builtin_functions_from_source_checkout() {
         let stubs_path = source_stubs_path();

server/crates/php-lsp-server/src/lsp/rename.rs

@@ -92,9 +92,10 @@ impl PhpLspBackend {
         }
 
         let resolved_for_rename = self.resolve_fqn_with_fallback(&sym.fqn, sym.ref_kind);
-        if resolved_for_rename.is_none()
-            && phpdoc_virtual_member_for_symbol(&self.index, &sym).is_some()
-        {
+        let phpdoc_virtual_member = phpdoc_virtual_member_for_symbol(&self.index, &sym);
+        if phpdoc_virtual_member.as_ref().is_some_and(|member| {
+            should_reject_phpdoc_virtual_member_rename(&resolved_for_rename, member)
+        }) {
             return Err(tower_lsp::jsonrpc::Error::invalid_params(
                 "Cannot rename PHPDoc virtual members",
             ));
@@ -269,9 +270,10 @@ impl PhpLspBackend {
 
                 // Don't rename built-in or PHPDoc virtual symbols
                 let resolved = self.resolve_fqn_with_fallback(&sym.fqn, sym.ref_kind);
-                if resolved.is_none()
-                    && phpdoc_virtual_member_for_symbol(&self.index, &sym).is_some()
-                {
+                let phpdoc_virtual_member = phpdoc_virtual_member_for_symbol(&self.index, &sym);
+                if phpdoc_virtual_member.as_ref().is_some_and(|member| {
+                    should_reject_phpdoc_virtual_member_rename(&resolved, member)
+                }) {
                     return Ok(None);
                 }
                 if resolved.is_none()
@@ -560,6 +562,35 @@ fn is_member_ref_kind(kind: RefKind) -> bool {
     )
 }
 
+fn should_reject_phpdoc_virtual_member_rename(
+    resolved: &Option<Arc<php_lsp_types::SymbolInfo>>,
+    member: &PhpDocVirtualMember,
+) -> bool {
+    match resolved.as_deref() {
+        Some(symbol) => resolved_symbol_is_phpdoc_virtual_member(symbol, member),
+        None => true,
+    }
+}
+
+fn resolved_symbol_is_phpdoc_virtual_member(
+    symbol: &php_lsp_types::SymbolInfo,
+    member: &PhpDocVirtualMember,
+) -> bool {
+    let expected_kind = match member.kind {
+        PhpDocVirtualMemberKind::Property => php_lsp_types::PhpSymbolKind::Property,
+        PhpDocVirtualMemberKind::Method => php_lsp_types::PhpSymbolKind::Method,
+    };
+    if symbol.kind != expected_kind
+        || symbol.parent_fqn.as_deref() != Some(member.owner.fqn.as_str())
+    {
+        return false;
+    }
+
+    let symbol_name = symbol.name.trim_start_matches('$');
+    symbol_name == member.name.trim_start_matches('$')
+        && symbol.doc_comment.as_deref() == member.owner.doc_comment.as_deref()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;