Fix diagnostices on array acccess of unknown type

Author: AJenbo

src/completion/resolver.rs

@@ -818,12 +818,11 @@ pub(crate) fn resolve_target_classes_expr(
             ) {
                 return resolved.into_iter().map(Arc::new).collect();
             }
-            // Fall through to variable resolution if the base is a bare variable
-            if let SubjectExpr::Variable(_) = **base {
-                resolve_variable_fallback(&base_var, access_kind, ctx)
-            } else {
-                vec![]
-            }
+            // Segment walk failed — the base type does not have
+            // array-shape, generic, or iterable annotations that
+            // cover bracket access.  Return empty: `$var['key']` is
+            // never the same type as `$var`.
+            vec![]
         }
 
         // ── Bare variable ───────────────────────────────────────

src/completion/source/helpers.rs

@@ -428,12 +428,45 @@ fn walk_array_segments_and_resolve(
     let mut current = PhpType::parse(&current_str);
 
     for seg in segments {
-        current = match seg {
+        // Try pure-type extraction first (array shapes, generics).
+        let extracted = match seg {
             BracketSegment::StringKey(key) => current
                 .shape_value_type(key)
                 .or_else(|| current.extract_value_type(true))
-                .cloned()?,
-            BracketSegment::ElementAccess => current.extract_value_type(true)?.clone(),
+                .cloned(),
+            BracketSegment::ElementAccess => current.extract_value_type(true).cloned(),
+        };
+
+        current = if let Some(t) = extracted {
+            t
+        } else {
+            // Fallback: when the current type is a plain class name (e.g.
+            // `Application`, `OpeningHours`), resolve the class and check
+            // its iterable generics (`@extends`, `@implements`) for the
+            // element type.  This handles bracket access on classes that
+            // implement `ArrayAccess` with generic type parameters.
+            let type_str = current.to_string();
+            let class_element = crate::completion::type_resolution::type_hint_to_classes(
+                &type_str,
+                current_class_name,
+                all_classes,
+                class_loader,
+            )
+            .into_iter()
+            .find_map(|cls| {
+                let merged =
+                    crate::virtual_members::resolve_class_fully(&cls, class_loader);
+                crate::completion::variable::foreach_resolution::extract_iterable_element_type_from_class(
+                    &merged,
+                    class_loader,
+                )
+            });
+
+            if let Some(element) = class_element {
+                PhpType::parse(&element)
+            } else {
+                return None;
+            }
         };
 
         // After each segment, the resulting type might itself be an

src/completion/variable/raw_type_inference.rs

@@ -228,9 +228,14 @@ pub(in crate::completion) fn resolve_array_func_raw_type(
 /// (e.g. `"User"`) for the output.
 ///
 /// Used by `resolve_rhs_expression` so that `$item = array_pop($users)`
-/// resolves `$item` to `User`.  This handles both element-extracting
-/// functions (array_pop, current, etc.) and `array_map` (via callback
-/// return type).
+/// resolves `$item` to `User`.  This only covers true element-extracting
+/// functions (array_pop, current, etc.) that return a single element.
+///
+/// Array-producing functions like `array_map` and `iterator_to_array`
+/// are handled exclusively by [`resolve_array_func_raw_type`] which
+/// preserves the container type (e.g. `list<User>`).  Returning the
+/// element type here would lose the array wrapper and break downstream
+/// consumers that need to walk bracket segments (e.g. `$result[0]->`).
 pub(in crate::completion) fn resolve_array_func_element_type(
     func_name: &str,
     args: &ArgumentList<'_>,
@@ -248,20 +253,6 @@ pub(in crate::completion) fn resolve_array_func_element_type(
             .map(|t| t.to_string());
     }
 
-    // array_map: callback return type is the element type.
-    if func_name.eq_ignore_ascii_case("array_map") {
-        return extract_array_map_element_type(args, ctx);
-    }
-
-    // iterator_to_array: the element type is the iterator's value type.
-    if func_name.eq_ignore_ascii_case("iterator_to_array") {
-        let iter_expr = super::resolution::first_arg_expr(args)?;
-        let raw = super::resolution::resolve_arg_raw_type(iter_expr, ctx)?;
-        return crate::php_type::PhpType::parse(&raw)
-            .extract_value_type(true)
-            .map(|t| t.to_string());
-    }
-
     None
 }
 

src/diagnostics/unknown_members.rs

@@ -170,12 +170,10 @@ enum SubjectOutcome {
     Scalar(String),
     /// Subject resolved to a class name that couldn't be loaded.
     UnresolvableClass(String),
-    /// Subject is a chain or call expression whose type couldn't be
-    /// resolved.
-    UnresolvableChain,
-    /// Subject is a bare variable with no type information at all.
-    /// No diagnostic should be emitted (the opt-in
-    /// `unresolved-member-access` diagnostic covers this case).
+    /// Subject type could not be resolved — no class information
+    /// available.  The opt-in `unresolved-member-access` diagnostic
+    /// covers this case regardless of whether the subject is a bare
+    /// variable, a chain, an array access, or a function call.
     Untyped,
 }
 
@@ -263,15 +261,6 @@ fn resolve_subject_outcome(
         return SubjectOutcome::UnresolvableClass(unresolved);
     }
 
-    // Check if the subject is a chain or call expression.
-    let is_chain = matches!(
-        expr,
-        SubjectExpr::PropertyChain { .. } | SubjectExpr::CallExpr { .. }
-    );
-    if is_chain {
-        return SubjectOutcome::UnresolvableChain;
-    }
-
     SubjectOutcome::Untyped
 }
 
@@ -548,65 +537,39 @@ impl Backend {
                     ));
                 }
 
-                SubjectOutcome::UnresolvableChain => {
-                    let range = match offset_range_to_lsp_range(
-                        content,
-                        span.start as usize,
-                        span.end as usize,
-                    ) {
-                        Some(r) => r,
-                        None => continue,
-                    };
-                    let kind_label = if is_method_call { "method" } else { "property" };
-                    let message = format!(
-                        "Cannot verify {} '{}' — subject type could not be resolved",
-                        kind_label, member_name,
-                    );
-                    out.push(make_diagnostic(
-                        range,
-                        DiagnosticSeverity::WARNING,
-                        UNKNOWN_MEMBER_CODE,
-                        message,
-                    ));
-                    broken_chain_prefixes.push(broken_chain_prefix(
-                        subject_text,
-                        member_name,
-                        is_static,
-                        is_method_call,
-                    ));
-                }
-
                 SubjectOutcome::Untyped => {
                     // When the opt-in `unresolved-member-access` diagnostic
-                    // is enabled, emit it here instead of in a separate
-                    // collector pass.  This avoids a second full walk of
-                    // the same symbol spans with duplicate type resolution.
+                    // is enabled, report every member access where the
+                    // subject type could not be resolved — regardless of
+                    // whether the subject is a bare variable, a chain, an
+                    // array access, or a function call result.
                     if self.config().diagnostics.unresolved_member_access_enabled() {
-                        // Skip call-expression subjects — the failure is
-                        // usually because the symbol map's subject_text
-                        // doesn't preserve full argument text, not because
-                        // the user is missing a type annotation.
-                        if !subject_text.is_empty() && !subject_text.contains('(') {
-                            let range = match offset_range_to_lsp_range(
-                                content,
-                                span.start as usize,
-                                span.end as usize,
-                            ) {
-                                Some(r) => r,
-                                None => continue,
-                            };
-                            let subject_display = subject_text.trim();
-                            let message = format!(
-                                "Cannot resolve type of '{}'. Add a type annotation or PHPDoc tag to enable full IDE support.",
-                                subject_display,
-                            );
-                            out.push(make_diagnostic(
-                                range,
-                                DiagnosticSeverity::HINT,
-                                UNRESOLVED_MEMBER_ACCESS_CODE,
-                                message,
-                            ));
-                        }
+                        let range = match offset_range_to_lsp_range(
+                            content,
+                            span.start as usize,
+                            span.end as usize,
+                        ) {
+                            Some(r) => r,
+                            None => continue,
+                        };
+                        let subject_display = subject_text.trim();
+                        let kind_label = if is_method_call { "method" } else { "property" };
+                        let message = format!(
+                            "Cannot verify {} '{}' — type of '{}' could not be resolved",
+                            kind_label, member_name, subject_display,
+                        );
+                        out.push(make_diagnostic(
+                            range,
+                            DiagnosticSeverity::HINT,
+                            UNRESOLVED_MEMBER_ACCESS_CODE,
+                            message,
+                        ));
+                        broken_chain_prefixes.push(broken_chain_prefix(
+                            subject_text,
+                            member_name,
+                            is_static,
+                            is_method_call,
+                        ));
                     }
                 }
 
@@ -4969,6 +4932,100 @@ function test(): void {
         );
     }
 
