Merge branch '1.9.x' into 1.10.x

Author: ondrejmirtes

Diff for: src/Analyser/MutatingScope.php

@@ -2419,18 +2419,18 @@ public function isInFunctionExists(string $functionName): bool
 	public function enterClass(ClassReflection $classReflection): self
 	{
 		$thisHolder = ExpressionTypeHolder::createYes(new Variable('this'), new ThisType($classReflection));
+		$constantTypes = $this->getConstantTypes();
+		$constantTypes['$this'] = $thisHolder;
+		$nativeConstantTypes = $this->getNativeConstantTypes();
+		$nativeConstantTypes['$this'] = $thisHolder;
 
 		return $this->scopeFactory->create(
 			$this->context->enterClass($classReflection),
 			$this->isDeclareStrictTypes(),
 			null,
 			$this->getNamespace(),
-			array_merge($this->getConstantTypes(), [
-				'$this' => $thisHolder,
-			]),
-			array_merge($this->getNativeConstantTypes(), [
-				'$this' => $thisHolder,
-			]),
+			$constantTypes,
+			$nativeConstantTypes,
 			[],
 			[],
 			null,
@@ -2451,13 +2451,26 @@ public function enterTrait(ClassReflection $traitReflection): self
 		if (count($traitNameParts) > 1) {
 			$namespace = implode('\\', array_slice($traitNameParts, 0, -1));
 		}
+
+		$traitContext = $this->context->enterTrait($traitReflection);
+		$classReflection = $traitContext->getClassReflection();
+		if ($classReflection === null) {
+			throw new ShouldNotHappenException();
+		}
+
+		$thisHolder = ExpressionTypeHolder::createYes(new Variable('this'), new ThisType($classReflection, null, $traitReflection));
+		$expressionTypes = $this->expressionTypes;
+		$expressionTypes['$this'] = $thisHolder;
+		$nativeExpressionTypes = $this->nativeExpressionTypes;
+		$nativeExpressionTypes['$this'] = $thisHolder;
+
 		return $this->scopeFactory->create(
-			$this->context->enterTrait($traitReflection),
+			$traitContext,
 			$this->isDeclareStrictTypes(),
 			$this->getFunction(),
 			$namespace,
-			$this->expressionTypes,
-			$this->nativeExpressionTypes,
+			$expressionTypes,
+			$nativeExpressionTypes,
 			[],
 			$this->inClosureBindScopeClasses,
 			$this->anonymousFunctionReflection,

Diff for: src/Type/ObjectType.php

@@ -302,6 +302,31 @@ public function isSuperTypeOf(Type $type): TrinaryLogic
 			return self::$superTypes[$thisDescription][$description] = TrinaryLogic::createMaybe();
 		}
 
+		if ($type instanceof ThisType && $type->isInTrait()) {
+			if ($type->getSubtractedType() !== null) {
+				$isSuperType = $type->getSubtractedType()->isSuperTypeOf($this);
+				if ($isSuperType->yes()) {
+					return self::$superTypes[$thisDescription][$description] = TrinaryLogic::createNo();
+				}
+			}
+
+			if ($this->getClassReflection() === null) {
+				return self::$superTypes[$thisDescription][$description] = TrinaryLogic::createMaybe();
+			}
+
+			$thisClassReflection = $this->getClassReflection();
+			if ($thisClassReflection->isTrait()) {
+				return self::$superTypes[$thisDescription][$description] = TrinaryLogic::createNo();
+			}
+
+			$traitReflection = $type->getTraitReflection();
+			if ($thisClassReflection->isFinal() && !$thisClassReflection->hasTraitUse($traitReflection->getName())) {
+				return self::$superTypes[$thisDescription][$description] = TrinaryLogic::createNo();
+			}
+
+			return self::$superTypes[$thisDescription][$description] = TrinaryLogic::createMaybe();
+		}
+
 		$transformResult = static fn (TrinaryLogic $result) => $result;
 		if ($this->subtractedType !== null) {
 			$isSuperType = $this->subtractedType->isSuperTypeOf($type);

Diff for: src/Type/ThisType.php

@@ -17,6 +17,7 @@ class ThisType extends StaticType
 	public function __construct(
 		ClassReflection $classReflection,
 		?Type $subtractedType = null,
+		private ?ClassReflection $traitReflection = null,
 	)
 	{
 		parent::__construct($classReflection, $subtractedType);
@@ -57,6 +58,19 @@ public function changeSubtractedType(?Type $subtractedType): Type
 		return $type;
 	}
 
+	/**
+	 * @phpstan-assert-if-true !null $this->getTraitReflection()
+	 */
+	public function isInTrait(): bool
+	{
+		return $this->traitReflection !== null;
+	}
+
+	public function getTraitReflection(): ?ClassReflection
+	{
+		return $this->traitReflection;
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		$subtractedType = $this->getSubtractedType() !== null ? $cb($this->getSubtractedType()) : null;

Diff for: tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -1197,6 +1197,7 @@ public function dataFileAsserts(): iterable
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/callsite-cast-narrowing.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-8775.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-8752.php');
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/trait-instance-of.php');
 	}
 
 	/**

Diff for: tests/PHPStan/Analyser/data/trait-instance-of.php

@@ -0,0 +1,70 @@
+<?php declare(strict_types = 1);
+
+namespace TraitInstanceOf;
+
+use function PHPStan\Testing\assertType;
+
+trait Trait1 {
+	public function test(): string {
+		assertType('$this(TraitInstanceOf\ATrait1Class)', $this);
+		if ($this instanceof WithoutFoo) {
+			assertType('$this(TraitInstanceOf\ATrait1Class)&TraitInstanceOf\WithoutFoo', $this);
+			return 'hello world';
+		}
+
+		if ($this instanceof FinalOther) {
+			assertType('*NEVER*', $this);
+			return 'hello world';
+		}
+
+		assertType('$this(TraitInstanceOf\ATrait1Class)', $this);
+		if ($this instanceof Trait2) {
+			assertType('*NEVER*', $this);
+			return 'hello world';
+		}
+
+		if ($this instanceof FinalTrait2Class) {
+			assertType('*NEVER*', $this);
+			return 'hello world';
+		}
+
+		assertType('$this(TraitInstanceOf\ATrait1Class)', $this);
+		throw new \Error();
+	}
+}
+
+trait Trait2 {
+	public function test(): string {
+		assertType('$this(TraitInstanceOf\FinalTrait2Class)', $this);
+
+		if ($this instanceof FinalTrait2Class) {
+			assertType('$this(TraitInstanceOf\FinalTrait2Class)&TraitInstanceOf\FinalTrait2Class', $this);
+			return 'hello world';
+		}
+
+		if ($this instanceof ATrait1Class) {
+			assertType('*NEVER*', $this);
+			return 'hello world';
+		}
+
+		if ($this instanceof FinalOther) {
+			assertType('*NEVER*', $this);
+			return 'hello world';
+		}
+
+		return 'hello world';
+	}
+}
+
+final class FinalOther {
+}
+
+final class FinalTrait2Class {
+	use Trait2;
+}
+
+class WithoutFoo {}
+
+class ATrait1Class {
+	use Trait1;
+}

Diff for: tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php

@@ -70,4 +70,14 @@ public function testBug7720(): void
 		]);
 	}
 
+	public function testTraitInstanceOf(): void
+	{
+		$this->analyse([__DIR__ . '/../../Analyser/data/trait-instance-of.php'], [
+			[
+				'Instanceof between $this(TraitInstanceOf\ATrait1Class) and trait TraitInstanceOf\Trait2 will always evaluate to false.',
+				21,
+			],
+		]);
+	}
+
 }

Diff for: tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php

@@ -541,4 +541,11 @@ public function testBug4689(): void
 		$this->analyse([__DIR__ . '/data/bug-4689.php'], []);
 	}
 
+	public function testBug3632(): void
+	{
+		$this->checkAlwaysTrueInstanceOf = true;
+		$this->treatPhpDocTypesAsCertain = false;
+		$this->analyse([__DIR__ . '/data/bug-3632.php'], []);
+	}
+
 }

Diff for: tests/PHPStan/Rules/Classes/data/bug-3632.php

@@ -0,0 +1,33 @@
+<?php declare(strict_types = 1);
+
+namespace Bug3632;
+
+trait Foo {
+	public function test(): string {
+		if ($this instanceof HelloWorld) {
+			return 'hello world';
+		}
+		if ($this instanceof OtherClass) {
+			return 'other class';
+		}
+
+		return 'no';
+	}
+}
+
+class HelloWorld
+{
+	use Foo;
+
+	function bar(): string {
+		return $this->test();
+	}
+}
+
+class OtherClass {
+	use Foo;
+
+	function bar(): string {
+		return $this->test();
+	}
+}