Fix static magic method pureness not being inherited from traits

vimeo#10385 "broke" this by propagating pseudo static methods from traits to using classes. `AtomicStaticCallAnalyzer` was then not capable of dealing with this, because now these static pseudo methods actually exist. It seems the logic in `AtomicStaticCallAnalyzer` should've been using `::getDeclaringMethodId()` instead of `::getAppearingMethodId()` for this purpose anyway, at least as long as the methods from traits aren't actually transferred to the using class.
tscni · Nov 29, 2023 · 7705d92 · 7705d92
1 parent 982f95c
commit 7705d92
Show file tree

Hide file tree

Showing 2 changed files with 79 additions and 4 deletions.
diff --git a/...lm/Internal/Analyzer/Statements/Expression/Call/StaticMethod/AtomicStaticCallAnalyzer.php b/...lm/Internal/Analyzer/Statements/Expression/Call/StaticMethod/AtomicStaticCallAnalyzer.php
@@ -566,12 +566,12 @@ private static function handleNamedCall(
                 true,
                 $context->insideUse(),
             )) {
-                $callstatic_appearing_id = $codebase->methods->getAppearingMethodId($callstatic_id);
-                assert($callstatic_appearing_id !== null);
+                $callstatic_declaring_id = $codebase->methods->getDeclaringMethodId($callstatic_id);
+                assert($callstatic_declaring_id !== null);
                 $callstatic_pure = false;
                 $callstatic_mutation_free = false;
-                if ($codebase->methods->hasStorage($callstatic_appearing_id)) {
-                    $callstatic_storage = $codebase->methods->getStorage($callstatic_appearing_id);
+                if ($codebase->methods->hasStorage($callstatic_declaring_id)) {
+                    $callstatic_storage = $codebase->methods->getStorage($callstatic_declaring_id);
                     $callstatic_pure = $callstatic_storage->pure;
                     $callstatic_mutation_free = $callstatic_storage->mutation_free;
                 }

diff --git a/tests/PureAnnotationTest.php b/tests/PureAnnotationTest.php
@@ -446,6 +446,81 @@ function gimmeFoo(): MyEnum
                         return MyEnum::FOO();
                     }',
             ],
+           'pureThroughCallStaticInTrait' => [
+                'code' => '<?php
+                    /**
+                     * @method static static foo()
+                     */
+                    trait TestTrait {
+                        /** @psalm-pure */
+                        public static function __callStatic(string $name, array $params): static
+                        {
+                            throw new BadMethodCallException("not implemented");
+                        }
+                    }
+
+                    class Test {
+                        use TestTrait;
+                    }
+
+                    /** @psalm-pure */
+                    function gimmeFoo(): Test
+                    {
+                        return Test::foo();
+                    }',
+            ],
+           'pureThroughCallStaticInNestedTrait' => [
+                'code' => '<?php
+                    /**
+                     * @method static static foo()
+                     */
+                    trait InnerTestTrait {
+                        /** @psalm-pure */
+                        public static function __callStatic(string $name, array $params): static
+                        {
+                            throw new BadMethodCallException("not implemented");
+                        }
+                    }
+
+                    trait TestTrait {
+                        use InnerTestTrait;
+                    }
+
+                    class Test {
+                        use TestTrait;
+                    }
+
+                    /** @psalm-pure */
+                    function gimmeFoo(): Test
+                    {
+                        return Test::foo();
+                    }',
+            ],
+           'pureThroughAliasedCallStaticInTrait' => [
+                'code' => '<?php
+                    /**
+                     * @method static static foo()
+                     */
+                    trait TestTrait {
+                        /** @psalm-pure */
+                        public static function toBeCallStatic(string $name, array $params): static
+                        {
+                            throw new BadMethodCallException("not implemented");
+                        }
+                    }
+
+                    class Test {
+                        use TestTrait {
+                            TestTrait::toBeCallStatic as __callStatic;
+                        }
+                    }
+
+                    /** @psalm-pure */
+                    function gimmeFoo(): Test
+                    {
+                        return Test::foo();
+                    }',
+            ],
             'dontCrashWhileCheckingPurityOnCallStaticInATrait' => [
                 'code' => '<?php
                     /**