Namespaces

Classes

Interfaces

Exceptions

1: <?php declare(strict_types=1);
2:
3: namespace PhpParser;
4:
5: /*
6: * This parser is based on a skeleton written by Moriyoshi Koizumi, which in
7: * turn is based on work by Masato Bito.
8: */
9:
10: use PhpParser\Node\Arg;
11: use PhpParser\Node\Expr;
12: use PhpParser\Node\Expr\Array_;
13: use PhpParser\Node\Expr\Cast\Double;
14: use PhpParser\Node\Identifier;
15: use PhpParser\Node\InterpolatedStringPart;
16: use PhpParser\Node\Name;
17: use PhpParser\Node\Param;
18: use PhpParser\Node\PropertyHook;
19: use PhpParser\Node\Scalar\InterpolatedString;
20: use PhpParser\Node\Scalar\Int_;
21: use PhpParser\Node\Scalar\String_;
22: use PhpParser\Node\Stmt;
23: use PhpParser\Node\Stmt\Class_;
24: use PhpParser\Node\Stmt\ClassConst;
25: use PhpParser\Node\Stmt\ClassMethod;
26: use PhpParser\Node\Stmt\Const_;
27: use PhpParser\Node\Stmt\Else_;
28: use PhpParser\Node\Stmt\ElseIf_;
29: use PhpParser\Node\Stmt\Enum_;
30: use PhpParser\Node\Stmt\Interface_;
31: use PhpParser\Node\Stmt\Namespace_;
32: use PhpParser\Node\Stmt\Nop;
33: use PhpParser\Node\Stmt\Property;
34: use PhpParser\Node\Stmt\TryCatch;
35: use PhpParser\Node\UseItem;
36: use PhpParser\Node\VarLikeIdentifier;
37: use PhpParser\NodeVisitor\CommentAnnotatingVisitor;
38:
39: abstract class ParserAbstract implements Parser {
40: private const SYMBOL_NONE = -1;
41:
42: /** @var Lexer Lexer that is used when parsing */
43: protected Lexer $lexer;
44: /** @var PhpVersion PHP version to target on a best-effort basis */
45: protected PhpVersion $phpVersion;
46:
47: /*
48: * The following members will be filled with generated parsing data:
49: */
50:
51: /** @var int Size of $tokenToSymbol map */
52: protected int $tokenToSymbolMapSize;
53: /** @var int Size of $action table */
54: protected int $actionTableSize;
55: /** @var int Size of $goto table */
56: protected int $gotoTableSize;
57:
58: /** @var int Symbol number signifying an invalid token */
59: protected int $invalidSymbol;
60: /** @var int Symbol number of error recovery token */
61: protected int $errorSymbol;
62: /** @var int Action number signifying default action */
63: protected int $defaultAction;
64: /** @var int Rule number signifying that an unexpected token was encountered */
65: protected int $unexpectedTokenRule;
66:
67: protected int $YY2TBLSTATE;
68: /** @var int Number of non-leaf states */
69: protected int $numNonLeafStates;
70:
71: /** @var int[] Map of PHP token IDs to internal symbols */
72: protected array $phpTokenToSymbol;
73: /** @var array<int, bool> Map of PHP token IDs to drop */
74: protected array $dropTokens;
75: /** @var int[] Map of external symbols (static::T_*) to internal symbols */
76: protected array $tokenToSymbol;
77: /** @var string[] Map of symbols to their names */
78: protected array $symbolToName;
79: /** @var array<int, string> Names of the production rules (only necessary for debugging) */
80: protected array $productions;
81:
82: /** @var int[] Map of states to a displacement into the $action table. The corresponding action for this
83: * state/symbol pair is $action[$actionBase[$state] + $symbol]. If $actionBase[$state] is 0, the
84: * action is defaulted, i.e. $actionDefault[$state] should be used instead. */
85: protected array $actionBase;
86: /** @var int[] Table of actions. Indexed according to $actionBase comment. */
87: protected array $action;
88: /** @var int[] Table indexed analogously to $action. If $actionCheck[$actionBase[$state] + $symbol] != $symbol
89: * then the action is defaulted, i.e. $actionDefault[$state] should be used instead. */
90: protected array $actionCheck;
91: /** @var int[] Map of states to their default action */
92: protected array $actionDefault;
93: /** @var callable[] Semantic action callbacks */
94: protected array $reduceCallbacks;
95:
96: /** @var int[] Map of non-terminals to a displacement into the $goto table. The corresponding goto state for this
97: * non-terminal/state pair is $goto[$gotoBase[$nonTerminal] + $state] (unless defaulted) */
98: protected array $gotoBase;
99: /** @var int[] Table of states to goto after reduction. Indexed according to $gotoBase comment. */
100: protected array $goto;
101: /** @var int[] Table indexed analogously to $goto. If $gotoCheck[$gotoBase[$nonTerminal] + $state] != $nonTerminal
102: * then the goto state is defaulted, i.e. $gotoDefault[$nonTerminal] should be used. */
103: protected array $gotoCheck;
104: /** @var int[] Map of non-terminals to the default state to goto after their reduction */
105: protected array $gotoDefault;
106:
107: /** @var int[] Map of rules to the non-terminal on their left-hand side, i.e. the non-terminal to use for
108: * determining the state to goto after reduction. */
109: protected array $ruleToNonTerminal;
110: /** @var int[] Map of rules to the length of their right-hand side, which is the number of elements that have to
111: * be popped from the stack(s) on reduction. */
112: protected array $ruleToLength;
113:
114: /*
115: * The following members are part of the parser state:
116: */
117:
118: /** @var mixed Temporary value containing the result of last semantic action (reduction) */
119: protected $semValue;
120: /** @var mixed[] Semantic value stack (contains values of tokens and semantic action results) */
121: protected array $semStack;
122: /** @var int[] Token start position stack */
123: protected array $tokenStartStack;
124: /** @var int[] Token end position stack */
125: protected array $tokenEndStack;
126:
127: /** @var ErrorHandler Error handler */
128: protected ErrorHandler $errorHandler;
129: /** @var int Error state, used to avoid error floods */
130: protected int $errorState;
131:
132: /** @var \SplObjectStorage<Array_, null>|null Array nodes created during parsing, for postprocessing of empty elements. */
133: protected ?\SplObjectStorage $createdArrays;
134:
135: /** @var \SplObjectStorage<Expr\ArrowFunction, null>|null
136: * Arrow functions that are wrapped in parentheses, to enforce the pipe operator parentheses requirements.
137: */
138: protected ?\SplObjectStorage $parenthesizedArrowFunctions;
139:
140: /** @var Token[] Tokens for the current parse */
141: protected array $tokens;
142: /** @var int Current position in token array */
143: protected int $tokenPos;
144:
145: /**
146: * Initialize $reduceCallbacks map.
147: */
148: abstract protected function initReduceCallbacks(): void;
149:
150: /**
151: * Creates a parser instance.
152: *
153: * Options:
154: * * phpVersion: ?PhpVersion,
155: *
156: * @param Lexer $lexer A lexer
157: * @param PhpVersion $phpVersion PHP version to target, defaults to latest supported. This
158: * option is best-effort: Even if specified, parsing will generally assume the latest
159: * supported version and only adjust behavior in minor ways, for example by omitting
160: * errors in older versions and interpreting type hints as a name or identifier depending
161: * on version.
162: */
163: public function __construct(Lexer $lexer, ?PhpVersion $phpVersion = null) {
164: $this->lexer = $lexer;
165: $this->phpVersion = $phpVersion ?? PhpVersion::getNewestSupported();
166:
167: $this->initReduceCallbacks();
168: $this->phpTokenToSymbol = $this->createTokenMap();
169: $this->dropTokens = array_fill_keys(
170: [\T_WHITESPACE, \T_OPEN_TAG, \T_COMMENT, \T_DOC_COMMENT, \T_BAD_CHARACTER], true
171: );
172: }
173:
174: /**
175: * Parses PHP code into a node tree.
176: *
177: * If a non-throwing error handler is used, the parser will continue parsing after an error
178: * occurred and attempt to build a partial AST.
179: *
180: * @param string $code The source code to parse
181: * @param ErrorHandler|null $errorHandler Error handler to use for lexer/parser errors, defaults
182: * to ErrorHandler\Throwing.
183: *
184: * @return Node\Stmt[]|null Array of statements (or null non-throwing error handler is used and
185: * the parser was unable to recover from an error).
186: */
187: public function parse(string $code, ?ErrorHandler $errorHandler = null): ?array {
188: $this->errorHandler = $errorHandler ?: new ErrorHandler\Throwing();
189: $this->createdArrays = new \SplObjectStorage();
190: $this->parenthesizedArrowFunctions = new \SplObjectStorage();
191:
192: $this->tokens = $this->lexer->tokenize($code, $this->errorHandler);
193: $result = $this->doParse();
194:
195: // Report errors for any empty elements used inside arrays. This is delayed until after the main parse,
196: // because we don't know a priori whether a given array expression will be used in a destructuring context
197: // or not.
198: foreach ($this->createdArrays as $node) {
199: foreach ($node->items as $item) {
200: if ($item->value instanceof Expr\Error) {
201: $this->errorHandler->handleError(
202: new Error('Cannot use empty array elements in arrays', $item->getAttributes()));
203: }
204: }
205: }
206:
207: // Clear out some of the interior state, so we don't hold onto unnecessary
208: // memory between uses of the parser
209: $this->tokenStartStack = [];
210: $this->tokenEndStack = [];
211: $this->semStack = [];
212: $this->semValue = null;
213: $this->createdArrays = null;
214: $this->parenthesizedArrowFunctions = null;
215:
216: if ($result !== null) {
217: $traverser = new NodeTraverser(new CommentAnnotatingVisitor($this->tokens));
218: $traverser->traverse($result);
219: }
220:
221: return $result;
222: }
223:
224: public function getTokens(): array {
225: return $this->tokens;
226: }
227:
228: /** @return Stmt[]|null */
229: protected function doParse(): ?array {
230: // We start off with no lookahead-token
231: $symbol = self::SYMBOL_NONE;
232: $tokenValue = null;
233: $this->tokenPos = -1;
234:
235: // Keep stack of start and end attributes
236: $this->tokenStartStack = [];
237: $this->tokenEndStack = [0];
238:
239: // Start off in the initial state and keep a stack of previous states
240: $state = 0;
241: $stateStack = [$state];
242:
243: // Semantic value stack (contains values of tokens and semantic action results)
244: $this->semStack = [];
245:
246: // Current position in the stack(s)
247: $stackPos = 0;
248:
249: $this->errorState = 0;
250:
251: for (;;) {
252: //$this->traceNewState($state, $symbol);
253:
254: if ($this->actionBase[$state] === 0) {
255: $rule = $this->actionDefault[$state];
256: } else {
257: if ($symbol === self::SYMBOL_NONE) {
258: do {
259: $token = $this->tokens[++$this->tokenPos];
260: $tokenId = $token->id;
261: } while (isset($this->dropTokens[$tokenId]));
262:
263: // Map the lexer token id to the internally used symbols.
264: $tokenValue = $token->text;
265: if (!isset($this->phpTokenToSymbol[$tokenId])) {
266: throw new \RangeException(sprintf(
267: 'The lexer returned an invalid token (id=%d, value=%s)',
268: $tokenId, $tokenValue
269: ));
270: }
271: $symbol = $this->phpTokenToSymbol[$tokenId];
272:
273: //$this->traceRead($symbol);
274: }
275:
276: $idx = $this->actionBase[$state] + $symbol;
277: if ((($idx >= 0 && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol)
278: || ($state < $this->YY2TBLSTATE
279: && ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $symbol) >= 0
280: && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol))
281: && ($action = $this->action[$idx]) !== $this->defaultAction) {
282: /*
283: * >= numNonLeafStates: shift and reduce
284: * > 0: shift
285: * = 0: accept
286: * < 0: reduce
287: * = -YYUNEXPECTED: error
288: */
289: if ($action > 0) {
290: /* shift */
291: //$this->traceShift($symbol);
292:
293: ++$stackPos;
294: $stateStack[$stackPos] = $state = $action;
295: $this->semStack[$stackPos] = $tokenValue;
296: $this->tokenStartStack[$stackPos] = $this->tokenPos;
297: $this->tokenEndStack[$stackPos] = $this->tokenPos;
298: $symbol = self::SYMBOL_NONE;
299:
300: if ($this->errorState) {
301: --$this->errorState;
302: }
303:
304: if ($action < $this->numNonLeafStates) {
305: continue;
306: }
307:
308: /* $yyn >= numNonLeafStates means shift-and-reduce */
309: $rule = $action - $this->numNonLeafStates;
310: } else {
311: $rule = -$action;
312: }
313: } else {
314: $rule = $this->actionDefault[$state];
315: }
316: }
317:
318: for (;;) {
319: if ($rule === 0) {
320: /* accept */
321: //$this->traceAccept();
322: return $this->semValue;
323: }
324: if ($rule !== $this->unexpectedTokenRule) {
325: /* reduce */
326: //$this->traceReduce($rule);
327:
328: $ruleLength = $this->ruleToLength[$rule];
329: try {
330: $callback = $this->reduceCallbacks[$rule];
331: if ($callback !== null) {
332: $callback($this, $stackPos);
333: } elseif ($ruleLength > 0) {
334: $this->semValue = $this->semStack[$stackPos - $ruleLength + 1];
335: }
336: } catch (Error $e) {
337: if (-1 === $e->getStartLine()) {
338: $e->setStartLine($this->tokens[$this->tokenPos]->line);
339: }
340:
341: $this->emitError($e);
342: // Can't recover from this type of error
343: return null;
344: }
345:
346: /* Goto - shift nonterminal */
347: $lastTokenEnd = $this->tokenEndStack[$stackPos];
348: $stackPos -= $ruleLength;
349: $nonTerminal = $this->ruleToNonTerminal[$rule];
350: $idx = $this->gotoBase[$nonTerminal] + $stateStack[$stackPos];
351: if ($idx >= 0 && $idx < $this->gotoTableSize && $this->gotoCheck[$idx] === $nonTerminal) {
352: $state = $this->goto[$idx];
353: } else {
354: $state = $this->gotoDefault[$nonTerminal];
355: }
356:
357: ++$stackPos;
358: $stateStack[$stackPos] = $state;
359: $this->semStack[$stackPos] = $this->semValue;
360: $this->tokenEndStack[$stackPos] = $lastTokenEnd;
361: if ($ruleLength === 0) {
362: // Empty productions use the start attributes of the lookahead token.
363: $this->tokenStartStack[$stackPos] = $this->tokenPos;
364: }
365: } else {
366: /* error */
367: switch ($this->errorState) {
368: case 0:
369: $msg = $this->getErrorMessage($symbol, $state);
370: $this->emitError(new Error($msg, $this->getAttributesForToken($this->tokenPos)));
371: // Break missing intentionally
372: // no break
373: case 1:
374: case 2:
375: $this->errorState = 3;
376:
377: // Pop until error-expecting state uncovered
378: while (!(
379: (($idx = $this->actionBase[$state] + $this->errorSymbol) >= 0
380: && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $this->errorSymbol)
381: || ($state < $this->YY2TBLSTATE
382: && ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $this->errorSymbol) >= 0
383: && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $this->errorSymbol)
384: ) || ($action = $this->action[$idx]) === $this->defaultAction) { // Not totally sure about this
385: if ($stackPos <= 0) {
386: // Could not recover from error
387: return null;
388: }
389: $state = $stateStack[--$stackPos];
390: //$this->tracePop($state);
391: }
392:
393: //$this->traceShift($this->errorSymbol);
394: ++$stackPos;
395: $stateStack[$stackPos] = $state = $action;
396:
397: // We treat the error symbol as being empty, so we reset the end attributes
398: // to the end attributes of the last non-error symbol
399: $this->tokenStartStack[$stackPos] = $this->tokenPos;
400: $this->tokenEndStack[$stackPos] = $this->tokenEndStack[$stackPos - 1];
401: break;
402:
403: case 3:
404: if ($symbol === 0) {
405: // Reached EOF without recovering from error
406: return null;
407: }
408:
409: //$this->traceDiscard($symbol);
410: $symbol = self::SYMBOL_NONE;
411: break 2;
412: }
413: }
414:
415: if ($state < $this->numNonLeafStates) {
416: break;
417: }
418:
419: /* >= numNonLeafStates means shift-and-reduce */
420: $rule = $state - $this->numNonLeafStates;
421: }
422: }
423: }
424:
425: protected function emitError(Error $error): void {
426: $this->errorHandler->handleError($error);
427: }
428:
429: /**
430: * Format error message including expected tokens.
431: *
432: * @param int $symbol Unexpected symbol
433: * @param int $state State at time of error
434: *
435: * @return string Formatted error message
436: */
437: protected function getErrorMessage(int $symbol, int $state): string {
438: $expectedString = '';
439: if ($expected = $this->getExpectedTokens($state)) {
440: $expectedString = ', expecting ' . implode(' or ', $expected);
441: }
442:
443: return 'Syntax error, unexpected ' . $this->symbolToName[$symbol] . $expectedString;
444: }
445:
446: /**
447: * Get limited number of expected tokens in given state.
448: *
449: * @param int $state State
450: *
451: * @return string[] Expected tokens. If too many, an empty array is returned.
452: */
453: protected function getExpectedTokens(int $state): array {
454: $expected = [];
455:
456: $base = $this->actionBase[$state];
457: foreach ($this->symbolToName as $symbol => $name) {
458: $idx = $base + $symbol;
459: if ($idx >= 0 && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol
460: || $state < $this->YY2TBLSTATE
461: && ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $symbol) >= 0
462: && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol
463: ) {
464: if ($this->action[$idx] !== $this->unexpectedTokenRule
465: && $this->action[$idx] !== $this->defaultAction
466: && $symbol !== $this->errorSymbol
467: ) {
468: if (count($expected) === 4) {
469: /* Too many expected tokens */
470: return [];
471: }
472:
473: $expected[] = $name;
474: }
475: }
476: }
477:
478: return $expected;
479: }
480:
481: /**
482: * Get attributes for a node with the given start and end token positions.
483: *
484: * @param int $tokenStartPos Token position the node starts at
485: * @param int $tokenEndPos Token position the node ends at
486: * @return array<string, mixed> Attributes
487: */
488: protected function getAttributes(int $tokenStartPos, int $tokenEndPos): array {
489: $startToken = $this->tokens[$tokenStartPos];
490: $afterEndToken = $this->tokens[$tokenEndPos + 1];
491: return [
492: 'startLine' => $startToken->line,
493: 'startTokenPos' => $tokenStartPos,
494: 'startFilePos' => $startToken->pos,
495: 'endLine' => $afterEndToken->line,
496: 'endTokenPos' => $tokenEndPos,
497: 'endFilePos' => $afterEndToken->pos - 1,
498: ];
499: }
500:
501: /**
502: * Get attributes for a single token at the given token position.
503: *
504: * @return array<string, mixed> Attributes
505: */
506: protected function getAttributesForToken(int $tokenPos): array {
507: if ($tokenPos < \count($this->tokens) - 1) {
508: return $this->getAttributes($tokenPos, $tokenPos);
509: }
510:
511: // Get attributes for the sentinel token.
512: $token = $this->tokens[$tokenPos];
513: return [
514: 'startLine' => $token->line,
515: 'startTokenPos' => $tokenPos,
516: 'startFilePos' => $token->pos,
517: 'endLine' => $token->line,
518: 'endTokenPos' => $tokenPos,
519: 'endFilePos' => $token->pos,
520: ];
521: }
522:
523: /*
524: * Tracing functions used for debugging the parser.
525: */
526:
527: /*
528: protected function traceNewState($state, $symbol): void {
529: echo '% State ' . $state
530: . ', Lookahead ' . ($symbol == self::SYMBOL_NONE ? '--none--' : $this->symbolToName[$symbol]) . "\n";
531: }
532:
533: protected function traceRead($symbol): void {
534: echo '% Reading ' . $this->symbolToName[$symbol] . "\n";
535: }
536:
537: protected function traceShift($symbol): void {
538: echo '% Shift ' . $this->symbolToName[$symbol] . "\n";
539: }
540:
541: protected function traceAccept(): void {
542: echo "% Accepted.\n";
543: }
544:
545: protected function traceReduce($n): void {
546: echo '% Reduce by (' . $n . ') ' . $this->productions[$n] . "\n";
547: }
548:
549: protected function tracePop($state): void {
550: echo '% Recovering, uncovered state ' . $state . "\n";
551: }
552:
553: protected function traceDiscard($symbol): void {
554: echo '% Discard ' . $this->symbolToName[$symbol] . "\n";
555: }
556: */
557:
558: /*
559: * Helper functions invoked by semantic actions
560: */
561:
562: /**
563: * Moves statements of semicolon-style namespaces into $ns->stmts and checks various error conditions.
564: *
565: * @param Node\Stmt[] $stmts
566: * @return Node\Stmt[]
567: */
568: protected function handleNamespaces(array $stmts): array {
569: $hasErrored = false;
570: $style = $this->getNamespacingStyle($stmts);
571: if (null === $style) {
572: // not namespaced, nothing to do
573: return $stmts;
574: }
575: if ('brace' === $style) {
576: // For braced namespaces we only have to check that there are no invalid statements between the namespaces
577: $afterFirstNamespace = false;
578: foreach ($stmts as $stmt) {
579: if ($stmt instanceof Node\Stmt\Namespace_) {
580: $afterFirstNamespace = true;
581: } elseif (!$stmt instanceof Node\Stmt\HaltCompiler
582: && !$stmt instanceof Node\Stmt\Nop
583: && $afterFirstNamespace && !$hasErrored) {
584: $this->emitError(new Error(
585: 'No code may exist outside of namespace {}', $stmt->getAttributes()));
586: $hasErrored = true; // Avoid one error for every statement
587: }
588: }
589: return $stmts;
590: } else {
591: // For semicolon namespaces we have to move the statements after a namespace declaration into ->stmts
592: $resultStmts = [];
593: $targetStmts = &$resultStmts;
594: $lastNs = null;
595: foreach ($stmts as $stmt) {
596: if ($stmt instanceof Node\Stmt\Namespace_) {
597: if ($lastNs !== null) {
598: $this->fixupNamespaceAttributes($lastNs);
599: }
600: if ($stmt->stmts === null) {
601: $stmt->stmts = [];
602: $targetStmts = &$stmt->stmts;
603: $resultStmts[] = $stmt;
604: } else {
605: // This handles the invalid case of mixed style namespaces
606: $resultStmts[] = $stmt;
607: $targetStmts = &$resultStmts;
608: }
609: $lastNs = $stmt;
610: } elseif ($stmt instanceof Node\Stmt\HaltCompiler) {
611: // __halt_compiler() is not moved into the namespace
612: $resultStmts[] = $stmt;
613: } else {
614: $targetStmts[] = $stmt;
615: }
616: }
617: if ($lastNs !== null) {
618: $this->fixupNamespaceAttributes($lastNs);
619: }
620: return $resultStmts;
621: }
622: }
623:
624: private function fixupNamespaceAttributes(Node\Stmt\Namespace_ $stmt): void {
625: // We moved the statements into the namespace node, as such the end of the namespace node
626: // needs to be extended to the end of the statements.
627: if (empty($stmt->stmts)) {
628: return;
629: }
630:
631: // We only move the builtin end attributes here. This is the best we can do with the
632: // knowledge we have.
633: $endAttributes = ['endLine', 'endFilePos', 'endTokenPos'];
634: $lastStmt = $stmt->stmts[count($stmt->stmts) - 1];
635: foreach ($endAttributes as $endAttribute) {
636: if ($lastStmt->hasAttribute($endAttribute)) {
637: $stmt->setAttribute($endAttribute, $lastStmt->getAttribute($endAttribute));
638: }
639: }
640: }
641:
642: /** @return array<string, mixed> */
643: private function getNamespaceErrorAttributes(Namespace_ $node): array {
644: $attrs = $node->getAttributes();
645: // Adjust end attributes to only cover the "namespace" keyword, not the whole namespace.
646: if (isset($attrs['startLine'])) {
647: $attrs['endLine'] = $attrs['startLine'];
648: }
649: if (isset($attrs['startTokenPos'])) {
650: $attrs['endTokenPos'] = $attrs['startTokenPos'];
651: }
652: if (isset($attrs['startFilePos'])) {
653: $attrs['endFilePos'] = $attrs['startFilePos'] + \strlen('namespace') - 1;
654: }
655: return $attrs;
656: }
657:
658: /**
659: * Determine namespacing style (semicolon or brace)
660: *
661: * @param Node[] $stmts Top-level statements.
662: *
663: * @return null|string One of "semicolon", "brace" or null (no namespaces)
664: */
665: private function getNamespacingStyle(array $stmts): ?string {
666: $style = null;
667: $hasNotAllowedStmts = false;
668: foreach ($stmts as $i => $stmt) {
669: if ($stmt instanceof Node\Stmt\Namespace_) {
670: $currentStyle = null === $stmt->stmts ? 'semicolon' : 'brace';
671: if (null === $style) {
672: $style = $currentStyle;
673: if ($hasNotAllowedStmts) {
674: $this->emitError(new Error(
675: 'Namespace declaration statement has to be the very first statement in the script',
676: $this->getNamespaceErrorAttributes($stmt)
677: ));
678: }
679: } elseif ($style !== $currentStyle) {
680: $this->emitError(new Error(
681: 'Cannot mix bracketed namespace declarations with unbracketed namespace declarations',
682: $this->getNamespaceErrorAttributes($stmt)
683: ));
684: // Treat like semicolon style for namespace normalization
685: return 'semicolon';
686: }
687: continue;
688: }
689:
690: /* declare(), __halt_compiler() and nops can be used before a namespace declaration */
691: if ($stmt instanceof Node\Stmt\Declare_
692: || $stmt instanceof Node\Stmt\HaltCompiler
693: || $stmt instanceof Node\Stmt\Nop) {
694: continue;
695: }
696:
697: /* There may be a hashbang line at the very start of the file */
698: if ($i === 0 && $stmt instanceof Node\Stmt\InlineHTML && preg_match('/\A#!.*\r?\n\z/', $stmt->value)) {
699: continue;
700: }
701:
702: /* Everything else if forbidden before namespace declarations */
703: $hasNotAllowedStmts = true;
704: }
705: return $style;
706: }
707:
708: /** @return Name|Identifier */
709: protected function handleBuiltinTypes(Name $name) {
710: if (!$name->isUnqualified()) {
711: return $name;
712: }
713:
714: $lowerName = $name->toLowerString();
715: if (!$this->phpVersion->supportsBuiltinType($lowerName)) {
716: return $name;
717: }
718:
719: return new Node\Identifier($lowerName, $name->getAttributes());
720: }
721:
722: /**
723: * Get combined start and end attributes at a stack location
724: *
725: * @param int $stackPos Stack location
726: *
727: * @return array<string, mixed> Combined start and end attributes
728: */
729: protected function getAttributesAt(int $stackPos): array {
730: return $this->getAttributes($this->tokenStartStack[$stackPos], $this->tokenEndStack[$stackPos]);
731: }
732:
733: protected function getFloatCastKind(string $cast): int {
734: $cast = strtolower($cast);
735: if (strpos($cast, 'float') !== false) {
736: return Double::KIND_FLOAT;
737: }
738:
739: if (strpos($cast, 'real') !== false) {
740: return Double::KIND_REAL;
741: }
742:
743: return Double::KIND_DOUBLE;
744: }
745:
746: protected function getIntCastKind(string $cast): int {
747: $cast = strtolower($cast);
748: if (strpos($cast, 'integer') !== false) {
749: return Expr\Cast\Int_::KIND_INTEGER;
750: }
751:
752: return Expr\Cast\Int_::KIND_INT;
753: }
754:
755: protected function getBoolCastKind(string $cast): int {
756: $cast = strtolower($cast);
757: if (strpos($cast, 'boolean') !== false) {
758: return Expr\Cast\Bool_::KIND_BOOLEAN;
759: }
760:
761: return Expr\Cast\Bool_::KIND_BOOL;
762: }
763:
764: protected function getStringCastKind(string $cast): int {
765: $cast = strtolower($cast);
766: if (strpos($cast, 'binary') !== false) {
767: return Expr\Cast\String_::KIND_BINARY;
768: }
769:
770: return Expr\Cast\String_::KIND_STRING;
771: }
772:
773: /** @param array<string, mixed> $attributes */
774: protected function parseLNumber(string $str, array $attributes, bool $allowInvalidOctal = false): Int_ {
775: try {
776: return Int_::fromString($str, $attributes, $allowInvalidOctal);
777: } catch (Error $error) {
778: $this->emitError($error);
779: // Use dummy value
780: return new Int_(0, $attributes);
781: }
782: }
783:
784: /**
785: * Parse a T_NUM_STRING token into either an integer or string node.
786: *
787: * @param string $str Number string
788: * @param array<string, mixed> $attributes Attributes
789: *
790: * @return Int_|String_ Integer or string node.
791: */
792: protected function parseNumString(string $str, array $attributes) {
793: if (!preg_match('/^(?:0|-?[1-9][0-9]*)$/', $str)) {
794: return new String_($str, $attributes);
795: }
796:
797: $num = +$str;
798: if (!is_int($num)) {
799: return new String_($str, $attributes);
800: }
801:
802: return new Int_($num, $attributes);
803: }
804:
805: /** @param array<string, mixed> $attributes */
806: protected function stripIndentation(
807: string $string, int $indentLen, string $indentChar,
808: bool $newlineAtStart, bool $newlineAtEnd, array $attributes
809: ): string {
810: if ($indentLen === 0) {
811: return $string;
812: }
813:
814: $start = $newlineAtStart ? '(?:(?<=\n)|\A)' : '(?<=\n)';
815: $end = $newlineAtEnd ? '(?:(?=[\r\n])|\z)' : '(?=[\r\n])';
816: $regex = '/' . $start . '([ \t]*)(' . $end . ')?/';
817: return preg_replace_callback(
818: $regex,
819: function ($matches) use ($indentLen, $indentChar, $attributes) {
820: $prefix = substr($matches[1], 0, $indentLen);
821: if (false !== strpos($prefix, $indentChar === " " ? "\t" : " ")) {
822: $this->emitError(new Error(
823: 'Invalid indentation - tabs and spaces cannot be mixed', $attributes
824: ));
825: } elseif (strlen($prefix) < $indentLen && !isset($matches[2])) {
826: $this->emitError(new Error(
827: 'Invalid body indentation level ' .
828: '(expecting an indentation level of at least ' . $indentLen . ')',
829: $attributes
830: ));
831: }
832: return substr($matches[0], strlen($prefix));
833: },
834: $string
835: );
836: }
837:
838: /**
839: * @param string|(Expr|InterpolatedStringPart)[] $contents
840: * @param array<string, mixed> $attributes
841: * @param array<string, mixed> $endTokenAttributes
842: */
843: protected function parseDocString(
844: string $startToken, $contents, string $endToken,
845: array $attributes, array $endTokenAttributes, bool $parseUnicodeEscape
846: ): Expr {
847: $kind = strpos($startToken, "'") === false
848: ? String_::KIND_HEREDOC : String_::KIND_NOWDOC;
849:
850: $regex = '/\A[bB]?<<<[ \t]*[\'"]?([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)[\'"]?(?:\r\n|\n|\r)\z/';
851: $result = preg_match($regex, $startToken, $matches);
852: assert($result === 1);
853: $label = $matches[1];
854:
855: $result = preg_match('/\A[ \t]*/', $endToken, $matches);
856: assert($result === 1);
857: $indentation = $matches[0];
858:
859: $attributes['kind'] = $kind;
860: $attributes['docLabel'] = $label;
861: $attributes['docIndentation'] = $indentation;
862:
863: $indentHasSpaces = false !== strpos($indentation, " ");
864: $indentHasTabs = false !== strpos($indentation, "\t");
865: if ($indentHasSpaces && $indentHasTabs) {
866: $this->emitError(new Error(
867: 'Invalid indentation - tabs and spaces cannot be mixed',
868: $endTokenAttributes
869: ));
870:
871: // Proceed processing as if this doc string is not indented
872: $indentation = '';
873: }
874:
875: $indentLen = \strlen($indentation);
876: $indentChar = $indentHasSpaces ? " " : "\t";
877:
878: if (\is_string($contents)) {
879: if ($contents === '') {
880: $attributes['rawValue'] = $contents;
881: return new String_('', $attributes);
882: }
883:
884: $contents = $this->stripIndentation(
885: $contents, $indentLen, $indentChar, true, true, $attributes
886: );
887: $contents = preg_replace('~(\r\n|\n|\r)\z~', '', $contents);
888: $attributes['rawValue'] = $contents;
889:
890: if ($kind === String_::KIND_HEREDOC) {
891: $contents = String_::parseEscapeSequences($contents, null, $parseUnicodeEscape);
892: }
893:
894: return new String_($contents, $attributes);
895: } else {
896: assert(count($contents) > 0);
897: if (!$contents[0] instanceof Node\InterpolatedStringPart) {
898: // If there is no leading encapsed string part, pretend there is an empty one
899: $this->stripIndentation(
900: '', $indentLen, $indentChar, true, false, $contents[0]->getAttributes()
901: );
902: }
903:
904: $newContents = [];
905: foreach ($contents as $i => $part) {
906: if ($part instanceof Node\InterpolatedStringPart) {
907: $isLast = $i === \count($contents) - 1;
908: $part->value = $this->stripIndentation(
909: $part->value, $indentLen, $indentChar,
910: $i === 0, $isLast, $part->getAttributes()
911: );
912: if ($isLast) {
913: $part->value = preg_replace('~(\r\n|\n|\r)\z~', '', $part->value);
914: }
915: $part->setAttribute('rawValue', $part->value);
916: $part->value = String_::parseEscapeSequences($part->value, null, $parseUnicodeEscape);
917: if ('' === $part->value) {
918: continue;
919: }
920: }
921: $newContents[] = $part;
922: }
923: return new InterpolatedString($newContents, $attributes);
924: }
925: }
926:
927: protected function createCommentFromToken(Token $token, int $tokenPos): Comment {
928: assert($token->id === \T_COMMENT || $token->id == \T_DOC_COMMENT);
929: return \T_DOC_COMMENT === $token->id
930: ? new Comment\Doc($token->text, $token->line, $token->pos, $tokenPos,
931: $token->getEndLine(), $token->getEndPos() - 1, $tokenPos)
932: : new Comment($token->text, $token->line, $token->pos, $tokenPos,
933: $token->getEndLine(), $token->getEndPos() - 1, $tokenPos);
934: }
935:
936: /**
937: * Get last comment before the given token position, if any
938: */
939: protected function getCommentBeforeToken(int $tokenPos): ?Comment {
940: while (--$tokenPos >= 0) {
941: $token = $this->tokens[$tokenPos];
942: if (!isset($this->dropTokens[$token->id])) {
943: break;
944: }
945:
946: if ($token->id === \T_COMMENT || $token->id === \T_DOC_COMMENT) {
947: return $this->createCommentFromToken($token, $tokenPos);
948: }
949: }
950: return null;
951: }
952:
953: /**
954: * Create a zero-length nop to capture preceding comments, if any.
955: */
956: protected function maybeCreateZeroLengthNop(int $tokenPos): ?Nop {
957: $comment = $this->getCommentBeforeToken($tokenPos);
958: if ($comment === null) {
959: return null;
960: }
961:
962: $commentEndLine = $comment->getEndLine();
963: $commentEndFilePos = $comment->getEndFilePos();
964: $commentEndTokenPos = $comment->getEndTokenPos();
965: $attributes = [
966: 'startLine' => $commentEndLine,
967: 'endLine' => $commentEndLine,
968: 'startFilePos' => $commentEndFilePos + 1,
969: 'endFilePos' => $commentEndFilePos,
970: 'startTokenPos' => $commentEndTokenPos + 1,
971: 'endTokenPos' => $commentEndTokenPos,
972: ];
973: return new Nop($attributes);
974: }
975:
976: protected function maybeCreateNop(int $tokenStartPos, int $tokenEndPos): ?Nop {
977: if ($this->getCommentBeforeToken($tokenStartPos) === null) {
978: return null;
979: }
980: return new Nop($this->getAttributes($tokenStartPos, $tokenEndPos));
981: }
982:
983: protected function handleHaltCompiler(): string {
984: // Prevent the lexer from returning any further tokens.
985: $nextToken = $this->tokens[$this->tokenPos + 1];
986: $this->tokenPos = \count($this->tokens) - 2;
987:
988: // Return text after __halt_compiler.
989: return $nextToken->id === \T_INLINE_HTML ? $nextToken->text : '';
990: }
991:
992: protected function inlineHtmlHasLeadingNewline(int $stackPos): bool {
993: $tokenPos = $this->tokenStartStack[$stackPos];
994: $token = $this->tokens[$tokenPos];
995: assert($token->id == \T_INLINE_HTML);
996: if ($tokenPos > 0) {
997: $prevToken = $this->tokens[$tokenPos - 1];
998: assert($prevToken->id == \T_CLOSE_TAG);
999: return false !== strpos($prevToken->text, "\n")
1000: || false !== strpos($prevToken->text, "\r");
1001: }
1002: return true;
1003: }
1004:
1005: /**
1006: * @return array<string, mixed>
1007: */
1008: protected function createEmptyElemAttributes(int $tokenPos): array {
1009: return $this->getAttributesForToken($tokenPos);
1010: }
1011:
1012: protected function fixupArrayDestructuring(Array_ $node): Expr\List_ {
1013: $this->createdArrays->offsetUnset($node);
1014: return new Expr\List_(array_map(function (Node\ArrayItem $item) {
1015: if ($item->value instanceof Expr\Error) {
1016: // We used Error as a placeholder for empty elements, which are legal for destructuring.
1017: return null;
1018: }
1019: if ($item->value instanceof Array_) {
1020: return new Node\ArrayItem(
1021: $this->fixupArrayDestructuring($item->value),
1022: $item->key, $item->byRef, $item->getAttributes());
1023: }
1024: return $item;
1025: }, $node->items), ['kind' => Expr\List_::KIND_ARRAY] + $node->getAttributes());
1026: }
1027:
1028: protected function postprocessList(Expr\List_ $node): void {
1029: foreach ($node->items as $i => $item) {
1030: if ($item->value instanceof Expr\Error) {
1031: // We used Error as a placeholder for empty elements, which are legal for destructuring.
1032: $node->items[$i] = null;
1033: }
1034: }
1035: }
1036:
1037: /** @param ElseIf_|Else_ $node */
1038: protected function fixupAlternativeElse($node): void {
1039: // Make sure a trailing nop statement carrying comments is part of the node.
1040: $numStmts = \count($node->stmts);
1041: if ($numStmts !== 0 && $node->stmts[$numStmts - 1] instanceof Nop) {
1042: $nopAttrs = $node->stmts[$numStmts - 1]->getAttributes();
1043: if (isset($nopAttrs['endLine'])) {
1044: $node->setAttribute('endLine', $nopAttrs['endLine']);
1045: }
1046: if (isset($nopAttrs['endFilePos'])) {
1047: $node->setAttribute('endFilePos', $nopAttrs['endFilePos']);
1048: }
1049: if (isset($nopAttrs['endTokenPos'])) {
1050: $node->setAttribute('endTokenPos', $nopAttrs['endTokenPos']);
1051: }
1052: }
1053: }
1054:
1055: protected function checkClassModifier(int $a, int $b, int $modifierPos): void {
1056: try {
1057: Modifiers::verifyClassModifier($a, $b);
1058: } catch (Error $error) {
1059: $error->setAttributes($this->getAttributesAt($modifierPos));
1060: $this->emitError($error);
1061: }
1062: }
1063:
1064: protected function checkModifier(int $a, int $b, int $modifierPos): void {
1065: // Jumping through some hoops here because verifyModifier() is also used elsewhere
1066: try {
1067: Modifiers::verifyModifier($a, $b);
1068: } catch (Error $error) {
1069: $error->setAttributes($this->getAttributesAt($modifierPos));
1070: $this->emitError($error);
1071: }
1072: }
1073:
1074: protected function checkParam(Param $node): void {
1075: if ($node->variadic && null !== $node->default) {
1076: $this->emitError(new Error(
1077: 'Variadic parameter cannot have a default value',
1078: $node->default->getAttributes()
1079: ));
1080: }
1081: }
1082:
1083: protected function checkTryCatch(TryCatch $node): void {
1084: if (empty($node->catches) && null === $node->finally) {
1085: $this->emitError(new Error(
1086: 'Cannot use try without catch or finally', $node->getAttributes()
1087: ));
1088: }
1089: }
1090:
1091: protected function checkNamespace(Namespace_ $node): void {
1092: if (null !== $node->stmts) {
1093: foreach ($node->stmts as $stmt) {
1094: if ($stmt instanceof Namespace_) {
1095: $this->emitError(new Error(
1096: 'Namespace declarations cannot be nested', $stmt->getAttributes()
1097: ));
1098: }
1099: }
1100: }
1101: }
1102:
1103: private function checkClassName(?Identifier $name, int $namePos): void {
1104: if (null !== $name && $name->isSpecialClassName()) {
1105: $this->emitError(new Error(
1106: sprintf('Cannot use \'%s\' as class name as it is reserved', $name),
1107: $this->getAttributesAt($namePos)
1108: ));
1109: }
1110: }
1111:
1112: /** @param Name[] $interfaces */
1113: private function checkImplementedInterfaces(array $interfaces): void {
1114: foreach ($interfaces as $interface) {
1115: if ($interface->isSpecialClassName()) {
1116: $this->emitError(new Error(
1117: sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
1118: $interface->getAttributes()
1119: ));
1120: }
1121: }
1122: }
1123:
1124: protected function checkClass(Class_ $node, int $namePos): void {
1125: $this->checkClassName($node->name, $namePos);
1126:
1127: if ($node->extends && $node->extends->isSpecialClassName()) {
1128: $this->emitError(new Error(
1129: sprintf('Cannot use \'%s\' as class name as it is reserved', $node->extends),
1130: $node->extends->getAttributes()
1131: ));
1132: }
1133:
1134: $this->checkImplementedInterfaces($node->implements);
1135: }
1136:
1137: protected function checkInterface(Interface_ $node, int $namePos): void {
1138: $this->checkClassName($node->name, $namePos);
1139: $this->checkImplementedInterfaces($node->extends);
1140: }
1141:
1142: protected function checkEnum(Enum_ $node, int $namePos): void {
1143: $this->checkClassName($node->name, $namePos);
1144: $this->checkImplementedInterfaces($node->implements);
1145: }
1146:
1147: protected function checkClassMethod(ClassMethod $node, int $modifierPos): void {
1148: if ($node->flags & Modifiers::STATIC) {
1149: switch ($node->name->toLowerString()) {
1150: case '__construct':
1151: $this->emitError(new Error(
1152: sprintf('Constructor %s() cannot be static', $node->name),
1153: $this->getAttributesAt($modifierPos)));
1154: break;
1155: case '__destruct':
1156: $this->emitError(new Error(
1157: sprintf('Destructor %s() cannot be static', $node->name),
1158: $this->getAttributesAt($modifierPos)));
1159: break;
1160: case '__clone':
1161: $this->emitError(new Error(
1162: sprintf('Clone method %s() cannot be static', $node->name),
1163: $this->getAttributesAt($modifierPos)));
1164: break;
1165: }
1166: }
1167:
1168: if ($node->flags & Modifiers::READONLY) {
1169: $this->emitError(new Error(
1170: sprintf('Method %s() cannot be readonly', $node->name),
1171: $this->getAttributesAt($modifierPos)));
1172: }
1173: }
1174:
1175: protected function checkClassConst(ClassConst $node, int $modifierPos): void {
1176: foreach ([Modifiers::STATIC, Modifiers::ABSTRACT, Modifiers::READONLY] as $modifier) {
1177: if ($node->flags & $modifier) {
1178: $this->emitError(new Error(
1179: "Cannot use '" . Modifiers::toString($modifier) . "' as constant modifier",
1180: $this->getAttributesAt($modifierPos)));
1181: }
1182: }
1183: }
1184:
1185: protected function checkUseUse(UseItem $node, int $namePos): void {
1186: if ($node->alias && $node->alias->isSpecialClassName()) {
1187: $this->emitError(new Error(
1188: sprintf(
1189: 'Cannot use %s as %s because \'%2$s\' is a special class name',
1190: $node->name, $node->alias
1191: ),
1192: $this->getAttributesAt($namePos)
1193: ));
1194: }
1195: }
1196:
1197: protected function checkPropertyHooksForMultiProperty(Property $property, int $hookPos): void {
1198: if (count($property->props) > 1) {
1199: $this->emitError(new Error(
1200: 'Cannot use hooks when declaring multiple properties', $this->getAttributesAt($hookPos)));
1201: }
1202: }
1203:
1204: /** @param PropertyHook[] $hooks */
1205: protected function checkEmptyPropertyHookList(array $hooks, int $hookPos): void {
1206: if (empty($hooks)) {
1207: $this->emitError(new Error(
1208: 'Property hook list cannot be empty', $this->getAttributesAt($hookPos)));
1209: }
1210: }
1211:
1212: protected function checkPropertyHook(PropertyHook $hook, ?int $paramListPos): void {
1213: $name = $hook->name->toLowerString();
1214: if ($name !== 'get' && $name !== 'set') {
1215: $this->emitError(new Error(
1216: 'Unknown hook "' . $hook->name . '", expected "get" or "set"',
1217: $hook->name->getAttributes()));
1218: }
1219: if ($name === 'get' && $paramListPos !== null) {
1220: $this->emitError(new Error(
1221: 'get hook must not have a parameter list', $this->getAttributesAt($paramListPos)));
1222: }
1223: }
1224:
1225: protected function checkPropertyHookModifiers(int $a, int $b, int $modifierPos): void {
1226: try {
1227: Modifiers::verifyModifier($a, $b);
1228: } catch (Error $error) {
1229: $error->setAttributes($this->getAttributesAt($modifierPos));
1230: $this->emitError($error);
1231: }
1232:
1233: if ($b != Modifiers::FINAL) {
1234: $this->emitError(new Error(
1235: 'Cannot use the ' . Modifiers::toString($b) . ' modifier on a property hook',
1236: $this->getAttributesAt($modifierPos)));
1237: }
1238: }
1239:
1240: protected function checkConstantAttributes(Const_ $node): void {
1241: if ($node->attrGroups !== [] && count($node->consts) > 1) {
1242: $this->emitError(new Error(
1243: 'Cannot use attributes on multiple constants at once', $node->getAttributes()));
1244: }
1245: }
1246:
1247: protected function checkPipeOperatorParentheses(Expr $node): void {
1248: if ($node instanceof Expr\ArrowFunction && !$this->parenthesizedArrowFunctions->offsetExists($node)) {
1249: $this->emitError(new Error(
1250: 'Arrow functions on the right hand side of |> must be parenthesized', $node->getAttributes()));
1251: }
1252: }
1253:
1254: /**
1255: * @param Property|Param $node
1256: */
1257: protected function addPropertyNameToHooks(Node $node): void {
1258: if ($node instanceof Property) {
1259: $name = $node->props[0]->name->toString();
1260: } else {
1261: $name = $node->var->name;
1262: }
1263: foreach ($node->hooks as $hook) {
1264: $hook->setAttribute('propertyName', $name);
1265: }
1266: }
1267:
1268: /** @param array<Node\Arg|Node\VariadicPlaceholder> $args */
1269: private function isSimpleExit(array $args): bool {
1270: if (\count($args) === 0) {
1271: return true;
1272: }
1273: if (\count($args) === 1) {
1274: $arg = $args[0];
1275: return $arg instanceof Arg && $arg->name === null &&
1276: $arg->byRef === false && $arg->unpack === false;
1277: }
1278: return false;
1279: }
1280:
1281: /**
1282: * @param array<Node\Arg|Node\VariadicPlaceholder> $args
1283: * @param array<string, mixed> $attrs
1284: */
1285: protected function createExitExpr(string $name, int $namePos, array $args, array $attrs): Expr {
1286: if ($this->isSimpleExit($args)) {
1287: // Create Exit node for backwards compatibility.
1288: $attrs['kind'] = strtolower($name) === 'exit' ? Expr\Exit_::KIND_EXIT : Expr\Exit_::KIND_DIE;
1289: return new Expr\Exit_(\count($args) === 1 ? $args[0]->value : null, $attrs);
1290: }
1291: return new Expr\FuncCall(new Name($name, $this->getAttributesAt($namePos)), $args, $attrs);
1292: }
1293:
1294: /**
1295: * Creates the token map.
1296: *
1297: * The token map maps the PHP internal token identifiers
1298: * to the identifiers used by the Parser. Additionally it
1299: * maps T_OPEN_TAG_WITH_ECHO to T_ECHO and T_CLOSE_TAG to ';'.
1300: *
1301: * @return array<int, int> The token map
1302: */
1303: protected function createTokenMap(): array {
1304: $tokenMap = [];
1305:
1306: // Single-char tokens use an identity mapping.
1307: for ($i = 0; $i < 256; ++$i) {
1308: $tokenMap[$i] = $i;
1309: }
1310:
1311: foreach ($this->symbolToName as $name) {
1312: if ($name[0] === 'T') {
1313: $tokenMap[\constant($name)] = constant(static::class . '::' . $name);
1314: }
1315: }
1316:
1317: // T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
1318: $tokenMap[\T_OPEN_TAG_WITH_ECHO] = static::T_ECHO;
1319: // T_CLOSE_TAG is equivalent to ';'
1320: $tokenMap[\T_CLOSE_TAG] = ord(';');
1321:
1322: // We have created a map from PHP token IDs to external symbol IDs.
1323: // Now map them to the internal symbol ID.
1324: $fullTokenMap = [];
1325: foreach ($tokenMap as $phpToken => $extSymbol) {
1326: $intSymbol = $this->tokenToSymbol[$extSymbol];
1327: if ($intSymbol === $this->invalidSymbol) {
1328: continue;
1329: }
1330: $fullTokenMap[$phpToken] = $intSymbol;
1331: }
1332:
1333: return $fullTokenMap;
1334: }
1335: }
1336:
PHPStan API documentation generated by ApiGen dev-master