added TypeAssert helper for type inference testing with Nette Tester

Author: dg

phpstan.neon

@@ -5,5 +5,9 @@ parameters:
 		- src
 		- tests
 
+	excludePaths:
+		analyse:
+			- tests/data/*
+
 includes:
 	- extension.neon

src/Testing/TypeAssert.php

@@ -0,0 +1,157 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nette\PHPStan\Testing;
+
+use PhpParser\Node;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\ScopeContext;
+use PHPStan\Analyser\ScopeFactory;
+use PHPStan\DependencyInjection\Container;
+use PHPStan\DependencyInjection\ContainerFactory;
+use PHPStan\File\FileHelper;
+use PHPStan\Type\VerbosityLevel;
+use Tester\Assert;
+use function array_merge, count, hash, implode, in_array, sprintf, strtolower, sys_get_temp_dir;
+
+
+/**
+ * Verifies assertType() calls in a PHP file against PHPStan's type inference using Nette Tester.
+ */
+class TypeAssert
+{
+	/** @var array<string, Container> */
+	private static array $containers = [];
+
+
+	/**
+	 * Gathers assertType() calls from a PHP file and verifies them against PHPStan's type inference.
+	 * @param list<string> $configFiles
+	 */
+	public static function assertTypes(string $file, array $configFiles = []): void
+	{
+		$container = self::createContainer($configFiles);
+
+		$fileHelper = $container->getByType(FileHelper::class);
+		$file = $fileHelper->normalizePath($file);
+
+		$parser = $container->getService('defaultAnalysisParser');
+		$nodeScopeResolver = $container->getByType(NodeScopeResolver::class);
+		$scopeFactory = $container->getByType(ScopeFactory::class);
+
+		$pathRoutingParser = $container->getService('pathRoutingParser');
+		$pathRoutingParser->setAnalysedFiles([$file]);
+		$nodeScopeResolver->setAnalysedFiles([$file]);
+		$scope = $scopeFactory->create(ScopeContext::create($file));
+
+		$asserts = [];
+		$nodeScopeResolver->processNodes(
+			$parser->parseFile($file),
+			$scope,
+			static function (Node $node, Scope $scope) use (&$asserts): void {
+				$assert = self::processAssertTypeCall($node, $scope);
+				if ($assert !== null) {
+					$asserts[] = $assert;
+				}
+			},
+		);
+
+		if (count($asserts) === 0) {
+			Assert::fail(sprintf('File %s does not contain any assertType() calls.', $file));
+		}
+
+		foreach ($asserts as $assert) {
+			Assert::same(
+				$assert['expected'],
+				$assert['actual'],
+				sprintf('on line %d', $assert['line']),
+			);
+		}
+	}
+
+
+	/**
+	 * @return array{expected: string, actual: string, line: int}|null
+	 */
+	private static function processAssertTypeCall(Node $node, Scope $scope): ?array
+	{
+		if (!$node instanceof Node\Expr\FuncCall) {
+			return null;
+		}
+
+		$nameNode = $node->name;
+		if (!$nameNode instanceof Name) {
+			return null;
+		}
+
+		$functionName = $nameNode->toString();
+
+		if (in_array(strtolower($functionName), ['asserttype', 'assertnativetype'], true)) {
+			Assert::fail(sprintf('Missing use statement for %s() on line %d.', $functionName, $node->getStartLine()));
+		}
+
+		if ($functionName !== 'PHPStan\Testing\assertType') {
+			return null;
+		}
+
+		if (count($node->getArgs()) !== 2) {
+			Assert::fail(sprintf('Wrong assertType() call on line %d.', $node->getStartLine()));
+		}
+
+		$expectedType = $scope->getType($node->getArgs()[0]->value);
+		$constantStrings = $expectedType->getConstantStrings();
+		if (count($constantStrings) !== 1) {
+			Assert::fail(sprintf(
+				'Expected type must be a literal string, %s given on line %d.',
+				$expectedType->describe(VerbosityLevel::precise()),
+				$node->getStartLine(),
+			));
+			return null;
+		}
+
+		$actualType = $scope->getType($node->getArgs()[1]->value);
+		return [
+			'expected' => $constantStrings[0]->getValue(),
+			'actual' => $actualType->describe(VerbosityLevel::precise()),
+			'line' => $node->getStartLine(),
+		];
+	}
+
+
+	/**
+	 * @param list<string> $configFiles
+	 */
+	private static function createContainer(array $configFiles): Container
+	{
+		$cacheKey = hash('sha256', implode("\n", $configFiles));
+
+		if (isset(self::$containers[$cacheKey])) {
+			ContainerFactory::postInitializeContainer(self::$containers[$cacheKey]);
+			return self::$containers[$cacheKey];
+		}
+
+		$tmpDir = sys_get_temp_dir() . '/phpstan-tests';
+		@mkdir($tmpDir, 0o777, true); // @ - directory may already exist
+
+		$containerFactory = new ContainerFactory((string) getcwd());
+
+		$allConfigFiles = array_merge(
+			[$containerFactory->getConfigDirectory() . '/config.level8.neon'],
+			$configFiles,
+		);
+
+		$container = $containerFactory->create($tmpDir, $allConfigFiles, []);
+		self::$containers[$cacheKey] = $container;
+
+		foreach ($container->getParameter('bootstrapFiles') as $bootstrapFile) {
+			(static function (string $file): void {
+				require_once $file;
+			})($bootstrapFile);
+		}
+
+		return $container;
+	}
+}

tests/TypeAssertTest.phpt

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+require __DIR__ . '/bootstrap.php';
+
+use Nette\PHPStan\Testing\TypeAssert;
+
+// assertType() inside a function body — verifies PathRoutingParser fix
+TypeAssert::assertTypes(__DIR__ . '/data/assert-in-function.php');

tests/data/assert-in-function.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+use function PHPStan\Testing\assertType;
+
+
+function testAssertTypeInsideFunction(): void
+{
+	assertType('1', 1);
+}