@flarum/cli 2.0.0-beta.8 → 3.0.0

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AttributeEmulator.php

@@ -2,43 +2,36 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\Lexer\Emulative;
+use PhpParser\PhpVersion;
+use PhpParser\Token;
 
-final class AttributeEmulator extends TokenEmulator
-{
-    public function getPhpVersion(): string
-    {
-        return Emulative::PHP_8_0;
+final class AttributeEmulator extends TokenEmulator {
+    public function getPhpVersion(): PhpVersion {
+        return PhpVersion::fromComponents(8, 0);
     }
 
-    public function isEmulationNeeded(string $code) : bool
-    {
+    public function isEmulationNeeded(string $code): bool {
         return strpos($code, '#[') !== false;
     }
 
-    public function emulate(string $code, array $tokens): array
-    {
+    public function emulate(string $code, array $tokens): array {
         // We need to manually iterate and manage a count because we'll change
         // the tokens array on the way.
-        $line = 1;
         for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
-            if ($tokens[$i] === '#' && isset($tokens[$i + 1]) && $tokens[$i + 1] === '[') {
+            $token = $tokens[$i];
+            if ($token->text === '#' && isset($tokens[$i + 1]) && $tokens[$i + 1]->text === '[') {
                 array_splice($tokens, $i, 2, [
-                    [\T_ATTRIBUTE, '#[', $line]
+                    new Token(\T_ATTRIBUTE, '#[', $token->line, $token->pos),
                 ]);
                 $c--;
                 continue;
             }
-            if (\is_array($tokens[$i])) {
-                $line += substr_count($tokens[$i][1], "\n");
-            }
         }
 
         return $tokens;
     }
 
-    public function reverseEmulate(string $code, array $tokens): array
-    {
+    public function reverseEmulate(string $code, array $tokens): array {
         // TODO
         return $tokens;
     }

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/EnumTokenEmulator.php

@@ -2,30 +2,25 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\Lexer\Emulative;
+use PhpParser\PhpVersion;
 
-final class EnumTokenEmulator extends KeywordEmulator
-{
-    public function getPhpVersion(): string
-    {
-        return Emulative::PHP_8_1;
+final class EnumTokenEmulator extends KeywordEmulator {
+    public function getPhpVersion(): PhpVersion {
+        return PhpVersion::fromComponents(8, 1);
     }
 
-    public function getKeywordString(): string
-    {
+    public function getKeywordString(): string {
         return 'enum';
     }
 
-    public function getKeywordToken(): int
-    {
+    public function getKeywordToken(): int {
         return \T_ENUM;
     }
 
-    protected function isKeywordContext(array $tokens, int $pos): bool
-    {
+    protected function isKeywordContext(array $tokens, int $pos): bool {
         return parent::isKeywordContext($tokens, $pos)
             && isset($tokens[$pos + 2])
-            && $tokens[$pos + 1][0] === \T_WHITESPACE
-            && $tokens[$pos + 2][0] === \T_STRING;
+            && $tokens[$pos + 1]->id === \T_WHITESPACE
+            && $tokens[$pos + 2]->id === \T_STRING;
     }
-}
+}

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ExplicitOctalEmulator.php

@@ -0,0 +1,45 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\PhpVersion;
+use PhpParser\Token;
+
+class ExplicitOctalEmulator extends TokenEmulator {
+    public function getPhpVersion(): PhpVersion {
+        return PhpVersion::fromComponents(8, 1);
+    }
+
+    public function isEmulationNeeded(string $code): bool {
+        return strpos($code, '0o') !== false || strpos($code, '0O') !== false;
+    }
+
+    public function emulate(string $code, array $tokens): array {
+        for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+            $token = $tokens[$i];
+            if ($token->id == \T_LNUMBER && $token->text === '0' &&
+                isset($tokens[$i + 1]) && $tokens[$i + 1]->id == \T_STRING &&
+                preg_match('/[oO][0-7]+(?:_[0-7]+)*/', $tokens[$i + 1]->text)
+            ) {
+                $tokenKind = $this->resolveIntegerOrFloatToken($tokens[$i + 1]->text);
+                array_splice($tokens, $i, 2, [
+                    new Token($tokenKind, '0' . $tokens[$i + 1]->text, $token->line, $token->pos),
+                ]);
+                $c--;
+            }
+        }
+        return $tokens;
+    }
+
+    private function resolveIntegerOrFloatToken(string $str): int {
+        $str = substr($str, 1);
+        $str = str_replace('_', '', $str);
+        $num = octdec($str);
+        return is_float($num) ? \T_DNUMBER : \T_LNUMBER;
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array {
+        // Explicit octals were not legal code previously, don't bother.
+        return $tokens;
+    }
+}

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php

@@ -2,43 +2,38 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-abstract class KeywordEmulator extends TokenEmulator
-{
-    abstract function getKeywordString(): string;
-    abstract function getKeywordToken(): int;
+use PhpParser\Token;
 
-    public function isEmulationNeeded(string $code): bool
-    {
+abstract class KeywordEmulator extends TokenEmulator {
+    abstract public function getKeywordString(): string;
+    abstract public function getKeywordToken(): int;
+
+    public function isEmulationNeeded(string $code): bool {
         return strpos(strtolower($code), $this->getKeywordString()) !== false;
     }
 
-    protected function isKeywordContext(array $tokens, int $pos): bool
-    {
+    /** @param Token[] $tokens */
+    protected function isKeywordContext(array $tokens, int $pos): bool {
         $previousNonSpaceToken = $this->getPreviousNonSpaceToken($tokens, $pos);
-        return $previousNonSpaceToken === null || $previousNonSpaceToken[0] !== \T_OBJECT_OPERATOR;
+        return $previousNonSpaceToken === null || $previousNonSpaceToken->id !== \T_OBJECT_OPERATOR;
     }
 
-    public function emulate(string $code, array $tokens): array
-    {
+    public function emulate(string $code, array $tokens): array {
         $keywordString = $this->getKeywordString();
         foreach ($tokens as $i => $token) {
-            if ($token[0] === T_STRING && strtolower($token[1]) === $keywordString
+            if ($token->id === T_STRING && strtolower($token->text) === $keywordString
                     && $this->isKeywordContext($tokens, $i)) {
-                $tokens[$i][0] = $this->getKeywordToken();
+                $token->id = $this->getKeywordToken();
             }
         }
 
         return $tokens;
     }
 
-    /**
-     * @param mixed[] $tokens
-     * @return mixed[]|null
-     */
-    private function getPreviousNonSpaceToken(array $tokens, int $start)
-    {
+    /** @param Token[] $tokens */
+    private function getPreviousNonSpaceToken(array $tokens, int $start): ?Token {
         for ($i = $start - 1; $i >= 0; --$i) {
-            if ($tokens[$i][0] === T_WHITESPACE) {
+            if ($tokens[$i]->id === T_WHITESPACE) {
                 continue;
             }
 
@@ -48,12 +43,11 @@ abstract class KeywordEmulator extends TokenEmulator
         return null;
     }
 
-    public function reverseEmulate(string $code, array $tokens): array
-    {
+    public function reverseEmulate(string $code, array $tokens): array {
         $keywordToken = $this->getKeywordToken();
-        foreach ($tokens as $i => $token) {
-            if ($token[0] === $keywordToken) {
-                $tokens[$i][0] = \T_STRING;
+        foreach ($tokens as $token) {
+            if ($token->id === $keywordToken) {
+                $token->id = \T_STRING;
             }
         }
 

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php

@@ -2,22 +2,18 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\Lexer\Emulative;
+use PhpParser\PhpVersion;
 
-final class MatchTokenEmulator extends KeywordEmulator
-{
-    public function getPhpVersion(): string
-    {
-        return Emulative::PHP_8_0;
+final class MatchTokenEmulator extends KeywordEmulator {
+    public function getPhpVersion(): PhpVersion {
+        return PhpVersion::fromComponents(8, 0);
     }
 
-    public function getKeywordString(): string
-    {
+    public function getKeywordString(): string {
         return 'match';
     }
 
-    public function getKeywordToken(): int
-    {
+    public function getKeywordToken(): int {
         return \T_MATCH;
     }
 }

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/NullsafeTokenEmulator.php

@@ -2,65 +2,58 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\Lexer\Emulative;
+use PhpParser\PhpVersion;
+use PhpParser\Token;
 
-final class NullsafeTokenEmulator extends TokenEmulator
-{
-    public function getPhpVersion(): string
-    {
-        return Emulative::PHP_8_0;
+final class NullsafeTokenEmulator extends TokenEmulator {
+    public function getPhpVersion(): PhpVersion {
+        return PhpVersion::fromComponents(8, 0);
     }
 
-    public function isEmulationNeeded(string $code): bool
-    {
+    public function isEmulationNeeded(string $code): bool {
         return strpos($code, '?->') !== false;
     }
 
-    public function emulate(string $code, array $tokens): array
-    {
+    public function emulate(string $code, array $tokens): array {
         // We need to manually iterate and manage a count because we'll change
         // the tokens array on the way
-        $line = 1;
         for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
-            if ($tokens[$i] === '?' && isset($tokens[$i + 1]) && $tokens[$i + 1][0] === \T_OBJECT_OPERATOR) {
+            $token = $tokens[$i];
+            if ($token->text === '?' && isset($tokens[$i + 1]) && $tokens[$i + 1]->id === \T_OBJECT_OPERATOR) {
                 array_splice($tokens, $i, 2, [
-                    [\T_NULLSAFE_OBJECT_OPERATOR, '?->', $line]
+                    new Token(\T_NULLSAFE_OBJECT_OPERATOR, '?->', $token->line, $token->pos),
                 ]);
                 $c--;
                 continue;
             }
 
             // Handle ?-> inside encapsed string.
-            if ($tokens[$i][0] === \T_ENCAPSED_AND_WHITESPACE && isset($tokens[$i - 1])
-                && $tokens[$i - 1][0] === \T_VARIABLE
-                && preg_match('/^\?->([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)/', $tokens[$i][1], $matches)
+            if ($token->id === \T_ENCAPSED_AND_WHITESPACE && isset($tokens[$i - 1])
+                && $tokens[$i - 1]->id === \T_VARIABLE
+                && preg_match('/^\?->([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)/', $token->text, $matches)
             ) {
                 $replacement = [
-                    [\T_NULLSAFE_OBJECT_OPERATOR, '?->', $line],
-                    [\T_STRING, $matches[1], $line],
+                    new Token(\T_NULLSAFE_OBJECT_OPERATOR, '?->', $token->line, $token->pos),
+                    new Token(\T_STRING, $matches[1], $token->line, $token->pos + 3),
                 ];
-                if (\strlen($matches[0]) !== \strlen($tokens[$i][1])) {
-                    $replacement[] = [
+                $matchLen = \strlen($matches[0]);
+                if ($matchLen !== \strlen($token->text)) {
+                    $replacement[] = new Token(
                         \T_ENCAPSED_AND_WHITESPACE,
-                        \substr($tokens[$i][1], \strlen($matches[0])),
-                        $line
-                    ];
+                        \substr($token->text, $matchLen),
+                        $token->line, $token->pos + $matchLen
+                    );
                 }
                 array_splice($tokens, $i, 1, $replacement);
                 $c += \count($replacement) - 1;
                 continue;
             }
-
-            if (\is_array($tokens[$i])) {
-                $line += substr_count($tokens[$i][1], "\n");
-            }
         }
 
         return $tokens;
     }
 
-    public function reverseEmulate(string $code, array $tokens): array
-    {
+    public function reverseEmulate(string $code, array $tokens): array {
         // ?-> was not valid code previously, don't bother.
         return $tokens;
     }

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReadonlyFunctionTokenEmulator.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\PhpVersion;
+
+/*
+ * In PHP 8.1, "readonly(" was special cased in the lexer in order to support functions with
+ * name readonly. In PHP 8.2, this may conflict with readonly properties having a DNF type. For
+ * this reason, PHP 8.2 instead treats this as T_READONLY and then handles it specially in the
+ * parser. This emulator only exists to handle this special case, which is skipped by the
+ * PHP 8.1 ReadonlyTokenEmulator.
+ */
+class ReadonlyFunctionTokenEmulator extends KeywordEmulator {
+    public function getKeywordString(): string {
+        return 'readonly';
+    }
+
+    public function getKeywordToken(): int {
+        return \T_READONLY;
+    }
+
+    public function getPhpVersion(): PhpVersion {
+        return PhpVersion::fromComponents(8, 2);
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array {
+        // Don't bother
+        return $tokens;
+    }
+}

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReadonlyTokenEmulator.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\PhpVersion;
+
+final class ReadonlyTokenEmulator extends KeywordEmulator {
+    public function getPhpVersion(): PhpVersion {
+        return PhpVersion::fromComponents(8, 1);
+    }
+
+    public function getKeywordString(): string {
+        return 'readonly';
+    }
+
+    public function getKeywordToken(): int {
+        return \T_READONLY;
+    }
+
+    protected function isKeywordContext(array $tokens, int $pos): bool {
+        if (!parent::isKeywordContext($tokens, $pos)) {
+            return false;
+        }
+        // Support "function readonly("
+        return !(isset($tokens[$pos + 1]) &&
+                 ($tokens[$pos + 1]->text === '(' ||
+                  ($tokens[$pos + 1]->id === \T_WHITESPACE &&
+                   isset($tokens[$pos + 2]) &&
+                   $tokens[$pos + 2]->text === '(')));
+    }
+}

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReverseEmulator.php

@@ -2,19 +2,20 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
+use PhpParser\PhpVersion;
+
 /**
  * Reverses emulation direction of the inner emulator.
  */
-final class ReverseEmulator extends TokenEmulator
-{
+final class ReverseEmulator extends TokenEmulator {
     /** @var TokenEmulator Inner emulator */
-    private $emulator;
+    private TokenEmulator $emulator;
 
     public function __construct(TokenEmulator $emulator) {
         $this->emulator = $emulator;
     }
 
-    public function getPhpVersion(): string {
+    public function getPhpVersion(): PhpVersion {
         return $this->emulator->getPhpVersion();
     }
 
@@ -33,4 +34,4 @@ final class ReverseEmulator extends TokenEmulator
     public function preprocessCode(string $code, array &$patches): string {
         return $code;
     }
-}
+}

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/TokenEmulator.php

@@ -2,23 +2,28 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
+use PhpParser\PhpVersion;
+use PhpParser\Token;
+
 /** @internal */
-abstract class TokenEmulator
-{
-    abstract public function getPhpVersion(): string;
+abstract class TokenEmulator {
+    abstract public function getPhpVersion(): PhpVersion;
 
     abstract public function isEmulationNeeded(string $code): bool;
 
     /**
-     * @return array Modified Tokens
+     * @param Token[] $tokens Original tokens
+     * @return Token[] Modified Tokens
      */
     abstract public function emulate(string $code, array $tokens): array;
 
     /**
-     * @return array Modified Tokens
+     * @param Token[] $tokens Original tokens
+     * @return Token[] Modified Tokens
      */
     abstract public function reverseEmulate(string $code, array $tokens): array;
 
+    /** @param array{int, string, string}[] $patches */
     public function preprocessCode(string $code, array &$patches): string {
         return $code;
     }