Put backed enum from()/tryFrom() parameter type behind bleeding edge

conf/bleedingEdge.neon

@@ -30,5 +30,6 @@ parameters:
 		unresolvedTemplateArguments: true
 		closureSignaturesFromUsages: true
 		staticVariablesFromUsages: true
+		backedEnumFromParameterType: true
 		unusedVariable: true
 		unusedParameters: true

conf/config.neon

@@ -62,6 +62,7 @@ parameters:
 		unresolvedTemplateArguments: false
 		closureSignaturesFromUsages: false
 		staticVariablesFromUsages: false
+		backedEnumFromParameterType: false
 		unusedVariable: false
 		unusedParameters: false
 	fileExtensions:

conf/parametersSchema.neon

@@ -59,6 +59,7 @@ parametersSchema:
 		unresolvedTemplateArguments: bool()
 		closureSignaturesFromUsages: bool()
 		staticVariablesFromUsages: bool()
+		backedEnumFromParameterType: bool()
 		unusedVariable: bool()
 		unusedParameters: bool()
 	])

src/Reflection/Php/PhpClassReflectionExtension.php

@@ -126,6 +126,8 @@ public function __construct(
 		#[AutowiredParameter]
 		private bool $inferPrivatePropertyTypeFromConstructor,
 		private PhpVersion $phpVersion,
+		#[AutowiredParameter(ref: '%featureToggles.backedEnumFromParameterType%')]
+		private bool $backedEnumFromParameterType,
 		#[AutowiredParameter(ref: '%cache.memberCacheKeysMax%')]
 		int $memberCacheKeysMax,
 	)
@@ -803,7 +805,7 @@ private function createMethod(
 			$this->findMethodTrait($methodReflection),
 		);
 
