Apply class purity tags to annotated methods

src/Reflection/Annotations/AnnotationMethodReflection.php

@@ -33,6 +33,7 @@ public function __construct(
 		private bool $isVariadic,
 		private ?Type $throwType,
 		private TemplateTypeMap $templateTypeMap,
+		private ?bool $isPure = null,
 	)
 	{
 	}
@@ -132,6 +133,9 @@ public function hasSideEffects(): TrinaryLogic
 		if ($this->returnType->isVoid()->yes()) {
 			return TrinaryLogic::createYes();
 		}
+		if ($this->isPure !== null) {
+			return TrinaryLogic::createFromBoolean(!$this->isPure);
+		}
 
 		if ((new ThisType($this->declaringClass))->isSuperTypeOf($this->returnType)->yes()) {
 			return TrinaryLogic::createYes();
@@ -172,11 +176,7 @@ public function isAbstract(): TrinaryLogic
 
 	public function isPure(): TrinaryLogic
 	{
-		if ($this->hasSideEffects()->yes()) {
-			return TrinaryLogic::createNo();
-		}
-
-		return TrinaryLogic::createMaybe();
+		return $this->hasSideEffects()->negate();
 	}
 
 	public function getPureUnlessCallableIsImpureParameters(): array

src/Reflection/Annotations/AnnotationsMethodsClassReflectionExtension.php

@@ -71,6 +71,19 @@ private function findClassReflectionWithMethod(
 
 			$isStatic = $methodTags[$methodName]->isStatic();
 			$nativeCallMethodName = $isStatic ? '__callStatic' : '__call';
+			$nativeCallMethod = $classReflection->hasNativeMethod($nativeCallMethodName)
+				? $classReflection->getNativeMethod($nativeCallMethodName)
+				: null;
+			$classResolvedPhpDoc = $classReflection->getResolvedPhpDoc();
+			$isPure = null;
+			if ($nativeCallMethod !== null) {
+				$nativePurity = $nativeCallMethod->isPure();
+				$isPure = $nativePurity->yes() ? true : ($nativePurity->no() ? false : null);
+			} elseif ($classResolvedPhpDoc !== null && $classResolvedPhpDoc->areAllMethodsPure()) {
+				$isPure = true;
+			} elseif ($classResolvedPhpDoc !== null && $classResolvedPhpDoc->areAllMethodsImpure()) {
+				$isPure = false;
+			}
 
 			return new AnnotationMethodReflection(
 				$methodName,
@@ -84,10 +97,9 @@ private function findClassReflectionWithMethod(
 				$parameters,
 				$isStatic,
 				$this->detectMethodVariadic($parameters),
-				$classReflection->hasNativeMethod($nativeCallMethodName)
-					? $classReflection->getNativeMethod($nativeCallMethodName)->getThrowType()
-					: null,
+				$nativeCallMethod !== null ? $nativeCallMethod->getThrowType() : null,
 				$templateTypeMap,
+				$isPure,
 			);
 		}
 

tests/PHPStan/Reflection/Annotations/AnnotationsMethodsClassReflectionExtensionTest.php

@@ -7,6 +7,8 @@
 use AnnotationsMethods\BazBaz;
 use AnnotationsMethods\Foo;
 use AnnotationsMethods\FooInterface;
+use AnnotationsMethods\ImpureMagicMethods;
+use AnnotationsMethods\PureMagicMethods;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\PassedByReference;
 use PHPStan\Reflection\Php\PhpMethodReflection;
@@ -1032,4 +1034,19 @@ public function testOverridingNativeMethodsWithAnnotationsDoesNotBreakGetNativeM
 		$this->assertInstanceOf(PhpMethodReflection::class, $class->getNativeMethod('overridenMethodWithAnnotation'));
 	}
 
+	public function testMagicMethodsInheritClassPurity(): void
+	{
+		$reflectionProvider = self::createReflectionProvider();
+		foreach ([PureMagicMethods::class => true, ImpureMagicMethods::class => false] as $className => $isPure) {
+			$class = $reflectionProvider->getClass($className);
+			$scope = $this->createStub(Scope::class);
+			$scope->method('isInClass')->willReturn(true);
+			$scope->method('getClassReflection')->willReturn($class);
+			$scope->method('canCallMethod')->willReturn(true);
+			$method = $class->getMethod('magic', $scope);
+			$this->assertSame($isPure, $method->isPure()->yes());
+			$this->assertSame(!$isPure, $method->hasSideEffects()->yes());
+		}
+	}
+
 }

tests/PHPStan/Reflection/Annotations/data/annotations-methods.php

@@ -147,3 +147,19 @@ trait FooTrait
 {
 
 }
+
+/**
+ * @phpstan-all-methods-pure
+ * @method int magic()
+ */
+class PureMagicMethods
+{
+}
+
+/**
+ * @phpstan-all-methods-impure
+ * @method int magic()
+ */
+class ImpureMagicMethods
+{
+}

tests/PHPStan/Rules/Pure/PureMethodRuleTest.php

@@ -347,6 +347,15 @@ public function testAllMethodsArePure(): void
 		]);
 	}
 
+	public function testBug15322(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-15322.php'], [
+			['Impure call to method Bug15322\\ImpureDispatcher::magic() in pure method Bug15322\\Test::runImpureDispatcher().', 63],
+			['Impure call to method Bug15322\\ImpureStaticDispatcher::magic() in pure method Bug15322\\Test::runImpureStaticDispatcher().', 69],
+		]);
+	}
+
 	#[RequiresPhp('>= 8.0.0')]
 	public function testBug14138Pure(): void
 	{

tests/PHPStan/Rules/Pure/data/bug-15322.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Bug15322;
+
+/**
+ * @phpstan-all-methods-pure
+ * @method int magic()
+ */
+class MagicMethods
+{
+}
+
+/**
+ * @phpstan-all-methods-pure
+ * @method int magic()
+ */
+class ImpureDispatcher
+{
+	/** @phpstan-impure */
+	public function __call(string $name, array $arguments): int
+	{
+		return time();
+	}
+}
+
+/**
+ * @phpstan-all-methods-pure
+ * @method static int magic()
+ */
+class ImpureStaticDispatcher
+{
+	/** @phpstan-impure */
+	public static function __callStatic(string $name, array $arguments): int
+	{
+		return time();
+	}
+}
+
+/**
+ * @phpstan-all-methods-impure
+ * @method int magic()
+ */
+class PureDispatcher
+{
+	/** @phpstan-pure */
+	public function __call(string $name, array $arguments): int
+	{
+		return 1;
+	}
+}
+
+class Test
+{
+	/** @phpstan-pure */
+	public function run(MagicMethods $object): int
+	{
+		return $object->magic();
+	}
+
+	/** @phpstan-pure */
+	public function runImpureDispatcher(ImpureDispatcher $object): int
+	{
+		return $object->magic();
+	}
+
+	/** @phpstan-pure */
+	public function runImpureStaticDispatcher(): int
+	{
+		return ImpureStaticDispatcher::magic();
+	}
+
+	/** @phpstan-pure */
+	public function runPureDispatcher(PureDispatcher $object): int
+	{
+		return $object->magic();
+	}
+}