Add DontWriteStateWhenNotApplyingRule

extension.neon

@@ -1,10 +1,10 @@
 services:
 	-
-		class: Patchlevel\EventSourcingPHPStanExtension\AggregateRootExtension
+		class: Patchlevel\EventSourcingPHPStanExtension\DontRecordWhenApplyingExtension
 		tags:
-			- phpstan.properties.readWriteExtension
+			- phpstan.restrictedMethodUsageExtension
 
 	-
-		class: Patchlevel\EventSourcingPHPStanExtension\DontRecordWhenApplyingExtension
+		class: Patchlevel\EventSourcingPHPStanExtension\DontWriteStateWhenNotApplyingRule
 		tags:
-			- phpstan.restrictedMethodUsageExtension
+			- phpstan.rules.rule

src/DontWriteStateWhenNotApplyingRule.php

@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcingPHPStanExtension;
+
+use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
+use PhpParser\Node;
+use PhpParser\Node\Expr\Assign;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\PropertyFetch;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\NodeVisitorAbstract;
+use PHPStan\Analyser\Scope;
+
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\ObjectType;
+use function sprintf;
+
+final class DontWriteStateWhenNotApplyingRule implements Rule
+{
+    public function getNodeType(): string
+    {
+        return ClassMethod::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        $classReflection = $scope->getClassReflection();
+        if (!$classReflection instanceof ClassReflection) {
+            return [];
+        }
+
+        if (!$classReflection->implementsInterface(AggregateRoot::class)) {
+            return [];
+        }
+
+        // check for handle attribute
+        $hasHandleAttribute = false;
+        foreach ($node->attrGroups as $attrGroup) {
+            foreach ($attrGroup->attrs as $attr) {
+                if ((string) $attr->name === 'Handle' || str_ends_with((string) $attr->name, '\\Handle')) {
+                    $hasHandleAttribute = true;
+                    break 2;
+                }
+            }
+        }
+
+        if (!$hasHandleAttribute) {
+            return [];
+        }
+
+        // now try to find writes by traversing over the node
+        $nodeFinder = new \PhpParser\NodeTraverser();
+        $visitor = new class($node, $scope) extends NodeVisitorAbstract {
+            public array $errors;
+            private ClassMethod $method;
+            private Scope $scope;
+
+            public function __construct(ClassMethod $method, Scope $scope)
+            {
+                $this->errors = [];
+                $this->method = $method;
+                $this->scope = $scope;
+            }
+
+            public function enterNode(Node $node)
+            {
+                if ($node instanceof Assign && $node->var instanceof PropertyFetch) {
+                    /** @var PropertyFetch $propertyFetch */
+                    $propertyFetch = $node->var;
+
+                    if (
+                        $propertyFetch->var instanceof Node\Expr\Variable &&
+                        ($propertyFetch->var->name === 'this' || $propertyFetch->var->name === 'self')
+                    ) {
+                        $this->errors[] = RuleErrorBuilder::message(sprintf(
+                            'Property "%s" should not be written in #[Handle] method "%s::%s()"',
+                            $propertyFetch->name instanceof Node\Identifier ? $propertyFetch->name->name : 'unknown',
+                            $this->scope->getClassReflection()?->getName() ?? 'unknown',
+                            $this->method->name->name
+                        ))
+                            ->identifier('myCustomRules.newPerson')
+                            ->build();
+                    }
+                }
+            }
+        };
+        $nodeFinder->addVisitor($visitor);
+        $nodeFinder->traverse($node->getStmts() ?? []);
+
+        return $visitor->errors;
+    }
+}

tests/Invalid/Profile.php

@@ -5,19 +5,23 @@
 use Patchlevel\EventSourcing\Aggregate\BasicAggregateRoot;
 use Patchlevel\EventSourcing\Aggregate\Uuid;
 use Patchlevel\EventSourcing\Attribute\Apply;
+use Patchlevel\EventSourcing\Attribute\Handle;
 use Patchlevel\EventSourcing\Attribute\Id;
 use Patchlevel\EventSourcingPHPStanExtension\Tests\Valid\ProfileCreated;
 
 class Profile extends BasicAggregateRoot
 {
     #[Id]
     private Uuid $id;
     private string $name;
 
+    #[Handle]
     public static function create(Uuid $id, string $name): self
     {
         $self = new self();
         $self->recordThat(new ProfileCreated($id, $name));
+        $self->name = 'asd';
+        $self->changeStateHidden();
 
         return $self;
     }
@@ -36,6 +40,11 @@
         $this->recordThat(new ProfileCreated($event->id, $event->name));
     }
 
+    public function changeStateHidden(): void
+    {
+        $this->name = 'invalid';
+    }
+
     public function id(): Uuid
     {
         return $this->id;