+    /// Bracket access on a class implementing `ArrayAccess` without
+    /// concrete generic annotations should NOT resolve to the container
+    /// class itself.  `$app['config']` is not `Application`.
+    /// The diagnostic should say the subject type could not be resolved,
+    /// not that the member is missing on `Application`.
+    #[test]
+    fn flags_member_on_array_access_class_without_generics() {
+        let php = r#"<?php
+class Application implements \ArrayAccess {
+    public function offsetExists(mixed $offset): bool { return true; }
+    public function offsetGet(mixed $offset): mixed { return null; }
+    public function offsetSet(mixed $offset, mixed $value): void {}
+    public function offsetUnset(mixed $offset): void {}
+
+    public function useStoragePath(string $path): void {}
+}
+
+function test(Application $app): void {
+    $app['config']->set('logging.default', 'stderr');
+}
+"#;
+        let backend = Backend::new_test();
+        // Enable unresolved-member-access so the Untyped outcome emits.
+        backend.config.lock().diagnostics.unresolved_member_access = Some(true);
+        let diags = collect(&backend, "file:///test.php", php);
+        // `$app['config']` returns `mixed` (no concrete generics), so
+        // we cannot know the type — the diagnostic should say the
+        // subject could not be resolved, NOT that 'set' is missing on
+        // `Application`.
+        assert!(
+            !diags.iter().any(|d| d.message.contains("Application")),
+            "should not report 'set' as missing on Application — bracket access returns mixed, got: {diags:?}",
+        );
+        assert!(
+            diags
+                .iter()
+                .any(|d| d.message.contains("could not be resolved")),
+            "expected 'could not be resolved' diagnostic for unresolvable bracket access, got: {diags:?}",
+        );
+    }
+
+    /// Same as above but with inheritance: `Application2 extends
+    /// Container2 implements ArrayAccess`.  The `ArrayAccess` interface
+    /// is on the parent class, not the child.
+    #[test]
+    fn flags_member_on_array_access_subclass_without_generics() {
+        let php = r#"<?php
+namespace Tests;
+
+use ArrayAccess;
+
+class Container2 implements ArrayAccess
+{
+    public function offsetExists($offset): bool
+    {
+        return false;
+    }
+
+    public function offsetGet($offset): mixed
+    {
+        return '';
+    }
+
+    public function offsetSet($offset, $value): void
+    {
+    }
+
+    public function offsetUnset($offset): void
+    {
+    }
+}
+
+class Application2 extends Container2
+{
+}
+
+class TestCase
+{
+    public function defineEnvironment(): void
+    {
+        $test4 = new Application2();
+        $test4['config']->set('logging.channels.stack.channels', ['stderr']);
+    }
+}
+"#;
+        let backend = Backend::new_test();
+        backend.config.lock().diagnostics.unresolved_member_access = Some(true);
+        let diags = collect(&backend, "file:///test.php", php);
+        assert!(
+            !diags.iter().any(|d| d.message.contains("Application2")),
+            "should not report 'set' as missing on Application2 — bracket access returns mixed, got: {diags:?}",
+        );
+    }
+
     /// B18 variant: assignment in while condition `while ($line = fgets($fp))`.
     #[test]
     fn assignment_in_while_condition_resolves_in_body() {

src/lib.rs

@@ -897,6 +897,14 @@ impl Backend {
         self.config.lock().clone()
     }
 
+    /// Replace the current configuration.
+    ///
+    /// Used by integration tests to enable opt-in diagnostics like
+    /// `unresolved-member-access` without needing a `.phpantom.toml` file.
+    pub fn set_config(&self, config: config::Config) {
+        *self.config.lock() = config;
+    }
+
     /// Set the PHP version (used by integration tests and during
     /// server initialization after reading `composer.json`).
     ///