Fix false positives for bare array and foreach class-string diagnostics

Author: AJenbo

docs/CHANGELOG.md

@@ -30,6 +30,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Magic `__call` method return type.** Calling undefined methods on objects with a `__call` method now resolves to `__call`'s declared return type for hover and type inference.
 - **SoapClient arbitrary methods.** Calling any method on `SoapClient` (or subclasses) no longer produces false-positive "unknown member" diagnostics. SoapClient is a SOAP proxy where any method name is valid at runtime.
 - **`self::class` and `static::class` in template arguments.** Passing `self::class` or `static::class` to a method with `@template T` + `@param class-string<T>` now correctly resolves T to the enclosing class instead of failing to resolve or resolving to the called class.
+- **Bare array return values no longer flagged against typed array parameters.** When a method returns `array` (without generic parameters), passing the result to a parameter expecting `array<T>` no longer triggers a false type mismatch error.
+- **Foreach over `::class` literal arrays resolves static access.** Variables assigned from `foreach ([A::class, B::class] as $className)` are now recognized as class-strings, so `$className::CONST` and `$className::method()` no longer produce unresolved-member-access diagnostics.
 - **Use-map shadowing no longer causes false type errors.** When a file imports a namespaced class under the same short name as a global class (e.g. `use App\Exceptions\Exception;`), type hierarchy checks no longer cycle and incorrectly flag subclass arguments as incompatible with parent interfaces like `Throwable`.
 - **Multi-namespace function return type resolution.** In files with multiple `namespace { }` blocks, function return types were resolved against the first namespace instead of the function's own namespace. This caused incorrect type inference for variables assigned from function calls in later namespace blocks.
 - **Template inference through stub interfaces.** `@template-implements` on stub-loaded interfaces (e.g. `IteratorAggregate<int, Foo>`) now correctly propagates substituted return types to child methods that omit a return type annotation. Previously these resolved as untyped.

src/completion/variable/class_string_resolution.rs

@@ -157,8 +157,56 @@ fn walk_class_string_assignments<'b>(
         if stmt.span().start.offset >= ctx.cursor_offset {
             continue;
         }
-        if let Statement::Expression(expr_stmt) = stmt {
-            check_class_string_assignment(expr_stmt.expression, ctx, results);
+        match stmt {
+            Statement::Expression(expr_stmt) => {
+                check_class_string_assignment(expr_stmt.expression, ctx, results);
+            }
+            Statement::Foreach(foreach) => {
+                // Check if the foreach value variable matches our target
+                // and the iterated expression is an array of ::class literals.
+                let value_expr = foreach.target.value();
+                let value_name = match value_expr {
+                    Expression::Variable(Variable::Direct(dv)) => Some(dv.name.to_string()),
+                    _ => None,
+                };
+                if let Some(name) = value_name
+                    && name == ctx.var_name
+                {
+                    // Extract class names from the iterated expression
+                    // (e.g. `[Page::class, CustomPage::class]`).
+                    let class_names =
+                        extract_class_string_names_from_array(foreach.expression);
+                    if !class_names.is_empty() {
+                        results.clear();
+                        for cn in class_names {
+                            let resolved_name = if let Some(resolved) =
+                                resolve_class_keyword(&cn, Some(ctx.current_class))
+                            {
+                                resolved
+                            } else {
+                                cn
+                            };
+                            let lookup = short_name(&resolved_name);
+                            if let Some(cls) =
+                                ctx.all_classes.iter().find(|c| c.name == lookup)
+                            {
+                                ClassInfo::push_unique(results, ClassInfo::clone(cls));
+                            } else if let Some(cls) = (ctx.class_loader)(&resolved_name) {
+                                ClassInfo::push_unique(results, Arc::unwrap_or_clone(cls));
+                            }
+                        }
+                    }
+                }
+                // Also walk the foreach body for nested assignments.
+                let body_stmts: Vec<&Statement> = match &foreach.body {
+                    mago_syntax::ast::ForeachBody::Statement(s) => vec![s],
+                    mago_syntax::ast::ForeachBody::ColonDelimited(b) => {
+                        b.statements.iter().collect()
+                    }
+                };
+                walk_class_string_assignments(body_stmts.into_iter(), ctx, results);
+            }
+            _ => {}
         }
     }
 }
@@ -235,3 +283,31 @@ fn extract_class_string_names(expr: &Expression<'_>) -> Vec<String> {
         _ => vec![],
     }
 }
