Introduce TypeResult

ondrejmirtes · ondrejmirtes · commit a815d575dc10 · 2024-10-18T09:27:08.000+02:00
diff --git a/src/Analyser/MutatingScope.php b/src/Analyser/MutatingScope.php
@@ -799,7 +799,7 @@ private function resolveType(string $exprString, Expr $node): Type
 			$leftType = $this->getType($node->left);
 			$rightType = $this->getType($node->right);
 
-			return $this->initializerExprTypeResolver->resolveEqualType($leftType, $rightType);
+			return $this->initializerExprTypeResolver->resolveEqualType($leftType, $rightType)->type;
 		}
 
 		if ($node instanceof Expr\BinaryOp\NotEqual) {
@@ -959,7 +959,7 @@ private function resolveType(string $exprString, Expr $node): Type
 				return new BooleanType();
 			}
 
-			return $this->initializerExprTypeResolver->resolveIdenticalType($leftType, $rightType);
+			return $this->initializerExprTypeResolver->resolveIdenticalType($leftType, $rightType)->type;
 		}
 
 		if ($node instanceof Expr\BinaryOp\NotIdentical) {
diff --git a/src/Reflection/InitializerExprTypeResolver.php b/src/Reflection/InitializerExprTypeResolver.php
@@ -65,6 +65,7 @@
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\TypehintHelper;
+use PHPStan\Type\TypeResult;
 use PHPStan\Type\TypeTraverser;
 use PHPStan\Type\TypeUtils;
 use PHPStan\Type\TypeWithClassName;
@@ -298,7 +299,7 @@ public function getType(Expr $expr, InitializerExprContext $context): Type
 			return $this->resolveIdenticalType(
 				$this->getType($expr->left, $context),
 				$this->getType($expr->right, $context),
-			);
+			)->type;
 		}
 
 		if ($expr instanceof BinaryOp\NotIdentical) {
@@ -309,7 +310,7 @@ public function getType(Expr $expr, InitializerExprContext $context): Type
 			return $this->resolveEqualType(
 				$this->getType($expr->left, $context),
 				$this->getType($expr->right, $context),
-			);
+			)->type;
 		}
 
 		if ($expr instanceof BinaryOp\NotEqual) {
@@ -1349,34 +1350,42 @@ public function getShiftRightType(Expr $left, Expr $right, callable $getTypeCall
 		return $this->resolveCommonMath(new Expr\BinaryOp\ShiftRight($left, $right), $leftType, $rightType);
 	}
 
-	public function resolveIdenticalType(Type $leftType, Type $rightType): BooleanType
+	/**
+	 * @return TypeResult<BooleanType>
+	 */
+	public function resolveIdenticalType(Type $leftType, Type $rightType): TypeResult
 	{
 		if ($leftType instanceof NeverType || $rightType instanceof NeverType) {
-			return new ConstantBooleanType(false);
+			return new TypeResult(new ConstantBooleanType(false), []);
 		}
 
 		if ($leftType instanceof ConstantScalarType && $rightType instanceof ConstantScalarType) {
-			return new ConstantBooleanType($leftType->getValue() === $rightType->getValue());
+			return new TypeResult(new ConstantBooleanType($leftType->getValue() === $rightType->getValue()), []);
 		}
 
 		$leftTypeFiniteTypes = $leftType->getFiniteTypes();
 		$rightTypeFiniteType = $rightType->getFiniteTypes();
 		if (count($leftTypeFiniteTypes) === 1 && count($rightTypeFiniteType) === 1) {
-			return new ConstantBooleanType($leftTypeFiniteTypes[0]->equals($rightTypeFiniteType[0]));
+			return new TypeResult(new ConstantBooleanType($leftTypeFiniteTypes[0]->equals($rightTypeFiniteType[0])), []);
 		}
 
-		if ($leftType->isSuperTypeOf($rightType)->no() && $rightType->isSuperTypeOf($leftType)->no()) {
-			return new ConstantBooleanType(false);
+		$leftIsSuperTypeOfRight = $leftType->isSuperTypeOfWithReason($rightType);
+		$rightIsSuperTypeOfLeft = $rightType->isSuperTypeOfWithReason($leftType);
+		if ($leftIsSuperTypeOfRight->no() && $rightIsSuperTypeOfLeft->no()) {
+			return new TypeResult(new ConstantBooleanType(false), array_merge($leftIsSuperTypeOfRight->reasons, $rightIsSuperTypeOfLeft->reasons));
 		}
 
 		if ($leftType instanceof ConstantArrayType && $rightType instanceof ConstantArrayType) {
-			return $this->resolveConstantArrayTypeComparison($leftType, $rightType, fn ($leftValueType, $rightValueType): BooleanType => $this->resolveIdenticalType($leftValueType, $rightValueType));
+			return $this->resolveConstantArrayTypeComparison($leftType, $rightType, fn ($leftValueType, $rightValueType): TypeResult => $this->resolveIdenticalType($leftValueType, $rightValueType));
 		}
 
-		return new BooleanType();
+		return new TypeResult(new BooleanType(), []);
 	}
 
-	public function resolveEqualType(Type $leftType, Type $rightType): BooleanType
+	/**
+	 * @return TypeResult<BooleanType>
+	 */
+	public function resolveEqualType(Type $leftType, Type $rightType): TypeResult
 	{
 		if (
 			($leftType->isEnum()->yes() && $rightType->isTrue()->no())
@@ -1386,16 +1395,17 @@ public function resolveEqualType(Type $leftType, Type $rightType): BooleanType
 		}
 
 		if ($leftType instanceof ConstantArrayType && $rightType instanceof ConstantArrayType) {
-			return $this->resolveConstantArrayTypeComparison($leftType, $rightType, fn ($leftValueType, $rightValueType): BooleanType => $this->resolveEqualType($leftValueType, $rightValueType));
+			return $this->resolveConstantArrayTypeComparison($leftType, $rightType, fn ($leftValueType, $rightValueType): TypeResult => $this->resolveEqualType($leftValueType, $rightValueType));
 		}
 
-		return $leftType->looseCompare($rightType, $this->phpVersion);
+		return new TypeResult($leftType->looseCompare($rightType, $this->phpVersion), []);
 	}
 
 	/**
-	 * @param callable(Type, Type): BooleanType $valueComparisonCallback
+	 * @param callable(Type, Type): TypeResult<BooleanType> $valueComparisonCallback
+	 * @return TypeResult<BooleanType>
 	 */
-	private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType, ConstantArrayType $rightType, callable $valueComparisonCallback): BooleanType
+	private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType, ConstantArrayType $rightType, callable $valueComparisonCallback): TypeResult
 	{
 		$leftKeyTypes = $leftType->getKeyTypes();
 		$rightKeyTypes = $rightType->getKeyTypes();
@@ -1412,7 +1422,7 @@ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType,
 
 			if (count($rightKeyTypes) === 0) {
 				if (!$leftOptional) {
-					return new ConstantBooleanType(false);
+					return new TypeResult(new ConstantBooleanType(false), []);
 				}
 				continue;
 			}
@@ -1425,13 +1435,13 @@ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType,
 					$found = true;
 					break;
 				} elseif (!$rightType->isOptionalKey($j)) {
-					return new ConstantBooleanType(false);
+					return new TypeResult(new ConstantBooleanType(false), []);
 				}
 			}
 
 			if (!$found) {
 				if (!$leftOptional) {
-					return new ConstantBooleanType(false);
+					return new TypeResult(new ConstantBooleanType(false), []);
 				}
 				continue;
 			}
