Add phpstan-sealed support

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(),
+		];
+	}
+
+}

tests/PHPStan/Analyser/nsrt/class-name-usage-location.php

@@ -6,7 +6,7 @@
 use function PHPStan\Testing\assertType;
 
 function (ClassNameUsageLocation $location): void {
-	assertType("'assert.test'|'attribute.test'|'catch.test'|'class.extendsTest'|'class.implementsTest'|'classConstant.test'|'enum.implementsTest'|'generics.testBound'|'generics.testDefault'|'instanceof.test'|'interface.extendsTest'|'methodTag.test'|'mixin.test'|'new.test'|'parameter.test'|'property.test'|'propertyTag.test'|'requireExtends.test'|'requireImplements.test'|'return.test'|'selfOut.test'|'staticMethod.test'|'staticProperty.test'|'traitUse.test'|'typeAlias.test'|'varTag.test'", $location->createIdentifier('test'));
+	assertType("'assert.test'|'attribute.test'|'catch.test'|'class.extendsTest'|'class.implementsTest'|'classConstant.test'|'enum.implementsTest'|'generics.testBound'|'generics.testDefault'|'instanceof.test'|'interface.extendsTest'|'methodTag.test'|'mixin.test'|'new.test'|'parameter.test'|'property.test'|'propertyTag.test'|'requireExtends.test'|'requireImplements.test'|'return.test'|'sealed.test'|'selfOut.test'|'staticMethod.test'|'staticProperty.test'|'traitUse.test'|'typeAlias.test'|'varTag.test'", $location->createIdentifier('test'));
 
 	if ($location->value === ClassNameUsageLocation::INSTANTIATION || $location->value === ClassNameUsageLocation::PROPERTY_TYPE) {
 		assertType("'new.test'|'property.test'", $location->createIdentifier('test'));