Apply PER2.0 phpcs (part 1)

Author: SerafimArts

composer.json

@@ -31,7 +31,9 @@
     },
     "require-dev": {
         "phpunit/phpunit": "^9.6|^10.0",
-        "vimeo/psalm": "^5.22"
+        "phpstan/extension-installer": "^1.4",
+        "phpstan/phpstan": "^1.11",
+        "phpstan/phpstan-strict-rules": "^1.6"
     },
     "autoload-dev": {
         "psr-4": {

phpstan.neon

@@ -0,0 +1,12 @@
+includes:
+  - phar://phpstan.phar/conf/bleedingEdge.neon
+parameters:
+  level: 1
+  strictRules:
+    allRules: true
+  fileExtensions:
+    - php
+  paths:
+    - src
+  tmpDir: vendor/.cache.phpstan
+  reportUnmatchedIgnoredErrors: false

psalm.xml

@@ -23,8 +23,8 @@ class TokenDef extends Definition
 
     public function __construct(string $name, string $value, bool $keep = true)
     {
-        $this->name  = $name;
+        $this->name = $name;
         $this->value = $value;
-        $this->keep  = $keep;
+        $this->keep = $keep;
     }
 }

src/Ast/Def/TokenDef.php

@@ -90,7 +90,7 @@ public function parse($source): iterable
 
         $parser = new Parser($lexer, $this->analyzer->rules, [
             ParserConfigsInterface::CONFIG_INITIAL_RULE => $this->analyzer->initial,
-            ParserConfigsInterface::CONFIG_AST_BUILDER  => new PrintableNodeBuilder(),
+            ParserConfigsInterface::CONFIG_AST_BUILDER => new PrintableNodeBuilder(),
         ]);
 
         return $parser->parse($source);

src/Compiler.php

@@ -99,7 +99,7 @@ public function __construct(IdCollection $ids)
     public function enter(NodeInterface $node): void
     {
         if ($node instanceof TokenDef) {
-            $state = $node->state ?: self::STATE_DEFAULT;
+            $state = $node->state ?? self::STATE_DEFAULT;
 
             if (!\array_key_exists($state, $this->tokens)) {
                 $this->tokens[$state] = [];

src/Context/CompilerContext.php

@@ -72,13 +72,14 @@ public function withClassUsage(string $class, string $alias = null): self
     public function generate(): string
     {
         $style = $this->printer->getStyle();
+        $filter = static fn(string $line): bool => \trim($line) !== '';
 
         return \implode($style->lineDelimiter, \array_filter([
             '<?php',
             $this->getStrictTypesResult(),
             $this->getReferencesResult(),
             $this->getBodyResult(),
-        ]));
+        ], $filter));
     }
 
     private function getStrictTypesResult(): string

src/Generator/PhpCodeGenerator.php

@@ -181,7 +181,7 @@ private function reducers(): array
     private function grammar(): array
     {
         return [
-            0  => new Repetition(11, 0),
+            0 => new Repetition(11, 0),
             11 => new Alternation([15, 16, 13, 14, 17]),
             13 => new Lexeme('T_PRAGMA'),
             14 => new Lexeme('T_INCLUDE'),
@@ -197,27 +197,27 @@ private function grammar(): array
             26 => new Lexeme('T_KEPT_NAME', false),
             27 => new Lexeme('T_NAME'),
             28 => new Lexeme('T_EQ', false),
-            8  => new Alternation([21, 22, 24, 5]),
-            9  => new Optional(29),
+            8 => new Alternation([21, 22, 24, 5]),
+            9 => new Optional(29),
             29 => new Lexeme('T_END_OF_RULE', false),
             21 => new Concatenation([2, 4]),
-            4  => new Repetition(1, 1),
-            1  => new Concatenation([30, 2]),
+            4 => new Repetition(1, 1),
+            1 => new Concatenation([30, 2]),
             30 => new Lexeme('T_OR', false),
-            2  => new Alternation([22, 24, 5]),
+            2 => new Alternation([22, 24, 5]),
             22 => new Repetition(3, 2),
-            3  => new Alternation([24, 5]),
-            5  => new Alternation([23, 31, 32, 33, 34]),
+            3 => new Alternation([24, 5]),
+            5 => new Alternation([23, 31, 32, 33, 34]),
             31 => new Lexeme('T_TOKEN_SKIPPED'),
             32 => new Lexeme('T_TOKEN_KEPT'),
             33 => new Lexeme('T_TOKEN_STRING'),
             34 => new Lexeme('T_INVOKE'),
             23 => new Concatenation([35, 7, 36]),
             35 => new Lexeme('T_GROUP_OPEN', false),
             36 => new Lexeme('T_GROUP_CLOSE', false),
-            7  => new Alternation([21, 22, 24, 5]),
+            7 => new Alternation([21, 22, 24, 5]),
             24 => new Concatenation([5, 6]),
-            6  => new Alternation([37, 38, 39, 40, 41, 42, 43]),
+            6 => new Alternation([37, 38, 39, 40, 41, 42, 43]),
             37 => new Lexeme('T_REPEAT_ZERO_OR_ONE'),
             38 => new Lexeme('T_REPEAT_ONE_OR_MORE'),
             39 => new Lexeme('T_REPEAT_ZERO_OR_MORE'),

src/Grammar/PP2Grammar.php

@@ -155,34 +155,34 @@ final class PP2Lexer implements PositionalLexerInterface
      * @var non-empty-array<non-empty-string, non-empty-string>
      */
     private const LEXER_TOKENS = [
-        self::T_PRAGMA              => '%pragma\\h+([\\w\\.]+)\\h+([^\\s]+)',
-        self::T_INCLUDE             => '%include\\h+([^\\s]+)',
-        self::T_TOKEN_DEF           => '%token\\h+(?:(\\w+):)?(\\w+)\\h+([^\\s]+)(?:\\h*\\->\\h*([^\\s]+))?',
-        self::T_SKIP_DEF            => '%skip\\h+(\\w+)\\h+([^\\s]+)',
-        self::T_OR                  => '\\|',
-        self::T_TOKEN_SKIPPED       => '::(\\w+)::',
-        self::T_TOKEN_KEPT          => '<(\\w+)>',
-        self::T_TOKEN_STRING        => '"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"',
-        self::T_INVOKE              => '([a-zA-Z0-9_]+)\\(\\)',
-        self::T_GROUP_OPEN          => '\\(',
-        self::T_GROUP_CLOSE         => '\\)',
-        self::T_REPEAT_ZERO_OR_ONE  => '\\?',
-        self::T_REPEAT_ONE_OR_MORE  => '\\+',
+        self::T_PRAGMA => '%pragma\\h+([\\w\\.]+)\\h+([^\\s]+)',
+        self::T_INCLUDE => '%include\\h+([^\\s]+)',
+        self::T_TOKEN_DEF => '%token\\h+(?:(\\w+):)?(\\w+)\\h+([^\\s]+)(?:\\h*\\->\\h*([^\\s]+))?',
+        self::T_SKIP_DEF => '%skip\\h+(\\w+)\\h+([^\\s]+)',
+        self::T_OR => '\\|',
+        self::T_TOKEN_SKIPPED => '::(\\w+)::',
+        self::T_TOKEN_KEPT => '<(\\w+)>',
+        self::T_TOKEN_STRING => '"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"',
+        self::T_INVOKE => '([a-zA-Z0-9_]+)\\(\\)',
+        self::T_GROUP_OPEN => '\\(',
+        self::T_GROUP_CLOSE => '\\)',
+        self::T_REPEAT_ZERO_OR_ONE => '\\?',
+        self::T_REPEAT_ONE_OR_MORE => '\\+',
         self::T_REPEAT_ZERO_OR_MORE => '\\*',
-        self::T_REPEAT_N_TO_M       => '{\\h*(\\-?\\d+)\\h*,\\h*(\\-?\\d+)\\h*}',
-        self::T_REPEAT_N_OR_MORE    => '{\\h*(\\-?\\d+)\\h*,\\h*}',
-        self::T_REPEAT_ZERO_TO_M    => '{\\h*,\\h*(\\-?\\d+)\\h*}',
-        self::T_REPEAT_EXACTLY_N    => '{\\h*(\\-?\\d+)\\h*}',
-        self::T_KEPT_NAME           => '#',
-        self::T_NAME                => '\\\\?[a-zA-Z0-9_]+(?:\\\\[a-zA-Z0-9_]+)*',
-        self::T_EQ                  => '(?:\\:\\:=|\\:|=)',
-        self::T_END_OF_RULE         => ';',
-        self::T_PHP_OPEN            => '\->\h*{',
-        self::T_ARROW_RIGHT         => '\->',
-        self::T_PHP_CLOSE           => '}',
-        self::T_WHITESPACE          => '(\\xfe\\xff|\\x20|\\x09|\\x0a|\\x0d)+',
-        self::T_COMMENT             => '//[^\\n]*',
-        self::T_BLOCK_COMMENT       => '/\\*.*?\\*/',
+        self::T_REPEAT_N_TO_M => '{\\h*(\\-?\\d+)\\h*,\\h*(\\-?\\d+)\\h*}',
+        self::T_REPEAT_N_OR_MORE => '{\\h*(\\-?\\d+)\\h*,\\h*}',
+        self::T_REPEAT_ZERO_TO_M => '{\\h*,\\h*(\\-?\\d+)\\h*}',
+        self::T_REPEAT_EXACTLY_N => '{\\h*(\\-?\\d+)\\h*}',
+        self::T_KEPT_NAME => '#',
+        self::T_NAME => '\\\\?[a-zA-Z0-9_]+(?:\\\\[a-zA-Z0-9_]+)*',
+        self::T_EQ => '(?:\\:\\:=|\\:|=)',
+        self::T_END_OF_RULE => ';',
+        self::T_PHP_OPEN => '\->\h*{',
+        self::T_ARROW_RIGHT => '\->',
+        self::T_PHP_CLOSE => '}',
+        self::T_WHITESPACE => '(\\xfe\\xff|\\x20|\\x09|\\x0a|\\x0d)+',
+        self::T_COMMENT => '//[^\\n]*',
+        self::T_BLOCK_COMMENT => '/\\*.*?\\*/',
     ];
 
     /**

src/Grammar/PP2Lexer.php

@@ -21,7 +21,7 @@ public function lex($source, int $offset = 0): iterable
         $depth = 0;
 
         $children = [];
-        $value  = '';
+        $value = '';
 
         foreach ($this->lexer->lex($source, $offset) as $inner) {
             if ($inner->getName() === '{') {