From bb0bac32d9612379bd19c914874a33f70768c120 Mon Sep 17 00:00:00 2001
From: ErickSkrauch <erickskrauch@yandex.ru>
Date: Tue, 16 Jan 2024 01:23:05 +0100
Subject: [PATCH] Fixes #4. Implemented ErickSkrauch/ordered_overrides fixer

---
 CHANGELOG.md                                  |   2 +
 README.md                                     |  20 ++
 composer.json                                 |   2 +-
 composer.lock                                 |  17 +-
 src/Analyzer/ClassNameAnalyzer.php            |  72 +++++
 src/ClassNotation/OrderedOverridesFixer.php   | 258 ++++++++++++++++++
 .../OrderedOverridesFixerTest.php             | 222 +++++++++++++++
 tests/ClassNotation/_data/AbstractA.php       |  11 +
 tests/ClassNotation/_data/EmptyInterface.php  |   8 +
 tests/ClassNotation/_data/InterfaceA.php      |  12 +
 tests/ClassNotation/_data/InterfaceAandB.php  |  10 +
 tests/ClassNotation/_data/InterfaceB.php      |  12 +
 12 files changed, 638 insertions(+), 8 deletions(-)
 create mode 100644 src/Analyzer/ClassNameAnalyzer.php
 create mode 100644 src/ClassNotation/OrderedOverridesFixer.php
 create mode 100644 tests/ClassNotation/OrderedOverridesFixerTest.php
 create mode 100644 tests/ClassNotation/_data/AbstractA.php
 create mode 100644 tests/ClassNotation/_data/EmptyInterface.php
 create mode 100644 tests/ClassNotation/_data/InterfaceA.php
 create mode 100644 tests/ClassNotation/_data/InterfaceAandB.php
 create mode 100644 tests/ClassNotation/_data/InterfaceB.php

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 360735a..6609bdf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Added
+- Enh #4: Introduce `ErickSkrauch\ordered_overrides` fixer.
 
 ## [1.2.4] - 2024-01-15
 ### Fixed
diff --git a/README.md b/README.md
index 924cc0d..bafb1a1 100644
--- a/README.md
+++ b/README.md
@@ -154,6 +154,26 @@ Ensures that multiline if statement body curly brace placed on the right line.
 * `keep_on_own_line` - should this place closing bracket on its own line? If it's set to `false`, than
   curly bracket will be placed right after the last condition statement. **Default**: `true`.
 
