Improve in_array extension to get rid of related impossible check adaptions

src/Rules/Comparison/ImpossibleCheckTypeHelper.php

@@ -12,14 +12,10 @@
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\TrinaryLogic;
-use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\Constant\ConstantStringType;
-use PHPStan\Type\MixedType;
-use PHPStan\Type\NeverType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
-use PHPStan\Type\TypeUtils;
 use PHPStan\Type\TypeWithClassName;
 use PHPStan\Type\VerbosityLevel;
 use function array_map;
@@ -77,65 +73,6 @@ public function findSpecifiedType(
 					return null;
 				} elseif ($functionName === 'array_search') {
 					return null;
-				} elseif ($functionName === 'in_array' && $argsCount >= 3) {
-					$haystackType = $scope->getType($node->getArgs()[1]->value);
-					if ($haystackType instanceof MixedType) {
-						return null;
-					}
-
-					if (!$haystackType->isArray()->yes()) {
-						return null;
-					}
-
-					$constantArrays = TypeUtils::getOldConstantArrays($haystackType);
-					$needleType = $scope->getType($node->getArgs()[0]->value);
-					$valueType = $haystackType->getIterableValueType();
-					$constantNeedleTypesCount = count(TypeUtils::getConstantScalars($needleType));
-					$constantHaystackTypesCount = count(TypeUtils::getConstantScalars($valueType));
-					$isNeedleSupertype = $needleType->isSuperTypeOf($valueType);
-					if (count($constantArrays) === 0) {
-						if ($haystackType->isIterableAtLeastOnce()->yes()) {
-							if ($constantNeedleTypesCount === 1 && $constantHaystackTypesCount === 1) {
-								if ($isNeedleSupertype->yes()) {
-									return true;
-								}
-								if ($isNeedleSupertype->no()) {
-									return false;
-								}
-							}
-						}
-						return null;
-					}
-
-					if (!$haystackType instanceof ConstantArrayType || count($haystackType->getValueTypes()) > 0) {
-						$haystackArrayTypes = TypeUtils::getArrays($haystackType);
-						if (count($haystackArrayTypes) === 1 && $haystackArrayTypes[0]->getIterableValueType() instanceof NeverType) {
-							return null;
-						}
-
-						if ($isNeedleSupertype->maybe() || $isNeedleSupertype->yes()) {
-							foreach ($haystackArrayTypes as $haystackArrayType) {
-								foreach (TypeUtils::getConstantScalars($haystackArrayType->getIterableValueType()) as $constantScalarType) {
-									if ($constantScalarType->isSuperTypeOf($needleType)->yes()) {
-										continue 2;
-									}
-								}
-
-								return null;
-							}
-						}
-
-						if ($isNeedleSupertype->yes()) {
-							$hasConstantNeedleTypes = $constantNeedleTypesCount > 0;
-							$hasConstantHaystackTypes = $constantHaystackTypesCount > 0;
-							if (
-								(!$hasConstantNeedleTypes && !$hasConstantHaystackTypes)
-								|| $hasConstantNeedleTypes !== $hasConstantHaystackTypes
-							) {
-								return null;
-							}
-						}
-					}
 				} elseif ($functionName === 'method_exists' && $argsCount >= 2) {
 					$objectType = $scope->getType($node->getArgs()[0]->value);
 					$methodType = $scope->getType($node->getArgs()[1]->value);

src/Type/Accessory/HasOffsetType.php

@@ -33,9 +33,12 @@ class HasOffsetType implements CompoundType, AccessoryType
 	use NonRemoveableTypeTrait;
 	use NonGeneralizableTypeTrait;
 
+	private Type $offsetValueType;
+
 	/** @api */
-	public function __construct(private Type $offsetType)
+	public function __construct(private Type $offsetType, ?Type $offsetValueType = null)
 	{
+		$this->offsetValueType = $offsetValueType ?? new MixedType();
 	}
 
 	public function getOffsetType(): Type
@@ -64,7 +67,8 @@ public function isSuperTypeOf(Type $type): TrinaryLogic
 			return TrinaryLogic::createYes();
 		}
 		return $type->isOffsetAccessible()
