Validate parameters with parametersSchema each time after container c…

…reation

This allows for validation of dynamic parameters

src/DependencyInjection/ContainerFactory.php

@@ -3,9 +3,17 @@
 namespace PHPStan\DependencyInjection;
 
 use Nette\DI\Config\Adapters\PhpAdapter;
+use Nette\DI\Definitions\Statement;
 use Nette\DI\Extensions\ExtensionsExtension;
 use Nette\DI\Extensions\PhpExtension;
 use Nette\DI\Helpers;
+use Nette\Schema\Context as SchemaContext;
+use Nette\Schema\Elements\AnyOf;
+use Nette\Schema\Elements\Structure;
+use Nette\Schema\Elements\Type;
+use Nette\Schema\Expect;
+use Nette\Schema\Processor;
+use Nette\Schema\Schema;
 use Nette\Utils\Strings;
 use Nette\Utils\Validators;
 use Phar;
@@ -21,6 +29,7 @@
 use PHPStan\Reflection\PhpVersionStaticAccessor;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Reflection\ReflectionProviderStaticAccessor;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\Accessory\AccessoryArrayListType;
 use PHPStan\Type\Generic\TemplateTypeVariance;
 use PHPStan\Type\ObjectType;
@@ -89,8 +98,8 @@ public function create(
 		?string $cliAutoloadFile = null,
 	): Container
 	{
-		$allConfigFiles = $this->detectDuplicateIncludedFiles(
-			$additionalConfigFiles,
+		[$allConfigFiles, $projectConfig] = $this->detectDuplicateIncludedFiles(
+			array_merge([__DIR__ . '/../../conf/parametersSchema.neon'], $additionalConfigFiles),
 			[
 				'rootDir' => $this->rootDirectory,
 				'currentWorkingDirectory' => $this->currentWorkingDirectory,
@@ -134,6 +143,7 @@ public function create(
 		$configurator->setAllConfigFiles($allConfigFiles);
 
 		$container = $configurator->createContainer()->getByType(Container::class);
+		$this->validateParameters($container->getParameters(), $projectConfig['parametersSchema']);
 		self::postInitializeContainer($container);
 
 		return $container;
@@ -232,7 +242,7 @@ public function getConfigDirectory(): string
 	/**
 	 * @param string[] $configFiles
 	 * @param array<string, string> $loaderParameters
-	 * @return string[]
+	 * @return array{list<string>, array<mixed>}
 	 * @throws DuplicateIncludedFilesException
 	 */
 	private function detectDuplicateIncludedFiles(
@@ -243,19 +253,22 @@ private function detectDuplicateIncludedFiles(
 		$neonAdapter = new NeonAdapter();
 		$phpAdapter = new PhpAdapter();
 		$allConfigFiles = [];
+		$configArray = [];
 		foreach ($configFiles as $configFile) {
-			$allConfigFiles = array_merge($allConfigFiles, self::getConfigFiles($this->fileHelper, $neonAdapter, $phpAdapter, $configFile, $loaderParameters, null));
+			[$tmpConfigFiles, $tmpConfigArray] = self::getConfigFiles($this->fileHelper, $neonAdapter, $phpAdapter, $configFile, $loaderParameters, null);
+			$allConfigFiles = array_merge($allConfigFiles, $tmpConfigFiles);
+			$configArray = \Nette\Schema\Helpers::merge($tmpConfigArray, $configArray);
 		}
 
 		$normalized = array_map(fn (string $file): string => $this->fileHelper->normalizePath($file), $allConfigFiles);
 
 		$deduplicated = array_unique($normalized);
 		if (count($normalized) <= count($deduplicated)) {
-			return $normalized;
+			return [$normalized, $configArray];
 		}
 
 		if (!$this->checkDuplicateFiles) {
-			return $normalized;
+			return [$normalized, $configArray];
 		}
 
 		$duplicateFiles = array_unique(array_diff_key($normalized, $deduplicated));
@@ -265,7 +278,7 @@ private function detectDuplicateIncludedFiles(
 
 	/**
 	 * @param array<string, string> $loaderParameters
-	 * @return string[]
+	 * @return array{string[], array<mixed>}
 	 */
 	private static function getConfigFiles(
 		FileHelper $fileHelper,
@@ -277,10 +290,10 @@ private static function getConfigFiles(
 	): array
 	{
 		if ($generateBaselineFile === $fileHelper->normalizePath($configFile)) {
-			return [];
+			return [[], []];
 		}
 		if (!is_file($configFile) || !is_readable($configFile)) {
-			return [];
+			return [[], []];
 		}
 
 		if (str_ends_with($configFile, '.php')) {
@@ -294,11 +307,13 @@ private static function getConfigFiles(
 			$includes = Helpers::expand($data['includes'], $loaderParameters);
 			foreach ($includes as $include) {
 				$include = self::expandIncludedFile($include, $configFile);
-				$allConfigFiles = array_merge($allConfigFiles, self::getConfigFiles($fileHelper, $neonAdapter, $phpAdapter, $include, $loaderParameters, $generateBaselineFile));
+				[$tmpConfigFiles, $tmpConfigArray] = self::getConfigFiles($fileHelper, $neonAdapter, $phpAdapter, $include, $loaderParameters, $generateBaselineFile);
+				$allConfigFiles = array_merge($allConfigFiles, $tmpConfigFiles);
+				$data = \Nette\Schema\Helpers::merge($tmpConfigArray, $data);
 			}
 		}
 
-		return $allConfigFiles;
+		return [$allConfigFiles, $data];
 	}
 
 	private static function expandIncludedFile(string $includedFile, string $mainFile): string
@@ -308,4 +323,92 @@ private static function expandIncludedFile(string $includedFile, string $mainFil
 			: dirname($mainFile) . '/' . $includedFile;
 	}
 
+	/**
+	 * @param array<mixed> $parameters
+	 * @param array<mixed> $parametersSchema
+	 */
+	private function validateParameters(array $parameters, array $parametersSchema): void
+	{
+		if (!$parameters['__validate']) {
+			return;
+		}
+
+		$schema = $this->processArgument(
+			new Statement('schema', [
+				new Statement('structure', [$parametersSchema]),
+			]),
+		);
+		$processor = new Processor();
+		$processor->onNewContext[] = static function (SchemaContext $context): void {
+			$context->path = ['parameters'];
+		};
+		$processor->process($schema, $parameters);
+	}
+
+	/**
+	 * @param Statement[] $statements
+	 */
+	private function processSchema(array $statements, bool $required = true): Schema
+	{
+		if (count($statements) === 0) {
+			throw new ShouldNotHappenException();
+		}
+
+		$parameterSchema = null;
+		foreach ($statements as $statement) {
+			$processedArguments = array_map(fn ($argument) => $this->processArgument($argument), $statement->arguments);
+			if ($parameterSchema === null) {
+				/** @var Type|AnyOf|Structure $parameterSchema */
+				$parameterSchema = Expect::{$statement->getEntity()}(...$processedArguments);
+			} else {
+				$parameterSchema->{$statement->getEntity()}(...$processedArguments);
+			}
+		}
+
+		if ($required) {
+			$parameterSchema->required();
+		}
+
+		return $parameterSchema;
+	}
+
+	/**
+	 * @param mixed $argument
+	 * @return mixed
+	 */
+	private function processArgument($argument, bool $required = true)
+	{
+		if ($argument instanceof Statement) {
+			if ($argument->entity === 'schema') {
+				$arguments = [];
+				foreach ($argument->arguments as $schemaArgument) {
+					if (!$schemaArgument instanceof Statement) {
+						throw new ShouldNotHappenException('schema() should contain another statement().');
+					}
+
+					$arguments[] = $schemaArgument;
+				}
+
+				if (count($arguments) === 0) {
+					throw new ShouldNotHappenException('schema() should have at least one argument.');
+				}
+
+				return $this->processSchema($arguments, $required);
+			}
+
+			return $this->processSchema([$argument], $required);
+		} elseif (is_array($argument)) {
+			$processedArray = [];
+			foreach ($argument as $key => $val) {
+				$required = $key[0] !== '?';
+				$key = $required ? $key : substr($key, 1);
+				$processedArray[$key] = $this->processArgument($val, $required);
+			}
+
+			return $processedArray;
+		}
+
+		return $argument;
+	}
+
 }

src/DependencyInjection/ParametersSchemaExtension.php

@@ -4,19 +4,8 @@
 
 use Nette\DI\CompilerExtension;
 use Nette\DI\Definitions\Statement;
-use Nette\Schema\Context as SchemaContext;
-use Nette\Schema\DynamicParameter;
-use Nette\Schema\Elements\AnyOf;
-use Nette\Schema\Elements\Structure;
-use Nette\Schema\Elements\Type;
 use Nette\Schema\Expect;
-use Nette\Schema\Processor;
 use Nette\Schema\Schema;
-use PHPStan\ShouldNotHappenException;
-use function array_map;
-use function count;
-use function is_array;
-use function substr;
 
 class ParametersSchemaExtension extends CompilerExtension
 {
@@ -26,93 +15,4 @@ public function getConfigSchema(): Schema
 		return Expect::arrayOf(Expect::type(Statement::class))->min(1);
 	}
 
-	public function loadConfiguration(): void
-	{
-		$builder = $this->getContainerBuilder();
-		if (!$builder->parameters['__validate']) {
-			return;
-		}
-
-		/** @var mixed[] $config */
-		$config = $this->config;
-		$config['analysedPaths'] = new Statement(DynamicParameter::class);
-		$config['analysedPathsFromConfig'] = new Statement(DynamicParameter::class);
-		$schema = $this->processArgument(
-			new Statement('schema', [
-				new Statement('structure', [$config]),
-			]),
-		);
-		$processor = new Processor();
-		$processor->onNewContext[] = static function (SchemaContext $context): void {
-			$context->path = ['parameters'];
-		};
-		$processor->process($schema, $builder->parameters);
-	}
-
-	/**
-	 * @param Statement[] $statements
-	 */
-	private function processSchema(array $statements, bool $required = true): Schema
-	{
-		if (count($statements) === 0) {
-			throw new ShouldNotHappenException();
-		}
-
-		$parameterSchema = null;
-		foreach ($statements as $statement) {
-			$processedArguments = array_map(fn ($argument) => $this->processArgument($argument), $statement->arguments);
-			if ($parameterSchema === null) {
-				/** @var Type|AnyOf|Structure $parameterSchema */
-				$parameterSchema = Expect::{$statement->getEntity()}(...$processedArguments);
-			} else {
-				$parameterSchema->{$statement->getEntity()}(...$processedArguments);
-			}
-		}
-
-		if ($required) {
-			$parameterSchema->required();
-		}
-
-		return $parameterSchema;
-	}
-
-	/**
-	 * @param mixed $argument
-	 * @return mixed
-	 */
-	private function processArgument($argument, bool $required = true)
-	{
-		if ($argument instanceof Statement) {
-			if ($argument->entity === 'schema') {
-				$arguments = [];
-				foreach ($argument->arguments as $schemaArgument) {
-					if (!$schemaArgument instanceof Statement) {
-						throw new ShouldNotHappenException('schema() should contain another statement().');
-					}
-
-					$arguments[] = $schemaArgument;
-				}
-
-				if (count($arguments) === 0) {
-					throw new ShouldNotHappenException('schema() should have at least one argument.');
-				}
-
-				return $this->processSchema($arguments, $required);
-			}
-
-			return $this->processSchema([$argument], $required);
-		} elseif (is_array($argument)) {
-			$processedArray = [];
-			foreach ($argument as $key => $val) {
-				$required = $key[0] !== '?';
-				$key = $required ? $key : substr($key, 1);
-				$processedArray[$key] = $this->processArgument($val, $required);
-			}
-
-			return $processedArray;
-		}
-
-		return $argument;
-	}
-
 }