Added new proposed rules

.gitignore

@@ -0,0 +1,6 @@
+/vendor
+/phpunit.xml
+/.php_cs.cache
+composer.lock
+.php-cs-fixer.cache
+.phpunit.result.cache

extension.neon

@@ -7,3 +7,6 @@ parameters:
 		- stubs/Money/MoneyParser.stub
 rules:
     - Ibexa\PHPStan\Rules\NoConfigResolverParametersInConstructorRule
+    - Ibexa\PHPStan\Rules\RequireInterfaceInDependenciesRule
+    - Ibexa\PHPStan\Rules\NamingConventionRule
+    - Ibexa\PHPStan\Rules\FinalClassRule

phpstan-baseline.neon

@@ -0,0 +1,16 @@
+parameters:
+	ignoreErrors:
+		-
+			message: "#^Property Ibexa\\\\Tests\\\\PHPStan\\\\Rules\\\\Fixtures\\\\RequireInterfaceInDependenciesFixture\\:\\:\\$classWithoutInterface is never read, only written\\.$#"
+			count: 1
+			path: tests/rules/Fixtures/RequireInterfaceInDependenciesFixture.php
+
+		-
+			message: "#^Property Ibexa\\\\Tests\\\\PHPStan\\\\Rules\\\\Fixtures\\\\RequireInterfaceInDependenciesFixture\\:\\:\\$concreteClass is never read, only written\\.$#"
+			count: 1
+			path: tests/rules/Fixtures/RequireInterfaceInDependenciesFixture.php
+
+		-
+			message: "#^Property Ibexa\\\\Tests\\\\PHPStan\\\\Rules\\\\Fixtures\\\\RequireInterfaceInDependenciesFixture\\:\\:\\$testInterface is never read, only written\\.$#"
+			count: 1
+			path: tests/rules/Fixtures/RequireInterfaceInDependenciesFixture.php

phpstan.neon

@@ -1,3 +1,6 @@
+includes:
+    - phpstan-baseline.neon
+
 parameters:
     level: 8
     paths:

rules/FinalClassRule.php

@@ -0,0 +1,77 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\PHPStan\Rules;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Class_>
+ */
+final class FinalClassRule implements Rule
+{
+    private ReflectionProvider $reflectionProvider;
+
+    public function __construct(
+        ReflectionProvider $reflectionProvider
+    ) {
+        $this->reflectionProvider = $reflectionProvider;
+    }
+
+    public function getNodeType(): string
+    {
+        return Node\Stmt\Class_::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        // Skip anonymous classes
+        if (!isset($node->namespacedName)) {
+            return [];
+        }
+
+        $className = $node->namespacedName->toString();
+
+        if (!$this->reflectionProvider->hasClass($className)) {
+            return [];
+        }
+
+        $reflection = $this->reflectionProvider->getClass($className);
+
+        // Skip if already final
+        if ($reflection->isFinal()) {
+            return [];
+        }
+
+        // Skip if abstract (abstract classes shouldn't be final)
+        if ($reflection->isAbstract()) {
+            return [];
+        }
+
+        // Skip interfaces and traits
+        if ($reflection->isInterface() || $reflection->isTrait()) {
+            return [];
+        }
+
+        return [
+            RuleErrorBuilder::message(
+                sprintf(
+                    'Class %s is not final. All non-abstract classes should be final.',
+                    $reflection->getName()
+                )
+            )
+                ->identifier('class.notFinal')
+                ->tip('Add "final" keyword to the class declaration.')
+                ->build(),
+        ];
+    }
+}

rules/NamingConventionRule.php

@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\PHPStan\Rules;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\ClassLike>
+ */
+final class NamingConventionRule implements Rule
+{
+    public function getNodeType(): string
+    {
+        return Node\Stmt\ClassLike::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (!$this->isRelevantNode($node)) {
+            return [];
+        }
+
+        if ($node->name === null) {
+            return [];
+        }
+
+        $className = $node->name->toString();
+        $errors = [];
+
+        if ($node instanceof Node\Stmt\Interface_ && substr($className, -9) !== 'Interface') {
+            $errors[] = RuleErrorBuilder::message(
+                sprintf(
+                    'Interface "%s" should have "Interface" suffix',
+                    $className
+                )
+            )->build();
+        }
+
+        if ($node instanceof Node\Stmt\Trait_ && substr($className, -5) !== 'Trait') {
+            $errors[] = RuleErrorBuilder::message(
+                sprintf(
+                    'Trait "%s" should have "Trait" suffix',
+                    $className
+                )
+            )->build();
+        }
+
+        if ($node instanceof Node\Stmt\Class_ && $node->isAbstract() && strpos($className, 'Abstract') !== 0) {
+            $errors[] = RuleErrorBuilder::message(
+                sprintf(
+                    'Abstract class "%s" should have "Abstract" prefix',
+                    $className
+                )
+            )->build();
+        }
+
+        return $errors;
+    }
+
+    private function isRelevantNode(Node $node): bool
+    {
+        return $node instanceof Node\Stmt\Interface_
+            || $node instanceof Node\Stmt\Trait_
+            || ($node instanceof Node\Stmt\Class_ && $node->isAbstract());
+    }
+}