+### `ErickSkrauch/ordered_overrides`
+
+Overridden and implemented methods must be sorted in the same order as they are defined in parent classes.
+
+```diff
+--- Original
++++ New
+@@ @@
+ <?php
+ class Foo implements Serializable {
+
+-    public function unserialize($data) {}
++    public function serialize() {}
+
+-    public function serialize() {}
++    public function unserialize($data) {}
+
+ }
+```
+
 ### `ErickSkrauch/remove_class_name_method_usages` (Yii2)
 
 Replaces Yii2 [`BaseObject::className()`](https://github.com/yiisoft/yii2/blob/e53fc0ded1/framework/base/BaseObject.php#L84)
diff --git a/composer.json b/composer.json
index 43ca217..a7e65b8 100644
--- a/composer.json
+++ b/composer.json
@@ -25,7 +25,7 @@
         "phpspec/prophecy": "^1.15",
         "phpspec/prophecy-phpunit": "^2.0",
         "phpstan/extension-installer": "^1.3",
-        "phpstan/phpstan": "^1.10",
+        "phpstan/phpstan": "^1.11.x-dev",
         "phpstan/phpstan-phpunit": "^1.3",
         "phpstan/phpstan-strict-rules": "^1.5",
         "phpunit/phpunit": "^9.5",
diff --git a/composer.lock b/composer.lock
index 03f0273..c4df174 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "2b5c7609285adc190656e11621eeb4b9",
+    "content-hash": "dea316b7b5a43abf592216a362f616c9",
     "packages": [
         {
             "name": "composer/pcre",
@@ -3393,16 +3393,16 @@
         },
         {
             "name": "phpstan/phpstan",
-            "version": "1.10.54",
+            "version": "1.11.x-dev",
             "source": {
                 "type": "git",
                 "url": "https://github.com/phpstan/phpstan.git",
-                "reference": "3e25f279dada0adc14ffd7bad09af2e2fc3523bb"
+                "reference": "790bdaf2ead9e373f8ddb00ffa3fddf863baef32"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/3e25f279dada0adc14ffd7bad09af2e2fc3523bb",
-                "reference": "3e25f279dada0adc14ffd7bad09af2e2fc3523bb",
+                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/790bdaf2ead9e373f8ddb00ffa3fddf863baef32",
+                "reference": "790bdaf2ead9e373f8ddb00ffa3fddf863baef32",
                 "shasum": ""
             },
             "require": {
@@ -3411,6 +3411,7 @@
             "conflict": {
                 "phpstan/phpstan-shim": "*"
             },
+            "default-branch": true,
             "bin": [
                 "phpstan",
                 "phpstan.phar"
@@ -3451,7 +3452,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2024-01-05T15:50:47+00:00"
+            "time": "2024-01-17T14:22:43+00:00"
         },
         {
             "name": "phpstan/phpstan-phpunit",
@@ -5161,7 +5162,9 @@
     ],
     "aliases": [],
     "minimum-stability": "stable",
-    "stability-flags": [],
+    "stability-flags": {
+        "phpstan/phpstan": 20
+    },
     "prefer-stable": false,
     "prefer-lowest": false,
     "platform": {
diff --git a/src/Analyzer/ClassNameAnalyzer.php b/src/Analyzer/ClassNameAnalyzer.php
new file mode 100644
index 0000000..1434e14
--- /dev/null
+++ b/src/Analyzer/ClassNameAnalyzer.php
@@ -0,0 +1,72 @@
+<?php
+declare(strict_types=1);
+
+namespace ErickSkrauch\PhpCsFixer\Analyzer;
+
+use LogicException;
+use PhpCsFixer\Tokenizer\Analyzer\NamespacesAnalyzer;
+use PhpCsFixer\Tokenizer\Analyzer\NamespaceUsesAnalyzer;
+use PhpCsFixer\Tokenizer\Tokens;
+
+// TODO: better naming
+// TODO: cover with tests
+final class ClassNameAnalyzer {
+
+    private NamespacesAnalyzer $namespacesAnalyzer;
+
+    private NamespaceUsesAnalyzer $namespacesUsesAnalyzer;
+
+    public function __construct() {
+        $this->namespacesAnalyzer = new NamespacesAnalyzer();
+        $this->namespacesUsesAnalyzer = new NamespaceUsesAnalyzer();
+    }
+
+    /**
+     * @see https://www.php.net/manual/en/language.namespaces.rules.php
+     *
+     * @phpstan-return class-string
+     */
+    public function getFqn(Tokens $tokens, int $classNameIndex): string {
+        $firstPart = $tokens[$classNameIndex];
+        if (!$firstPart->isGivenKind([T_STRING, T_NS_SEPARATOR])) {
+            throw new LogicException(sprintf('No T_STRING or T_NS_SEPARATOR at given index %d, got "%s".', $classNameIndex, $firstPart->getName()));
+        }
+
+        $relativeClassName = $this->readClassName($tokens, $classNameIndex);
+        if (str_starts_with($relativeClassName, '\\')) {
+            return $relativeClassName; // @phpstan-ignore return.type
+        }
+
+        $namespace = $this->namespacesAnalyzer->getNamespaceAt($tokens, $classNameIndex);
+        $uses = $this->namespacesUsesAnalyzer->getDeclarationsInNamespace($tokens, $namespace);
+        $parts = explode('\\', $relativeClassName, 2);
+        /** @var \PhpCsFixer\Tokenizer\Analyzer\Analysis\NamespaceUseAnalysis $use */
+        foreach ($uses as $use) {
+            if ($use->getShortName() !== $parts[0]) {
+                continue;
+            }
+
+            // @phpstan-ignore return.type
+            return '\\' . $use->getFullName() . (isset($parts[1]) ? ('\\' . $parts[1]) : '');
+        }
+
+        // @phpstan-ignore return.type
+        return ($namespace->getFullName() !== '' ? '\\' : '') . $namespace->getFullName() . '\\' . $relativeClassName;
+    }
+
+    private function readClassName(Tokens $tokens, int $classNameStart): string {
+        $className = '';
+        $index = $classNameStart;
+        do {
+            $token = $tokens[$index];
+            if ($token->isWhitespace()) {
+                continue;
+            }
+
+            $className .= $token->getContent();
+        } while ($tokens[++$index]->isGivenKind([T_STRING, T_NS_SEPARATOR, T_WHITESPACE]));
+
+        return $className;
+    }
+
+}
diff --git a/src/ClassNotation/OrderedOverridesFixer.php b/src/ClassNotation/OrderedOverridesFixer.php
new file mode 100644
index 0000000..34fa3ea
--- /dev/null
+++ b/src/ClassNotation/OrderedOverridesFixer.php
@@ -0,0 +1,258 @@
+<?php
+declare(strict_types=1);
+
+namespace ErickSkrauch\PhpCsFixer\ClassNotation;
+
+use ErickSkrauch\PhpCsFixer\AbstractFixer;
+use ErickSkrauch\PhpCsFixer\Analyzer\ClassNameAnalyzer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Tokens;
+use ReflectionClass;
+use SplFileInfo;
+use SplStack;
+
+/**
+ * @phpstan-type MethodData array{
+ *     name: string,
+ *     start: int,
+ *     end: int,
+ * }
+ */
+final class OrderedOverridesFixer extends AbstractFixer {
+
+    /**
+     * @readonly
+     */
+    private ClassNameAnalyzer $classNameAnalyzer;
+
+    public function __construct() {
+        parent::__construct();
+        $this->classNameAnalyzer = new ClassNameAnalyzer();
+    }
+
+    public function isCandidate(Tokens $tokens): bool {
+        return $tokens->isAnyTokenKindsFound([T_CLASS, T_INTERFACE]);
+    }
+
+    public function getDefinition(): FixerDefinitionInterface {
+        return new FixerDefinition(
+            'Overridden and implemented methods must be sorted in the same order as they are defined in parent classes.',
+            [
+                new CodeSample('<?php
+class Foo implements Serializable {
+
+    public function unserialize($data) {}
+
+    public function serialize() {}
+
+}
+'),
+            ],
+        );
+    }
+
+    /**
+     * Must run before OrderedClassElementsFixer
+     * Must run after OrderedInterfacesFixer TODO: it's invariant right now: x < 0, but x > 65
+     */
+    public function getPriority(): int {
+        return 75;
+    }
+
+    /**
+     * @throws \ReflectionException
+     */
+    protected function applyFix(SplFileInfo $file, Tokens $tokens): void {
+        for ($i = 1, $count = $tokens->count(); $i < $count; ++$i) {
+            $classToken = $tokens[$i];
+            if (!$classToken->isGivenKind([T_CLASS, T_INTERFACE])) {
+                continue;
+            }
+
+            $methodsOrder = [];
+
+            $extends = $this->getClassExtensions($tokens, $i, T_EXTENDS);
+            $interfaces = $this->getClassExtensions($tokens, $i, T_IMPLEMENTS);
+            $extensions = array_merge($extends, $interfaces);
+            if (count($extensions) === 0) {
+                continue;
+            }
+
+            foreach ($extensions as $className) {
+                $classReflection = new ReflectionClass($className);
+                $parents = $this->getClassParents($classReflection, new SplStack());
+                foreach ($parents as $parent) {
+                    foreach ($parent->getMethods() as $method) {
+                        if (!in_array($method->getShortName(), $methodsOrder, true)) {
+                            $methodsOrder[] = $method->getShortName();
+                        }
+                    }
+                }
+            }
+
+            if (count($methodsOrder) === 0) {
+                continue;
+            }
+
+            /** @var array<string, non-negative-int> $methodsPriority */
+            $methodsPriority = array_flip(array_reverse($methodsOrder));
+
+            $classBodyStart = $tokens->getNextTokenOfKind($i, ['{']);
+            $classBodyEnd = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $classBodyStart);
+
+            /** @var list<MethodData> $unsortedMethods */
+            $unsortedMethods = [];
+            // TODO: actually there still might be properties and traits in between methods declarations
+            for ($j = $classBodyStart; $j < $classBodyEnd; $j++) {
+                $functionToken = $tokens[$j];
+                if (!$functionToken->isGivenKind(T_FUNCTION)) {
+                    continue;
+                }
+
+                $methodNameToken = $tokens[$tokens->getNextMeaningfulToken($j)];
+                // Ensure it's not an anonymous function
+                if ($methodNameToken->equals('(')) {
+                    continue;
+                }
+
+                $methodName = $methodNameToken->getContent();
+
+                // Take the closest whitespace to the beginning of the method
+                $methodStart = $tokens->getPrevTokenOfKind($j, ['}', ';', '{']) + 1;
+                $methodEnd = $this->findElementEnd($tokens, $j);
+
+                $unsortedMethods[] = [
+                    'name' => $methodName,
+                    'start' => $methodStart,
+                    'end' => $methodEnd,
+                ];
+            }
+
+            $sortedMethods = $this->sortMethods($unsortedMethods, $methodsPriority);
+            if ($sortedMethods === $unsortedMethods) {
+                continue;
+            }
+
+            $startIndex = $unsortedMethods[array_key_first($unsortedMethods)]['start'];
+            $endIndex = $unsortedMethods[array_key_last($unsortedMethods)]['end'];
+            $replaceTokens = [];
+            foreach ($sortedMethods as $method) {
+                for ($k = $method['start']; $k <= $method['end']; ++$k) {
+                    $replaceTokens[] = clone $tokens[$k];
+                }
+            }
+
+            $tokens->overrideRange($startIndex, $endIndex, $replaceTokens);
+
+            $i = $endIndex;
+        }
+    }
+
+    /**
+     * @return array<int, class-string>
+     */
+    private function getClassExtensions(Tokens $tokens, int $classTokenIndex, int $extensionType): array {
+        $extensionTokenIndex = $tokens->getNextTokenOfKind($classTokenIndex, [[$extensionType], '{']);
+        if (!$tokens[$extensionTokenIndex]->isGivenKind($extensionType)) {
+            return [];
+        }
+
+        $classNames = [];
+        $classStartIndex = $tokens->getNextMeaningfulToken($extensionTokenIndex);
+        do {
+            $nextDelimiterIndex = $tokens->getNextTokenOfKind($classStartIndex, [',', '{']);
+            $classNames[] = $this->classNameAnalyzer->getFqn($tokens, $classStartIndex);
+            $classStartIndex = $tokens->getNextMeaningfulToken($nextDelimiterIndex);
+        } while ($tokens[$nextDelimiterIndex]->getContent() === ',');
+
+        return $classNames;
+    }
+
+    /**
+     * @param ReflectionClass<object> $class
+     * @param SplStack<ReflectionClass<object>> $stack
+     *
+     * @return SplStack<ReflectionClass<object>>
+     */
+    private function getClassParents(ReflectionClass $class, SplStack $stack): SplStack {
+        $stack->push($class);
+        $parent = $class->getParentClass();
+        if ($parent !== false) {
+            $stack = $this->getClassParents($parent, $stack);
+        }
+
+        $interfaces = $class->getInterfaces();
+        if (count($interfaces) > 0) {
+            foreach (array_reverse($interfaces) as $interface) {
+                $stack = $this->getClassParents($interface, $stack);
+            }
+        }
+
+        return $stack;
+    }
+
+    /**
+     * Taken from the OrderedClassElementsFixer
+     */
+    private function findElementEnd(Tokens $tokens, int $index): int {
+        $blockStart = $tokens->getNextTokenOfKind($index, ['{', ';']);
+        if ($tokens[$blockStart]->equals('{')) {
+            $blockEnd = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $blockStart);
+        } else {
+            $blockEnd = $blockStart;
+        }
+
+        for (++$blockEnd; $tokens[$blockEnd]->isWhitespace(" \t") || $tokens[$blockEnd]->isComment(); ++$blockEnd);
+
+        --$blockEnd;
+
+        return $tokens[$blockEnd]->isWhitespace() ? $blockEnd - 1 : $blockEnd;
+    }
+
+    /**
+     * @phpstan-param list<MethodData> $methods
+     * @phpstan-param array<string, non-negative-int> $methodsPriority
+     *
+     * @phpstan-return list<MethodData>
+     */
+    private function sortMethods(array $methods, array $methodsPriority): array {
+        $count = count($methods);
+        $targetPriority = $methodsPriority[array_key_last($methodsPriority)];
+        for ($i = 0; $i < $count; $i++) {
+            $a = $methods[$i];
+            if (!isset($methodsPriority[$a['name']])) {
+                continue;
+            }
+
+            $priorityA = $methodsPriority[$a['name']];
+            if ($priorityA === $targetPriority) {
+                $targetPriority--;
+                continue;
+            }
+
+            do {
+                for ($j = $i + 1; $j < $count; $j++) {
+                    $b = $methods[$j];
+                    if (!isset($methodsPriority[$b['name']])) {
+                        continue;
+                    }
+
+                    $priorityB = $methodsPriority[$b['name']];
+                    if ($priorityB === $targetPriority) {
+                        $methods[$i] = $b;
+                        $methods[$j] = $a;
+                        $targetPriority--;
+
+                        continue 3;
+                    }
+                }
+            } while ($targetPriority > $priorityA && $targetPriority-- >= 0); // @phpstan-ignore greaterOrEqual.alwaysTrue
+        }
+
+        // @phpstan-ignore return.type
+        return $methods;
+    }
+
+}
diff --git a/tests/ClassNotation/OrderedOverridesFixerTest.php b/tests/ClassNotation/OrderedOverridesFixerTest.php
new file mode 100644
index 0000000..8739572
--- /dev/null
+++ b/tests/ClassNotation/OrderedOverridesFixerTest.php
@@ -0,0 +1,222 @@
+<?php
+declare(strict_types=1);
+
+namespace ErickSkrauch\PhpCsFixer\Tests\ClassNotation;
+
+use ErickSkrauch\PhpCsFixer\ClassNotation\OrderedOverridesFixer;
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\Tests\Test\AbstractFixerTestCase;
+
+/**
+ * @covers \ErickSkrauch\PhpCsFixer\ClassNotation\OrderedOverridesFixer
+ */
+final class OrderedOverridesFixerTest extends AbstractFixerTestCase {
+
+    /**
+     * @dataProvider provideTestCases
+     */
+    public function test(string $expected, ?string $input = null): void {
+        $this->doTest($expected, $input);
+    }
+
+    /**
+     * @return iterable<array{0: string, 1?: string}>
+     */
+    public function provideTestCases(): iterable {
+        yield 'no extends, no implements' => [
+            '<?php
+            class A {
+                public function foo(): void {}
+                public function bar(): void {}
+            }
+            ',
+        ];
+
+        yield 'implements empty interface' => [
+            '<?php
+            class A implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\EmptyInterface {
+                public function foo(): void {}
+            }
+            ',
+        ];
+
+        yield 'single interface implementation' => [
+            '<?php
+            class A implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceA {
+                public function foo(): void {}
+                public function bar(): void {}
+            }
+            ',
+            '<?php
+            class A implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceA {
+                public function bar(): void {}
+                public function foo(): void {}
+            }
+            ',
+        ];
+
+        yield 'multiple interfaces implementation' => [
+            '<?php
+            use ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+            class A implements _data\InterfaceA, _data\InterfaceB {
+                public function foo(): void {}
+                public function bar(): void {}
+                public function baz(): void {}
+                public function qux(): void {}
+            }
+            ',
+            '<?php
+            use ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+            class A implements _data\InterfaceA, _data\InterfaceB {
+                public function baz(): void {}
+                public function bar(): void {}
+                public function qux(): void {}
+                public function foo(): void {}
+            }
+            ',
+        ];
+
+        yield 'abstract class' => [
+            '<?php
+            use ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+            abstract class A implements _data\InterfaceA, _data\InterfaceB {
+                public function bar(): void {}
+                abstract function ownMethod(): void;
+                public function baz(): void {}
+            }
+            ',
+            '<?php
+            use ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+            abstract class A implements _data\InterfaceA, _data\InterfaceB {
+                public function baz(): void {}
+                abstract function ownMethod(): void;
+                public function bar(): void {}
+            }
+            ',
+        ];
+
+        yield 'interface extension' => [
+            '<?php
+            interface ExtendedA extends \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceA {
+                public function baz(): void;
+            }
+            ',
+        ];
+
+        yield 'non-interface methods' => [
+            '<?php
+            class A implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceA {
+                public function foo(): void {}
+                public function nonInterface(): void {}
+                public function bar(): void {}
+            }
+            ',
+            '<?php
+            class A implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceA {
+                public function bar(): void {}
+                public function nonInterface(): void {}
+                public function foo(): void {}
+            }
+            ',
+        ];
+
+        yield 'extend abstract class' => [
+            '<?php
+            class A extends \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\AbstractA {
+                public function foo(): void {}
+                public function nonInterface(): void {}
+                public function bar(): void {}
+            }
+            ',
+            '<?php
+            class A extends \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\AbstractA {
+                public function bar(): void {}
+                public function nonInterface(): void {}
+                public function foo(): void {}
+            }
+            ',
+        ];
+
+        yield 'interface with multiple extends' => [
+            '<?php
+            class A implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceAandB {
+                public function foo(): void {}
+                public function nonInterface(): void {}
+                public function bar(): void {}
+                public function baz() : void{}
+                public function qux() : void{}
+                public function quux(): void{}
+            }
+            ',
+            '<?php
+            class A implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceAandB {
+                public function bar(): void {}
+                public function nonInterface(): void {}
+                public function qux() : void{}
+                public function foo(): void {}
+                public function quux(): void{}
+                public function baz() : void{}
+            }
+            ',
+        ];
+
+        yield 'mix of extends and interface' => [
+            '<?php
+            use ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+            class A extends _data\AbstractA implements _data\InterfaceB {
+                public function foo(): void {}
+                public function nonInterface(): void {}
+                public function baz() : void{}
+                public function qux() : void{}
+            }
+            ',
+            '<?php
+            use ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+            class A extends _data\AbstractA implements _data\InterfaceB {
+                public function qux() : void{}
+                public function nonInterface(): void {}
+                public function foo(): void {}
+                public function baz() : void{}
+            }
+            ',
+        ];
+
+        yield 'function in implementation' => [
+            '<?php
+            class A extends \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\AbstractA {
+                public function bar(): void {
+                    $a = function() {
+                        // body
+                    };
+                }
+            }
+            ',
+        ];
+
+        yield 'anonymous class' => [
+            '<?php
+            $a = new class implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceA {
+                public function foo(): void {}
+                public function bar(): void {}
+            };
+            ',
+            '<?php
+            $a = new class implements \ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data\InterfaceA {
+                public function bar(): void {}
+                public function foo(): void {}
+            };
+            ',
+        ];
+    }
+
+    protected function createFixer(): AbstractFixer {
+        return new OrderedOverridesFixer();
+    }
+
+}
diff --git a/tests/ClassNotation/_data/AbstractA.php b/tests/ClassNotation/_data/AbstractA.php
new file mode 100644
index 0000000..8031279
--- /dev/null
+++ b/tests/ClassNotation/_data/AbstractA.php
@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+
+namespace ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+abstract class AbstractA implements InterfaceA {
+
+    public function bar(): void {
+    }
+
+}
diff --git a/tests/ClassNotation/_data/EmptyInterface.php b/tests/ClassNotation/_data/EmptyInterface.php
new file mode 100644
index 0000000..9edc9e2
--- /dev/null
+++ b/tests/ClassNotation/_data/EmptyInterface.php
@@ -0,0 +1,8 @@
+<?php
+declare(strict_types=1);
+
+namespace ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+interface EmptyInterface {
+
+}
diff --git a/tests/ClassNotation/_data/InterfaceA.php b/tests/ClassNotation/_data/InterfaceA.php
new file mode 100644
index 0000000..cbf7d9c
--- /dev/null
+++ b/tests/ClassNotation/_data/InterfaceA.php
@@ -0,0 +1,12 @@
+<?php
+declare(strict_types=1);
+
+namespace ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+interface InterfaceA {
+
+    public function foo(): void;
+
+    public function bar(): void;
+
+}
diff --git a/tests/ClassNotation/_data/InterfaceAandB.php b/tests/ClassNotation/_data/InterfaceAandB.php
new file mode 100644
index 0000000..1df6ffd
--- /dev/null
+++ b/tests/ClassNotation/_data/InterfaceAandB.php
@@ -0,0 +1,10 @@
+<?php
+declare(strict_types=1);
+
+namespace ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+interface InterfaceAandB extends InterfaceA, InterfaceB {
+
+    public function quux(): void;
+
+}
diff --git a/tests/ClassNotation/_data/InterfaceB.php b/tests/ClassNotation/_data/InterfaceB.php
new file mode 100644
index 0000000..ca7379d
--- /dev/null
+++ b/tests/ClassNotation/_data/InterfaceB.php
@@ -0,0 +1,12 @@
+<?php
+declare(strict_types=1);
+
+namespace ErickSkrauch\PhpCsFixer\Tests\ClassNotation\_data;
+
+interface InterfaceB {
+
+    public function baz(): void;
+
+    public function qux(): void;
+
+}