-		if (in_array(strtolower($methodReflection->getName()), ['from', 'tryfrom'], true)) {
+		if ($this->backedEnumFromParameterType && in_array(strtolower($methodReflection->getName()), ['from', 'tryfrom'], true)) {
 			$backedEnumType = $declaringClass->getBackedEnumType();
 			if ($backedEnumType !== null) {
 				return new BackedEnumFromMethodReflection($method, $backedEnumType);

tests/PHPStan/Reflection/Php/BackedEnumFromParameterTypeToggleOffTest.php

@@ -0,0 +1,45 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Reflection\Php;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\RequiresPhp;
+use function array_merge;
+
+/**
+ * With backedEnumFromParameterType off, from() and tryFrom() of a backed
+ * enum keep the int|string parameter reflection declares.
+ */
+#[RequiresPhp('>= 8.1.0')]
+class BackedEnumFromParameterTypeToggleOffTest extends TypeInferenceTestCase
+{
+
+	/** @return iterable<mixed> */
+	public static function dataFileAsserts(): iterable
+	{
+		yield from self::gatherAssertTypes(__DIR__ . '/data/backed-enum-from-parameter-type-off.php');
+	}
+
+	/**
+	 * @param mixed ...$args
+	 */
+	#[DataProvider('dataFileAsserts')]
+	public function testFileAsserts(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return array_merge(parent::getAdditionalConfigFiles(), [
+			__DIR__ . '/../../../../conf/bleedingEdge.neon',
+			__DIR__ . '/backed-enum-from-parameter-type-off.neon',
+		]);
+	}
+
+}

tests/PHPStan/Reflection/Php/backed-enum-from-parameter-type-off.neon

@@ -0,0 +1,3 @@
+parameters:
+	featureToggles:
+		backedEnumFromParameterType: false

tests/PHPStan/Reflection/Php/data/backed-enum-from-parameter-type-off.php

@@ -0,0 +1,24 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace BackedEnumFromParameterTypeOff;
+
+use function PHPStan\Testing\assertType;
+
+enum NumberEnum: int
+{
+	case One = 1;
+}
+
+enum WordEnum: string
+{
+	case One = 'one';
+}
+
+function (): void {
+	assertType('Closure(int|string): BackedEnumFromParameterTypeOff\NumberEnum', NumberEnum::from(...));
+	assertType('Closure(int|string): (BackedEnumFromParameterTypeOff\NumberEnum|null)', NumberEnum::tryFrom(...));
+	assertType('Closure(int|string): BackedEnumFromParameterTypeOff\WordEnum', WordEnum::from(...));
+	assertType('Closure(int|string): (BackedEnumFromParameterTypeOff\WordEnum|null)', WordEnum::tryFrom(...));
+};

turbo-ext/src/PhpClassReflectionExtension.cpp

@@ -312,6 +312,7 @@ struct ConstructorArgs
 	zval *allowedConstantsMapProvider;
 	bool inferPrivatePropertyTypeFromConstructor;
 	zval *phpVersion;
+	bool backedEnumFromParameterType;
 	zend_long memberCacheKeysMax;
 };
 
@@ -365,6 +366,7 @@ class PhpClassReflectionExtension
 			ZVAL_COPY(OBJ_PROP_NUM(object, entry.slot), value);
 		}
 		ZVAL_BOOL(OBJ_PROP_NUM(object, slots::inferPrivatePropertyTypeFromConstructor), a.inferPrivatePropertyTypeFromConstructor);
+		ZVAL_BOOL(OBJ_PROP_NUM(object, slots::backedEnumFromParameterType), a.backedEnumFromParameterType);
 
 		zval lru;
 		if (UNEXPECTED(!pt_lru_cache_new(&lru, a.memberCacheKeysMax))) return false;
@@ -1576,6 +1578,8 @@ class PhpClassReflectionExtension
 		zv::Val method = createUserlandMethodReflection(declaringClass, declaringClass, methodReflection, methodTrait.raw());
 		if (UNEXPECTED(method.isUndef())) return zv::Val();
 
+		if (Z_TYPE_P(slot(slots::backedEnumFromParameterType)) != IS_TRUE) return method;
+
 		zv::Str loweredName = zv::Str::adopt(zend_string_tolower(methodNameStr.get()));
 		if (zend_string_equals_literal(loweredName.get(), "from") || zend_string_equals_literal(loweredName.get(), "tryfrom")) {
 			zv::Val backedEnumType = call(declaringClass, PT_LC("getbackedenumtype"));
@@ -2953,7 +2957,8 @@ PT_MINIT_REGISTRATION(pt_register_php_class_reflection_extension)
 	cls.method(sigs::__construct, [](INTERNAL_FUNCTION_PARAMETERS) {
 		ConstructorArgs a;
 		bool inferPrivatePropertyTypeFromConstructor;
-		ZEND_PARSE_PARAMETERS_START(18, 18)
+		bool backedEnumFromParameterType;
+		ZEND_PARSE_PARAMETERS_START(19, 19)
 			Z_PARAM_OBJECT(a.scopeFactory)
 			Z_PARAM_OBJECT(a.phpDocsResolver)
 			Z_PARAM_OBJECT(a.nodeScopeResolver)
@@ -2971,9 +2976,11 @@ PT_MINIT_REGISTRATION(pt_register_php_class_reflection_extension)
 			Z_PARAM_OBJECT(a.allowedConstantsMapProvider)
 			Z_PARAM_BOOL(inferPrivatePropertyTypeFromConstructor)
 			Z_PARAM_OBJECT(a.phpVersion)
+			Z_PARAM_BOOL(backedEnumFromParameterType)
 			Z_PARAM_LONG(a.memberCacheKeysMax)
 		ZEND_PARSE_PARAMETERS_END();
 		a.inferPrivatePropertyTypeFromConstructor = inferPrivatePropertyTypeFromConstructor;
+		a.backedEnumFromParameterType = backedEnumFromParameterType;
 		if (UNEXPECTED(!phpstanturbo::PhpClassReflectionExtension::construct(Z_OBJ_P(ZEND_THIS), a))) RETURN_THROWS();
 	});