nextcloud / fulltextsearch_elasticsearch

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ErrorSuppress.php

Indentation +18 added lines, -18 removed lines

@@ -6,25 +6,25 @@
 
 class ErrorSuppress extends Expr
 {
-    /** @var Expr Expression */
-    public $expr;
+	/** @var Expr Expression */
+	public $expr;
 
-    /**
-     * Constructs an error suppress node.
-     *
-     * @param Expr  $expr       Expression
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(Expr $expr, array $attributes = []) {
-        $this->attributes = $attributes;
-        $this->expr = $expr;
-    }
+	/**
+	 * Constructs an error suppress node.
+	 *
+	 * @param Expr  $expr       Expression
+	 * @param array $attributes Additional attributes
+	 */
+	public function __construct(Expr $expr, array $attributes = []) {
+		$this->attributes = $attributes;
+		$this->expr = $expr;
+	}
 
-    public function getSubNodeNames() : array {
-        return ['expr'];
-    }
+	public function getSubNodeNames() : array {
+		return ['expr'];
+	}
     
-    public function getType() : string {
-        return 'Expr_ErrorSuppress';
-    }
+	public function getType() : string {
+		return 'Expr_ErrorSuppress';
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -4,8 +4,7 @@
 
 use PhpParser\Node\Expr;
 
-class ErrorSuppress extends Expr
-{
+class ErrorSuppress extends Expr {
     /** @var Expr Expression */
     public $expr;
 

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafeMethodCall.php

Indentation +29 added lines, -29 removed lines

@@ -9,37 +9,37 @@
 
 class NullsafeMethodCall extends CallLike
 {
-    /** @var Expr Variable holding object */
-    public $var;
-    /** @var Identifier|Expr Method name */
-    public $name;
-    /** @var array<Arg|VariadicPlaceholder> Arguments */
-    public $args;
+	/** @var Expr Variable holding object */
+	public $var;
+	/** @var Identifier|Expr Method name */
+	public $name;
+	/** @var array<Arg|VariadicPlaceholder> Arguments */
+	public $args;
 
-    /**
-     * Constructs a nullsafe method call node.
-     *
-     * @param Expr                           $var        Variable holding object
-     * @param string|Identifier|Expr         $name       Method name
-     * @param array<Arg|VariadicPlaceholder> $args       Arguments
-     * @param array                          $attributes Additional attributes
-     */
-    public function __construct(Expr $var, $name, array $args = [], array $attributes = []) {
-        $this->attributes = $attributes;
-        $this->var = $var;
-        $this->name = \is_string($name) ? new Identifier($name) : $name;
-        $this->args = $args;
-    }
+	/**
+	 * Constructs a nullsafe method call node.
+	 *
+	 * @param Expr                           $var        Variable holding object
+	 * @param string|Identifier|Expr         $name       Method name
+	 * @param array<Arg|VariadicPlaceholder> $args       Arguments
+	 * @param array                          $attributes Additional attributes
+	 */
+	public function __construct(Expr $var, $name, array $args = [], array $attributes = []) {
+		$this->attributes = $attributes;
+		$this->var = $var;
+		$this->name = \is_string($name) ? new Identifier($name) : $name;
+		$this->args = $args;
+	}
 
-    public function getSubNodeNames() : array {
-        return ['var', 'name', 'args'];
-    }
+	public function getSubNodeNames() : array {
+		return ['var', 'name', 'args'];
+	}
     
-    public function getType() : string {
-        return 'Expr_NullsafeMethodCall';
-    }
+	public function getType() : string {
+		return 'Expr_NullsafeMethodCall';
+	}
 
-    public function getRawArgs(): array {
-        return $this->args;
-    }
+	public function getRawArgs(): array {
+		return $this->args;
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -7,8 +7,7 @@
 use PhpParser\Node\Identifier;
 use PhpParser\Node\VariadicPlaceholder;
 
-class NullsafeMethodCall extends CallLike
-{
+class NullsafeMethodCall extends CallLike {
     /** @var Expr Variable holding object */
     public $var;
     /** @var Identifier|Expr Method name */

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Isset_.php

Indentation +18 added lines, -18 removed lines

@@ -6,25 +6,25 @@
 
 class Isset_ extends Expr
 {
-    /** @var Expr[] Variables */
-    public $vars;
+	/** @var Expr[] Variables */
+	public $vars;
 
-    /**
-     * Constructs an array node.
-     *
-     * @param Expr[] $vars       Variables
-     * @param array  $attributes Additional attributes
-     */
-    public function __construct(array $vars, array $attributes = []) {
-        $this->attributes = $attributes;
-        $this->vars = $vars;
-    }
+	/**
+	 * Constructs an array node.
+	 *
+	 * @param Expr[] $vars       Variables
+	 * @param array  $attributes Additional attributes
+	 */
+	public function __construct(array $vars, array $attributes = []) {
+		$this->attributes = $attributes;
+		$this->vars = $vars;
+	}
 
-    public function getSubNodeNames() : array {
-        return ['vars'];
-    }
+	public function getSubNodeNames() : array {
+		return ['vars'];
+	}
     
-    public function getType() : string {
-        return 'Expr_Isset';
-    }
+	public function getType() : string {
+		return 'Expr_Isset';
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -4,8 +4,7 @@
 
 use PhpParser\Node\Expr;
 
-class Isset_ extends Expr
-{
+class Isset_ extends Expr {
     /** @var Expr[] Variables */
     public $vars;
 

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/Node/Identifier.php

Indentation +55 added lines, -55 removed lines

@@ -9,67 +9,67 @@
  */
 class Identifier extends NodeAbstract
 {
-    /** @var string Identifier as string */
-    public $name;
+	/** @var string Identifier as string */
+	public $name;
 
-    private static $specialClassNames = [
-        'self'   => true,
-        'parent' => true,
-        'static' => true,
-    ];
+	private static $specialClassNames = [
+		'self'   => true,
+		'parent' => true,
+		'static' => true,
+	];
 
-    /**
-     * Constructs an identifier node.
-     *
-     * @param string $name       Identifier as string
-     * @param array  $attributes Additional attributes
-     */
-    public function __construct(string $name, array $attributes = []) {
-        $this->attributes = $attributes;
-        $this->name = $name;
-    }
+	/**
+	 * Constructs an identifier node.
+	 *
+	 * @param string $name       Identifier as string
+	 * @param array  $attributes Additional attributes
+	 */
+	public function __construct(string $name, array $attributes = []) {
+		$this->attributes = $attributes;
+		$this->name = $name;
+	}
 
-    public function getSubNodeNames() : array {
-        return ['name'];
-    }
+	public function getSubNodeNames() : array {
+		return ['name'];
+	}
 
-    /**
-     * Get identifier as string.
-     *
-     * @return string Identifier as string.
-     */
-    public function toString() : string {
-        return $this->name;
-    }
+	/**
+	 * Get identifier as string.
+	 *
+	 * @return string Identifier as string.
+	 */
+	public function toString() : string {
+		return $this->name;
+	}
 
-    /**
-     * Get lowercased identifier as string.
-     *
-     * @return string Lowercased identifier as string
-     */
-    public function toLowerString() : string {
-        return strtolower($this->name);
-    }
+	/**
+	 * Get lowercased identifier as string.
+	 *
+	 * @return string Lowercased identifier as string
+	 */
+	public function toLowerString() : string {
+		return strtolower($this->name);
+	}
 
-    /**
-     * Checks whether the identifier is a special class name (self, parent or static).
-     *
-     * @return bool Whether identifier is a special class name
-     */
-    public function isSpecialClassName() : bool {
-        return isset(self::$specialClassNames[strtolower($this->name)]);
-    }
+	/**
+	 * Checks whether the identifier is a special class name (self, parent or static).
+	 *
+	 * @return bool Whether identifier is a special class name
+	 */
+	public function isSpecialClassName() : bool {
+		return isset(self::$specialClassNames[strtolower($this->name)]);
+	}
 
-    /**
-     * Get identifier as string.
-     *
-     * @return string Identifier as string
-     */
-    public function __toString() : string {
-        return $this->name;
-    }
+	/**
+	 * Get identifier as string.
+	 *
+	 * @return string Identifier as string
+	 */
+	public function __toString() : string {
+		return $this->name;
+	}
     
-    public function getType() : string {
-        return 'Identifier';
-    }
+	public function getType() : string {
+		return 'Identifier';
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -7,8 +7,7 @@
 /**
  * Represents a non-namespaced name. Namespaced names are represented using Name nodes.
  */
-class Identifier extends NodeAbstract
-{
+class Identifier extends NodeAbstract {
     /** @var string Identifier as string */
     public $name;
 

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/Node/Name/FullyQualified.php

Indentation +38 added lines, -38 removed lines

@@ -4,47 +4,47 @@
 
 class FullyQualified extends \PhpParser\Node\Name
 {
-    /**
-     * Checks whether the name is unqualified. (E.g. Name)
-     *
-     * @return bool Whether the name is unqualified
-     */
-    public function isUnqualified() : bool {
-        return false;
-    }
+	/**
+	 * Checks whether the name is unqualified. (E.g. Name)
+	 *
+	 * @return bool Whether the name is unqualified
+	 */
+	public function isUnqualified() : bool {
+		return false;
+	}
 
-    /**
-     * Checks whether the name is qualified. (E.g. Name\Name)
-     *
-     * @return bool Whether the name is qualified
-     */
-    public function isQualified() : bool {
-        return false;
-    }
+	/**
+	 * Checks whether the name is qualified. (E.g. Name\Name)
+	 *
+	 * @return bool Whether the name is qualified
+	 */
+	public function isQualified() : bool {
+		return false;
+	}
 
-    /**
-     * Checks whether the name is fully qualified. (E.g. \Name)
-     *
-     * @return bool Whether the name is fully qualified
-     */
-    public function isFullyQualified() : bool {
-        return true;
-    }
+	/**
+	 * Checks whether the name is fully qualified. (E.g. \Name)
+	 *
+	 * @return bool Whether the name is fully qualified
+	 */
+	public function isFullyQualified() : bool {
+		return true;
+	}
 
-    /**
-     * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
-     *
-     * @return bool Whether the name is relative
-     */
-    public function isRelative() : bool {
-        return false;
-    }
+	/**
+	 * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
+	 *
+	 * @return bool Whether the name is relative
+	 */
+	public function isRelative() : bool {
+		return false;
+	}
 
-    public function toCodeString() : string {
-        return '\\' . $this->toString();
-    }
+	public function toCodeString() : string {
+		return '\\' . $this->toString();
+	}
     
-    public function getType() : string {
-        return 'Name_FullyQualified';
-    }
+	public function getType() : string {
+		return 'Name_FullyQualified';
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -41,7 +41,7 @@
     }
 
     public function toCodeString() : string {
-        return '\\' . $this->toString();
+        return '\\'.$this->toString();
     }
     
     public function getType() : string {

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/Node/Name/Relative.php

Indentation +38 added lines, -38 removed lines

@@ -4,47 +4,47 @@
 
 class Relative extends \PhpParser\Node\Name
 {
-    /**
-     * Checks whether the name is unqualified. (E.g. Name)
-     *
-     * @return bool Whether the name is unqualified
-     */
-    public function isUnqualified() : bool {
-        return false;
-    }
+	/**
+	 * Checks whether the name is unqualified. (E.g. Name)
+	 *
+	 * @return bool Whether the name is unqualified
+	 */
+	public function isUnqualified() : bool {
+		return false;
+	}
 
-    /**
-     * Checks whether the name is qualified. (E.g. Name\Name)
-     *
-     * @return bool Whether the name is qualified
-     */
-    public function isQualified() : bool {
-        return false;
-    }
+	/**
+	 * Checks whether the name is qualified. (E.g. Name\Name)
+	 *
+	 * @return bool Whether the name is qualified
+	 */
+	public function isQualified() : bool {
+		return false;
+	}
 
-    /**
-     * Checks whether the name is fully qualified. (E.g. \Name)
-     *
-     * @return bool Whether the name is fully qualified
-     */
-    public function isFullyQualified() : bool {
-        return false;
-    }
+	/**
+	 * Checks whether the name is fully qualified. (E.g. \Name)
+	 *
+	 * @return bool Whether the name is fully qualified
+	 */
+	public function isFullyQualified() : bool {
+		return false;
+	}
 
-    /**
-     * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
-     *
-     * @return bool Whether the name is relative
-     */
-    public function isRelative() : bool {
-        return true;
-    }
+	/**
+	 * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
+	 *
+	 * @return bool Whether the name is relative
+	 */
+	public function isRelative() : bool {
+		return true;
+	}
 
-    public function toCodeString() : string {
-        return 'namespace\\' . $this->toString();
-    }
+	public function toCodeString() : string {
+		return 'namespace\\' . $this->toString();
+	}
     
-    public function getType() : string {
-        return 'Name_Relative';
-    }
+	public function getType() : string {
+		return 'Name_Relative';
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -41,7 +41,7 @@
     }
 
     public function toCodeString() : string {
-        return 'namespace\\' . $this->toString();
+        return 'namespace\\'.$this->toString();
     }
     
     public function getType() : string {

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/Node/AttributeGroup.php

Indentation +16 added lines, -16 removed lines

@@ -7,23 +7,23 @@
 
 class AttributeGroup extends NodeAbstract
 {
-    /** @var Attribute[] Attributes */
-    public $attrs;
+	/** @var Attribute[] Attributes */
+	public $attrs;
 
-    /**
-     * @param Attribute[] $attrs PHP attributes
-     * @param array $attributes Additional node attributes
-     */
-    public function __construct(array $attrs, array $attributes = []) {
-        $this->attributes = $attributes;
-        $this->attrs = $attrs;
-    }
+	/**
+	 * @param Attribute[] $attrs PHP attributes
+	 * @param array $attributes Additional node attributes
+	 */
+	public function __construct(array $attrs, array $attributes = []) {
+		$this->attributes = $attributes;
+		$this->attrs = $attrs;
+	}
 
-    public function getSubNodeNames() : array {
-        return ['attrs'];
-    }
+	public function getSubNodeNames() : array {
+		return ['attrs'];
+	}
 
-    public function getType() : string {
-        return 'AttributeGroup';
-    }
+	public function getType() : string {
+		return 'AttributeGroup';
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -5,8 +5,7 @@
 use PhpParser\Node;
 use PhpParser\NodeAbstract;
 
-class AttributeGroup extends NodeAbstract
-{
+class AttributeGroup extends NodeAbstract {
     /** @var Attribute[] Attributes */
     public $attrs;
 

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/ConstExprEvaluator.php

Indentation +199 added lines, -199 removed lines

@@ -27,203 +27,203 @@
  */
 class ConstExprEvaluator
 {
-    private $fallbackEvaluator;
-
-    /**
-     * Create a constant expression evaluator.
-     *
-     * The provided fallback evaluator is invoked whenever a subexpression cannot be evaluated. See
-     * class doc comment for more information.
-     *
-     * @param callable|null $fallbackEvaluator To call if subexpression cannot be evaluated
-     */
-    public function __construct(?callable $fallbackEvaluator = null) {
-        $this->fallbackEvaluator = $fallbackEvaluator ?? function(Expr $expr) {
-            throw new ConstExprEvaluationException(
-                "Expression of type {$expr->getType()} cannot be evaluated"
-            );
-        };
-    }
-
-    /**
-     * Silently evaluates a constant expression into a PHP value.
-     *
-     * Thrown Errors, warnings or notices will be converted into a ConstExprEvaluationException.
-     * The original source of the exception is available through getPrevious().
-     *
-     * If some part of the expression cannot be evaluated, the fallback evaluator passed to the
-     * constructor will be invoked. By default, if no fallback is provided, an exception of type
-     * ConstExprEvaluationException is thrown.
-     *
-     * See class doc comment for caveats and limitations.
-     *
-     * @param Expr $expr Constant expression to evaluate
-     * @return mixed Result of evaluation
-     *
-     * @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) {
-            throw new \ErrorException($str, 0, $num, $file, $line);
-        });
-
-        try {
-            return $this->evaluate($expr);
-        } catch (\Throwable $e) {
-            if (!$e instanceof ConstExprEvaluationException) {
-                $e = new ConstExprEvaluationException(
-                    "An error occurred during constant expression evaluation", 0, $e);
-            }
-            throw $e;
-        } finally {
-            restore_error_handler();
-        }
-    }
-
-    /**
-     * Directly evaluates a constant expression into a PHP value.
-     *
-     * May generate Error exceptions, warnings or notices. Use evaluateSilently() to convert these
-     * into a ConstExprEvaluationException.
-     *
-     * If some part of the expression cannot be evaluated, the fallback evaluator passed to the
-     * constructor will be invoked. By default, if no fallback is provided, an exception of type
-     * ConstExprEvaluationException is thrown.
-     *
-     * See class doc comment for caveats and limitations.
-     *
-     * @param Expr $expr Constant expression to evaluate
-     * @return mixed Result of evaluation
-     *
-     * @throws ConstExprEvaluationException if the expression cannot be evaluated
-     */
-    public function evaluateDirectly(Expr $expr) {
-        return $this->evaluate($expr);
-    }
-
-    private function evaluate(Expr $expr) {
-        if ($expr instanceof Scalar\LNumber
-            || $expr instanceof Scalar\DNumber
-            || $expr instanceof Scalar\String_
-        ) {
-            return $expr->value;
-        }
-
-        if ($expr instanceof Expr\Array_) {
-            return $this->evaluateArray($expr);
-        }
-
-        // Unary operators
-        if ($expr instanceof Expr\UnaryPlus) {
-            return +$this->evaluate($expr->expr);
-        }
-        if ($expr instanceof Expr\UnaryMinus) {
-            return -$this->evaluate($expr->expr);
-        }
-        if ($expr instanceof Expr\BooleanNot) {
-            return !$this->evaluate($expr->expr);
-        }
-        if ($expr instanceof Expr\BitwiseNot) {
-            return ~$this->evaluate($expr->expr);
-        }
-
-        if ($expr instanceof Expr\BinaryOp) {
-            return $this->evaluateBinaryOp($expr);
-        }
-
-        if ($expr instanceof Expr\Ternary) {
-            return $this->evaluateTernary($expr);
-        }
-
-        if ($expr instanceof Expr\ArrayDimFetch && null !== $expr->dim) {
-            return $this->evaluate($expr->var)[$this->evaluate($expr->dim)];
-        }
-
-        if ($expr instanceof Expr\ConstFetch) {
-            return $this->evaluateConstFetch($expr);
-        }
-
-        return ($this->fallbackEvaluator)($expr);
-    }
-
-    private function evaluateArray(Expr\Array_ $expr) {
-        $array = [];
-        foreach ($expr->items as $item) {
-            if (null !== $item->key) {
-                $array[$this->evaluate($item->key)] = $this->evaluate($item->value);
-            } elseif ($item->unpack) {
-                $array = array_merge($array, $this->evaluate($item->value));
-            } else {
-                $array[] = $this->evaluate($item->value);
-            }
-        }
-        return $array;
-    }
-
-    private function evaluateTernary(Expr\Ternary $expr) {
-        if (null === $expr->if) {
-            return $this->evaluate($expr->cond) ?: $this->evaluate($expr->else);
-        }
-
-        return $this->evaluate($expr->cond)
-            ? $this->evaluate($expr->if)
-            : $this->evaluate($expr->else);
-    }
-
-    private function evaluateBinaryOp(Expr\BinaryOp $expr) {
-        if ($expr instanceof Expr\BinaryOp\Coalesce
-            && $expr->left instanceof Expr\ArrayDimFetch
-        ) {
-            // This needs to be special cased to respect BP_VAR_IS fetch semantics
-            return $this->evaluate($expr->left->var)[$this->evaluate($expr->left->dim)]
-                ?? $this->evaluate($expr->right);
-        }
-
-        // The evaluate() calls are repeated in each branch, because some of the operators are
-        // short-circuiting and evaluating the RHS in advance may be illegal in that case
-        $l = $expr->left;
-        $r = $expr->right;
-        switch ($expr->getOperatorSigil()) {
-            case '&':   return $this->evaluate($l) &   $this->evaluate($r);
-            case '|':   return $this->evaluate($l) |   $this->evaluate($r);
-            case '^':   return $this->evaluate($l) ^   $this->evaluate($r);
-            case '&&':  return $this->evaluate($l) &&  $this->evaluate($r);
-            case '||':  return $this->evaluate($l) ||  $this->evaluate($r);
-            case '??':  return $this->evaluate($l) ??  $this->evaluate($r);
-            case '.':   return $this->evaluate($l) .   $this->evaluate($r);
-            case '/':   return $this->evaluate($l) /   $this->evaluate($r);
-            case '==':  return $this->evaluate($l) ==  $this->evaluate($r);
-            case '>':   return $this->evaluate($l) >   $this->evaluate($r);
-            case '>=':  return $this->evaluate($l) >=  $this->evaluate($r);
-            case '===': return $this->evaluate($l) === $this->evaluate($r);
-            case 'and': return $this->evaluate($l) and $this->evaluate($r);
-            case 'or':  return $this->evaluate($l) or  $this->evaluate($r);
-            case 'xor': return $this->evaluate($l) xor $this->evaluate($r);
-            case '-':   return $this->evaluate($l) -   $this->evaluate($r);
-            case '%':   return $this->evaluate($l) %   $this->evaluate($r);
-            case '*':   return $this->evaluate($l) *   $this->evaluate($r);
-            case '!=':  return $this->evaluate($l) !=  $this->evaluate($r);
-            case '!==': return $this->evaluate($l) !== $this->evaluate($r);
-            case '+':   return $this->evaluate($l) +   $this->evaluate($r);
-            case '**':  return $this->evaluate($l) **  $this->evaluate($r);
-            case '<<':  return $this->evaluate($l) <<  $this->evaluate($r);
-            case '>>':  return $this->evaluate($l) >>  $this->evaluate($r);
-            case '<':   return $this->evaluate($l) <   $this->evaluate($r);
-            case '<=':  return $this->evaluate($l) <=  $this->evaluate($r);
-            case '<=>': return $this->evaluate($l) <=> $this->evaluate($r);
-        }
-
-        throw new \Exception('Should not happen');
-    }
-
-    private function evaluateConstFetch(Expr\ConstFetch $expr) {
-        $name = $expr->name->toLowerString();
-        switch ($name) {
-            case 'null': return null;
-            case 'false': return false;
-            case 'true': return true;
-        }
-
-        return ($this->fallbackEvaluator)($expr);
-    }
+	private $fallbackEvaluator;
+
+	/**
+	 * Create a constant expression evaluator.
+	 *
+	 * The provided fallback evaluator is invoked whenever a subexpression cannot be evaluated. See
+	 * class doc comment for more information.
+	 *
+	 * @param callable|null $fallbackEvaluator To call if subexpression cannot be evaluated
+	 */
+	public function __construct(?callable $fallbackEvaluator = null) {
+		$this->fallbackEvaluator = $fallbackEvaluator ?? function(Expr $expr) {
+			throw new ConstExprEvaluationException(
+				"Expression of type {$expr->getType()} cannot be evaluated"
+			);
+		};
+	}
+
+	/**
+	 * Silently evaluates a constant expression into a PHP value.
+	 *
+	 * Thrown Errors, warnings or notices will be converted into a ConstExprEvaluationException.
+	 * The original source of the exception is available through getPrevious().
+	 *
+	 * If some part of the expression cannot be evaluated, the fallback evaluator passed to the
+	 * constructor will be invoked. By default, if no fallback is provided, an exception of type
+	 * ConstExprEvaluationException is thrown.
+	 *
+	 * See class doc comment for caveats and limitations.
+	 *
+	 * @param Expr $expr Constant expression to evaluate
+	 * @return mixed Result of evaluation
+	 *
+	 * @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) {
+			throw new \ErrorException($str, 0, $num, $file, $line);
+		});
+
+		try {
+			return $this->evaluate($expr);
+		} catch (\Throwable $e) {
+			if (!$e instanceof ConstExprEvaluationException) {
+				$e = new ConstExprEvaluationException(
+					"An error occurred during constant expression evaluation", 0, $e);
+			}
+			throw $e;
+		} finally {
+			restore_error_handler();
+		}
+	}
+
+	/**
+	 * Directly evaluates a constant expression into a PHP value.
+	 *
+	 * May generate Error exceptions, warnings or notices. Use evaluateSilently() to convert these
+	 * into a ConstExprEvaluationException.
+	 *
+	 * If some part of the expression cannot be evaluated, the fallback evaluator passed to the
+	 * constructor will be invoked. By default, if no fallback is provided, an exception of type
+	 * ConstExprEvaluationException is thrown.
+	 *
+	 * See class doc comment for caveats and limitations.
+	 *
+	 * @param Expr $expr Constant expression to evaluate
+	 * @return mixed Result of evaluation
+	 *
+	 * @throws ConstExprEvaluationException if the expression cannot be evaluated
+	 */
+	public function evaluateDirectly(Expr $expr) {
+		return $this->evaluate($expr);
+	}
+
+	private function evaluate(Expr $expr) {
+		if ($expr instanceof Scalar\LNumber
+			|| $expr instanceof Scalar\DNumber
+			|| $expr instanceof Scalar\String_
+		) {
+			return $expr->value;
+		}
+
+		if ($expr instanceof Expr\Array_) {
+			return $this->evaluateArray($expr);
+		}
+
+		// Unary operators
+		if ($expr instanceof Expr\UnaryPlus) {
+			return +$this->evaluate($expr->expr);
+		}
+		if ($expr instanceof Expr\UnaryMinus) {
+			return -$this->evaluate($expr->expr);
+		}
+		if ($expr instanceof Expr\BooleanNot) {
+			return !$this->evaluate($expr->expr);
+		}
+		if ($expr instanceof Expr\BitwiseNot) {
+			return ~$this->evaluate($expr->expr);
+		}
+
+		if ($expr instanceof Expr\BinaryOp) {
+			return $this->evaluateBinaryOp($expr);
+		}
+
+		if ($expr instanceof Expr\Ternary) {
+			return $this->evaluateTernary($expr);
+		}
+
+		if ($expr instanceof Expr\ArrayDimFetch && null !== $expr->dim) {
+			return $this->evaluate($expr->var)[$this->evaluate($expr->dim)];
+		}
+
+		if ($expr instanceof Expr\ConstFetch) {
+			return $this->evaluateConstFetch($expr);
+		}
+
+		return ($this->fallbackEvaluator)($expr);
+	}
+
+	private function evaluateArray(Expr\Array_ $expr) {
+		$array = [];
+		foreach ($expr->items as $item) {
+			if (null !== $item->key) {
+				$array[$this->evaluate($item->key)] = $this->evaluate($item->value);
+			} elseif ($item->unpack) {
+				$array = array_merge($array, $this->evaluate($item->value));
+			} else {
+				$array[] = $this->evaluate($item->value);
+			}
+		}
+		return $array;
+	}
+
+	private function evaluateTernary(Expr\Ternary $expr) {
+		if (null === $expr->if) {
+			return $this->evaluate($expr->cond) ?: $this->evaluate($expr->else);
+		}
+
+		return $this->evaluate($expr->cond)
+			? $this->evaluate($expr->if)
+			: $this->evaluate($expr->else);
+	}
+
+	private function evaluateBinaryOp(Expr\BinaryOp $expr) {
+		if ($expr instanceof Expr\BinaryOp\Coalesce
+			&& $expr->left instanceof Expr\ArrayDimFetch
+		) {
+			// This needs to be special cased to respect BP_VAR_IS fetch semantics
+			return $this->evaluate($expr->left->var)[$this->evaluate($expr->left->dim)]
+				?? $this->evaluate($expr->right);
+		}
+
+		// The evaluate() calls are repeated in each branch, because some of the operators are
+		// short-circuiting and evaluating the RHS in advance may be illegal in that case
+		$l = $expr->left;
+		$r = $expr->right;
+		switch ($expr->getOperatorSigil()) {
+			case '&':   return $this->evaluate($l) &   $this->evaluate($r);
+			case '|':   return $this->evaluate($l) |   $this->evaluate($r);
+			case '^':   return $this->evaluate($l) ^   $this->evaluate($r);
+			case '&&':  return $this->evaluate($l) &&  $this->evaluate($r);
+			case '||':  return $this->evaluate($l) ||  $this->evaluate($r);
+			case '??':  return $this->evaluate($l) ??  $this->evaluate($r);
+			case '.':   return $this->evaluate($l) .   $this->evaluate($r);
+			case '/':   return $this->evaluate($l) /   $this->evaluate($r);
+			case '==':  return $this->evaluate($l) ==  $this->evaluate($r);
+			case '>':   return $this->evaluate($l) >   $this->evaluate($r);
+			case '>=':  return $this->evaluate($l) >=  $this->evaluate($r);
+			case '===': return $this->evaluate($l) === $this->evaluate($r);
+			case 'and': return $this->evaluate($l) and $this->evaluate($r);
+			case 'or':  return $this->evaluate($l) or  $this->evaluate($r);
+			case 'xor': return $this->evaluate($l) xor $this->evaluate($r);
+			case '-':   return $this->evaluate($l) -   $this->evaluate($r);
+			case '%':   return $this->evaluate($l) %   $this->evaluate($r);
+			case '*':   return $this->evaluate($l) *   $this->evaluate($r);
+			case '!=':  return $this->evaluate($l) !=  $this->evaluate($r);
+			case '!==': return $this->evaluate($l) !== $this->evaluate($r);
+			case '+':   return $this->evaluate($l) +   $this->evaluate($r);
+			case '**':  return $this->evaluate($l) **  $this->evaluate($r);
+			case '<<':  return $this->evaluate($l) <<  $this->evaluate($r);
+			case '>>':  return $this->evaluate($l) >>  $this->evaluate($r);
+			case '<':   return $this->evaluate($l) <   $this->evaluate($r);
+			case '<=':  return $this->evaluate($l) <=  $this->evaluate($r);
+			case '<=>': return $this->evaluate($l) <=> $this->evaluate($r);
+		}
+
+		throw new \Exception('Should not happen');
+	}
+
+	private function evaluateConstFetch(Expr\ConstFetch $expr) {
+		$name = $expr->name->toLowerString();
+		switch ($name) {
+			case 'null': return null;
+			case 'false': return false;
+			case 'true': return true;
+		}
+
+		return ($this->fallbackEvaluator)($expr);
+	}
 }

Spacing +21 added lines, -21 removed lines

@@ -184,32 +184,32 @@
         $l = $expr->left;
         $r = $expr->right;
         switch ($expr->getOperatorSigil()) {
-            case '&':   return $this->evaluate($l) &   $this->evaluate($r);
-            case '|':   return $this->evaluate($l) |   $this->evaluate($r);
-            case '^':   return $this->evaluate($l) ^   $this->evaluate($r);
-            case '&&':  return $this->evaluate($l) &&  $this->evaluate($r);
-            case '||':  return $this->evaluate($l) ||  $this->evaluate($r);
-            case '??':  return $this->evaluate($l) ??  $this->evaluate($r);
-            case '.':   return $this->evaluate($l) .   $this->evaluate($r);
-            case '/':   return $this->evaluate($l) /   $this->evaluate($r);
-            case '==':  return $this->evaluate($l) ==  $this->evaluate($r);
-            case '>':   return $this->evaluate($l) >   $this->evaluate($r);
-            case '>=':  return $this->evaluate($l) >=  $this->evaluate($r);
+            case '&':   return $this->evaluate($l) & $this->evaluate($r);
+            case '|':   return $this->evaluate($l) | $this->evaluate($r);
+            case '^':   return $this->evaluate($l) ^ $this->evaluate($r);
+            case '&&':  return $this->evaluate($l) && $this->evaluate($r);
+            case '||':  return $this->evaluate($l) || $this->evaluate($r);
+            case '??':  return $this->evaluate($l) ?? $this->evaluate($r);
+            case '.':   return $this->evaluate($l).$this->evaluate($r);
+            case '/':   return $this->evaluate($l) / $this->evaluate($r);
+            case '==':  return $this->evaluate($l) == $this->evaluate($r);
+            case '>':   return $this->evaluate($l) > $this->evaluate($r);
+            case '>=':  return $this->evaluate($l) >= $this->evaluate($r);
             case '===': return $this->evaluate($l) === $this->evaluate($r);
             case 'and': return $this->evaluate($l) and $this->evaluate($r);
-            case 'or':  return $this->evaluate($l) or  $this->evaluate($r);
+            case 'or':  return $this->evaluate($l) or $this->evaluate($r);
             case 'xor': return $this->evaluate($l) xor $this->evaluate($r);
-            case '-':   return $this->evaluate($l) -   $this->evaluate($r);
-            case '%':   return $this->evaluate($l) %   $this->evaluate($r);
-            case '*':   return $this->evaluate($l) *   $this->evaluate($r);
-            case '!=':  return $this->evaluate($l) !=  $this->evaluate($r);
+            case '-':   return $this->evaluate($l) - $this->evaluate($r);
+            case '%':   return $this->evaluate($l) % $this->evaluate($r);
+            case '*':   return $this->evaluate($l) * $this->evaluate($r);
+            case '!=':  return $this->evaluate($l) != $this->evaluate($r);
             case '!==': return $this->evaluate($l) !== $this->evaluate($r);
-            case '+':   return $this->evaluate($l) +   $this->evaluate($r);
+            case '+':   return $this->evaluate($l) + $this->evaluate($r);
             case '**':  return $this->evaluate($l) **  $this->evaluate($r);
-            case '<<':  return $this->evaluate($l) <<  $this->evaluate($r);
-            case '>>':  return $this->evaluate($l) >>  $this->evaluate($r);
-            case '<':   return $this->evaluate($l) <   $this->evaluate($r);
-            case '<=':  return $this->evaluate($l) <=  $this->evaluate($r);
+            case '<<':  return $this->evaluate($l) << $this->evaluate($r);
+            case '>>':  return $this->evaluate($l) >> $this->evaluate($r);
+            case '<':   return $this->evaluate($l) < $this->evaluate($r);
+            case '<=':  return $this->evaluate($l) <= $this->evaluate($r);
             case '<=>': return $this->evaluate($l) <=> $this->evaluate($r);
         }
 

Braces +1 added lines, -2 removed lines

@@ -25,8 +25,7 @@
  * point to string conversions are affected by the precision ini setting. Secondly, they are also
  * affected by the LC_NUMERIC locale.
  */
-class ConstExprEvaluator
-{
+class ConstExprEvaluator {
     private $fallbackEvaluator;
 
     /**

vendor-bin/php-scoper/vendor/nikic/php-parser/lib/PhpParser/Lexer.php

Indentation +551 added lines, -551 removed lines

@@ -6,555 +6,555 @@
 
 class Lexer
 {
-    protected $code;
-    protected $tokens;
-    protected $pos;
-    protected $line;
-    protected $filePos;
-    protected $prevCloseTagHasNewline;
-
-    protected $tokenMap;
-    protected $dropTokens;
-    protected $identifierTokens;
-
-    private $attributeStartLineUsed;
-    private $attributeEndLineUsed;
-    private $attributeStartTokenPosUsed;
-    private $attributeEndTokenPosUsed;
-    private $attributeStartFilePosUsed;
-    private $attributeEndFilePosUsed;
-    private $attributeCommentsUsed;
-
-    /**
-     * Creates a Lexer.
-     *
-     * @param array $options Options array. Currently only the 'usedAttributes' option is supported,
-     *                       which is an array of attributes to add to the AST nodes. Possible
-     *                       attributes are: 'comments', 'startLine', 'endLine', 'startTokenPos',
-     *                       'endTokenPos', 'startFilePos', 'endFilePos'. The option defaults to the
-     *                       first three. For more info see getNextToken() docs.
-     */
-    public function __construct(array $options = []) {
-        // Create Map from internal tokens to PhpParser tokens.
-        $this->defineCompatibilityTokens();
-        $this->tokenMap = $this->createTokenMap();
-        $this->identifierTokens = $this->createIdentifierTokenMap();
-
-        // map of tokens to drop while lexing (the map is only used for isset lookup,
-        // that's why the value is simply set to 1; the value is never actually used.)
-        $this->dropTokens = array_fill_keys(
-            [\T_WHITESPACE, \T_OPEN_TAG, \T_COMMENT, \T_DOC_COMMENT, \T_BAD_CHARACTER], 1
-        );
-
-        $defaultAttributes = ['comments', 'startLine', 'endLine'];
-        $usedAttributes = array_fill_keys($options['usedAttributes'] ?? $defaultAttributes, true);
-
-        // Create individual boolean properties to make these checks faster.
-        $this->attributeStartLineUsed = isset($usedAttributes['startLine']);
-        $this->attributeEndLineUsed = isset($usedAttributes['endLine']);
-        $this->attributeStartTokenPosUsed = isset($usedAttributes['startTokenPos']);
-        $this->attributeEndTokenPosUsed = isset($usedAttributes['endTokenPos']);
-        $this->attributeStartFilePosUsed = isset($usedAttributes['startFilePos']);
-        $this->attributeEndFilePosUsed = isset($usedAttributes['endFilePos']);
-        $this->attributeCommentsUsed = isset($usedAttributes['comments']);
-    }
-
-    /**
-     * Initializes the lexer for lexing the provided source code.
-     *
-     * This function does not throw if lexing errors occur. Instead, errors may be retrieved using
-     * the getErrors() method.
-     *
-     * @param string $code The source code to lex
-     * @param ErrorHandler|null $errorHandler Error handler to use for lexing errors. Defaults to
-     *                                        ErrorHandler\Throwing
-     */
-    public function startLexing(string $code, ?ErrorHandler $errorHandler = null) {
-        if (null === $errorHandler) {
-            $errorHandler = new ErrorHandler\Throwing();
-        }
-
-        $this->code = $code; // keep the code around for __halt_compiler() handling
-        $this->pos  = -1;
-        $this->line =  1;
-        $this->filePos = 0;
-
-        // If inline HTML occurs without preceding code, treat it as if it had a leading newline.
-        // This ensures proper composability, because having a newline is the "safe" assumption.
-        $this->prevCloseTagHasNewline = true;
-
-        $scream = ini_set('xdebug.scream', '0');
-
-        $this->tokens = @token_get_all($code);
-        $this->postprocessTokens($errorHandler);
-
-        if (false !== $scream) {
-            ini_set('xdebug.scream', $scream);
-        }
-    }
-
-    private function handleInvalidCharacterRange($start, $end, $line, ErrorHandler $errorHandler) {
-        $tokens = [];
-        for ($i = $start; $i < $end; $i++) {
-            $chr = $this->code[$i];
-            if ($chr === "\0") {
-                // PHP cuts error message after null byte, so need special case
-                $errorMsg = 'Unexpected null byte';
-            } else {
-                $errorMsg = sprintf(
-                    'Unexpected character "%s" (ASCII %d)', $chr, ord($chr)
-                );
-            }
-
-            $tokens[] = [\T_BAD_CHARACTER, $chr, $line];
-            $errorHandler->handleError(new Error($errorMsg, [
-                'startLine' => $line,
-                'endLine' => $line,
-                'startFilePos' => $i,
-                'endFilePos' => $i,
-            ]));
-        }
-        return $tokens;
-    }
-
-    /**
-     * Check whether comment token is unterminated.
-     *
-     * @return bool
-     */
-    private function isUnterminatedComment($token) : bool {
-        return ($token[0] === \T_COMMENT || $token[0] === \T_DOC_COMMENT)
-            && substr($token[1], 0, 2) === '/*'
-            && substr($token[1], -2) !== '*/';
-    }
-
-    protected function postprocessTokens(ErrorHandler $errorHandler) {
-        // PHP's error handling for token_get_all() is rather bad, so if we want detailed
-        // error information we need to compute it ourselves. Invalid character errors are
-        // detected by finding "gaps" in the token array. Unterminated comments are detected
-        // by checking if a trailing comment has a "*/" at the end.
-        //
-        // Additionally, we perform a number of canonicalizations here:
-        //  * Use the PHP 8.0 comment format, which does not include trailing whitespace anymore.
-        //  * Use PHP 8.0 T_NAME_* tokens.
-        //  * Use PHP 8.1 T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG and
-        //    T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG tokens used to disambiguate intersection types.
-
-        $filePos = 0;
-        $line = 1;
-        $numTokens = \count($this->tokens);
-        for ($i = 0; $i < $numTokens; $i++) {
-            $token = $this->tokens[$i];
-
-            // Since PHP 7.4 invalid characters are represented by a T_BAD_CHARACTER token.
-            // In this case we only need to emit an error.
-            if ($token[0] === \T_BAD_CHARACTER) {
-                $this->handleInvalidCharacterRange($filePos, $filePos + 1, $line, $errorHandler);
-            }
-
-            if ($token[0] === \T_COMMENT && substr($token[1], 0, 2) !== '/*'
-                    && preg_match('/(\r\n|\n|\r)$/D', $token[1], $matches)) {
-                $trailingNewline = $matches[0];
-                $token[1] = substr($token[1], 0, -strlen($trailingNewline));
-                $this->tokens[$i] = $token;
-                if (isset($this->tokens[$i + 1]) && $this->tokens[$i + 1][0] === \T_WHITESPACE) {
-                    // Move trailing newline into following T_WHITESPACE token, if it already exists.
-                    $this->tokens[$i + 1][1] = $trailingNewline . $this->tokens[$i + 1][1];
-                    $this->tokens[$i + 1][2]--;
-                } else {
-                    // Otherwise, we need to create a new T_WHITESPACE token.
-                    array_splice($this->tokens, $i + 1, 0, [
-                        [\T_WHITESPACE, $trailingNewline, $line],
-                    ]);
-                    $numTokens++;
-                }
-            }
-
-            // Emulate PHP 8 T_NAME_* tokens, by combining sequences of T_NS_SEPARATOR and T_STRING
-            // into a single token.
-            if (\is_array($token)
-                    && ($token[0] === \T_NS_SEPARATOR || isset($this->identifierTokens[$token[0]]))) {
-                $lastWasSeparator = $token[0] === \T_NS_SEPARATOR;
-                $text = $token[1];
-                for ($j = $i + 1; isset($this->tokens[$j]); $j++) {
-                    if ($lastWasSeparator) {
-                        if (!isset($this->identifierTokens[$this->tokens[$j][0]])) {
-                            break;
-                        }
-                        $lastWasSeparator = false;
-                    } else {
-                        if ($this->tokens[$j][0] !== \T_NS_SEPARATOR) {
-                            break;
-                        }
-                        $lastWasSeparator = true;
-                    }
-                    $text .= $this->tokens[$j][1];
-                }
-                if ($lastWasSeparator) {
-                    // Trailing separator is not part of the name.
-                    $j--;
-                    $text = substr($text, 0, -1);
-                }
-                if ($j > $i + 1) {
-                    if ($token[0] === \T_NS_SEPARATOR) {
-                        $type = \T_NAME_FULLY_QUALIFIED;
-                    } else if ($token[0] === \T_NAMESPACE) {
-                        $type = \T_NAME_RELATIVE;
-                    } else {
-                        $type = \T_NAME_QUALIFIED;
-                    }
-                    $token = [$type, $text, $line];
-                    array_splice($this->tokens, $i, $j - $i, [$token]);
-                    $numTokens -= $j - $i - 1;
-                }
-            }
-
-            if ($token === '&') {
-                $next = $i + 1;
-                while (isset($this->tokens[$next]) && $this->tokens[$next][0] === \T_WHITESPACE) {
-                    $next++;
-                }
-                $followedByVarOrVarArg = isset($this->tokens[$next]) &&
-                    ($this->tokens[$next][0] === \T_VARIABLE || $this->tokens[$next][0] === \T_ELLIPSIS);
-                $this->tokens[$i] = $token = [
-                    $followedByVarOrVarArg
-                        ? \T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
-                        : \T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG,
-                    '&',
-                    $line,
-                ];
-            }
-
-            $tokenValue = \is_string($token) ? $token : $token[1];
-            $tokenLen = \strlen($tokenValue);
-
-            if (substr($this->code, $filePos, $tokenLen) !== $tokenValue) {
-                // Something is missing, must be an invalid character
-                $nextFilePos = strpos($this->code, $tokenValue, $filePos);
-                $badCharTokens = $this->handleInvalidCharacterRange(
-                    $filePos, $nextFilePos, $line, $errorHandler);
-                $filePos = (int) $nextFilePos;
-
-                array_splice($this->tokens, $i, 0, $badCharTokens);
-                $numTokens += \count($badCharTokens);
-                $i += \count($badCharTokens);
-            }
-
-            $filePos += $tokenLen;
-            $line += substr_count($tokenValue, "\n");
-        }
-
-        if ($filePos !== \strlen($this->code)) {
-            if (substr($this->code, $filePos, 2) === '/*') {
-                // Unlike PHP, HHVM will drop unterminated comments entirely
-                $comment = substr($this->code, $filePos);
-                $errorHandler->handleError(new Error('Unterminated comment', [
-                    'startLine' => $line,
-                    'endLine' => $line + substr_count($comment, "\n"),
-                    'startFilePos' => $filePos,
-                    'endFilePos' => $filePos + \strlen($comment),
-                ]));
-
-                // Emulate the PHP behavior
-                $isDocComment = isset($comment[3]) && $comment[3] === '*';
-                $this->tokens[] = [$isDocComment ? \T_DOC_COMMENT : \T_COMMENT, $comment, $line];
-            } else {
-                // Invalid characters at the end of the input
-                $badCharTokens = $this->handleInvalidCharacterRange(
-                    $filePos, \strlen($this->code), $line, $errorHandler);
-                $this->tokens = array_merge($this->tokens, $badCharTokens);
-            }
-            return;
-        }
-
-        if (count($this->tokens) > 0) {
-            // Check for unterminated comment
-            $lastToken = $this->tokens[count($this->tokens) - 1];
-            if ($this->isUnterminatedComment($lastToken)) {
-                $errorHandler->handleError(new Error('Unterminated comment', [
-                    'startLine' => $line - substr_count($lastToken[1], "\n"),
-                    'endLine' => $line,
-                    'startFilePos' => $filePos - \strlen($lastToken[1]),
-                    'endFilePos' => $filePos,
-                ]));
-            }
-        }
-    }
-
-    /**
-     * Fetches the next token.
-     *
-     * The available attributes are determined by the 'usedAttributes' option, which can
-     * be specified in the constructor. The following attributes are supported:
-     *
-     *  * 'comments'      => Array of PhpParser\Comment or PhpParser\Comment\Doc instances,
-     *                       representing all comments that occurred between the previous
-     *                       non-discarded token and the current one.
-     *  * 'startLine'     => Line in which the node starts.
-     *  * 'endLine'       => Line in which the node ends.
-     *  * 'startTokenPos' => Offset into the token array of the first token in the node.
-     *  * 'endTokenPos'   => Offset into the token array of the last token in the node.
-     *  * 'startFilePos'  => Offset into the code string of the first character that is part of the node.
-     *  * 'endFilePos'    => Offset into the code string of the last character that is part of the node.
-     *
-     * @param mixed $value           Variable to store token content in
-     * @param mixed $startAttributes Variable to store start attributes in
-     * @param mixed $endAttributes   Variable to store end attributes in
-     *
-     * @return int Token id
-     */
-    public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) : int {
-        $startAttributes = [];
-        $endAttributes   = [];
-
-        while (1) {
-            if (isset($this->tokens[++$this->pos])) {
-                $token = $this->tokens[$this->pos];
-            } else {
-                // EOF token with ID 0
-                $token = "\0";
-            }
-
-            if ($this->attributeStartLineUsed) {
-                $startAttributes['startLine'] = $this->line;
-            }
-            if ($this->attributeStartTokenPosUsed) {
-                $startAttributes['startTokenPos'] = $this->pos;
-            }
-            if ($this->attributeStartFilePosUsed) {
-                $startAttributes['startFilePos'] = $this->filePos;
-            }
-
-            if (\is_string($token)) {
-                $value = $token;
-                if (isset($token[1])) {
-                    // bug in token_get_all
-                    $this->filePos += 2;
-                    $id = ord('"');
-                } else {
-                    $this->filePos += 1;
-                    $id = ord($token);
-                }
-            } elseif (!isset($this->dropTokens[$token[0]])) {
-                $value = $token[1];
-                $id = $this->tokenMap[$token[0]];
-                if (\T_CLOSE_TAG === $token[0]) {
-                    $this->prevCloseTagHasNewline = false !== strpos($token[1], "\n")
-                        || false !== strpos($token[1], "\r");
-                } elseif (\T_INLINE_HTML === $token[0]) {
-                    $startAttributes['hasLeadingNewline'] = $this->prevCloseTagHasNewline;
-                }
-
-                $this->line += substr_count($value, "\n");
-                $this->filePos += \strlen($value);
-            } else {
-                $origLine = $this->line;
-                $origFilePos = $this->filePos;
-                $this->line += substr_count($token[1], "\n");
-                $this->filePos += \strlen($token[1]);
-
-                if (\T_COMMENT === $token[0] || \T_DOC_COMMENT === $token[0]) {
-                    if ($this->attributeCommentsUsed) {
-                        $comment = \T_DOC_COMMENT === $token[0]
-                            ? new Comment\Doc($token[1],
-                                $origLine, $origFilePos, $this->pos,
-                                $this->line, $this->filePos - 1, $this->pos)
-                            : new Comment($token[1],
-                                $origLine, $origFilePos, $this->pos,
-                                $this->line, $this->filePos - 1, $this->pos);
-                        $startAttributes['comments'][] = $comment;
-                    }
-                }
-                continue;
-            }
-
-            if ($this->attributeEndLineUsed) {
-                $endAttributes['endLine'] = $this->line;
-            }
-            if ($this->attributeEndTokenPosUsed) {
-                $endAttributes['endTokenPos'] = $this->pos;
-            }
-            if ($this->attributeEndFilePosUsed) {
-                $endAttributes['endFilePos'] = $this->filePos - 1;
-            }
-
-            return $id;
-        }
-
-        throw new \RuntimeException('Reached end of lexer loop');
-    }
-
-    /**
-     * Returns the token array for current code.
-     *
-     * The token array is in the same format as provided by the
-     * token_get_all() function and does not discard tokens (i.e.
-     * whitespace and comments are included). The token position
-     * attributes are against this token array.
-     *
-     * @return array Array of tokens in token_get_all() format
-     */
-    public function getTokens() : array {
-        return $this->tokens;
-    }
-
-    /**
-     * Handles __halt_compiler() by returning the text after it.
-     *
-     * @return string Remaining text
-     */
-    public function handleHaltCompiler() : string {
-        // text after T_HALT_COMPILER, still including ();
-        $textAfter = substr($this->code, $this->filePos);
-
-        // ensure that it is followed by ();
-        // this simplifies the situation, by not allowing any comments
-        // in between of the tokens.
-        if (!preg_match('~^\s*\(\s*\)\s*(?:;|\?>\r?\n?)~', $textAfter, $matches)) {
-            throw new Error('__HALT_COMPILER must be followed by "();"');
-        }
-
-        // prevent the lexer from returning any further tokens
-        $this->pos = count($this->tokens);
-
-        // return with (); removed
-        return substr($textAfter, strlen($matches[0]));
-    }
-
-    private function defineCompatibilityTokens() {
-        static $compatTokensDefined = false;
-        if ($compatTokensDefined) {
-            return;
-        }
-
-        $compatTokens = [
-            // PHP 7.4
-            'T_BAD_CHARACTER',
-            'T_FN',
-            'T_COALESCE_EQUAL',
-            // PHP 8.0
-            'T_NAME_QUALIFIED',
-            'T_NAME_FULLY_QUALIFIED',
-            'T_NAME_RELATIVE',
-            'T_MATCH',
-            'T_NULLSAFE_OBJECT_OPERATOR',
-            'T_ATTRIBUTE',
-            // PHP 8.1
-            'T_ENUM',
-            'T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG',
-            'T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG',
-            'T_READONLY',
-        ];
-
-        // PHP-Parser might be used together with another library that also emulates some or all
-        // of these tokens. Perform a sanity-check that all already defined tokens have been
-        // assigned a unique ID.
-        $usedTokenIds = [];
-        foreach ($compatTokens as $token) {
-            if (\defined($token)) {
-                $tokenId = \constant($token);
-                $clashingToken = $usedTokenIds[$tokenId] ?? null;
-                if ($clashingToken !== null) {
-                    throw new \Error(sprintf(
-                        'Token %s has same ID as token %s, ' .
-                        'you may be using a library with broken token emulation',
-                        $token, $clashingToken
-                    ));
-                }
-                $usedTokenIds[$tokenId] = $token;
-            }
-        }
-
-        // Now define any tokens that have not yet been emulated. Try to assign IDs from -1
-        // downwards, but skip any IDs that may already be in use.
-        $newTokenId = -1;
-        foreach ($compatTokens as $token) {
-            if (!\defined($token)) {
-                while (isset($usedTokenIds[$newTokenId])) {
-                    $newTokenId--;
-                }
-                \define($token, $newTokenId);
-                $newTokenId--;
-            }
-        }
-
-        $compatTokensDefined = true;
-    }
-
-    /**
-     * Creates the token map.
-     *
-     * The token map maps the PHP internal token identifiers
-     * to the identifiers used by the Parser. Additionally it
-     * maps T_OPEN_TAG_WITH_ECHO to T_ECHO and T_CLOSE_TAG to ';'.
-     *
-     * @return array The token map
-     */
-    protected function createTokenMap() : array {
-        $tokenMap = [];
-
-        // 256 is the minimum possible token number, as everything below
-        // it is an ASCII value
-        for ($i = 256; $i < 1000; ++$i) {
-            if (\T_DOUBLE_COLON === $i) {
-                // T_DOUBLE_COLON is equivalent to T_PAAMAYIM_NEKUDOTAYIM
-                $tokenMap[$i] = Tokens::T_PAAMAYIM_NEKUDOTAYIM;
-            } elseif(\T_OPEN_TAG_WITH_ECHO === $i) {
-                // T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
-                $tokenMap[$i] = Tokens::T_ECHO;
-            } elseif(\T_CLOSE_TAG === $i) {
-                // T_CLOSE_TAG is equivalent to ';'
-                $tokenMap[$i] = ord(';');
-            } elseif ('UNKNOWN' !== $name = token_name($i)) {
-                if ('T_HASHBANG' === $name) {
-                    // HHVM uses a special token for #! hashbang lines
-                    $tokenMap[$i] = Tokens::T_INLINE_HTML;
-                } elseif (defined($name = Tokens::class . '::' . $name)) {
-                    // Other tokens can be mapped directly
-                    $tokenMap[$i] = constant($name);
-                }
-            }
-        }
-
-        // HHVM uses a special token for numbers that overflow to double
-        if (defined('T_ONUMBER')) {
-            $tokenMap[\T_ONUMBER] = Tokens::T_DNUMBER;
-        }
-        // HHVM also has a separate token for the __COMPILER_HALT_OFFSET__ constant
-        if (defined('T_COMPILER_HALT_OFFSET')) {
-            $tokenMap[\T_COMPILER_HALT_OFFSET] = Tokens::T_STRING;
-        }
-
-        // Assign tokens for which we define compatibility constants, as token_name() does not know them.
-        $tokenMap[\T_FN] = Tokens::T_FN;
-        $tokenMap[\T_COALESCE_EQUAL] = Tokens::T_COALESCE_EQUAL;
-        $tokenMap[\T_NAME_QUALIFIED] = Tokens::T_NAME_QUALIFIED;
-        $tokenMap[\T_NAME_FULLY_QUALIFIED] = Tokens::T_NAME_FULLY_QUALIFIED;
-        $tokenMap[\T_NAME_RELATIVE] = Tokens::T_NAME_RELATIVE;
-        $tokenMap[\T_MATCH] = Tokens::T_MATCH;
-        $tokenMap[\T_NULLSAFE_OBJECT_OPERATOR] = Tokens::T_NULLSAFE_OBJECT_OPERATOR;
-        $tokenMap[\T_ATTRIBUTE] = Tokens::T_ATTRIBUTE;
-        $tokenMap[\T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG] = Tokens::T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG;
-        $tokenMap[\T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG] = Tokens::T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG;
-        $tokenMap[\T_ENUM] = Tokens::T_ENUM;
-        $tokenMap[\T_READONLY] = Tokens::T_READONLY;
-
-        return $tokenMap;
-    }
-
-    private function createIdentifierTokenMap(): array {
-        // Based on semi_reserved production.
-        return 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);
-    }
+	protected $code;
+	protected $tokens;
+	protected $pos;
+	protected $line;
+	protected $filePos;
+	protected $prevCloseTagHasNewline;
+
+	protected $tokenMap;
+	protected $dropTokens;
+	protected $identifierTokens;
+
+	private $attributeStartLineUsed;
+	private $attributeEndLineUsed;
+	private $attributeStartTokenPosUsed;
+	private $attributeEndTokenPosUsed;
+	private $attributeStartFilePosUsed;
+	private $attributeEndFilePosUsed;
+	private $attributeCommentsUsed;
+
+	/**
+	 * Creates a Lexer.
+	 *
+	 * @param array $options Options array. Currently only the 'usedAttributes' option is supported,
+	 *                       which is an array of attributes to add to the AST nodes. Possible
+	 *                       attributes are: 'comments', 'startLine', 'endLine', 'startTokenPos',
+	 *                       'endTokenPos', 'startFilePos', 'endFilePos'. The option defaults to the
+	 *                       first three. For more info see getNextToken() docs.
+	 */
+	public function __construct(array $options = []) {
+		// Create Map from internal tokens to PhpParser tokens.
+		$this->defineCompatibilityTokens();
+		$this->tokenMap = $this->createTokenMap();
+		$this->identifierTokens = $this->createIdentifierTokenMap();
+
+		// map of tokens to drop while lexing (the map is only used for isset lookup,
+		// that's why the value is simply set to 1; the value is never actually used.)
+		$this->dropTokens = array_fill_keys(
+			[\T_WHITESPACE, \T_OPEN_TAG, \T_COMMENT, \T_DOC_COMMENT, \T_BAD_CHARACTER], 1
+		);
+
+		$defaultAttributes = ['comments', 'startLine', 'endLine'];
+		$usedAttributes = array_fill_keys($options['usedAttributes'] ?? $defaultAttributes, true);
+
+		// Create individual boolean properties to make these checks faster.
+		$this->attributeStartLineUsed = isset($usedAttributes['startLine']);
+		$this->attributeEndLineUsed = isset($usedAttributes['endLine']);
+		$this->attributeStartTokenPosUsed = isset($usedAttributes['startTokenPos']);
+		$this->attributeEndTokenPosUsed = isset($usedAttributes['endTokenPos']);
+		$this->attributeStartFilePosUsed = isset($usedAttributes['startFilePos']);
+		$this->attributeEndFilePosUsed = isset($usedAttributes['endFilePos']);
+		$this->attributeCommentsUsed = isset($usedAttributes['comments']);
+	}
+
+	/**
+	 * Initializes the lexer for lexing the provided source code.
+	 *
+	 * This function does not throw if lexing errors occur. Instead, errors may be retrieved using
+	 * the getErrors() method.
+	 *
+	 * @param string $code The source code to lex
+	 * @param ErrorHandler|null $errorHandler Error handler to use for lexing errors. Defaults to
+	 *                                        ErrorHandler\Throwing
+	 */
+	public function startLexing(string $code, ?ErrorHandler $errorHandler = null) {
+		if (null === $errorHandler) {
+			$errorHandler = new ErrorHandler\Throwing();
+		}
+
+		$this->code = $code; // keep the code around for __halt_compiler() handling
+		$this->pos  = -1;
+		$this->line =  1;
+		$this->filePos = 0;
+
+		// If inline HTML occurs without preceding code, treat it as if it had a leading newline.
+		// This ensures proper composability, because having a newline is the "safe" assumption.
+		$this->prevCloseTagHasNewline = true;
+
+		$scream = ini_set('xdebug.scream', '0');
+
+		$this->tokens = @token_get_all($code);
+		$this->postprocessTokens($errorHandler);
+
+		if (false !== $scream) {
+			ini_set('xdebug.scream', $scream);
+		}
+	}
+
+	private function handleInvalidCharacterRange($start, $end, $line, ErrorHandler $errorHandler) {
+		$tokens = [];
+		for ($i = $start; $i < $end; $i++) {
+			$chr = $this->code[$i];
+			if ($chr === "\0") {
+				// PHP cuts error message after null byte, so need special case
+				$errorMsg = 'Unexpected null byte';
+			} else {
+				$errorMsg = sprintf(
+					'Unexpected character "%s" (ASCII %d)', $chr, ord($chr)
+				);
+			}
+
+			$tokens[] = [\T_BAD_CHARACTER, $chr, $line];
+			$errorHandler->handleError(new Error($errorMsg, [
+				'startLine' => $line,
+				'endLine' => $line,
+				'startFilePos' => $i,
+				'endFilePos' => $i,
+			]));
+		}
+		return $tokens;
+	}
+
+	/**
+	 * Check whether comment token is unterminated.
+	 *
+	 * @return bool
+	 */
+	private function isUnterminatedComment($token) : bool {
+		return ($token[0] === \T_COMMENT || $token[0] === \T_DOC_COMMENT)
+			&& substr($token[1], 0, 2) === '/*'
+			&& substr($token[1], -2) !== '*/';
+	}
+
+	protected function postprocessTokens(ErrorHandler $errorHandler) {
+		// PHP's error handling for token_get_all() is rather bad, so if we want detailed
+		// error information we need to compute it ourselves. Invalid character errors are
+		// detected by finding "gaps" in the token array. Unterminated comments are detected
+		// by checking if a trailing comment has a "*/" at the end.
+		//
+		// Additionally, we perform a number of canonicalizations here:
+		//  * Use the PHP 8.0 comment format, which does not include trailing whitespace anymore.
+		//  * Use PHP 8.0 T_NAME_* tokens.
+		//  * Use PHP 8.1 T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG and
+		//    T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG tokens used to disambiguate intersection types.
+
+		$filePos = 0;
+		$line = 1;
+		$numTokens = \count($this->tokens);
+		for ($i = 0; $i < $numTokens; $i++) {
+			$token = $this->tokens[$i];
+
+			// Since PHP 7.4 invalid characters are represented by a T_BAD_CHARACTER token.
+			// In this case we only need to emit an error.
+			if ($token[0] === \T_BAD_CHARACTER) {
+				$this->handleInvalidCharacterRange($filePos, $filePos + 1, $line, $errorHandler);
+			}
+
+			if ($token[0] === \T_COMMENT && substr($token[1], 0, 2) !== '/*'
+					&& preg_match('/(\r\n|\n|\r)$/D', $token[1], $matches)) {
+				$trailingNewline = $matches[0];
+				$token[1] = substr($token[1], 0, -strlen($trailingNewline));
+				$this->tokens[$i] = $token;
+				if (isset($this->tokens[$i + 1]) && $this->tokens[$i + 1][0] === \T_WHITESPACE) {
+					// Move trailing newline into following T_WHITESPACE token, if it already exists.
+					$this->tokens[$i + 1][1] = $trailingNewline . $this->tokens[$i + 1][1];
+					$this->tokens[$i + 1][2]--;
+				} else {
+					// Otherwise, we need to create a new T_WHITESPACE token.
+					array_splice($this->tokens, $i + 1, 0, [
+						[\T_WHITESPACE, $trailingNewline, $line],
+					]);
+					$numTokens++;
+				}
+			}
+
+			// Emulate PHP 8 T_NAME_* tokens, by combining sequences of T_NS_SEPARATOR and T_STRING
+			// into a single token.
+			if (\is_array($token)
+					&& ($token[0] === \T_NS_SEPARATOR || isset($this->identifierTokens[$token[0]]))) {
+				$lastWasSeparator = $token[0] === \T_NS_SEPARATOR;
+				$text = $token[1];
+				for ($j = $i + 1; isset($this->tokens[$j]); $j++) {
+					if ($lastWasSeparator) {
+						if (!isset($this->identifierTokens[$this->tokens[$j][0]])) {
+							break;
+						}
+						$lastWasSeparator = false;
+					} else {
+						if ($this->tokens[$j][0] !== \T_NS_SEPARATOR) {
+							break;
+						}
+						$lastWasSeparator = true;
+					}
+					$text .= $this->tokens[$j][1];
+				}
+				if ($lastWasSeparator) {
+					// Trailing separator is not part of the name.
+					$j--;
+					$text = substr($text, 0, -1);
+				}
+				if ($j > $i + 1) {
+					if ($token[0] === \T_NS_SEPARATOR) {
+						$type = \T_NAME_FULLY_QUALIFIED;
+					} else if ($token[0] === \T_NAMESPACE) {
+						$type = \T_NAME_RELATIVE;
+					} else {
+						$type = \T_NAME_QUALIFIED;
+					}
+					$token = [$type, $text, $line];
+					array_splice($this->tokens, $i, $j - $i, [$token]);
+					$numTokens -= $j - $i - 1;
+				}
+			}
+
+			if ($token === '&') {
+				$next = $i + 1;
+				while (isset($this->tokens[$next]) && $this->tokens[$next][0] === \T_WHITESPACE) {
+					$next++;
+				}
+				$followedByVarOrVarArg = isset($this->tokens[$next]) &&
+					($this->tokens[$next][0] === \T_VARIABLE || $this->tokens[$next][0] === \T_ELLIPSIS);
+				$this->tokens[$i] = $token = [
+					$followedByVarOrVarArg
+						? \T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
+						: \T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG,
+					'&',
+					$line,
+				];
+			}
+
+			$tokenValue = \is_string($token) ? $token : $token[1];
+			$tokenLen = \strlen($tokenValue);
+
+			if (substr($this->code, $filePos, $tokenLen) !== $tokenValue) {
+				// Something is missing, must be an invalid character
+				$nextFilePos = strpos($this->code, $tokenValue, $filePos);
+				$badCharTokens = $this->handleInvalidCharacterRange(
+					$filePos, $nextFilePos, $line, $errorHandler);
+				$filePos = (int) $nextFilePos;
+
+				array_splice($this->tokens, $i, 0, $badCharTokens);
+				$numTokens += \count($badCharTokens);
+				$i += \count($badCharTokens);
+			}
+
+			$filePos += $tokenLen;
+			$line += substr_count($tokenValue, "\n");
+		}
+
+		if ($filePos !== \strlen($this->code)) {
+			if (substr($this->code, $filePos, 2) === '/*') {
+				// Unlike PHP, HHVM will drop unterminated comments entirely
+				$comment = substr($this->code, $filePos);
+				$errorHandler->handleError(new Error('Unterminated comment', [
+					'startLine' => $line,
+					'endLine' => $line + substr_count($comment, "\n"),
+					'startFilePos' => $filePos,
+					'endFilePos' => $filePos + \strlen($comment),
+				]));
+
+				// Emulate the PHP behavior
+				$isDocComment = isset($comment[3]) && $comment[3] === '*';
+				$this->tokens[] = [$isDocComment ? \T_DOC_COMMENT : \T_COMMENT, $comment, $line];
+			} else {
+				// Invalid characters at the end of the input
+				$badCharTokens = $this->handleInvalidCharacterRange(
+					$filePos, \strlen($this->code), $line, $errorHandler);
+				$this->tokens = array_merge($this->tokens, $badCharTokens);
+			}
+			return;
+		}
+
+		if (count($this->tokens) > 0) {
+			// Check for unterminated comment
+			$lastToken = $this->tokens[count($this->tokens) - 1];
+			if ($this->isUnterminatedComment($lastToken)) {
+				$errorHandler->handleError(new Error('Unterminated comment', [
+					'startLine' => $line - substr_count($lastToken[1], "\n"),
+					'endLine' => $line,
+					'startFilePos' => $filePos - \strlen($lastToken[1]),
+					'endFilePos' => $filePos,
+				]));
+			}
+		}
+	}
+
+	/**
+	 * Fetches the next token.
+	 *
+	 * The available attributes are determined by the 'usedAttributes' option, which can
+	 * be specified in the constructor. The following attributes are supported:
+	 *
+	 *  * 'comments'      => Array of PhpParser\Comment or PhpParser\Comment\Doc instances,
+	 *                       representing all comments that occurred between the previous
+	 *                       non-discarded token and the current one.
+	 *  * 'startLine'     => Line in which the node starts.
+	 *  * 'endLine'       => Line in which the node ends.
+	 *  * 'startTokenPos' => Offset into the token array of the first token in the node.
+	 *  * 'endTokenPos'   => Offset into the token array of the last token in the node.
+	 *  * 'startFilePos'  => Offset into the code string of the first character that is part of the node.
+	 *  * 'endFilePos'    => Offset into the code string of the last character that is part of the node.
+	 *
+	 * @param mixed $value           Variable to store token content in
+	 * @param mixed $startAttributes Variable to store start attributes in
+	 * @param mixed $endAttributes   Variable to store end attributes in
+	 *
+	 * @return int Token id
+	 */
+	public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) : int {
+		$startAttributes = [];
+		$endAttributes   = [];
+
+		while (1) {
+			if (isset($this->tokens[++$this->pos])) {
+				$token = $this->tokens[$this->pos];
+			} else {
+				// EOF token with ID 0
+				$token = "\0";
+			}
+
+			if ($this->attributeStartLineUsed) {
+				$startAttributes['startLine'] = $this->line;
+			}
+			if ($this->attributeStartTokenPosUsed) {
+				$startAttributes['startTokenPos'] = $this->pos;
+			}
+			if ($this->attributeStartFilePosUsed) {
+				$startAttributes['startFilePos'] = $this->filePos;
+			}
+
+			if (\is_string($token)) {
+				$value = $token;
+				if (isset($token[1])) {
+					// bug in token_get_all
+					$this->filePos += 2;
+					$id = ord('"');
+				} else {
+					$this->filePos += 1;
+					$id = ord($token);
+				}
+			} elseif (!isset($this->dropTokens[$token[0]])) {
+				$value = $token[1];
+				$id = $this->tokenMap[$token[0]];
+				if (\T_CLOSE_TAG === $token[0]) {
+					$this->prevCloseTagHasNewline = false !== strpos($token[1], "\n")
+						|| false !== strpos($token[1], "\r");
+				} elseif (\T_INLINE_HTML === $token[0]) {
+					$startAttributes['hasLeadingNewline'] = $this->prevCloseTagHasNewline;
+				}
+
+				$this->line += substr_count($value, "\n");
+				$this->filePos += \strlen($value);
+			} else {
+				$origLine = $this->line;
+				$origFilePos = $this->filePos;
+				$this->line += substr_count($token[1], "\n");
+				$this->filePos += \strlen($token[1]);
+
+				if (\T_COMMENT === $token[0] || \T_DOC_COMMENT === $token[0]) {
+					if ($this->attributeCommentsUsed) {
+						$comment = \T_DOC_COMMENT === $token[0]
+							? new Comment\Doc($token[1],
+								$origLine, $origFilePos, $this->pos,
+								$this->line, $this->filePos - 1, $this->pos)
+							: new Comment($token[1],
+								$origLine, $origFilePos, $this->pos,
+								$this->line, $this->filePos - 1, $this->pos);
+						$startAttributes['comments'][] = $comment;
+					}
+				}
+				continue;
+			}
+
+			if ($this->attributeEndLineUsed) {
+				$endAttributes['endLine'] = $this->line;
+			}
+			if ($this->attributeEndTokenPosUsed) {
+				$endAttributes['endTokenPos'] = $this->pos;
+			}
+			if ($this->attributeEndFilePosUsed) {
+				$endAttributes['endFilePos'] = $this->filePos - 1;
+			}
+
+			return $id;
+		}
+
+		throw new \RuntimeException('Reached end of lexer loop');
+	}
+
+	/**
+	 * Returns the token array for current code.
+	 *
+	 * The token array is in the same format as provided by the
+	 * token_get_all() function and does not discard tokens (i.e.
+	 * whitespace and comments are included). The token position
+	 * attributes are against this token array.
+	 *
+	 * @return array Array of tokens in token_get_all() format
+	 */
+	public function getTokens() : array {
+		return $this->tokens;
+	}
+
+	/**
+	 * Handles __halt_compiler() by returning the text after it.
+	 *
+	 * @return string Remaining text
+	 */
+	public function handleHaltCompiler() : string {
+		// text after T_HALT_COMPILER, still including ();
+		$textAfter = substr($this->code, $this->filePos);
+
+		// ensure that it is followed by ();
+		// this simplifies the situation, by not allowing any comments
+		// in between of the tokens.
+		if (!preg_match('~^\s*\(\s*\)\s*(?:;|\?>\r?\n?)~', $textAfter, $matches)) {
+			throw new Error('__HALT_COMPILER must be followed by "();"');
+		}
+
+		// prevent the lexer from returning any further tokens
+		$this->pos = count($this->tokens);
+
+		// return with (); removed
+		return substr($textAfter, strlen($matches[0]));
+	}
+
+	private function defineCompatibilityTokens() {
+		static $compatTokensDefined = false;
+		if ($compatTokensDefined) {
+			return;
+		}
+
+		$compatTokens = [
+			// PHP 7.4
+			'T_BAD_CHARACTER',
+			'T_FN',
+			'T_COALESCE_EQUAL',
+			// PHP 8.0
+			'T_NAME_QUALIFIED',
+			'T_NAME_FULLY_QUALIFIED',
+			'T_NAME_RELATIVE',
+			'T_MATCH',
+			'T_NULLSAFE_OBJECT_OPERATOR',
+			'T_ATTRIBUTE',
+			// PHP 8.1
+			'T_ENUM',
+			'T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG',
+			'T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG',
+			'T_READONLY',
+		];
+
+		// PHP-Parser might be used together with another library that also emulates some or all
+		// of these tokens. Perform a sanity-check that all already defined tokens have been
+		// assigned a unique ID.
+		$usedTokenIds = [];
+		foreach ($compatTokens as $token) {
+			if (\defined($token)) {
+				$tokenId = \constant($token);
+				$clashingToken = $usedTokenIds[$tokenId] ?? null;
+				if ($clashingToken !== null) {
+					throw new \Error(sprintf(
+						'Token %s has same ID as token %s, ' .
+						'you may be using a library with broken token emulation',
+						$token, $clashingToken
+					));
+				}
+				$usedTokenIds[$tokenId] = $token;
+			}
+		}
+
+		// Now define any tokens that have not yet been emulated. Try to assign IDs from -1
+		// downwards, but skip any IDs that may already be in use.
+		$newTokenId = -1;
+		foreach ($compatTokens as $token) {
+			if (!\defined($token)) {
+				while (isset($usedTokenIds[$newTokenId])) {
+					$newTokenId--;
+				}
+				\define($token, $newTokenId);
+				$newTokenId--;
+			}
+		}
+
+		$compatTokensDefined = true;
+	}
+
+	/**
+	 * Creates the token map.
+	 *
+	 * The token map maps the PHP internal token identifiers
+	 * to the identifiers used by the Parser. Additionally it
+	 * maps T_OPEN_TAG_WITH_ECHO to T_ECHO and T_CLOSE_TAG to ';'.
+	 *
+	 * @return array The token map
+	 */
+	protected function createTokenMap() : array {
+		$tokenMap = [];
+
+		// 256 is the minimum possible token number, as everything below
+		// it is an ASCII value
+		for ($i = 256; $i < 1000; ++$i) {
+			if (\T_DOUBLE_COLON === $i) {
+				// T_DOUBLE_COLON is equivalent to T_PAAMAYIM_NEKUDOTAYIM
+				$tokenMap[$i] = Tokens::T_PAAMAYIM_NEKUDOTAYIM;
+			} elseif(\T_OPEN_TAG_WITH_ECHO === $i) {
+				// T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
+				$tokenMap[$i] = Tokens::T_ECHO;
+			} elseif(\T_CLOSE_TAG === $i) {
+				// T_CLOSE_TAG is equivalent to ';'
+				$tokenMap[$i] = ord(';');
+			} elseif ('UNKNOWN' !== $name = token_name($i)) {
+				if ('T_HASHBANG' === $name) {
+					// HHVM uses a special token for #! hashbang lines
+					$tokenMap[$i] = Tokens::T_INLINE_HTML;
+				} elseif (defined($name = Tokens::class . '::' . $name)) {
+					// Other tokens can be mapped directly
+					$tokenMap[$i] = constant($name);
+				}
+			}
+		}
+
+		// HHVM uses a special token for numbers that overflow to double
+		if (defined('T_ONUMBER')) {
+			$tokenMap[\T_ONUMBER] = Tokens::T_DNUMBER;
+		}
+		// HHVM also has a separate token for the __COMPILER_HALT_OFFSET__ constant
+		if (defined('T_COMPILER_HALT_OFFSET')) {
+			$tokenMap[\T_COMPILER_HALT_OFFSET] = Tokens::T_STRING;
+		}
+
+		// Assign tokens for which we define compatibility constants, as token_name() does not know them.
+		$tokenMap[\T_FN] = Tokens::T_FN;
+		$tokenMap[\T_COALESCE_EQUAL] = Tokens::T_COALESCE_EQUAL;
+		$tokenMap[\T_NAME_QUALIFIED] = Tokens::T_NAME_QUALIFIED;
+		$tokenMap[\T_NAME_FULLY_QUALIFIED] = Tokens::T_NAME_FULLY_QUALIFIED;
+		$tokenMap[\T_NAME_RELATIVE] = Tokens::T_NAME_RELATIVE;
+		$tokenMap[\T_MATCH] = Tokens::T_MATCH;
+		$tokenMap[\T_NULLSAFE_OBJECT_OPERATOR] = Tokens::T_NULLSAFE_OBJECT_OPERATOR;
+		$tokenMap[\T_ATTRIBUTE] = Tokens::T_ATTRIBUTE;
+		$tokenMap[\T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG] = Tokens::T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG;
+		$tokenMap[\T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG] = Tokens::T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG;
+		$tokenMap[\T_ENUM] = Tokens::T_ENUM;
+		$tokenMap[\T_READONLY] = Tokens::T_READONLY;
+
+		return $tokenMap;
+	}
+
+	private function createIdentifierTokenMap(): array {
+		// Based on semi_reserved production.
+		return 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);
+	}
 }

Spacing +7 added lines, -7 removed lines

@@ -76,7 +76,7 @@ 
 
         $this->code = $code; // keep the code around for __halt_compiler() handling
         $this->pos  = -1;
-        $this->line =  1;
+        $this->line = 1;
         $this->filePos = 0;
 
         // If inline HTML occurs without preceding code, treat it as if it had a leading newline.
@@ -159,7 +159,7 @@ 
                 $this->tokens[$i] = $token;
                 if (isset($this->tokens[$i + 1]) && $this->tokens[$i + 1][0] === \T_WHITESPACE) {
                     // Move trailing newline into following T_WHITESPACE token, if it already exists.
-                    $this->tokens[$i + 1][1] = $trailingNewline . $this->tokens[$i + 1][1];
+                    $this->tokens[$i + 1][1] = $trailingNewline.$this->tokens[$i + 1][1];
                     $this->tokens[$i + 1][2]--;
                 } else {
                     // Otherwise, we need to create a new T_WHITESPACE token.
@@ -233,7 +233,7 @@ 
                 $nextFilePos = strpos($this->code, $tokenValue, $filePos);
                 $badCharTokens = $this->handleInvalidCharacterRange(
                     $filePos, $nextFilePos, $line, $errorHandler);
-                $filePos = (int) $nextFilePos;
+                $filePos = (int)$nextFilePos;
 
                 array_splice($this->tokens, $i, 0, $badCharTokens);
                 $numTokens += \count($badCharTokens);
@@ -456,7 +456,7 @@ 
                 $clashingToken = $usedTokenIds[$tokenId] ?? null;
                 if ($clashingToken !== null) {
                     throw new \Error(sprintf(
-                        'Token %s has same ID as token %s, ' .
+                        'Token %s has same ID as token %s, '.
                         'you may be using a library with broken token emulation',
                         $token, $clashingToken
                     ));
@@ -499,17 +499,17 @@ 
             if (\T_DOUBLE_COLON === $i) {
                 // T_DOUBLE_COLON is equivalent to T_PAAMAYIM_NEKUDOTAYIM
                 $tokenMap[$i] = Tokens::T_PAAMAYIM_NEKUDOTAYIM;
-            } elseif(\T_OPEN_TAG_WITH_ECHO === $i) {
+            } elseif (\T_OPEN_TAG_WITH_ECHO === $i) {
                 // T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
                 $tokenMap[$i] = Tokens::T_ECHO;
-            } elseif(\T_CLOSE_TAG === $i) {
+            } elseif (\T_CLOSE_TAG === $i) {
                 // T_CLOSE_TAG is equivalent to ';'
                 $tokenMap[$i] = ord(';');
             } elseif ('UNKNOWN' !== $name = token_name($i)) {
                 if ('T_HASHBANG' === $name) {
                     // HHVM uses a special token for #! hashbang lines
                     $tokenMap[$i] = Tokens::T_INLINE_HTML;
-                } elseif (defined($name = Tokens::class . '::' . $name)) {
+                } elseif (defined($name = Tokens::class.'::'.$name)) {
                     // Other tokens can be mapped directly
                     $tokenMap[$i] = constant($name);
                 }

Braces +1 added lines, -2 removed lines

@@ -4,8 +4,7 @@
 
 use PhpParser\Parser\Tokens;
 
-class Lexer
-{
+class Lexer {
     protected $code;
     protected $tokens;
     protected $pos;