Remove optional parameters added since June 2026

Parameters that became optional in the last 135 days are now required,
and every caller passes the former default explicitly. The native mirrors
in turbo-ext follow: regenerated arginfo, required ZPP arguments, and
native calls into PHP that pass the full argument lists.

Kept optional: parameters after an older optional parameter, the
TemplateTypeTrait::isValidVariance() $strict required by the interface,
CachedParser's $cachedSourceBytesMax (constructed by Larastan),
OpenSslCipherMethodsProvider's $supportedCipherMethods (DI autowiring),
and the trailing ExpressionResult constructor parameters that the
generated ExpressionResultFactory does not pass.

Amp-Thread-ID: https://ampcode.com/threads/T-01a18404-a5f9-74cf-bb1b-815927dc7033

Author: ondrejmirtes

bin/phpstan

@@ -33,7 +33,7 @@ use Symfony\Component\Console\Helper\ProgressBar;
 	require_once __DIR__ . '/../src/Process/Restart/IniComposer.php';
 	require_once __DIR__ . '/../src/Process/Restart/RestartExecutor.php';
 	require_once __DIR__ . '/../src/Process/Restart/RestartManager.php';
-	RestartManager::run($_SERVER['argv']);
+	RestartManager::run($_SERVER['argv'], null, null, 'phpstan');
 	TurboExtensionEnabler::trustOwnTypesIfSuitable($_SERVER['argv']);
 
 	$analysisStartTime = microtime(true);

build/PHPStan/Build/InlineCallCollector.php

@@ -83,7 +83,7 @@ final class InlineCallCollector implements Collector
 	/**
 	 * @param list<string>|null $directories the closed world to scan for overrides; null = directories()
 	 */
-	public function __construct(private Parser $parser, private ReflectionProvider $reflectionProvider, private ?array $directories = null)
+	public function __construct(private Parser $parser, private ReflectionProvider $reflectionProvider, private ?array $directories)
 	{
 	}
 

build/baseline-optional-parameters.neon

@@ -17,6 +17,7 @@ services:
 		class: PHPStan\Build\InlineCallCollector
 		arguments:
 			parser: @defaultAnalysisParser
+			directories: null
 		tags:
 			- phpstan.collector
 	-

build/inline.neon

@@ -131,7 +131,7 @@
 %token T_LITERAL                  \\.|.|\n
 
 Expression -> {
-    return new RegexNode('#expression', children: \is_array($children) ? $children : [$children]);
+    return new RegexNode('#expression', '', '', \is_array($children) ? $children : [$children]);
 }
   : Alternation()?
   ;
@@ -145,14 +145,14 @@ Alternation -> {
     foreach ($children as $child) {
         if ($child instanceof TokenInterface) {
             $isAlternation = true;
-            $child = new RegexNode('token', 'alternation', $child->value);
+            $child = new RegexNode('token', 'alternation', $child->value, []);
         }
         $nodes[] = $child;
     }
     if (!$isAlternation) {
         return $children[0] ?? [];
     }
-    return new RegexNode('#alternation', children: $nodes);
+    return new RegexNode('#alternation', '', '', $nodes);
 }
   : Concatenation()? (<T_ALTERNATION> Concatenation()?)*
   ;
