Improve array_search inference

VincentLanglet · VincentLanglet · commit 8e55d6d161a1 · 2025-07-17T17:05:31.000+02:00
diff --git a/src/Type/Accessory/AccessoryArrayListType.php b/src/Type/Accessory/AccessoryArrayListType.php
@@ -225,7 +225,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return new MixedType();
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		return new MixedType();
 	}
diff --git a/src/Type/Accessory/HasOffsetValueType.php b/src/Type/Accessory/HasOffsetValueType.php
@@ -250,11 +250,15 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return new NonEmptyArrayType();
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		if (
 			$needleType instanceof ConstantScalarType && $this->valueType instanceof ConstantScalarType
-			&& $needleType->getValue() === $this->valueType->getValue()
+			&& (
+				$needleType->getValue() === $this->valueType->getValue()
+				// @phpstan-ignore equal.notAllowed
+				|| ($strict->no() && $needleType->getValue() == $this->valueType->getValue()) // phpcs:ignore
+			)
 		) {
 			return new UnionType([
 				new IntegerType(),
diff --git a/src/Type/Accessory/NonEmptyArrayType.php b/src/Type/Accessory/NonEmptyArrayType.php
@@ -204,7 +204,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return $this;
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		return new MixedType();
 	}
diff --git a/src/Type/Accessory/OversizedArrayType.php b/src/Type/Accessory/OversizedArrayType.php
@@ -199,7 +199,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return $this;
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		return new MixedType();
 	}
diff --git a/src/Type/ArrayType.php b/src/Type/ArrayType.php
@@ -430,8 +430,12 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return $this;
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
+		if ($strict->yes() && $this->getIterableValueType()->isSuperTypeOf($needleType)->no()) {
+			return new ConstantBooleanType(false);
+		}
+
 		return TypeCombinator::union($this->getIterableKeyType(), new ConstantBooleanType(false));
 	}
 
diff --git a/src/Type/Constant/ConstantArrayType.php b/src/Type/Constant/ConstantArrayType.php
@@ -881,22 +881,31 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return $builder->getArray();
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		$matches = [];
 		$hasIdenticalValue = false;
 
 		foreach ($this->valueTypes as $index => $valueType) {
-			$isNeedleSuperType = $valueType->isSuperTypeOf($needleType);
-			if ($isNeedleSuperType->no()) {
-				continue;
+			if ($strict->yes()) {
+				$isNeedleSuperType = $valueType->isSuperTypeOf($needleType);
+				if ($isNeedleSuperType->no()) {
+					continue;
+				}
 			}
 
-			if ($needleType instanceof ConstantScalarType && $valueType instanceof ConstantScalarType
-				&& $needleType->getValue() === $valueType->getValue()
-				&& !$this->isOptionalKey($index)
-			) {
-				$hasIdenticalValue = true;
+			if ($needleType instanceof ConstantScalarType && $valueType instanceof ConstantScalarType) {
+				// @phpstan-ignore equal.notAllowed
+				$isLooseEqual = $needleType->getValue() == $valueType->getValue(); // phpcs:ignore
+				if (!$isLooseEqual) {
+					continue;
+				}
+				if (
+					($strict->no() || $needleType->getValue() === $valueType->getValue())
+					&& !$this->isOptionalKey($index)
+				) {
+					$hasIdenticalValue = true;
+				}
 			}
 
 			$matches[] = $this->keyTypes[$index];
diff --git a/src/Type/IntersectionType.php b/src/Type/IntersectionType.php
@@ -887,9 +887,9 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return $this->intersectTypes(static fn (Type $type): Type => $type->reverseArray($preserveKeys));
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
-		return $this->intersectTypes(static fn (Type $type): Type => $type->searchArray($needleType));
+		return $this->intersectTypes(static fn (Type $type): Type => $type->searchArray($needleType, $strict));
 	}
 
 	public function shiftArray(): Type
diff --git a/src/Type/MixedType.php b/src/Type/MixedType.php
@@ -257,7 +257,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return new ArrayType(new MixedType($this->isExplicitMixed), new MixedType($this->isExplicitMixed));
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		if ($this->isArray()->no()) {
 			return new ErrorType();
diff --git a/src/Type/NeverType.php b/src/Type/NeverType.php
@@ -318,7 +318,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return new NeverType();
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		return new NeverType();
 	}
diff --git a/src/Type/Php/ArraySearchFunctionDynamicReturnTypeExtension.php b/src/Type/Php/ArraySearchFunctionDynamicReturnTypeExtension.php
@@ -12,7 +12,6 @@
 use PHPStan\Type\NeverType;
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
-use PHPStan\Type\TypeCombinator;
 use function count;
 
 #[AutowiredService]
@@ -41,20 +40,14 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		}
 
 		if ($argsCount < 3) {
-			return TypeCombinator::union($haystackArgType->getIterableKeyType(), new ConstantBooleanType(false));
-		}
-
-		$strictArgType = $scope->getType($functionCall->getArgs()[2]->value);
-		if (!$strictArgType->isTrue()->yes()) {
-			return TypeCombinator::union($haystackArgType->getIterableKeyType(), new ConstantBooleanType(false));
+			$strictArgType = new ConstantBooleanType(false);
+		} else {
+			$strictArgType = $scope->getType($functionCall->getArgs()[2]->value);
 		}
 
 		$needleArgType = $scope->getType($functionCall->getArgs()[0]->value);
-		if ($haystackArgType->getIterableValueType()->isSuperTypeOf($needleArgType)->no()) {
-			return new ConstantBooleanType(false);
-		}
 
-		return $haystackArgType->searchArray($needleArgType);
+		return $haystackArgType->searchArray($needleArgType, $strictArgType->isTrue());
 	}
 
 }
