Implement require-extends rules

conf/config.level2.neon

@@ -64,6 +64,29 @@ services:
 			checkClassCaseSensitivity: %checkClassCaseSensitivity%
 		tags:
 			- phpstan.rules.rule
+
+	-
+		class: PHPStan\Rules\Classes\RequireExtendsRule
+		tags:
+			- phpstan.rules.rule
+	-
+		class: PHPStan\Rules\PhpDoc\IncompatibleRequireExtendsTypeRule
+		arguments:
+			checkClassCaseSensitivity: %checkClassCaseSensitivity%
+		tags:
+			- phpstan.rules.rule
+
+	-
+		class: PHPStan\Rules\Classes\RequireImplementsRule
+		tags:
+			- phpstan.rules.rule
+	-
+		class: PHPStan\Rules\PhpDoc\IncompatibleRequireImplementsTypeRule
+		arguments:
+			checkClassCaseSensitivity: %checkClassCaseSensitivity%
+		tags:
+			- phpstan.rules.rule
+
 	-
 		class: PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule
 	-

src/Rules/Classes/RequireExtendsRule.php

@@ -0,0 +1,76 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Classes;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\InClassNode;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\VerbosityLevel;
+use function in_array;
+use function sprintf;
+
+/**
+ * @implements Rule<InClassNode>
+ */
+class RequireExtendsRule implements Rule
+{
+
+	public function getNodeType(): string
+	{
+		return InClassNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$classReflection = $node->getClassReflection();
+		$parentNames = $classReflection->getParentClassesNames();
+
+		$errors = [];
+		foreach ($classReflection->getInterfaces() as $interface) {
+			$extendsTags = $interface->getRequireExtendsTags();
+			foreach ($extendsTags as $extendsTag) {
+				$type = $extendsTag->getType();
+				$typeName = $type->describe(VerbosityLevel::typeOnly());
+
+				if (in_array($typeName, $parentNames, true)) {
+					continue;
+				}
+
+				$errors[] = RuleErrorBuilder::message(
+					sprintf(
+						'%s requires implementing class to extend %s, but %s does not.',
+						$interface->getName(),
+						$type->describe(VerbosityLevel::typeOnly()),
+						$classReflection->getName(),
+					),
+				)->build();
+			}
+		}
+
+		foreach ($classReflection->getTraits() as $trait) {
+			$extendsTags = $trait->getRequireExtendsTags();
+			foreach ($extendsTags as $extendsTag) {
+				$type = $extendsTag->getType();
+				$typeName = $type->describe(VerbosityLevel::typeOnly());
+
+				if (in_array($typeName, $parentNames, true)) {
+					continue;
+				}
+
+				$errors[] = RuleErrorBuilder::message(
+					sprintf(
+						'%s requires using class to extend %s, but %s does not.',
+						$trait->getName(),
+						$type->describe(VerbosityLevel::typeOnly()),
+						$classReflection->getName(),
+					),
+				)->build();
+			}
+		}
+
+		return $errors;
+	}
+
+}

src/Rules/Classes/RequireImplementsRule.php

@@ -0,0 +1,57 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Classes;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\InClassNode;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\VerbosityLevel;
+use function array_map;
+use function in_array;
+use function sprintf;
+
+/**
+ * @implements Rule<InClassNode>
+ */
+class RequireImplementsRule implements Rule
+{
+
+	public function getNodeType(): string
+	{
+		return InClassNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$classReflection = $node->getClassReflection();
+		$interfaceNames = array_map(static fn (ClassReflection $interface): string => $interface->getName(), $classReflection->getInterfaces());
+
+		$errors = [];
+		foreach ($classReflection->getTraits() as $trait) {
+			$implementsTags = $trait->getRequireImplementsTags();
+			foreach ($implementsTags as $implementsTag) {
+				$type = $implementsTag->getType();
+				$typeName = $type->describe(VerbosityLevel::typeOnly());
+
+				if (in_array($typeName, $interfaceNames, true)) {
+					continue;
+				}
+
+				$errors[] = RuleErrorBuilder::message(
+					sprintf(
+						'%s requires using class to implement %s, but %s does not.',
+						$trait->getName(),
+						$type->describe(VerbosityLevel::typeOnly()),
+						$classReflection->getName(),
+					),
+				)->build();
+			}
+		}
+
+		return $errors;
+	}
+
+}

