Feature/deprecations

README.md

@@ -21,6 +21,7 @@
 * Always true `instanceof`, type-checking `is_*` functions and strict comparisons `===`/`!==`. These checks can be turned off by setting `checkAlwaysTrueInstanceof`/`checkAlwaysTrueCheckTypeFunctionCall`/`checkAlwaysTrueStrictComparison` to false.
 * Correct case for referenced and called function names.
 * Correct case for inherited and implemented method names.
+* Disallows the usage of deprecated code.
 
 Additional rules are coming in subsequent releases!
 

rules.neon

@@ -12,6 +12,17 @@ rules:
 	- PHPStan\Rules\BooleansInConditions\BooleanInElseIfConditionRule
 	- PHPStan\Rules\BooleansInConditions\BooleanInIfConditionRule
 	- PHPStan\Rules\BooleansInConditions\BooleanInTernaryOperatorRule
+	- PHPStan\Rules\Deprecations\AccessDeprecatedPropertyRule
+	- PHPStan\Rules\Deprecations\AccessDeprecatedStaticPropertyRule
+	- PHPStan\Rules\Deprecations\CallToDeprecatedFunctionRule
+	- PHPStan\Rules\Deprecations\CallToDeprecatedMethodRule
+	- PHPStan\Rules\Deprecations\CallToDeprecatedStaticMethodRule
+	- PHPStan\Rules\Deprecations\FetchingClassConstOfDeprecatedClassRule
+	- PHPStan\Rules\Deprecations\ImplementationOfDeprecatedInterfaceRule
+	- PHPStan\Rules\Deprecations\InheritanceOfDeprecatedClassRule
+	- PHPStan\Rules\Deprecations\InheritanceOfDeprecatedInterfaceRule
+	- PHPStan\Rules\Deprecations\InstantiationOfDeprecatedClassRule
+	- PHPStan\Rules\Deprecations\UsageOfDeprecatedTraitRule
 	- PHPStan\Rules\DisallowedConstructs\DisallowedEmptyRule
 	- PHPStan\Rules\DisallowedConstructs\DisallowedImplicitArrayCreationRule
 	- PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule

src/Rules/Deprecations/AccessDeprecatedPropertyRule.php

