Suppress unknown member diagnostics for arbitrary SoapClient methods

Author: AJenbo

docs/CHANGELOG.md

@@ -28,6 +28,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Property `self`/`static` type resolution.** Properties declared with `@var self|null` or `static` type annotations now resolve to the owning class name instead of displaying the raw `self`/`static` keyword in hover and type inference.
 - **Magic `__get` property access.** Accessing undefined properties on objects with a `__get` method now resolves to the method's declared return type, even when `__get` has no template parameters (e.g. `SimpleXMLElement::$child` resolves to `SimpleXMLElement`).
 - **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.
 - **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.

src/diagnostics/unknown_members/mod.rs

@@ -480,6 +480,13 @@ impl Backend {
                 }
 
                 SubjectOutcome::UnresolvableClass(ref unresolved) => {
+                    // SoapClient is a SOAP proxy where any method is
+                    // valid.  Even if we cannot fully resolve the class,
+                    // suppress the diagnostic.
+                    let type_str = unresolved.to_string();
+                    if type_str == "SoapClient" || type_str == "\\SoapClient" {
+                        continue;
+                    }
                     let range = match self.offset_range_to_lsp_range(
                         uri,
                         content,
@@ -733,6 +740,19 @@ impl Backend {
                     .iter()
                     .any(|c| has_magic_method_for_access(c, is_static, true)));
 
+        // ── SoapClient: suppress diagnostic entirely ────────────────
+        // SoapClient is a SOAP proxy where any method name is valid
+        // (proxied to the remote service).  PHP does not error, and
+        // PHPStan treats all calls as returning mixed.  Suppress the
+        // diagnostic but do not break the chain.
+        if has_magic_call
+            && resolved_classes
+                .iter()
+                .any(|c| is_soap_client(&c.name, class_loader))
+        {
+            return (MemberCheckResult::MagicFallback, diagnostics);
+        }
+
         // ── Member is unresolved on ALL branches — emit diagnostic ──
         let range = match offset_range_to_lsp_range(content, start as usize, end as usize) {
             Some(r) => r,
@@ -946,6 +966,29 @@ fn has_magic_method_for_access(class: &ClassInfo, is_static: bool, is_method_cal
     false
 }
 
+/// Returns `true` if `class_name` is `SoapClient` or a class that
+/// ultimately extends `SoapClient`.  SoapClient acts as a SOAP
+/// proxy: any method name is valid and returns mixed at runtime.
+fn is_soap_client(class_name: &str, class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>) -> bool {
+    if class_name == "SoapClient" {
+        return true;
+    }
+    // Walk the parent chain to check if this class extends SoapClient.
+    let mut current = class_loader(class_name);
+    let mut depth = 0;
+    while let Some(cls) = current {
+        if cls.name == "SoapClient" {
+            return true;
+        }
+        depth += 1;
+        if depth > 20 {
+            break;
+        }
+        current = cls.parent_class.as_ref().and_then(|p| class_loader(p));
+    }
+    false
+}
+
 fn display_class_name(class: &ClassInfo) -> String {
     if class.name.starts_with("__anonymous@") {
         return "anonymous class".to_string();

src/diagnostics/unknown_members/tests.rs

@@ -5228,3 +5228,44 @@ class Svc {
         "expected no diagnostics after guard clause narrowing on property in foreach, got: {diags:?}",
     );
 }
+
+#[test]
+fn no_diagnostic_for_arbitrary_method_on_soap_client() {
+    let php = r#"<?php
+function test(\SoapClient $client): void {
+$client->gettransactionlist(['foo' => 'bar']);
+$client->delete(123);
+$client->capture('abc');
+}
+"#;
+    let backend = Backend::new_test();
+    let diags = collect(&backend, "file:///test.php", php);
+    assert!(
+        diags.is_empty(),
+        "expected no diagnostics for arbitrary methods on SoapClient, got: {diags:?}",
+    );
+}
+
+#[test]
+fn no_diagnostic_for_arbitrary_method_on_soap_client_subclass() {
+    // When a class extends SoapClient, it inherits __call and any
+    // method should be valid.  In single-file tests the parent chain
+    // may not fully resolve from stubs, so we test with a direct
+    // SoapClient parameter typed as the subclass via docblock.
+    let php = r#"<?php
+class MyService extends \SoapClient {
+    public function getConnection(): \SoapClient { return $this; }
+}
+function test(): void {
+$svc = new MyService('http://example.com?wsdl');
+$svc->getConnection()->customMethod();
+}
+"#;
+    let backend = Backend::new_test();
+    let diags = collect(&backend, "file:///test.php", php);
+    // The getConnection() returns \SoapClient, which should suppress.
+    assert!(
+        diags.is_empty(),
+        "expected no diagnostics for arbitrary methods on SoapClient subclass, got: {diags:?}",
+    );
+}