diff --git a/src/Type/StaticType.php b/src/Type/StaticType.php
@@ -440,9 +440,9 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return $this->getStaticObjectType()->reverseArray($preserveKeys);
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
-		return $this->getStaticObjectType()->searchArray($needleType);
+		return $this->getStaticObjectType()->searchArray($needleType, $strict);
 	}
 
 	public function shiftArray(): Type
diff --git a/src/Type/Traits/LateResolvableTypeTrait.php b/src/Type/Traits/LateResolvableTypeTrait.php
@@ -293,9 +293,9 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return $this->resolve()->reverseArray($preserveKeys);
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
-		return $this->resolve()->searchArray($needleType);
+		return $this->resolve()->searchArray($needleType, $strict);
 	}
 
 	public function shiftArray(): Type
diff --git a/src/Type/Traits/MaybeArrayTypeTrait.php b/src/Type/Traits/MaybeArrayTypeTrait.php
@@ -84,7 +84,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return new ErrorType();
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		return new ErrorType();
 	}
diff --git a/src/Type/Traits/NonArrayTypeTrait.php b/src/Type/Traits/NonArrayTypeTrait.php
@@ -84,7 +84,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return new ErrorType();
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
 		return new ErrorType();
 	}
diff --git a/src/Type/Type.php b/src/Type/Type.php
@@ -152,7 +152,7 @@ public function popArray(): Type;
 
 	public function reverseArray(TrinaryLogic $preserveKeys): Type;
 
-	public function searchArray(Type $needleType): Type;
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type;
 
 	public function shiftArray(): Type;
 
diff --git a/src/Type/UnionType.php b/src/Type/UnionType.php
@@ -776,9 +776,9 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type
 		return $this->unionTypes(static fn (Type $type): Type => $type->reverseArray($preserveKeys));
 	}
 
-	public function searchArray(Type $needleType): Type
+	public function searchArray(Type $needleType, TrinaryLogic $strict): Type
 	{
-		return $this->unionTypes(static fn (Type $type): Type => $type->searchArray($needleType));
+		return $this->unionTypes(static fn (Type $type): Type => $type->searchArray($needleType, $strict));
 	}
 
 	public function shiftArray(): Type
diff --git a/tests/PHPStan/Analyser/nsrt/array-search.php b/tests/PHPStan/Analyser/nsrt/array-search.php
@@ -30,7 +30,7 @@ public function normalArrays(array $arr, string $string): void
 
 		if (array_key_exists(17, $arr) && $arr[17] === 'foo') {
 			assertType('int', array_search('foo', $arr, true));
-			assertType('int|false', array_search('foo', $arr));
+			assertType('int', array_search('foo', $arr));
 			assertType('int|false', array_search($string, $arr, true));
 		}
 	}
@@ -39,25 +39,33 @@ public function constantArrays(array $arr, string $string): void
 	{
 		/** @var array{'a', 'b', 'c'} $arr */
 		assertType('1', array_search('b', $arr, true));
-		assertType('0|1|2|false', array_search('b', $arr));
+		assertType('1', array_search('b', $arr));
 		assertType('0|1|2|false', array_search($string, $arr, true));
+		assertType('0|1|2|false', array_search($string, $arr, false));
 
 		/** @var array{} $arr */
 		assertType('false', array_search('b', $arr, true));
 		assertType('false', array_search('b', $arr));
 		assertType('false', array_search($string, $arr, true));
+		assertType('false', array_search($string, $arr, false));
+
+		/** @var array{1, '1', '2'} $arr */
+		assertType('1', array_search('1', $arr, true));
+		assertType('0|1', array_search('1', $arr));
+		assertType('1|2|false', array_search($string, $arr, true));
+		assertType('0|1|2|false', array_search($string, $arr, false));
 	}
 
 	public function constantArraysWithOptionalKeys(array $arr, string $string): void
 	{
 		/** @var array{0: 'a', 1?: 'b', 2: 'c'} $arr */
 		assertType('1|false', array_search('b', $arr, true));
-		assertType('0|1|2|false', array_search('b', $arr));
+		assertType('1|false', array_search('b', $arr));
 		assertType('0|1|2|false', array_search($string, $arr, true));
 
 		/** @var array{0: 'a', 1?: 'b', 2: 'b'} $arr */
 		assertType('1|2', array_search('b', $arr, true));
-		assertType('0|1|2|false', array_search('b', $arr));
+		assertType('1|2', array_search('b', $arr));
 		assertType('0|1|2|false', array_search($string, $arr, true));
 	}
 
