Merge pull request #561 from phparkitect/claude/fix-pr-560-rule-1ZmIe

fain182 · web-flow · commit 8097d801c1f7 · 2026-01-28T21:58:15.000+01:00
Fix: appliesTo() incorrectly excludes mutually exclusive class states
diff --git a/src/Analyzer/DocblockTypesResolver.php b/src/Analyzer/DocblockTypesResolver.php
@@ -69,7 +69,7 @@ public function enterNode(Node $node): void
 
     private function resolvePropertyTypes(Node $node): void
     {
-        if (!($node instanceof Stmt\Property)) {
+        if (!$node instanceof Stmt\Property) {
             return;
         }
 
diff --git a/src/Analyzer/FileVisitor.php b/src/Analyzer/FileVisitor.php
@@ -109,7 +109,7 @@ public function leaveNode(Node $node): void
 
     private function handleClassNode(Node $node): void
     {
-        if (!($node instanceof Node\Stmt\Class_)) {
+        if (!$node instanceof Node\Stmt\Class_) {
             return;
         }
 
@@ -140,7 +140,7 @@ private function handleClassNode(Node $node): void
 
     private function handleAnonClassNode(Node $node): void
     {
-        if (!($node instanceof Node\Stmt\Class_)) {
+        if (!$node instanceof Node\Stmt\Class_) {
             return;
         }
 
@@ -161,7 +161,7 @@ private function handleAnonClassNode(Node $node): void
 
     private function handleEnumNode(Node $node): void
     {
-        if (!($node instanceof Node\Stmt\Enum_)) {
+        if (!$node instanceof Node\Stmt\Enum_) {
             return;
         }
 
@@ -180,11 +180,11 @@ private function handleEnumNode(Node $node): void
 
     private function handleStaticClassConstantNode(Node $node): void
     {
-        if (!($node instanceof Node\Expr\ClassConstFetch)) {
+        if (!$node instanceof Node\Expr\ClassConstFetch) {
             return;
         }
 
-        if (!($node->class instanceof Node\Name\FullyQualified)) {
+        if (!$node->class instanceof Node\Name\FullyQualified) {
             return;
         }
 
@@ -194,11 +194,11 @@ private function handleStaticClassConstantNode(Node $node): void
 
     private function handleStaticClassCallsNode(Node $node): void
     {
-        if (!($node instanceof Node\Expr\StaticCall)) {
+        if (!$node instanceof Node\Expr\StaticCall) {
             return;
         }
 
-        if (!($node->class instanceof Node\Name\FullyQualified)) {
+        if (!$node->class instanceof Node\Name\FullyQualified) {
             return;
         }
 
@@ -208,11 +208,11 @@ private function handleStaticClassCallsNode(Node $node): void
 
     private function handleInstanceOf(Node $node): void
     {
-        if (!($node instanceof Node\Expr\Instanceof_)) {
+        if (!$node instanceof Node\Expr\Instanceof_) {
             return;
         }
 
-        if (!($node->class instanceof Node\Name\FullyQualified)) {
+        if (!$node->class instanceof Node\Name\FullyQualified) {
             return;
         }
 
@@ -222,11 +222,11 @@ private function handleInstanceOf(Node $node): void
 
     private function handleNewExpression(Node $node): void
     {
-        if (!($node instanceof Node\Expr\New_)) {
+        if (!$node instanceof Node\Expr\New_) {
             return;
         }
 
-        if (!($node->class instanceof Node\Name\FullyQualified)) {
+        if (!$node->class instanceof Node\Name\FullyQualified) {
             return;
         }
 
@@ -236,7 +236,7 @@ private function handleNewExpression(Node $node): void
 
     private function handleTypedProperty(Node $node): void
     {
-        if (!($node instanceof Node\Stmt\Property)) {
+        if (!$node instanceof Node\Stmt\Property) {
             return;
         }
 
@@ -246,7 +246,7 @@ private function handleTypedProperty(Node $node): void
 
         $type = $node->type instanceof NullableType ? $node->type->type : $node->type;
 
-        if (!($type instanceof Node\Name\FullyQualified)) {
+        if (!$type instanceof Node\Name\FullyQualified) {
             return;
         }
 
@@ -274,7 +274,7 @@ private function handleParamDependency(Node $node): void
 
     private function handleInterfaceNode(Node $node): void
     {
-        if (!($node instanceof Node\Stmt\Interface_)) {
+        if (!$node instanceof Node\Stmt\Interface_) {
             return;
         }
 
@@ -293,7 +293,7 @@ private function handleInterfaceNode(Node $node): void
 
     private function handleTraitNode(Node $node): void
     {
-        if (!($node instanceof Node\Stmt\Trait_)) {
+        if (!$node instanceof Node\Stmt\Trait_) {
             return;
         }
 
@@ -307,13 +307,13 @@ private function handleTraitNode(Node $node): void
 
     private function handleReturnTypeDependency(Node $node): void
     {
-        if (!($node instanceof Node\Stmt\ClassMethod)) {
+        if (!$node instanceof Node\Stmt\ClassMethod) {
             return;
         }
 
         $returnType = $node->returnType;
 
-        if (!($returnType instanceof Node\Name\FullyQualified)) {
+        if (!$returnType instanceof Node\Name\FullyQualified) {
             return;
         }
 
@@ -323,13 +323,13 @@ private function handleReturnTypeDependency(Node $node): void
 
     private function handleAttributeNode(Node $node): void
     {
-        if (!($node instanceof Node\Attribute)) {
+        if (!$node instanceof Node\Attribute) {
             return;
         }
 
         $nodeName = $node->name;
 
-        if (!($nodeName instanceof Node\Name\FullyQualified)) {
+        if (!$nodeName instanceof Node\Name\FullyQualified) {
             return;
         }
 
@@ -345,7 +345,7 @@ private function addParamDependency(Node\Param $node): void
 
         $type = $node->type instanceof NullableType ? $node->type->type : $node->type;
 
-        if (!($type instanceof Node\Name\FullyQualified)) {
+        if (!$type instanceof Node\Name\FullyQualified) {
             return;
         }
 
@@ -355,7 +355,7 @@ private function addParamDependency(Node\Param $node): void
 
     private function handlePropertyHookNode(Node $node): void
     {
-        if (!($node instanceof Node\PropertyHook)) {
+        if (!$node instanceof Node\PropertyHook) {
             return;
         }
 
diff --git a/src/Expression/ForClasses/Implement.php b/src/Expression/ForClasses/Implement.php
@@ -40,7 +40,7 @@ public function evaluate(ClassDescription $theClass, Violations $violations, str
 
         $interface = $this->interface;
         $interfaces = $theClass->getInterfaces();
-        $implements = function (FullyQualifiedClassName $FQCN) use ($interface): bool {
+        $implements = static function (FullyQualifiedClassName $FQCN) use ($interface): bool {
             return $FQCN->matches($interface);
         };
 
diff --git a/src/Expression/ForClasses/IsAbstract.php b/src/Expression/ForClasses/IsAbstract.php
@@ -20,7 +20,7 @@ public function describe(ClassDescription $theClass, string $because): Descripti
 
     public function appliesTo(ClassDescription $theClass): bool
     {
-        return !($theClass->isInterface() || $theClass->isTrait() || $theClass->isEnum() || $theClass->isFinal());
+        return !($theClass->isInterface() || $theClass->isTrait() || $theClass->isEnum());
     }
 
     public function evaluate(ClassDescription $theClass, Violations $violations, string $because): void
diff --git a/src/Expression/ForClasses/IsFinal.php b/src/Expression/ForClasses/IsFinal.php
@@ -20,7 +20,7 @@ public function describe(ClassDescription $theClass, string $because): Descripti
 
     public function appliesTo(ClassDescription $theClass): bool
     {
-        return !($theClass->isInterface() || $theClass->isTrait() || $theClass->isEnum() || $theClass->isAbstract());
+        return !($theClass->isInterface() || $theClass->isTrait() || $theClass->isEnum());
     }
 
     public function evaluate(ClassDescription $theClass, Violations $violations, string $because): void
diff --git a/src/Expression/ForClasses/IsNotAbstract.php b/src/Expression/ForClasses/IsNotAbstract.php
@@ -20,7 +20,7 @@ public function describe(ClassDescription $theClass, string $because): Descripti
 
     public function appliesTo(ClassDescription $theClass): bool
     {
-        return !($theClass->isInterface() || $theClass->isTrait() || $theClass->isEnum() || $theClass->isFinal());
+        return !($theClass->isInterface() || $theClass->isTrait() || $theClass->isEnum());
     }
 
     public function evaluate(ClassDescription $theClass, Violations $violations, string $because): void
diff --git a/src/Expression/ForClasses/IsNotFinal.php b/src/Expression/ForClasses/IsNotFinal.php
@@ -20,7 +20,7 @@ public function describe(ClassDescription $theClass, string $because): Descripti
 
     public function appliesTo(ClassDescription $theClass): bool
     {
-        return !($theClass->isInterface() || $theClass->isTrait() || $theClass->isEnum() || $theClass->isAbstract());
+        return !($theClass->isInterface() || $theClass->isTrait() || $theClass->isEnum());
     }
 
     public function evaluate(ClassDescription $theClass, Violations $violations, string $because): void
diff --git a/src/Expression/ForClasses/NotHaveDependencyOutsideNamespace.php b/src/Expression/ForClasses/NotHaveDependencyOutsideNamespace.php
@@ -36,7 +36,7 @@ public function describe(ClassDescription $theClass, string $because): Descripti
     public function evaluate(ClassDescription $theClass, Violations $violations, string $because): void
     {
         $namespace = $this->namespace;
-        $depends = function (ClassDependency $dependency) use ($namespace): bool {
+        $depends = static function (ClassDependency $dependency) use ($namespace): bool {
             return !$dependency->getFQCN()->matches($namespace);
         };
 
diff --git a/src/Expression/ForClasses/NotImplement.php b/src/Expression/ForClasses/NotImplement.php
@@ -40,7 +40,7 @@ public function evaluate(ClassDescription $theClass, Violations $violations, str
 
         $interface = $this->interface;
         $interfaces = $theClass->getInterfaces();
-        $implements = function (FullyQualifiedClassName $FQCN) use ($interface): bool {
+        $implements = static function (FullyQualifiedClassName $FQCN) use ($interface): bool {
             return $FQCN->matches($interface);
         };
 
diff --git a/src/Rules/Violations.php b/src/Rules/Violations.php
@@ -27,7 +27,7 @@ public static function fromJson(string $json): self
 
         $instance = new self();
 
-        $instance->violations = array_map(function (array $json): Violation {
+        $instance->violations = array_map(static function (array $json): Violation {
             return Violation::fromJson($json);
         }, $json['violations']);
 
@@ -67,7 +67,7 @@ public function count(): int
 
     public function groupedByFqcn(): array
     {
-        return array_reduce($this->violations, function (array $accumulator, Violation $element) {
+        return array_reduce($this->violations, static function (array $accumulator, Violation $element) {
             $accumulator[$element->getFqcn()][] = $element;
 
             return $accumulator;
diff --git a/tests/Integration/IsAbstractTest.php b/tests/Integration/IsAbstractTest.php
@@ -72,6 +72,95 @@ public function test_is_not_abstract_in_should_should_consider_final_traits_enum
         self::assertEquals('App\MyAbstract', $runner->getViolations()->get(0)->getFqcn());
     }
 
+    public function test_is_not_abstract_in_that_should_include_final_classes(): void
+    {
+        $structure = [
+            'App' => [
+                'Test' => [
+                    // Final class with correct name - should pass
+                    'GoodEndToEndTest.php' => '<?php namespace App\Test; final class GoodEndToEndTest {} ',
+
+                    // Abstract class - should be filtered out by IsNotAbstract
+                    'AbstractTestCase.php' => '<?php namespace App\Test; abstract class AbstractTestCase {} ',
+
+                    // Final class with wrong name - should generate violation
+                    'BadE2ETest.php' => '<?php namespace App\Test; final class BadE2ETest {} ',
+
+                    // Normal class with wrong name - should also generate violation
+                    'AnotherBadTest.php' => '<?php namespace App\Test; class AnotherBadTest {} ',
+                ],
+            ],
+        ];
+
+        $runner = TestRunner::create('8.4');
+
+        // This replicates the use case from PR 560:
+        // Filter for non-abstract classes (including final), then check naming convention
+        $rule = Rule::allClasses()
+            ->that(new ResideInOneOfTheseNamespaces('App\Test'))
+            ->andThat(new IsNotAbstract())
+            ->should(new HaveNameMatching('*EndToEndTest'))
+            ->because('all E2E tests must follow naming convention');
+
+        $runner->run(vfsStream::setup('root', null, $structure)->url(), $rule);
+
+        // Should find 2 violations: BadE2ETest and AnotherBadTest
+        // AbstractTestCase should be filtered out by IsNotAbstract
+        // GoodEndToEndTest should pass
+        self::assertCount(2, $runner->getViolations());
+        self::assertEquals('App\Test\AnotherBadTest', $runner->getViolations()->get(0)->getFqcn());
+        self::assertEquals('App\Test\BadE2ETest', $runner->getViolations()->get(1)->getFqcn());
+        self::assertCount(0, $runner->getParsingErrors());
+    }
+
+    public function test_is_not_abstract_in_should_validates_final_classes_correctly(): void
+    {
+        $structure = [
+            'App' => [
+                'Service' => [
+                    // Abstract class - should generate violation
+                    'AbstractService.php' => '<?php namespace App\Service; abstract class AbstractService {} ',
+
+                    // Final class - should NOT generate violation (final is non-abstract)
+                    'FinalService.php' => '<?php namespace App\Service; final class FinalService {} ',
+
+                    // Normal class - should NOT generate violation (normal is non-abstract)
+                    'NormalService.php' => '<?php namespace App\Service; class NormalService {} ',
+
+                    // Interface - should NOT generate violation (isAbstract() returns false)
+                    'ServiceInterface.php' => '<?php namespace App\Service; interface ServiceInterface {} ',
+
+                    // Trait - should NOT generate violation (isAbstract() returns false)
+                    'ServiceTrait.php' => '<?php namespace App\Service; trait ServiceTrait {} ',
+
+                    // Enum - should NOT generate violation (isAbstract() returns false)
+                    'ServiceEnum.php' => '<?php namespace App\Service; enum ServiceEnum {} ',
+                ],
+            ],
+        ];
+
+        $runner = TestRunner::create('8.4');
+
+        // When IsNotAbstract is used in should() (not that()), it validates ALL classes
+        // In PHP, isAbstract() returns true only for classes with 'abstract' keyword
+        // It does NOT return true for interface/trait/enum
+        $rule = Rule::allClasses()
+            ->that(new ResideInOneOfTheseNamespaces('App\Service'))
+            ->should(new IsNotAbstract())
+            ->because('services should be concrete implementations');
+
+        $runner->run(vfsStream::setup('root', null, $structure)->url(), $rule);
+
+        // Should find violation only for: AbstractService
+        // Should NOT violate: FinalService, NormalService, ServiceInterface, ServiceTrait, ServiceEnum
+        // This test verifies that:
+        // 1. Final classes are correctly recognized as non-abstract
+        // 2. Interface/trait/enum don't trigger violations (isAbstract() = false for them)
+        self::assertCount(1, $runner->getViolations());
+        self::assertEquals('App\Service\AbstractService', $runner->getViolations()->get(0)->getFqcn());
+        self::assertCount(0, $runner->getParsingErrors());
+    }
+
     public function test_it_can_check_multiple_class_properties(): void
     {
         $structure = [
diff --git a/tests/Unit/Analyzer/FileParser/CanParsePropertyHooksTest.php b/tests/Unit/Analyzer/FileParser/CanParsePropertyHooksTest.php
@@ -75,7 +75,7 @@ class User {
         self::assertInstanceOf(ClassDescription::class, $cd[0]);
 
         $dependencies = $cd[0]->getDependencies();
-        $dependencyNames = array_map(fn ($dep) => $dep->getFQCN()->toString(), $dependencies);
+        $dependencyNames = array_map(static fn ($dep) => $dep->getFQCN()->toString(), $dependencies);
 
         self::assertContains('App\Services\Formatter', $dependencyNames);
         self::assertContains('App\Services\Validator', $dependencyNames);
@@ -107,7 +107,7 @@ class User {
         self::assertInstanceOf(ClassDescription::class, $cd[0]);
 
         $dependencies = $cd[0]->getDependencies();
-        $dependencyNames = array_map(fn ($dep) => $dep->getFQCN()->toString(), $dependencies);
+        $dependencyNames = array_map(static fn ($dep) => $dep->getFQCN()->toString(), $dependencies);
 
         self::assertContains('App\ValueObjects\Name', $dependencyNames);
     }
diff --git a/tests/Unit/ClassSetTest.php b/tests/Unit/ClassSetTest.php
@@ -27,7 +27,7 @@ public function test_can_exclude_files_or_directories_from_multiple_dir_class_se
             $path.'/Model/Products.php',
             $path.'/Model/User.php',
         ];
-        $actual = array_values(array_map(function ($item) {
+        $actual = array_values(array_map(static function ($item) {
             /** @var \SplFileInfo $item */
             return $item->getPathname();
         }, iterator_to_array($set)));
@@ -54,7 +54,7 @@ public function test_can_exclude_files_or_directories(): void
             'View/UserView.php',
         ];
 
-        $actual = array_values(array_map(function ($item) {
+        $actual = array_values(array_map(static function ($item) {
             return $item->getRelativePathname();
         }, iterator_to_array($set)));
 
@@ -83,7 +83,7 @@ public function test_can_exclude_glob_patterns(): void
             'View/UserView.php',
         ];
 
-        $actual = array_values(array_map(function ($item) {
+        $actual = array_values(array_map(static function ($item) {
             return $item->getRelativePathname();
         }, iterator_to_array($set)));
 
diff --git a/tests/Unit/Expressions/ForClasses/IsAbstractTest.php b/tests/Unit/Expressions/ForClasses/IsAbstractTest.php
diff --git a/tests/Unit/Expressions/ForClasses/IsFinalTest.php b/tests/Unit/Expressions/ForClasses/IsFinalTest.php

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ public function enterNode(Node $node): void`
`69`	`69`
`70`	`70`	`private function resolvePropertyTypes(Node $node): void`
`71`	`71`	`{`
`72`		`- if (!($node instanceof Stmt\Property)) {`
	`72`	`+ if (!$node instanceof Stmt\Property) {`
`73`	`73`	`return;`
`74`	`74`	`}`
`75`	`75`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ public function leaveNode(Node $node): void`
`109`	`109`
`110`	`110`	`private function handleClassNode(Node $node): void`
`111`	`111`	`{`
`112`		`- if (!($node instanceof Node\Stmt\Class_)) {`
	`112`	`+ if (!$node instanceof Node\Stmt\Class_) {`
`113`	`113`	`return;`
`114`	`114`	`}`
`115`	`115`
`@@ -140,7 +140,7 @@ private function handleClassNode(Node $node): void`
`140`	`140`
`141`	`141`	`private function handleAnonClassNode(Node $node): void`
`142`	`142`	`{`
`143`		`- if (!($node instanceof Node\Stmt\Class_)) {`
	`143`	`+ if (!$node instanceof Node\Stmt\Class_) {`
`144`	`144`	`return;`
`145`	`145`	`}`
`146`	`146`
`@@ -161,7 +161,7 @@ private function handleAnonClassNode(Node $node): void`
`161`	`161`
`162`	`162`	`private function handleEnumNode(Node $node): void`
`163`	`163`	`{`
`164`		`- if (!($node instanceof Node\Stmt\Enum_)) {`
	`164`	`+ if (!$node instanceof Node\Stmt\Enum_) {`
`165`	`165`	`return;`
`166`	`166`	`}`
`167`	`167`
`@@ -180,11 +180,11 @@ private function handleEnumNode(Node $node): void`
`180`	`180`
`181`	`181`	`private function handleStaticClassConstantNode(Node $node): void`
`182`	`182`	`{`
`183`		`- if (!($node instanceof Node\Expr\ClassConstFetch)) {`
	`183`	`+ if (!$node instanceof Node\Expr\ClassConstFetch) {`
`184`	`184`	`return;`
`185`	`185`	`}`
`186`	`186`
`187`		`- if (!($node->class instanceof Node\Name\FullyQualified)) {`
	`187`	`+ if (!$node->class instanceof Node\Name\FullyQualified) {`
`188`	`188`	`return;`
`189`	`189`	`}`
`190`	`190`
`@@ -194,11 +194,11 @@ private function handleStaticClassConstantNode(Node $node): void`
`194`	`194`
`195`	`195`	`private function handleStaticClassCallsNode(Node $node): void`
`196`	`196`	`{`
`197`		`- if (!($node instanceof Node\Expr\StaticCall)) {`
	`197`	`+ if (!$node instanceof Node\Expr\StaticCall) {`
`198`	`198`	`return;`
`199`	`199`	`}`
`200`	`200`
`201`		`- if (!($node->class instanceof Node\Name\FullyQualified)) {`
	`201`	`+ if (!$node->class instanceof Node\Name\FullyQualified) {`
`202`	`202`	`return;`
`203`	`203`	`}`
`204`	`204`
`@@ -208,11 +208,11 @@ private function handleStaticClassCallsNode(Node $node): void`
`208`	`208`
`209`	`209`	`private function handleInstanceOf(Node $node): void`
`210`	`210`	`{`
`211`		`- if (!($node instanceof Node\Expr\Instanceof_)) {`
	`211`	`+ if (!$node instanceof Node\Expr\Instanceof_) {`
`212`	`212`	`return;`
`213`	`213`	`}`
`214`	`214`
`215`		`- if (!($node->class instanceof Node\Name\FullyQualified)) {`
	`215`	`+ if (!$node->class instanceof Node\Name\FullyQualified) {`
`216`	`216`	`return;`
`217`	`217`	`}`
`218`	`218`
`@@ -222,11 +222,11 @@ private function handleInstanceOf(Node $node): void`
`222`	`222`
`223`	`223`	`private function handleNewExpression(Node $node): void`
`224`	`224`	`{`
`225`		`- if (!($node instanceof Node\Expr\New_)) {`
	`225`	`+ if (!$node instanceof Node\Expr\New_) {`
`226`	`226`	`return;`
`227`	`227`	`}`
`228`	`228`
`229`		`- if (!($node->class instanceof Node\Name\FullyQualified)) {`
	`229`	`+ if (!$node->class instanceof Node\Name\FullyQualified) {`
`230`	`230`	`return;`
`231`	`231`	`}`
`232`	`232`
`@@ -236,7 +236,7 @@ private function handleNewExpression(Node $node): void`
`236`	`236`
`237`	`237`	`private function handleTypedProperty(Node $node): void`
`238`	`238`	`{`
`239`		`- if (!($node instanceof Node\Stmt\Property)) {`
	`239`	`+ if (!$node instanceof Node\Stmt\Property) {`
`240`	`240`	`return;`
`241`	`241`	`}`
`242`	`242`
`@@ -246,7 +246,7 @@ private function handleTypedProperty(Node $node): void`
`246`	`246`
`247`	`247`	`$type = $node->type instanceof NullableType ? $node->type->type : $node->type;`
`248`	`248`
`249`		`- if (!($type instanceof Node\Name\FullyQualified)) {`
	`249`	`+ if (!$type instanceof Node\Name\FullyQualified) {`
`250`	`250`	`return;`
`251`	`251`	`}`
`252`	`252`
`@@ -274,7 +274,7 @@ private function handleParamDependency(Node $node): void`
`274`	`274`
`275`	`275`	`private function handleInterfaceNode(Node $node): void`
`276`	`276`	`{`
`277`		`- if (!($node instanceof Node\Stmt\Interface_)) {`
	`277`	`+ if (!$node instanceof Node\Stmt\Interface_) {`
`278`	`278`	`return;`
`279`	`279`	`}`
`280`	`280`
`@@ -293,7 +293,7 @@ private function handleInterfaceNode(Node $node): void`
`293`	`293`
`294`	`294`	`private function handleTraitNode(Node $node): void`
`295`	`295`	`{`
`296`		`- if (!($node instanceof Node\Stmt\Trait_)) {`
	`296`	`+ if (!$node instanceof Node\Stmt\Trait_) {`
`297`	`297`	`return;`
`298`	`298`	`}`
`299`	`299`
`@@ -307,13 +307,13 @@ private function handleTraitNode(Node $node): void`
`307`	`307`
`308`	`308`	`private function handleReturnTypeDependency(Node $node): void`
`309`	`309`	`{`
`310`		`- if (!($node instanceof Node\Stmt\ClassMethod)) {`
	`310`	`+ if (!$node instanceof Node\Stmt\ClassMethod) {`
`311`	`311`	`return;`
`312`	`312`	`}`
`313`	`313`
`314`	`314`	`$returnType = $node->returnType;`
`315`	`315`
`316`		`- if (!($returnType instanceof Node\Name\FullyQualified)) {`
	`316`	`+ if (!$returnType instanceof Node\Name\FullyQualified) {`
`317`	`317`	`return;`
`318`	`318`	`}`
`319`	`319`
`@@ -323,13 +323,13 @@ private function handleReturnTypeDependency(Node $node): void`
`323`	`323`
`324`	`324`	`private function handleAttributeNode(Node $node): void`
`325`	`325`	`{`
`326`		`- if (!($node instanceof Node\Attribute)) {`
	`326`	`+ if (!$node instanceof Node\Attribute) {`
`327`	`327`	`return;`
`328`	`328`	`}`
`329`	`329`
`330`	`330`	`$nodeName = $node->name;`
`331`	`331`
`332`		`- if (!($nodeName instanceof Node\Name\FullyQualified)) {`
	`332`	`+ if (!$nodeName instanceof Node\Name\FullyQualified) {`
`333`	`333`	`return;`
`334`	`334`	`}`
`335`	`335`
`@@ -345,7 +345,7 @@ private function addParamDependency(Node\Param $node): void`
`345`	`345`
`346`	`346`	`$type = $node->type instanceof NullableType ? $node->type->type : $node->type;`
`347`	`347`
`348`		`- if (!($type instanceof Node\Name\FullyQualified)) {`
	`348`	`+ if (!$type instanceof Node\Name\FullyQualified) {`
`349`	`349`	`return;`
`350`	`350`	`}`
`351`	`351`
`@@ -355,7 +355,7 @@ private function addParamDependency(Node\Param $node): void`
`355`	`355`
`356`	`356`	`private function handlePropertyHookNode(Node $node): void`
`357`	`357`	`{`
`358`		`- if (!($node instanceof Node\PropertyHook)) {`
	`358`	`+ if (!$node instanceof Node\PropertyHook) {`
`359`	`359`	`return;`
`360`	`360`	`}`
`361`	`361`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public function describe(ClassDescription $theClass, string $because): Descripti`
`20`	`20`
`21`	`21`	`public function appliesTo(ClassDescription $theClass): bool`
`22`	`22`	`{`
`23`		`- return !($theClass->isInterface() \|\| $theClass->isTrait() \|\| $theClass->isEnum() \|\| $theClass->isFinal());`
	`23`	`+ return !($theClass->isInterface() \|\| $theClass->isTrait() \|\| $theClass->isEnum());`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public function evaluate(ClassDescription $theClass, Violations $violations, string $because): void`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public function describe(ClassDescription $theClass, string $because): Descripti`
`36`	`36`	`public function evaluate(ClassDescription $theClass, Violations $violations, string $because): void`
`37`	`37`	`{`
`38`	`38`	`$namespace = $this->namespace;`
`39`		`- $depends = function (ClassDependency $dependency) use ($namespace): bool {`
	`39`	`+ $depends = static function (ClassDependency $dependency) use ($namespace): bool {`
`40`	`40`	`return !$dependency->getFQCN()->matches($namespace);`
`41`	`41`	`};`
`42`	`42`