Readonly classes cannot be combined with #[AllowDynamicProperties]

Makefile

@@ -87,6 +87,8 @@ lint:
 		--exclude tests/PHPStan/Rules/Properties/data/non-abstract-hooked-properties-in-class.php \
 		--exclude tests/PHPStan/Rules/Properties/data/hooked-properties-in-class.php \
 		--exclude tests/PHPStan/Rules/Properties/data/hooked-properties-without-bodies-in-class.php \
+		--exclude tests/PHPStan/Rules/Classes/data/bug-12281.php \
+		--exclude tests/PHPStan/Rules/Traits/data/bug-12281.php \
 		src tests
 
 cs:

conf/config.level0.neon

@@ -103,6 +103,7 @@ rules:
 	- PHPStan\Rules\Regexp\RegularExpressionPatternRule
 	- PHPStan\Rules\Traits\ConflictingTraitConstantsRule
 	- PHPStan\Rules\Traits\ConstantsInTraitsRule
+	- PHPStan\Rules\Traits\TraitAttributesRule
 	- PHPStan\Rules\Types\InvalidTypesInUnionRule
 	- PHPStan\Rules\Variables\UnsetRule
 	- PHPStan\Rules\Whitespace\FileWhitespaceRule

src/Rules/Classes/ClassAttributesRule.php

@@ -8,6 +8,9 @@
 use PHPStan\Node\InClassNode;
 use PHPStan\Rules\AttributesCheck;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use function count;
+use function sprintf;
 
 /**
  * @implements Rule<InClassNode>
@@ -28,12 +31,39 @@ public function processNode(Node $node, Scope $scope): array
 	{
 		$classLikeNode = $node->getOriginalNode();
 
-		return $this->attributesCheck->check(
+		$errors = $this->attributesCheck->check(
 			$scope,
 			$classLikeNode->attrGroups,
 			Attribute::TARGET_CLASS,
 			'class',
 		);
+
+		$classReflection = $node->getClassReflection();
+		if (
+			$classReflection->isReadOnly()
+			|| $classReflection->isEnum()
+			|| $classReflection->isInterface()
+		) {
+			$typeName = 'readonly class';
+			$identifier = 'class.allowDynamicPropertiesReadonly';
+			if ($classReflection->isEnum()) {
+				$typeName = 'enum';
+				$identifier = 'enum.allowDynamicProperties';
+			}
+			if ($classReflection->isInterface()) {
+				$typeName = 'interface';
+				$identifier = 'interface.allowDynamicProperties';
+			}
+
+			if (count($classReflection->getNativeReflection()->getAttributes('AllowDynamicProperties')) > 0) {
+				$errors[] = RuleErrorBuilder::message(sprintf('Attribute class AllowDynamicProperties cannot be used with %s.', $typeName))
+					->identifier($identifier)
+					->nonIgnorable()
+					->build();
+			}
+		}
+
+		return $errors;
 	}
 
 }

src/Rules/Traits/TraitAttributesRule.php

@@ -0,0 +1,51 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Traits;
+
+use Attribute;
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\InTraitNode;
+use PHPStan\Rules\AttributesCheck;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use function count;
+
+/**
+ * @implements Rule<InTraitNode>
+ */
+final class TraitAttributesRule implements Rule
+{
+
+	public function __construct(
+		private AttributesCheck $attributesCheck,
+	)
+	{
+	}
+
+	public function getNodeType(): string
+	{
+		return InTraitNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$originalNode = $node->getOriginalNode();
+		$errors = $this->attributesCheck->check(
+			$scope,
+			$originalNode->attrGroups,
+			Attribute::TARGET_CLASS,
+			'class',
+		);
+
+		if (count($node->getTraitReflection()->getNativeReflection()->getAttributes('AllowDynamicProperties')) > 0) {
+			$errors[] = RuleErrorBuilder::message('Attribute class AllowDynamicProperties cannot be used with trait.')
+				->identifier('trait.allowDynamicProperties')
+				->nonIgnorable()
+				->build();
+		}
+
+		return $errors;
+	}
+
+}

tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php

@@ -167,4 +167,28 @@ public function testBug12011(): void
 		]);
 	}
 