@@ -1448,21 +1458,22 @@ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType,
 				}
 			}
 
-			$leftIdenticalToRight = $valueComparisonCallback($leftValueTypes[$i], $rightValueTypes[$j]);
+			$leftIdenticalToRightResult = $valueComparisonCallback($leftValueTypes[$i], $rightValueTypes[$j]);
+			$leftIdenticalToRight = $leftIdenticalToRightResult->type;
 			if ($leftIdenticalToRight->isFalse()->yes()) {
-				return new ConstantBooleanType(false);
+				return $leftIdenticalToRightResult;
 			}
 			$resultType = TypeCombinator::union($resultType, $leftIdenticalToRight);
 		}
 
 		foreach (array_keys($rightKeyTypes) as $j) {
 			if (!$rightType->isOptionalKey($j)) {
-				return new ConstantBooleanType(false);
+				return new TypeResult(new ConstantBooleanType(false), []);
 			}
 			$resultType = new BooleanType();
 		}
 
-		return $resultType->toBoolean();
+		return new TypeResult($resultType->toBoolean(), []);
 	}
 
 	private function callOperatorTypeSpecifyingExtensions(Expr\BinaryOp $expr, Type $leftType, Type $rightType): ?Type
diff --git a/src/Type/TypeResult.php b/src/Type/TypeResult.php
@@ -0,0 +1,22 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type;
+
+/**
+ * @template-covariant T of Type
+ */
+final class TypeResult
+{
+
+	/**
+	 * @param T $type
+	 * @param list<string> $reasons
+	 */
+	public function __construct(
+		public readonly Type $type,
+		public readonly array $reasons,
+	)
+	{
+	}
+
+}

