code style: Order class elements in methods and properties. (#62)

Author: terabytesoftw

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## 0.3.1 Under development
 
+- Bug #62: Order class elements in methods and properties (@terabytesoftw)
+
 ## 0.3.0 June 27, 2025
 
 - Enh #35: Move config fixtures into `config` subdirectory (@terabytesoftw)

README.md

@@ -1,6 +1,6 @@
 <p align="center">
     <a href="https://github.com/yii2-extensions/phpstan" target="_blank">
-        <img src="https://www.yiiframework.com/image/yii_logo_light.svg" height="100px;" alt="Yii Framework">
+        <img src="https://www.yiiframework.com/image/yii_logo_light.svg" alt="Yii Framework">
     </a>
     <h1 align="center">Extension for PHPStan</h1>
 </p>

docs/installation.md

@@ -253,7 +253,7 @@ vendor/bin/phpstan --version
 
 ## Next steps
 
-Once installation is complete:
+Once the installation is complete.
 
 - ⚙️ [Configuration Reference](configuration.md)
 - 💡 [Usage Examples](examples.md)

docs/testing.md

@@ -4,7 +4,7 @@
 
 This package uses [composer-require-checker](https://github.com/maglnet/ComposerRequireChecker) to check if all dependencies are correctly defined in `composer.json`.
 
-To run the checker, execute the following command:
+To run the checker, execute the following command.
 
 ```shell
 composer run check-dependencies
@@ -13,23 +13,23 @@ composer run check-dependencies
 ## Easy coding standard
 
 The code is checked with [Easy Coding Standard](https://github.com/easy-coding-standard/easy-coding-standard) and
-[PHP CS Fixer](https://github.com/PHP-CS-Fixer/PHP-CS-Fixer). To run it:
+[PHP CS Fixer](https://github.com/PHP-CS-Fixer/PHP-CS-Fixer). To run it.
 
 ```shell
 composer run ecs
 ```
 
 ## Static analysis
 
-The code is statically analyzed with [PHPStan](https://phpstan.org/). To run static analysis:
+The code is statically analyzed with [PHPStan](https://phpstan.org/). To run static analysis.
 
 ```shell
-composer run phpstan
+composer run static
 ```
 
 ## Unit tests
 
-The code is tested with [PHPUnit](https://phpunit.de/). To run tests:
+The code is tested with [PHPUnit](https://phpunit.de/). To run tests.
 
 ```
 composer run test

ecs.php

@@ -18,6 +18,28 @@
             'space_before_parenthesis' => true,
         ],
     )