-			->and($type->hasOffsetValueType($this->offsetType));
+			->and($type->hasOffsetValueType($this->offsetType))
+			->and($this->offsetValueType->isSuperTypeOf($type->getOffsetValueType($this->offsetType)));
 	}
 
 	public function isSubTypeOf(Type $otherType): TrinaryLogic
@@ -110,7 +114,7 @@ public function hasOffsetValueType(Type $offsetType): TrinaryLogic
 
 	public function getOffsetValueType(Type $offsetType): Type
 	{
-		return new MixedType();
+		return $offsetType->equals($this->offsetType) ? $this->offsetValueType : new ErrorType();
 	}
 
 	public function setOffsetValueType(?Type $offsetType, Type $valueType, bool $unionValues = true): Type

src/Type/Php/InArrayFunctionTypeSpecifyingExtension.php

@@ -9,9 +9,12 @@
 use PHPStan\Analyser\TypeSpecifierAwareExtension;
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Type\Accessory\HasOffsetType;
 use PHPStan\Type\Accessory\NonEmptyArrayType;
 use PHPStan\Type\ArrayType;
+use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantBooleanType;
+use PHPStan\Type\ConstantScalarType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\TypeCombinator;
@@ -56,6 +59,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 			|| count(TypeUtils::getConstantScalars($arrayValueType)) > 0
 			|| count(TypeUtils::getEnumCaseObjects($arrayValueType)) > 0
 		) {
+			// Specify needle type
 			$specifiedTypes = $this->typeSpecifier->create(
 				$node->getArgs()[0]->value,
 				$arrayValueType,
@@ -65,27 +69,44 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 			);
 		}
 
+		// "Simple" all constant cases that always evaluate to true still need a nudge (e.g. needle 'foo' in haystack {'foo', 'bar'})
+		if ($arrayType instanceof ConstantArrayType && $needleType instanceof ConstantScalarType) {
+			foreach ($arrayType->getValueTypes() as $i => $valueType) {
+				if (!$arrayType->isOptionalKey($i) && $valueType->equals($needleType)) {
+					return $specifiedTypes;
+				}
+			}
+		}
+
+		// If e.g. needle is 'a' and haystack non-empty-array<int, 'a'> we can be sure that this always evaluates to true
+		// Belows HasOffset::isSuperTypeOf cannot deal with that since it calls ArrayType::hasOffsetValueType and that returns maybe at max
+		if ($needleType instanceof ConstantScalarType && $arrayType->isIterableAtLeastOnce()->yes() && $arrayValueType->equals($needleType)) {
+			return $specifiedTypes;
+		}
+
 		if (
 			$context->truthy()
 			|| count(TypeUtils::getConstantScalars($needleType)) > 0
 			|| count(TypeUtils::getEnumCaseObjects($needleType)) > 0
 		) {
+			// Specify haystack type
 			if ($context->truthy()) {
-				$arrayType = TypeCombinator::intersect(
+				$newArrayType = TypeCombinator::intersect(
 					new ArrayType(new MixedType(), TypeCombinator::union($arrayValueType, $needleType)),
+					new HasOffsetType(new MixedType(), $needleType),
 					new NonEmptyArrayType(),
 				);
 			} else {
-				$arrayType = new ArrayType(new MixedType(), TypeCombinator::remove($arrayValueType, $needleType));
+				$newArrayType = new ArrayType(new MixedType(), TypeCombinator::remove($arrayValueType, $needleType));
 			}
 
-				$specifiedTypes = $specifiedTypes->unionWith($this->typeSpecifier->create(
-					$node->getArgs()[1]->value,
-					$arrayType,
-					TypeSpecifierContext::createTrue(),
-					false,
-					$scope,
-				));
+			$specifiedTypes = $specifiedTypes->unionWith($this->typeSpecifier->create(
+				$node->getArgs()[1]->value,
+				$newArrayType,
+				TypeSpecifierContext::createTrue(),
+				false,
+				$scope,
+			));
 		}
 
 		return $specifiedTypes;

tests/PHPStan/Analyser/data/in-array-non-empty.php

@@ -14,15 +14,15 @@ class HelloWorld
 	public function sayHello(array $array): void
 	{
 		if(in_array("thing", $array, true)){
-			assertType('non-empty-array<int, string>', $array);
+			assertType('non-empty-array<int, string>&hasOffset(mixed)', $array);
 		}
 	}
 
 	/** @param array<int> $haystack */
 	public function nonConstantNeedle(int $needle, array $haystack): void
 	{
 		if (in_array($needle, $haystack, true)) {
-			assertType('non-empty-array<int>', $haystack);
+			assertType('non-empty-array<int>&hasOffset(mixed)', $haystack);
 		}
 	}
 }

