Support define() and defined() in local scope

phpstan · Jun 30, 2018 · a4e248e · a4e248e
1 parent ffd57a3
commit a4e248e
Show file tree

Hide file tree

Showing 11 changed files with 213 additions and 30 deletions.
diff --git a/conf/config.neon b/conf/config.neon
@@ -352,6 +352,16 @@ services:
 		tags:
 			- phpstan.typeSpecifier.functionTypeSpecifyingExtension
 
+	-
+		class: PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension
+		tags:
+			- phpstan.typeSpecifier.functionTypeSpecifyingExtension
+
+	-
+		class: PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension
+		tags:
+			- phpstan.typeSpecifier.functionTypeSpecifyingExtension
+
 	-
 		class: PHPStan\Type\Php\IsIntFunctionTypeSpecifyingExtension
 		tags:

diff --git a/src/Analyser/Scope.php b/src/Analyser/Scope.php
@@ -318,6 +318,15 @@ private function isGlobalVariable(string $variableName): bool
 		], true);
 	}
 
+	public function hasConstant(Name $name): bool
+	{
+		$node = new ConstFetch(new Name\FullyQualified($name->toCodeString()));
+		if ($this->isSpecified($node)) {
+			return true;
+		}
+		return $this->broker->hasConstant($name, $this);
+	}
+
 	public function isInAnonymousFunction(): bool
 	{
 		return $this->inAnonymousFunctionReturnType !== null;

diff --git a/src/Rules/Comparison/ImpossibleCheckTypeHelper.php b/src/Rules/Comparison/ImpossibleCheckTypeHelper.php
@@ -33,19 +33,25 @@ public function findSpecifiedType(
 	{
 		if (
 			$node instanceof FuncCall
-			&& $node->name instanceof \PhpParser\Node\Name
-			&& strtolower((string) $node->name) === 'is_numeric'
 			&& count($node->args) > 0
 		) {
-			$argType = $scope->getType($node->args[0]->value);
-			if (count(\PHPStan\Type\TypeUtils::getConstantScalars($argType)) > 0) {
-				return !$argType->toNumber() instanceof ErrorType;
-			}
-
-			if (!(new StringType())->isSuperTypeOf($argType)->no()) {
-				return null;
+			if ($node->name instanceof \PhpParser\Node\Name) {
+				$functionName = strtolower((string) $node->name);
+				if ($functionName === 'is_numeric') {
+					$argType = $scope->getType($node->args[0]->value);
+					if (count(\PHPStan\Type\TypeUtils::getConstantScalars($argType)) > 0) {
+						return !$argType->toNumber() instanceof ErrorType;
+					}
+
+					if (!(new StringType())->isSuperTypeOf($argType)->no()) {
+						return null;
+					}
+				} elseif ($functionName === 'defined') {
+					return null;
+				}
 			}
 		}
+
 		$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition($scope, $node, TypeSpecifierContext::createTruthy());
 		$sureTypes = $specifiedTypes->getSureTypes();
 		$sureNotTypes = $specifiedTypes->getSureNotTypes();

diff --git a/src/Rules/Constants/ConstantRule.php b/src/Rules/Constants/ConstantRule.php
@@ -4,19 +4,10 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
-use PHPStan\Broker\Broker;
 
 class ConstantRule implements \PHPStan\Rules\Rule
 {
 
-	/** @var \PHPStan\Broker\Broker */
-	private $broker;
-
-	public function __construct(Broker $broker)
-	{
-		$this->broker = $broker;
-	}
-
 	public function getNodeType(): string
 	{
 		return Node\Expr\ConstFetch::class;
@@ -29,7 +20,7 @@ public function getNodeType(): string
 	 */
 	public function processNode(Node $node, Scope $scope): array
 	{
-		if (!$this->broker->hasConstant($node->name, $scope)) {
+		if (!$scope->hasConstant($node->name)) {
 			return [
 				sprintf(
 					'Constant %s not found.',

diff --git a/src/Type/Php/DefineConstantTypeSpecifyingExtension.php b/src/Type/Php/DefineConstantTypeSpecifyingExtension.php
@@ -0,0 +1,61 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Php;
+
+use PhpParser\Node\Expr\FuncCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeSpecifier;
+use PHPStan\Analyser\TypeSpecifierAwareExtension;
+use PHPStan\Analyser\TypeSpecifierContext;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\FunctionTypeSpecifyingExtension;
+
+class DefineConstantTypeSpecifyingExtension implements FunctionTypeSpecifyingExtension, TypeSpecifierAwareExtension
+{
+
+	/** @var TypeSpecifier */
+	private $typeSpecifier;
+
+	public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void
+	{
+		$this->typeSpecifier = $typeSpecifier;
+	}
+
+	public function isFunctionSupported(
+		FunctionReflection $functionReflection,
+		FuncCall $node,
+		TypeSpecifierContext $context
+	): bool
+	{
+		return $functionReflection->getName() === 'define'
+			&& $context->null()
+			&& count($node->args) >= 2;
+	}
+
+	public function specifyTypes(
+		FunctionReflection $functionReflection,
+		FuncCall $node,
+		Scope $scope,
+		TypeSpecifierContext $context
+	): SpecifiedTypes
+	{
+		$constantName = $scope->getType($node->args[0]->value);
+		if (
+			!$constantName instanceof ConstantStringType
+			|| $constantName->getValue() === ''
+		) {
+			return new SpecifiedTypes([], []);
+		}
+
+		return $this->typeSpecifier->create(
+			new \PhpParser\Node\Expr\ConstFetch(
+				new \PhpParser\Node\Name\FullyQualified($constantName->getValue())
+			),
+			$scope->getType($node->args[1]->value),
+			TypeSpecifierContext::createTruthy()
+		);
+	}
+
+}
diff --git a/src/Type/Php/DefinedConstantTypeSpecifyingExtension.php b/src/Type/Php/DefinedConstantTypeSpecifyingExtension.php
@@ -0,0 +1,62 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Php;
+
+use PhpParser\Node\Expr\FuncCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeSpecifier;
+use PHPStan\Analyser\TypeSpecifierAwareExtension;
+use PHPStan\Analyser\TypeSpecifierContext;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\FunctionTypeSpecifyingExtension;
+use PHPStan\Type\MixedType;
+
+class DefinedConstantTypeSpecifyingExtension implements FunctionTypeSpecifyingExtension, TypeSpecifierAwareExtension
+{
+
+	/** @var TypeSpecifier */
+	private $typeSpecifier;
+
+	public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void
+	{
+		$this->typeSpecifier = $typeSpecifier;
+	}
+
+	public function isFunctionSupported(
+		FunctionReflection $functionReflection,
+		FuncCall $node,
+		TypeSpecifierContext $context
+	): bool
+	{
+		return $functionReflection->getName() === 'defined'
+			&& count($node->args) >= 1
+			&& !$context->null();
+	}
+
+	public function specifyTypes(
+		FunctionReflection $functionReflection,
+		FuncCall $node,
+		Scope $scope,
+		TypeSpecifierContext $context
+	): SpecifiedTypes
+	{
+		$constantName = $scope->getType($node->args[0]->value);
+		if (
+			!$constantName instanceof ConstantStringType
+			|| $constantName->getValue() === ''
+		) {
+			return new SpecifiedTypes([], []);
+		}
+
+		return $this->typeSpecifier->create(
+			new \PhpParser\Node\Expr\ConstFetch(
+				new \PhpParser\Node\Name\FullyQualified($constantName->getValue())
+			),
+			new MixedType(),
+			$context
+		);
+	}
+
+}
diff --git a/tests/PHPStan/Analyser/NodeScopeResolverTest.php b/tests/PHPStan/Analyser/NodeScopeResolverTest.php
@@ -2731,6 +2731,10 @@ public function testLiteralArrays(
 
 	public function dataLiteralArraysKeys(): array
 	{
+		define('STRING_ONE', '1');
+		define('INT_ONE', 1);
+		define('STRING_FOO', 'foo');
+
 		return [
 			[
 				'0|1|2',
@@ -2797,12 +2801,6 @@ public function testLiteralArraysKeys(
 		string $evaluatedPointExpressionType
 	): void
 	{
-		if (!defined('STRING_ONE')) {
-			define('STRING_ONE', '1');
-			define('INT_ONE', 1);
-			define('STRING_FOO', 'foo');
-		}
-
 		$this->assertTypes(
 			__DIR__ . '/data/literal-arrays-keys.php',
 			$description,
@@ -5250,6 +5248,8 @@ public function testCombineTypes(
 
 	public function dataConstants(): array
 	{
+		define('ConstantsForNodeScopeResolverTest\\FOO_CONSTANT', 1);
+
 		return [
 			[
 				'1',
@@ -5259,6 +5259,14 @@ public function dataConstants(): array
 				'*ERROR*',
 				'NONEXISTENT_CONSTANT',
 			],
+			[
+				"'bar'",
+				'\\BAR_CONSTANT',
+			],
+			[
+				'mixed',
+				'\\BAZ_CONSTANT',
+			],
 		];
 	}
 
@@ -5272,9 +5280,6 @@ public function testConstants(
 		string $expression
 	): void
 	{
-		if (!defined('ConstantsForNodeScopeResolverTest\\FOO_CONSTANT')) {
-			define('ConstantsForNodeScopeResolverTest\\FOO_CONSTANT', 1);
-		}
 		$this->assertTypes(
 			__DIR__ . '/data/constants.php',
 			$description,

diff --git a/tests/PHPStan/Analyser/data/constants.php b/tests/PHPStan/Analyser/data/constants.php
@@ -4,4 +4,8 @@
 
 $foo = FOO_CONSTANT;
 
-die;
+define('BAR_CONSTANT', 'bar');
+
+if (defined('BAZ_CONSTANT')) {
+	die;
+}
diff --git a/tests/PHPStan/Rules/Comparison/data/check-type-function-call.php b/tests/PHPStan/Rules/Comparison/data/check-type-function-call.php
@@ -159,3 +159,18 @@ public function doFoo(
 	}
 
 }
+
+class DefinedConstant
+{
+
+	public function doFoo()
+	{
+		if (defined('DEFINITELY_DOES_NOT_EXIST')) {
+
+		}
+		if (!defined('ANOTHER_DEFINITELY_DOES_NOT_EXIST')) {
+
+		}
+	}
+
+}
diff --git a/tests/PHPStan/Rules/Constants/ConstantRuleTest.php b/tests/PHPStan/Rules/Constants/ConstantRuleTest.php
@@ -7,7 +7,7 @@ class ConstantRuleTest extends \PHPStan\Testing\RuleTestCase
 
 	protected function getRule(): \PHPStan\Rules\Rule
 	{
-		return new ConstantRule($this->createBroker());
+		return new ConstantRule();
 	}
 
 	public function testConstants(): void
@@ -20,6 +20,14 @@ public function testConstants(): void
 				'Constant NONEXISTENT_CONSTANT not found.',
 				10,
 			],
+			[
+				'Constant DEFINED_CONSTANT not found.',
+				13,
+			],
+			/*[
+				'Constant DEFINED_CONSTANT_IF not found.',
+				21,
+			],*/
 		]);
 	}
 

diff --git a/tests/PHPStan/Rules/Constants/data/constants.php b/tests/PHPStan/Rules/Constants/data/constants.php
@@ -8,3 +8,15 @@
 echo BAR_CONSTANT;
 echo BAZ_CONSTANT;
 echo NONEXISTENT_CONSTANT;
+
+function () {
+	echo DEFINED_CONSTANT;
+	define('DEFINED_CONSTANT', true);
+	echo DEFINED_CONSTANT;
+
+	if (defined('DEFINED_CONSTANT_IF')) {
+		echo DEFINED_CONSTANT_IF;
+	}
+
+	echo DEFINED_CONSTANT_IF;
+};