@appthreat/atom 1.8.1 → 1.8.2

package/plugins/nikic/php-parser/lib/PhpParser/ConstExprEvaluator.php

@@ -1,12 +1,11 @@
-<?php declare(strict_types=1);
+<?php
 
 namespace PhpParser;
 
+use function array_merge;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Scalar;
 
-use function array_merge;
-
 /**
  * Evaluates constant expressions.
  *
@@ -26,8 +25,8 @@ use function array_merge;
  * point to string conversions are affected by the precision ini setting. Secondly, they are also
  * affected by the LC_NUMERIC locale.
  */
-class ConstExprEvaluator {
-    /** @var callable|null */
+class ConstExprEvaluator
+{
     private $fallbackEvaluator;
 
     /**
@@ -38,8 +37,8 @@ class ConstExprEvaluator {
      *
      * @param callable|null $fallbackEvaluator To call if subexpression cannot be evaluated
      */
-    public function __construct(?callable $fallbackEvaluator = null) {
-        $this->fallbackEvaluator = $fallbackEvaluator ?? function (Expr $expr) {
+    public function __construct(callable $fallbackEvaluator = null) {
+        $this->fallbackEvaluator = $fallbackEvaluator ?? function(Expr $expr) {
             throw new ConstExprEvaluationException(
                 "Expression of type {$expr->getType()} cannot be evaluated"
             );
@@ -64,7 +63,7 @@ class ConstExprEvaluator {
      * @throws ConstExprEvaluationException if the expression cannot be evaluated or an error occurred
      */
     public function evaluateSilently(Expr $expr) {
-        set_error_handler(function ($num, $str, $file, $line) {
+        set_error_handler(function($num, $str, $file, $line) {
             throw new \ErrorException($str, 0, $num, $file, $line);
         });
 
@@ -102,10 +101,9 @@ class ConstExprEvaluator {
         return $this->evaluate($expr);
     }
 
-    /** @return mixed */
     private function evaluate(Expr $expr) {
-        if ($expr instanceof Scalar\Int_
-            || $expr instanceof Scalar\Float_
+        if ($expr instanceof Scalar\LNumber
+            || $expr instanceof Scalar\DNumber
             || $expr instanceof Scalar\String_
         ) {
             return $expr->value;
@@ -148,7 +146,7 @@ class ConstExprEvaluator {
         return ($this->fallbackEvaluator)($expr);
     }
 
-    private function evaluateArray(Expr\Array_ $expr): array {
+    private function evaluateArray(Expr\Array_ $expr) {
         $array = [];
         foreach ($expr->items as $item) {
             if (null !== $item->key) {
@@ -162,7 +160,6 @@ class ConstExprEvaluator {
         return $array;
     }
 
-    /** @return mixed */
     private function evaluateTernary(Expr\Ternary $expr) {
         if (null === $expr->if) {
             return $this->evaluate($expr->cond) ?: $this->evaluate($expr->else);
@@ -173,7 +170,6 @@ class ConstExprEvaluator {
             : $this->evaluate($expr->else);
     }
 
-    /** @return mixed */
     private function evaluateBinaryOp(Expr\BinaryOp $expr) {
         if ($expr instanceof Expr\BinaryOp\Coalesce
             && $expr->left instanceof Expr\ArrayDimFetch
@@ -220,7 +216,6 @@ class ConstExprEvaluator {
         throw new \Exception('Should not happen');
     }
 
-    /** @return mixed */
     private function evaluateConstFetch(Expr\ConstFetch $expr) {
         $name = $expr->name->toLowerString();
         switch ($name) {

package/plugins/nikic/php-parser/lib/PhpParser/Error.php

@@ -2,20 +2,25 @@
 
 namespace PhpParser;
 
-class Error extends \RuntimeException {
-    protected string $rawMessage;
-    /** @var array<string, mixed> */
-    protected array $attributes;
+class Error extends \RuntimeException
+{
+    protected $rawMessage;
+    protected $attributes;
 
     /**
      * Creates an Exception signifying a parse error.
      *
-     * @param string $message Error message
-     * @param array<string, mixed> $attributes Attributes of node/token where error occurred
+     * @param string    $message    Error message
+     * @param array|int $attributes Attributes of node/token where error occurred
+     *                              (or start line of error -- deprecated)
      */
-    public function __construct(string $message, array $attributes = []) {
+    public function __construct(string $message, $attributes = []) {
         $this->rawMessage = $message;
-        $this->attributes = $attributes;
+        if (is_array($attributes)) {
+            $this->attributes = $attributes;
+        } else {
+            $this->attributes = ['startLine' => $attributes];
+        }
         $this->updateMessage();
     }
 
@@ -24,7 +29,7 @@ class Error extends \RuntimeException {
      *
      * @return string Error message
      */
-    public function getRawMessage(): string {
+    public function getRawMessage() : string {
         return $this->rawMessage;
     }
 
@@ -33,7 +38,7 @@ class Error extends \RuntimeException {
      *
      * @return int Error start line
      */
-    public function getStartLine(): int {
+    public function getStartLine() : int {
         return $this->attributes['startLine'] ?? -1;
     }
 
@@ -42,25 +47,25 @@ class Error extends \RuntimeException {
      *
      * @return int Error end line
      */
-    public function getEndLine(): int {
+    public function getEndLine() : int {
         return $this->attributes['endLine'] ?? -1;
     }
 
     /**
      * Gets the attributes of the node/token the error occurred at.
      *
-     * @return array<string, mixed>
+     * @return array
      */
-    public function getAttributes(): array {
+    public function getAttributes() : array {
         return $this->attributes;
     }
 
     /**
      * Sets the attributes of the node/token the error occurred at.
      *
-     * @param array<string, mixed> $attributes
+     * @param array $attributes
      */
-    public function setAttributes(array $attributes): void {
+    public function setAttributes(array $attributes) {
         $this->attributes = $attributes;
         $this->updateMessage();
     }
@@ -70,7 +75,7 @@ class Error extends \RuntimeException {
      *
      * @param string $message Error message
      */
-    public function setRawMessage(string $message): void {
+    public function setRawMessage(string $message) {
         $this->rawMessage = $message;
         $this->updateMessage();
     }
@@ -80,7 +85,7 @@ class Error extends \RuntimeException {
      *
      * @param int $line Error start line
      */
-    public function setStartLine(int $line): void {
+    public function setStartLine(int $line) {
         $this->attributes['startLine'] = $line;
         $this->updateMessage();
     }
@@ -89,8 +94,10 @@ class Error extends \RuntimeException {
      * Returns whether the error has start and end column information.
      *
      * For column information enable the startFilePos and endFilePos in the lexer options.
+     *
+     * @return bool
      */
-    public function hasColumnInfo(): bool {
+    public function hasColumnInfo() : bool {
         return isset($this->attributes['startFilePos'], $this->attributes['endFilePos']);
     }
 
@@ -98,8 +105,9 @@ class Error extends \RuntimeException {
      * Gets the start column (1-based) into the line where the error started.
      *
      * @param string $code Source code of the file
+     * @return int
      */
-    public function getStartColumn(string $code): int {
+    public function getStartColumn(string $code) : int {
         if (!$this->hasColumnInfo()) {
             throw new \RuntimeException('Error does not have column information');
         }
@@ -111,8 +119,9 @@ class Error extends \RuntimeException {
      * Gets the end column (1-based) into the line where the error ended.
      *
      * @param string $code Source code of the file
+     * @return int
      */
-    public function getEndColumn(string $code): int {
+    public function getEndColumn(string $code) : int {
         if (!$this->hasColumnInfo()) {
             throw new \RuntimeException('Error does not have column information');
         }
@@ -127,7 +136,7 @@ class Error extends \RuntimeException {
      *
      * @return string Formatted message
      */
-    public function getMessageWithColumnInfo(string $code): string {
+    public function getMessageWithColumnInfo(string $code) : string {
         return sprintf(
             '%s from %d:%d to %d:%d', $this->getRawMessage(),
             $this->getStartLine(), $this->getStartColumn($code),
@@ -139,11 +148,11 @@ class Error extends \RuntimeException {
      * Converts a file offset into a column.
      *
      * @param string $code Source code that $pos indexes into
-     * @param int $pos 0-based position in $code
+     * @param int    $pos  0-based position in $code
      *
      * @return int 1-based column (relative to start of line)
      */
-    private function toColumn(string $code, int $pos): int {
+    private function toColumn(string $code, int $pos) : int {
         if ($pos > strlen($code)) {
             throw new \RuntimeException('Invalid position information');
         }
@@ -159,7 +168,7 @@ class Error extends \RuntimeException {
     /**
      * Updates the exception message after a change to rawMessage or rawLine.
      */
-    protected function updateMessage(): void {
+    protected function updateMessage() {
         $this->message = $this->rawMessage;
 
         if (-1 === $this->getStartLine()) {

package/plugins/nikic/php-parser/lib/PhpParser/ErrorHandler/Collecting.php

@@ -10,11 +10,12 @@ use PhpParser\ErrorHandler;
  *
  * This allows graceful handling of errors.
  */
-class Collecting implements ErrorHandler {
+class Collecting implements ErrorHandler
+{
     /** @var Error[] Collected errors */
-    private array $errors = [];
+    private $errors = [];
 
-    public function handleError(Error $error): void {
+    public function handleError(Error $error) {
         $this->errors[] = $error;
     }
 
@@ -23,21 +24,23 @@ class Collecting implements ErrorHandler {
      *
      * @return Error[]
      */
-    public function getErrors(): array {
+    public function getErrors() : array {
         return $this->errors;
     }
 
     /**
      * Check whether there are any errors.
+     *
+     * @return bool
      */
-    public function hasErrors(): bool {
+    public function hasErrors() : bool {
         return !empty($this->errors);
     }
 
     /**
      * Reset/clear collected errors.
      */
-    public function clearErrors(): void {
+    public function clearErrors() {
         $this->errors = [];
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/ErrorHandler/Throwing.php

@@ -10,8 +10,9 @@ use PhpParser\ErrorHandler;
  *
  * This is the default strategy used by all components.
  */
-class Throwing implements ErrorHandler {
-    public function handleError(Error $error): void {
+class Throwing implements ErrorHandler
+{
+    public function handleError(Error $error) {
         throw $error;
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/ErrorHandler.php

@@ -2,11 +2,12 @@
 
 namespace PhpParser;
 
-interface ErrorHandler {
+interface ErrorHandler
+{
     /**
      * Handle an error generated during lexing, parsing or some other operation.
      *
      * @param Error $error The error that needs to be handled
      */
-    public function handleError(Error $error): void;
+    public function handleError(Error $error);
 }

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

@@ -5,24 +5,20 @@ namespace PhpParser\Internal;
 /**
  * @internal
  */
-class DiffElem {
-    public const TYPE_KEEP = 0;
-    public const TYPE_REMOVE = 1;
-    public const TYPE_ADD = 2;
-    public const TYPE_REPLACE = 3;
+class DiffElem
+{
+    const TYPE_KEEP = 0;
+    const TYPE_REMOVE = 1;
+    const TYPE_ADD = 2;
+    const TYPE_REPLACE = 3;
 
     /** @var int One of the TYPE_* constants */
-    public int $type;
+    public $type;
     /** @var mixed Is null for add operations */
     public $old;
     /** @var mixed Is null for remove operations */
     public $new;
 
-    /**
-     * @param int $type One of the TYPE_* constants
-     * @param mixed $old Is null for add operations
-     * @param mixed $new Is null for remove operations
-     */
     public function __construct(int $type, $old, $new) {
         $this->type = $type;
         $this->old = $old;

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

@@ -8,17 +8,16 @@ 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 {
-    /** @var callable(T, T): bool */
+class Differ
+{
     private $isEqual;
 
     /**
      * Create differ over the given equality relation.
      *
-     * @param callable(T, T): bool $isEqual Equality relation
+     * @param callable $isEqual Equality relation with signature function($a, $b) : bool
      */
     public function __construct(callable $isEqual) {
         $this->isEqual = $isEqual;
@@ -27,14 +26,12 @@ class Differ {
     /**
      * Calculate diff (edit script) from $old to $new.
      *
-     * @param T[] $old Original array
-     * @param T[] $new New array
+     * @param array $old Original array
+     * @param array $new New array
      *
      * @return DiffElem[] Diff (edit script)
      */
-    public function diff(array $old, array $new): array {
-        $old = \array_values($old);
-        $new = \array_values($new);
+    public function diff(array $old, array $new) {
         list($trace, $x, $y) = $this->calculateTrace($old, $new);
         return $this->extractDiff($trace, $x, $y, $old, $new);
     }
@@ -45,37 +42,32 @@ 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 T[] $old Original array
-     * @param T[] $new New array
+     * @param array $old Original array
+     * @param array $new New array
      *
      * @return DiffElem[] Diff (edit script), including replace operations
      */
-    public function diffWithReplacements(array $old, array $new): array {
+    public function diffWithReplacements(array $old, array $new) {
         return $this->coalesceReplacements($this->diff($old, $new));
     }
 
-    /**
-     * @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);
+    private function calculateTrace(array $a, array $b) {
+        $n = \count($a);
+        $m = \count($b);
         $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)($old[$x], $new[$y])) {
+                while ($x < $n && $y < $m && ($this->isEqual)($a[$x], $b[$y])) {
                     $x++;
                     $y++;
                 }
@@ -89,19 +81,13 @@ class Differ {
         throw new \Exception('Should not happen');
     }
 
-    /**
-     * @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 {
+    private function extractDiff(array $trace, int $x, int $y, array $a, array $b) {
         $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;
@@ -111,7 +97,7 @@ class Differ {
             $prevY = $prevX - $prevK;
 
             while ($x > $prevX && $y > $prevY) {
-                $result[] = new DiffElem(DiffElem::TYPE_KEEP, $old[$x - 1], $new[$y - 1]);
+                $result[] = new DiffElem(DiffElem::TYPE_KEEP, $a[$x-1], $b[$y-1]);
                 $x--;
                 $y--;
             }
@@ -121,12 +107,12 @@ class Differ {
             }
 
             while ($x > $prevX) {
-                $result[] = new DiffElem(DiffElem::TYPE_REMOVE, $old[$x - 1], null);
+                $result[] = new DiffElem(DiffElem::TYPE_REMOVE, $a[$x-1], null);
                 $x--;
             }
 
             while ($y > $prevY) {
-                $result[] = new DiffElem(DiffElem::TYPE_ADD, null, $new[$y - 1]);
+                $result[] = new DiffElem(DiffElem::TYPE_ADD, null, $b[$y-1]);
                 $y--;
             }
         }
@@ -139,7 +125,7 @@ class Differ {
      * @param DiffElem[] $diff
      * @return DiffElem[]
      */
-    private function coalesceReplacements(array $diff): array {
+    private function coalesceReplacements(array $diff) {
         $newDiff = [];
         $c = \count($diff);
         for ($i = 0; $i < $c; $i++) {

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

@@ -15,30 +15,23 @@ use PhpParser\Node\Expr;
  *
  * @internal
  */
-class PrintableNewAnonClassNode extends Expr {
+class PrintableNewAnonClassNode extends Expr
+{
     /** @var Node\AttributeGroup[] PHP attribute groups */
-    public array $attrGroups;
+    public $attrGroups;
     /** @var int Modifiers */
-    public int $flags;
-    /** @var (Node\Arg|Node\VariadicPlaceholder)[] Arguments */
-    public array $args;
+    public $flags;
+    /** @var Node\Arg[] Arguments */
+    public $args;
     /** @var null|Node\Name Name of extended class */
-    public ?Node\Name $extends;
+    public $extends;
     /** @var Node\Name[] Names of implemented interfaces */
-    public array $implements;
+    public $implements;
     /** @var Node\Stmt[] Statements */
-    public array $stmts;
+    public $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, array $implements,
+        array $attrGroups, int $flags, array $args, Node\Name $extends = null, array $implements,
         array $stmts, array $attributes
     ) {
         parent::__construct($attributes);
@@ -50,7 +43,7 @@ class PrintableNewAnonClassNode extends Expr {
         $this->stmts = $stmts;
     }
 
-    public static function fromNewNode(Expr\New_ $newNode): self {
+    public static function fromNewNode(Expr\New_ $newNode) {
         $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
@@ -61,11 +54,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'];
     }
 }