Fix cross resolve for facades, consistency for model-properties, a

couple of compleation issue

Author: AJenbo

src/class_lookup.rs

@@ -459,9 +459,11 @@ pub(crate) fn is_subtype_of_typed(
         if let Some(model_name) = args[0].base_name()
             && let Some(cls) = class_loader(model_name)
         {
-            return crate::virtual_members::laravel::where_property::collect_column_names(&cls)
-                .iter()
-                .any(|col| col == prop_name);
+            let resolved = crate::inheritance::resolve_class_with_inheritance(&cls, class_loader);
+            return resolved.properties.iter().any(|p| &*p.name == prop_name)
+                || crate::virtual_members::laravel::where_property::collect_column_names(&cls)
+                    .iter()
+                    .any(|col| col == prop_name);
         }
         return true;
     }

src/completion/context/override_completion.rs

@@ -722,24 +722,50 @@ fn preceded_by_use_keyword_bytes(bytes: &[u8], keyword_start: usize) -> bool {
     check_keyword_ending_at_bytes(bytes, before, b"use")
 }
 
-fn has_const_keyword_before_name(bytes: &[u8], pos: usize) -> bool {
+pub(super) fn has_const_keyword_before_name(bytes: &[u8], pos: usize) -> bool {
     let mut line_start = pos;
     while line_start > 0 && bytes[line_start - 1] != b'\n' {
         line_start -= 1;
     }
-    bytes[line_start..pos]
+    // Find the standalone `const` keyword governing this line (skipping
+    // `use const` imports).
+    let Some(const_end) = bytes[line_start..pos]
         .windows(b"const".len())
         .enumerate()
-        .any(|(idx, window)| {
+        .find_map(|(idx, window)| {
             if window != b"const" {
-                return false;
+                return None;
             }
             let start = line_start + idx;
             let end = start + b"const".len();
-            (start == 0 || !is_ident_byte(bytes[start - 1]))
-                && (end >= bytes.len() || !is_ident_byte(bytes[end]))
-                && !preceded_by_use_keyword_bytes(bytes, start)
+            let is_word = (start == 0 || !is_ident_byte(bytes[start - 1]))
+                && (end >= bytes.len() || !is_ident_byte(bytes[end]));
+            (is_word && !preceded_by_use_keyword_bytes(bytes, start)).then_some(end)
         })
+    else {
+        return false;
+    };
+    // A declarator *name* follows `const` or a top-level `,`; the cursor is
+    // in the initializer once a top-level `=` is seen (until the next
+    // comma). `const MAX = PHP_INT_M|` is a value position, not a name.
+    !in_const_initializer(bytes, const_end, pos)
+}
+
+/// Whether the byte range `from..pos` (starting just after a `const`
+/// keyword) ends inside a declarator initializer rather than a name slot.
+fn in_const_initializer(bytes: &[u8], from: usize, pos: usize) -> bool {
+    let mut depth = 0i32;
+    let mut in_value = false;
+    for &b in &bytes[from..pos] {
+        match b {
+            b'(' | b'[' | b'{' => depth += 1,
+            b')' | b']' | b'}' => depth = depth.saturating_sub(1),
+            b',' if depth == 0 => in_value = false,
+            b'=' if depth == 0 => in_value = true,
+            _ => {}
+        }
+    }
+    in_value
 }
 
 /// Property name after `$` on a property declaration line (not a parameter).
@@ -773,11 +799,14 @@ fn is_function_or_const_name_position_at_offset(bytes: &[u8], cursor: usize) ->
         return false;
     }
 
-    if check_keyword_ending_at_bytes(bytes, i, b"fn")
-        || check_keyword_ending_at_bytes(bytes, i, b"case")
-    {
+    if check_keyword_ending_at_bytes(bytes, i, b"fn") {
         return true;
     }
+    // `case` names an enum case (a member) but also labels a `switch`
+    // branch, where a class/const/enum name completion is wanted.
+    if check_keyword_ending_at_bytes(bytes, i, b"case") {
+        return case_is_enum_declaration(bytes, i);
+    }
     if check_keyword_ending_at_bytes(bytes, i, b"function") {
         return !preceded_by_use_keyword_bytes(bytes, i - "function".len());
     }
@@ -787,6 +816,40 @@ fn is_function_or_const_name_position_at_offset(bytes: &[u8], cursor: usize) ->
     has_const_keyword_before_name(bytes, i)
 }
 
+/// Whether the `case` keyword ending at `keyword_end` declares an enum case
+/// (directly inside an `enum` body) rather than a `switch` branch label.
+/// Scans back to the nearest enclosing unmatched `{` and checks whether it
+/// opens an enum.
+pub(super) fn case_is_enum_declaration(bytes: &[u8], keyword_end: usize) -> bool {
+    let mut depth = 0i32;
+    let mut k = keyword_end - "case".len();
+    while k > 0 {
+        k -= 1;
+        match bytes[k] {
+            b'}' => depth += 1,
+            b'{' => {
+                if depth == 0 {
+                    return brace_opens_enum(bytes, k);
+                }
+                depth -= 1;
+            }
+            _ => {}
+        }
+    }
+    false
+}
+
+/// Whether the block opened by the `{` at `brace_pos` is an `enum` body,
+/// determined from the block header (the text back to the previous
+/// statement boundary).
+fn brace_opens_enum(bytes: &[u8], brace_pos: usize) -> bool {
+    let mut start = brace_pos;
+    while start > 0 && !matches!(bytes[start - 1], b';' | b'{' | b'}') {
+        start -= 1;
+    }
+    contains_ascii_word(&bytes[start..brace_pos], b"enum")
+}
+
 fn is_property_declaration_name_position_at_offset(bytes: &[u8], cursor: usize) -> bool {
     // Skip partial name.
     let mut i = cursor;

src/completion/context/type_hint_completion.rs

@@ -243,11 +243,14 @@ pub(crate) fn is_function_or_const_name_position(content: &str, position: Positi
         return false;
     }
 
-    if check_keyword_ending_at_bytes(bytes, i, b"fn")
-        || check_keyword_ending_at_bytes(bytes, i, b"case")
-    {
+    if check_keyword_ending_at_bytes(bytes, i, b"fn") {
         return true;
     }
+    // `case` names an enum case (a member) but also labels a `switch`
+    // branch, where a class/const/enum name completion is wanted.
+    if check_keyword_ending_at_bytes(bytes, i, b"case") {
+        return super::override_completion::case_is_enum_declaration(bytes, i);
+    }
     // `function` / `const` declare member names, but not after `use`
     // (`use function foo`, `use const BAR` still need symbol completion).
     if check_keyword_ending_at_bytes(bytes, i, b"function") {
@@ -342,23 +345,7 @@ fn preceded_by_use_keyword_bytes(bytes: &[u8], keyword_start: usize) -> bool {
 }
 
 fn has_const_keyword_before_name(bytes: &[u8], pos: usize) -> bool {
-    let mut line_start = pos;
-    while line_start > 0 && bytes[line_start - 1] != b'\n' {
-        line_start -= 1;
-    }
-    bytes[line_start..pos]
-        .windows(b"const".len())
-        .enumerate()
-        .any(|(idx, window)| {
-            if window != b"const" {
-                return false;
-            }
-            let start = line_start + idx;
-            let end = start + b"const".len();
-            (start == 0 || !is_ident_byte(bytes[start - 1]))
-                && (end >= bytes.len() || !is_ident_byte(bytes[end]))
-                && !preceded_by_use_keyword_bytes(bytes, start)
-        })
+    super::override_completion::has_const_keyword_before_name(bytes, pos)
 }
 
 // ─── Private helpers ────────────────────────────────────────────────────────

src/completion/context/type_hint_completion_tests.rs

@@ -341,6 +341,51 @@ fn case_name_position_in_enum() {
     ));
 }
 
+#[test]
+fn switch_case_label_is_not_name_position() {
+    use super::is_function_or_const_name_position;
+    // A `case` inside a `switch` wants class/const/enum completion, unlike
+    // an enum-case declaration.
+    let src = "<?php\nfunction f($x) {\n    switch ($x) {\n        case Sta\n    }\n}";
+    assert!(!is_function_or_const_name_position(
+        src,
+        Position {
+            line: 3,
+            character: 16
+        }
+    ));
+}
+
+#[test]
+fn const_initializer_is_not_name_position() {
+    use super::is_function_or_const_name_position;
+    // The right-hand side of a constant initializer is a value expression,
+    // so class/const completion (e.g. `PHP_INT_MAX`) must not be suppressed.
+    let src = "<?php\nclass Foo {\n    const MAX = PHP_INT_M\n}";
+    assert!(!is_function_or_const_name_position(
+        src,
+        Position {
+            line: 2,
+            character: 25
+        }
+    ));
+}
+
+#[test]
+fn second_const_declarator_is_name_position() {
+    use super::is_function_or_const_name_position;
+    // A subsequent declarator name in a `const A = 1, B` list is still a
+    // name position even though a `const` value precedes it on the line.
+    let src = "<?php\nclass Foo {\n    const A = 1, B\n}";
+    assert!(is_function_or_const_name_position(
+        src,
+        Position {
+            line: 2,
+            character: 18
+        }
+    ));
+}
+
 #[test]
 fn property_name_after_dollar_is_not_function_name_position() {
     use super::is_function_or_const_name_position;

src/type_engine/variable/rhs_resolution/calls.rs

@@ -1998,10 +1998,18 @@ fn facade_accessor_concrete_owner(
     let merged =
         crate::virtual_members::resolve_class_fully_maybe_cached(facade, class_loader, cache);
 
-    if let Some(concrete) = crate::virtual_members::laravel::parse_facade_accessor(content)
-        .and_then(facade_accessor_to_class_name)
-        .and_then(|name| class_loader(&name))
-        .filter(|class| class_has_method(class, method_name, class_loader, cache))
+    // When the facade is declared in the current file, read its
+    // `getFacadeAccessor()` return directly from source: the body walker
+    // that `try_infer_body_return_type` relies on is not always active in
+    // the hover/completion paths, and it honours the declared `: string`
+    // return type rather than the `::class` value we need. Scope the parse
+    // to the facade's own class so a file declaring several facades does
+    // not cross-resolve.
+    if let Some(concrete) =
+        crate::virtual_members::laravel::parse_facade_accessor_for_class(content, &facade.name)
+            .and_then(facade_accessor_to_class_name)
+            .and_then(|name| class_loader(&name))
+            .filter(|class| class_has_method(class, method_name, class_loader, cache))
     {
         return Some(Arc::unwrap_or_clone(concrete));
     }

src/virtual_members/laravel/aliases.rs

@@ -340,6 +340,48 @@ pub(crate) fn parse_facade_accessor(content: &str) -> Option<FacadeAccessor> {
     })
 }
 
+/// Like [`parse_facade_accessor`] but scoped to the class named
+/// `class_name` within `content`.
+///
+/// A single file may declare several facades (or a facade alongside
+/// unrelated classes), so resolving the accessor for a specific facade
+/// must not pick up the first `getFacadeAccessor()` in the file. Returns
+/// `None` when no class of that name is present (e.g. the facade lives in
+/// another file).
+pub(crate) fn parse_facade_accessor_for_class(
+    content: &str,
+    class_name: &str,
+) -> Option<FacadeAccessor> {
+    with_parsed(content, |program, resolved| {
+        let return_value =
+            find_facade_accessor_return_in_class(Node::Program(program), class_name)?;
+        if let Some((text, _, _)) = super::helpers::extract_string_literal(return_value, content) {
+            return Some(FacadeAccessor::Alias(text.to_string()));
+        }
+        class_const_fqn(return_value, resolved).map(FacadeAccessor::Class)
+    })
+}
+
+/// Find the `getFacadeAccessor()` return value inside the class named
+/// `class_name` reachable from `node`.
+fn find_facade_accessor_return_in_class<'ast, 'arena>(
+    node: Node<'ast, 'arena>,
+    class_name: &str,
+) -> Option<&'ast Expression<'arena>> {
+    if let Node::Class(class) = node
+        && bytes_to_str(class.name.value).eq_ignore_ascii_case(class_name)
+    {
+        return find_facade_accessor_return(node);
+    }
+    let mut found = None;
+    node.visit_children(|child| {
+        if found.is_none() {
+            found = find_facade_accessor_return_in_class(child, class_name);
+        }
+    });
+    found
+}
+
 /// Find the first return-statement value inside a `getFacadeAccessor()` method
 /// reachable from `node`.
 fn find_facade_accessor_return<'ast, 'arena>(

src/virtual_members/laravel/mod.rs

@@ -101,7 +101,7 @@ mod trans_keys;
 mod view_names;
 pub(crate) mod where_property;
 
-pub(crate) use aliases::{FacadeAccessor, LaravelAliases, parse_facade_accessor};
+pub(crate) use aliases::{FacadeAccessor, LaravelAliases, parse_facade_accessor_for_class};
 pub(crate) use auth::{GUARD_FQN, REQUEST_FQN, patch_auth_user_class, resolve_auth_user_type};
 pub(crate) use config_keys::find_config_references;
 pub(crate) use config_keys::{

tests/integration/hover.rs

@@ -7140,6 +7140,80 @@ namespace {
     );
 }
 
+#[test]
+fn hover_facade_concrete_target_scoped_to_own_class() {
+    // Two facades declared in the same file: resolving a call on `Second`
+    // must read `Second::getFacadeAccessor()`, not the first accessor found
+    // in the file (which belongs to `First`).
+    let backend = create_test_backend();
+    let uri = "file:///test.php";
+    let content = r#"<?php
+
+namespace Illuminate\Support\Facades {
+    abstract class Facade
+    {
+        public static function __callStatic(string $method, array $args): mixed
+        {
+            return null;
+        }
+    }
+}
+
+namespace {
+    use Illuminate\Support\Facades\Facade;
+
+    final class WrongType {}
+    final class RightType {}
+
+    final class FirstTarget
+    {
+        public function handle(): WrongType
+        {
+            return new WrongType();
+        }
+    }
+
+    final class SecondTarget
+    {
+        public function handle(): RightType
+        {
+            return new RightType();
+        }
+    }
+
+    final class First extends Facade
+    {
+        protected static function getFacadeAccessor(): string
+        {
+            return FirstTarget::class;
+        }
+    }
+
+    final class Second extends Facade
+    {
+        protected static function getFacadeAccessor(): string
+        {
+            return SecondTarget::class;
+        }
+    }
+
+    $result = Second::handle();
+    $result;
+}
+"#;
+
+    let hover = hover_at(&backend, uri, content, 51, 6).expect("hover on $result should resolve");
+    let text = hover_text(&hover);
+    assert!(
+        text.contains("RightType"),
+        "facade call should resolve through its own accessor, got: {text}"
+    );
+    assert!(
+        !text.contains("WrongType"),
+        "facade call must not cross-resolve to another facade's accessor, got: {text}"
+    );
+}
+
 #[test]
 fn hover_foreach_over_variable_assigned_via_elvis_with_static_call() {
     let backend = create_test_backend();