Original file line number	Diff line number	Diff line change
`@@ -799,7 +799,7 @@ private function resolveType(string $exprString, Expr $node): Type`
`799`	`799`	`$leftType = $this->getType($node->left);`
`800`	`800`	`$rightType = $this->getType($node->right);`
`801`	`801`
`802`		`- return $this->initializerExprTypeResolver->resolveEqualType($leftType, $rightType);`
	`802`	`+ return $this->initializerExprTypeResolver->resolveEqualType($leftType, $rightType)->type;`
`803`	`803`	`}`
`804`	`804`
`805`	`805`	`if ($node instanceof Expr\BinaryOp\NotEqual) {`
`@@ -959,7 +959,7 @@ private function resolveType(string $exprString, Expr $node): Type`
`959`	`959`	`return new BooleanType();`
`960`	`960`	`}`
`961`	`961`
`962`		`- return $this->initializerExprTypeResolver->resolveIdenticalType($leftType, $rightType);`
	`962`	`+ return $this->initializerExprTypeResolver->resolveIdenticalType($leftType, $rightType)->type;`
`963`	`963`	`}`
`964`	`964`
`965`	`965`	`if ($node instanceof Expr\BinaryOp\NotIdentical) {`
Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,7 @@`
`65`	`65`	`use PHPStan\Type\Type;`
`66`	`66`	`use PHPStan\Type\TypeCombinator;`
`67`	`67`	`use PHPStan\Type\TypehintHelper;`
	`68`	`+use PHPStan\Type\TypeResult;`
`68`	`69`	`use PHPStan\Type\TypeTraverser;`
`69`	`70`	`use PHPStan\Type\TypeUtils;`
`70`	`71`	`use PHPStan\Type\TypeWithClassName;`
`@@ -298,7 +299,7 @@ public function getType(Expr $expr, InitializerExprContext $context): Type`
`298`	`299`	`return $this->resolveIdenticalType(`
`299`	`300`	`$this->getType($expr->left, $context),`
`300`	`301`	`$this->getType($expr->right, $context),`
`301`		`- );`
	`302`	`+ )->type;`
`302`	`303`	`}`
`303`	`304`
`304`	`305`	`if ($expr instanceof BinaryOp\NotIdentical) {`
`@@ -309,7 +310,7 @@ public function getType(Expr $expr, InitializerExprContext $context): Type`
`309`	`310`	`return $this->resolveEqualType(`
`310`	`311`	`$this->getType($expr->left, $context),`
`311`	`312`	`$this->getType($expr->right, $context),`
`312`		`- );`
	`313`	`+ )->type;`
`313`	`314`	`}`
`314`	`315`
`315`	`316`	`if ($expr instanceof BinaryOp\NotEqual) {`
`@@ -1349,34 +1350,42 @@ public function getShiftRightType(Expr $left, Expr $right, callable $getTypeCall`
`1349`	`1350`	`return $this->resolveCommonMath(new Expr\BinaryOp\ShiftRight($left, $right), $leftType, $rightType);`
`1350`	`1351`	`}`
`1351`	`1352`
`1352`		`- public function resolveIdenticalType(Type $leftType, Type $rightType): BooleanType`
	`1353`	`+ /**`
	`1354`	`+ * @return TypeResult<BooleanType>`
	`1355`	`+ */`
	`1356`	`+ public function resolveIdenticalType(Type $leftType, Type $rightType): TypeResult`
`1353`	`1357`	`{`
`1354`	`1358`	`if ($leftType instanceof NeverType \|\| $rightType instanceof NeverType) {`
`1355`		`- return new ConstantBooleanType(false);`
	`1359`	`+ return new TypeResult(new ConstantBooleanType(false), []);`
`1356`	`1360`	`}`
`1357`	`1361`
`1358`	`1362`	`if ($leftType instanceof ConstantScalarType && $rightType instanceof ConstantScalarType) {`
`1359`		`- return new ConstantBooleanType($leftType->getValue() === $rightType->getValue());`
	`1363`	`+ return new TypeResult(new ConstantBooleanType($leftType->getValue() === $rightType->getValue()), []);`
`1360`	`1364`	`}`
`1361`	`1365`
`1362`	`1366`	`$leftTypeFiniteTypes = $leftType->getFiniteTypes();`
`1363`	`1367`	`$rightTypeFiniteType = $rightType->getFiniteTypes();`
`1364`	`1368`	`if (count($leftTypeFiniteTypes) === 1 && count($rightTypeFiniteType) === 1) {`
`1365`		`- return new ConstantBooleanType($leftTypeFiniteTypes[0]->equals($rightTypeFiniteType[0]));`
	`1369`	`+ return new TypeResult(new ConstantBooleanType($leftTypeFiniteTypes[0]->equals($rightTypeFiniteType[0])), []);`
`1366`	`1370`	`}`
`1367`	`1371`
`1368`		`- if ($leftType->isSuperTypeOf($rightType)->no() && $rightType->isSuperTypeOf($leftType)->no()) {`
`1369`		`- return new ConstantBooleanType(false);`
	`1372`	`+ $leftIsSuperTypeOfRight = $leftType->isSuperTypeOfWithReason($rightType);`
	`1373`	`+ $rightIsSuperTypeOfLeft = $rightType->isSuperTypeOfWithReason($leftType);`
	`1374`	`+ if ($leftIsSuperTypeOfRight->no() && $rightIsSuperTypeOfLeft->no()) {`
	`1375`	`+ return new TypeResult(new ConstantBooleanType(false), array_merge($leftIsSuperTypeOfRight->reasons, $rightIsSuperTypeOfLeft->reasons));`
`1370`	`1376`	`}`
`1371`	`1377`
`1372`	`1378`	`if ($leftType instanceof ConstantArrayType && $rightType instanceof ConstantArrayType) {`
`1373`		`- return $this->resolveConstantArrayTypeComparison($leftType, $rightType, fn ($leftValueType, $rightValueType): BooleanType => $this->resolveIdenticalType($leftValueType, $rightValueType));`
	`1379`	`+ return $this->resolveConstantArrayTypeComparison($leftType, $rightType, fn ($leftValueType, $rightValueType): TypeResult => $this->resolveIdenticalType($leftValueType, $rightValueType));`
`1374`	`1380`	`}`
`1375`	`1381`
`1376`		`- return new BooleanType();`
	`1382`	`+ return new TypeResult(new BooleanType(), []);`
`1377`	`1383`	`}`
`1378`	`1384`
`1379`		`- public function resolveEqualType(Type $leftType, Type $rightType): BooleanType`
	`1385`	`+ /**`
	`1386`	`+ * @return TypeResult<BooleanType>`
	`1387`	`+ */`
	`1388`	`+ public function resolveEqualType(Type $leftType, Type $rightType): TypeResult`
`1380`	`1389`	`{`
`1381`	`1390`	`if (`
`1382`	`1391`	`($leftType->isEnum()->yes() && $rightType->isTrue()->no())`
`@@ -1386,16 +1395,17 @@ public function resolveEqualType(Type $leftType, Type $rightType): BooleanType`
`1386`	`1395`	`}`
`1387`	`1396`
`1388`	`1397`	`if ($leftType instanceof ConstantArrayType && $rightType instanceof ConstantArrayType) {`
`1389`		`- return $this->resolveConstantArrayTypeComparison($leftType, $rightType, fn ($leftValueType, $rightValueType): BooleanType => $this->resolveEqualType($leftValueType, $rightValueType));`
	`1398`	`+ return $this->resolveConstantArrayTypeComparison($leftType, $rightType, fn ($leftValueType, $rightValueType): TypeResult => $this->resolveEqualType($leftValueType, $rightValueType));`
`1390`	`1399`	`}`
`1391`	`1400`
`1392`		`- return $leftType->looseCompare($rightType, $this->phpVersion);`
	`1401`	`+ return new TypeResult($leftType->looseCompare($rightType, $this->phpVersion), []);`
`1393`	`1402`	`}`
`1394`	`1403`
`1395`	`1404`	`/**`
`1396`		`- * @param callable(Type, Type): BooleanType $valueComparisonCallback`
	`1405`	`+ * @param callable(Type, Type): TypeResult<BooleanType> $valueComparisonCallback`
	`1406`	`+ * @return TypeResult<BooleanType>`
`1397`	`1407`	`*/`
`1398`		`- private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType, ConstantArrayType $rightType, callable $valueComparisonCallback): BooleanType`
	`1408`	`+ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType, ConstantArrayType $rightType, callable $valueComparisonCallback): TypeResult`
`1399`	`1409`	`{`
`1400`	`1410`	`$leftKeyTypes = $leftType->getKeyTypes();`
`1401`	`1411`	`$rightKeyTypes = $rightType->getKeyTypes();`
`@@ -1412,7 +1422,7 @@ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType,`
`1412`	`1422`
`1413`	`1423`	`if (count($rightKeyTypes) === 0) {`
`1414`	`1424`	`if (!$leftOptional) {`
`1415`		`- return new ConstantBooleanType(false);`
	`1425`	`+ return new TypeResult(new ConstantBooleanType(false), []);`
`1416`	`1426`	`}`
`1417`	`1427`	`continue;`
`1418`	`1428`	`}`
`@@ -1425,13 +1435,13 @@ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType,`
`1425`	`1435`	`$found = true;`
`1426`	`1436`	`break;`
`1427`	`1437`	`} elseif (!$rightType->isOptionalKey($j)) {`
`1428`		`- return new ConstantBooleanType(false);`
	`1438`	`+ return new TypeResult(new ConstantBooleanType(false), []);`
`1429`	`1439`	`}`
`1430`	`1440`	`}`
`1431`	`1441`
`1432`	`1442`	`if (!$found) {`
`1433`	`1443`	`if (!$leftOptional) {`
`1434`		`- return new ConstantBooleanType(false);`
	`1444`	`+ return new TypeResult(new ConstantBooleanType(false), []);`
`1435`	`1445`	`}`
`1436`	`1446`	`continue;`
`1437`	`1447`	`}`
`@@ -1448,21 +1458,22 @@ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType,`
`1448`	`1458`	`}`
`1449`	`1459`	`}`
`1450`	`1460`
`1451`		`- $leftIdenticalToRight = $valueComparisonCallback($leftValueTypes[$i], $rightValueTypes[$j]);`
	`1461`	`+ $leftIdenticalToRightResult = $valueComparisonCallback($leftValueTypes[$i], $rightValueTypes[$j]);`
	`1462`	`+ $leftIdenticalToRight = $leftIdenticalToRightResult->type;`
`1452`	`1463`	`if ($leftIdenticalToRight->isFalse()->yes()) {`
`1453`		`- return new ConstantBooleanType(false);`
	`1464`	`+ return $leftIdenticalToRightResult;`
`1454`	`1465`	`}`
`1455`	`1466`	`$resultType = TypeCombinator::union($resultType, $leftIdenticalToRight);`
`1456`	`1467`	`}`
`1457`	`1468`
`1458`	`1469`	`foreach (array_keys($rightKeyTypes) as $j) {`
`1459`	`1470`	`if (!$rightType->isOptionalKey($j)) {`
`1460`		`- return new ConstantBooleanType(false);`
	`1471`	`+ return new TypeResult(new ConstantBooleanType(false), []);`
`1461`	`1472`	`}`
`1462`	`1473`	`$resultType = new BooleanType();`
`1463`	`1474`	`}`
`1464`	`1475`
`1465`		`- return $resultType->toBoolean();`
	`1476`	`+ return new TypeResult($resultType->toBoolean(), []);`
`1466`	`1477`	`}`
`1467`	`1478`
`1468`	`1479`	`private function callOperatorTypeSpecifyingExtensions(Expr\BinaryOp $expr, Type $leftType, Type $rightType): ?Type`