tests/PHPStan/Analyser/data/in-array.php

@@ -10,12 +10,14 @@ class Foo
 	 * @param string $r
 	 * @param $mixed
 	 * @param string[] $strings
+	 * @param string[] $moreStrings
 	 */
 	public function doFoo(
 		string $s,
 		string $r,
 		$mixed,
-		array $strings
+		array $strings,
+		array $moreStrings
 	)
 	{
 		if (!in_array($s, ['foo', 'bar'], true)) {
@@ -26,7 +28,7 @@ public function doFoo(
 			return;
 		}
 
-		if (in_array($r, $strings, true)) {
+		if (in_array($r, $moreStrings, true)) {
 			return;
 		}
 

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php

@@ -233,6 +233,18 @@ public function testImpossibleCheckTypeFunctionCall(): void
 					'Call to function property_exists() with CheckTypeFunctionCall\Bug2221 and \'foo\' will always evaluate to true.',
 					786,
 				],
+				[
+					'Call to function in_array() with arguments \'foo\', non-empty-array<string> and true will always evaluate to true.',
+					890,
+				],
+				[
+					'Call to function in_array() with arguments \'foo\', array{0?: \'foo\'}&non-empty-array and true will always evaluate to true.',
+					896,
+				],
+				[
+					'Call to function in_array() with arguments \'foo\', array{0?: *NEVER*} and true will always evaluate to false.',
+					900,
+				],
 			],
 		);
 	}
@@ -329,6 +341,10 @@ public function testImpossibleCheckTypeFunctionCallWithoutAlwaysTrue(): void
 					'Call to function is_numeric() with \'blabla\' will always evaluate to false.',
 					693,
 				],
+				[
+					'Call to function in_array() with arguments \'foo\', array{0?: *NEVER*} and true will always evaluate to false.',
+					900,
+				],
 			],
 		);
 	}
@@ -483,6 +499,10 @@ public function testBugInArrayDateFormat(): void
 				'Call to function in_array() with arguments int, array{} and true will always evaluate to false.',
 				47,
 			],
+			[
+				'Call to function in_array() with arguments int, array<int, string> and true will always evaluate to false.',
+				61,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Comparison/data/check-type-function-call.php

@@ -860,3 +860,47 @@ public function doFoo(int $i, array $is): void
 	}
 
 }
+
+class InArray2
+{
+
+	/** @param non-empty-array<int, int> $haystack */
+	public function nonConstants(int $needle, array $haystack): void
+	{
+		if (in_array($needle, $haystack, true)) { // bool
+
+		}
+	}
+
+	/** @param array{'self', string} $haystack */
+	public function slevomatCsBug(string $needle, array $haystack): void
+	{
+		if (in_array($needle, $haystack, true)) { // bool
+
+		}
+	}
+
+	/**
+	 * @param array<string> $genericHaystack
+	 * @param array{0?: 'foo'} $constantHaystack
+	 */
+	public function triggersIfArrayIsNarrowedDownTwiceWithConstant(array $genericHaystack, array $constantHaystack): void
+	{
+		if (in_array('foo', $genericHaystack, true)) { // bool
+			if (in_array('foo', $genericHaystack, true)) { // true
+
+			}
+		}
+
+		if (in_array('foo', $constantHaystack, true)) { // bool
+			if (in_array('foo', $constantHaystack, true)) { // true
+
+			}
+		} else {
+			if (in_array('foo', $constantHaystack, true)) { // false
+
+			}
+		}
+	}
+
+}