Support for console InputInterface::getArgument()

Author: lookyman

composer.json

@@ -33,8 +33,9 @@
     "phpstan/phpstan-phpunit": "^0.11",
     "symfony/framework-bundle": "^3.0 || ^4.0",
     "squizlabs/php_codesniffer": "^3.3.2",
-    "symfony/serializer": "^3|^4",
-    "symfony/messenger": "^4.2"
+    "symfony/serializer": "^3.0 || ^4.0",
+    "symfony/messenger": "^4.2",
+    "symfony/console": "^3.0 || ^4.0"
   },
   "conflict": {
     "symfony/framework-bundle": "<3.0"

extension.neon

@@ -1,12 +1,20 @@
 parameters:
 	symfony:
 		constant_hassers: true
+		console_application_loader: null
 
 rules:
 	- PHPStan\Rules\Symfony\ContainerInterfacePrivateServiceRule
 	- PHPStan\Rules\Symfony\ContainerInterfaceUnknownServiceRule
+	- PHPStan\Rules\Symfony\UndefinedArgumentRule
+	- PHPStan\Rules\Symfony\InvalidArgumentDefaultValueRule
 
 services:
+	# console resolver
+	-
+		factory: PHPStan\Symfony\ConsoleApplicationResolver
+		arguments: [%symfony.console_application_loader%]
+
 	# service map
 	symfony.serviceMapFactory:
 		class: PHPStan\Symfony\ServiceMapFactory
@@ -55,3 +63,13 @@ services:
 	-
 		factory: PHPStan\Type\Symfony\EnvelopeReturnTypeExtension
 		tags: [phpstan.broker.dynamicMethodReturnTypeExtension]
+
+	# InputInterface::getArgument() return type
+	-
+		factory: PHPStan\Type\Symfony\InputInterfaceGetArgumentDynamicReturnTypeExtension
+		tags: [phpstan.broker.dynamicMethodReturnTypeExtension]
+
+	# InputInterface::hasArgument() type specification
+	-
+		factory: PHPStan\Type\Symfony\ArgumentTypeSpecifyingExtension
+		tags: [phpstan.typeSpecifier.methodTypeSpecifyingExtension]

phpstan.neon

@@ -7,6 +7,8 @@ parameters:
 	excludes_analyse:
 		- */tests/tmp/*
 		- */tests/*/Example*.php
+		- */tests/*/console_application_loader.php
+		- */tests/*/envelope_all.php
 		- */tests/*/header_bag_get.php
 		- */tests/*/request_get_content.php
 		- */tests/*/serializer.php

src/Rules/Symfony/InvalidArgumentDefaultValueRule.php

@@ -0,0 +1,78 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Symfony;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\ArrayType;
+use PHPStan\Type\Constant\ConstantIntegerType;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\NullType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\StringType;
+use PHPStan\Type\TypeUtils;
+use PHPStan\Type\UnionType;
+use PHPStan\Type\VerbosityLevel;
+use function sprintf;
+
+final class InvalidArgumentDefaultValueRule implements Rule
+{
+
+	public function getNodeType(): string
+	{
+		return MethodCall::class;
+	}
+
+	/**
+	 * @param \PhpParser\Node $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return (string|\PHPStan\Rules\RuleError)[] errors
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (!$node instanceof MethodCall) {
+			throw new ShouldNotHappenException();
+		};
+
+		if (!(new ObjectType('Symfony\Component\Console\Command\Command'))->isSuperTypeOf($scope->getType($node->var))->yes()) {
+			return [];
+		}
+		if (!$node->name instanceof Node\Identifier || $node->name->name !== 'addArgument') {
+			return [];
+		}
+		if (!isset($node->args[3])) {
+			return [];
+		}
+
+		$modeType = isset($node->args[1]) ? $scope->getType($node->args[1]->value) : new NullType();
+		if ($modeType instanceof NullType) {
+			$modeType = new ConstantIntegerType(2); // InputArgument::OPTIONAL
+		}
+		$modeTypes = TypeUtils::getConstantScalars($modeType);
+		if (count($modeTypes) !== 1) {
+			return [];
+		}
+		if (!$modeTypes[0] instanceof ConstantIntegerType) {
+			return [];
+		}
+		$mode = $modeTypes[0]->getValue();
+
+		$defaultType = $scope->getType($node->args[3]->value);
+
+		// not an array
+		if (($mode & 4) !== 4 && !(new UnionType([new StringType(), new NullType()]))->isSuperTypeOf($defaultType)->yes()) {
+			return [sprintf('Parameter #4 $default of method Symfony\Component\Console\Command\Command::addArgument() expects string|null, %s given.', $defaultType->describe(VerbosityLevel::typeOnly()))];
+		}
+
+		// is array
+		if (($mode & 4) === 4 && !(new UnionType([new ArrayType(new IntegerType(), new StringType()), new NullType()]))->isSuperTypeOf($defaultType)->yes()) {
+			return [sprintf('Parameter #4 $default of method Symfony\Component\Console\Command\Command::addArgument() expects array<int, string>|null, %s given.', $defaultType->describe(VerbosityLevel::typeOnly()))];
+		}
+
+		return [];
+	}
+
+}

src/Rules/Symfony/UndefinedArgumentRule.php

@@ -0,0 +1,90 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Symfony;
+
+use InvalidArgumentException;
+use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\PrettyPrinter\Standard;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Symfony\ConsoleApplicationResolver;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Symfony\Helper;
+use PHPStan\Type\TypeUtils;
+use function count;
+use function sprintf;
+
+final class UndefinedArgumentRule implements Rule
+{
+
+	/** @var \PHPStan\Symfony\ConsoleApplicationResolver */
+	private $consoleApplicationResolver;
+
+	/** @var \PhpParser\PrettyPrinter\Standard */
+	private $printer;
+
+	public function __construct(ConsoleApplicationResolver $consoleApplicationResolver, Standard $printer)
+	{
+		$this->consoleApplicationResolver = $consoleApplicationResolver;
+		$this->printer = $printer;
+	}
+
+	public function getNodeType(): string
+	{
+		return MethodCall::class;
+	}
+
+	/**
+	 * @param \PhpParser\Node $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return (string|\PHPStan\Rules\RuleError)[] errors
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (!$node instanceof MethodCall) {
+			throw new ShouldNotHappenException();
+		};
+
+		$classReflection = $scope->getClassReflection();
+		if ($classReflection === null) {
+			throw new ShouldNotHappenException();
+		}
+
+		if (!(new ObjectType('Symfony\Component\Console\Command\Command'))->isSuperTypeOf(new ObjectType($classReflection->getName()))->yes()) {
+			return [];
+		}
+		if (!(new ObjectType('Symfony\Component\Console\Input\InputInterface'))->isSuperTypeOf($scope->getType($node->var))->yes()) {
+			return [];
+		}
+		if (!$node->name instanceof Node\Identifier || $node->name->name !== 'getArgument') {
+			return [];
+		}
+		if (!isset($node->args[0])) {
+			return [];
+		}
+
+		$argType = $scope->getType($node->args[0]->value);
+		$argStrings = TypeUtils::getConstantStrings($argType);
+		if (count($argStrings) !== 1) {
+			return [];
+		}
+		$argName = $argStrings[0]->getValue();
+
+		$errors = [];
+		foreach ($this->consoleApplicationResolver->findCommands($classReflection) as $name => $command) {
+			try {
+				$command->getDefinition()->getArgument($argName);
+			} catch (InvalidArgumentException $e) {
+				if ($scope->getType(Helper::createMarkerNode($node->var, $argType, $this->printer))->equals($argType)) {
+					continue;
+				}
+				$errors[] = sprintf('Command "%s" does not define argument "%s".', $name, $argName);
+			}
+		}
+
+		return $errors;
+	}
+
+}

src/Symfony/ConsoleApplicationResolver.php

@@ -0,0 +1,66 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Symfony;
+
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\ObjectType;
+use function file_exists;
+use function get_class;
+use function is_readable;
+
+final class ConsoleApplicationResolver
+{
+
+	/** @var \Symfony\Component\Console\Application|null */
+	private $consoleApplication;
+
+	public function __construct(?string $consoleApplicationLoader)
+	{
+		if ($consoleApplicationLoader === null) {
+			return;
+		}
+		$this->consoleApplication = $this->loadConsoleApplication($consoleApplicationLoader);
+	}
+
+	/**
+	 * @return \Symfony\Component\Console\Application|null
+	 * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingReturnTypeHint
+	 */
+	private function loadConsoleApplication(string $consoleApplicationLoader)
+	{
+		if (!file_exists($consoleApplicationLoader)
+			|| !is_readable($consoleApplicationLoader)
+		) {
+			throw new ShouldNotHappenException();
+		}
+
+		return require $consoleApplicationLoader;
+	}
+
+	/**
+	 * @return \Symfony\Component\Console\Command\Command[]
+	 */
+	public function findCommands(ClassReflection $classReflection): array
+	{
+		if ($this->consoleApplication === null) {
+			return [];
+		}
+
+		$classType = new ObjectType($classReflection->getName());
+		if (!(new ObjectType('Symfony\Component\Console\Command\Command'))->isSuperTypeOf($classType)->yes()) {
+			return [];
+		}
+
+		$commands = [];
+		foreach ($this->consoleApplication->all() as $name => $command) {
+			if (!$classType->isSuperTypeOf(new ObjectType(get_class($command)))->yes()) {
+				continue;
+			}
+			$commands[$name] = $command;
+		}
+
+		return $commands;
+	}
+
+}

