WIP assertSuperType

Author: vojtech-dobes

composer.json

@@ -14,6 +14,9 @@
 		"classmap": [
 			"tests/objects"
 		],
+		"files": [
+			"tests/functions.php"
+		],
 		"psr-4": {
 			"Vojtechdobes\\Tests\\": "tests/cases/"
 		}

phpstan-baseline.neon

@@ -24,6 +24,18 @@ parameters:
 			count: 3
 			path: tests/cases/DatabaseSpecificTypeInferenceSharedBase.php
 
+		-
+			message: '#^Calling PHPStan\\File\\SystemAgnosticSimpleRelativePathHelper\:\:getRelativePath\(\) is not covered by backward compatibility promise\. The method might change in a minor PHPStan version\.$#'
+			identifier: phpstanApi.method
+			count: 4
+			path: tests/cases/DatabaseSpecificTypeInferenceTest.php
+
+		-
+			message: '#^Creating new PHPStan\\File\\SystemAgnosticSimpleRelativePathHelper is not covered by backward compatibility promise\. The class might change in a minor PHPStan version\.$#'
+			identifier: phpstanApi.constructor
+			count: 1
+			path: tests/cases/DatabaseSpecificTypeInferenceTest.php
+
 		-
 			message: '#^Parameter \#1 \$sql of method Dibi\\Connection\<null\>\:\:nativeQuery\(\) expects literal\-string, non\-empty\-string given\.$#'
 			identifier: argument.type
@@ -35,3 +47,9 @@ parameters:
 			identifier: argument.type
 			count: 1
 			path: tests/cases/SchemaTest.php
+
+		-
+			message: '#^Declaring PHPStan namespace is not allowed in 3rd party packages\.$#'
+			identifier: phpstanApi.phpstanNamespace
+			count: 1
+			path: tests/functions.php

tests/cases/DatabaseSpecificTypeInferenceTest.php

@@ -4,6 +4,7 @@
 
 use PHPStan;
 use PHPUnit;
+use PhpParser;
 
 
 final class DatabaseSpecificTypeInferenceTest extends PHPStan\Testing\TypeInferenceTestCase
@@ -38,4 +39,130 @@ public static function getAdditionalConfigFiles(): array
 		return [__DIR__ . '/DatabaseSpecificTypeInferenceTest.extension.neon'];
 	}
 
+
+
+	/**
+	 * @api
+	 * @param mixed ...$args
+	 */
+	public function assertFileAsserts(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		parent::assertFileAsserts($assertType, $file, ...$args);
+
+		if ($assertType === 'superType') {
+			$expected = $args[0];
+			$actual = $args[1];
+			$isCorrect = $args[2];
+
+			$failureMessage = sprintf('Expected subtype of %s, got type %s in %s on line %d.', $expected, $actual, $file, $args[3]);
+
+			self::assertTrue(
+				$isCorrect,
+				$failureMessage,
+			);
+		}
+	}
+
+
+
+	/**
+	 * @api
+	 * @return array<string, mixed[]>
+	 */
+	public static function gatherAssertTypes(string $file): array
+	{
+		$parentAsserts = parent::gatherAssertTypes($file);
+
+		$fileHelper = self::getContainer()->getByType(PHPStan\File\FileHelper::class);
+
+		$relativePathHelper = new PHPStan\File\SystemAgnosticSimpleRelativePathHelper($fileHelper);
+		$typeStringResolver = self::getContainer()->getByType(PHPStan\PhpDoc\TypeStringResolver::class);
+
+		$file = $fileHelper->normalizePath($file);
+
+		$asserts = [];
+		self::processFile($file, static function (PhpParser\Node $node, PHPStan\Analyser\Scope $scope) use (& $asserts, $file, $relativePathHelper, $typeStringResolver): void {
+			if (!$node instanceof PhpParser\Node\Expr\FuncCall) {
+				return;
+			}
+
+			$nameNode = $node->name;
+
+			if (!$nameNode instanceof PhpParser\Node\Name) {
+				return;
+			}
+
+			$functionName = $nameNode->toString();
+
+			if (in_array(strtolower($functionName), ['assertsupertype'], true)) {
+				self::fail(sprintf(
+					'Missing use statement for %s() in %s on line %d.',
+					$functionName,
+					$relativePathHelper->getRelativePath($file),
+					$node->getStartLine(),
+				));
+			} elseif ($functionName === 'PHPStan\\Testing\\assertSuperType') {
+				$expectedType = $scope->getType($node->getArgs()[0]->value);
+				$expectedTypeStrings = $expectedType->getConstantStrings();
+
+				if (count($expectedTypeStrings) !== 1) {
+					self::fail(sprintf(
+						'Expected super type must be a literal string, %s given in %s on line %d.',
+						$expectedType->describe(PHPStan\Type\VerbosityLevel::precise()),
+						$relativePathHelper->getRelativePath($file),
+						$node->getStartLine(),
+					));
+				}
+
+				$actualType = $scope->getType($node->getArgs()[1]->value);
+				$isCorrect = $typeStringResolver->resolve($expectedTypeStrings[0]->getValue())->isSuperTypeOf($actualType)->yes();
+
+				$assert = ['superType', $file, $expectedTypeStrings[0]->getValue(), $actualType->describe(PHPStan\Type\VerbosityLevel::precise()), $isCorrect, $node->getStartLine()];
+			} else {
+				$correctFunction = null;
+
+				$assertFunctions = [
+					'assertSuperType' => 'PHPStan\\Testing\\assertSuperType',
+				];
+
+				foreach ($assertFunctions as $assertFn => $fqFunctionName) {
+					if (stripos($functionName, $assertFn) === false) {
+						continue;
+					}
+
+					$correctFunction = $fqFunctionName;
+				}
+
+				if ($correctFunction === null) {
+					return;
+				}
+
+				self::fail(sprintf(
+					'Function %s imported with wrong namespace %s called in %s on line %d.',
+					$correctFunction,
+					$functionName,
+					$relativePathHelper->getRelativePath($file),
+					$node->getStartLine(),
+				));
+			}
+
+			if (count($node->getArgs()) !== 2) {
+				self::fail(sprintf(
+					'ERROR: Wrong %s() call in %s on line %d.',
+					$functionName,
+					$relativePathHelper->getRelativePath($file),
+					$node->getStartLine(),
+				));
+			}
+
+			$asserts[$file . ':' . $node->getStartLine()] = $assert;
+		});
+
+		return array_merge($parentAsserts, $asserts);
+	}
+
 }

tests/functions.php

@@ -0,0 +1,17 @@
+<?php declare(strict_types=1);
+
+namespace PHPStan\Testing;
+
+/**
+ * Asserts a super type of a value.
+ *
+ * @phpstan-pure
+ * @param mixed $value
+ * @return mixed
+ *
+ * @throws void
+ */
+function assertSuperType(string $superType, $value) // phpcs:ignore
+{
+	return null;
+}