+
+/// Extract class names from array elements that are `::class` literals.
+///
+/// Handles `[Page::class, CustomPage::class]` and similar array
+/// expressions used as foreach iterables.
+fn extract_class_string_names_from_array(expr: &Expression<'_>) -> Vec<String> {
+    match expr {
+        Expression::Array(array) => {
+            let mut names = Vec::new();
+            for item in array.elements.iter() {
+                if let ArrayElement::Value(val) = item {
+                    names.extend(extract_class_string_names(val.value));
+                }
+            }
+            names
+        }
+        Expression::LegacyArray(array) => {
+            let mut names = Vec::new();
+            for item in array.elements.iter() {
+                if let ArrayElement::Value(val) = item {
+                    names.extend(extract_class_string_names(val.value));
+                }
+            }
+            names
+        }
+        _ => vec![],
+    }
+}

src/diagnostics/type_errors.rs

@@ -57,6 +57,7 @@ struct ResolvedCallArgs {
 /// Returns `true` when the type is a bare unparameterised `array`.
 fn is_bare_array(ty: &PhpType) -> bool {
     matches!(ty, PhpType::Named(n) if n.eq_ignore_ascii_case("array"))
+        || matches!(ty, PhpType::Array(inner) if inner.is_mixed())
 }
 
 /// Check if an argument type is compatible with a parameter type.

tests/integration/diag_timing.rs

@@ -15,7 +15,7 @@
 //! invalidation, classes from unedited files stay cached and the second
 //! pass is significantly faster.
 
-use crate::common::{create_psr4_workspace, create_test_backend_with_full_stubs};
+use crate::common::{create_psr4_workspace, create_test_backend, create_test_backend_with_full_stubs};
 use std::time::Instant;
 use tower_lsp::lsp_types::NumberOrString;
 
@@ -2096,3 +2096,52 @@ class Calculator {
         out.iter().map(|d| &d.message).collect::<Vec<_>>()
     );
 }
+
+// ─── Foreach over array of ::class literals resolves static access ───────────
+
+#[test]
+fn foreach_class_string_array_static_access_no_false_positive() {
+    let php = r#"<?php
+class Page {
+    public const TABLE_NAME = 'pages';
+}
+
+class Newsletter {
+    public const TABLE_NAME = 'newsletters';
+}
+
+class Controller {
+    public function test(): void {
+        foreach ([Page::class, Newsletter::class] as $className) {
+            echo $className::TABLE_NAME;
+        }
+    }
+}
+"#;
+
+    let uri = "file:///test/foreach_class.php";
+    let backend = create_test_backend();
+    {
+        let mut cfg = backend.config();
+        cfg.diagnostics.unresolved_member_access = Some(true);
+        backend.set_config(cfg);
+    }
+    backend.update_ast(uri, php);
+
+    let mut out = Vec::new();
+    backend.collect_unknown_member_diagnostics(uri, php, &mut out);
+
+    let relevant: Vec<_> = out
+        .iter()
+        .filter(|d| {
+            d.code.as_ref().is_some_and(|c| {
+                matches!(c, NumberOrString::String(s) if s == "unknown_member" || s == "unresolved_member_access")
+            })
+        })
+        .collect();
+    assert!(
+        relevant.is_empty(),
+        "Should not flag static access on foreach class-string variable, got: {:?}",
+        relevant.iter().map(|d| &d.message).collect::<Vec<_>>()
+    );
+}

tests/integration/diagnostics_type_errors.rs

@@ -3803,3 +3803,31 @@ class MyException extends NativeException {}
         "Should not flag Exception subclass as incompatible with Throwable, got: {msgs:?}"
     );
 }
+
+// ─── Bare array (Array(mixed)) passed to typed array parameter ──────────────
+
+#[test]
+fn no_false_positive_bare_array_from_method_call_to_typed_array_param() {
+    let php = r#"<?php
+class ORM {
+    /** @return array */
+    public function getByQuery(string $class, string $query): array { return []; }
+}
+
+class Controller {
+    /** @param array<Item> $items */
+    public function process(array $items): void {}
+
+    public function test(ORM $orm): void {
+        $items = $orm->getByQuery('Item', 'SELECT * FROM items');
+        $this->process($items);
+    }
+}
+"#;
+    let diags = collect(php);
+    let msgs = type_error_messages(&diags);
+    assert!(
+        msgs.is_empty(),
+        "Should not flag bare array from method return as incompatible with typed array param, got: {msgs:?}"
+    );
+}