@@ -0,0 +1,74 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Deprecations;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\PropertyFetch;
+use PhpParser\Node\Identifier;
+use PHPStan\Analyser\Scope;
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\DeprecatableReflection;
+use PHPStan\Type\TypeUtils;
+
+class AccessDeprecatedPropertyRule implements \PHPStan\Rules\Rule
+{
+
+	/** @var Broker */
+	private $broker;
+
+	public function __construct(Broker $broker)
+	{
+		$this->broker = $broker;
+	}
+
+	public function getNodeType(): string
+	{
+		return PropertyFetch::class;
+	}
+
+	/**
+	 * @param PropertyFetch $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return string[] errors
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (DeprecatedScopeHelper::isScopeDeprecated($scope)) {
+			return [];
+		}
+
+		if (!$node->name instanceof Identifier) {
+			return [];
+		}
+
+		$propertyName = $node->name->name;
+		$propertyAccessedOnType = $scope->getType($node->var);
+		$referencedClasses = TypeUtils::getDirectClassNames($propertyAccessedOnType);
+
+		foreach ($referencedClasses as $referencedClass) {
+			try {
+				$classReflection = $this->broker->getClass($referencedClass);
+				$propertyReflection = $classReflection->getProperty($propertyName, $scope);
+
+				if (!$propertyReflection instanceof DeprecatableReflection) {
+					continue;
+				}
+
+				if ($propertyReflection->isDeprecated()) {
+					return [sprintf(
+						'Access to deprecated property $%s of class %s.',
+						$propertyName,
+						$propertyReflection->getDeclaringClass()->getName()
+					)];
+				}
+			} catch (\PHPStan\Broker\ClassNotFoundException $e) {
+				// Other rules will notify if the class is not found
+			} catch (\PHPStan\Reflection\MissingPropertyFromReflectionException $e) {
+				// Other rules will notify if the property is not found
+			}
+		}
+
+		return [];
+	}
+
+}

src/Rules/Deprecations/AccessDeprecatedStaticPropertyRule.php

@@ -0,0 +1,95 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Deprecations;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\StaticPropertyFetch;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\DeprecatableReflection;
+use PHPStan\Rules\RuleLevelHelper;
+use PHPStan\Type\ErrorType;
+use PHPStan\Type\Type;
+
+class AccessDeprecatedStaticPropertyRule implements \PHPStan\Rules\Rule
+{
+
+	/** @var Broker */
+	private $broker;
+
+	/** @var RuleLevelHelper */
+	private $ruleLevelHelper;
+
+	public function __construct(Broker $broker, RuleLevelHelper $ruleLevelHelper)
+	{
+		$this->broker = $broker;
+		$this->ruleLevelHelper = $ruleLevelHelper;
+	}
+
+	public function getNodeType(): string
+	{
+		return StaticPropertyFetch::class;
+	}
+
+	/**
+	 * @param StaticPropertyFetch $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return string[] errors
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (DeprecatedScopeHelper::isScopeDeprecated($scope)) {
+			return [];
+		}
+
+		if (!$node->name instanceof Identifier) {
+			return [];
+		}
+
+		$propertyName = $node->name->name;
+		$referencedClasses = [];
+
+		if ($node->class instanceof Name) {
+			$referencedClasses[] = (string) $node->class;
+		} else {
+			$classTypeResult = $this->ruleLevelHelper->findTypeToCheck(
+				$scope,
+				$node->class,
+				'', // We don't care about the error message
+				function (Type $type) use ($propertyName) {
+					return $type->canAccessProperties()->yes() && $type->hasProperty($propertyName);
+				}
+			);
+
+			if ($classTypeResult->getType() instanceof ErrorType) {
+				return [];
+			}
+
+			$referencedClasses = $classTypeResult->getReferencedClasses();
+		}
+
+		foreach ($referencedClasses as $referencedClass) {
+			try {
+				$class = $this->broker->getClass($referencedClass);
+				$property = $class->getProperty($propertyName, $scope);
+			} catch (\PHPStan\Broker\ClassNotFoundException $e) {
+				continue;
+			} catch (\PHPStan\Reflection\MissingPropertyFromReflectionException $e) {
+				continue;
+			}
+
+			if ($property instanceof DeprecatableReflection && $property->isDeprecated()) {
+				return [sprintf(
+					'Access to deprecated static property $%s of class %s.',
+					$propertyName,
+					$referencedClass
+				)];
+			}
+		}
+
+		return [];
+	}
+
+}

src/Rules/Deprecations/CallToDeprecatedFunctionRule.php

@@ -0,0 +1,58 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Deprecations;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\FuncCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Broker\Broker;
+
+class CallToDeprecatedFunctionRule implements \PHPStan\Rules\Rule
+{
+
+	/** @var Broker */
+	private $broker;
+
+	public function __construct(Broker $broker)
+	{
+		$this->broker = $broker;
+	}
+
+	public function getNodeType(): string
+	{
+		return FuncCall::class;
+	}
+
+	/**
+	 * @param FuncCall $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return string[] errors
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (DeprecatedScopeHelper::isScopeDeprecated($scope)) {
+			return [];
+		}
+
+		if (!($node->name instanceof \PhpParser\Node\Name)) {
+			return [];
+		}
+
+		try {
+			$function = $this->broker->getFunction($node->name, $scope);
+		} catch (\PHPStan\Broker\FunctionNotFoundException $e) {
+			// Other rules will notify if the function is not found
+			return [];
+		}
+
+		if ($function->isDeprecated()) {
+			return [sprintf(
+				'Call to deprecated function %s().',
+				$function->getName()
+			)];
+		}
+
+		return [];
+	}
+
+}

src/Rules/Deprecations/CallToDeprecatedMethodRule.php

@@ -0,0 +1,74 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Deprecations;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Identifier;
+use PHPStan\Analyser\Scope;
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\DeprecatableReflection;
+use PHPStan\Type\TypeUtils;
+
+class CallToDeprecatedMethodRule implements \PHPStan\Rules\Rule
+{
+
+	/** @var Broker */
+	private $broker;
+
+	public function __construct(Broker $broker)
+	{
+		$this->broker = $broker;
+	}
+
+	public function getNodeType(): string
+	{
+		return MethodCall::class;
+	}
+
+	/**
+	 * @param MethodCall $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return string[] errors
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (DeprecatedScopeHelper::isScopeDeprecated($scope)) {
+			return [];
+		}
+
+		if (!$node->name instanceof Identifier) {
+			return [];
+		}
+
+		$methodName = $node->name->name;
+		$methodCalledOnType = $scope->getType($node->var);
+		$referencedClasses = TypeUtils::getDirectClassNames($methodCalledOnType);
+
+		foreach ($referencedClasses as $referencedClass) {
+			try {
+				$classReflection = $this->broker->getClass($referencedClass);
+				$methodReflection = $classReflection->getMethod($methodName, $scope);
+
+				if (!$methodReflection instanceof DeprecatableReflection) {
+					continue;
+				}
+
+				if ($methodReflection->isDeprecated()) {
+					return [sprintf(
+						'Call to deprecated method %s() of class %s.',
+						$methodReflection->getName(),
+						$methodReflection->getDeclaringClass()->getName()
+					)];
+				}
+			} catch (\PHPStan\Broker\ClassNotFoundException $e) {
+				// Other rules will notify if the class is not found
+			} catch (\PHPStan\Reflection\MissingMethodFromReflectionException $e) {
+				// Other rules will notify if the the method is not found
+			}
+		}
+
+		return [];
+	}
+
+}