src/Type/Symfony/ArgumentTypeSpecifyingExtension.php

@@ -0,0 +1,57 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Symfony;
+
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\PrettyPrinter\Standard;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeSpecifier;
+use PHPStan\Analyser\TypeSpecifierAwareExtension;
+use PHPStan\Analyser\TypeSpecifierContext;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\MethodTypeSpecifyingExtension;
+
+final class ArgumentTypeSpecifyingExtension implements MethodTypeSpecifyingExtension, TypeSpecifierAwareExtension
+{
+
+	/** @var \PhpParser\PrettyPrinter\Standard */
+	private $printer;
+
+	/** @var \PHPStan\Analyser\TypeSpecifier */
+	private $typeSpecifier;
+
+	public function __construct(Standard $printer)
+	{
+		$this->printer = $printer;
+	}
+
+	public function getClass(): string
+	{
+		return 'Symfony\Component\Console\Input\InputInterface';
+	}
+
+	public function isMethodSupported(MethodReflection $methodReflection, MethodCall $node, TypeSpecifierContext $context): bool
+	{
+		return $methodReflection->getName() === 'hasArgument' && !$context->null();
+	}
+
+	public function specifyTypes(MethodReflection $methodReflection, MethodCall $node, Scope $scope, TypeSpecifierContext $context): SpecifiedTypes
+	{
+		if (!isset($node->args[0])) {
+			return new SpecifiedTypes();
+		}
+		$argType = $scope->getType($node->args[0]->value);
+		return $this->typeSpecifier->create(
+			Helper::createMarkerNode($node->var, $argType, $this->printer),
+			$argType,
+			$context
+		);
+	}
+
+	public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void
+	{
+		$this->typeSpecifier = $typeSpecifier;
+	}
+
+}