Implement TypeSpecifierContext->getReturnType()

src/Analyser/TypeSpecifier.php

@@ -331,21 +331,6 @@ public function specifyTypesInCondition(
 				}
 			}
 
-			if (
-				!$context->null()
-				&& $expr->right instanceof FuncCall
-				&& count($expr->right->getArgs()) >= 3
-				&& $expr->right->name instanceof Name
-				&& in_array(strtolower((string) $expr->right->name), ['preg_match'], true)
-				&& IntegerRangeType::fromInterval(0, null)->isSuperTypeOf($leftType)->yes()
-			) {
-				return $this->specifyTypesInCondition(
-					$scope,
-					new Expr\BinaryOp\NotIdentical($expr->right, new ConstFetch(new Name('false'))),
-					$context,
-				)->setRootExpr($expr);
-			}
-
 			if (
 				!$context->null()
 				&& $expr->right instanceof FuncCall
@@ -466,6 +451,24 @@ public function specifyTypesInCondition(
 				}
 			}
 
+			if (
+				!$context->null()
+				&& $expr->right instanceof Expr\CallLike
+			) {
+				if (!$scope instanceof MutatingScope) {
+					throw new ShouldNotHappenException();
+				}
+				$newScope = $scope->filterBySpecifiedTypes($result);
+				$callType = $newScope->getType($expr->right);
+				$newContext = $context->true() ? TypeSpecifierContext::createTrue($callType) : TypeSpecifierContext::createTrue($callType)->negate();
+
+				$result = $result->unionWith($this->specifyTypesInCondition(
+					$scope,
+					$expr->right,
+					$newContext,
+				)->setRootExpr($expr));
+			}
+
 			return $result;
 
 		} elseif ($expr instanceof Node\Expr\BinaryOp\Greater) {
@@ -1173,7 +1176,7 @@ private function specifyTypesForConstantBinaryExpression(
 			return $types->unionWith($this->specifyTypesInCondition(
 				$scope,
 				$exprNode,
-				$context->true() ? TypeSpecifierContext::createTrue() : TypeSpecifierContext::createTrue()->negate(),
+				$context->true() ? TypeSpecifierContext::createTrue($context->getReturnType()) : TypeSpecifierContext::createTrue($context->getReturnType())->negate(),
 			)->setRootExpr($rootExpr));
 		}
 
@@ -1973,7 +1976,7 @@ public function resolveEqual(Expr\BinaryOp\Equal $expr, Scope $scope, TypeSpecif
 				return $this->specifyTypesInCondition(
 					$scope,
 					$exprNode,
-					$context->true() ? TypeSpecifierContext::createFalsey() : TypeSpecifierContext::createFalsey()->negate(),
+					$context->true() ? TypeSpecifierContext::createFalsey($context->getReturnType()) : TypeSpecifierContext::createFalsey($context->getReturnType())->negate(),
 				)->setRootExpr($expr);
 			}
 

src/Analyser/TypeSpecifierContext.php

@@ -3,6 +3,9 @@
 namespace PHPStan\Analyser;
 
 use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\GeneralizePrecision;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 
 /**
  * @api
@@ -21,34 +24,42 @@ final class TypeSpecifierContext
 	/** @var self[] */
 	private static array $registry;
 
-	private function __construct(private ?int $value)
+	private function __construct(
+		private ?int $value,
+		private ?Type $returnType,
+	)
 	{
 	}
 
-	private static function create(?int $value): self
+	private static function create(?int $value, ?Type $returnType = null): self
 	{
-		self::$registry[$value] ??= new self($value);
+		if ($returnType !== null) {
+			// return type bound context is unique for each context and therefore not cacheable
+			return new self($value, $returnType);
+		}
+
+		self::$registry[$value] ??= new self($value, null);
 		return self::$registry[$value];
 	}
 
-	public static function createTrue(): self
+	public static function createTrue(?Type $returnType = null): self
 	{
-		return self::create(self::CONTEXT_TRUE);
+		return self::create(self::CONTEXT_TRUE, $returnType);
 	}
 
-	public static function createTruthy(): self
+	public static function createTruthy(?Type $returnType = null): self
 	{
-		return self::create(self::CONTEXT_TRUTHY);
+		return self::create(self::CONTEXT_TRUTHY, $returnType);
 	}
 
-	public static function createFalse(): self
+	public static function createFalse(?Type $returnType = null): self
 	{
-		return self::create(self::CONTEXT_FALSE);
+		return self::create(self::CONTEXT_FALSE, $returnType);
 	}
 
-	public static function createFalsey(): self
+	public static function createFalsey(?Type $returnType = null): self
 	{
-		return self::create(self::CONTEXT_FALSEY);
+		return self::create(self::CONTEXT_FALSEY, $returnType);
 	}
 
 	public static function createNull(): self
@@ -61,7 +72,14 @@ public function negate(): self
 		if ($this->value === null) {
 			throw new ShouldNotHappenException();
 		}
-		return self::create(~$this->value & self::CONTEXT_BITMASK);
+
+		$negatedReturnType = null;
+		if ($this->returnType !== null) {
+			$baseType = $this->returnType->generalize(GeneralizePrecision::lessSpecific());
+			$negatedReturnType = TypeCombinator::remove($baseType, $this->returnType);
+		}
+
+		return self::create(~$this->value & self::CONTEXT_BITMASK, $negatedReturnType);
 	}
 
 	public function true(): bool
