isophonics-drupal-site: vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php comparison

comparison vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php @ 13:5fb285c0d0e3

Update Drupal core to 8.4.7 via Composer. Security update; I *think* we've been lucky to get away with this so far, as we don't support self-registration which seems to be used by the so-called "drupalgeddon 2" attack that 8.4.5 was vulnerable to.

author	Chris Cannam
date	Mon, 23 Apr 2018 09:33:26 +0100
parents	4c8ae668cc8c
children	c2387f117808

comparison

equal deleted inserted replaced

-:7a779792577d
+:5fb285c0d0e3
-<?php
+<?php declare(strict_types=1);
 namespace PhpParser;
 /*
 * This parser is based on a skeleton written by Moriyoshi Koizumi, which in
 * turn is based on work by Masato Bito.
 */
+use PhpParser\Node\Expr;
 use PhpParser\Node\Name;
 use PhpParser\Node\Param;
 use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\Interface_;
 use PhpParser\Node\Stmt\Namespace_;
 use PhpParser\Node\Stmt\Property;
 use PhpParser\Node\Stmt\TryCatch;
 use PhpParser\Node\Stmt\UseUse;
+use PhpParser\Node\VarLikeIdentifier;
 abstract class ParserAbstract implements Parser
 {
 const SYMBOL_NONE = -1;
 protected $defaultAction;
 /** @var int Rule number signifying that an unexpected token was encountered */
 protected $unexpectedTokenRule;
 protected $YY2TBLSTATE;
-protected $YYNLSTATES;
+/** @var int Number of non-leaf states */
+protected $numNonLeafStates;
-/** @var array Map of lexer tokens to internal symbols */
+/** @var int[] Map of lexer tokens to internal symbols */
 protected $tokenToSymbol;
-/** @var array Map of symbols to their names */
+/** @var string[] Map of symbols to their names */
 protected $symbolToName;
 /** @var array Names of the production rules (only necessary for debugging) */
 protected $productions;
-/** @var array Map of states to a displacement into the $action table. The corresponding action for this
+/** @var int[] Map of states to a displacement into the $action table. The corresponding action for this
 *             state/symbol pair is $action[$actionBase[$state] + $symbol]. If $actionBase[$state] is 0, the
 action is defaulted, i.e. $actionDefault[$state] should be used instead. */
 protected $actionBase;
-/** @var array Table of actions. Indexed according to $actionBase comment. */
+/** @var int[] Table of actions. Indexed according to $actionBase comment. */
 protected $action;
-/** @var array Table indexed analogously to $action. If $actionCheck[$actionBase[$state] + $symbol] != $symbol
+/** @var int[] Table indexed analogously to $action. If $actionCheck[$actionBase[$state] + $symbol] != $symbol
 *             then the action is defaulted, i.e. $actionDefault[$state] should be used instead. */
 protected $actionCheck;
-/** @var array Map of states to their default action */
+/** @var int[] Map of states to their default action */
 protected $actionDefault;
+/** @var callable[] Semantic action callbacks */
-/** @var array Map of non-terminals to a displacement into the $goto table. The corresponding goto state for this
+protected $reduceCallbacks;
+/** @var int[] Map of non-terminals to a displacement into the $goto table. The corresponding goto state for this
 *             non-terminal/state pair is $goto[$gotoBase[$nonTerminal] + $state] (unless defaulted) */
 protected $gotoBase;
-/** @var array Table of states to goto after reduction. Indexed according to $gotoBase comment. */
+/** @var int[] Table of states to goto after reduction. Indexed according to $gotoBase comment. */
 protected $goto;
-/** @var array Table indexed analogously to $goto. If $gotoCheck[$gotoBase[$nonTerminal] + $state] != $nonTerminal
+/** @var int[] Table indexed analogously to $goto. If $gotoCheck[$gotoBase[$nonTerminal] + $state] != $nonTerminal
 *             then the goto state is defaulted, i.e. $gotoDefault[$nonTerminal] should be used. */
 protected $gotoCheck;
-/** @var array Map of non-terminals to the default state to goto after their reduction */
+/** @var int[] Map of non-terminals to the default state to goto after their reduction */
 protected $gotoDefault;
-/** @var array Map of rules to the non-terminal on their left-hand side, i.e. the non-terminal to use for
+/** @var int[] Map of rules to the non-terminal on their left-hand side, i.e. the non-terminal to use for
 *             determining the state to goto after reduction. */
 protected $ruleToNonTerminal;
-/** @var array Map of rules to the length of their right-hand side, which is the number of elements that have to
+/** @var int[] Map of rules to the length of their right-hand side, which is the number of elements that have to
 *             be popped from the stack(s) on reduction. */
 protected $ruleToLength;
 /*
 * The following members are part of the parser state:
 /** @var Lexer Lexer that is used when parsing */
 protected $lexer;
 /** @var mixed Temporary value containing the result of last semantic action (reduction) */
 protected $semValue;
-/** @var int Position in stacks (state stack, semantic value stack, attribute stack) */
-protected $stackPos;
 /** @var array Semantic value stack (contains values of tokens and semantic action results) */
 protected $semStack;
 /** @var array[] Start attribute stack */
 protected $startAttributeStack;
 /** @var array[] End attribute stack */
 protected $errors;
 /** @var int Error state, used to avoid error floods */
 protected $errorState;
 /**
+* Initialize $reduceCallbacks map.
+*/
+abstract protected function initReduceCallbacks();
+/**
 * Creates a parser instance.
 *
+* Options: Currently none.
+*
 * @param Lexer $lexer A lexer
-* @param array $options Options array. Currently no options are supported.
+* @param array $options Options array.
 */
-public function __construct(Lexer $lexer, array $options = array()) {
+public function __construct(Lexer $lexer, array $options = []) {
 $this->lexer = $lexer;
-$this->errors = array();
+$this->errors = [];
 if (isset($options['throwOnError'])) {
 throw new \LogicException(
 '"throwOnError" is no longer supported, use "errorHandler" instead');
 }
+$this->initReduceCallbacks();
 }
 /**
 * Parses PHP code into a node tree.
 *
 *
 * @param string $code The source code to parse
 * @param ErrorHandler|null $errorHandler Error handler to use for lexer/parser errors, defaults
 *                                        to ErrorHandler\Throwing.
 *
-* @return Node[]|null Array of statements (or null if the 'throwOnError' option is disabled and the parser was
+* @return Node\Stmt[]|null Array of statements (or null non-throwing error handler is used and
-*                     unable to recover from an error).
+*                          the parser was unable to recover from an error).
 */
-public function parse($code, ErrorHandler $errorHandler = null) {
+public function parse(string $code, ErrorHandler $errorHandler = null) {
 $this->errorHandler = $errorHandler ?: new ErrorHandler\Throwing;
-// Initialize the lexer
 $this->lexer->startLexing($code, $this->errorHandler);
+$result = $this->doParse();
+// Clear out some of the interior state, so we don't hold onto unnecessary
+// memory between uses of the parser
+$this->startAttributeStack = [];
+$this->endAttributeStack = [];
+$this->semStack = [];
+$this->semValue = null;
+return $result;
+}
+protected function doParse() {
 // We start off with no lookahead-token
 $symbol = self::SYMBOL_NONE;
 // The attributes for a node are taken from the first and last token of the node.
 // From the first token only the startAttributes are taken and from the last only
 // the endAttributes. Both are merged using the array union operator (+).
-$startAttributes = '*POISON';
+$startAttributes = [];
-$endAttributes = '*POISON';
+$endAttributes = [];
 $this->endAttributes = $endAttributes;
 // Keep stack of start and end attributes
-$this->startAttributeStack = array();
+$this->startAttributeStack = [];
-$this->endAttributeStack = array($endAttributes);
+$this->endAttributeStack = [$endAttributes];
 // Start off in the initial state and keep a stack of previous states
 $state = 0;
-$stateStack = array($state);
+$stateStack = [$state];
 // Semantic value stack (contains values of tokens and semantic action results)
-$this->semStack = array();
+$this->semStack = [];
 // Current position in the stack(s)
-$this->stackPos = 0;
+$stackPos = 0;
 $this->errorState = 0;
 for (;;) {
 //$this->traceNewState($state, $symbol);
-if ($this->actionBase[$state] == 0) {
+if ($this->actionBase[$state] === 0) {
 $rule = $this->actionDefault[$state];
 } else {
 if ($symbol === self::SYMBOL_NONE) {
 // Fetch the next token id from the lexer and fetch additional info by-ref.
 // The end attributes are fetched into a temporary variable and only set once the token is really
 ));
 }
 // This is necessary to assign some meaningful attributes to /* empty */ productions. They'll get
 // the attributes of the next token, even though they don't contain it themselves.
-$this->startAttributeStack[$this->stackPos+1] = $startAttributes;
+$this->startAttributeStack[$stackPos+1] = $startAttributes;
-$this->endAttributeStack[$this->stackPos+1] = $endAttributes;
+$this->endAttributeStack[$stackPos+1] = $endAttributes;
 $this->lookaheadStartAttributes = $startAttributes;
 //$this->traceRead($symbol);
 }
 $idx = $this->actionBase[$state] + $symbol;
-if ((($idx >= 0 && $idx < $this->actionTableSize && $this->actionCheck[$idx] == $symbol)
+if ((($idx >= 0 && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol)
 || ($state < $this->YY2TBLSTATE
-&& ($idx = $this->actionBase[$state + $this->YYNLSTATES] + $symbol) >= 0
+&& ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $symbol) >= 0
-&& $idx < $this->actionTableSize && $this->actionCheck[$idx] == $symbol))
+&& $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol))
-&& ($action = $this->action[$idx]) != $this->defaultAction) {
+&& ($action = $this->action[$idx]) !== $this->defaultAction) {
 /*
-* >= YYNLSTATES: shift and reduce
+* >= numNonLeafStates: shift and reduce
 * > 0: shift
 * = 0: accept
 * < 0: reduce
 * = -YYUNEXPECTED: error
 */
 if ($action > 0) {
 /* shift */
 //$this->traceShift($symbol);
-++$this->stackPos;
+++$stackPos;
-$stateStack[$this->stackPos] = $state = $action;
+$stateStack[$stackPos] = $state = $action;
-$this->semStack[$this->stackPos] = $tokenValue;
+$this->semStack[$stackPos] = $tokenValue;
-$this->startAttributeStack[$this->stackPos] = $startAttributes;
+$this->startAttributeStack[$stackPos] = $startAttributes;
-$this->endAttributeStack[$this->stackPos] = $endAttributes;
+$this->endAttributeStack[$stackPos] = $endAttributes;
 $this->endAttributes = $endAttributes;
 $symbol = self::SYMBOL_NONE;
 if ($this->errorState) {
 --$this->errorState;
 }
-if ($action < $this->YYNLSTATES) {
+if ($action < $this->numNonLeafStates) {
 continue;
 }
-/* $yyn >= YYNLSTATES means shift-and-reduce */
+/* $yyn >= numNonLeafStates means shift-and-reduce */
-$rule = $action - $this->YYNLSTATES;
+$rule = $action - $this->numNonLeafStates;
 } else {
 $rule = -$action;
 }
 } else {
 $rule = $this->actionDefault[$state];
 } elseif ($rule !== $this->unexpectedTokenRule) {
 /* reduce */
 //$this->traceReduce($rule);
 try {
-$this->{'reduceRule' . $rule}();
+$this->reduceCallbacks[$rule]($stackPos);
 } catch (Error $e) {
 if (-1 === $e->getStartLine() && isset($startAttributes['startLine'])) {
 $e->setStartLine($startAttributes['startLine']);
 }
 // Can't recover from this type of error
 return null;
 }
 /* Goto - shift nonterminal */
-$lastEndAttributes = $this->endAttributeStack[$this->stackPos];
+$lastEndAttributes = $this->endAttributeStack[$stackPos];
-$this->stackPos -= $this->ruleToLength[$rule];
+$stackPos -= $this->ruleToLength[$rule];
 $nonTerminal = $this->ruleToNonTerminal[$rule];
-$idx = $this->gotoBase[$nonTerminal] + $stateStack[$this->stackPos];
+$idx = $this->gotoBase[$nonTerminal] + $stateStack[$stackPos];
-if ($idx >= 0 && $idx < $this->gotoTableSize && $this->gotoCheck[$idx] == $nonTerminal) {
+if ($idx >= 0 && $idx < $this->gotoTableSize && $this->gotoCheck[$idx] === $nonTerminal) {
 $state = $this->goto[$idx];
 } else {
 $state = $this->gotoDefault[$nonTerminal];
 }
-++$this->stackPos;
+++$stackPos;
-$stateStack[$this->stackPos]     = $state;
+$stateStack[$stackPos]     = $state;
-$this->semStack[$this->stackPos] = $this->semValue;
+$this->semStack[$stackPos] = $this->semValue;
-$this->endAttributeStack[$this->stackPos] = $lastEndAttributes;
+$this->endAttributeStack[$stackPos] = $lastEndAttributes;
 } else {
 /* error */
 switch ($this->errorState) {
 case 0:
 $msg = $this->getErrorMessage($symbol, $state);
 $this->errorState = 3;
 // Pop until error-expecting state uncovered
 while (!(
 (($idx = $this->actionBase[$state] + $this->errorSymbol) >= 0
-&& $idx < $this->actionTableSize && $this->actionCheck[$idx] == $this->errorSymbol)
+&& $idx < $this->actionTableSize && $this->actionCheck[$idx] === $this->errorSymbol)
 || ($state < $this->YY2TBLSTATE
-&& ($idx = $this->actionBase[$state + $this->YYNLSTATES] + $this->errorSymbol) >= 0
+&& ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $this->errorSymbol) >= 0
-&& $idx < $this->actionTableSize && $this->actionCheck[$idx] == $this->errorSymbol)
+&& $idx < $this->actionTableSize && $this->actionCheck[$idx] === $this->errorSymbol)
-) || ($action = $this->action[$idx]) == $this->defaultAction) { // Not totally sure about this
+) || ($action = $this->action[$idx]) === $this->defaultAction) { // Not totally sure about this
-if ($this->stackPos <= 0) {
+if ($stackPos <= 0) {
 // Could not recover from error
 return null;
 }
-$state = $stateStack[--$this->stackPos];
+$state = $stateStack[--$stackPos];
 //$this->tracePop($state);
 }
 //$this->traceShift($this->errorSymbol);
-++$this->stackPos;
+++$stackPos;
-$stateStack[$this->stackPos] = $state = $action;
+$stateStack[$stackPos] = $state = $action;
 // We treat the error symbol as being empty, so we reset the end attributes
 // to the end attributes of the last non-error symbol
-$this->endAttributeStack[$this->stackPos] = $this->endAttributeStack[$this->stackPos - 1];
+$this->endAttributeStack[$stackPos] = $this->endAttributeStack[$stackPos - 1];
-$this->endAttributes = $this->endAttributeStack[$this->stackPos - 1];
+$this->endAttributes = $this->endAttributeStack[$stackPos - 1];
 break;
 case 3:
 if ($symbol === 0) {
 // Reached EOF without recovering from error
 $symbol = self::SYMBOL_NONE;
 break 2;
 }
 }
-if ($state < $this->YYNLSTATES) {
+if ($state < $this->numNonLeafStates) {
 break;
 }
-/* >= YYNLSTATES means shift-and-reduce */
+/* >= numNonLeafStates means shift-and-reduce */
-$rule = $state - $this->YYNLSTATES;
+$rule = $state - $this->numNonLeafStates;
 }
 }
 throw new \RuntimeException('Reached end of parser loop');
 }
 protected function emitError(Error $error) {
 $this->errorHandler->handleError($error);
 }
-protected function getErrorMessage($symbol, $state) {
+/**
+* Format error message including expected tokens.
+*
+* @param int $symbol Unexpected symbol
+* @param int $state  State at time of error
+*
+* @return string Formatted error message
+*/
+protected function getErrorMessage(int $symbol, int $state) : string {
 $expectedString = '';
 if ($expected = $this->getExpectedTokens($state)) {
 $expectedString = ', expecting ' . implode(' or ', $expected);
 }
 return 'Syntax error, unexpected ' . $this->symbolToName[$symbol] . $expectedString;
 }
-protected function getExpectedTokens($state) {
+/**
-$expected = array();
+* Get limited number of expected tokens in given state.
+*
+* @param int $state State
+*
+* @return string[] Expected tokens. If too many, an empty array is returned.
+*/
+protected function getExpectedTokens(int $state) : array {
+$expected = [];
 $base = $this->actionBase[$state];
 foreach ($this->symbolToName as $symbol => $name) {
 $idx = $base + $symbol;
 if ($idx >= 0 && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol
 || $state < $this->YY2TBLSTATE
-&& ($idx = $this->actionBase[$state + $this->YYNLSTATES] + $symbol) >= 0
+&& ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $symbol) >= 0
 && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol
 ) {
-if ($this->action[$idx] != $this->unexpectedTokenRule
+if ($this->action[$idx] !== $this->unexpectedTokenRule
-&& $this->action[$idx] != $this->defaultAction
+&& $this->action[$idx] !== $this->defaultAction
-&& $symbol != $this->errorSymbol
+&& $symbol !== $this->errorSymbol
 ) {
-if (count($expected) == 4) {
+if (count($expected) === 4) {
 /* Too many expected tokens */
-return array();
+return [];
 }
 $expected[] = $name;
 }
 }
 */
 /**
 * Moves statements of semicolon-style namespaces into $ns->stmts and checks various error conditions.
 *
-* @param Node[] $stmts
+* @param Node\Stmt[] $stmts
-* @return Node[]
+* @return Node\Stmt[]
 */
-protected function handleNamespaces(array $stmts) {
+protected function handleNamespaces(array $stmts) : array {
 $hasErrored = false;
 $style = $this->getNamespacingStyle($stmts);
 if (null === $style) {
 // not namespaced, nothing to do
 return $stmts;
 }
 }
 return $stmts;
 } else {
 // For semicolon namespaces we have to move the statements after a namespace declaration into ->stmts
-$resultStmts = array();
+$resultStmts = [];
 $targetStmts =& $resultStmts;
+$lastNs = null;
 foreach ($stmts as $stmt) {
 if ($stmt instanceof Node\Stmt\Namespace_) {
+if ($lastNs !== null) {
+$this->fixupNamespaceAttributes($lastNs);
+}
 if ($stmt->stmts === null) {
-$stmt->stmts = array();
+$stmt->stmts = [];
 $targetStmts =& $stmt->stmts;
 $resultStmts[] = $stmt;
 } else {
 // This handles the invalid case of mixed style namespaces
 $resultStmts[] = $stmt;
 $targetStmts =& $resultStmts;
 }
+$lastNs = $stmt;
 } elseif ($stmt instanceof Node\Stmt\HaltCompiler) {
 // __halt_compiler() is not moved into the namespace
 $resultStmts[] = $stmt;
 } else {
 $targetStmts[] = $stmt;
 }
 }
+if ($lastNs !== null) {
+$this->fixupNamespaceAttributes($lastNs);
+}
 return $resultStmts;
 }
 }
+private function fixupNamespaceAttributes(Node\Stmt\Namespace_ $stmt) {
+// We moved the statements into the namespace node, as such the end of the namespace node
+// needs to be extended to the end of the statements.
+if (empty($stmt->stmts)) {
+return;
+}
+// We only move the builtin end attributes here. This is the best we can do with the
+// knowledge we have.
+$endAttributes = ['endLine', 'endFilePos', 'endTokenPos'];
+$lastStmt = $stmt->stmts[count($stmt->stmts) - 1];
+foreach ($endAttributes as $endAttribute) {
+if ($lastStmt->hasAttribute($endAttribute)) {
+$stmt->setAttribute($endAttribute, $lastStmt->getAttribute($endAttribute));
+}
+}
+}
+/**
+* Determine namespacing style (semicolon or brace)
+*
+* @param Node[] $stmts Top-level statements.
+*
+* @return null|string One of "semicolon", "brace" or null (no namespaces)
+*/
 private function getNamespacingStyle(array $stmts) {
 $style = null;
 $hasNotAllowedStmts = false;
 foreach ($stmts as $i => $stmt) {
 if ($stmt instanceof Node\Stmt\Namespace_) {
 || $stmt instanceof Node\Stmt\Nop) {
 continue;
 }
 /* There may be a hashbang line at the very start of the file */
-if ($i == 0 && $stmt instanceof Node\Stmt\InlineHTML && preg_match('/\A#!.*\r?\n\z/', $stmt->value)) {
+if ($i === 0 && $stmt instanceof Node\Stmt\InlineHTML && preg_match('/\A#!.*\r?\n\z/', $stmt->value)) {
 continue;
 }
 /* Everything else if forbidden before namespace declarations */
 $hasNotAllowedStmts = true;
 }
 return $style;
+}
+/**
+* Fix up parsing of static property calls in PHP 5.
+*
+* In PHP 5 A::$b[c][d] and A::$b[c][d]() have very different interpretation. The former is
+* interpreted as (A::$b)[c][d], while the latter is the same as A::{$b[c][d]}(). We parse the
+* latter as the former initially and this method fixes the AST into the correct form when we
+* encounter the "()".
+*
+* @param  Node\Expr\StaticPropertyFetch|Node\Expr\ArrayDimFetch $prop
+* @param  Node\Arg[] $args
+* @param  array      $attributes
+*
+* @return Expr\StaticCall
+*/
+protected function fixupPhp5StaticPropCall($prop, array $args, array $attributes) : Expr\StaticCall {
+if ($prop instanceof Node\Expr\StaticPropertyFetch) {
+$name = $prop->name instanceof VarLikeIdentifier
+? $prop->name->toString() : $prop->name;
+$var = new Expr\Variable($name, $prop->name->getAttributes());
+return new Expr\StaticCall($prop->class, $var, $args, $attributes);
+} elseif ($prop instanceof Node\Expr\ArrayDimFetch) {
+$tmp = $prop;
+while ($tmp->var instanceof Node\Expr\ArrayDimFetch) {
+$tmp = $tmp->var;
+}
+/** @var Expr\StaticPropertyFetch $staticProp */
+$staticProp = $tmp->var;
+// Set start attributes to attributes of innermost node
+$tmp = $prop;
+$this->fixupStartAttributes($tmp, $staticProp->name);
+while ($tmp->var instanceof Node\Expr\ArrayDimFetch) {
+$tmp = $tmp->var;
+$this->fixupStartAttributes($tmp, $staticProp->name);
+}
+$name = $staticProp->name instanceof VarLikeIdentifier
+? $staticProp->name->toString() : $staticProp->name;
+$tmp->var = new Expr\Variable($name, $staticProp->name->getAttributes());
+return new Expr\StaticCall($staticProp->class, $prop, $args, $attributes);
+} else {
+throw new \Exception;
+}
+}
+protected function fixupStartAttributes(Node $to, Node $from) {
+$startAttributes = ['startLine', 'startFilePos', 'startTokenPos'];
+foreach ($startAttributes as $startAttribute) {
+if ($from->hasAttribute($startAttribute)) {
+$to->setAttribute($startAttribute, $from->getAttribute($startAttribute));
+}
+}
 }
 protected function handleBuiltinTypes(Name $name) {
 $scalarTypes = [
 'bool'     => true,
 if (!$name->isUnqualified()) {
 return $name;
 }
-$lowerName = strtolower($name->toString());
+$lowerName = $name->toLowerString();
-return isset($scalarTypes[$lowerName]) ? $lowerName : $name;
+if (!isset($scalarTypes[$lowerName])) {
-}
+return $name;
+}
-protected static $specialNames = array(
-'self'   => true,
+return new Node\Identifier($lowerName, $name->getAttributes());
-'parent' => true,
+}
-'static' => true,
-);
+/**
+* Get combined start and end attributes at a stack location
-protected function getAttributesAt($pos) {
+*
+* @param int $pos Stack location
+*
+* @return array Combined start and end attributes
+*/
+protected function getAttributesAt(int $pos) : array {
 return $this->startAttributeStack[$pos] + $this->endAttributeStack[$pos];
 }
 protected function parseLNumber($str, $attributes, $allowInvalidOctal = false) {
 try {
 // Use dummy value
 return new LNumber(0, $attributes);
 }
 }
-protected function parseNumString($str, $attributes) {
+/**
+* Parse a T_NUM_STRING token into either an integer or string node.
+*
+* @param string $str        Number string
+* @param array  $attributes Attributes
+*
+* @return LNumber|String_ Integer or string node.
+*/
+protected function parseNumString(string $str, array $attributes) {
 if (!preg_match('/^(?:0|-?[1-9][0-9]*)$/', $str)) {
 return new String_($str, $attributes);
 }
 $num = +$str;
 ));
 }
 }
 protected function checkNamespace(Namespace_ $node) {
-if (isset(self::$specialNames[strtolower($node->name)])) {
+if ($node->name && $node->name->isSpecialClassName()) {
 $this->emitError(new Error(
 sprintf('Cannot use \'%s\' as namespace name', $node->name),
 $node->name->getAttributes()
 ));
 }
 }
 }
 }
 protected function checkClass(Class_ $node, $namePos) {
-if (null !== $node->name && isset(self::$specialNames[strtolower($node->name)])) {
+if (null !== $node->name && $node->name->isSpecialClassName()) {
 $this->emitError(new Error(
 sprintf('Cannot use \'%s\' as class name as it is reserved', $node->name),
 $this->getAttributesAt($namePos)
 ));
 }
-if (isset(self::$specialNames[strtolower($node->extends)])) {
+if ($node->extends && $node->extends->isSpecialClassName()) {
 $this->emitError(new Error(
 sprintf('Cannot use \'%s\' as class name as it is reserved', $node->extends),
 $node->extends->getAttributes()
 ));
 }
 foreach ($node->implements as $interface) {
-if (isset(self::$specialNames[strtolower($interface)])) {
+if ($interface->isSpecialClassName()) {
 $this->emitError(new Error(
 sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
 $interface->getAttributes()
 ));
 }
 }
 }
 protected function checkInterface(Interface_ $node, $namePos) {
-if (null !== $node->name && isset(self::$specialNames[strtolower($node->name)])) {
+if (null !== $node->name && $node->name->isSpecialClassName()) {
 $this->emitError(new Error(
 sprintf('Cannot use \'%s\' as class name as it is reserved', $node->name),
 $this->getAttributesAt($namePos)
 ));
 }
 foreach ($node->extends as $interface) {
-if (isset(self::$specialNames[strtolower($interface)])) {
+if ($interface->isSpecialClassName()) {
 $this->emitError(new Error(
 sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
 $interface->getAttributes()
 ));
 }
 }
 }
 protected function checkClassMethod(ClassMethod $node, $modifierPos) {
 if ($node->flags & Class_::MODIFIER_STATIC) {
-switch (strtolower($node->name)) {
+switch ($node->name->toLowerString()) {
 case '__construct':
 $this->emitError(new Error(
 sprintf('Constructor %s() cannot be static', $node->name),
 $this->getAttributesAt($modifierPos)));
 break;
 $this->getAttributesAt($modifierPos)));
 }
 }
 protected function checkUseUse(UseUse $node, $namePos) {
-if ('self' == strtolower($node->alias) || 'parent' == strtolower($node->alias)) {
+if ($node->alias && $node->alias->isSpecialClassName()) {
 $this->emitError(new Error(
 sprintf(
 'Cannot use %s as %s because \'%2$s\' is a special class name',
 $node->name, $node->alias
 ),

Mercurial > hg > isophonics-drupal-site

comparison vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php @ 13:5fb285c0d0e3