rules/RequireInterfaceInDependenciesRule.php

@@ -0,0 +1,78 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\PHPStan\Rules;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\Error;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\ClassMethod>
+ */
+final class RequireInterfaceInDependenciesRule implements Rule
+{
+    public function getNodeType(): string
+    {
+        return Node\Stmt\ClassMethod::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        $errors = [];
+
+        if (!$node->params) {
+            return [];
+        }
+
+        foreach ($node->params as $param) {
+            if (!$param->type instanceof Node\Name) {
+                continue;
+            }
+            if ($param->var instanceof Error) {
+                continue;
+            }
+            $typeName = $param->type->toString();
+
+            // Skip built-in types and primitives
+            if ($this->isBuiltInType($typeName)) {
+                continue;
+            }
+
+            if (!interface_exists($typeName) && class_exists($typeName)) {
+                // Check if this class implements any interface
+                $interfaces = class_implements($typeName);
+
+                if (!empty($interfaces)) {
+                    $errors[] = RuleErrorBuilder::message(
+                        sprintf(
+                            'Parameter $%s uses concrete class %s instead of an interface. Available interfaces: %s',
+                            is_string($param->var->name) ? $param->var->name : $param->var->name->getType(),
+                            $typeName,
+                            implode(', ', $interfaces)
+                        )
+                    )->build();
+                }
+            }
+        }
+
+        return $errors;
+    }
+
+    private function isBuiltInType(string $type): bool
+    {
+        $builtInTypes = [
+            'string', 'int', 'float', 'bool', 'array', 'object',
+            'callable', 'iterable', 'mixed', 'void', 'never',
+        ];
+
+        return in_array(strtolower($type), $builtInTypes);
+    }
+}

tests/rules/FinalClassRuleTest.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\Tests\PHPStan\Rules;
+
+use Ibexa\PHPStan\Rules\FinalClassRule;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<\Ibexa\PHPStan\Rules\FinalClassRule>
+ */
+final class FinalClassRuleTest extends RuleTestCase
+{
+    protected function getRule(): Rule
+    {
+        return new FinalClassRule($this->createReflectionProvider());
+    }
+
+    public function testRule(): void
+    {
+        $this->analyse(
+            [
+                __DIR__ . '/Fixtures/FinalClass/NonFinalClass.php',
+            ],
+            [
+                [
+                    'Class Ibexa\Tests\PHPStan\Rules\Fixtures\FinalClass\NonFinalClass is not final. All non-abstract classes should be final.',
+                    11,
+                    'Add "final" keyword to the class declaration.',
+                ],
+            ]
+        );
+    }
+
+    public function testNoErrorsOnFinalAndAbstractClassesAndInterfaces(): void
+    {
+        $this->analyse(
+            [
+                __DIR__ . '/Fixtures/FinalClass/FinalClass.php',
+                __DIR__ . '/Fixtures/FinalClass/AbstractClass.php',
+                __DIR__ . '/Fixtures/FinalClass/SomeInterface.php',
+                __DIR__ . '/Fixtures/FinalClass/SomeTrait.php',
+            ],
+            []
+        );
+    }
+}

tests/rules/Fixtures/FinalClass/AbstractClass.php

@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\Tests\PHPStan\Rules\Fixtures\FinalClass;
+
+abstract class AbstractClass
+{
+}

tests/rules/Fixtures/FinalClass/FinalClass.php

@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\Tests\PHPStan\Rules\Fixtures\FinalClass;
+
+final class FinalClass
+{
+}

tests/rules/Fixtures/FinalClass/NonFinalClass.php

@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\Tests\PHPStan\Rules\Fixtures\FinalClass;
+
+class NonFinalClass
+{
+}

tests/rules/Fixtures/FinalClass/SomeInterface.php

@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\Tests\PHPStan\Rules\Fixtures\FinalClass;
+
+interface SomeInterface
+{
+}

tests/rules/Fixtures/FinalClass/SomeTrait.php

@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\Tests\PHPStan\Rules\Fixtures\FinalClass;
+
+trait SomeTrait
+{
+}