@@ -89,4 +107,9 @@ public function null(): bool
 		return $this->value === null;
 	}
 
+	public function getReturnType(): ?Type
+	{
+		return $this->returnType;
+	}
+
 }

src/Type/Php/InArrayFunctionTypeSpecifyingExtension.php

@@ -147,7 +147,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 			$specifiedTypes = $specifiedTypes->unionWith($this->typeSpecifier->create(
 				$node->getArgs()[1]->value,
 				new ArrayType(new MixedType(), $arrayValueType),
-				TypeSpecifierContext::createTrue(),
+				TypeSpecifierContext::createTrue($context->getReturnType()),
 				$scope,
 			));
 		}

tests/PHPStan/Analyser/TypeSpecifierContextReturnTypeExtension.neon

@@ -0,0 +1,5 @@
+services:
+	-
+		class: PHPStan\Tests\TypeSpecifierContextReturnTypeExtension
+		tags:
+			- phpstan.typeSpecifier.methodTypeSpecifyingExtension

tests/PHPStan/Analyser/TypeSpecifierContextReturnTypeTest.php

@@ -0,0 +1,35 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+
+class TypeSpecifierContextReturnTypeTest extends TypeInferenceTestCase
+{
+
+	public function dataContextReturnType(): iterable
+	{
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/type-specifier-context-return-type.php');
+	}
+
+	/**
+	 * @dataProvider dataContextReturnType
+	 * @param mixed ...$args
+	 */
+	public function testContextReturnType(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return [
+			__DIR__ . '/TypeSpecifierContextReturnTypeExtension.neon',
+		];
+	}
+
+}

tests/PHPStan/Analyser/data/TypeSpecifierContextReturnTypeExtension.php

@@ -0,0 +1,59 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Tests;
+
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeSpecifier;
+use PHPStan\Analyser\TypeSpecifierAwareExtension;
+use PHPStan\Analyser\TypeSpecifierContext;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\MethodTypeSpecifyingExtension;
+use TypeSpecifierContextReturnTypeTest\ContextReturnType;
+use function str_starts_with;
+
+class TypeSpecifierContextReturnTypeExtension implements MethodTypeSpecifyingExtension, TypeSpecifierAwareExtension
+{
+
+	private TypeSpecifier $typeSpecifier;
+
+	public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void
+	{
+		$this->typeSpecifier = $typeSpecifier;
+	}
+
+	public function getClass(): string
+	{
+		return ContextReturnType::class;
+	}
+
+	public function isMethodSupported(
+		MethodReflection $methodReflection,
+		MethodCall $node,
+		TypeSpecifierContext $context,
+	): bool
+	{
+		return str_starts_with($methodReflection->getName(), 'returns');
+	}
+
+	public function specifyTypes(
+		MethodReflection $methodReflection,
+		MethodCall $node,
+		Scope $scope,
+		TypeSpecifierContext $context,
+	): SpecifiedTypes
+	{
+        if ($context->null()) {
+            return new SpecifiedTypes();
+        }
+
+		return $this->typeSpecifier->create(
+			$node->getArgs()[0]->value,
+			$context->getReturnType(),
+			$context,
+			$scope,
+		);
+	}
+
+}

tests/PHPStan/Analyser/data/type-specifier-context-return-type.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace TypeSpecifierContextReturnTypeTest;
+
+use function PHPStan\Testing\assertType;
+
+class ContextReturnType {
+	public function returnsInt(int $specifiedContextReturnType): int {}
+
+	public function doFooLeft(int $i) {
+		assertType('int', $i);
+		if ($this->returnsInt($i) > 0) {
+			assertType('int<1, max>', $i);
+		} else {
+			assertType('int<min, 0>', $i);
+		}
+		assertType('int', $i);
+	}
+
+	public function doFooRight(int $i) {
+		assertType('int', $i);
+		if (0 < $this->returnsInt($i)) {
+			assertType('int<1, max>', $i);
+		} else {
+			assertType('int<min, 0>', $i);
+		}
+		assertType('int', $i);
+	}
+}