+	public function testBug12281(): void
+	{
+		if (PHP_VERSION_ID < 80200) {
+			$this->markTestSkipped('Test requires PHP 8.2.');
+		}
+
+		$this->checkExplicitMixed = true;
+		$this->checkImplicitMixed = true;
+		$this->analyse([__DIR__ . '/data/bug-12281.php'], [
+			[
+				'Attribute class AllowDynamicProperties cannot be used with readonly class.',
+				05,
+			],
+			[
+				'Attribute class AllowDynamicProperties cannot be used with enum.',
+				12,
+			],
+			[
+				'Attribute class AllowDynamicProperties cannot be used with interface.',
+				15,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Classes/data/bug-12281.php

@@ -0,0 +1,16 @@
+<?php // lint >= 8.2
+
+namespace Bug12281;
+
+#[\AllowDynamicProperties]
+readonly class BlogData { /* … */ }
+
+/** @readonly  */
+#[\AllowDynamicProperties]
+class BlogDataPhpdoc { /* … */ }
+
+#[\AllowDynamicProperties]
+enum BlogDataEnum { /* … */ }
+
+#[\AllowDynamicProperties]
+interface BlogDataInterface { /* … */ }

tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php

@@ -0,0 +1,96 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Traits;
+
+use PHPStan\Php\PhpVersion;
+use PHPStan\Rules\AttributesCheck;
+use PHPStan\Rules\ClassCaseSensitivityCheck;
+use PHPStan\Rules\ClassForbiddenNameCheck;
+use PHPStan\Rules\ClassNameCheck;
+use PHPStan\Rules\FunctionCallParametersCheck;
+use PHPStan\Rules\NullsafeCheck;
+use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
+use PHPStan\Rules\Properties\PropertyReflectionFinder;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleLevelHelper;
+use PHPStan\Testing\RuleTestCase;
+use const PHP_VERSION_ID;
+
+/**
+ * @extends RuleTestCase<TraitAttributesRule>
+ */
+class TraitAttributesRuleTest extends RuleTestCase
+{
+
+	private bool $checkExplicitMixed = false;
+
+	private bool $checkImplicitMixed = false;
+
+	protected function getRule(): Rule
+	{
+		$reflectionProvider = $this->createReflectionProvider();
+		return new TraitAttributesRule(
+			new AttributesCheck(
+				$reflectionProvider,
+				new FunctionCallParametersCheck(
+					new RuleLevelHelper($reflectionProvider, true, false, true, $this->checkExplicitMixed, $this->checkImplicitMixed, false),
+					new NullsafeCheck(),
+					new PhpVersion(80000),
+					new UnresolvableTypeHelper(),
+					new PropertyReflectionFinder(),
+					true,
+					true,
+					true,
+					true,
+				),
+				new ClassNameCheck(
+					new ClassCaseSensitivityCheck($reflectionProvider, false),
+					new ClassForbiddenNameCheck(self::getContainer()),
+				),
+				true,
+			),
+		);
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/trait-attributes.php'], [
+			[
+				'Attribute class TraitAttributes\AbstractAttribute is abstract.',
+				8,
+			],
+			[
+				'Attribute class TraitAttributes\MyTargettedAttribute does not have the class target.',
+				20,
+			],
+		]);
+	}
+
+	public function testBug12011(): void
+	{
+		if (PHP_VERSION_ID < 80300) {
+			$this->markTestSkipped('Test requires PHP 8.3.');
+		}
+
+		$this->checkExplicitMixed = true;
+		$this->checkImplicitMixed = true;
+
+		$this->analyse([__DIR__ . '/data/bug-12011.php'], [
+			[
+				'Parameter #1 $name of attribute class Bug12011Trait\Table constructor expects string|null, int given.',
+				8,
+			],
+		]);
+	}
+
+	public function testBug12281(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-12281.php'], [
+			[
+				'Attribute class AllowDynamicProperties cannot be used with trait.',
+				11,
+			],
+		]);
+	}
+
+}

tests/PHPStan/Rules/Traits/data/bug-12011.php

@@ -0,0 +1,26 @@
+<?php // lint >= 8.3
+
+namespace Bug12011Trait;
+
+use Attribute;
+
+
+#[Table(self::TABLE_NAME)]
+trait MyTrait
+{
+	private const int TABLE_NAME = 1;
+}
+
+class X {
+	use MyTrait;
+}
+
+#[Attribute(Attribute::TARGET_CLASS)]
+final class Table
+{
+	public function __construct(
+		public readonly string|null $name = null,
+		public readonly string|null $schema = null,
+	) {
+	}
+}

tests/PHPStan/Rules/Traits/data/bug-12281.php

@@ -0,0 +1,19 @@
+<?php // lint >= 8.2
+
+namespace Bug12281Traits;
+
+#[\AllowDynamicProperties]
+enum BlogDataEnum { /* … */ } // reported by ClassAttributesRule
+
+#[\AllowDynamicProperties]
+interface BlogDataInterface { /* … */ } // reported by ClassAttributesRule
+
+#[\AllowDynamicProperties]
+trait BlogDataTrait { /* … */ }
+
+class Uses
+{
+
+	use BlogDataTrait;
+
+}

tests/PHPStan/Rules/Traits/data/trait-attributes.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace TraitAttributes;
+
+#[\Attribute]
+abstract class AbstractAttribute {}
+
+#[AbstractAttribute]
+trait MyTrait {}
+
+#[\Attribute]
+class MyAttribute {}
+
+#[MyAttribute]
+trait MyTrait2 {}
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+class MyTargettedAttribute {}
+
+#[MyTargettedAttribute]
+trait MyTrait3 {}
+
+class Uses
+{
+
+	use MyTrait;
+	use MyTrait2;
+	use MyTrait3;
+
+}