Merge pull request #507 from MauricioFauth/token-type-enum

Introduce the TokenType enum
phpmyadmin · Sep 26, 2023 · 61baa39 · 61baa39
2 parents 4077a82 + e9edd4c
commit 61baa39
Show file tree

Hide file tree

Showing 490 changed files with 66,538 additions and 22,752 deletions.
diff --git a/composer.json b/composer.json
@@ -35,7 +35,7 @@
         "phpunit/phpunit": "^10.0",
         "psalm/plugin-phpunit": "^0.18.4",
         "vimeo/psalm": "^5.7",
-        "zumba/json-serializer": "^3.0"
+        "zumba/json-serializer": "^3.2"
     },
     "conflict": {
         "phpmyadmin/motranslator": "<5.2"

diff --git a/psalm-baseline.xml b/psalm-baseline.xml
@@ -1260,7 +1260,7 @@
       <code>$i</code>
     </PossiblyNullOperand>
     <PossiblyNullPropertyFetch>
-      <code><![CDATA[$lexer->list->getNextOfType(Token::TYPE_KEYWORD)->keyword]]></code>
+      <code><![CDATA[$lexer->list->getNextOfType(TokenType::Keyword)->keyword]]></code>
       <code><![CDATA[$statement->into->dest]]></code>
     </PossiblyNullPropertyFetch>
     <PossiblyNullReference>

diff --git a/src/Components/AlterOperation.php b/src/Components/AlterOperation.php
@@ -8,6 +8,7 @@
 use PhpMyAdmin\SqlParser\Parser;
 use PhpMyAdmin\SqlParser\Token;
 use PhpMyAdmin\SqlParser\TokensList;
+use PhpMyAdmin\SqlParser\TokenType;
 
 use function array_key_exists;
 use function in_array;
@@ -321,17 +322,17 @@ public static function parse(Parser $parser, TokensList $list, array $options =
             $token = $list->tokens[$list->idx];
 
             // End of statement.
-            if ($token->type === Token::TYPE_DELIMITER) {
+            if ($token->type === TokenType::Delimiter) {
                 break;
             }
 
             // Skipping comments.
-            if ($token->type === Token::TYPE_COMMENT) {
+            if ($token->type === TokenType::Comment) {
                 continue;
             }
 
             // Skipping whitespaces.
-            if ($token->type === Token::TYPE_WHITESPACE) {
+            if ($token->type === TokenType::Whitespace) {
                 if ($state === 2) {
                     // When parsing the unknown part, the whitespaces are
                     // included to not break anything.
@@ -347,7 +348,7 @@ public static function parse(Parser $parser, TokensList $list, array $options =
                 // body in the unknown tokens list, as they define their own statements.
                 if ($ret->options->has('AS') || $ret->options->has('DO')) {
                     for (; $list->idx < $list->count; ++$list->idx) {
-                        if ($list->tokens[$list->idx]->type === Token::TYPE_DELIMITER) {
+                        if ($list->tokens[$list->idx]->type === TokenType::Delimiter) {
                             break;
                         }
 
@@ -392,22 +393,22 @@ public static function parse(Parser $parser, TokensList $list, array $options =
                     $arrayKey = $token->token;
                 }
 
-                if ($token->type === Token::TYPE_OPERATOR) {
+                if ($token->type === TokenType::Operator) {
                     if ($token->value === '(') {
                         ++$brackets;
                     } elseif ($token->value === ')') {
                         --$brackets;
                     } elseif (($token->value === ',') && ($brackets === 0)) {
                         break;
                     }
-                } elseif (! self::checkIfTokenQuotedSymbol($token) && $token->type !== Token::TYPE_STRING) {
+                } elseif (! self::checkIfTokenQuotedSymbol($token) && $token->type !== TokenType::String) {
                     if (isset(Parser::STATEMENT_PARSERS[$arrayKey]) && Parser::STATEMENT_PARSERS[$arrayKey] !== '') {
                         $list->idx++; // Ignore the current token
                         $nextToken = $list->getNext();
 
                         if ($token->value === 'SET' && $nextToken !== null && $nextToken->value === '(') {
                             // To avoid adding the tokens between the SET() parentheses to the unknown tokens
-                            $list->getNextOfTypeAndValue(Token::TYPE_OPERATOR, ')');
+                            $list->getNextOfTypeAndValue(TokenType::Operator, ')');
                         } elseif ($token->value === 'SET' && $nextToken !== null && $nextToken->value === 'DEFAULT') {
                             // to avoid adding the `DEFAULT` token to the unknown tokens.
                             ++$list->idx;
@@ -438,12 +439,12 @@ public static function parse(Parser $parser, TokensList $list, array $options =
                     $list->idx++; // Ignore the current token
                     $nextToken = $list->getNext();
                     if (
-                        ($token->type === Token::TYPE_KEYWORD)
+                        ($token->type === TokenType::Keyword)
                         && (($token->keyword === 'PARTITION BY')
                         || ($token->keyword === 'PARTITION' && $nextToken && $nextToken->value !== '('))
                     ) {
                         $partitionState = 1;
-                    } elseif (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'PARTITION')) {
+                    } elseif (($token->type === TokenType::Keyword) && ($token->keyword === 'PARTITION')) {
                         $partitionState = 2;
                     }
 
@@ -466,15 +467,15 @@ public static function parse(Parser $parser, TokensList $list, array $options =
                     }
 
                     if (
-                        $token->type === Token::TYPE_OPERATOR
+                        $token->type === TokenType::Operator
                         && $token->value === '('
                         && $nextToken
                         && $nextToken->keyword === 'PARTITION'
                     ) {
                         $partitionState = 2;
                         --$list->idx; // Current idx is on "(". We need a step back for ArrayObj::parse incoming.
                     } else {
-                        $ret->field .= $token->type === Token::TYPE_WHITESPACE ? ' ' : $token->token;
+                        $ret->field .= $token->type === TokenType::Whitespace ? ' ' : $token->token;
                     }
                 } elseif ($partitionState === 2) {
                     $ret->partitions = ArrayObj::parse(
@@ -552,7 +553,7 @@ private static function checkIfColumnDefinitionKeyword($tokenValue): bool
      */
     private static function checkIfTokenQuotedSymbol($token): bool
     {
-        return $token->type === Token::TYPE_SYMBOL && $token->flags === Token::FLAG_SYMBOL_BACKTICK;
+        return $token->type === TokenType::Symbol && $token->flags === Token::FLAG_SYMBOL_BACKTICK;
     }
 
     public function __toString(): string

diff --git a/src/Components/Array2d.php b/src/Components/Array2d.php
@@ -8,6 +8,7 @@
 use PhpMyAdmin\SqlParser\Parser;
 use PhpMyAdmin\SqlParser\Token;
 use PhpMyAdmin\SqlParser\TokensList;
+use PhpMyAdmin\SqlParser\TokenType;
 use PhpMyAdmin\SqlParser\Translator;
 use RuntimeException;
 
@@ -58,17 +59,17 @@ public static function parse(Parser $parser, TokensList $list, array $options =
             $token = $list->tokens[$list->idx];
 
             // End of statement.
-            if ($token->type === Token::TYPE_DELIMITER) {
+            if ($token->type === TokenType::Delimiter) {
                 break;
             }
 
             // Skipping whitespaces and comments.
-            if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
+            if (($token->type === TokenType::Whitespace) || ($token->type === TokenType::Comment)) {
                 continue;
             }
 
             // No keyword is expected.
-            if (($token->type === Token::TYPE_KEYWORD) && ($token->flags & Token::FLAG_KEYWORD_RESERVED)) {
+            if (($token->type === TokenType::Keyword) && ($token->flags & Token::FLAG_KEYWORD_RESERVED)) {
                 break;
             }
 

diff --git a/src/Components/ArrayObj.php b/src/Components/ArrayObj.php
@@ -6,8 +6,8 @@
 
 use PhpMyAdmin\SqlParser\Component;
 use PhpMyAdmin\SqlParser\Parser;
-use PhpMyAdmin\SqlParser\Token;
 use PhpMyAdmin\SqlParser\TokensList;
+use PhpMyAdmin\SqlParser\TokenType;
 
 use function implode;
 use function strlen;
@@ -88,7 +88,7 @@ public static function parse(Parser $parser, TokensList $list, array $options =
             $token = $list->tokens[$list->idx];
 
             // End of statement.
-            if ($token->type === Token::TYPE_DELIMITER) {
+            if ($token->type === TokenType::Delimiter) {
                 if ($brackets > 0) {
                     $parser->error('A closing bracket was expected.', $token);
                 }
@@ -97,18 +97,18 @@ public static function parse(Parser $parser, TokensList $list, array $options =
             }
 
             // Skipping whitespaces and comments.
-            if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
+            if (($token->type === TokenType::Whitespace) || ($token->type === TokenType::Comment)) {
                 $lastRaw .= $token->token;
                 $lastValue = trim($lastValue) . ' ';
                 continue;
             }
 
-            if (($brackets === 0) && (($token->type !== Token::TYPE_OPERATOR) || ($token->value !== '('))) {
+            if (($brackets === 0) && (($token->type !== TokenType::Operator) || ($token->value !== '('))) {
                 $parser->error('An opening bracket was expected.', $token);
                 break;
             }
 
-            if ($token->type === Token::TYPE_OPERATOR) {
+            if ($token->type === TokenType::Operator) {
                 if ($token->value === '(') {
                     if (++$brackets === 1) { // 1 is the base level.
                         continue;

diff --git a/src/Components/CaseExpression.php b/src/Components/CaseExpression.php
@@ -9,6 +9,7 @@
 use PhpMyAdmin\SqlParser\Parser;
 use PhpMyAdmin\SqlParser\Token;
 use PhpMyAdmin\SqlParser\TokensList;
+use PhpMyAdmin\SqlParser\TokenType;
 
 use function count;
 
@@ -98,12 +99,12 @@ public static function parse(Parser $parser, TokensList $list, array $options =
             $token = $list->tokens[$list->idx];
 
             // Skipping whitespaces and comments.
-            if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
+            if (($token->type === TokenType::Whitespace) || ($token->type === TokenType::Comment)) {
                 continue;
             }
 
             if ($state === 0) {
-                if ($token->type === Token::TYPE_KEYWORD) {
+                if ($token->type === TokenType::Keyword) {
                     switch ($token->keyword) {
                         case 'WHEN':
                             ++$list->idx; // Skip 'WHEN'
@@ -132,7 +133,7 @@ public static function parse(Parser $parser, TokensList $list, array $options =
                 }
             } elseif ($state === 1) {
                 if ($type === 0) {
-                    if ($token->type === Token::TYPE_KEYWORD) {
+                    if ($token->type === TokenType::Keyword) {
                         switch ($token->keyword) {
                             case 'WHEN':
                                 ++$list->idx; // Skip 'WHEN'
@@ -154,23 +155,23 @@ public static function parse(Parser $parser, TokensList $list, array $options =
                                 break 2;
                         }
                     }
-                } elseif ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'THEN') {
+                } elseif ($token->type === TokenType::Keyword && $token->keyword === 'THEN') {
                     ++$list->idx; // Skip 'THEN'
                     $newResult = Expression::parse($parser, $list);
                     $state = 0;
                     $ret->results[] = $newResult;
-                } elseif ($token->type === Token::TYPE_KEYWORD) {
+                } elseif ($token->type === TokenType::Keyword) {
                     $parser->error('Unexpected keyword.', $token);
                     break;
                 }
             } elseif ($state === 2) {
                 if ($type === 0) {
-                    if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'THEN') {
+                    if ($token->type === TokenType::Keyword && $token->keyword === 'THEN') {
                         ++$list->idx; // Skip 'THEN'
                         $newResult = Expression::parse($parser, $list);
                         $ret->results[] = $newResult;
                         $state = 1;
-                    } elseif ($token->type === Token::TYPE_KEYWORD) {
+                    } elseif ($token->type === TokenType::Keyword) {
                         $parser->error('Unexpected keyword.', $token);
                         break;
                     }
@@ -187,17 +188,17 @@ public static function parse(Parser $parser, TokensList $list, array $options =
                 $token = $list->tokens[$list->idx];
 
                 // End of statement.
-                if ($token->type === Token::TYPE_DELIMITER) {
+                if ($token->type === TokenType::Delimiter) {
                     break;
                 }
 
                 // Skipping whitespaces and comments.
-                if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
+                if (($token->type === TokenType::Whitespace) || ($token->type === TokenType::Comment)) {
                     continue;
                 }
 
                 // Handle optional AS keyword before alias
-                if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'AS') {
+                if ($token->type === TokenType::Keyword && $token->keyword === 'AS') {
                     if ($asFound || ! empty($ret->alias)) {
                         $parser->error('Potential duplicate alias of CASE expression.', $token);
                         break;
@@ -209,7 +210,7 @@ public static function parse(Parser $parser, TokensList $list, array $options =
 
                 if (
                     $asFound
-                    && $token->type === Token::TYPE_KEYWORD
+                    && $token->type === TokenType::Keyword
                     && ($token->flags & Token::FLAG_KEYWORD_RESERVED || $token->flags & Token::FLAG_KEYWORD_FUNCTION)
                 ) {
                     $parser->error('An alias expected after AS but got ' . $token->value, $token);
@@ -219,9 +220,9 @@ public static function parse(Parser $parser, TokensList $list, array $options =
 
                 if (
                     $asFound
-                    || $token->type === Token::TYPE_STRING
-                    || ($token->type === Token::TYPE_SYMBOL && ! $token->flags & Token::FLAG_SYMBOL_VARIABLE)
-                    || $token->type === Token::TYPE_NONE
+                    || $token->type === TokenType::String
+                    || ($token->type === TokenType::Symbol && ! $token->flags & Token::FLAG_SYMBOL_VARIABLE)
+                    || $token->type === TokenType::None
                 ) {
                     // An alias is expected (the keyword `AS` was previously found).
                     if (! empty($ret->alias)) {

diff --git a/src/Components/Condition.php b/src/Components/Condition.php
@@ -8,6 +8,7 @@
 use PhpMyAdmin\SqlParser\Parser;
 use PhpMyAdmin\SqlParser\Token;
 use PhpMyAdmin\SqlParser\TokensList;
+use PhpMyAdmin\SqlParser\TokenType;
 
 use function implode;
 use function in_array;
@@ -122,18 +123,18 @@ public static function parse(Parser $parser, TokensList $list, array $options =
             $token = $list->tokens[$list->idx];
 
             // End of statement.
-            if ($token->type === Token::TYPE_DELIMITER) {
+            if ($token->type === TokenType::Delimiter) {
                 break;
             }
 
             // Skipping whitespaces and comments.
-            if ($token->type === Token::TYPE_COMMENT) {
+            if ($token->type === TokenType::Comment) {
                 continue;
             }
 
             // Replacing all whitespaces (new lines, tabs, etc.) with a single
             // space character.
-            if ($token->type === Token::TYPE_WHITESPACE) {
+            if ($token->type === TokenType::Whitespace) {
                 $expr->expr .= ' ';
                 continue;
             }
@@ -162,7 +163,7 @@ public static function parse(Parser $parser, TokensList $list, array $options =
             }
 
             if (
-                ($token->type === Token::TYPE_KEYWORD)
+                ($token->type === TokenType::Keyword)
                 && ($token->flags & Token::FLAG_KEYWORD_RESERVED)
                 && ! ($token->flags & Token::FLAG_KEYWORD_FUNCTION)
             ) {
@@ -175,7 +176,7 @@ public static function parse(Parser $parser, TokensList $list, array $options =
                 }
             }
 
-            if ($token->type === Token::TYPE_OPERATOR) {
+            if ($token->type === TokenType::Operator) {
                 if ($token->value === '(') {
                     ++$brackets;
                 } elseif ($token->value === ')') {
@@ -189,11 +190,11 @@ public static function parse(Parser $parser, TokensList $list, array $options =
 
             $expr->expr .= $token->token;
             if (
-                ($token->type !== Token::TYPE_NONE)
-                && (($token->type !== Token::TYPE_KEYWORD)
+                ($token->type !== TokenType::None)
+                && (($token->type !== TokenType::Keyword)
                 || ($token->flags & Token::FLAG_KEYWORD_RESERVED))
-                && ($token->type !== Token::TYPE_STRING)
-                && ($token->type !== Token::TYPE_SYMBOL)
+                && ($token->type !== TokenType::String)
+                && ($token->type !== TokenType::Symbol)
             ) {
                 continue;
             }