+    ->withConfiguredRule(
+        OrderedClassElementsFixer::class,
+        [
+            'order' => [
+                'use_trait',
+                'constant_public',
+                'constant_protected',
+                'constant_private',
+                'property_public',
+                'property_protected',
+                'property_private',
+                'construct',
+                'destruct',
+                'magic',
+                'phpunit',
+                'method_public',
+                'method_protected',
+                'method_private',
+            ],
+            'sort_algorithm' => 'alpha',
+        ],
+    )
     ->withConfiguredRule(
         OrderedImportsFixer::class,
         [
@@ -49,7 +71,6 @@
     ->withRules(
         [
             NoUnusedImportsFixer::class,
-            OrderedClassElementsFixer::class,
             OrderedTraitsFixer::class,
             SingleQuoteFixer::class,
         ]

src/ServiceMap.php

@@ -78,18 +78,18 @@ final class ServiceMap
     private array $behaviors = [];
 
     /**
-     * Component definitions map for Yii Application analysis.
+     * Reverse index mapping class names to component IDs for optimized lookups.
      *
-     * @phpstan-var string[]
+     * @phpstan-var array<string, string>
      */
-    private array $components = [];
+    private array $componentClassToIdMap = [];
 
     /**
-     * Reverse index mapping class names to component IDs for optimized lookups.
+     * Component definitions map for Yii Application analysis.
      *
-     * @phpstan-var array<string, string>
+     * @phpstan-var string[]
      */
-    private array $componentClassToIdMap = [];
+    private array $components = [];
 
     /**
      * Component definitions for Yii Application analysis.
@@ -189,29 +189,6 @@ public function getComponentClassById(string $id): string|null
         return $this->components[$id] ?? null;
     }
 
-    /**
-     * Retrieves the component definition array by its identifier.
-     *
-     * Looks up the component definition registered under the specified component ID in the internal component
-     * definitions map.
-     *
-     * This method provides access to the raw component configuration array, enabling static analysis tools and IDEs to
-     * inspect component properties, dependencies, and configuration options for accurate type inference and reflection
-     * analysis.
-     *
-     * @param string $id Component identifier to look up in the component definitions map.
-     *
-     * @return array Component definition array with configuration options, or empty array if not found.
-     *
-     * @phpstan-return array<array-key, mixed>
-     */
-    public function getComponentDefinitionById(string $id): array
-    {
-        $definition = $this->componentsDefinitions[$id] ?? null;
-
-        return is_array($definition) ? $definition : [];
-    }
-
     /**
      * Retrieves the component definition array for a given class name.
      *
@@ -238,6 +215,29 @@ public function getComponentDefinitionByClassName(string $class): array|null
         return $this->getComponentDefinitionById($id);
     }
 
+    /**
+     * Retrieves the component definition array by its identifier.
+     *
+     * Looks up the component definition registered under the specified component ID in the internal component
+     * definitions map.
+     *
+     * This method provides access to the raw component configuration array, enabling static analysis tools and IDEs to
+     * inspect component properties, dependencies, and configuration options for accurate type inference and reflection
+     * analysis.
+     *
+     * @param string $id Component identifier to look up in the component definitions map.
+     *
+     * @return array Component definition array with configuration options, or empty array if not found.
+     *
+     * @phpstan-return array<array-key, mixed>
+     */
+    public function getComponentDefinitionById(string $id): array
+    {
+        $definition = $this->componentsDefinitions[$id] ?? null;
+
+        return is_array($definition) ? $definition : [];
+    }
+
     /**
      * Retrieves the fully qualified class name of a Yii Service by its identifier.
      *

src/type/ActiveRecordDynamicStaticMethodReturnTypeExtension.php

@@ -75,74 +75,6 @@ public function getClass(): string
         return ActiveRecord::class;
     }
 
-    /**
-     * Determines whether the specified static method is supported for dynamic return type inference.
-     *
-     * Inspects the method's return type and class context to decide if the static method should be handled by this
-     * extension for dynamic return type analysis.
-     *
-     * This includes methods returning `$this`, union types containing {@see ActiveRecord} subclasses, or types related
-     * to {@see ActiveQuery}.
-     *
-     * This method enables PHPStan to apply custom type inference for static {@see ActiveRecord} query methods ensuring
-     * accurate autocompletion and static analysis for methods such as {@see ActiveRecord::findOne()},
-     * {@see ActiveRecord::findAll()}, and custom query builders.
-     *
-     * @param MethodReflection $methodReflection Reflection instance for the method being analyzed.
-     *
-     * @return bool `true` if the static method is supported for dynamic return type inference; `false` otherwise.
-     */
-    public function isStaticMethodSupported(MethodReflection $methodReflection): bool
-    {
-        $variants = $methodReflection->getVariants();
-
-        if (count($variants) === 0) {
-            return false;
-        }
-
-        $returnType = $variants[0]->getReturnType();
-
-        if ($returnType::class === ThisType::class) {
-            return true;
-        }
-
-        if ($returnType::class === UnionType::class) {
-            foreach ($returnType->getTypes() as $type) {
-                $classNames = $type->getObjectClassNames();
-
-                if (count($classNames) > 0) {
-                    $className = $classNames[0];
-
-                    if ($this->reflectionProvider->hasClass($className)) {
-                        $classReflection = $this->reflectionProvider->getClass($className);
-
-                        return $classReflection->isSubclassOfClass(
-                            $this->reflectionProvider->getClass($this->getClass()),
-                        );
-                    }
-                }
-            }
-        }
-
-        $classNames = $returnType->getObjectClassNames();
-
-        if (count($classNames) > 0) {
-            $className = $classNames[0];
-
-            if ($className === ActiveQuery::class) {
-                return true;
-            }
-
-            if ($this->reflectionProvider->hasClass($className)) {
-                $classReflection = $this->reflectionProvider->getClass($className);
-
-                return $classReflection->isSubclassOfClass($this->reflectionProvider->getClass(ActiveQuery::class));
-            }
-        }
-
-        return $returnType::class === GenericObjectType::class && $returnType->getClassName() === ActiveQuery::class;
-    }
-
     /**
      * Infers the return type for a static method call on an {@see ActiveRecord} class based on method signature and
      * context.
@@ -225,30 +157,71 @@ public function getTypeFromStaticMethodCall(
     }
 
     /**
-     * Determines whether the specified class is {@see ActiveRecord} or a subclass.
+     * Determines whether the specified static method is supported for dynamic return type inference.
      *
-     * Checks if the given class name corresponds to the {@see ActiveRecord} base class or any of its subclasses by
-     * leveraging the reflection provider.
+     * Inspects the method's return type and class context to decide if the static method should be handled by this
+     * extension for dynamic return type analysis.
      *
-     * This is used to ensure type compatibility and accurate type inference for static {@see ActiveRecord} methods
-     * during PHPStan analysis.
+     * This includes methods returning `$this`, union types containing {@see ActiveRecord} subclasses, or types related
+     * to {@see ActiveQuery}.
      *
-     * This method is essential for supporting dynamic return type inference in scenarios where union types or generic
-     * {@see ActiveRecord} subclasses are involved, enabling precise type checks and autocompletion.
+     * This method enables PHPStan to apply custom type inference for static {@see ActiveRecord} query methods ensuring
+     * accurate autocompletion and static analysis for methods such as {@see ActiveRecord::findOne()},
+     * {@see ActiveRecord::findAll()}, and custom query builders.
      *
-     * @param string $className Fully qualified class name to check.
+     * @param MethodReflection $methodReflection Reflection instance for the method being analyzed.
      *
-     * @return bool `true` if the class is {@see ActiveRecord} or a subclass; `false` otherwise.
+     * @return bool `true` if the static method is supported for dynamic return type inference; `false` otherwise.
      */
-    private function isActiveRecordClass(string $className): bool
+    public function isStaticMethodSupported(MethodReflection $methodReflection): bool
     {
-        if ($this->reflectionProvider->hasClass($className) === false) {
+        $variants = $methodReflection->getVariants();
+
+        if (count($variants) === 0) {
             return false;
         }
 
-        return $this->reflectionProvider->getClass($className)->isSubclassOfClass(
-            $this->reflectionProvider->getClass(ActiveRecord::class),
-        );
+        $returnType = $variants[0]->getReturnType();
+
+        if ($returnType::class === ThisType::class) {
+            return true;
+        }
+
+        if ($returnType::class === UnionType::class) {
+            foreach ($returnType->getTypes() as $type) {
+                $classNames = $type->getObjectClassNames();
+
+                if (count($classNames) > 0) {
+                    $className = $classNames[0];
+
+                    if ($this->reflectionProvider->hasClass($className)) {
+                        $classReflection = $this->reflectionProvider->getClass($className);
+
+                        return $classReflection->isSubclassOfClass(
+                            $this->reflectionProvider->getClass($this->getClass()),
+                        );
+                    }
+                }
+            }
+        }
+
+        $classNames = $returnType->getObjectClassNames();
+
+        if (count($classNames) > 0) {
+            $className = $classNames[0];
+
+            if ($className === ActiveQuery::class) {
+                return true;
+            }
+
+            if ($this->reflectionProvider->hasClass($className)) {
+                $classReflection = $this->reflectionProvider->getClass($className);
+
+                return $classReflection->isSubclassOfClass($this->reflectionProvider->getClass(ActiveQuery::class));
+            }
+        }
+
+        return $returnType::class === GenericObjectType::class && $returnType->getClassName() === ActiveQuery::class;
     }
 
     /**
@@ -277,4 +250,31 @@ private function isActiveQueryClass(string $className): bool
             $this->reflectionProvider->getClass(ActiveQuery::class),
         );
     }
+
+    /**
+     * Determines whether the specified class is {@see ActiveRecord} or a subclass.
+     *
+     * Checks if the given class name corresponds to the {@see ActiveRecord} base class or any of its subclasses by
+     * leveraging the reflection provider.
+     *
+     * This is used to ensure type compatibility and accurate type inference for static {@see ActiveRecord} methods
+     * during PHPStan analysis.
+     *
+     * This method is essential for supporting dynamic return type inference in scenarios where union types or generic
+     * {@see ActiveRecord} subclasses are involved, enabling precise type checks and autocompletion.
+     *
+     * @param string $className Fully qualified class name to check.
+     *
+     * @return bool `true` if the class is {@see ActiveRecord} or a subclass; `false` otherwise.
+     */
+    private function isActiveRecordClass(string $className): bool
+    {
+        if ($this->reflectionProvider->hasClass($className) === false) {
+            return false;
+        }
+
+        return $this->reflectionProvider->getClass($className)->isSubclassOfClass(
+            $this->reflectionProvider->getClass(ActiveRecord::class),
+        );
+    }
 }