@@ -164,14 +164,14 @@ Concatenation -> {
     if (\count($children) === 1) {
         return $children[0];
     }
-    return new RegexNode('#concatenation', children: $children);
+    return new RegexNode('#concatenation', '', '', $children);
 }
   : (InternalOptions() | Assertion() | Quantification() | Condition())+
   ;
 
 InternalOptions -> {
-    return new RegexNode('#internal_options', children: [
-        new RegexNode('token', 'internal_option', $children->value),
+    return new RegexNode('#internal_options', '', '', [
+        new RegexNode('token', 'internal_option', $children->value, []),
     ]);
 }
   : <T_INTERNAL_OPTION>
@@ -181,16 +181,16 @@ Condition -> {
     $reference = \array_shift($children);
     switch ($reference->id) {
         case self::T_NAMED_REFERENCE:
-            \array_unshift($children, new RegexNode('token', 'capturing_name', $reference->captures[0]));
-            return new RegexNode('#namedcondition', children: $children);
+            \array_unshift($children, new RegexNode('token', 'capturing_name', $reference->captures[0], []));
+            return new RegexNode('#namedcondition', '', '', $children);
         case self::T_ABSOLUTE_REFERENCE:
-            \array_unshift($children, new RegexNode('token', 'index', $reference->captures[0]));
-            return new RegexNode('#absolutecondition', children: $children);
+            \array_unshift($children, new RegexNode('token', 'index', $reference->captures[0], []));
+            return new RegexNode('#absolutecondition', '', '', $children);
         case self::T_RELATIVE_REFERENCE:
-            \array_unshift($children, new RegexNode('token', 'index', $reference->captures[0]));
-            return new RegexNode('#relativecondition', children: $children);
+            \array_unshift($children, new RegexNode('token', 'index', $reference->captures[0], []));
+            return new RegexNode('#relativecondition', '', '', $children);
         default:
-            return new RegexNode('#assertioncondition', children: $children);
+            return new RegexNode('#assertioncondition', '', '', $children);
     }
 }
   : (
@@ -211,7 +211,7 @@ Assertion -> {
         self::T_LOOKBEHIND => '#lookbehind',
         self::T_NEGATIVE_LOOKBEHIND => '#negativelookbehind',
     ];
-    return new RegexNode($ids[$assertion->id], children: $children);
+    return new RegexNode($ids[$assertion->id], '', '', $children);
 }
   : (<T_LOOKAHEAD> | <T_NEGATIVE_LOOKAHEAD> | <T_LOOKBEHIND> | <T_NEGATIVE_LOOKBEHIND>)
     Alternation()?
@@ -225,9 +225,9 @@ Quantification -> {
     if (\count($children) === 1) {
         return $children[0];
     }
-    return new RegexNode('#quantification', children: [
+    return new RegexNode('#quantification', '', '', [
         $children[0],
-        new RegexNode('token', \strtolower(\substr($children[1]->name, 2)), $children[1]->value),
+        new RegexNode('token', \strtolower(\substr($children[1]->name, 2)), $children[1]->value, []),
     ]);
 }
   : (CharacterClass() | Capturing() | Literal()) Quantifier()?
@@ -251,7 +251,7 @@ CharacterClass -> {
 
     $nodes = [];
     if ($children->id === self::T_NEGATIVE_CLASS_FC || $children->id === self::T_CLASS_FC) {
-        $nodes[] = new RegexNode('token', '_class', ']');
+        $nodes[] = new RegexNode('token', '_class', ']', []);
     }
 
     $literalNames = [
@@ -265,37 +265,37 @@ CharacterClass -> {
     $i = 0;
     // <range>? ( <posix_class> | <class_> | range() <range>? | literal() )* <range>?
     if ($i < $count && $tokens[$i]->name === 'T_RANGE') {
-        $nodes[] = new RegexNode('token', 'range', $tokens[$i]->value);
+        $nodes[] = new RegexNode('token', 'range', $tokens[$i]->value, []);
         $i++;
     }
     while ($i < $count) {
         $token = $tokens[$i];
         if ($token->name === 'T_POSIX_CLASS') {
-            $nodes[] = new RegexNode('token', 'posix_class', $token->value);
+            $nodes[] = new RegexNode('token', 'posix_class', $token->value, []);
             $i++;
             continue;
         }
         if ($token->name === 'T_CLASS_NESTED') {
-            $nodes[] = new RegexNode('token', 'class_', $token->value);
+            $nodes[] = new RegexNode('token', 'class_', $token->value, []);
             $i++;
             continue;
         }
         if (!isset($literalNames[$token->name])) {
             break;
         }
-        $literal = new RegexNode('token', $literalNames[$token->name], $token->value);
+        $literal = new RegexNode('token', $literalNames[$token->name], $token->value, []);
         if (
             $i + 2 < $count
             && $tokens[$i + 1]->name === 'T_RANGE'
             && isset($literalNames[$tokens[$i + 2]->name])
         ) {
-            $nodes[] = new RegexNode('#range', children: [
+            $nodes[] = new RegexNode('#range', '', '', [
                 $literal,
-                new RegexNode('token', $literalNames[$tokens[$i + 2]->name], $tokens[$i + 2]->value),
+                new RegexNode('token', $literalNames[$tokens[$i + 2]->name], $tokens[$i + 2]->value, []),
             ]);
             $i += 3;
             if ($i < $count && $tokens[$i]->name === 'T_RANGE') {
-                $nodes[] = new RegexNode('token', 'range', $tokens[$i]->value);
+                $nodes[] = new RegexNode('token', 'range', $tokens[$i]->value, []);
                 $i++;
             }
             continue;
@@ -304,15 +304,15 @@ CharacterClass -> {
         $i++;
     }
     if ($i < $count && $tokens[$i]->name === 'T_RANGE') {
-        $nodes[] = new RegexNode('token', 'range', $tokens[$i]->value);
+        $nodes[] = new RegexNode('token', 'range', $tokens[$i]->value, []);
         $i++;
     }
     if ($i !== $count) {
         throw new RegexSyntaxException('Unexpected token in character class');
     }
 
     $negative = $children->id === self::T_NEGATIVE_CLASS_FC || $children->id === self::T_NEGATIVE_CLASS;
-    return new RegexNode($negative ? '#negativeclass' : '#class', children: $nodes);
+    return new RegexNode($negative ? '#negativeclass' : '#class', '', '', $nodes);
 }
   : <T_NEGATIVE_CLASS_FC> | <T_CLASS_FC> | <T_NEGATIVE_CLASS> | <T_CLASS>
   ;
@@ -324,27 +324,27 @@ Capturing -> {
     $opening = \array_shift($children);
     switch ($opening->id) {
         case self::T_MARKER:
-            return new RegexNode('#mark', children: [
-                new RegexNode('token', 'name', $opening->captures[0]),
+            return new RegexNode('#mark', '', '', [
+                new RegexNode('token', 'name', $opening->captures[0], []),
             ]);
         case self::T_COMMENT:
-            return new RegexNode('#comment', children: $opening->captures[0] === '' ? [] : [
-                new RegexNode('token', 'comment', $opening->captures[0]),
+            return new RegexNode('#comment', '', '', $opening->captures[0] === '' ? [] : [
+                new RegexNode('token', 'comment', $opening->captures[0], []),
             ]);
         case self::T_NAMED_CAPTURING:
-            \array_unshift($children, new RegexNode('token', 'capturing_name', $opening->captures[0]));
-            return new RegexNode('#namedcapturing', children: $children);
+            \array_unshift($children, new RegexNode('token', 'capturing_name', $opening->captures[0], []));
+            return new RegexNode('#namedcapturing', '', '', $children);
         case self::T_NON_CAPTURING:
-            return new RegexNode('#noncapturing', children: $children);
+            return new RegexNode('#noncapturing', '', '', $children);
         case self::T_NON_CAPTURING_INTERNAL_OPTION:
-            \array_unshift($children, new RegexNode('token', 'non_capturing_internal_option', $opening->value));
-            return new RegexNode('#noncapturing', children: $children);
+            \array_unshift($children, new RegexNode('token', 'non_capturing_internal_option', $opening->value, []));
+            return new RegexNode('#noncapturing', '', '', $children);
         case self::T_NON_CAPTURING_RESET:
-            return new RegexNode('#noncapturingreset', children: $children);
+            return new RegexNode('#noncapturingreset', '', '', $children);
         case self::T_ATOMIC_GROUP:
-            return new RegexNode('#atomicgroup', children: $children);
+            return new RegexNode('#atomicgroup', '', '', $children);
         default:
-            return new RegexNode('#capturing', children: $children);
+            return new RegexNode('#capturing', '', '', $children);
     }
 }
   : <T_MARKER>
@@ -367,7 +367,7 @@ Literal -> {
         self::T_SUBROUTINE_G => 'subroutine',
     ];
 
-    return new RegexNode('token', $names[$children->id] ?? \strtolower(\substr($children->name, 2)), $children->value);
+    return new RegexNode('token', $names[$children->id] ?? \strtolower(\substr($children->name, 2)), $children->value, []);
 }
   : <T_CHARACTER>
   | <T_DYNAMIC_CHARACTER>

build/regex-parser/RegexGrammar.pp3

@@ -152,6 +152,7 @@ public function analyse(
 			// analysis ran in this process - its peak is read where the number is printed
 			peakMemoryUsageBytes: 0,
 			processedFiles: $allProcessedFiles,
+			workerCount: 0,
 		);
 	}
 

src/Analyser/Analyser.php

@@ -50,7 +50,7 @@ public function __construct(
 		private bool $reachedInternalErrorsCountLimit,
 		private int $peakMemoryUsageBytes,
 		private array $processedFiles,
-		private int $workerCount = 0,
+		private int $workerCount,
 	)
 	{
 	}

src/Analyser/AnalyserResult.php

@@ -61,23 +61,23 @@ public function finalize(
 		AnalyserResult $analyserResult,
 		bool $onlyFiles,
 		bool $debug,
-		?Closure $preRuleCallback = null,
-		?Closure $postRuleCallback = null,
-		array $previousCollectedDataRuleResults = [],
+		?Closure $preRuleCallback,
+		?Closure $postRuleCallback,
+		array $previousCollectedDataRuleResults,
 	): FinalizerResult
 	{
 		if (count($analyserResult->getCollectedData()) === 0) {
-			return $this->addUnmatchedIgnoredErrors($this->mergeFilteredPhpErrors($analyserResult), [], []);
+			return $this->addUnmatchedIgnoredErrors($this->mergeFilteredPhpErrors($analyserResult), [], [], [], 0);
 		}
 
 		$hasInternalErrors = count($analyserResult->getInternalErrors()) > 0 || $analyserResult->hasReachedInternalErrorsCountLimit();
 		if ($hasInternalErrors) {
-			return $this->addUnmatchedIgnoredErrors($this->mergeFilteredPhpErrors($analyserResult), [], []);
+			return $this->addUnmatchedIgnoredErrors($this->mergeFilteredPhpErrors($analyserResult), [], [], [], 0);
 		}
 
 		$nodeType = CollectedDataNode::class;
 		$collectedData = $analyserResult->getCollectedData();
-		$node = new CollectedDataNode($collectedData, $onlyFiles);
+		$node = new CollectedDataNode($collectedData, $onlyFiles, null);
 
 		// Hashed once per collector type and run, in the same order however the files were merged.
 		$collectorHashes = [];
@@ -349,8 +349,8 @@ private function addUnmatchedIgnoredErrors(
 		AnalyserResult $analyserResult,
 		array $collectorErrors,
 		array $locallyIgnoredCollectorErrors,
-		array $collectedDataRuleResults = [],
-		int $reusedRulesCount = 0,
+		array $collectedDataRuleResults,
+		int $reusedRulesCount,
 	): FinalizerResult
 	{
 		if (!$this->reportUnmatchedIgnoredErrors) {

src/Analyser/AnalyserResultFinalizer.php

@@ -31,7 +31,7 @@ public function __construct(
 		private ExpressionResult $expressionResult,
 		private ?ParametersAcceptor $resolvedParametersAcceptor,
 		private array $argResults,
-		private array $byRefArguments = [],
+		private array $byRefArguments,
 	)
 	{
 	}