@appthreat/atom-parsetools 1.0.3 → 1.0.5

package/plugins/nikic/php-parser/lib/PhpParser/Internal/Differ.php

@@ -8,16 +8,17 @@ namespace PhpParser\Internal;
  * Myers, Eugene W. "An O (ND) difference algorithm and its variations."
  * Algorithmica 1.1 (1986): 251-266.
  *
+ * @template T
  * @internal
  */
-class Differ
-{
+class Differ {
+    /** @var callable(T, T): bool */
     private $isEqual;
 
     /**
      * Create differ over the given equality relation.
      *
-     * @param callable $isEqual Equality relation with signature function($a, $b) : bool
+     * @param callable(T, T): bool $isEqual Equality relation
      */
     public function __construct(callable $isEqual) {
         $this->isEqual = $isEqual;
@@ -26,12 +27,14 @@ class Differ
     /**
      * Calculate diff (edit script) from $old to $new.
      *
-     * @param array $old Original array
-     * @param array $new New array
+     * @param T[] $old Original array
+     * @param T[] $new New array
      *
      * @return DiffElem[] Diff (edit script)
      */
-    public function diff(array $old, array $new) {
+    public function diff(array $old, array $new): array {
+        $old = \array_values($old);
+        $new = \array_values($new);
         list($trace, $x, $y) = $this->calculateTrace($old, $new);
         return $this->extractDiff($trace, $x, $y, $old, $new);
     }
@@ -42,32 +45,37 @@ class Differ
      * If a sequence of remove operations is followed by the same number of add operations, these
      * will be coalesced into replace operations.
      *
-     * @param array $old Original array
-     * @param array $new New array
+     * @param T[] $old Original array
+     * @param T[] $new New array
      *
      * @return DiffElem[] Diff (edit script), including replace operations
      */
-    public function diffWithReplacements(array $old, array $new) {
+    public function diffWithReplacements(array $old, array $new): array {
         return $this->coalesceReplacements($this->diff($old, $new));
     }
 
-    private function calculateTrace(array $a, array $b) {
-        $n = \count($a);
-        $m = \count($b);
+    /**
+     * @param T[] $old
+     * @param T[] $new
+     * @return array{array<int, array<int, int>>, int, int}
+     */
+    private function calculateTrace(array $old, array $new): array {
+        $n = \count($old);
+        $m = \count($new);
         $max = $n + $m;
         $v = [1 => 0];
         $trace = [];
         for ($d = 0; $d <= $max; $d++) {
             $trace[] = $v;
             for ($k = -$d; $k <= $d; $k += 2) {
-                if ($k === -$d || ($k !== $d && $v[$k-1] < $v[$k+1])) {
-                    $x = $v[$k+1];
+                if ($k === -$d || ($k !== $d && $v[$k - 1] < $v[$k + 1])) {
+                    $x = $v[$k + 1];
                 } else {
-                    $x = $v[$k-1] + 1;
+                    $x = $v[$k - 1] + 1;
                 }
 
                 $y = $x - $k;
-                while ($x < $n && $y < $m && ($this->isEqual)($a[$x], $b[$y])) {
+                while ($x < $n && $y < $m && ($this->isEqual)($old[$x], $new[$y])) {
                     $x++;
                     $y++;
                 }
@@ -81,13 +89,19 @@ class Differ
         throw new \Exception('Should not happen');
     }
 
-    private function extractDiff(array $trace, int $x, int $y, array $a, array $b) {
+    /**
+     * @param array<int, array<int, int>> $trace
+     * @param T[] $old
+     * @param T[] $new
+     * @return DiffElem[]
+     */
+    private function extractDiff(array $trace, int $x, int $y, array $old, array $new): array {
         $result = [];
         for ($d = \count($trace) - 1; $d >= 0; $d--) {
             $v = $trace[$d];
             $k = $x - $y;
 
-            if ($k === -$d || ($k !== $d && $v[$k-1] < $v[$k+1])) {
+            if ($k === -$d || ($k !== $d && $v[$k - 1] < $v[$k + 1])) {
                 $prevK = $k + 1;
             } else {
                 $prevK = $k - 1;
@@ -97,7 +111,7 @@ class Differ
             $prevY = $prevX - $prevK;
 
             while ($x > $prevX && $y > $prevY) {
-                $result[] = new DiffElem(DiffElem::TYPE_KEEP, $a[$x-1], $b[$y-1]);
+                $result[] = new DiffElem(DiffElem::TYPE_KEEP, $old[$x - 1], $new[$y - 1]);
                 $x--;
                 $y--;
             }
@@ -107,12 +121,12 @@ class Differ
             }
 
             while ($x > $prevX) {
-                $result[] = new DiffElem(DiffElem::TYPE_REMOVE, $a[$x-1], null);
+                $result[] = new DiffElem(DiffElem::TYPE_REMOVE, $old[$x - 1], null);
                 $x--;
             }
 
             while ($y > $prevY) {
-                $result[] = new DiffElem(DiffElem::TYPE_ADD, null, $b[$y-1]);
+                $result[] = new DiffElem(DiffElem::TYPE_ADD, null, $new[$y - 1]);
                 $y--;
             }
         }
@@ -125,7 +139,7 @@ class Differ
      * @param DiffElem[] $diff
      * @return DiffElem[]
      */
-    private function coalesceReplacements(array $diff) {
+    private function coalesceReplacements(array $diff): array {
         $newDiff = [];
         $c = \count($diff);
         for ($i = 0; $i < $c; $i++) {

package/plugins/nikic/php-parser/lib/PhpParser/Internal/PrintableNewAnonClassNode.php

@@ -15,23 +15,30 @@ use PhpParser\Node\Expr;
  *
  * @internal
  */
-class PrintableNewAnonClassNode extends Expr
-{
+class PrintableNewAnonClassNode extends Expr {
     /** @var Node\AttributeGroup[] PHP attribute groups */
-    public $attrGroups;
+    public array $attrGroups;
     /** @var int Modifiers */
-    public $flags;
-    /** @var Node\Arg[] Arguments */
-    public $args;
+    public int $flags;
+    /** @var (Node\Arg|Node\VariadicPlaceholder)[] Arguments */
+    public array $args;
     /** @var null|Node\Name Name of extended class */
-    public $extends;
+    public ?Node\Name $extends;
     /** @var Node\Name[] Names of implemented interfaces */
-    public $implements;
+    public array $implements;
     /** @var Node\Stmt[] Statements */
-    public $stmts;
+    public array $stmts;
 
+    /**
+     * @param Node\AttributeGroup[] $attrGroups PHP attribute groups
+     * @param (Node\Arg|Node\VariadicPlaceholder)[] $args Arguments
+     * @param Node\Name|null $extends Name of extended class
+     * @param Node\Name[] $implements Names of implemented interfaces
+     * @param Node\Stmt[] $stmts Statements
+     * @param array<string, mixed> $attributes Attributes
+     */
     public function __construct(
-        array $attrGroups, int $flags, array $args, Node\Name $extends = null, array $implements,
+        array $attrGroups, int $flags, array $args, ?Node\Name $extends, array $implements,
         array $stmts, array $attributes
     ) {
         parent::__construct($attributes);
@@ -43,7 +50,7 @@ class PrintableNewAnonClassNode extends Expr
         $this->stmts = $stmts;
     }
 
-    public static function fromNewNode(Expr\New_ $newNode) {
+    public static function fromNewNode(Expr\New_ $newNode): self {
         $class = $newNode->class;
         assert($class instanceof Node\Stmt\Class_);
         // We don't assert that $class->name is null here, to allow consumers to assign unique names
@@ -54,11 +61,11 @@ class PrintableNewAnonClassNode extends Expr
         );
     }
 
-    public function getType() : string {
+    public function getType(): string {
         return 'Expr_PrintableNewAnonClass';
     }
 
-    public function getSubNodeNames() : array {
+    public function getSubNodeNames(): array {
         return ['attrGroups', 'flags', 'args', 'extends', 'implements', 'stmts'];
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Internal/TokenPolyfill.php

@@ -0,0 +1,237 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Internal;
+
+if (\PHP_VERSION_ID >= 80000) {
+    class TokenPolyfill extends \PhpToken {
+    }
+    return;
+}
+
+/**
+ * This is a polyfill for the PhpToken class introduced in PHP 8.0. We do not actually polyfill
+ * PhpToken, because composer might end up picking a different polyfill implementation, which does
+ * not meet our requirements.
+ *
+ * @internal
+ */
+class TokenPolyfill {
+    /** @var int The ID of the token. Either a T_* constant of a character code < 256. */
+    public int $id;
+    /** @var string The textual content of the token. */
+    public string $text;
+    /** @var int The 1-based starting line of the token (or -1 if unknown). */
+    public int $line;
+    /** @var int The 0-based starting position of the token (or -1 if unknown). */
+    public int $pos;
+
+    /** @var array<int, bool> Tokens ignored by the PHP parser. */
+    private const IGNORABLE_TOKENS = [
+        \T_WHITESPACE => true,
+        \T_COMMENT => true,
+        \T_DOC_COMMENT => true,
+        \T_OPEN_TAG => true,
+    ];
+
+    /** @var array<int, bool> Tokens that may be part of a T_NAME_* identifier. */
+    private static array $identifierTokens;
+
+    /**
+     * Create a Token with the given ID and text, as well optional line and position information.
+     */
+    final public function __construct(int $id, string $text, int $line = -1, int $pos = -1) {
+        $this->id = $id;
+        $this->text = $text;
+        $this->line = $line;
+        $this->pos = $pos;
+    }
+
+    /**
+     * Get the name of the token. For single-char tokens this will be the token character.
+     * Otherwise it will be a T_* style name, or null if the token ID is unknown.
+     */
+    public function getTokenName(): ?string {
+        if ($this->id < 256) {
+            return \chr($this->id);
+        }
+
+        $name = token_name($this->id);
+        return $name === 'UNKNOWN' ? null : $name;
+    }
+
+    /**
+     * Check whether the token is of the given kind. The kind may be either an integer that matches
+     * the token ID, a string that matches the token text, or an array of integers/strings. In the
+     * latter case, the function returns true if any of the kinds in the array match.
+     *
+     * @param int|string|(int|string)[] $kind
+     */
+    public function is($kind): bool {
+        if (\is_int($kind)) {
+            return $this->id === $kind;
+        }
+        if (\is_string($kind)) {
+            return $this->text === $kind;
+        }
+        if (\is_array($kind)) {
+            foreach ($kind as $entry) {
+                if (\is_int($entry)) {
+                    if ($this->id === $entry) {
+                        return true;
+                    }
+                } elseif (\is_string($entry)) {
+                    if ($this->text === $entry) {
+                        return true;
+                    }
+                } else {
+                    throw new \TypeError(
+                        'Argument #1 ($kind) must only have elements of type string|int, ' .
+                        gettype($entry) . ' given');
+                }
+            }
+            return false;
+        }
+        throw new \TypeError(
+            'Argument #1 ($kind) must be of type string|int|array, ' .gettype($kind) . ' given');
+    }
+
+    /**
+     * Check whether this token would be ignored by the PHP parser. Returns true for T_WHITESPACE,
+     * T_COMMENT, T_DOC_COMMENT and T_OPEN_TAG, and false for everything else.
+     */
+    public function isIgnorable(): bool {
+        return isset(self::IGNORABLE_TOKENS[$this->id]);
+    }
+
+    /**
+     * Return the textual content of the token.
+     */
+    public function __toString(): string {
+        return $this->text;
+    }
+
+    /**
+     * Tokenize the given source code and return an array of tokens.
+     *
+     * This performs certain canonicalizations to match the PHP 8.0 token format:
+     *  * Bad characters are represented using T_BAD_CHARACTER rather than omitted.
+     *  * T_COMMENT does not include trailing newlines, instead the newline is part of a following
+     *    T_WHITESPACE token.
+     *  * Namespaced names are represented using T_NAME_* tokens.
+     *
+     * @return static[]
+     */
+    public static function tokenize(string $code, int $flags = 0): array {
+        self::init();
+
+        $tokens = [];
+        $line = 1;
+        $pos = 0;
+        $origTokens = \token_get_all($code, $flags);
+
+        $numTokens = \count($origTokens);
+        for ($i = 0; $i < $numTokens; $i++) {
+            $token = $origTokens[$i];
+            if (\is_string($token)) {
+                if (\strlen($token) === 2) {
+                    // b" and B" are tokenized as single-char tokens, even though they aren't.
+                    $tokens[] = new static(\ord('"'), $token, $line, $pos);
+                    $pos += 2;
+                } else {
+                    $tokens[] = new static(\ord($token), $token, $line, $pos);
+                    $pos++;
+                }
+            } else {
+                $id = $token[0];
+                $text = $token[1];
+
+                // Emulate PHP 8.0 comment format, which does not include trailing whitespace anymore.
+                if ($id === \T_COMMENT && \substr($text, 0, 2) !== '/*' &&
+                    \preg_match('/(\r\n|\n|\r)$/D', $text, $matches)
+                ) {
+                    $trailingNewline = $matches[0];
+                    $text = \substr($text, 0, -\strlen($trailingNewline));
+                    $tokens[] = new static($id, $text, $line, $pos);
+                    $pos += \strlen($text);
+
+                    if ($i + 1 < $numTokens && $origTokens[$i + 1][0] === \T_WHITESPACE) {
+                        // Move trailing newline into following T_WHITESPACE token, if it already exists.
+                        $origTokens[$i + 1][1] = $trailingNewline . $origTokens[$i + 1][1];
+                        $origTokens[$i + 1][2]--;
+                    } else {
+                        // Otherwise, we need to create a new T_WHITESPACE token.
+                        $tokens[] = new static(\T_WHITESPACE, $trailingNewline, $line, $pos);
+                        $line++;
+                        $pos += \strlen($trailingNewline);
+                    }
+                    continue;
+                }
+
+                // Emulate PHP 8.0 T_NAME_* tokens, by combining sequences of T_NS_SEPARATOR and
+                // T_STRING into a single token.
+                if (($id === \T_NS_SEPARATOR || isset(self::$identifierTokens[$id]))) {
+                    $newText = $text;
+                    $lastWasSeparator = $id === \T_NS_SEPARATOR;
+                    for ($j = $i + 1; $j < $numTokens; $j++) {
+                        if ($lastWasSeparator) {
+                            if (!isset(self::$identifierTokens[$origTokens[$j][0]])) {
+                                break;
+                            }
+                            $lastWasSeparator = false;
+                        } else {
+                            if ($origTokens[$j][0] !== \T_NS_SEPARATOR) {
+                                break;
+                            }
+                            $lastWasSeparator = true;
+                        }
+                        $newText .= $origTokens[$j][1];
+                    }
+                    if ($lastWasSeparator) {
+                        // Trailing separator is not part of the name.
+                        $j--;
+                        $newText = \substr($newText, 0, -1);
+                    }
+                    if ($j > $i + 1) {
+                        if ($id === \T_NS_SEPARATOR) {
+                            $id = \T_NAME_FULLY_QUALIFIED;
+                        } elseif ($id === \T_NAMESPACE) {
+                            $id = \T_NAME_RELATIVE;
+                        } else {
+                            $id = \T_NAME_QUALIFIED;
+                        }
+                        $tokens[] = new static($id, $newText, $line, $pos);
+                        $pos += \strlen($newText);
+                        $i = $j - 1;
+                        continue;
+                    }
+                }
+
+                $tokens[] = new static($id, $text, $line, $pos);
+                $line += \substr_count($text, "\n");
+                $pos += \strlen($text);
+            }
+        }
+        return $tokens;
+    }
+
+    /** Initialize private static state needed by tokenize(). */
+    private static function init(): void {
+        if (isset(self::$identifierTokens)) {
+            return;
+        }
+
+        // Based on semi_reserved production.
+        self::$identifierTokens = \array_fill_keys([
+            \T_STRING,
+            \T_STATIC, \T_ABSTRACT, \T_FINAL, \T_PRIVATE, \T_PROTECTED, \T_PUBLIC, \T_READONLY,
+            \T_INCLUDE, \T_INCLUDE_ONCE, \T_EVAL, \T_REQUIRE, \T_REQUIRE_ONCE, \T_LOGICAL_OR, \T_LOGICAL_XOR, \T_LOGICAL_AND,
+            \T_INSTANCEOF, \T_NEW, \T_CLONE, \T_EXIT, \T_IF, \T_ELSEIF, \T_ELSE, \T_ENDIF, \T_ECHO, \T_DO, \T_WHILE,
+            \T_ENDWHILE, \T_FOR, \T_ENDFOR, \T_FOREACH, \T_ENDFOREACH, \T_DECLARE, \T_ENDDECLARE, \T_AS, \T_TRY, \T_CATCH,
+            \T_FINALLY, \T_THROW, \T_USE, \T_INSTEADOF, \T_GLOBAL, \T_VAR, \T_UNSET, \T_ISSET, \T_EMPTY, \T_CONTINUE, \T_GOTO,
+            \T_FUNCTION, \T_CONST, \T_RETURN, \T_PRINT, \T_YIELD, \T_LIST, \T_SWITCH, \T_ENDSWITCH, \T_CASE, \T_DEFAULT,
+            \T_BREAK, \T_ARRAY, \T_CALLABLE, \T_EXTENDS, \T_IMPLEMENTS, \T_NAMESPACE, \T_TRAIT, \T_INTERFACE, \T_CLASS,
+            \T_CLASS_C, \T_TRAIT_C, \T_FUNC_C, \T_METHOD_C, \T_LINE, \T_FILE, \T_DIR, \T_NS_C, \T_HALT_COMPILER, \T_FN,
+            \T_MATCH,
+        ], true);
+    }
+}