AOT: Reflection getParameters() on runtime internal names + phpcredits true return

lib/BuiltinInternalArgInfo.php

@@ -587,8 +587,8 @@ public static function stubReturnTypeLabelForFunction(string $callableLc): ?stri
             'version_compare' => 'int|bool',
             // ext/standard/basic_functions.stub.php — InternalArgInfo return string (missing |false) (#27906)
             'php_sapi_name' => 'string|false',
-            // ext/standard/info.stub.php — InternalArgInfo empty return; Zend : bool (#24508)
-            'phpcredits' => 'bool',
+            // ext/standard/info.stub.php — InternalArgInfo empty return; Zend : true (#24508, re-#27728)
+            'phpcredits' => 'true',
             // ext/standard/basic_functions.stub.php — InternalArgInfo omits return; Zend : true (#27728, re-#24550)
             'phpinfo' => 'true',
             // ext/standard/basic_functions.stub.php — InternalArgInfo omits return; Zend array|float (#27906)

lib/JIT/Builtin/ReflectionFunctionParamCountLowering.php

@@ -45,6 +45,9 @@ public static function implementLookupFunctions(Context $context): void
                 $internalArity[strtolower($builtin)] = \count($names);
             }
         }
+        if (ReflectionInternalFunctionLowering::consumeRuntimeInternalParameterLookup()) {
+            $internalArity = ReflectionInternalFunctionLowering::buildAllInternalParamCounts() + $internalArity;
+        }
 
         ReflectionFunctionParamCountLookupRuntime::implement(
             $context,

lib/JIT/Builtin/ReflectionInternalFunctionLowering.php

@@ -19,6 +19,9 @@ final class ReflectionInternalFunctionLowering
     /** @var array<string, true> */
     private static array $functions = [];
 
+    /** Embed full internal metadata when ReflectionFunction::getParameters() uses runtime names (#23593). */
+    private static bool $runtimeInternalParameterLookup = false;
+
     public static function recordFunction(string $funcLc): void
     {
         $lc = strtolower(trim($funcLc));
@@ -57,13 +60,24 @@ public static function resetAccumulated(): void
         self::$functions = [];
     }
 
+    public static function consumeRuntimeInternalParameterLookup(): bool
+    {
+        $needed = self::$runtimeInternalParameterLookup;
+        self::$runtimeInternalParameterLookup = false;
+
+        return $needed;
+    }
+
+    public static function noteRuntimeInternalParameterLookup(): void
+    {
+        self::$runtimeInternalParameterLookup = true;
+    }
+
     public static function implementLookupFunctions(Context $context): void
     {
         $recorded = self::$functions;
+        $embedAllInternal = self::$runtimeInternalParameterLookup;
         self::resetAccumulated();
-        if ([] === $recorded) {
-            return;
-        }
 
         $metadata = [];
         foreach (array_keys($recorded) as $funcLc) {
@@ -91,8 +105,10 @@ public static function implementLookupFunctions(Context $context): void
             ];
         }
 
-        if ([] === $metadata) {
-            return;
+        if ($embedAllInternal) {
+            foreach (self::buildAllInternalMetadata() as $funcLc => $entry) {
+                $metadata[$funcLc] = $entry;
+            }
         }
 
         foreach ($metadata as $entry) {
@@ -117,6 +133,57 @@ public static function implementLookupFunctions(Context $context): void
         $context->builder->clearInsertionPosition();
     }
 
+    /**
+     * @return array<string, array{params: array<int, array{name: string, type: ?string, hasDefault: bool}>, return: ?string}>
+     */
+    public static function buildAllInternalMetadata(): array
+    {
+        $metadata = [];
+        $funcNames = array_keys(BuiltinInternalArgInfo::functionArityTables());
+        foreach (BuiltinParamNames::variadicInternalFunctionNames() as $funcLc) {
+            if (!\in_array($funcLc, $funcNames, true)) {
+                $funcNames[] = $funcLc;
+            }
+        }
+        foreach ($funcNames as $funcLc) {
+            $names = BuiltinParamNames::paramNamesForInternalFunction($funcLc);
+            if (null === $names) {
+                continue;
+            }
+            $params = [];
+            foreach (array_keys($names) as $index) {
+                $info = BuiltinInternalArgInfo::paramInfoForFunction($funcLc, (int) $index);
+                $type = null !== $info ? trim((string) ($info['type'] ?? '')) : '';
+                $params[(int) $index] = [
+                    'name' => self::displayParamName((string) $names[$index]),
+                    'type' => '' !== $type ? $type : null,
+                    'hasDefault' => self::internalParamHasDefault($funcLc, (int) $index),
+                ];
+            }
+            $ret = BuiltinInternalArgInfo::returnTypeLabelForFunction($funcLc);
+            $metadata[$funcLc] = [
+                'params' => $params,
+                'return' => null !== $ret && '' !== trim($ret) ? trim($ret) : null,
+            ];
+        }
+
+        return $metadata;
+    }
+
+    /** @return array<string, int> */
+    public static function buildAllInternalParamCounts(): array
+    {
+        $counts = [];
+        foreach (array_keys(self::buildAllInternalMetadata()) as $funcLc) {
+            $count = BuiltinParamNames::paramCountForInternalFunction($funcLc);
+            if (null !== $count) {
+                $counts[$funcLc] = $count;
+            }
+        }
+
+        return $counts;
+    }
+
     private static function displayParamName(string $raw): string
     {
         $display = ltrim($raw, '&');

lib/JIT/Call/ReflectionFunctionGetParameters.php

@@ -5,6 +5,7 @@
 namespace PHPCompiler\JIT\Call;
 
 use PHPCompiler\JIT\BasicBlockHelper;
+use PHPCompiler\JIT\Builtin\ReflectionInternalFunctionLowering;
 use PHPCompiler\JIT\Builtin\ReflectionNative;
 use PHPCompiler\JIT\Builtin\ReflectionParameterJitHelper;
 use PHPCompiler\JIT\Builtin\ReflectionRuntime;
@@ -34,6 +35,7 @@ public function call(Context $context, Variable ...$args): Value
 
         ReflectionRuntime::ensureLinked($context);
         ReflectionNative::registerDeclarations($context);
+        ReflectionInternalFunctionLowering::noteRuntimeInternalParameterLookup();
         $obj = ReflectionSetup::loadObjectFromArg($context, $args[0]);
         [$funcCstr] = ReflectionSetup::stringPropertyAsCstr(
             $context,

lib/JIT/NamedArgs.php

@@ -393,6 +393,9 @@ private static function resolveMixed(
             if (false === $unknownName || null === $unknownName) {
                 BuiltinParamNames::throwUnknownNamedParameterError($functionName);
             }
+            if (null !== $variadicParamIndex) {
+                BuiltinParamNames::throwUnknownNamedParameterError($functionName);
+            }
             throw new \Error("Unknown named parameter \${$unknownName}");
         }