src/Rules/PhpDoc/IncompatibleRequireExtendsTypeRule.php

@@ -0,0 +1,125 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PhpDoc;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\ClassLike;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\ClassCaseSensitivityCheck;
+use PHPStan\Rules\ClassNameNodePair;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\Generic\GenericObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeTraverser;
+use PHPStan\Type\VerbosityLevel;
+use function array_merge;
+use function count;
+use function sprintf;
+
+/**
+ * @implements Rule<ClassLike>
+ */
+class IncompatibleRequireExtendsTypeRule implements Rule
+{
+
+	public function __construct(
+		private ReflectionProvider $reflectionProvider,
+		private ClassCaseSensitivityCheck $classCaseSensitivityCheck,
+		private UnresolvableTypeHelper $unresolvableTypeHelper,
+		private bool $checkClassCaseSensitivity,
+	)
+	{
+	}
+
+	public function getNodeType(): string
+	{
+		return ClassLike::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (
+			$node->namespacedName === null
+			|| !$this->reflectionProvider->hasClass($node->namespacedName->toString())
+		) {
+			return [];
+		}
+
+		$classReflection = $this->reflectionProvider->getClass($node->namespacedName->toString());
+		$extendsTags = $classReflection->getRequireExtendsTags();
+
+		if (
+			!$classReflection->isTrait()
+			&& ! $classReflection->isInterface()
+			&& count($extendsTags) > 0
+		) {
+			return [
+				RuleErrorBuilder::message('PHPDoc tag @require-extends is only valid on trait or interface.')->build(),
+			];
+		}
+
+		$errors = [];
+		foreach ($extendsTags as $extendsTag) {
+			$type = $extendsTag->getType();
+			if (!$type->canCallMethods()->yes() || !$type->canAccessProperties()->yes()) {
+				$errors[] = RuleErrorBuilder::message(sprintf('PHPDoc tag @require-extends contains non-object type %s.', $type->describe(VerbosityLevel::typeOnly())))->build();
+				continue;
+			}
+
+			if (
+				$this->unresolvableTypeHelper->containsUnresolvableType($type)
+			) {
+				$errors[] = RuleErrorBuilder::message('PHPDoc tag @require-extends contains unresolvable type.')->build();
+				continue;
+			}
+
+			if (
+				$this->containsGenericType($type)
+			) {
+				$errors[] = RuleErrorBuilder::message('PHPDoc tag @require-extends cannot contain generic type.')->build();
+				continue;
+			}
+
+			foreach ($type->getReferencedClasses() as $class) {
+				if (!$this->reflectionProvider->hasClass($class)) {
+					$errors[] = RuleErrorBuilder::message(sprintf('PHPDoc tag @require-extends contains unknown class %s.', $class))->discoveringSymbolsTip()->build();
+					continue;
+				}
+
+				$referencedClassReflection = $this->reflectionProvider->getClass($class);
+				if (!$referencedClassReflection->isClass()) {
+					$errors[] = RuleErrorBuilder::message(sprintf('PHPDoc tag @require-extends cannot contain non-class type %s.', $class))->build();
+				} elseif ($referencedClassReflection->isFinal()) {
+					$errors[] = RuleErrorBuilder::message(sprintf('PHPDoc tag @require-extends cannot contain final class %s.', $class))->build();
+				} elseif ($this->checkClassCaseSensitivity) {
+					$errors = array_merge(
+						$errors,
+						$this->classCaseSensitivityCheck->checkClassNames([
+							new ClassNameNodePair($class, $node),
+						]),
+					);
+				}
+			}
+		}
+
+		return $errors;
+	}
+
+	private function containsGenericType(Type $phpDocType): bool
+	{
+		$containsGeneric = false;
+		TypeTraverser::map($phpDocType, static function (Type $type, callable $traverse) use (&$containsGeneric): Type {
+			if ($type instanceof GenericObjectType) {
+				$containsGeneric = true;
+				return $type;
+			}
+			$traverse($type);
+			return $type;
+		});
+
+		return $containsGeneric;
+	}
+
+}