Add @phpstan-sealed support

Author: VincentLanglet

src/Dependency/DependencyResolver.php

@@ -536,6 +536,15 @@ private function addClassToDependencies(string $className, array &$dependenciesR
 }
 }
 
+foreach ($classReflection->getSealedTags() as $sealedTag) {
+foreach ($sealedTag->getType()->getReferencedClasses() as $referencedClass) {
+if (!$this->reflectionProvider->hasClass($referencedClass)) {
+continue;
+}
+$dependenciesReflections[] = $this->reflectionProvider->getClass($referencedClass);
+}
+}
+
 foreach ($classReflection->getTemplateTags() as $templateTag) {
 foreach ($templateTag->getBound()->getReferencedClasses() as $referencedClass) {
 if (!$this->reflectionProvider->hasClass($referencedClass)) {

src/PhpDoc/PhpDocNodeResolver.php

@@ -19,6 +19,7 @@
 use PHPStan\PhpDoc\Tag\RequireExtendsTag;
 use PHPStan\PhpDoc\Tag\RequireImplementsTag;
 use PHPStan\PhpDoc\Tag\ReturnTag;
+use PHPStan\PhpDoc\Tag\SealedTypeTag;
 use PHPStan\PhpDoc\Tag\SelfOutTypeTag;
 use PHPStan\PhpDoc\Tag\TemplateTag;
 use PHPStan\PhpDoc\Tag\ThrowsTag;
@@ -524,6 +525,24 @@ public function resolveRequireImplementsTags(PhpDocNode $phpDocNode, NameScope $
 return $resolved;
 }
 
+/**
+ * @return array<SealedTypeTag>
+ */
+public function resolveSealedTags(PhpDocNode $phpDocNode, NameScope $nameScope): array
+{
+$resolved = [];
+
+foreach (['@psalm-inheritors', '@phpstan-sealed'] as $tagName) {
+foreach ($phpDocNode->getSealedTagValues($tagName) as $tagValue) {
+$resolved[] = new SealedTypeTag(
+$this->typeNodeResolver->resolve($tagValue->type, $nameScope),
+);
+}
+}
+
+return $resolved;
+}
+
 /**
  * @return array<string, TypeAliasTag>
  */

src/PhpDoc/ResolvedPhpDocBlock.php

@@ -16,6 +16,7 @@
 use PHPStan\PhpDoc\Tag\RequireExtendsTag;
 use PHPStan\PhpDoc\Tag\RequireImplementsTag;
 use PHPStan\PhpDoc\Tag\ReturnTag;
+use PHPStan\PhpDoc\Tag\SealedTypeTag;
 use PHPStan\PhpDoc\Tag\SelfOutTypeTag;
 use PHPStan\PhpDoc\Tag\TemplateTag;
 use PHPStan\PhpDoc\Tag\ThrowsTag;
@@ -111,6 +112,9 @@ final class ResolvedPhpDocBlock
 /** @var array<RequireImplementsTag>|false */
 private array|false $requireImplementsTags = false;
 
+/** @var array<SealedTypeTag>|false */
+private array|false $sealedTypeTags = false;
+
 /** @var array<TypeAliasTag>|false */
 private array|false $typeAliasTags = false;
 
@@ -218,6 +222,7 @@ public static function createEmpty(): self
 $self->mixinTags = [];
 $self->requireExtendsTags = [];
 $self->requireImplementsTags = [];
+$self->sealedTypeTags = [];
 $self->typeAliasTags = [];
 $self->typeAliasImportTags = [];
 $self->assertTags = [];
@@ -282,6 +287,7 @@ public function merge(array $parents, array $parentPhpDocBlocks): self
 $result->mixinTags = $this->getMixinTags();
 $result->requireExtendsTags = $this->getRequireExtendsTags();
 $result->requireImplementsTags = $this->getRequireImplementsTags();
+$result->sealedTypeTags = $this->getSealedTags();
 $result->typeAliasTags = $this->getTypeAliasTags();
 $result->typeAliasImportTags = $this->getTypeAliasImportTags();
 $result->assertTags = self::mergeAssertTags($this->getAssertTags(), $parents, $parentPhpDocBlocks);
@@ -663,6 +669,21 @@ public function getRequireImplementsTags(): array
 return $this->requireImplementsTags;
 }
 
+/**
+ * @return array<SealedTypeTag>
+ */
+public function getSealedTags(): array
+{
+if ($this->sealedTypeTags === false) {
+$this->sealedTypeTags = $this->phpDocNodeResolver->resolveSealedTags(
+$this->phpDocNode,
+$this->getNameScope(),
+);
+}
+
+return $this->sealedTypeTags;
+}
+
 /**
  * @return array<TypeAliasTag>
  */

src/PhpDoc/Tag/SealedTypeTag.php

@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDoc\Tag;
+
+use PHPStan\Type\Type;
+
+/**
+ * @api
+ */
+final class SealedTypeTag implements TypedTag
+{
+
+public function __construct(private Type $type)
+{
+}
+
+public function getType(): Type
+{
+return $this->type;
+}
+
+public function withType(Type $type): self
+{
+return new self($type);
+}
+
+}

src/Reflection/ClassReflection.php

@@ -23,6 +23,7 @@
 use PHPStan\PhpDoc\Tag\PropertyTag;
 use PHPStan\PhpDoc\Tag\RequireExtendsTag;
 use PHPStan\PhpDoc\Tag\RequireImplementsTag;
+use PHPStan\PhpDoc\Tag\SealedTypeTag;
 use PHPStan\PhpDoc\Tag\TemplateTag;
 use PHPStan\PhpDoc\Tag\TypeAliasImportTag;
 use PHPStan\PhpDoc\Tag\TypeAliasTag;
@@ -1887,6 +1888,19 @@ public function getRequireImplementsTags(): array
 return $resolvedPhpDoc->getRequireImplementsTags();
 }
 
+/**
+ * @return array<SealedTypeTag>
+ */
+public function getSealedTags(): array
+{
+$resolvedPhpDoc = $this->getResolvedPhpDoc();
+if ($resolvedPhpDoc === null) {
+return [];
+}
+
+return $resolvedPhpDoc->getSealedTags();
+}
+
 /**
  * @return array<string, PropertyTag>
  */

src/Reflection/Php/SealedAllowedSubTypesClassReflectionExtension.php

@@ -0,0 +1,36 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Reflection\Php;
+
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Reflection\AllowedSubTypesClassReflectionExtension;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Type\UnionType;
+use function count;
+
+#[AutowiredService]
+final class SealedAllowedSubTypesClassReflectionExtension implements AllowedSubTypesClassReflectionExtension
+{
+
+public function supports(ClassReflection $classReflection): bool
+{
+return count($classReflection->getSealedTags()) > 0;
+}
+
+public function getAllowedSubTypes(ClassReflection $classReflection): array
+{
+$types = [];
+
+foreach ($classReflection->getSealedTags() as $sealedTag) {
+$type = $sealedTag->getType();
+if ($type instanceof UnionType) {
+$types = $type->getTypes();
+} else {
+$types = [$type];
+}
+}
+
+return $types;
+}
+
+}

src/Rules/ClassNameUsageLocation.php

@@ -38,6 +38,7 @@ final class ClassNameUsageLocation
 public const PHPDOC_TAG_PROPERTY = 'propertyTag';
 public const PHPDOC_TAG_REQUIRE_EXTENDS = 'requireExtends';
 public const PHPDOC_TAG_REQUIRE_IMPLEMENTS = 'requireImplements';
+public const PHPDOC_TAG_SEALED = 'sealed';
 public const STATIC_METHOD_CALL = 'staticMethod';
 public const PHPDOC_TAG_TEMPLATE_BOUND = 'templateBound';
 public const PHPDOC_TAG_TEMPLATE_DEFAULT = 'templateDefault';
@@ -255,6 +256,8 @@ public function createMessage(string $part): string
 return sprintf('PHPDoc tag @phpstan-require-extends references %s.', $part);
 case self::PHPDOC_TAG_REQUIRE_IMPLEMENTS:
 return sprintf('PHPDoc tag @phpstan-require-implements references %s.', $part);
+case self::PHPDOC_TAG_SEALED:
+return sprintf('PHPDoc tag @phpstan-sealed references %s.', $part);
 case self::STATIC_METHOD_CALL:
 $method = $this->getMethod();
 if ($method !== null) {

src/Rules/PhpDoc/InvalidPHPStanDocTagRule.php

@@ -58,6 +58,7 @@ final class InvalidPHPStanDocTagRule implements Rule
 '@phpstan-readonly-allow-private-mutation',
 '@phpstan-require-extends',
 '@phpstan-require-implements',
+'@phpstan-sealed',
 '@phpstan-param-immediately-invoked-callable',
 '@phpstan-param-later-invoked-callable',
 '@phpstan-param-closure-this',

src/Rules/PhpDoc/SealedDefinitionClassRule.php

@@ -0,0 +1,100 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PhpDoc;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\DependencyInjection\AutowiredParameter;
+use PHPStan\DependencyInjection\RegisteredRule;
+use PHPStan\Node\InClassNode;
+use PHPStan\Rules\ClassNameCheck;
+use PHPStan\Rules\ClassNameNodePair;
+use PHPStan\Rules\ClassNameUsageLocation;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\VerbosityLevel;
+use function array_column;
+use function array_map;
+use function array_merge;
+use function count;
+use function sprintf;
+
+/**
+ * @implements Rule<InClassNode>
+ */
+#[RegisteredRule(level: 2)]
+final class SealedDefinitionClassRule implements Rule
+{
+
+public function __construct(
+private ClassNameCheck $classCheck,
+#[AutowiredParameter]
+private bool $checkClassCaseSensitivity,
+#[AutowiredParameter(ref: '%tips.discoveringSymbols%')]
+private bool $discoveringSymbolsTip,
+)
+{
+}
+
+public function getNodeType(): string
+{
+return InClassNode::class;
+}
+
+public function processNode(Node $node, Scope $scope): array
+{
+$classReflection = $node->getClassReflection();
+$sealedTags = $classReflection->getSealedTags();
+
+if (count($sealedTags) === 0) {
+return [];
+}
+
+if ($classReflection->isEnum()) {
+return [
+RuleErrorBuilder::message('PHPDoc tag @phpstan-sealed is only valid on class or interface.')
+->identifier('sealed.onEnum')
+->build(),
+];
+}
+
+$errors = [];
+foreach ($sealedTags as $sealedTag) {
+$type = $sealedTag->getType();
+$classNames = $type->getObjectClassNames();
+if (count($classNames) === 0) {
+$errors[] = RuleErrorBuilder::message(sprintf('PHPDoc tag @phpstan-sealed contains non-object type %s.', $type->describe(VerbosityLevel::typeOnly())))
+->identifier('sealed.nonObject')
+->build();
+continue;
+}
+
+$referencedClassReflections = array_map(static fn ($reflection) => [$reflection, $reflection->getName()], $type->getObjectClassReflections());
+$referencedClassReflectionsMap = array_column($referencedClassReflections, 0, 1);
+foreach ($classNames as $class) {
+$referencedClassReflection = $referencedClassReflectionsMap[$class] ?? null;
+if ($referencedClassReflection === null) {
+$errorBuilder = RuleErrorBuilder::message(sprintf('PHPDoc tag @phpstan-sealed contains unknown class %s.', $class))
+->identifier('class.notFound');
+
+if ($this->discoveringSymbolsTip) {
+$errorBuilder->discoveringSymbolsTip();
+}
+
+$errors[] = $errorBuilder->build();
+continue;
+}
+
+$errors = array_merge(
+$errors,
+$this->classCheck->checkClassNames($scope, [
+new ClassNameNodePair($class, $node),
+], ClassNameUsageLocation::from(ClassNameUsageLocation::PHPDOC_TAG_SEALED), $this->checkClassCaseSensitivity),
+);
+}
+}
+
+return $errors;
+}
+
+}

src/Rules/PhpDoc/SealedDefinitionTraitRule.php

@@ -0,0 +1,54 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PhpDoc;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\DependencyInjection\RegisteredRule;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use function count;
+
+/**
+ * @implements Rule<Node\Stmt\Trait_>
+ */
+#[RegisteredRule(level: 0)]
+final class SealedDefinitionTraitRule implements Rule
+{
+
+public function __construct(
+private ReflectionProvider $reflectionProvider,
+)
+{
+}
+
+public function getNodeType(): string
+{
+return Node\Stmt\Trait_::class;
+}
+
+public function processNode(Node $node, Scope $scope): array
+{
+if (
+$node->namespacedName === null
+|| !$this->reflectionProvider->hasClass($node->namespacedName->toString())
+) {
+return [];
+}
+
+$traitReflection = $this->reflectionProvider->getClass($node->namespacedName->toString());
+$sealedTags = $traitReflection->getSealedTags();
+
+if (count($sealedTags) === 0) {
+return [];
+}
+
+return [
+RuleErrorBuilder::message('PHPDoc tag @phpstan-sealed is only valid on class or interface.')
+->identifier('sealed.onTrait')
+->build(),
+];
+}
+
+}