diff --git a/tests/PHPStan/Analyser/nsrt/bug-3789.php b/tests/PHPStan/Analyser/nsrt/bug-3789.php
@@ -19,5 +19,5 @@ function doFoo(string $needle, array $haystack): void {
 	assertType('0|1|2', array_search('foo', $haystack, true));
 
 	assertType('0|1|2|false', array_search($needle, $haystack));
-	assertType('0|1|2|false', array_search('foo', $haystack));
+	assertType('0|1|2', array_search('foo', $haystack));
 }
diff --git a/tests/PHPStan/Analyser/nsrt/bug-7809.php b/tests/PHPStan/Analyser/nsrt/bug-7809.php
@@ -6,13 +6,13 @@
 use function PHPStan\Testing\assertType;
 
 function foo(bool $strict = false): void {
-	assertType('0|1|2|false', array_search('c', ['a', 'b', 'c'], $strict));
+	assertType('2', array_search('c', ['a', 'b', 'c'], $strict));
 }
 
 function bar(): void{
 	assertType('2', array_search('c', ['a', 'b', 'c'], true));
 }
 
 function baz(): void{
-	assertType('0|1|2|false', array_search('c', ['a', 'b', 'c'], false));
+	assertType('2', array_search('c', ['a', 'b', 'c'], false));
 }

Original file line number	Diff line number	Diff line change
`@@ -225,7 +225,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type`
`225`	`225`	`return new MixedType();`
`226`	`226`	`}`
`227`	`227`
`228`		`- public function searchArray(Type $needleType): Type`
	`228`	`+ public function searchArray(Type $needleType, TrinaryLogic $strict): Type`
`229`	`229`	`{`
`230`	`230`	`return new MixedType();`
`231`	`231`	`}`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type`
`204`	`204`	`return $this;`
`205`	`205`	`}`
`206`	`206`
`207`		`- public function searchArray(Type $needleType): Type`
	`207`	`+ public function searchArray(Type $needleType, TrinaryLogic $strict): Type`
`208`	`208`	`{`
`209`	`209`	`return new MixedType();`
`210`	`210`	`}`
Original file line number	Diff line number	Diff line change
`@@ -199,7 +199,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type`
`199`	`199`	`return $this;`
`200`	`200`	`}`
`201`	`201`
`202`		`- public function searchArray(Type $needleType): Type`
	`202`	`+ public function searchArray(Type $needleType, TrinaryLogic $strict): Type`
`203`	`203`	`{`
`204`	`204`	`return new MixedType();`
`205`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -430,8 +430,12 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type`
`430`	`430`	`return $this;`
`431`	`431`	`}`
`432`	`432`
`433`		`- public function searchArray(Type $needleType): Type`
	`433`	`+ public function searchArray(Type $needleType, TrinaryLogic $strict): Type`
`434`	`434`	`{`
	`435`	`+ if ($strict->yes() && $this->getIterableValueType()->isSuperTypeOf($needleType)->no()) {`
	`436`	`+ return new ConstantBooleanType(false);`
	`437`	`+ }`
	`438`	`+`
`435`	`439`	`return TypeCombinator::union($this->getIterableKeyType(), new ConstantBooleanType(false));`
`436`	`440`	`}`
`437`	`441`
Original file line number	Diff line number	Diff line change
`@@ -887,9 +887,9 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type`
`887`	`887`	`return $this->intersectTypes(static fn (Type $type): Type => $type->reverseArray($preserveKeys));`
`888`	`888`	`}`
`889`	`889`
`890`		`- public function searchArray(Type $needleType): Type`
	`890`	`+ public function searchArray(Type $needleType, TrinaryLogic $strict): Type`
`891`	`891`	`{`
`892`		`- return $this->intersectTypes(static fn (Type $type): Type => $type->searchArray($needleType));`
	`892`	`+ return $this->intersectTypes(static fn (Type $type): Type => $type->searchArray($needleType, $strict));`
`893`	`893`	`}`
`894`	`894`
`895`	`895`	`public function shiftArray(): Type`
Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type`
`257`	`257`	`return new ArrayType(new MixedType($this->isExplicitMixed), new MixedType($this->isExplicitMixed));`
`258`	`258`	`}`
`259`	`259`
`260`		`- public function searchArray(Type $needleType): Type`
	`260`	`+ public function searchArray(Type $needleType, TrinaryLogic $strict): Type`
`261`	`261`	`{`
`262`	`262`	`if ($this->isArray()->no()) {`
`263`	`263`	`return new ErrorType();`
Original file line number	Diff line number	Diff line change
`@@ -318,7 +318,7 @@ public function reverseArray(TrinaryLogic $preserveKeys): Type`
`318`	`318`	`return new NeverType();`
`319`	`319`	`}`
`320`	`320`
`321`		`- public function searchArray(Type $needleType): Type`
	`321`	`+ public function searchArray(Type $needleType, TrinaryLogic $strict): Type`
`322`	`322`	`{`
`323`	`323`	`return new NeverType();`
`324`	`324`	`}`