Compare commits

..

181 Commits

Author SHA1 Message Date
Nikita Popov
139676794d Release PHP-Parser 5.0.2 2024-03-05 21:51:40 +01:00
Nikita Popov
70c96493b4 Fix indentation detection after opening tag
Fixes .
2024-03-02 18:59:44 +01:00
Maarten Buis
ec02613432 Update PhpVersion::getNewestSupported() to PHP 8.3 2024-03-02 08:27:21 +01:00
Nikita Popov
af14fdb282 Avoid cyclic reference in parser
Pass $this as an explicit $self argument to the reduce callbacks,
so we can make them static. This avoids a circular reference in
the parser, so that it can be immediately destroyed when it goes
out of scope.

Fixes .
2024-02-21 21:13:45 +01:00
Nikita Popov
2218c2252c Release PHP-Parser 5.0.1 2024-02-21 20:24:10 +01:00
sasezaki
ce019e9ad7 Add dev tool files to export-ignore 2024-01-14 10:02:54 +01:00
Nikita Popov
ff095c3c65 Check for tokens with non-integer ID
Fixes .
2024-01-10 20:34:09 +01:00
Nikita Popov
d619c8b4e6 Fix typo in upgrading guide
Fixes .
2024-01-09 20:23:09 +01:00
Nikita Popov
eb036d5a09 Add instructions for adding new syntax support 2024-01-07 18:54:10 +01:00
Nikita Popov
4a21235f7e Update documentation links in README 2024-01-07 18:17:35 +01:00
Nikita Popov
fba1d621c0 Release PHP-Parser 5.0.0 2024-01-07 18:14:20 +01:00
Nikita Popov
5cc5a67004 Upgrading guide tweaks 2024-01-07 18:11:19 +01:00
Nikita Popov
f603e19336 Avoid PHPUnit deprecation warnings 2024-01-07 17:46:24 +01:00
Ondrej Mirtes
1eeeb2d525 Fix parent class of PropertyItem and UseItem 2023-12-22 19:57:32 +01:00
Nikita Popov
255000ad49 Release PHP-Parser 5.0.0rc1 2023-12-20 22:32:29 +01:00
Nikita Popov
f7d484aa0e Fix handling of empty input
Fixes .
2023-12-20 21:51:46 +01:00
Nikita Popov
f82a6365a5 Add upgrading nodes for changes since beta1
Fixes .
Fixes .
2023-12-20 21:36:53 +01:00
Ondřej Mirtes
13a41f05a7 Fix typos in UPGRADE-5.0.md 2023-12-17 21:03:53 +01:00
Ondrej Mirtes
f66650073c Fix NameResolver for class constant native type 2023-11-28 20:10:53 +01:00
Nikita Popov
d0b35126e7 Update CHANGELOG 2023-11-12 17:06:58 +01:00
Nikita Popov
3640d18b87 Remove ParserFactory::create()
Don't try to keep backwards-compatibility with the old factory
style, which doesn't map cleanly onto supported options (we only
have ONLY_PHP7/PREFER_PHP7, which should probably create a Php8
parser in terms of how they are used, but this would no longer
match their names).

Instead, I have backported the new createForNewestSupportedVersion()
and createForHostVersion() methods to PHP-Parser 4.
2023-11-12 16:52:30 +01:00
Théo FIDRY
b54302f363 build: Exclude grammar from export git artifact
(cherry picked from commit 402b6cf345)
2023-11-12 13:04:04 +01:00
Nikita Popov
acfccd9d74 Run with updated php-cs-fixer 2023-11-01 18:50:25 +01:00
Sandro Gehri
eabae1f7fa Fix typo 2023-11-01 18:45:07 +01:00
xjaja
8d50e9d066 Don't drop class statements before error ()
When encountering a null statement (indicating that an error occurred),
retain the preceding statements. These were accidentally dropped
previously.

(cherry picked from commit 54103d8387)
2023-10-07 12:22:01 +02:00
Abdul Malik Ikhsan
481fec47f4 Improve performance of find() and findFirst() when passed $nodes is empty array 2023-10-07 12:11:47 +02:00
Nikita Popov
4e27a17cd8 Use visitor to assign comments
This fixes the long-standing issue where a comment would get assigned
to all nodes with the same starting position, instead of only the
outer-most one.

Fixes .
2023-09-28 21:45:08 +02:00
Nikita Popov
de84f76766 Avoid by-reference iteration in NodeTraverser
No need to create reference wrappers around every element in the
array.
2023-09-26 20:25:37 +02:00
Nikita Popov
b4183c2b09 Remove Stmt\Throw
This was a backwards-compatibility shim for Expr\Throw.
2023-09-25 18:37:07 +02:00
Nikita Popov
a1ccf57727 Introduce Stmt\Block
Stmt\Block will be created for { $a; } style blocks, unless these
occur directly inside some structure that is usually combined
with a block.

For example if ($a) { $b; } will continue to use the old
representation (plain array in in If_::$stmts), but a free-standing
{ $b; } will become a Stmt\Block.

Fixes .
2023-09-24 21:13:01 +02:00
Nikita Popov
f5adbb5e3f Add rawValue to InterpolatedStringPart and doc strings
For doc strings, the rawValue (on either the String_ or
InterpolatedStringPrts) does not include the leading indentation
(which is available as docIndentation) or the trailing newline on
the last part.
2023-09-24 12:55:38 +02:00
Nikita Popov
5edc190bda Add support for dumping additional attributes 2023-09-23 21:36:57 +02:00
Nikita Popov
80851163a6 Assemble NodeDumper result in property
Append to a property instead of returning strings. This is
significantly faster when dumping large ASTs.

This also fixes an inconsistency where the indentation level for
strings and comments was off-by-one.
2023-09-23 20:38:53 +02:00
Nikita Popov
8f175fe7c8 Pass --dry-run to php-cs-fixer
Apparently it only returns the correct exit code with the
--dry-run option.
2023-09-23 18:38:52 +02:00
Nikita Popov
d8e8065313 Don't parse unicode escapes for PHP < 7.0
We still had the option for this but were hardcoding it to true.
Make it conditional on the PHP version instead.
2023-09-23 17:35:51 +02:00
RainX
f4961b89ac Add missing phpdoc annotations in AST nodes () 2023-09-18 21:16:54 +02:00
Nikita Popov
8b9488e1e6 Explicit test new ParserFactory methods 2023-09-17 20:42:25 +02:00
Nikita Popov
21fa9c98b3 Drop some @covers annotations 2023-09-17 20:28:02 +02:00
Nikita Popov
0b3c762939 Update docs table of contents 2023-09-17 20:26:35 +02:00
Nikita Popov
edee19a5d2 Release PHP-Parser 5.0.0 Beta 1 2023-09-17 20:19:48 +02:00
Nikita Popov
ea5ba26749 Add upgrading notes for lexer changes 2023-09-17 20:17:54 +02:00
Nikita Popov
ab51e9d35a Remove superfluous phpdoc tags
These just specify a type that is already specified as a real PHP
type.
2023-09-17 18:24:05 +02:00
Nikita Popov
1873020bf7 Deprecate Node::getLine() in favor of Node::getStartLine() 2023-09-17 16:32:10 +02:00
Nikita Popov
1b346f7935 Remove deprecated Comment methods 2023-09-17 16:30:28 +02:00
Nikita Popov
2d3dd4e23e Don't align phpdoc tags
I did this to start with, but then alignment kept being broken
during refactorings, and at some point I switched to not aligning,
and now we have a big mess.

Add a php-cs-fixer rule to consistently not align phpdoc tags.
2023-09-17 16:00:10 +02:00
Nikita Popov
3c52ea9b6d Document phpVersion effect on pretty printer 2023-09-17 15:52:10 +02:00
Nikita Popov
5a7753a930 Update changelog 2023-09-17 15:28:40 +02:00
Nikita Popov
c91c8633a4 Add PHP 8.3 to CI matrix 2023-09-17 11:59:43 +02:00
Nikita Popov
e395f042d2 Add php-cs-fixer CI job 2023-09-17 11:08:23 +02:00
Nikita Popov
21ead39056 Update docs after lexer changes 2023-09-17 09:07:58 +02:00
Nikita Popov
b11fca0310 Run integration test against PHP 8.3 2023-09-16 09:54:10 +02:00
Nikita Popov
06c7ab51b7 Drop Lexer::getTokens() method
This doesn't make a lot of sense now that Lexer::tokenize() returns
the tokens.

The tokens for the last parse should be fetched via
Parser::getTokens() instead.
2023-09-16 09:50:50 +02:00
Markus Staab
263fa80b81 Use more precise Use_::TYPE_* types ()
For better static analysis support in consuming projects.
2023-09-14 10:03:42 +02:00
Nikita Popov
5da5231fde Indent heredoc/nowdoc when targeting PHP >= 7.3 2023-08-27 22:02:31 +02:00
Nikita Popov
8d58380108 Default pretty printer to PHP 7.4 2023-08-27 21:26:47 +02:00
Nikita Popov
efe93a171b Update PHP versions in workflow 2023-08-17 21:40:48 +02:00
Nikita Popov
ea77807592 Add more property types
Some of these are not maximally accurate due to lack of union
types.
2023-08-17 21:36:07 +02:00
Nikita Popov
9a68468fda Update phpstan baseline 2023-08-16 21:38:27 +02:00
Nikita Popov
502b090900 Add property types
Types omitted in two places where we violate them currently:
Namespace_::$stmts can be null during parsing, and Enum_::$scalarType
can be a complex type for invalid programs.
2023-08-16 21:37:02 +02:00
Nikita Popov
3c0432b09d Remove emulation for unsupported PHP versions 2023-08-16 21:09:51 +02:00
Nikita Popov
ee3e7db3fc Raise minimum PHP version to PHP 7.4 2023-08-16 21:06:38 +02:00
Nikita Popov
ba851243f4 Replace startLexing() with tokenize()
For now Lexer::getTokens() still exists, but should probably be
removed.
2023-08-13 16:06:10 +02:00
Nikita Popov
d1d784a5c6 Fixup line numbers when applying emulator patches
This fixes the test failures on PHP 7.2.
2023-08-13 12:59:26 +02:00
Nikita Popov
62853b179c Fix PhpStan errors 2023-08-13 12:45:21 +02:00
Nikita Popov
4b497045e0 Move attribute handling into parser
The Lexer now only provides the tokens to the parser, while the
parser is responsible for determining which attributes are placed
on notes. This only needs to be done when the attributes are
actually needed, rather than for all tokens.

This removes the usedAttributes lexer option (and lexer options
entirely). The attributes are now enabled unconditionally. They
have less overhead now, and the need to explicitly enable them for
some use cases (e.g. formatting-preserving printing) doesn't seem
like a good tradeoff anymore.

There are some additional changes to the Lexer interface that
should be done after this, and the docs / upgrading guide haven't
been adjusted yet.
2023-08-13 10:40:21 +02:00
Nikita Popov
b20267c5ad Make use of default actions
For the default action $$ = $1, save the closure invocation.
2023-07-09 21:18:21 +02:00
Nikita Popov
748aab3365 Don't set start attributes for whitespace
These will get overwritten later anyway.
2023-07-09 15:47:37 +02:00
Nikita Popov
c48ee36f54 Allow passing visitors to NodeTraverser constructor 2023-07-09 15:34:31 +02:00
Nikita Popov
8b1371990c Minor documentation updates 2023-07-09 15:34:31 +02:00
Abdul Malik Ikhsan
eaa1d91b4e Early return false after VariadicPlaceholder check on CallLike::isFirstClassCallable() ()
VariadicPlaceholder can only occur as the first (and only) argument, so avoid a loop to check for it.
2023-06-25 18:38:11 +02:00
Danny van der Sluijs
3fb4b92f59 Update main.yml to use GitHub Actions V3
Updates the GitHub Actions from V2 to V3

(cherry picked from commit 1d0748ad35)
2023-06-24 17:59:49 +02:00
Nikita Popov
571ca90b7e Release PHP-Parser 5.0.0-alpha3 2023-06-24 17:48:52 +02:00
Nikita Popov
16c766eae1 Don't take subnodes by reference when traversing
Explicitly assign the property where necessary to avoid the
creation of unnecessary reference-wrappers everywhere.
2023-05-28 21:54:07 +02:00
Nikita Popov
53f6717329 Remove unnecessary Node return value from traverseNode()
The node always stays the same: We may only change subnodes.
2023-05-28 21:51:45 +02:00
Nikita Popov
5b65f9fc92 Some documentation updates 2023-05-27 21:35:10 +02:00
Nikita Popov
69993a181a Update CHANGELOG and UPGRADING 2023-05-27 16:26:36 +02:00
Nikita Popov
23647573e8 Represent names using string rather than array of parts
In most circumstances we are interested in the whole string, not
the parts split by namespace separator. As names are common, this
representation measurably improves memory usage and performance.
2023-05-21 21:25:49 +02:00
Nikita Popov
df3a7057ab Add Name::getParts(), deprecate Name::$parts
In preparation for switching this to a plain string in
PHP-Parser 5, deprecate direct access to the property and
provide an API that will work on both versions.

(cherry picked from commit c9e5a13d68)
2023-05-21 21:24:13 +02:00
Nikita Popov
d43edfbb31 Support CRLF newlines in pretty printer
Can be enabled using the "newlines" option.
2023-05-21 20:56:56 +02:00
Nikita Popov
ad8daa12b2 Normalize newlines in Comment::getReformattedText()
Normalize CRLF to LF in getReformattedText(). That was, if the
comment is pretty-printed, we will use proper LF newlines, rather
than inserting indentation between the CR and LF.

At the same time, this also makes it easier to emit actual CRLF
newlines with a custom pretty printer.

Fixes .
2023-05-21 17:38:56 +02:00
Nikita Popov
5883189d61 Fix return type of Comment::getReformattedText() 2023-05-21 15:51:27 +02:00
Nikita Popov
afe1628a72 Add support for NodeVisitor::REPLACE_WITH_NULL
Fixes .
2023-05-21 15:41:41 +02:00
Nikita Popov
289756d056 Gracefully handle non-contiguous arrays in Differ
Fixes .
2023-05-21 15:15:36 +02:00
Nikita Popov
8490c0e82d Call leaveNode() on visitors in reverse order
Node visitation is now properly nested. The call sequence will
now be

    $visitor1->enterNode($n);
    $visitor2->enterNode($n);
    $visitor2->leaveNode($n);
    $visitor1->leaveNode($n);

rather than

    $visitor1->enterNode($n);
    $visitor2->enterNode($n);
    $visitor1->leaveNode($n);
    $visitor2->leaveNode($n);

Fixes .
2023-05-21 12:31:15 +02:00
Nikita Popov
8bc698248d Ensure removing visitor does not leave holes 2023-05-21 12:07:21 +02:00
Nikita Popov
fb2c3ac97c Fix emulative lexer with default error handler
If no error handler is provided, explicitly create one, so we don't
end up calling handleError() on null.
2023-05-20 22:26:53 +02:00
Nikita Popov
c23976a299 Stop accepting strings as types
For types the use of a string is ambiguous -- it could be either
an Identifier or a Name. Don't guess.

Retain the implicit promotion to Identifier in places where only
Identifier is legal, e.g. various symbol names.
2023-05-20 22:13:04 +02:00
Nikita Popov
a9dad5c54e Fix type of ClassConst::$type 2023-05-20 22:01:01 +02:00
Nikita Popov
74caed6446 Fix labelCharMap for DEL character
This map is supposed to have string keys, not integer keys.
2023-05-20 21:55:53 +02:00
Nikita Popov
a5d4c1005c Remove some unused symbols 2023-05-20 21:40:55 +02:00
Nikita Popov
93731c5cfa Move constants from NodeTraverser to NodeVisitor
These are really part of the NodeVisitor API. Retain aliases for
compatibility.
2023-05-20 21:37:34 +02:00
Nikita Popov
0a8a333a4a Blacklist test with comments in intersection types 2023-05-20 21:21:45 +02:00
Nikita Popov
91da19147b Support readonly anonymous classes 2023-05-20 21:17:44 +02:00
Nikita Popov
5c267f55c9 Add support for typed constants
RFC: https://wiki.php.net/rfc/typed_class_constants
2023-05-20 21:02:03 +02:00
Nikita Popov
9a5d5c112c Add newline at end of file for many tests
Add the newline in reconstructTest() and run updateTests.php, to
reduce spurious diffs in the future.
2023-05-20 19:18:11 +02:00
Nikita Popov
779b6950c3 Fix coding style 2023-05-20 18:55:12 +02:00
Nikita Popov
b68fb76f14 Add makeReadonly() to param builder
(cherry picked from commit 11e2dcd96c)
2023-05-19 22:17:50 +02:00
Cees-Jan Kiewiet
36a6dcd04e [5.x] Add constructor property promotion
By making flags on the Param builder configurable by providing make(Public|Protected|Private) methods we can promote parameters to properties from the constructor
2023-03-06 23:12:51 +01:00
Nikita Popov
bb4263ea1a Treat del as label character depending on PHP version
In formatting-preserving pretty printing, treat DEL as a label
character based on the target PHP version (the default of 7.1
implying it isn't one).

This avoids failure to round-trip an unchanged input.
2023-03-05 17:03:00 +01:00
Nikita Popov
4ce0de2d12 Use PHP 7.1 as default pretty printer target 2023-03-05 16:56:50 +01:00
Nikita Popov
a3bc900a41 Don't ltrim when preserving formatting
We shouldn't ltrim when printing a whole file, that way we will
not just fail to preserve formatting, but actually change semantics
by dropping meaningful whitespace.
2023-03-05 16:42:30 +01:00
Nikita Popov
7785d2b887 Remove garbage collection section from docs
The GC issue has been fixed in PHP 7.3 and is no longer relevant.
2023-03-05 16:12:50 +01:00
Nikita Popov
aa721520f9 Don't generate braces for "else if"
Mentioned in .
2023-03-05 11:30:39 +01:00
Nikita Popov
da65ae474d Release PHP-Parser 5.0.0 alpha 2 2023-03-05 10:49:58 +01:00
Nikita Popov
8fb716841e Update upgrading documentation 2023-03-05 10:49:24 +01:00
Nikita Popov
b9974596e0 Update changelog 2023-03-04 23:25:31 +01:00
Anthony Ferrara
64484a4979 Add PrettyPrinter interface
Closes .
2023-03-04 21:56:58 +01:00
Nikita Popov
a0ed229b31 Revert "Rename PrettyPrinterAbstract to PrettyPrinter"
This reverts commit 2217f14d6e.
2023-03-04 21:54:56 +01:00
Nikita Popov
1286059998 Set allowed exceptions in fuzzer 2023-03-04 19:07:27 +01:00
Nikita Popov
698ff1ca46 Don't always omit parentheses for argument-less yield
We may need parentheses around an argument-less yield to distinguish
(yield) - $a from yield -$a and similar.

Treat argument-less yield like a prefix operator. This will print
parentheses a bit more often than is really required, because the
arity ambiguity only exists for certain operators. This seems like
a reasonably good approximation through, as it only affects
argument-less yield on the LHS of infix operators.
2023-03-04 12:06:35 +01:00
Nikita Popov
7877e0302d Handle group use special case in fuzzer
Same as for normal use.
2023-03-04 11:59:42 +01:00
Nikita Popov
b3158e0b53 Respect namespace style for enum scalar type printing
Doesn't matter in any practical sense because such types are always
invalid, but makes sure pretty printing round-trips.
2023-03-04 11:56:59 +01:00
Nikita Popov
bbec9db626 Handle overflowing \u escape sequence 2023-03-01 22:39:15 +01:00
Nikita Popov
a4728678fc Don't skip tests with evaluate segment when generating corpus
This code was adopted from test updating, but in this context
we're fine with just evaluating these.
2023-03-01 21:37:37 +01:00
Nikita Popov
6649012e6c Produce error if <?= used as identifier
Due to a peculiarity of how <?= is handled, it can get treated as
an echo identifier. Make sure it isn't, to match PHP behavior.
2023-03-01 21:35:27 +01:00
Nikita Popov
2217f14d6e Rename PrettyPrinterAbstract to PrettyPrinter 2023-03-01 21:25:02 +01:00
Nikita Popov
c62dda9507 Strip trailing doc string newline before parsing escape sequences
If the doc string ends on an escaped \r, it should not get eaten
as the "last newline".
2023-03-01 21:05:55 +01:00
Nikita Popov
4c3e759a51 Support parsing from stdin in php-parse
Following the usual convention, read from stdin if the file name
is "-".
2023-03-01 20:56:03 +01:00
Nikita Popov
f8fea0997c Detect another special case in fuzzer 2023-02-27 23:05:08 +01:00
Nikita Popov
57d4a02659 Handle isolated \r in doc string
Doc strings have a trailing \n and these will get interpreted as
\r\n and removed from the string contents.

For nowdoc, fall back to single quote if there's a trailing \r.
For heredoc, escape all isolated \r -- unlike \n and \r\n this is
really a special character, because this is no longer relevant as
an actual newline character.
2023-02-27 22:00:49 +01:00
Nikita Popov
8e100f1e69 Handle another yield edge case
match also uses =>, so we need to make sure that a trailing yield
is wrapped in parentheses.
2023-02-27 21:36:36 +01:00
Nikita Popov
fcd5934dae Prevent merging of consecutive -/+ more thoroughly
The unary -/+ or --/++ might not be the direct child. Instead
determine this by actually printing the operand and checking
whether it starts with -/+.
2023-02-27 19:07:44 +01:00
Nikita Popov
cc34c2450c Fix logic for new operand parentheses requirement
We need to perform this check recursively.
2023-02-27 19:00:33 +01:00
Nikita Popov
68eb1ca9c1 Add fuzzing target 2023-02-26 23:02:31 +01:00
Nikita Popov
cb60eda774 Support yield precedence
Since PHP 7.0 yield is a proper expression, so print it with
proper precedence. If the pretty printer is configured for
older version (non-default), then always print parentheses.

There is an interesting interaction here, in that => is resolved
in favor of yield if the yield occurs as part of an array (or
outer yield). This kind of bypasses the entire precedence hierarchy
and *only* affects yield expressions. For the sake of simplicity
this is modeled via normal LHS precedence, because this will only
add unnecessary parentheses to a handful of low precedence unary
operators. If desired, a special marker for this purpose could be
added though.
2023-02-26 22:58:53 +01:00
Nikita Popov
1cb460ae38 Handle throw precedence
Now that this is an expression, we also need to handle precedence.
2023-02-26 18:33:24 +01:00
Nikita Popov
5ad02d8a2c Run integration tests against PHP 8.2 test suite 2023-02-26 18:28:17 +01:00
Nikita Popov
3bd38c5b2c Properly support prefix operator precedence printing
The pretty printer is supposed to produce a minimal-parentheses
printing for expressions. However, for prefix operators, we were
failing to do so in ways that are practically meaningful, e.g.
$a = yield from $b produced redundant parentheses around the
yield from.

For prefix operators, the precedence of the direct parent operator
is not actually relevant: What matters is the precedence of any
infix operator whose LHS it appears on. For example, $a . include $b
does not require parentheses, but (include $a) . $b does.

To handle this, keep separate track of the parent operator
precedence, and a special LHS precedence which is used for unary
operator printing only. Because the LHS precedence may not come
from the direct parent, we have to pass it down the call stack.
And if we do that, we may as well do the same for the parent
precedence.

This also fixes an integration test failure with php-src, because
arrow function precedence was previously not respected (and would
be ugly to respect without this change).
2023-02-26 18:26:20 +01:00
Nikita Popov
e9416a0eae Support fixup for dynamic class const name
This is new in PHP 8.3.
2023-02-26 16:00:35 +01:00
Nikita Popov
7b4a8c1ebd Properly handle static deref LHS
The rules for static and array/object deref are slightly different:
The former does not allow constants.
2023-02-26 15:57:37 +01:00
Nikita Popov
ee3c80f90b Add .idea and .php-cs-fixer.cache to .gitignore 2023-02-26 15:29:47 +01:00
Nikita Popov
9476cff37d Doc string end label may have leading whitespace
When detecting whether the string contains the end label, allow
leading whitespace in front of it. This is legal since the
introduction of flexible doc strings.
2023-02-26 15:21:33 +01:00
Nikita Popov
6a88bdb05a Support new variables in fixup 2023-02-26 15:17:07 +01:00
Nikita Popov
1eb6b5653e Properly handle new/instanceof operand restrictions
Fixes .
2023-02-26 15:11:36 +01:00
Nikita Popov
d24745ddbc Respect precedence during clone pretty printing
Clone is the prefix operator with the highest operator precedence,
but was not treated as an operator at all.
2023-02-26 14:58:17 +01:00
Nikita Popov
cd3c0c11e4 Remove __halt_compiler from semi reserved keyword list
Apparently PHP does not allow use of __halt_compiler as a
semi-reserved keyword.
2023-02-26 12:32:22 +01:00
Nikita Popov
f6ddde6428 Perform end label check on escaped string
Escaping might convert a label character into an escape sequence
if it is not valid UTF-8.
2023-02-26 12:27:05 +01:00
Nikita Popov
47626c74ec Handle interpolated variable after end label
Interpolated variables start with non-label characters, and as
such also count as end label terminators since PHP 7.3.
2023-02-26 12:20:32 +01:00
Nikita Popov
ce3337b0c2 Update allowed characters after doc string label
With the introduction of flexible doc strings, the ending label
is no longer required to be followed by a semicolon or newline.
We need to prevent doc string printing if the label is followed
by any non-label character.
2023-02-26 12:14:04 +01:00
Nikita Popov
d83562e6fe Print INF as 1.0E+1000
This makes pretty printing round trip to another Float literal,
rather than a constant lookup. The 1e1000 form in particular is
chosen because that seems to be the typical form used in various
tests.
2023-02-26 09:47:19 +01:00
Nikita Popov
55cc60c286 Add tools directory to export-ignore 2023-02-26 09:41:02 +01:00
Nikita Popov
2df8878f5d [PHP 8.3] Support dynamic class const fetch
RFC: https://wiki.php.net/rfc/dynamic_class_constant_fetch
2023-01-29 20:49:00 +01:00
Markus Staab
8ad4129442 Declare list types ()
Closes 
2022-12-14 22:59:53 +01:00
Markus Staab
4c4af21df8 Rewrote overly magic code to make it readable ()
New code inspired by 950bf8f1d1/lib/PhpParser/Builder/Trait_.php (L43)
2022-12-14 22:58:37 +01:00
Nikita Popov
21a3e8cac5 Fix attrGroups/attributes confusion in EnumCase builder
Found by staabm in .
2022-12-14 21:50:11 +01:00
Nikita Popov
950bf8f1d1 Adjust tests to work on 32-bit
Fixes .
2022-11-12 16:19:15 +01:00
Nikita Popov
4ce9781260 Fix parsing of large hex floats containing "e"
These ended up taking the code path for normal floats and being
cast to zero.
2022-11-12 16:15:32 +01:00
Nikita Popov
f077f76557 Add some unit tests for PhpVersion 2022-10-30 18:00:30 +01:00
Nikita Popov
b0edd4c411 Bail out on PHP tags in removed code
If dropping a node would drop PHP tags, bail out of formatting
preservation. This will lose formatting, but at least produce
legal code.

Closes GH-884.
2022-09-21 20:42:21 +02:00
Nikita Popov
bad10e1618 Add more tests for formatting preservation with InlineHTML
It's all broken...
2022-09-21 20:28:52 +02:00
Nikita Popov
4bcdf74b8b Add support for perserving formatting for static modifier change
Closes GH-891.
2022-09-21 18:56:58 +02:00
Abdul Malik Ikhsan
46558ed9a5 Show missing format preservation when adding static modifier to closure 2022-09-21 18:49:23 +02:00
Nikita Popov
5573afc06e Test PHP 8.2 in CI 2022-09-18 15:33:40 +02:00
Nikita Popov
0dd85ebd34 Support readonly before DNF type
This makes us match the PHP 8.2 handling of readonly. Handling of
"readonly" functions is moved to the parser to allow distinguishing
them from readonly properties with DNF types. We have to uglify the
grammar to avoid some shift/reduce conflicts. Thank you WordPress.
2022-09-18 15:32:34 +02:00
Nikita Popov
132690f2f8 Slightly more precise type 2022-09-17 21:19:37 +02:00
Nikita Popov
f7b448fa15 Bail out on list insertion of non-Node
PhpStan correctly detected that this is not supported. We could
add support for it, but for now just make sure it doesn't crash.
2022-09-17 21:14:31 +02:00
Nikita Popov
b3ad14b938 Fix some types 2022-09-17 20:33:04 +02:00
Nikita Popov
9f9c2ea81b Use PhpStan level 6
New baseline errors are array types that I prefer to leave alone,
as well as one PhpStan bug:
https://github.com/phpstan/phpstan/issues/4526
2022-09-17 18:49:51 +02:00
Nikita Popov
f98341f688 Specify more types 2022-09-17 18:48:56 +02:00
Nikita Popov
fc6b4890ef Specify more types 2022-09-17 16:45:25 +02:00
Nikita Popov
032b102146 Remove deprecated Error constructor
And use this chance to provide accurate position information for
namespace errors.
2022-09-11 22:05:47 +02:00
Nikita Popov
40c89cf924 Specify some more types 2022-09-11 21:54:39 +02:00
Nikita Popov
a099803d01 Use array<string, mixed> type for $attributes
Slightly more accurate, and stops PHPStan from complaining about
the missing array type information.
2022-09-11 20:51:31 +02:00
Nikita Popov
c595989e4d Support adding class constants in trait builder
These are allowed as of PHP 8.2.
2022-09-11 19:34:27 +02:00
Nikita Popov
6af204467c Add some missing property types 2022-09-11 19:30:14 +02:00
Nikita Popov
48f470eac7 Add missing return types 2022-09-11 18:17:05 +02:00
Nikita Popov
43d6332dce Add return types to PrettyPrinter\Standard 2022-09-11 17:49:41 +02:00
Nikita Popov
9b46dffb12 Fix formatting preservation for alternative elseif/else syntax
Test taken from PR .
2022-09-11 16:58:35 +02:00
Nikita Popov
205bd75aa8 Add isPublic() etc methods on Param node
Also isPromoted() to check for any flags.
2022-09-11 16:11:32 +02:00
Nikita Popov
031c5e6ed0 Move verifyModifier/verifyClassModifier to Modifiers class
Now that the Modifiers are in a separate class, these *internal*
verification methods should also be moved there.
2022-09-11 16:05:21 +02:00
Christopher Hertel
36b2a996ca Add isReadonly on Param node 2022-09-11 16:05:10 +02:00
Nikita Popov
b9fe3449e8 Add missing parameter types 2022-09-11 15:22:23 +02:00
Nikita Popov
e9800cf7d3 Add tools/ directory
With php-cs-fixer and phpstan. Also reformat one file.
2022-09-11 13:17:17 +02:00
Nikita Popov
2070cb7cb2 Drop phpstan from composer.json
It does not support PHP 7.1, so we should not include it
unconditionally.
2022-09-11 12:45:59 +02:00
Nikita Popov
9b5a2c8991 Use PHPStan level 5 2022-09-11 12:40:08 +02:00
Nikita Popov
8dfce13d77 Add phpstan baseline 2022-09-11 12:31:50 +02:00
Nikita Popov
f59f226f65 Fix some phpstan warnings 2022-09-11 12:16:12 +02:00
Jaroslav Hanslík
468c0ef6bc Fixed type in UnionType
(cherry picked from commit 2f1fd784fe)
2022-09-10 22:42:32 +02:00
Nikita Popov
b4b60c8460 Remove phpunit 6.5
With the minimum version raised to PHP 7.1, there should be no
more need for PHPUnit 6.
2022-09-06 20:29:27 +02:00
Nikita Popov
636f066b76 Use Node\ClosureUse instead of Expr\ClosureUse in parser
Fixes .
2022-09-05 18:35:39 +02:00
Ondřej Mirtes
7362f2b2d0 Fix pretty printing example 2022-09-05 10:32:21 +02:00
428 changed files with 10462 additions and 9485 deletions
.gitattributes
.github/workflows
.gitignore.php-cs-fixer.dist.phpCHANGELOG.mdCONTRIBUTING.mdMakefileREADME.mdUPGRADE-5.0.md
bin
composer.json
doc
grammar
lib/PhpParser
Builder
BuilderFactory.phpBuilderHelpers.phpComment.phpConstExprEvaluator.phpError.phpErrorHandler.php
ErrorHandler
Internal
JsonDecoder.phpLexer.php
Lexer
Modifiers.phpNameContext.phpNode.php
Node
NodeAbstract.phpNodeDumper.phpNodeFinder.phpNodeTraverser.phpNodeTraverserInterface.phpNodeVisitor.php
NodeVisitor
Parser.php
Parser
ParserAbstract.phpParserFactory.phpPhpVersion.phpPrettyPrinter.php
PrettyPrinter
PrettyPrinterAbstract.phpcompatibility_tokens.php
phpstan-baseline.neonphpstan.neon.dist
test
PhpParser
code
formatPreservation
parser
blockComments.testcomments.testemptyFile.test
errorHandling
expr
formattingAttributes.testnopPositions.test
scalar
semiReserved.test
stmt
prettyPrinter
test_old
tools

6
.gitattributes vendored

@@ -1,11 +1,17 @@
/.github export-ignore
/doc export-ignore
/grammar export-ignore
/test export-ignore
/test_old export-ignore
/tools export-ignore
.editorconfig export-ignore
.gitattributes export-ignore
.gitignore export-ignore
.php-cs-fixer.dist.php export-ignore
Makefile export-ignore
CHANGELOG.md export-ignore
CONTRIBUTING.md export-ignore
phpstan-baseline.neon export-ignore
phpstan.neon.dist export-ignore
phpunit.xml.dist export-ignore
UPGRADE-*.md export-ignore

@@ -7,15 +7,15 @@ on:
jobs:
tests_coverage:
runs-on: "ubuntu-latest"
name: "PHP 7.1 Unit Tests (with coverage)"
name: "PHP 7.4 Unit Tests (with coverage)"
steps:
- name: "Checkout"
uses: "actions/checkout@v2"
uses: "actions/checkout@v3"
- name: "Install PHP"
uses: "shivammathur/setup-php@v2"
with:
coverage: "xdebug"
php-version: "7.1"
php-version: "7.4"
tools: composer:v2
- name: "Install dependencies"
run: |
@@ -34,14 +34,13 @@ jobs:
strategy:
matrix:
php-version:
- "7.2"
- "7.3"
- "7.4"
- "8.0"
- "8.1"
- "8.2"
- "8.3"
steps:
- name: "Checkout"
uses: "actions/checkout@v2"
uses: "actions/checkout@v3"
- name: "Install PHP"
uses: "shivammathur/setup-php@v2"
with:
@@ -54,33 +53,67 @@ jobs:
run: "php vendor/bin/phpunit"
test_old_73_80:
runs-on: "ubuntu-latest"
name: "PHP 7.3 Code on PHP 8.0 Integration Tests"
name: "PHP 7.4 Code on PHP 8.2 Integration Tests"
steps:
- name: "Checkout"
uses: "actions/checkout@v2"
uses: "actions/checkout@v3"
- name: "Install PHP"
uses: "shivammathur/setup-php@v2"
with:
coverage: "none"
php-version: "8.0"
php-version: "8.2"
tools: composer:v2
- name: "Install PHP 8 dependencies"
run: "composer update --no-progress --prefer-dist"
- name: "Tests"
run: "test_old/run-php-src.sh 7.3.21"
run: "test_old/run-php-src.sh 7.4.33"
test_old_80_70:
runs-on: "ubuntu-latest"
name: "PHP 8.1 Code on PHP 7.1 Integration Tests"
name: "PHP 8.3 Code on PHP 7.4 Integration Tests"
steps:
- name: "Checkout"
uses: "actions/checkout@v2"
uses: "actions/checkout@v3"
- name: "Install PHP"
uses: "shivammathur/setup-php@v2"
with:
coverage: "none"
php-version: "7.1"
php-version: "7.4"
tools: composer:v2
- name: "Install PHP 8 dependencies"
run: "composer update --no-progress --prefer-dist"
- name: "Tests"
run: "test_old/run-php-src.sh 8.1.6"
run: "test_old/run-php-src.sh 8.3.0RC2"
phpstan:
runs-on: "ubuntu-latest"
name: "PHPStan"
steps:
- name: "Checkout"
uses: "actions/checkout@v3"
- name: "Install PHP"
uses: "shivammathur/setup-php@v2"
with:
coverage: "none"
php-version: "8.2"
tools: composer:v2
- name: "Install dependencies"
run: |
cd tools && composer install
- name: "PHPStan"
run: "php tools/vendor/bin/phpstan"
php-cs-fixer:
runs-on: "ubuntu-latest"
name: "PHP-CS-Fixer"
steps:
- name: "Checkout"
uses: "actions/checkout@v3"
- name: "Install PHP"
uses: "shivammathur/setup-php@v2"
with:
coverage: "none"
php-version: "8.2"
tools: composer:v2
- name: "Install dependencies"
run: |
cd tools && composer install
- name: "php-cs-fixer"
run: "php tools/vendor/bin/php-cs-fixer fix --dry-run"

2
.gitignore vendored

@@ -1,5 +1,7 @@
.idea/
vendor/
composer.lock
grammar/kmyacc.exe
grammar/y.output
.phpunit.result.cache
.php-cs-fixer.cache

@@ -21,6 +21,11 @@ return $config->setRiskyAllowed(true)
'declare_strict_types' => true,
// Keep argument formatting for now.
'method_argument_space' => ['on_multiline' => 'ignore'],
'phpdoc_align' => ['align' => 'left'],
'phpdoc_trim' => true,
'no_empty_phpdoc' => true,
'no_superfluous_phpdoc_tags' => ['allow_mixed' => true],
'no_extra_blank_lines' => true,
])
->setFinder($finder)
;

@@ -1,7 +1,176 @@
Version 5.0.0-dev
-----------------
Version 5.0.2 (2024-03-05)
--------------------------
Nothing yet.
### Fixed
* Fix handling of indentation on next line after opening PHP tag in formatting-preserving pretty
printer.
### Changed
* Avoid cyclic references in `Parser` objects. This means that no longer used parser objects are
immediately destroyed now, instead of requiring cycle GC.
* Update `PhpVersion::getNewestSupported()` to report PHP 8.3 instead of PHP 8.2.
Version 5.0.1 (2024-02-21)
--------------------------
### Changed
* Added check to detect use of PHP-Parser with libraries that define `T_*` compatibility tokens
with incorrect type (such as string instead of int). This would lead to `TypeError`s down the
line. Now an `Error` will be thrown early to indicate the problem.
Version 5.0.0 (2024-01-07)
--------------------------
See UPGRADE-5.0 for detailed migration instructions.
### Fixed
* Fixed parent class of `PropertyItem` and `UseItem`.
Version 5.0.0-rc1 (2023-12-20)
------------------------------
See UPGRADE-5.0 for detailed migration instructions.
### Fixed
* Fixed parsing of empty files.
### Added
* Added support for printing additional attributes (like `kind`) in `NodeDumper`.
* Added `rawValue` attribute to `InterpolatedStringPart` and heredoc/nowdoc `String_`s, which
provides the original, unparsed value. It was previously only available for non-interpolated
single/double quoted strings.
* Added `Stmt\Block` to represent `{}` code blocks. Previously, such code blocks were flattened
into the parent statements array. `Stmt\Block` will not be created for structures that are
typically used with code blocks, for example `if ($x) { $y; }` will be represented as previously,
while `if ($x) { { $x; } }` will have an extra `Stmt\Block` wrapper.
### Changed
* Use visitor to assign comments. This fixes the long-standing issue where comments were assigned
to all nodes sharing a starting position. Now only the outer-most node will hold the comments.
* Don't parse unicode escape sequences when targeting PHP < 7.0.
* Improve NodeDumper performance for large dumps.
### Removed
* Removed `Stmt\Throw_` node, use `Expr\Throw_` inside `Stmt\Expression` instead.
* Removed `ParserFactory::create()`.
Version 5.0.0-beta1 (2023-09-17)
--------------------------------
See UPGRADE-5.0 for detailed migration instructions.
### Added
* Visitors can now be passed directly to the `NodeTraverser` constructor. A separate call to
`addVisitor()` is no longer required.
### Changed
* The minimum host PHP version is now PHP 7.4. It is still possible to parse code from older
versions. Property types have been added where possible.
* The `Lexer` no longer accepts options. `Lexer\Emulative` only accepts a `PhpVersion`. The
`startLexing()`, `getTokens()` and `handleHaltCompiler()` methods have been removed. Instead,
there is a single method `tokenize()` returning the tokens.
* The `Parser::getLexer()` method has been replaced by `Parser::getTokens()`.
* Attribute handling has been moved from the lexer to the parser, and is no longer configurable.
The comments, startLine, endLine, startTokenPos, endTokenPos, startFilePos, and endFilePos
attributes will always be added.
* The pretty printer now defaults to PHP 7.4 as the target version.
* The pretty printer now indents heredoc/nowdoc strings if the target version is >= 7.3
(flexible heredoc/nowdoc).
### Removed
* The deprecated `Comment::getLine()`, `Comment::getTokenPos()` and `Comment::getFilePos()` methods
have been removed. Use `Comment::getStartLine()`, `Comment::getStartTokenPos()` and
`Comment::getStartFilePos()` instead.
### Deprecated
* The `Node::getLine()` method has been deprecated. Use `Node::getStartLine()` instead.
Version 5.0.0-alpha3 (2023-06-24)
---------------------------------
See UPGRADE-5.0 for detailed migration instructions.
### Added
* [PHP 8.3] Added support for typed constants.
* [PHP 8.3] Added support for readonly anonymous classes.
* Added support for `NodeVisitor::REPLACE_WITH_NULL`.
* Added support for CRLF newlines in the pretty printer, using the new `newline` option.
### Changed
* Use PHP 7.1 as the default target version for the pretty printer.
* Print `else if { }` instead of `else { if { } }`.
* The `leaveNode()` method on visitors is now invoked in reverse order of `enterNode()`.
* Moved `NodeTraverser::REMOVE_NODE` etc. to `NodeVisitor::REMOVE_NODE`. The old constants are still
available for compatibility.
* The `Name` subnode `parts` has been replaced by `name`, which stores the name as a string rather
than an array of parts separated by namespace separators. The `getParts()` method returns the old
representation.
* No longer accept strings for types in Node constructors. Instead, either an `Identifier`, `Name`
or `ComplexType` must be passed.
* `Comment::getReformattedText()` now normalizes CRLF newlines to LF newlines.
### Fixed
* Don't trim leading whitespace in formatting preserving printer.
* Treat DEL as a label character in the formatting preserving printer depending on the targeted
PHP version.
* Fix error reporting in emulative lexer without explicitly specified error handler.
* Gracefully handle non-contiguous array indices in the `Differ`.
Version 5.0.0-alpha2 (2023-03-05)
---------------------------------
See UPGRADE-5.0 for detailed migration instructions.
### Added
* [PHP 8.3] Added support for dynamic class constant fetch.
* Added many additional type annotations. PhpStan is now used.
* Added a fuzzing target for PHP-Fuzzer, which was how a lot of pretty printer bugs were found.
* Added `isPromoted()`, `isPublic()`, `isProtected()`, `isPrivate()` and `isReadonly()` methods
on `Param`.
* Added support for class constants in trait builder.
* Added `PrettyPrinter` interface.
* Added support for formatting preservation when toggling static modifiers.
* The `php-parse` binary now accepts `-` as the file name, in which case it will read from stdin.
### Fixed
* The pretty printer now uses a more accurate treatment of unary operator precedence, and will only
wrap them in parentheses if required. This allowed fixing a number of other precedence related
bugs.
* The pretty printer now respects the precedence of `clone`, `throw` and arrow functions.
* The pretty printer no longer unconditionally wraps `yield` in parentheses, unless the target
version is set to older than PHP 7.0.
* Fixed formatting preservation for alternative elseif/else syntax.
* Fixed checks for when it is safe to print strings as heredoc/nowdoc to accommodate flexible
doc string semantics.
* The pretty printer now prints parentheses around new/instanceof operands in all required
situations.
* Similar, differences in allowed expressions on the LHS of `->` and `::` are now taken into account.
* Fixed various cases where `\r` at the end of a doc string could be incorrectly merged into a CRLF
sequence with a following `\n`.
* `__halt_compiler` is no longer recognized as a semi-reserved keyword, in line with PHP behavior.
* `<?=` is no longer recognized as a semi-reserved keyword.
* Fix handling of very large overflowing `\u` escape sequences.
### Removed
* Removed deprecated `Error` constructor taking a line number instead of an attributes array.
Version 5.0.0-alpha1 (2022-09-04)
---------------------------------

@@ -2,3 +2,31 @@
This project uses PSR-12 with consistent brace placement. This means that the opening brace is
always on the same line, even for class and method declarations.
## Tools
This project uses PHP-CS-Fixer and PHPStan. You can invoke them using `make`:
```shell
make php-cs-fixer
make phpstan
```
## Adding support for new PHP syntax
1. If necessary, add emulation support for new tokens.
* Add a new subclass of `Lexer\TokenEmulator`. Take inspiration from existing classes.
* Add the new class to the array in `Lexer\Emulative`.
* Add tests for the emulation in `Lexer\EmulativeTest`. You'll want to modify
`provideTestReplaceKeywords()` for new reserved keywords and `provideTestLexNewFeatures()` for
other emulations.
2. Add any new node classes that are needed.
3. Add support for the new syntax in `grammar/php.y`. Regenerate the parser by running
`php grammar/rebuildParsers.php`. Use `--debug` if there are conflicts.
4. Add pretty-printing support by implementing a `pFooBar()` method in `PrettyPrinter\Standard`.
5. Add tests both in `test/code/parser` and `test/code/prettyPrinter`.
6. Add support for formatting-preserving pretty-printing. This is done by modifying the data tables
at the end of `PrettyPrinterAbstract`. Add a test in `test/code/formatPreservation`.
7. Does the new syntax feature namespaced names? If so, add support for name resolution in
`NodeVisitor\NameResolver`. Test it in `NodeVisitor\NameResolverTest`.
8. Does the new syntax require any changes to builders? Is so, make them :)

10
Makefile Normal file

@@ -0,0 +1,10 @@
.PHONY: phpstan php-cs-fixer
tools/vendor:
composer install -d tools
phpstan: tools/vendor
tools/vendor/bin/phpstan
php-cs-fixer: tools/vendor
tools/vendor/bin/php-cs-fixer fix

@@ -6,11 +6,9 @@ PHP Parser
This is a PHP parser written in PHP. Its purpose is to simplify static code analysis and
manipulation.
[Documentation for version 5.x][doc_master] (in development; for running on PHP >= 7.1; for parsing PHP 7.0 to PHP 8.2, with limited support for parsing PHP 5.x).
[**Documentation for version 5.x**][doc_master] (current; for running on PHP >= 7.4; for parsing PHP 7.0 to PHP 8.3, with limited support for parsing PHP 5.x).
[**Documentation for version 4.x**][doc_4_x] (stable; for running on PHP >= 7.0; for parsing PHP 5.2 to PHP 8.2).
[Documentation for version 3.x][doc_3_x] (unsupported; for running on PHP >= 5.5; for parsing PHP 5.2 to PHP 7.2).
[Documentation for version 4.x][doc_4_x] (supported; for running on PHP >= 7.0; for parsing PHP 5.2 to PHP 8.3).
Features
--------
@@ -70,12 +68,17 @@ This dumps an AST looking something like this:
```
array(
0: Stmt_Function(
attrGroups: array(
)
byRef: false
name: Identifier(
name: test
)
params: array(
0: Param(
attrGroups: array(
)
flags: 0
type: null
byRef: false
variadic: false
@@ -90,12 +93,11 @@ array(
0: Stmt_Expression(
expr: Expr_FuncCall(
name: Name(
parts: array(
0: var_dump
)
name: var_dump
)
args: array(
0: Arg(
name: null
value: Expr_Variable(
name: foo
)
@@ -137,12 +139,16 @@ This gives us an AST where the `Function_::$stmts` are empty:
```
array(
0: Stmt_Function(
attrGroups: array(
)
byRef: false
name: Identifier(
name: test
)
params: array(
0: Param(
attrGroups: array(
)
type: null
byRef: false
variadic: false
@@ -205,9 +211,8 @@ Component documentation:
* [AST builders](doc/component/AST_builders.markdown)
* Fluent builders for AST nodes
* [Lexer](doc/component/Lexer.markdown)
* Lexer options
* Token and file positions for nodes
* Custom attributes
* Emulation
* Tokens, positions and attributes
* [Error handling](doc/component/Error_handling.markdown)
* Column information for errors
* Error recovery (parsing of syntactically incorrect code)

@@ -3,7 +3,7 @@ Upgrading from PHP-Parser 4.x to 5.0
### PHP version requirements
PHP-Parser now requires PHP 7.1 or newer to run. It is however still possible to *parse* code for older versions, while running on a newer version.
PHP-Parser now requires PHP 7.4 or newer to run. It is however still possible to *parse* code for older versions, while running on a newer version.
### PHP 5 parsing support
@@ -13,6 +13,7 @@ In particular, if an older `PhpVersion` is specified, then:
* For versions before PHP 7.0, `$foo =& new Bar()` assignments are allowed without error.
* For versions before PHP 7.0, invalid octal literals `089` are allowed without error.
* For versions before PHP 7.0, unicode escape sequences `\u{123}` in strings are not parsed.
* Type hints are interpreted as a class `Name` or as a built-in `Identifier` depending on PHP
version, for example `int` is treated as a class name on PHP 5.6 and as a built-in on PHP 7.0.
@@ -27,16 +28,17 @@ The following symbols are affected by this removal:
* The `PhpParser\Parser\Php5` class has been removed.
* The `PhpParser\Parser\Multiple` class has been removed. While not strictly related to PHP 5 support, this functionality is no longer useful without it.
* The `PhpParser\ParserFactory::ONLY_PHP5` and `PREFER_PHP5` options have been removed.
* The `PhpParser\ParserFactory::PREFER_PHP7` option is now equivalent to `ONLY_PHP7`.
### Changes to the parser factory
The `ParserFactory::create()` method is deprecated in favor of three new methods that provide more fine-grained control over the PHP version being targeted:
The `ParserFactory::create()` method has been removed in favor of three new methods that provide more fine-grained control over the PHP version being targeted:
* `createForNewestSupportedVersion()`: Use this if you don't know the PHP version of the code you're parsing. It's better to assume a too new version than a too old one.
* `createForHostVersion()`: Use this if you're parsing code for the PHP version you're running on.
* `createForVersion()`: Use this if you know the PHP version of the code you want to parse.
The `createForNewestSupportedVersion()` and `creatForHostVersion()` are available since PHP-Parser 4.18.0, to allow libraries to support PHP-Parser 4 and 5 at the same time more easily.
In all cases, the PHP version is a fairly weak hint that is only used on a best-effort basis. The parser will usually accept code for newer versions if it does not have any backwards-compatibility implications.
For example, if you specify version `"8.0"`, then `class ReadOnly {}` is treated as a valid class declaration, while using `public readonly int $prop` will lead to a parse error. However, `final public const X = Y;` will be accepted in both cases.
@@ -45,7 +47,7 @@ For example, if you specify version `"8.0"`, then `class ReadOnly {}` is treated
use PhpParser\ParserFactory;
use PhpParser\PhpVersion;
$factory = new ParserFactory;
$factory = new ParserFactory();
# Before
$parser = $factory->create(ParserFactory::PREFER_PHP7);
@@ -61,6 +63,35 @@ $parser = $factory->create(ParserFactory::ONLY_PHP5);
$parser = $factory->createForVersion(PhpVersion::fromString("5.6"));
```
### Changes to the throw representation
Previously, `throw` statements like `throw $e;` were represented using the `Stmt\Throw_` class,
while uses inside other expressions (such as `$x ?? throw $e`) used the `Expr\Throw_` class.
Now, `throw $e;` is represented as a `Stmt\Expression` that contains an `Expr\Throw_`. The
`Stmt\Throw_` class has been removed.
```php
# Code
throw $e;
# Before
Stmt_Throw(
expr: Expr_Variable(
name: e
)
)
# After
Stmt_Expression(
expr: Expr_Throw(
expr: Expr_Variable(
name: e
)
)
)
```
### Changes to the array destructuring representation
Previously, the `list($x) = $y` destructuring syntax was represented using a `Node\Expr\List_`
@@ -71,6 +102,177 @@ Now, destructuring is always represented using `Node\Expr\List_`. The `kind` att
`Node\Expr\List_::KIND_LIST` or `Node\Expr\List_::KIND_ARRAY` specifies which syntax was actually
used.
```php
# Code
[$x] = $y;
# Before
Expr_Assign(
var: Expr_Array(
items: array(
0: Expr_ArrayItem(
key: null
value: Expr_Variable(
name: x
)
byRef: false
unpack: false
)
)
)
expr: Expr_Variable(
name: y
)
)
# After
Expr_Assign(
var: Expr_List(
items: array(
0: ArrayItem(
key: null
value: Expr_Variable(
name: x
)
byRef: false
unpack: false
)
)
)
expr: Expr_Variable(
name: y
)
)
```
### Changes to the name representation
Previously, `Name` nodes had a `parts` subnode, which stores an array of name parts, split by
namespace separators. Now, `Name` nodes instead have a `name` subnode, which stores a plain string.
For example, the name `Foo\Bar` was previously represented by `Name(parts: ['Foo', 'Bar'])` and is
now represented by `Name(name: 'Foo\Bar')` instead.
It is possible to convert the name to the previous representation using `$name->getParts()`. The
`Name` constructor continues to accept both the string and the array representation.
The `Name::getParts()` method is available since PHP-Parser 4.16.0, to allow libraries to support
PHP-Parser 4 and 5 at the same time more easily.
### Changes to the block representation
Previously, code blocks `{ ... }` were always flattened into their parent statement list. For
example `while ($x) { $a; { $b; } $c; }` would produce the same node structure as
`if ($x) { $a; $b; $c; }`, namely a `Stmt\While_` node whose `stmts` subnode is an array of three
statements.
Now, the nested `{ $b; }` block is represented using an explicit `Stmt\Block` node. However, the
outer `{ $a; { $b; } $c; }` block is still represented using a simple array in the `stmts` subnode.
```php
# Code
while ($x) { $a; { $b; } $c; }
# Before
Stmt_While(
cond: Expr_Variable(
name: x
)
stmts: array(
0: Stmt_Expression(
expr: Expr_Variable(
name: a
)
)
1: Stmt_Expression(
expr: Expr_Variable(
name: b
)
)
2: Stmt_Expression(
expr: Expr_Variable(
name: c
)
)
)
)
# After
Stmt_While(
cond: Expr_Variable(
name: x
)
stmts: array(
0: Stmt_Expression(
expr: Expr_Variable(
name: a
)
)
1: Stmt_Block(
stmts: array(
0: Stmt_Expression(
expr: Expr_Variable(
name: b
)
)
)
)
2: Stmt_Expression(
expr: Expr_Variable(
name: c
)
)
)
)
```
### Changes to comment assignment
Previously, comments were assigned to all nodes starting at the same position. Now they will be
assigned to the outermost node only.
```php
# Code
// Comment
$a + $b;
# Before
Stmt_Expression(
expr: Expr_BinaryOp_Plus(
left: Expr_Variable(
name: a
comments: array(
0: // Comment
)
)
right: Expr_Variable(
name: b
)
comments: array(
0: // Comment
)
)
comments: array(
0: // Comment
)
)
# After
Stmt_Expression(
expr: Expr_BinaryOp_Plus(
left: Expr_Variable(
name: a
)
right: Expr_Variable(
name: b
)
)
comments: array(
0: // Comment
)
)
```
### Renamed nodes
A number of AST nodes have been renamed or moved in the AST hierarchy:
@@ -93,7 +295,7 @@ The old class names have been retained as aliases for backwards compatibility. H
Modifier flags (as used by the `$flags` subnode of `Class_`, `ClassMethod`, `Property`, etc.) are now available as class constants on a separate `PhpParser\Modifiers` class, instead of being part of `PhpParser\Node\Stmt\Class_`, to make it clearer that these are used by many different nodes. The old constants are deprecated, but are still available.
```
```php
PhpParser\Node\Stmt\Class_::MODIFIER_PUBLIC -> PhpParser\Modifiers::PUBLIC
PhpParser\Node\Stmt\Class_::MODIFIER_PROTECTED -> PhpParser\Modifiers::PROTECTED
PhpParser\Node\Stmt\Class_::MODIFIER_PRIVATE -> PhpParser\Modifiers::PRIVATE
@@ -104,7 +306,22 @@ PhpParser\Node\Stmt\Class_::MODIFIER_READONLY -> PhpParser\Modifiers::READONLY
PhpParser\Node\Stmt\Class_::VISIBILITY_MODIFIER_MASK -> PhpParser\Modifiers::VISIBILITY_MASK
```
### Changes to the default pretty printer
### Changes to node constructors
Node constructor arguments accepting types now longer accept plain strings. Either an `Identifier` or `Name` (or `ComplexType`) should be passed instead. This affects the following constructor arguments:
* The `'returnType'` key of `$subNodes` argument of `Node\Expr\ArrowFunction`.
* The `'returnType'` key of `$subNodes` argument of `Node\Expr\Closure`.
* The `'returnType'` key of `$subNodes` argument of `Node\Stmt\ClassMethod`.
* The `'returnType'` key of `$subNodes` argument of `Node\Stmt\Function_`.
* The `$type` argument of `Node\NullableType`.
* The `$type` argument of `Node\Param`.
* The `$type` argument of `Node\Stmt\Property`.
* The `$type` argument of `Node\ClassConst`.
To follow the previous behavior, an `Identifier` should be passed, which indicates a built-in type.
### Changes to the pretty printer
A number of changes to the standard pretty printer have been made, to make it match contemporary coding style conventions (and in particular PSR-12). Options to restore the previous behavior are not provided, but it is possible to override the formatting methods (such as `pStmt_ClassMethod`) with your preferred formatting.
@@ -156,12 +373,100 @@ Backslashes in single-quoted strings are now only printed if they are necessary:
'\\\\';
```
The pretty printer now accepts a `phpVersion` option, which accepts a `PhpVersion` object and defaults to PHP 7.0. The pretty printer will make formatting choices to make the code valid for that version. It currently controls the following behavior:
`else if` structures will now omit redundant parentheses:
```php
# Before
else {
if ($x) {
// ...
}
}
# After
else if ($x) {
// ...
}
```
The pretty printer now accepts a `phpVersion` option, which accepts a `PhpVersion` object and defaults to PHP 7.4. The pretty printer will make formatting choices to make the code valid for that version. It currently controls the following behavior:
* For PHP >= 7.0 (default), short array syntax `[]` will be used by default. This does not affect nodes that specify an explicit array syntax using the `kind` attribute.
* For PHP >= 7.1, the short array syntax `[]` will be used for destructuring by default (instead of
`list()`). This does not affect nodes that specify and explicit syntax using the `kind` attribute.
* For PHP >= 7.3, a newline is no longer forced after heredoc/nowdoc strings, as the requirement for this has been removed with the introduction of flexible heredoc/nowdoc strings.
* For PHP >= 7.0 (default), parentheses around `yield` expressions will only be printed when necessary. Previously, parentheses were always printed, even if `yield` was used as a statement.
* For PHP >= 7.1 (default), the short array syntax `[]` will be used for destructuring by default (instead of `list()`). This does not affect nodes that specify an explicit syntax using the `kind` attribute.
* For PHP >= 7.3 (default), a newline is no longer forced after heredoc/nowdoc strings, as the requirement for this has been removed with the introduction of flexible heredoc/nowdoc strings.
* For PHP >= 7.3 (default), heredoc/nowdoc strings are now indented just like regular code. This was allowed with the introduction of flexible heredoc/nowdoc strings.
### Changes to precedence handling in the pretty printer
The pretty printer now more accurately models operator precedence. Especially for unary operators, less unnecessary parentheses will be printed. Conversely, many bugs where semantically meaningful parentheses were omitted have been fixed.
To support these changes, precedence is now handled differently in the pretty printer. The internal `p()` method, which is used to recursively print nodes, now has the following signature:
```php
protected function p(
Node $node, int $precedence = self::MAX_PRECEDENCE, int $lhsPrecedence = self::MAX_PRECEDENCE,
bool $parentFormatPreserved = false
): string;
```
The `$precedence` is the precedence of the direct parent operator (if any), while `$lhsPrecedence` is that precedence of the nearest binary operator on whose left-hand-side the node occurs. For unary operators, only the `$lhsPrecedence` is relevant.
Recursive calls in pretty-printer methods should generally continue calling `p()` without additional parameters. However, pretty-printer methods for operators that participate in precedence resolution need to be adjusted. For example, typical implementations for operators look as follows now:
```php
protected function pExpr_BinaryOp_Plus(
BinaryOp\Plus $node, int $precedence, int $lhsPrecedence
): string {
return $this->pInfixOp(
BinaryOp\Plus::class, $node->left, ' + ', $node->right, $precedence, $lhsPrecedence);
}
protected function pExpr_UnaryPlus(
Expr\UnaryPlus $node, int $precedence, int $lhsPrecedence
): string {
return $this->pPrefixOp(Expr\UnaryPlus::class, '+', $node->expr, $precedence, $lhsPrecedence);
}
```
The new `$precedence` and `$lhsPrecedence` arguments need to be passed down to the `pInfixOp()`, `pPrefixOp()` and `pPostfixOp()` methods.
### Changes to the node traverser
If there are multiple visitors, the node traverser will now call `leaveNode()` and `afterTraverse()` methods in the reverse order of the corresponding `enterNode()` and `beforeTraverse()` calls:
```php
# Before
$visitor1->enterNode($node);
$visitor2->enterNode($node);
$visitor1->leaveNode($node);
$visitor2->leaveNode($node);
# After
$visitor1->enterNode($node);
$visitor2->enterNode($node);
$visitor2->leaveNode($node);
$visitor1->leaveNode($node);
```
Additionally, the special `NodeVisitor` return values have been moved from `NodeTraverser` to `NodeVisitor`. The old names are deprecated, but still available.
```php
PhpParser\NodeTraverser::REMOVE_NODE -> PhpParser\NodeVisitor::REMOVE_NODE
PhpParser\NodeTraverser::DONT_TRAVERSE_CHILDREN -> PhpParser\NodeVisitor::DONT_TRAVERSE_CHILDREN
PhpParser\NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN -> PhpParser\NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN
PhpParser\NodeTraverser::STOP_TRAVERSAL -> PhpParser\NodeVisitor::STOP_TRAVERSAL
```
Visitors can now also be passed directly to the `NodeTraverser` constructor:
```php
# Before (and still supported)
$traverser = new NodeTraverser();
$traverser->addVisitor(new NameResolver());
# After
$traverser = new NodeTraverser(new NameResolver());
```
### Changes to token representation
@@ -180,9 +485,50 @@ class Token {
}
```
The `Lexer::getTokens()` method will now return an array of `Token`s, rather than an array of arrays and strings.
The token array is now an array of `Token`s, rather than an array of arrays and strings.
Additionally, the token array is now terminated by a sentinel token with ID 0.
### Other removed functionality
### Changes to the lexer
The lexer API is reduced to a single `Lexer::tokenize()` method, which returns an array of tokens. The `startLexing()` and `getNextToken()` methods have been removed.
Responsibility for determining start and end attributes for nodes has been moved from the lexer to the parser. The lexer no longer accepts an options array. The `usedAttributes` option has been removed without replacement, and the parser will now unconditionally add the `comments`, `startLine`, `endLine`, `startFilePos`, `endFilePos`, `startTokenPos` and `endTokenPos` attributes.
There should no longer be a need to directly interact with the `Lexer` for end users, as the `ParserFactory` will create an appropriate instance, and no additional configuration of the lexer is necessary. To use formatting-preserving pretty printing, the setup boilerplate changes as follows:
```php
# Before
$lexer = new Lexer\Emulative([
'usedAttributes' => [
'comments',
'startLine', 'endLine',
'startTokenPos', 'endTokenPos',
],
]);
$parser = new Parser\Php7($lexer);
$oldStmts = $parser->parse($code);
$oldTokens = $lexer->getTokens();
$traverser = new NodeTraverser();
$traverser->addVisitor(new NodeVisitor\CloningVisitor());
$newStmts = $traverser->traverse($oldStmts);
# After
$parser = (new ParserFactory())->createForNewestSupportedVersion();
$oldStmts = $parser->parse($code);
$oldTokens = $parser->getTokens();
$traverser = new NodeTraverser(new NodeVisitor\CloningVisitor());
$newStmts = $traverser->traverse($oldStmts);
```
### Miscellaneous changes
* The deprecated `Builder\Param::setTypeHint()` method has been removed in favor of `Builder\Param::setType()`.
* The deprecated `Error` constructor taking a start line has been removed. Pass `['startLine' => $startLine]` attributes instead.
* The deprecated `Comment::getLine()`, `Comment::getTokenPos()` and `Comment::getFilePos()` methods have been removed. Use `Comment::getStartLine()`, `Comment::getStartTokenPos()` and `Comment::getStartFilePos()` instead.
* `Comment::getReformattedText()` now normalizes CRLF newlines to LF newlines.
* The `Node::getLine()` method has been deprecated. Use `Node::getStartLine()` instead.

@@ -26,10 +26,7 @@ if (empty($files)) {
showHelp("Must specify at least one file.");
}
$lexerOptions = ['usedAttributes' => [
'startLine', 'endLine', 'startFilePos', 'endFilePos', 'comments'
]];
$parser = (new PhpParser\ParserFactory())->createForVersion($attributes['version'], $lexerOptions);
$parser = (new PhpParser\ParserFactory())->createForVersion($attributes['version']);
$dumper = new PhpParser\NodeDumper([
'dumpComments' => true,
'dumpPositions' => $attributes['with-positions'],
@@ -40,7 +37,10 @@ $traverser = new PhpParser\NodeTraverser();
$traverser->addVisitor(new PhpParser\NodeVisitor\NameResolver);
foreach ($files as $file) {
if (strpos($file, '<?php') === 0) {
if ($file === '-') {
$code = file_get_contents('php://stdin');
fwrite(STDERR, "====> Stdin:\n");
} else if (strpos($file, '<?php') === 0) {
$code = $file;
fwrite(STDERR, "====> Code $code\n");
} else {
@@ -194,7 +194,7 @@ function parseArgs($args) {
default:
if (preg_match('/^--version=(.*)$/', $arg, $matches)) {
$attributes['version'] = PhpParser\PhpVersion::fromString($matches[1]);
} elseif ($arg[0] === '-') {
} elseif ($arg[0] === '-' && \strlen($arg[0]) > 1) {
showHelp("Invalid operation $arg.");
} else {
$files[] = $arg;

@@ -13,13 +13,13 @@
}
],
"require": {
"php": ">=7.1",
"php": ">=7.4",
"ext-tokenizer": "*",
"ext-json": "*",
"ext-ctype": "*"
},
"require-dev": {
"phpunit/phpunit": "^6.5 || ^7.0 || ^8.0 || ^9.0",
"phpunit/phpunit": "^7.0 || ^8.0 || ^9.0",
"ircmaxell/php-yacc": "^0.0.7"
},
"extra": {

@@ -13,14 +13,14 @@ application dealing with code programmatically. A parser constructs an [Abstract
There are other ways of processing source code. One that PHP supports natively is using the
token stream generated by [`token_get_all`][2]. The token stream is much more low level than
the AST and thus has different applications: It allows to also analyze the exact formatting of
a file. On the other hand the token stream is much harder to deal with for more complex analysis.
a file. On the other hand, the token stream is much harder to deal with for more complex analysis.
For example, an AST abstracts away the fact that, in PHP, variables can be written as `$foo`, but also
as `$$bar`, `${'foobar'}` or even `${!${''}=barfoo()}`. You don't have to worry about recognizing
all the different syntaxes from a stream of tokens.
Another question is: Why would I want to have a PHP parser *written in PHP*? Well, PHP might not be
a language especially suited for fast parsing, but processing the AST is much easier in PHP than it
would be in other, faster languages like C. Furthermore the people most probably wanting to do
would be in other, faster languages like C. Furthermore the people most likely wanting to do
programmatic PHP code analysis are incidentally PHP developers, not C developers.
What can it parse?
@@ -43,7 +43,7 @@ following caveats:
As the parser is based on the tokens returned by `token_get_all` (which is only able to lex the PHP
version it runs on), additionally a wrapper for emulating tokens from newer versions is provided.
This allows to parse PHP 8.0 source code running on PHP 7.1, for example. This emulation is not
This allows to parse PHP 8.3 source code running on PHP 7.4, for example. This emulation is not
perfect, but works well in practice.
Finally, it should be noted that the parser aims to accept all valid code, not reject all invalid
@@ -81,16 +81,16 @@ However, it does retain accurate position information, which can be used to insp
What else can it do?
--------------------
Apart from the parser itself this package also bundles support for some other, related features:
Apart from the parser itself, this package also bundles support for some other, related features:
* Support for pretty printing, which is the act of converting an AST into PHP code. Please note
that "pretty printing" does not imply that the output is especially pretty. It's just how it's
called ;)
* Support for serializing and unserializing the node tree to JSON
* Support for serializing and unserializing the node tree to JSON.
* Support for dumping the node tree in a human-readable form (see the section above for an
example of how the output looks like)
* Infrastructure for traversing and changing the AST (node traverser and node visitors)
* A node visitor for resolving namespaced names
example of how the output looks like).
* Infrastructure for traversing and changing the AST (node traverser and node visitors).
* A node visitor for resolving namespaced names.
[0]: http://en.wikipedia.org/wiki/Static_program_analysis
[1]: http://en.wikipedia.org/wiki/Abstract_syntax_tree

@@ -50,7 +50,7 @@ The `createXYZ()` methods optionally accept an array of lexer options. Some use
customized lexer options are discussed in the [lexer documentation](component/Lexer.markdown).
Subsequently, you can pass PHP code (including the opening `<?php` tag) to the `parse()` method in
order to create a syntax tree. If a syntax error is encountered, an `PhpParser\Error` exception will
order to create a syntax tree. If a syntax error is encountered, a `PhpParser\Error` exception will
be thrown by default:
```php
@@ -72,7 +72,7 @@ try {
$stmts = $parser->parse($code);
// $stmts is an array of statement nodes
} catch (Error $e) {
echo 'Parse Error: ', $e->getMessage();
echo 'Parse Error: ', $e->getMessage(), "\n";
}
```
@@ -96,12 +96,17 @@ For the sample code from the previous section, this will produce the following o
```
array(
0: Stmt_Function(
attrGroups: array(
)
byRef: false
name: Identifier(
name: printLine
)
params: array(
0: Param(
attrGroups: array(
)
flags: 0
type: null
byRef: false
variadic: false
@@ -129,12 +134,11 @@ array(
1: Stmt_Expression(
expr: Expr_FuncCall(
name: Name(
parts: array(
0: printLine
)
name: printLine
)
args: array(
0: Arg(
name: null
value: Scalar_String(
value: Hello World!!!
)
@@ -202,11 +206,13 @@ without the `PhpParser\Node\` prefix and `\` replaced with `_`. It also does not
It is possible to associate custom metadata with a node using the `setAttribute()` method. This data
can then be retrieved using `hasAttribute()`, `getAttribute()` and `getAttributes()`.
By default the lexer adds the `startLine`, `endLine` and `comments` attributes. `comments` is an array
of `PhpParser\Comment[\Doc]` instances.
By default, the parser adds the `startLine`, `endLine`, `startTokenPos`, `endTokenPos`,
`startFilePos`, `endFilePos` and `comments` attributes. `comments` is an array of
`PhpParser\Comment[\Doc]` instances.
The start line can also be accessed using `getStartLine()` (instead of `getAttribute('startLine')`).
The last doc comment from the `comments` attribute can be obtained using `getDocComment()`.
The pre-defined attributes can also be accessed using `getStartLine()` instead of
`getAttribute('startLine')`, and so on. The last doc comment from the `comments` attribute can be
obtained using `getDocComment()`.
Pretty printer
--------------
@@ -240,7 +246,7 @@ try {
echo $code;
} catch (Error $e) {
echo 'Parse Error: ', $e->getMessage();
echo 'Parse Error: ', $e->getMessage(), "\n";
}
```
@@ -248,7 +254,7 @@ The above code will output:
echo 'Hello ', hi\getTarget();
As you can see the source code was first parsed using `PhpParser\Parser->parse()`, then changed and then
As you can see, the source code was first parsed using `PhpParser\Parser->parse()`, then changed and then
again converted to code using `PhpParser\PrettyPrinter\Standard->prettyPrint()`.
The `prettyPrint()` method pretty prints a statements array. It is also possible to pretty print only a
@@ -343,15 +349,18 @@ i.e. before its subnodes are traversed, the latter when it is left.
All four methods can either return the changed node or not return at all (i.e. `null`) in which
case the current node is not changed.
The `enterNode()` method can additionally return the value `NodeTraverser::DONT_TRAVERSE_CHILDREN`,
The `enterNode()` method can additionally return the value `NodeVisitor::DONT_TRAVERSE_CHILDREN`,
which instructs the traverser to skip all children of the current node. To furthermore prevent subsequent
visitors from visiting the current node, `NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN` can be used instead.
visitors from visiting the current node, `NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN` can be used instead.
Both methods can additionally return the value `NodeTraverser::REMOVE_NODE`, in which
case the current node will be removed from the parent array. Furthermore, it is possible to return
an array of nodes, which will be merged into the parent array at the offset of the current node.
I.e. if in `array(A, B, C)` the node `B` should be replaced with `array(X, Y, Z)` the result will
be `array(A, X, Y, Z, C)`.
Both methods can additionally return the following values:
* `NodeVisitor::STOP_TRAVERSAL`, in which case no further nodes will be visited.
* `NodeVisitor::REMOVE_NODE`, in which case the current node will be removed from the parent array.
* `NodeVisitor::REPLACE_WITH_NULL`, in which case the current node will be replaced with `null`.
* An array of nodes, which will be merged into the parent array at the offset of the current node.
I.e. if in `array(A, B, C)` the node `B` should be replaced with `array(X, Y, Z)` the result will
be `array(A, X, Y, Z, C)`.
Instead of manually implementing the `NodeVisitor` interface you can also extend the `NodeVisitorAbstract`
class, which will define empty default implementations for all the above methods.
@@ -386,7 +395,7 @@ declarations that contains the namespaced name instead of only the shortname tha
Example: Converting namespaced code to pseudo namespaces
--------------------------------------------------------
A small example to understand the concept: We want to convert namespaced code to pseudo namespaces
A small example to understand the concept: We want to convert namespaced code to pseudo namespaces,
so it works on 5.2, i.e. names like `A\\B` should be converted to `A_B`. Note that such conversions
are fairly complicated if you take PHP's dynamic features into account, so our conversion will
assume that no dynamic features are used.
@@ -438,7 +447,7 @@ foreach ($files as $file) {
}
```
Now lets start with the main code, the `NodeVisitor\NamespaceConverter`. One thing it needs to do
Now lets start with the main code, the `NamespaceConverter`. One thing it needs to do
is convert `A\\B` style names to `A_B` style ones.
```php
@@ -493,7 +502,7 @@ The last thing we need to do is remove the `namespace` and `use` statements:
```php
use PhpParser\Node;
use PhpParser\Node\Stmt;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitor;
class NodeVisitor_NamespaceConverter extends \PhpParser\NodeVisitorAbstract
{
@@ -513,7 +522,7 @@ class NodeVisitor_NamespaceConverter extends \PhpParser\NodeVisitorAbstract
return $node->stmts;
} elseif ($node instanceof Stmt\Use_) {
// remove use nodes altogether
return NodeTraverser::REMOVE_NODE;
return NodeVisitor::REMOVE_NODE;
}
}
}

@@ -27,9 +27,8 @@ Component documentation
* [AST builders](component/AST_builders.markdown)
* Fluent builders for AST nodes
* [Lexer](component/Lexer.markdown)
* Lexer options
* Token and file positions for nodes
* Custom attributes
* Emulation
* Tokens, positions and attributes
* [Error handling](component/Error_handling.markdown)
* Column information for errors
* Error recovery (parsing of syntactically incorrect code)

@@ -15,9 +15,10 @@ accessed through `getNode()`. Fluent builders are available for
the following syntactic elements:
* namespaces and use statements
* classes, interfaces and traits
* classes, interfaces, traits and enums
* methods, functions and parameters
* properties
* properties, class constants and enum cases
* trait uses and trait use adaptations
Here is an example:
@@ -95,13 +96,13 @@ abstract class SomeOtherClass extends SomeClass implements A\Few, \Interfaces
AnotherTrait::func insteadof SecondTrait;
}
protected $someProperty;
private $anotherProperty = array(1, 2, 3);
private $anotherProperty = [1, 2, 3];
/**
* This method does something.
*
* @param SomeClass And takes a parameter
*/
public abstract function someMethod(SomeClass $someParam): bool;
abstract public function someMethod(SomeClass $someParam): bool;
protected function anotherMethod($someParam = 'test')
{
print $someParam;
@@ -133,6 +134,8 @@ nodes. The following methods are currently available:
* `propertyFetch($var, $name)`: Creates a property fetch node. Converts `$name` to an `Identifier`
node.
* `concat(...$exprs)`: Create a tree of `BinaryOp\Concat` nodes for the given expressions.
* `attribute($name, $args)`: Create a `Attribute` node. Converts `$name` to a `Name` node and
normalizes arguments.
These methods may be expanded on an as-needed basis. Please open an issue or PR if a common
operation is missing.

@@ -70,6 +70,7 @@ expressions, apart from the following:
* `Expr\ConstFetch` (only null/false/true are handled)
* `Expr\ClassConstFetch`
* `Expr\New_` (since PHP 8.1)
* `Expr\PropertyFetch` (since PHP 8.2)
Handling these expression types requires non-local information, such as which global constants are
defined. By default, the evaluator will throw a `ConstExprEvaluationException` when it encounters
@@ -84,7 +85,7 @@ specifying an evaluation fallback function:
use PhpParser\{ConstExprEvaluator, ConstExprEvaluationException};
use PhpParser\Node\Expr;
$evalutator = new ConstExprEvaluator(function(Expr $expr) {
$evaluator = new ConstExprEvaluator(function(Expr $expr) {
if ($expr instanceof Expr\ConstFetch) {
return fetchConstantSomehow($expr);
}
@@ -97,7 +98,7 @@ $evalutator = new ConstExprEvaluator(function(Expr $expr) {
});
try {
$evalutator->evaluateSilently($someExpr);
$evaluator->evaluateSilently($someExpr);
} catch (ConstExprEvaluationException $e) {
// Handle exception
}

@@ -4,29 +4,12 @@ Error handling
Errors during parsing or analysis are represented using the `PhpParser\Error` exception class. In addition to an error
message, an error can also store additional information about the location the error occurred at.
How much location information is available depends on the origin of the error and how many lexer attributes have been
enabled. At a minimum the start line of the error is usually available.
How much location information is available depends on the origin of the error. At a minimum the start line of the error
is usually available.
Column information
------------------
In order to receive information about not only the line, but also the column span an error occurred at, the file
position attributes in the lexer need to be enabled:
```php
$lexerOptions = array(
'usedAttributes' => array('comments', 'startLine', 'endLine', 'startFilePos', 'endFilePos'),
);
$parser = (new PhpParser\ParserFactory())->createForHostVersion($lexerOptions);
try {
$stmts = $parser->parse($code);
// ...
} catch (PhpParser\Error $e) {
// ...
}
```
Before using column information, its availability needs to be checked with `$e->hasColumnInfo()`, as the precise
location of an error cannot always be determined. The methods for retrieving column information also have to be passed
the source code of the parsed file. An example for printing an error:

@@ -16,8 +16,7 @@ use PhpParser\ParserFactory;
$code = '...';
$traverser = new NodeTraverser;
$traverser->addVisitor(new ParentConnectingVisitor);
$traverser = new NodeTraverser(new ParentConnectingVisitor);
$parser = (new ParserFactory())->createForHostVersion();
$ast = $parser->parse($code);
@@ -39,8 +38,7 @@ use PhpParser\ParserFactory;
$code = '...';
$traverser = new NodeTraverser;
$traverser->addVisitor(new NodeConnectingVisitor);
$traverser = new NodeTraverser(new NodeConnectingVisitor);
$parser = (new ParserFactory())->createForHostVersion();
$ast = $parser->parse($code);

@@ -35,65 +35,6 @@ This will result in the following output (which includes attributes):
[
{
"nodeType": "Stmt_Function",
"byRef": false,
"name": {
"nodeType": "Identifier",
"name": "printLine",
"attributes": {
"startLine": 4,
"endLine": 4
}
},
"params": [
{
"nodeType": "Param",
"type": null,
"byRef": false,
"variadic": false,
"var": {
"nodeType": "Expr_Variable",
"name": "msg",
"attributes": {
"startLine": 4,
"endLine": 4
}
},
"default": null,
"attributes": {
"startLine": 4,
"endLine": 4
}
}
],
"returnType": null,
"stmts": [
{
"nodeType": "Stmt_Echo",
"exprs": [
{
"nodeType": "Expr_Variable",
"name": "msg",
"attributes": {
"startLine": 5,
"endLine": 5
}
},
{
"nodeType": "Scalar_String",
"value": "\n",
"attributes": {
"startLine": 5,
"endLine": 5,
"kind": 2
}
}
],
"attributes": {
"startLine": 5,
"endLine": 5
}
}
],
"attributes": {
"startLine": 4,
"comments": [
@@ -101,12 +42,79 @@ This will result in the following output (which includes attributes):
"nodeType": "Comment_Doc",
"text": "\/** @param string $msg *\/",
"line": 3,
"filePos": 9,
"tokenPos": 2
"filePos": 7,
"tokenPos": 2,
"endLine": 3,
"endFilePos": 31,
"endTokenPos": 2
}
],
"endLine": 6
}
},
"byRef": false,
"name": {
"nodeType": "Identifier",
"attributes": {
"startLine": 4,
"endLine": 4
},
"name": "printLine"
},
"params": [
{
"nodeType": "Param",
"attributes": {
"startLine": 4,
"endLine": 4
},
"type": null,
"byRef": false,
"variadic": false,
"var": {
"nodeType": "Expr_Variable",
"attributes": {
"startLine": 4,
"endLine": 4
},
"name": "msg"
},
"default": null,
"flags": 0,
"attrGroups": []
}
],
"returnType": null,
"stmts": [
{
"nodeType": "Stmt_Echo",
"attributes": {
"startLine": 5,
"endLine": 5
},
"exprs": [
{
"nodeType": "Expr_Variable",
"attributes": {
"startLine": 5,
"endLine": 5
},
"name": "msg"
},
{
"nodeType": "Scalar_String",
"attributes": {
"startLine": 5,
"endLine": 5
"kind": 2,
"rawValue": "\"\\n\""
},
"value": "\n"
}
]
}
],
"attrGroups": [],
"namespacedName": null
}
]
```

@@ -1,41 +1,79 @@
Lexer component documentation
=============================
The lexer is responsible for providing tokens to the parser. The project comes with two lexers: `PhpParser\Lexer` and
`PhpParser\Lexer\Emulative`. The latter is an extension of the former, which adds the ability to emulate tokens of
newer PHP versions and thus allows parsing of new code on older versions.
The lexer is responsible for providing tokens to the parser. Typical use of the library does not require direct
interaction with the lexer, as an appropriate lexer is created by `PhpParser\ParserFactory`. The tokens produced
by the lexer can then be retrieved using `PhpParser\Parser::getTokens()`.
This documentation discusses options available for the default lexers and explains how lexers can be extended.
Emulation
---------
Lexer options
-------------
While this library implements a custom parser, it relies on PHP's `ext/tokenizer` extension to perform lexing. However,
this extension only supports lexing code for the PHP version you are running on, while this library also wants to support
parsing newer code. For that reason, the lexer performs additional "emulation" in three layers:
The two default lexers accept an `$options` array in the constructor. Currently only the `'usedAttributes'` option is
supported, which allows you to specify which attributes will be added to the AST nodes. The attributes can then be
accessed using `$node->getAttribute()`, `$node->setAttribute()`, `$node->hasAttribute()` and `$node->getAttributes()`
methods. A sample options array:
First, PhpParser uses the `PhpToken` based representation introduced in PHP 8.0, rather than the array-based tokens from
previous versions. The `PhpParser\Token` class either extends `PhpToken` (on PHP 8.0) or a polyfill implementation. The
polyfill implementation will also perform two emulations that are required by the parser and cannot be disabled:
* Single-line comments use the PHP 8.0 representation that does not include a trailing newline. The newline will be
part of a following `T_WHITESPACE` token.
* Namespaced names use the PHP 8.0 representation using `T_NAME_FULLY_QUALIFIED`, `T_NAME_QUALIFIED` and
`T_NAME_RELATIVE` tokens, rather than the previous representation using a sequence of `T_STRING` and `T_NS_SEPARATOR`.
This means that certain code that is legal on older versions (namespaced names including whitespace, such as `A \ B`)
will not be accepted by the parser.
Second, the `PhpParser\Lexer` base class will convert `&` tokens into the PHP 8.1 representation of either
`T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG` or `T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG`. This is required by the parser
and cannot be disabled.
Finally, `PhpParser\Lexer\Emulative` performs other, optional emulations. This lexer is parameterized by `PhpVersion`
and will try to emulate `ext/tokenizer` output for that version. This is done using separate `TokenEmulator`s for each
emulated feature.
Emulation is usually used to support newer PHP versions, but there is also very limited support for reverse emulation to
older PHP versions, which can make keywords from newer versions non-reserved.
Tokens, positions and attributes
--------------------------------
The `Lexer::tokenize()` method returns an array of `PhpParser\Token`s. The most important parts of the interface can be
summarized as follows:
```php
$lexer = new PhpParser\Lexer(array(
'usedAttributes' => array(
'comments', 'startLine', 'endLine'
)
));
class Token {
/** @var int Token ID, either T_* or ord($char) for single-character tokens. */
public int $id;
/** @var string The textual content of the token. */
public string $text;
/** @var int The 1-based starting line of the token (or -1 if unknown). */
public int $line;
/** @var int The 0-based starting position of the token (or -1 if unknown). */
public int $pos;
/** @param int|string|(int|string)[] $kind Token ID or text (or array of them) */
public function is($kind): bool;
}
```
The attributes used in this example match the default behavior of the lexer. The following attributes are supported:
Unlike PHP's own `PhpToken::tokenize()` output, the token array is terminated by a sentinel token with ID 0.
* `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. Use of this attribute is required for the
`$node->getComments()` and `$node->getDocComment()` methods to work. The attribute is also needed if you wish the pretty
printer to retain comments present in the original code.
* `startLine`: Line in which the node starts. This attribute is required for the `$node->getLine()` to work. It is also
required if syntax errors should contain line number information.
* `endLine`: Line in which the node ends. Required for `$node->getEndLine()`.
* `startTokenPos`: Offset into the token array of the first token in the node. Required for `$node->getStartTokenPos()`.
* `endTokenPos`: Offset into the token array of the last token in the node. Required for `$node->getEndTokenPos()`.
* `startFilePos`: Offset into the code string of the first character that is part of the node. Required for `$node->getStartFilePos()`.
* `endFilePos`: Offset into the code string of the last character that is part of the node. Required for `$node->getEndFilePos()`.
The lexer is normally invoked implicitly by the parser. In that case, the tokens for the last parse can be retrieved
using `Parser::getTokens()`.
Nodes in the AST produced by the parser always corresponds to some range of tokens. The parser adds a number of
positioning attributes to allow mapping nodes back to lines, tokens or file offsets:
* `startLine`: Line in which the node starts. Used by `$node->getStartLine()`.
* `endLine`: Line in which the node ends. Used by `$node->getEndLine()`.
* `startTokenPos`: Offset into the token array of the first token in the node. Used by `$node->getStartTokenPos()`.
* `endTokenPos`: Offset into the token array of the last token in the node. Used by `$node->getEndTokenPos()`.
* `startFilePos`: Offset into the code string of the first character that is part of the node. Used by `$node->getStartFilePos()`.
* `endFilePos`: Offset into the code string of the last character that is part of the node. Used by `$node->getEndFilePos()`.
Note that `start`/`end` here are closed rather than half-open ranges. This means that a node consisting of a single
token will have `startTokenPos == endTokenPos` rather than `startTokenPos + 1 == endTokenPos`. This also means that a
zero-length node will have `startTokenPos -1 == endTokenPos`.
### Using token positions
@@ -73,89 +111,16 @@ class MyNodeVisitor extends PhpParser\NodeVisitorAbstract {
}
}
$lexerOptions = array(
'usedAttributes' => array(
'comments', 'startLine', 'endLine', 'startTokenPos', 'endTokenPos'
)
);
$parser = (new PhpParser\ParserFactory())->createForHostVersion($lexerOptions);
$visitor = new MyNodeVisitor();
$traverser = new PhpParser\NodeTraverser();
$traverser->addVisitor($visitor);
$traverser = new PhpParser\NodeTraverser($visitor);
try {
$stmts = $parser->parse($code);
$visitor->setTokens($lexer->getTokens());
$visitor->setTokens($parser->getTokens());
$stmts = $traverser->traverse($stmts);
} catch (PhpParser\Error $e) {
echo 'Parse Error: ', $e->getMessage();
}
```
The same approach can also be used to perform specific modifications in the code, without changing the formatting in
other places (which is the case when using the pretty printer).
Lexer extension
---------------
A lexer has to define the following public interface:
```php
function startLexing(string $code, ErrorHandler $errorHandler = null): void;
function getTokens(): array;
function handleHaltCompiler(): string;
function getNextToken(string &$value = null, array &$startAttributes = null, array &$endAttributes = null): int;
```
The `startLexing()` method is invoked whenever the `parse()` method of the parser is called and is passed the source
code that is to be lexed (including the opening tag). It can be used to reset state or preprocess the source code or tokens. The
passed `ErrorHandler` should be used to report lexing errors.
The `getTokens()` method returns the current array of `PhpParser\Token`s, which are compatible with the PHP 8 `PhpToken`
class. This method is not used by the parser (which uses `getNextToken()`), but is useful in combination with the token
position attributes.
The `handleHaltCompiler()` method is called whenever a `T_HALT_COMPILER` token is encountered. It has to return the
remaining string after the construct (not including `();`).
The `getNextToken()` method returns the ID of the next token (in the sense of `Token::$id`). If no more
tokens are available it must return `0`, which is the ID of the `EOF` token. Furthermore, the string content of the
token should be written into the by-reference `$value` parameter (which will then be available as `$n` in the parser).
### Attribute handling
The other two by-ref variables `$startAttributes` and `$endAttributes` define which attributes will eventually be
assigned to the generated nodes: The parser will take the `$startAttributes` from the first token which is part of the
node and the `$endAttributes` from the last token that is part of the node.
E.g. if the tokens `T_FUNCTION T_STRING ... '{' ... '}'` constitute a node, then the `$startAttributes` from the
`T_FUNCTION` token will be taken and the `$endAttributes` from the `'}'` token.
An application of custom attributes is storing the exact original formatting of literals: While the parser does retain
some information about the formatting of integers (like decimal vs. hexadecimal) or strings (like used quote type), it
does not preserve the exact original formatting (e.g. leading zeros for integers or escape sequences in strings). This
can be remedied by storing the original value in an attribute:
```php
use PhpParser\Lexer;
use PhpParser\Parser\Tokens;
class KeepOriginalValueLexer extends Lexer // or Lexer\Emulative
{
public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
$tokenId = parent::getNextToken($value, $startAttributes, $endAttributes);
if ($tokenId == \T_CONSTANT_ENCAPSED_STRING // non-interpolated string
|| $tokenId == \T_ENCAPSED_AND_WHITESPACE // interpolated string
|| $tokenId == \T_LNUMBER // integer
|| $tokenId == \T_DNUMBER // floating point number
) {
// could also use $startAttributes, doesn't really matter here
$endAttributes['originalValue'] = $value;
}
return $tokenId;
}
}
```

@@ -24,7 +24,7 @@ $stmts = $nodeTraverser->traverse($stmts);
In the default configuration, the name resolver will perform three actions:
* Declarations of functions, classes, interfaces, traits and global constants will have a
* Declarations of functions, classes, interfaces, traits, enums and global constants will have a
`namespacedName` property added, which contains the function/class/etc name including the
namespace prefix. For historic reasons this is a **property** rather than an attribute.
* Names will be replaced by fully qualified resolved names, which are instances of
@@ -32,7 +32,7 @@ In the default configuration, the name resolver will perform three actions:
* Unqualified function and constant names inside a namespace cannot be statically resolved. Inside
a namespace `Foo`, a call to `strlen()` may either refer to the namespaced `\Foo\strlen()`, or
the global `\strlen()`. Because PHP-Parser does not have the necessary context to decide this,
such names are left unresolved. Additionally a `namespacedName` **attribute** is added to the
such names are left unresolved. Additionally, a `namespacedName` **attribute** is added to the
name node.
The name resolver accepts an option array as the second argument, with the following default values:
@@ -47,7 +47,7 @@ $nameResolver = new PhpParser\NodeVisitor\NameResolver(null, [
If the `preserveOriginalNames` option is enabled, then the resolved (fully qualified) name will have
an `originalName` attribute, which contains the unresolved name.
If the `replaceNodes` option is disabled, then names will no longer be resolved in-place. Instead a
If the `replaceNodes` option is disabled, then names will no longer be resolved in-place. Instead, a
`resolvedName` attribute will be added to each name, which contains the resolved (fully qualified)
name. Once again, if an unqualified function or constant name cannot be resolved, then the
`resolvedName` attribute will not be present, and instead a `namespacedName` attribute is added.
@@ -75,7 +75,7 @@ class NameContext {
}
```
The `$type` parameters accept on of the `Stmt\Use_::TYPE_*` constants, which represent the three
The `$type` parameters accept one of the `Stmt\Use_::TYPE_*` constants, which represent the three
basic symbol types in PHP (functions, constants and everything else).
Next to name resolution, the `NameContext` also supports the reverse operation of finding a short

@@ -40,26 +40,5 @@ parse multiple files.
When possible, objects should be reused rather than being newly instantiated for every use. Some
objects have expensive initialization procedures, which will be unnecessarily repeated if the object
is not reused. (Currently two objects with particularly expensive setup are lexers and pretty
is not reused. (Currently two objects with particularly expensive setup are parsers and pretty
printers, though the details might change between versions of this library.)
Garbage collection
------------------
A limitation in PHP's cyclic garbage collector may lead to major performance degradation when the
active working set exceeds 10000 objects (or arrays). Especially when parsing very large files this
limit is significantly exceeded and PHP will spend the majority of time performing unnecessary
garbage collection attempts.
Without GC, parsing time is roughly linear in the input size. With GC, this degenerates to quadratic
runtime for large files. While the specifics may differ, as a rough guideline you may expect a 2.5x
GC overhead for 500KB files and a 5x overhead for 1MB files.
Because this a limitation in PHP's implementation, there is no easy way to work around this. If
possible, you should avoid parsing very large files, as they will impact overall execution time
disproportionally (and are usually generated anyway).
Of course, you can also try to (temporarily) disable GC. By design the AST generated by PHP-Parser
is cycle-free, so the AST itself will never cause leaks with GC disabled. However, other code
(including for example the parser object itself) may hold cycles, so disabling of GC should be
approached with care.

@@ -31,16 +31,29 @@ expression.
Customizing the formatting
--------------------------
The pretty printer respects a number of `kind` attributes used by some notes (e.g., whether an
integer should be printed as decimal, hexadecimal, etc). Additionally, it supports two options:
The pretty printer respects a number of `kind` attributes used by some nodes (e.g., whether an
integer should be printed as decimal, hexadecimal, etc). Additionally, it supports three options:
* `phpVersion` (defaults to 7.0) allows opting into formatting that is not supported by older PHP
* `phpVersion` (defaults to 7.4) allows opting into formatting that is not supported by older PHP
versions.
* `newline` (defaults to `"\n"`) can be set to `"\r\n"` in order to produce Windows newlines.
* `shortArraySyntax` determines the used array syntax if the `kind` attribute is not set. This is
a legacy option, and `phpVersion` should be used to control this behavior instead.
However, the default pretty printer does not provide any functionality for fine-grained
customization of code formatting.
The behaviors controlled by `phpVersion` (defaults to PHP 7.4) are:
* For PHP >= 7.0, short array syntax `[]` will be used by default. This does not affect nodes that
specify an explicit array syntax using the `kind` attribute.
* For PHP >= 7.0, parentheses around `yield` expressions will only be printed when necessary.
* For PHP >= 7.1, the short array syntax `[]` will be used for destructuring by default (instead of
`list()`). This does not affect nodes that specify and explicit syntax using the `kind` attribute.
* For PHP >= 7.3, a newline is no longer forced after heredoc/nowdoc strings, as the requirement
for this has been removed with the introduction of flexible heredoc/nowdoc strings.
* For PHP >= 7.3, heredoc/nowdoc strings are indented just like regular code. This was allowed with
the introduction of flexible heredoc/nowdoc strings.
The default pretty printer does not provide functionality for fine-grained customization of code
formatting.
If you want to make minor changes to the formatting, the easiest way is to extend the pretty printer
and override the methods responsible for the node types you are interested in.
@@ -63,29 +76,19 @@ code which has been modified or newly inserted.
Use of the formatting-preservation functionality requires some additional preparatory steps:
```php
use PhpParser\{Lexer, NodeTraverser, NodeVisitor, ParserFactory, PrettyPrinter};
$lexerOptions = new [
'usedAttributes' => [
'comments',
'startLine', 'endLine',
'startTokenPos', 'endTokenPos',
],
];
$parser = (new ParserFactory())->createForHostVersion($lexerOptions);
$traverser = new NodeTraverser();
$traverser->addVisitor(new NodeVisitor\CloningVisitor());
$printer = new PrettyPrinter\Standard();
use PhpParser\{NodeTraverser, NodeVisitor, ParserFactory, PrettyPrinter};
$parser = (new ParserFactory())->createForHostVersion();
$oldStmts = $parser->parse($code);
$oldTokens = $lexer->getTokens();
$oldTokens = $parser->getTokens();
// Run CloningVisitor before making changes to the AST.
$traverser = new NodeTraverser(new NodeVisitor\CloningVisitor());
$newStmts = $traverser->traverse($oldStmts);
// MODIFY $newStmts HERE
$printer = new PrettyPrinter\Standard();
$newCode = $printer->printFormatPreserving($newStmts, $oldStmts, $oldTokens);
```
@@ -94,5 +97,5 @@ If you make use of the name resolution functionality, you will likely want to di
the AST and causing spurious changes to the pretty printed code. For more information, see the
[name resolution documentation](Name_resolution.markdown).
The formatting-preservation works on a best-effort basis and may sometimes reformat more code tha
The formatting-preservation works on a best-effort basis and may sometimes reformat more code than
necessary. If you encounter problems while using this functionality, please open an issue.

@@ -21,6 +21,18 @@ $stmts = ...;
$modifiedStmts = $traverser->traverse($stmts);
```
Visitors can be either passed to the `NodeTraverser` constructor, or added using `addVisitor()`:
```php
$traverser = new NodeTraverser($visitor1, $visitor2, $visitor3);
// Equivalent to:
$traverser = new NodeTraverser();
$traverser->addVisitor($visitor1);
$traverser->addVisitor($visitor2);
$traverser->addVisitor($visitor3);
```
Node visitors
-------------
@@ -47,20 +59,19 @@ For example, if we have the following excerpt of an AST
```
Expr_FuncCall(
name: Name(
parts: array(
0: printLine
)
)
args: array(
0: Arg(
value: Scalar_String(
value: Hello World!!!
)
byRef: false
unpack: false
)
)
name: Name(
name: printLine
)
args: array(
0: Arg(
name: null
value: Scalar_String(
value: Hello World!!!
)
byRef: false
unpack: false
)
)
)
```
@@ -129,13 +140,13 @@ Now `$a && $b` will be replaced by `!($a && $b)`. Then the traverser will go int
only) child of `!($a && $b)`, which is `$a && $b`. The transformation applies again and we end up
with `!!($a && $b)`. This will continue until PHP hits the memory limit.
Finally, there are two special replacement types. The first is removal of a node:
Finally, there are three special replacement types. The first is removal of a node:
```php
public function leaveNode(Node $node) {
if ($node instanceof Node\Stmt\Return_) {
// Remove all return statements
return NodeTraverser::REMOVE_NODE;
return NodeVisitor::REMOVE_NODE;
}
}
```
@@ -155,7 +166,7 @@ public function leaveNode(Node $node) {
&& $node->expr->name instanceof Node\Name
&& $node->expr->name->toString() === 'var_dump'
) {
return NodeTraverser::REMOVE_NODE;
return NodeVisitor::REMOVE_NODE;
}
}
```
@@ -164,6 +175,20 @@ This example will remove all calls to `var_dump()` which occur as expression sta
that `var_dump($a);` will be removed, but `if (var_dump($a))` will not be removed (and there is no
obvious way in which it can be removed).
Another way to remove nodes is to replace them with `null`. For example, all `else` statements could
be removed as follows:
```php
public function leaveNode(Node $node) {
if ($node instanceof Node\Stmt\Else_) {
return NodeVisitor::REPLACE_WITH_NULL;
}
}
```
This is only safe to do if the subnode the node is stored in is nullable. `Node\Stmt\Else_` only
occurs inside `Node\Stmt\If_::$else`, which is nullable, so this particular replacement is safe.
Next to removing nodes, it is also possible to replace one node with multiple nodes. This
only works if the parent structure is an array.
@@ -197,7 +222,7 @@ private $classes = [];
public function enterNode(Node $node) {
if ($node instanceof Node\Stmt\Class_) {
$this->classes[] = $node;
return NodeTraverser::DONT_TRAVERSE_CHILDREN;
return NodeVisitor::DONT_TRAVERSE_CHILDREN;
}
}
```
@@ -217,7 +242,7 @@ public function enterNode(Node $node) {
$node->namespacedName->toString() === 'Foo\Bar\Baz'
) {
$this->class = $node;
return NodeTraverser::STOP_TRAVERSAL;
return NodeVisitor::STOP_TRAVERSAL;
}
}
```
@@ -255,13 +280,14 @@ $visitorA->enterNode(Stmt_Return)
$visitorB->enterNode(Stmt_Return)
$visitorA->enterNode(Expr_Variable)
$visitorB->enterNode(Expr_Variable)
$visitorA->leaveNode(Expr_Variable)
$visitorB->leaveNode(Expr_Variable)
$visitorA->leaveNode(Stmt_Return)
$visitorA->leaveNode(Expr_Variable)
$visitorB->leaveNode(Stmt_Return)
$visitorA->leaveNode(Stmt_Return)
```
That is, when visiting a node, enterNode and leaveNode will always be called for all visitors.
That is, when visiting a node, `enterNode()` and `leaveNode()` will always be called for all
visitors, with the `leaveNode()` calls happening in the reverse order of the `enterNode()` calls.
Running multiple visitors in parallel improves performance, as the AST only has to be traversed
once. However, it is not always possible to write visitors in a way that allows interleaved
execution. In this case, you can always fall back to performing multiple traversals:
@@ -286,6 +312,7 @@ special enterNode/leaveNode return values:
* If a visitor returns a replacement node, subsequent visitors will be passed the replacement node,
not the original one.
* If a visitor returns `REMOVE_NODE`, subsequent visitors will not see this node.
* If a visitor returns `REPLACE_WITH_NULL`, subsequent visitors will not see this node.
* If a visitor returns an array of replacement nodes, subsequent visitors will see neither the node
that was replaced, nor the replacement nodes.
@@ -332,5 +359,6 @@ be accessed: From parents to children. However, it can often be convenient to op
reverse direction: When working on a node, you might want to check if the parent node satisfies a
certain property.
PHP-Parser does not add parent (or sibling) references to nodes by itself, but you can easily
emulate this with a visitor. See the [FAQ](FAQ.markdown) for more information.
PHP-Parser does not add parent (or sibling) references to nodes by default, but you can enable them
using the `ParentConnectingVisitor` or `NodeConnectingVisitor`. See the [FAQ](FAQ.markdown) for
more information.

@@ -1,7 +1,7 @@
<?php declare(strict_types=1);
$meta #
#semval($) $this->semValue
#semval($,%t) $this->semValue
#semval($) $self->semValue
#semval($,%t) $self->semValue
#semval(%n) $stackPos-(%l-%n)
#semval(%n,%t) $stackPos-(%l-%n)
@@ -28,82 +28,80 @@ class #(-p) extends \PhpParser\ParserAbstract
public const %s = %n;
#endtokenval
protected $tokenToSymbolMapSize = #(YYMAXLEX);
protected $actionTableSize = #(YYLAST);
protected $gotoTableSize = #(YYGLAST);
protected int $tokenToSymbolMapSize = #(YYMAXLEX);
protected int $actionTableSize = #(YYLAST);
protected int $gotoTableSize = #(YYGLAST);
protected $invalidSymbol = #(YYBADCH);
protected $errorSymbol = #(YYINTERRTOK);
protected $defaultAction = #(YYDEFAULT);
protected $unexpectedTokenRule = #(YYUNEXPECTED);
protected int $invalidSymbol = #(YYBADCH);
protected int $errorSymbol = #(YYINTERRTOK);
protected int $defaultAction = #(YYDEFAULT);
protected int $unexpectedTokenRule = #(YYUNEXPECTED);
protected $YY2TBLSTATE = #(YY2TBLSTATE);
protected $numNonLeafStates = #(YYNLSTATES);
protected int $YY2TBLSTATE = #(YY2TBLSTATE);
protected int $numNonLeafStates = #(YYNLSTATES);
protected $symbolToName = array(
protected array $symbolToName = array(
#listvar terminals
);
protected $tokenToSymbol = array(
protected array $tokenToSymbol = array(
#listvar yytranslate
);
protected $action = array(
protected array $action = array(
#listvar yyaction
);
protected $actionCheck = array(
protected array $actionCheck = array(
#listvar yycheck
);
protected $actionBase = array(
protected array $actionBase = array(
#listvar yybase
);
protected $actionDefault = array(
protected array $actionDefault = array(
#listvar yydefault
);
protected $goto = array(
protected array $goto = array(
#listvar yygoto
);
protected $gotoCheck = array(
protected array $gotoCheck = array(
#listvar yygcheck
);
protected $gotoBase = array(
protected array $gotoBase = array(
#listvar yygbase
);
protected $gotoDefault = array(
protected array $gotoDefault = array(
#listvar yygdefault
);
protected $ruleToNonTerminal = array(
protected array $ruleToNonTerminal = array(
#listvar yylhs
);
protected $ruleToLength = array(
protected array $ruleToLength = array(
#listvar yylen
);
#if -t
protected $productions = array(
protected array $productions = array(
#production-strings;
);
#endif
protected function initReduceCallbacks() {
protected function initReduceCallbacks(): void {
$this->reduceCallbacks = [
#reduce
%n => function ($stackPos) {
%n => static function ($self, $stackPos) {
%b
},
#noact
%n => function ($stackPos) {
$this->semValue = $this->semStack[$stackPos];
},
%n => null,
#endreduce
];
}

@@ -134,7 +134,7 @@ top_statement_list_ex:
top_statement_list:
top_statement_list_ex
{ makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
{ makeZeroLengthNop($nop);
if ($nop !== null) { $1[] = $nop; } $$ = $1; }
;
@@ -145,13 +145,14 @@ ampersand:
reserved_non_modifiers:
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_INSTANCEOF | T_NEW | T_CLONE | T_EXIT | T_IF | T_ELSEIF | T_ELSE | T_ENDIF | 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_CLASS_C | T_TRAIT_C | T_FUNC_C | T_METHOD_C | T_LINE | T_FILE | T_DIR | T_NS_C | T_FN
| T_MATCH | T_ENUM
| T_ECHO { $$ = $1; if ($$ === "<?=") $this->emitError(new Error('Cannot use "<?=" as an identifier', attributes())); }
;
semi_reserved:
@@ -184,7 +185,7 @@ namespace_name:
;
legacy_namespace_name:
namespace_name { $$ = $1; }
namespace_name
| T_NAME_FULLY_QUALIFIED { $$ = Name[substr($1, 1)]; }
;
@@ -228,15 +229,15 @@ attributes:
optional_attributes:
/* empty */ { $$ = []; }
| attributes { $$ = $1; }
| attributes
;
top_statement:
statement { $$ = $1; }
| function_declaration_statement { $$ = $1; }
| class_declaration_statement { $$ = $1; }
statement
| function_declaration_statement
| class_declaration_statement
| T_HALT_COMPILER '(' ')' ';'
{ $$ = Stmt\HaltCompiler[$this->lexer->handleHaltCompiler()]; }
{ $$ = Stmt\HaltCompiler[$this->handleHaltCompiler()]; }
| T_NAMESPACE namespace_declaration_name semi
{ $$ = Stmt\Namespace_[$2, null];
$$->setAttribute('kind', Stmt\Namespace_::KIND_SEMICOLON);
@@ -251,7 +252,7 @@ top_statement:
$this->checkNamespace($$); }
| T_USE use_declarations semi { $$ = Stmt\Use_[$2, Stmt\Use_::TYPE_NORMAL]; }
| T_USE use_type use_declarations semi { $$ = Stmt\Use_[$3, $2]; }
| group_use_declaration semi { $$ = $1; }
| group_use_declaration semi
| T_CONST constant_declaration_list semi { $$ = Stmt\Const_[$2]; }
;
@@ -268,7 +269,7 @@ group_use_declaration:
;
unprefixed_use_declarations:
non_empty_unprefixed_use_declarations optional_comma { $$ = $1; }
non_empty_unprefixed_use_declarations optional_comma
;
non_empty_unprefixed_use_declarations:
@@ -278,7 +279,7 @@ non_empty_unprefixed_use_declarations:
;
use_declarations:
non_empty_use_declarations no_comma { $$ = $1; }
non_empty_use_declarations no_comma
;
non_empty_use_declarations:
@@ -287,7 +288,7 @@ non_empty_use_declarations:
;
inline_use_declarations:
non_empty_inline_use_declarations optional_comma { $$ = $1; }
non_empty_inline_use_declarations optional_comma
;
non_empty_inline_use_declarations:
@@ -316,7 +317,7 @@ inline_use_declaration:
;
constant_declaration_list:
non_empty_constant_declaration_list no_comma { $$ = $1; }
non_empty_constant_declaration_list no_comma
;
non_empty_constant_declaration_list:
@@ -330,7 +331,7 @@ constant_declaration:
;
class_const_list:
non_empty_class_const_list no_comma { $$ = $1; }
non_empty_class_const_list no_comma
;
non_empty_class_const_list:
@@ -339,7 +340,10 @@ non_empty_class_const_list:
;
class_const:
identifier_maybe_reserved '=' expr { $$ = Node\Const_[$1, $3]; }
T_STRING '=' expr
{ $$ = Node\Const_[new Node\Identifier($1, stackAttributes(#1)), $3]; }
| semi_reserved '=' expr
{ $$ = Node\Const_[new Node\Identifier($1, stackAttributes(#1)), $3]; }
;
inner_statement_list_ex:
@@ -349,34 +353,26 @@ inner_statement_list_ex:
inner_statement_list:
inner_statement_list_ex
{ makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
{ makeZeroLengthNop($nop);
if ($nop !== null) { $1[] = $nop; } $$ = $1; }
;
inner_statement:
statement { $$ = $1; }
| function_declaration_statement { $$ = $1; }
| class_declaration_statement { $$ = $1; }
statement
| function_declaration_statement
| class_declaration_statement
| T_HALT_COMPILER
{ throw new Error('__HALT_COMPILER() can only be used from the outermost scope', attributes()); }
;
non_empty_statement:
'{' inner_statement_list '}'
{
if ($2) {
$$ = $2; prependLeadingComments($$);
} else {
makeNop($$, $this->startAttributeStack[#1], $this->endAttributes);
if (null === $$) { $$ = array(); }
}
}
| T_IF '(' expr ')' statement elseif_list else_single
{ $$ = Stmt\If_[$3, ['stmts' => toArray($5), 'elseifs' => $6, 'else' => $7]]; }
'{' inner_statement_list '}' { $$ = Stmt\Block[$2]; }
| T_IF '(' expr ')' blocklike_statement elseif_list else_single
{ $$ = Stmt\If_[$3, ['stmts' => $5, 'elseifs' => $6, 'else' => $7]]; }
| T_IF '(' expr ')' ':' inner_statement_list new_elseif_list new_else_single T_ENDIF ';'
{ $$ = Stmt\If_[$3, ['stmts' => $6, 'elseifs' => $7, 'else' => $8]]; }
| T_WHILE '(' expr ')' while_statement { $$ = Stmt\While_[$3, $5]; }
| T_DO statement T_WHILE '(' expr ')' ';' { $$ = Stmt\Do_ [$5, toArray($2)]; }
| T_DO blocklike_statement T_WHILE '(' expr ')' ';' { $$ = Stmt\Do_ [$5, $2]; }
| T_FOR '(' for_expr ';' for_expr ';' for_expr ')' for_statement
{ $$ = Stmt\For_[['init' => $3, 'cond' => $5, 'loop' => $7, 'stmts' => $9]]; }
| T_SWITCH '(' expr ')' switch_case_list { $$ = Stmt\Switch_[$3, $5]; }
@@ -386,17 +382,11 @@ non_empty_statement:
| T_GLOBAL global_var_list semi { $$ = Stmt\Global_[$2]; }
| T_STATIC static_var_list semi { $$ = Stmt\Static_[$2]; }
| T_ECHO expr_list_forbid_comma semi { $$ = Stmt\Echo_[$2]; }
| T_INLINE_HTML { $$ = Stmt\InlineHTML[$1]; }
| expr semi {
$e = $1;
if ($e instanceof Expr\Throw_) {
// For backwards-compatibility reasons, convert throw in statement position into
// Stmt\Throw_ rather than Stmt\Expression(Expr\Throw_).
$$ = Stmt\Throw_[$e->expr];
} else {
$$ = Stmt\Expression[$e];
}
| T_INLINE_HTML {
$$ = Stmt\InlineHTML[$1];
$$->setAttribute('hasLeadingNewline', $this->inlineHtmlHasLeadingNewline(#1));
}
| expr semi { $$ = Stmt\Expression[$1]; }
| T_UNSET '(' variables_list ')' semi { $$ = Stmt\Unset_[$3]; }
| T_FOREACH '(' expr T_AS foreach_variable ')' foreach_statement
{ $$ = Stmt\Foreach_[$3, $5[0], ['keyVar' => null, 'byRef' => $5[1], 'stmts' => $7]]; }
@@ -409,14 +399,16 @@ non_empty_statement:
{ $$ = Stmt\TryCatch[$3, $5, $6]; $this->checkTryCatch($$); }
| T_GOTO identifier_not_reserved semi { $$ = Stmt\Goto_[$2]; }
| identifier_not_reserved ':' { $$ = Stmt\Label[$1]; }
| error { $$ = array(); /* means: no statement */ }
| error { $$ = null; /* means: no statement */ }
;
statement:
non_empty_statement { $$ = $1; }
| ';'
{ makeNop($$, $this->startAttributeStack[#1], $this->endAttributes);
if ($$ === null) $$ = array(); /* means: no statement */ }
non_empty_statement
| ';' { makeNop($$); }
;
blocklike_statement:
statement { toBlock($1); }
;
catches:
@@ -440,7 +432,7 @@ optional_finally:
;
variables_list:
non_empty_variables_list optional_comma { $$ = $1; }
non_empty_variables_list optional_comma
;
non_empty_variables_list:
@@ -468,15 +460,23 @@ block_or_error:
| error { $$ = []; }
;
identifier_maybe_readonly:
identifier_not_reserved
| T_READONLY { $$ = Node\Identifier[$1]; }
;
function_declaration_statement:
T_FUNCTION optional_ref identifier_not_reserved '(' parameter_list ')' optional_return_type block_or_error
T_FUNCTION optional_ref identifier_maybe_readonly '(' parameter_list ')' optional_return_type block_or_error
{ $$ = Stmt\Function_[$3, ['byRef' => $2, 'params' => $5, 'returnType' => $7, 'stmts' => $8, 'attrGroups' => []]]; }
| attributes T_FUNCTION optional_ref identifier_not_reserved '(' parameter_list ')' optional_return_type block_or_error
| attributes T_FUNCTION optional_ref identifier_maybe_readonly '(' parameter_list ')' optional_return_type block_or_error
{ $$ = Stmt\Function_[$4, ['byRef' => $3, 'params' => $6, 'returnType' => $8, 'stmts' => $9, 'attrGroups' => $1]]; }
;
class_declaration_statement:
optional_attributes class_entry_type identifier_not_reserved extends_from implements_list '{' class_statement_list '}'
class_entry_type identifier_not_reserved extends_from implements_list '{' class_statement_list '}'
{ $$ = Stmt\Class_[$2, ['type' => $1, 'extends' => $3, 'implements' => $4, 'stmts' => $6, 'attrGroups' => []]];
$this->checkClass($$, #2); }
| attributes class_entry_type identifier_not_reserved extends_from implements_list '{' class_statement_list '}'
{ $$ = Stmt\Class_[$3, ['type' => $2, 'extends' => $4, 'implements' => $5, 'stmts' => $7, 'attrGroups' => $1]];
$this->checkClass($$, #3); }
| optional_attributes T_INTERFACE identifier_not_reserved interface_extends_list '{' class_statement_list '}'
@@ -500,11 +500,11 @@ enum_case_expr:
class_entry_type:
T_CLASS { $$ = 0; }
| class_modifiers T_CLASS { $$ = $1; }
| class_modifiers T_CLASS
;
class_modifiers:
class_modifier { $$ = $1; }
class_modifier
| class_modifiers class_modifier { $this->checkClassModifier($1, $2, #2); $$ = $1 | $2; }
;
@@ -530,7 +530,7 @@ implements_list:
;
class_name_list:
non_empty_class_name_list no_comma { $$ = $1; }
non_empty_class_name_list no_comma
;
non_empty_class_name_list:
@@ -539,23 +539,23 @@ non_empty_class_name_list:
;
for_statement:
statement { $$ = toArray($1); }
blocklike_statement
| ':' inner_statement_list T_ENDFOR ';' { $$ = $2; }
;
foreach_statement:
statement { $$ = toArray($1); }
blocklike_statement
| ':' inner_statement_list T_ENDFOREACH ';' { $$ = $2; }
;
declare_statement:
non_empty_statement { $$ = toArray($1); }
non_empty_statement { toBlock($1); }
| ';' { $$ = null; }
| ':' inner_statement_list T_ENDDECLARE ';' { $$ = $2; }
;
declare_list:
non_empty_declare_list no_comma { $$ = $1; }
non_empty_declare_list no_comma
;
non_empty_declare_list:
@@ -595,7 +595,7 @@ match:
match_arm_list:
/* empty */ { $$ = []; }
| non_empty_match_arm_list optional_comma { $$ = $1; }
| non_empty_match_arm_list optional_comma
;
non_empty_match_arm_list:
@@ -609,7 +609,7 @@ match_arm:
;
while_statement:
statement { $$ = toArray($1); }
blocklike_statement { $$ = $1; }
| ':' inner_statement_list T_ENDWHILE ';' { $$ = $2; }
;
@@ -619,7 +619,7 @@ elseif_list:
;
elseif:
T_ELSEIF '(' expr ')' statement { $$ = Stmt\ElseIf_[$3, toArray($5)]; }
T_ELSEIF '(' expr ')' blocklike_statement { $$ = Stmt\ElseIf_[$3, $5]; }
;
new_elseif_list:
@@ -628,17 +628,19 @@ new_elseif_list:
;
new_elseif:
T_ELSEIF '(' expr ')' ':' inner_statement_list { $$ = Stmt\ElseIf_[$3, $6]; }
T_ELSEIF '(' expr ')' ':' inner_statement_list
{ $$ = Stmt\ElseIf_[$3, $6]; $this->fixupAlternativeElse($$); }
;
else_single:
/* empty */ { $$ = null; }
| T_ELSE statement { $$ = Stmt\Else_[toArray($2)]; }
| T_ELSE blocklike_statement { $$ = Stmt\Else_[$2]; }
;
new_else_single:
/* empty */ { $$ = null; }
| T_ELSE ':' inner_statement_list { $$ = Stmt\Else_[$3]; }
| T_ELSE ':' inner_statement_list
{ $$ = Stmt\Else_[$3]; $this->fixupAlternativeElse($$); }
;
foreach_variable:
@@ -650,7 +652,7 @@ foreach_variable:
;
parameter_list:
non_empty_parameter_list optional_comma { $$ = $1; }
non_empty_parameter_list optional_comma
| /* empty */ { $$ = array(); }
;
@@ -687,14 +689,14 @@ parameter:
;
type_expr:
type { $$ = $1; }
type
| '?' type { $$ = Node\NullableType[$2]; }
| union_type { $$ = Node\UnionType[$1]; }
| intersection_type { $$ = $1; }
| intersection_type
;
type:
type_without_static { $$ = $1; }
type_without_static
| T_STATIC { $$ = Node\Name['static']; }
;
@@ -705,8 +707,8 @@ type_without_static:
;
union_type_element:
type { $$ = $1; }
| '(' intersection_type ')' { $$ = $2; }
type
| '(' intersection_type ')' { $$ = $2; }
;
union_type:
@@ -715,7 +717,7 @@ union_type:
;
union_type_without_static_element:
type_without_static { $$ = $1; }
type_without_static
| '(' intersection_type_without_static ')' { $$ = $2; }
;
@@ -746,15 +748,15 @@ intersection_type_without_static:
;
type_expr_without_static:
type_without_static { $$ = $1; }
type_without_static
| '?' type_without_static { $$ = Node\NullableType[$2]; }
| union_type_without_static { $$ = Node\UnionType[$1]; }
| intersection_type_without_static { $$ = $1; }
| intersection_type_without_static
;
optional_type_without_static:
/* empty */ { $$ = null; }
| type_expr_without_static { $$ = $1; }
| type_expr_without_static
;
optional_return_type:
@@ -787,7 +789,7 @@ argument:
;
global_var_list:
non_empty_global_var_list no_comma { $$ = $1; }
non_empty_global_var_list no_comma
;
non_empty_global_var_list:
@@ -796,11 +798,11 @@ non_empty_global_var_list:
;
global_var:
simple_variable { $$ = $1; }
simple_variable
;
static_var_list:
non_empty_static_var_list no_comma { $$ = $1; }
non_empty_static_var_list no_comma
;
non_empty_static_var_list:
@@ -814,13 +816,13 @@ static_var:
;
class_statement_list_ex:
class_statement_list_ex class_statement { if ($2 !== null) { push($1, $2); } }
class_statement_list_ex class_statement { if ($2 !== null) { push($1, $2); } else { $$ = $1; } }
| /* empty */ { init(); }
;
class_statement_list:
class_statement_list_ex
{ makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
{ makeZeroLengthNop($nop);
if ($nop !== null) { $1[] = $nop; } $$ = $1; }
;
@@ -831,6 +833,9 @@ class_statement:
| optional_attributes method_modifiers T_CONST class_const_list semi
{ $$ = new Stmt\ClassConst($4, $2, attributes(), $1);
$this->checkClassConst($$, #2); }
| optional_attributes method_modifiers T_CONST type_expr class_const_list semi
{ $$ = new Stmt\ClassConst($5, $2, attributes(), $1, $4);
$this->checkClassConst($$, #2); }
| optional_attributes method_modifiers T_FUNCTION optional_ref identifier_maybe_reserved '(' parameter_list ')'
optional_return_type method_body
{ $$ = Stmt\ClassMethod[$5, ['type' => $2, 'byRef' => $4, 'params' => $7, 'returnType' => $9, 'stmts' => $10, 'attrGroups' => $1]];
@@ -868,27 +873,27 @@ trait_method_reference_fully_qualified:
name T_PAAMAYIM_NEKUDOTAYIM identifier_maybe_reserved { $$ = array($1, $3); }
;
trait_method_reference:
trait_method_reference_fully_qualified { $$ = $1; }
trait_method_reference_fully_qualified
| identifier_maybe_reserved { $$ = array(null, $1); }
;
method_body:
';' /* abstract method */ { $$ = null; }
| block_or_error { $$ = $1; }
| block_or_error
;
variable_modifiers:
non_empty_member_modifiers { $$ = $1; }
non_empty_member_modifiers
| T_VAR { $$ = 0; }
;
method_modifiers:
/* empty */ { $$ = 0; }
| non_empty_member_modifiers { $$ = $1; }
| non_empty_member_modifiers
;
non_empty_member_modifiers:
member_modifier { $$ = $1; }
member_modifier
| non_empty_member_modifiers member_modifier { $this->checkModifier($1, $2, #2); $$ = $1 | $2; }
;
@@ -903,7 +908,7 @@ member_modifier:
;
property_declaration_list:
non_empty_property_declaration_list no_comma { $$ = $1; }
non_empty_property_declaration_list no_comma
;
non_empty_property_declaration_list:
@@ -922,11 +927,11 @@ property_declaration:
;
expr_list_forbid_comma:
non_empty_expr_list no_comma { $$ = $1; }
non_empty_expr_list no_comma
;
expr_list_allow_comma:
non_empty_expr_list optional_comma { $$ = $1; }
non_empty_expr_list optional_comma
;
non_empty_expr_list:
@@ -936,11 +941,11 @@ non_empty_expr_list:
for_expr:
/* empty */ { $$ = array(); }
| expr_list_forbid_comma { $$ = $1; }
| expr_list_forbid_comma
;
expr:
variable { $$ = $1; }
variable
| list_expr '=' expr { $$ = Expr\Assign[$1, $3]; }
| array_short_syntax '=' expr
{ $$ = Expr\Assign[$this->fixupArrayDestructuring($1), $3]; }
@@ -952,8 +957,8 @@ expr:
$this->emitError(new Error('Cannot assign new by reference', attributes()));
}
}
| new_expr { $$ = $1; }
| match { $$ = $1; }
| new_expr
| match
| T_CLONE expr { $$ = Expr\Clone_[$2]; }
| variable T_PLUS_EQUAL expr { $$ = Expr\AssignOp\Plus [$1, $3]; }
| variable T_MINUS_EQUAL expr { $$ = Expr\AssignOp\Minus [$1, $3]; }
@@ -1030,7 +1035,7 @@ expr:
$attrs['kind'] = strtolower($1) === 'exit' ? Expr\Exit_::KIND_EXIT : Expr\Exit_::KIND_DIE;
$$ = new Expr\Exit_($2, $attrs); }
| '@' expr { $$ = Expr\ErrorSuppress[$2]; }
| scalar { $$ = $1; }
| scalar
| '`' backticks_expr '`' { $$ = Expr\ShellExec[$2]; }
| T_PRINT expr { $$ = Expr\Print_[$2]; }
| T_YIELD { $$ = Expr\Yield_[null, null]; }
@@ -1059,8 +1064,8 @@ expr:
;
anonymous_class:
optional_attributes T_CLASS ctor_arguments extends_from implements_list '{' class_statement_list '}'
{ $$ = array(Stmt\Class_[null, ['type' => 0, 'extends' => $4, 'implements' => $5, 'stmts' => $7, 'attrGroups' => $1]], $3);
optional_attributes class_entry_type ctor_arguments extends_from implements_list '{' class_statement_list '}'
{ $$ = array(Stmt\Class_[null, ['type' => $2, 'extends' => $4, 'implements' => $5, 'stmts' => $7, 'attrGroups' => $1]], $3);
$this->checkClass($$[0], -1); }
;
@@ -1076,7 +1081,7 @@ lexical_vars:
;
lexical_var_list:
non_empty_lexical_var_list optional_comma { $$ = $1; }
non_empty_lexical_var_list optional_comma
;
non_empty_lexical_var_list:
@@ -1085,11 +1090,16 @@ non_empty_lexical_var_list:
;
lexical_var:
optional_ref plain_variable { $$ = Expr\ClosureUse[$2, $1]; }
optional_ref plain_variable { $$ = Node\ClosureUse[$2, $1]; }
;
name_readonly:
T_READONLY { $$ = Name[$1]; }
;
function_call:
name argument_list { $$ = Expr\FuncCall[$1, $2]; }
| name_readonly argument_list { $$ = Expr\FuncCall[$1, $2]; }
| callable_expr argument_list { $$ = Expr\FuncCall[$1, $2]; }
| class_name_or_var T_PAAMAYIM_NEKUDOTAYIM member_name argument_list
{ $$ = Expr\StaticCall[$1, $3, $4]; }
@@ -1097,7 +1107,7 @@ function_call:
class_name:
T_STATIC { $$ = Name[$1]; }
| name { $$ = $1; }
| name
;
name:
@@ -1108,15 +1118,15 @@ name:
;
class_name_reference:
class_name { $$ = $1; }
| new_variable { $$ = $1; }
class_name
| new_variable
| '(' expr ')' { $$ = $2; }
| error { $$ = Expr\Error[]; $this->errorState = 2; }
;
class_name_or_var:
class_name { $$ = $1; }
| fully_dereferencable { $$ = $1; }
class_name
| fully_dereferencable
;
exit_expr:
@@ -1126,14 +1136,14 @@ exit_expr:
backticks_expr:
/* empty */ { $$ = array(); }
| T_ENCAPSED_AND_WHITESPACE
{ $$ = array(Node\InterpolatedStringPart[Scalar\String_::parseEscapeSequences($1, '`')]); }
| encaps_list { parseEncapsed($1, '`', true); $$ = $1; }
| encaps_string_part
{ $$ = array($1); parseEncapsed($$, '`', $this->phpVersion->supportsUnicodeEscapes()); }
| encaps_list { parseEncapsed($1, '`', $this->phpVersion->supportsUnicodeEscapes()); $$ = $1; }
;
ctor_arguments:
/* empty */ { $$ = array(); }
| argument_list { $$ = $1; }
| argument_list
;
constant:
@@ -1151,6 +1161,8 @@ constant:
class_constant:
class_name_or_var T_PAAMAYIM_NEKUDOTAYIM identifier_maybe_reserved
{ $$ = Expr\ClassConstFetch[$1, $3]; }
| class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '{' expr '}'
{ $$ = Expr\ClassConstFetch[$1, $4]; }
/* We interpret an isolated FOO:: as an unfinished class constant fetch. It could also be
an unfinished static property fetch or unfinished scoped call. */
| class_name_or_var T_PAAMAYIM_NEKUDOTAYIM error
@@ -1169,19 +1181,20 @@ dereferencable_scalar:
$$ = new Expr\Array_($3, $attrs);
$this->createdArrays->attach($$); }
| array_short_syntax { $$ = $1; $this->createdArrays->attach($$); }
| T_CONSTANT_ENCAPSED_STRING { $$ = Scalar\String_::fromString($1, attributes()); }
| T_CONSTANT_ENCAPSED_STRING
{ $$ = Scalar\String_::fromString($1, attributes(), $this->phpVersion->supportsUnicodeEscapes()); }
| '"' encaps_list '"'
{ $attrs = attributes(); $attrs['kind'] = Scalar\String_::KIND_DOUBLE_QUOTED;
parseEncapsed($2, '"', true); $$ = new Scalar\InterpolatedString($2, $attrs); }
parseEncapsed($2, '"', $this->phpVersion->supportsUnicodeEscapes()); $$ = new Scalar\InterpolatedString($2, $attrs); }
;
scalar:
T_LNUMBER
{ $$ = $this->parseLNumber($1, attributes(), $this->phpVersion->allowsInvalidOctals()); }
| T_DNUMBER { $$ = Scalar\Float_::fromString($1, attributes()); }
| dereferencable_scalar { $$ = $1; }
| constant { $$ = $1; }
| class_constant { $$ = $1; }
| dereferencable_scalar
| constant
| class_constant
| T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC
{ $$ = $this->parseDocString($1, $2, $3, attributes(), stackAttributes(#3), true); }
| T_START_HEREDOC T_END_HEREDOC
@@ -1192,32 +1205,32 @@ scalar:
optional_expr:
/* empty */ { $$ = null; }
| expr { $$ = $1; }
| expr
;
fully_dereferencable:
variable { $$ = $1; }
variable
| '(' expr ')' { $$ = $2; }
| dereferencable_scalar { $$ = $1; }
| class_constant { $$ = $1; }
| dereferencable_scalar
| class_constant
;
array_object_dereferencable:
fully_dereferencable { $$ = $1; }
| constant { $$ = $1; }
fully_dereferencable
| constant
;
callable_expr:
callable_variable { $$ = $1; }
callable_variable
| '(' expr ')' { $$ = $2; }
| dereferencable_scalar { $$ = $1; }
| dereferencable_scalar
;
callable_variable:
simple_variable { $$ = $1; }
simple_variable
| array_object_dereferencable '[' optional_expr ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
| array_object_dereferencable '{' expr '}' { $$ = Expr\ArrayDimFetch[$1, $3]; }
| function_call { $$ = $1; }
| function_call
| array_object_dereferencable T_OBJECT_OPERATOR property_name argument_list
{ $$ = Expr\MethodCall[$1, $3, $4]; }
| array_object_dereferencable T_NULLSAFE_OBJECT_OPERATOR property_name argument_list
@@ -1226,12 +1239,12 @@ callable_variable:
optional_plain_variable:
/* empty */ { $$ = null; }
| plain_variable { $$ = $1; }
| plain_variable
;
variable:
callable_variable { $$ = $1; }
| static_member { $$ = $1; }
callable_variable
| static_member
| array_object_dereferencable T_OBJECT_OPERATOR property_name
{ $$ = Expr\PropertyFetch[$1, $3]; }
| array_object_dereferencable T_NULLSAFE_OBJECT_OPERATOR property_name
@@ -1239,7 +1252,7 @@ variable:
;
simple_variable:
plain_variable { $$ = $1; }
plain_variable
| '$' '{' expr '}' { $$ = Expr\Variable[$3]; }
| '$' simple_variable { $$ = Expr\Variable[$2]; }
| '$' error { $$ = Expr\Variable[Expr\Error[]]; $this->errorState = 2; }
@@ -1256,7 +1269,7 @@ static_member:
;
new_variable:
simple_variable { $$ = $1; }
simple_variable
| new_variable '[' optional_expr ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
| new_variable '{' expr '}' { $$ = Expr\ArrayDimFetch[$1, $3]; }
| new_variable T_OBJECT_OPERATOR property_name { $$ = Expr\PropertyFetch[$1, $3]; }
@@ -1268,15 +1281,15 @@ new_variable:
;
member_name:
identifier_maybe_reserved { $$ = $1; }
identifier_maybe_reserved
| '{' expr '}' { $$ = $2; }
| simple_variable { $$ = $1; }
| simple_variable
;
property_name:
identifier_not_reserved { $$ = $1; }
identifier_not_reserved
| '{' expr '}' { $$ = $2; }
| simple_variable { $$ = $1; }
| simple_variable
| error { $$ = Expr\Error[]; $this->errorState = 2; }
;
@@ -1309,11 +1322,11 @@ array_pair:
| expr T_DOUBLE_ARROW expr { $$ = Node\ArrayItem[$3, $1, false]; }
| expr T_DOUBLE_ARROW ampersand variable { $$ = Node\ArrayItem[$4, $1, true]; }
| expr T_DOUBLE_ARROW list_expr { $$ = Node\ArrayItem[$3, $1, false]; }
| T_ELLIPSIS expr { $$ = Node\ArrayItem[$2, null, false, attributes(), true]; }
| T_ELLIPSIS expr { $$ = new Node\ArrayItem($2, null, false, attributes(), true); }
| /* empty */
{ /* Create an Error node now to remember the position. We'll later either report an error,
or convert this into a null element, depending on whether this is a creation or destructuring context. */
$attrs = $this->createEmptyElemAttributes($this->lookaheadStartAttributes);
$attrs = $this->createEmptyElemAttributes($this->tokenPos);
$$ = new Node\ArrayItem(new Expr\Error($attrs), null, false, $attrs); }
;
@@ -1325,7 +1338,8 @@ encaps_list:
;
encaps_string_part:
T_ENCAPSED_AND_WHITESPACE { $$ = Node\InterpolatedStringPart[$1]; }
T_ENCAPSED_AND_WHITESPACE
{ $attrs = attributes(); $attrs['rawValue'] = $1; $$ = new Node\InterpolatedStringPart($1, $attrs); }
;
encaps_str_varname:
@@ -1333,7 +1347,7 @@ encaps_str_varname:
;
encaps_var:
plain_variable { $$ = $1; }
plain_variable
| plain_variable '[' encaps_var_offset ']' { $$ = Expr\ArrayDimFetch[$1, $3]; }
| plain_variable T_OBJECT_OPERATOR identifier_not_reserved
{ $$ = Expr\PropertyFetch[$1, $3]; }
@@ -1350,7 +1364,7 @@ encaps_var_offset:
T_STRING { $$ = Scalar\String_[$1]; }
| T_NUM_STRING { $$ = $this->parseNumString($1, attributes()); }
| '-' T_NUM_STRING { $$ = $this->parseNumString('-' . $2, attributes()); }
| plain_variable { $$ = $1; }
| plain_variable
;
%%

@@ -23,6 +23,7 @@ function preprocessGrammar($code) {
$code = resolveNodes($code);
$code = resolveMacros($code);
$code = resolveStackAccess($code);
$code = str_replace('$this', '$self', $code);
return $code;
}
@@ -65,13 +66,13 @@ function resolveMacros($code) {
if ('attributes' === $name) {
assertArgs(0, $args, $name);
return '$this->startAttributeStack[#1] + $this->endAttributes';
return '$this->getAttributes($this->tokenStartStack[#1], $this->tokenEndStack[$stackPos])';
}
if ('stackAttributes' === $name) {
assertArgs(1, $args, $name);
return '$this->startAttributeStack[' . $args[0] . ']'
. ' + $this->endAttributeStack[' . $args[0] . ']';
return '$this->getAttributes($this->tokenStartStack[' . $args[0] . '], '
. ' $this->tokenEndStack[' . $args[0] . '])';
}
if ('init' === $name) {
@@ -87,14 +88,15 @@ function resolveMacros($code) {
if ('pushNormalizing' === $name) {
assertArgs(2, $args, $name);
return 'if (is_array(' . $args[1] . ')) { $$ = array_merge(' . $args[0] . ', ' . $args[1] . '); }'
. ' else { ' . $args[0] . '[] = ' . $args[1] . '; $$ = ' . $args[0] . '; }';
return 'if (' . $args[1] . ' !== null) { ' . $args[0] . '[] = ' . $args[1] . '; } $$ = ' . $args[0] . ';';
}
if ('toArray' == $name) {
if ('toBlock' == $name) {
assertArgs(1, $args, $name);
return 'is_array(' . $args[0] . ') ? ' . $args[0] . ' : array(' . $args[0] . ')';
return 'if (' . $args[0] . ' instanceof Stmt\Block) { $$ = ' . $args[0] . '->stmts; } '
. 'else if (' . $args[0] . ' === null) { $$ = []; } '
. 'else { $$ = [' . $args[0] . ']; }';
}
if ('parseVar' === $name) {
@@ -111,30 +113,15 @@ function resolveMacros($code) {
}
if ('makeNop' === $name) {
assertArgs(3, $args, $name);
assertArgs(1, $args, $name);
return '$startAttributes = ' . $args[1] . ';'
. ' if (isset($startAttributes[\'comments\']))'
. ' { ' . $args[0] . ' = new Stmt\Nop($startAttributes + ' . $args[2] . '); }'
. ' else { ' . $args[0] . ' = null; }';
return $args[0] . ' = $this->maybeCreateNop($this->tokenStartStack[#1], $this->tokenEndStack[$stackPos])';
}
if ('makeZeroLengthNop' == $name) {
assertArgs(2, $args, $name);
return '$startAttributes = ' . $args[1] . ';'
. ' if (isset($startAttributes[\'comments\']))'
. ' { ' . $args[0] . ' = new Stmt\Nop($this->createCommentNopAttributes($startAttributes[\'comments\'])); }'
. ' else { ' . $args[0] . ' = null; }';
}
if ('prependLeadingComments' === $name) {
assertArgs(1, $args, $name);
return '$attrs = $this->startAttributeStack[#1]; $stmts = ' . $args[0] . '; '
. 'if (!empty($attrs[\'comments\'])) {'
. '$stmts[0]->setAttribute(\'comments\', '
. 'array_merge($attrs[\'comments\'], $stmts[0]->getAttribute(\'comments\', []))); }';
return $args[0] . ' = $this->maybeCreateZeroLengthNop($this->tokenPos);';
}
return $matches[0];

@@ -13,17 +13,21 @@ use PhpParser\Node\Identifier;
use PhpParser\Node\Stmt;
class ClassConst implements PhpParser\Builder {
protected $flags = 0;
protected $attributes = [];
protected $constants = [];
protected int $flags = 0;
/** @var array<string, mixed> */
protected array $attributes = [];
/** @var list<Const_> */
protected array $constants = [];
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/** @var Identifier|Node\Name|Node\ComplexType|null */
protected ?Node $type = null;
/**
* Creates a class constant builder
*
* @param string|Identifier $name Name
* @param string|Identifier $name Name
* @param Node\Expr|bool|null|int|float|string|array $value Value
*/
public function __construct($name, $value) {
@@ -33,7 +37,7 @@ class ClassConst implements PhpParser\Builder {
/**
* Add another constant to const group
*
* @param string|Identifier $name Name
* @param string|Identifier $name Name
* @param Node\Expr|bool|null|int|float|string|array $value Value
*
* @return $this The builder instance (for fluid interface)
@@ -116,6 +120,19 @@ class ClassConst implements PhpParser\Builder {
return $this;
}
/**
* Sets the constant type.
*
* @param string|Node\Name|Identifier|Node\ComplexType $type
*
* @return $this
*/
public function setType($type) {
$this->type = BuilderHelpers::normalizeType($type);
return $this;
}
/**
* Returns the built class node.
*
@@ -126,7 +143,8 @@ class ClassConst implements PhpParser\Builder {
$this->constants,
$this->flags,
$this->attributes,
$this->attributeGroups
$this->attributeGroups,
$this->type
);
}
}

@@ -10,19 +10,21 @@ use PhpParser\Node\Name;
use PhpParser\Node\Stmt;
class Class_ extends Declaration {
protected $name;
protected $extends = null;
protected $implements = [];
protected $flags = 0;
protected $uses = [];
protected $constants = [];
protected $properties = [];
protected $methods = [];
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
protected string $name;
protected ?Name $extends = null;
/** @var list<Name> */
protected array $implements = [];
protected int $flags = 0;
/** @var list<Stmt\TraitUse> */
protected array $uses = [];
/** @var list<Stmt\ClassConst> */
protected array $constants = [];
/** @var list<Stmt\Property> */
protected array $properties = [];
/** @var list<Stmt\ClassMethod> */
protected array $methods = [];
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates a class builder.
@@ -83,6 +85,11 @@ class Class_ extends Declaration {
return $this;
}
/**
* Makes the class readonly.
*
* @return $this The builder instance (for fluid interface)
*/
public function makeReadonly() {
$this->flags = BuilderHelpers::addClassModifier($this->flags, Modifiers::READONLY);
@@ -99,20 +106,18 @@ class Class_ extends Declaration {
public function addStmt($stmt) {
$stmt = BuilderHelpers::normalizeNode($stmt);
$targets = [
Stmt\TraitUse::class => &$this->uses,
Stmt\ClassConst::class => &$this->constants,
Stmt\Property::class => &$this->properties,
Stmt\ClassMethod::class => &$this->methods,
];
$class = \get_class($stmt);
if (!isset($targets[$class])) {
if ($stmt instanceof Stmt\Property) {
$this->properties[] = $stmt;
} elseif ($stmt instanceof Stmt\ClassMethod) {
$this->methods[] = $stmt;
} elseif ($stmt instanceof Stmt\TraitUse) {
$this->uses[] = $stmt;
} elseif ($stmt instanceof Stmt\ClassConst) {
$this->constants[] = $stmt;
} else {
throw new \LogicException(sprintf('Unexpected node of type "%s"', $stmt->getType()));
}
$targets[$class][] = $stmt;
return $this;
}

@@ -6,14 +6,22 @@ use PhpParser;
use PhpParser\BuilderHelpers;
abstract class Declaration implements PhpParser\Builder {
protected $attributes = [];
/** @var array<string, mixed> */
protected array $attributes = [];
/**
* Adds a statement.
*
* @param PhpParser\Node\Stmt|PhpParser\Builder $stmt The statement to add
*
* @return $this The builder instance (for fluid interface)
*/
abstract public function addStmt($stmt);
/**
* Adds multiple statements.
*
* @param array $stmts The statements to add
* @param (PhpParser\Node\Stmt|PhpParser\Builder)[] $stmts The statements to add
*
* @return $this The builder instance (for fluid interface)
*/

@@ -11,17 +11,20 @@ use PhpParser\Node\Identifier;
use PhpParser\Node\Stmt;
class EnumCase implements PhpParser\Builder {
/** @var Identifier|string */
protected $name;
protected $value = null;
protected $attributes = [];
/** @var ?Node\Expr */
protected ?Node\Expr $value = null;
/** @var array<string, mixed> */
protected array $attributes = [];
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates an enum case builder.
*
* @param string|Identifier $name Name
* @param string|Identifier $name Name
*/
public function __construct($name) {
$this->name = $name;
@@ -77,8 +80,8 @@ class EnumCase implements PhpParser\Builder {
return new Stmt\EnumCase(
$this->name,
$this->value,
$this->attributes,
$this->attributeGroups
$this->attributeGroups,
$this->attributes
);
}
}

@@ -10,18 +10,20 @@ use PhpParser\Node\Name;
use PhpParser\Node\Stmt;
class Enum_ extends Declaration {
protected $name;
protected $scalarType = null;
protected $implements = [];
protected $uses = [];
protected $enumCases = [];
protected $constants = [];
protected $methods = [];
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
protected string $name;
protected ?Identifier $scalarType = null;
/** @var list<Name> */
protected array $implements = [];
/** @var list<Stmt\TraitUse> */
protected array $uses = [];
/** @var list<Stmt\EnumCase> */
protected array $enumCases = [];
/** @var list<Stmt\ClassConst> */
protected array $constants = [];
/** @var list<Stmt\ClassMethod> */
protected array $methods = [];
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates an enum builder.
@@ -35,7 +37,7 @@ class Enum_ extends Declaration {
/**
* Sets the scalar type.
*
* @param string|Identifier $type
* @param string|Identifier $scalarType
*
* @return $this
*/
@@ -70,20 +72,18 @@ class Enum_ extends Declaration {
public function addStmt($stmt) {
$stmt = BuilderHelpers::normalizeNode($stmt);
$targets = [
Stmt\TraitUse::class => &$this->uses,
Stmt\EnumCase::class => &$this->enumCases,
Stmt\ClassConst::class => &$this->constants,
Stmt\ClassMethod::class => &$this->methods,
];
$class = \get_class($stmt);
if (!isset($targets[$class])) {
if ($stmt instanceof Stmt\EnumCase) {
$this->enumCases[] = $stmt;
} elseif ($stmt instanceof Stmt\ClassMethod) {
$this->methods[] = $stmt;
} elseif ($stmt instanceof Stmt\TraitUse) {
$this->uses[] = $stmt;
} elseif ($stmt instanceof Stmt\ClassConst) {
$this->constants[] = $stmt;
} else {
throw new \LogicException(sprintf('Unexpected node of type "%s"', $stmt->getType()));
}
$targets[$class][] = $stmt;
return $this;
}

@@ -6,11 +6,12 @@ use PhpParser\BuilderHelpers;
use PhpParser\Node;
abstract class FunctionLike extends Declaration {
protected $returnByRef = false;
protected $params = [];
protected bool $returnByRef = false;
/** @var Node\Param[] */
protected array $params = [];
/** @var string|Node\Name|Node\NullableType|null */
protected $returnType = null;
/** @var Node\Identifier|Node\Name|Node\ComplexType|null */
protected ?Node $returnType = null;
/**
* Make the function return by reference.
@@ -45,7 +46,7 @@ abstract class FunctionLike extends Declaration {
/**
* Adds multiple parameters.
*
* @param array $params The parameters to add
* @param (Node\Param|Param)[] $params The parameters to add
*
* @return $this The builder instance (for fluid interface)
*/

@@ -8,11 +8,12 @@ use PhpParser\Node;
use PhpParser\Node\Stmt;
class Function_ extends FunctionLike {
protected $name;
protected $stmts = [];
protected string $name;
/** @var list<Stmt> */
protected array $stmts = [];
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates a function builder.

@@ -9,13 +9,15 @@ use PhpParser\Node\Name;
use PhpParser\Node\Stmt;
class Interface_ extends Declaration {
protected $name;
protected $extends = [];
protected $constants = [];
protected $methods = [];
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
protected string $name;
/** @var list<Name> */
protected array $extends = [];
/** @var list<Stmt\ClassConst> */
protected array $constants = [];
/** @var list<Stmt\ClassMethod> */
protected array $methods = [];
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates an interface builder.

@@ -9,14 +9,15 @@ use PhpParser\Node;
use PhpParser\Node\Stmt;
class Method extends FunctionLike {
protected $name;
protected $flags = 0;
protected string $name;
/** @var array|null */
protected $stmts = [];
protected int $flags = 0;
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
/** @var list<Stmt>|null */
protected ?array $stmts = [];
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates a method builder.

@@ -8,8 +8,9 @@ use PhpParser\Node;
use PhpParser\Node\Stmt;
class Namespace_ extends Declaration {
private $name;
private $stmts = [];
private ?Node\Name $name;
/** @var Stmt[] */
private array $stmts = [];
/**
* Creates a namespace builder.

@@ -4,22 +4,19 @@ namespace PhpParser\Builder;
use PhpParser;
use PhpParser\BuilderHelpers;
use PhpParser\Modifiers;
use PhpParser\Node;
class Param implements PhpParser\Builder {
protected $name;
protected $default = null;
/** @var Node\Identifier|Node\Name|Node\NullableType|null */
protected $type = null;
protected $byRef = false;
protected $variadic = false;
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
protected string $name;
protected ?Node\Expr $default = null;
/** @var Node\Identifier|Node\Name|Node\ComplexType|null */
protected ?Node $type = null;
protected bool $byRef = false;
protected int $flags = 0;
protected bool $variadic = false;
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates a parameter builder.
@@ -81,6 +78,50 @@ class Param implements PhpParser\Builder {
return $this;
}
/**
* Makes the (promoted) parameter public.
*
* @return $this The builder instance (for fluid interface)
*/
public function makePublic() {
$this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PUBLIC);
return $this;
}
/**
* Makes the (promoted) parameter protected.
*
* @return $this The builder instance (for fluid interface)
*/
public function makeProtected() {
$this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PROTECTED);
return $this;
}
/**
* Makes the (promoted) parameter private.
*
* @return $this The builder instance (for fluid interface)
*/
public function makePrivate() {
$this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PRIVATE);
return $this;
}
/**
* Makes the (promoted) parameter readonly.
*
* @return $this The builder instance (for fluid interface)
*/
public function makeReadonly() {
$this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::READONLY);
return $this;
}
/**
* Adds an attribute group.
*
@@ -102,7 +143,7 @@ class Param implements PhpParser\Builder {
public function getNode(): Node {
return new Node\Param(
new Node\Expr\Variable($this->name),
$this->default, $this->type, $this->byRef, $this->variadic, [], 0, $this->attributeGroups
$this->default, $this->type, $this->byRef, $this->variadic, [], $this->flags, $this->attributeGroups
);
}
}

@@ -12,17 +12,17 @@ use PhpParser\Node\Stmt;
use PhpParser\Node\ComplexType;
class Property implements PhpParser\Builder {
protected $name;
protected string $name;
protected $flags = 0;
protected $default = null;
protected $attributes = [];
protected int $flags = 0;
/** @var null|Identifier|Name|NullableType */
protected $type;
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
protected ?Node\Expr $default = null;
/** @var array<string, mixed> */
protected array $attributes = [];
/** @var null|Identifier|Name|ComplexType */
protected ?Node $type = null;
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates a property builder.

@@ -8,8 +8,10 @@ use PhpParser\Node;
use PhpParser\Node\Stmt;
class TraitUse implements Builder {
protected $traits = [];
protected $adaptations = [];
/** @var Node\Name[] */
protected array $traits = [];
/** @var Stmt\TraitUseAdaptation[] */
protected array $adaptations = [];
/**
* Creates a trait use builder.

@@ -9,26 +9,23 @@ use PhpParser\Node;
use PhpParser\Node\Stmt;
class TraitUseAdaptation implements Builder {
public const TYPE_UNDEFINED = 0;
public const TYPE_ALIAS = 1;
public const TYPE_PRECEDENCE = 2;
private const TYPE_UNDEFINED = 0;
private const TYPE_ALIAS = 1;
private const TYPE_PRECEDENCE = 2;
/** @var int Type of building adaptation */
protected $type;
protected $trait;
protected $method;
protected $modifier = null;
protected $alias = null;
protected $insteadof = [];
protected int $type;
protected ?Node\Name $trait;
protected Node\Identifier $method;
protected ?int $modifier = null;
protected ?Node\Identifier $alias = null;
/** @var Node\Name[] */
protected array $insteadof = [];
/**
* Creates a trait use adaptation builder.
*
* @param Node\Name|string|null $trait Name of adaptated trait
* @param Node\Identifier|string $method Name of adaptated method
* @param Node\Name|string|null $trait Name of adapted trait
* @param Node\Identifier|string $method Name of adapted method
*/
public function __construct($trait, $method) {
$this->type = self::TYPE_UNDEFINED;
@@ -40,7 +37,7 @@ class TraitUseAdaptation implements Builder {
/**
* Sets alias of method.
*
* @param Node\Identifier|string $alias Alias for adaptated method
* @param Node\Identifier|string $alias Alias for adapted method
*
* @return $this The builder instance (for fluid interface)
*/
@@ -53,12 +50,12 @@ class TraitUseAdaptation implements Builder {
throw new \LogicException('Cannot set alias for not alias adaptation buider');
}
$this->alias = $alias;
$this->alias = BuilderHelpers::normalizeIdentifier($alias);
return $this;
}
/**
* Sets adaptated method public.
* Sets adapted method public.
*
* @return $this The builder instance (for fluid interface)
*/
@@ -68,7 +65,7 @@ class TraitUseAdaptation implements Builder {
}
/**
* Sets adaptated method protected.
* Sets adapted method protected.
*
* @return $this The builder instance (for fluid interface)
*/
@@ -78,7 +75,7 @@ class TraitUseAdaptation implements Builder {
}
/**
* Sets adaptated method private.
* Sets adapted method private.
*
* @return $this The builder instance (for fluid interface)
*/
@@ -114,7 +111,7 @@ class TraitUseAdaptation implements Builder {
return $this;
}
protected function setModifier(int $modifier) {
protected function setModifier(int $modifier): void {
if ($this->type === self::TYPE_UNDEFINED) {
$this->type = self::TYPE_ALIAS;
}

@@ -8,13 +8,17 @@ use PhpParser\Node;
use PhpParser\Node\Stmt;
class Trait_ extends Declaration {
protected $name;
protected $uses = [];
protected $properties = [];
protected $methods = [];
/** @var Node\AttributeGroup[] */
protected $attributeGroups = [];
protected string $name;
/** @var list<Stmt\TraitUse> */
protected array $uses = [];
/** @var list<Stmt\ClassConst> */
protected array $constants = [];
/** @var list<Stmt\Property> */
protected array $properties = [];
/** @var list<Stmt\ClassMethod> */
protected array $methods = [];
/** @var list<Node\AttributeGroup> */
protected array $attributeGroups = [];
/**
* Creates an interface builder.
@@ -41,6 +45,8 @@ class Trait_ extends Declaration {
$this->methods[] = $stmt;
} elseif ($stmt instanceof Stmt\TraitUse) {
$this->uses[] = $stmt;
} elseif ($stmt instanceof Stmt\ClassConst) {
$this->constants[] = $stmt;
} else {
throw new \LogicException(sprintf('Unexpected node of type "%s"', $stmt->getType()));
}
@@ -69,7 +75,7 @@ class Trait_ extends Declaration {
public function getNode(): PhpParser\Node {
return new Stmt\Trait_(
$this->name, [
'stmts' => array_merge($this->uses, $this->properties, $this->methods),
'stmts' => array_merge($this->uses, $this->constants, $this->properties, $this->methods),
'attrGroups' => $this->attributeGroups,
], $this->attributes
);

@@ -8,15 +8,16 @@ use PhpParser\Node;
use PhpParser\Node\Stmt;
class Use_ implements Builder {
protected $name;
protected $type;
protected $alias = null;
protected Node\Name $name;
/** @var Stmt\Use_::TYPE_* */
protected int $type;
protected ?string $alias = null;
/**
* Creates a name use (alias) builder.
*
* @param Node\Name|string $name Name of the entity (namespace, class, function, constant) to alias
* @param int $type One of the Stmt\Use_::TYPE_* constants
* @param Stmt\Use_::TYPE_* $type One of the Stmt\Use_::TYPE_* constants
*/
public function __construct($name, int $type) {
$this->name = BuilderHelpers::normalizeName($name);

@@ -15,9 +15,7 @@ class BuilderFactory {
* Creates an attribute node.
*
* @param string|Name $name Name of the attribute
* @param array $args Attribute named arguments
*
* @return Node\Attribute
* @param array $args Attribute named arguments
*/
public function attribute($name, array $args = []): Node\Attribute {
return new Node\Attribute(
@@ -86,7 +84,7 @@ class BuilderFactory {
*
* @param Node\Name|string ...$traits Trait names
*
* @return Builder\TraitUse The create trait use builder
* @return Builder\TraitUse The created trait use builder
*/
public function useTrait(...$traits): Builder\TraitUse {
return new Builder\TraitUse(...$traits);
@@ -95,10 +93,10 @@ class BuilderFactory {
/**
* Creates a trait use adaptation builder.
*
* @param Node\Name|string|null $trait Trait name
* @param Node\Name|string|null $trait Trait name
* @param Node\Identifier|string $method Method name
*
* @return Builder\TraitUseAdaptation The create trait use adaptation builder
* @return Builder\TraitUseAdaptation The created trait use adaptation builder
*/
public function traitUseAdaptation($trait, $method = null): Builder\TraitUseAdaptation {
if ($method === null) {
@@ -189,7 +187,7 @@ class BuilderFactory {
/**
* Creates a class constant builder.
*
* @param string|Identifier $name Name
* @param string|Identifier $name Name
* @param Node\Expr|bool|null|int|float|string|array $value Value
*
* @return Builder\ClassConst The created use const builder
@@ -201,7 +199,7 @@ class BuilderFactory {
/**
* Creates an enum case builder.
*
* @param string|Identifier $name Name
* @param string|Identifier $name Name
*
* @return Builder\EnumCase The created use const builder
*/
@@ -213,8 +211,6 @@ class BuilderFactory {
* Creates node a for a literal value.
*
* @param Expr|bool|null|int|float|string|array $value $value
*
* @return Expr
*/
public function val($value): Expr {
return BuilderHelpers::normalizeValue($value);
@@ -224,8 +220,6 @@ class BuilderFactory {
* Creates variable node.
*
* @param string|Expr $name Name
*
* @return Expr\Variable
*/
public function var($name): Expr\Variable {
if (!\is_string($name) && !$name instanceof Expr) {
@@ -242,7 +236,7 @@ class BuilderFactory {
*
* @param array $args List of arguments to normalize
*
* @return Arg[]
* @return list<Arg>
*/
public function args(array $args): array {
$normalizedArgs = [];
@@ -262,9 +256,7 @@ class BuilderFactory {
* Creates a function call node.
*
* @param string|Name|Expr $name Function name
* @param array $args Function arguments
*
* @return Expr\FuncCall
* @param array $args Function arguments
*/
public function funcCall($name, array $args = []): Expr\FuncCall {
return new Expr\FuncCall(
@@ -276,11 +268,9 @@ class BuilderFactory {
/**
* Creates a method call node.
*
* @param Expr $var Variable the method is called on
* @param Expr $var Variable the method is called on
* @param string|Identifier|Expr $name Method name
* @param array $args Method arguments
*
* @return Expr\MethodCall
* @param array $args Method arguments
*/
public function methodCall(Expr $var, $name, array $args = []): Expr\MethodCall {
return new Expr\MethodCall(
@@ -293,11 +283,9 @@ class BuilderFactory {
/**
* Creates a static method call node.
*
* @param string|Name|Expr $class Class name
* @param string|Identifier|Expr $name Method name
* @param array $args Method arguments
*
* @return Expr\StaticCall
* @param string|Name|Expr $class Class name
* @param string|Identifier|Expr $name Method name
* @param array $args Method arguments
*/
public function staticCall($class, $name, array $args = []): Expr\StaticCall {
return new Expr\StaticCall(
@@ -311,9 +299,7 @@ class BuilderFactory {
* Creates an object creation node.
*
* @param string|Name|Expr $class Class name
* @param array $args Constructor arguments
*
* @return Expr\New_
* @param array $args Constructor arguments
*/
public function new($class, array $args = []): Expr\New_ {
return new Expr\New_(
@@ -326,8 +312,6 @@ class BuilderFactory {
* Creates a constant fetch node.
*
* @param string|Name $name Constant name
*
* @return Expr\ConstFetch
*/
public function constFetch($name): Expr\ConstFetch {
return new Expr\ConstFetch(BuilderHelpers::normalizeName($name));
@@ -336,10 +320,8 @@ class BuilderFactory {
/**
* Creates a property fetch node.
*
* @param Expr $var Variable holding object
* @param Expr $var Variable holding object
* @param string|Identifier|Expr $name Property name
*
* @return Expr\PropertyFetch
*/
public function propertyFetch(Expr $var, $name): Expr\PropertyFetch {
return new Expr\PropertyFetch($var, BuilderHelpers::normalizeIdentifierOrExpr($name));
@@ -348,15 +330,13 @@ class BuilderFactory {
/**
* Creates a class constant fetch node.
*
* @param string|Name|Expr $class Class name
* @param string|Identifier $name Constant name
*
* @return Expr\ClassConstFetch
* @param string|Name|Expr $class Class name
* @param string|Identifier|Expr $name Constant name
*/
public function classConstFetch($class, $name): Expr\ClassConstFetch {
return new Expr\ClassConstFetch(
BuilderHelpers::normalizeNameOrExpr($class),
BuilderHelpers::normalizeIdentifier($name)
BuilderHelpers::normalizeIdentifierOrExpr($name)
);
}
@@ -364,8 +344,6 @@ class BuilderFactory {
* Creates nested Concat nodes from a list of expressions.
*
* @param Expr|string ...$exprs Expressions or literal strings
*
* @return Concat
*/
public function concat(...$exprs): Concat {
$numExprs = count($exprs);
@@ -382,7 +360,6 @@ class BuilderFactory {
/**
* @param string|Expr $expr
* @return Expr
*/
private function normalizeStringExpr($expr): Expr {
if ($expr instanceof Expr) {

@@ -313,12 +313,12 @@ final class BuilderHelpers {
* Adds a modifier and returns new modifier bitmask.
*
* @param int $modifiers Existing modifiers
* @param int $modifier Modifier to set
* @param int $modifier Modifier to set
*
* @return int New modifiers
*/
public static function addModifier(int $modifiers, int $modifier): int {
Stmt\Class_::verifyModifier($modifiers, $modifier);
Modifiers::verifyModifier($modifiers, $modifier);
return $modifiers | $modifier;
}
@@ -327,7 +327,7 @@ final class BuilderHelpers {
* @return int New modifiers
*/
public static function addClassModifier(int $existingModifiers, int $modifierToSet): int {
Stmt\Class_::verifyClassModifier($existingModifiers, $modifierToSet);
Modifiers::verifyClassModifier($existingModifiers, $modifierToSet);
return $existingModifiers | $modifierToSet;
}
}

@@ -3,21 +3,21 @@
namespace PhpParser;
class Comment implements \JsonSerializable {
protected $text;
protected $startLine;
protected $startFilePos;
protected $startTokenPos;
protected $endLine;
protected $endFilePos;
protected $endTokenPos;
protected string $text;
protected int $startLine;
protected int $startFilePos;
protected int $startTokenPos;
protected int $endLine;
protected int $endFilePos;
protected int $endTokenPos;
/**
* Constructs a comment node.
*
* @param string $text Comment text (including comment delimiters like /*)
* @param int $startLine Line number the comment started on
* @param int $startFilePos File offset the comment started on
* @param int $startTokenPos Token offset the comment started on
* @param string $text Comment text (including comment delimiters like /*)
* @param int $startLine Line number the comment started on
* @param int $startFilePos File offset the comment started on
* @param int $startTokenPos Token offset the comment started on
*/
public function __construct(
string $text,
@@ -96,39 +96,6 @@ class Comment implements \JsonSerializable {
return $this->endTokenPos;
}
/**
* Gets the line number the comment started on.
*
* @deprecated Use getStartLine() instead
*
* @return int Line number
*/
public function getLine(): int {
return $this->startLine;
}
/**
* Gets the file offset the comment started on.
*
* @deprecated Use getStartFilePos() instead
*
* @return int File offset
*/
public function getFilePos(): int {
return $this->startFilePos;
}
/**
* Gets the token offset the comment started on.
*
* @deprecated Use getStartTokenPos() instead
*
* @return int Token offset
*/
public function getTokenPos(): int {
return $this->startTokenPos;
}
/**
* Gets the comment text.
*
@@ -143,19 +110,19 @@ class Comment implements \JsonSerializable {
*
* "Reformatted" here means that we try to clean up the whitespace at the
* starts of the lines. This is necessary because we receive the comments
* without trailing whitespace on the first line, but with trailing whitespace
* without leading whitespace on the first line, but with leading whitespace
* on all subsequent lines.
*
* @return mixed|string
* Additionally, this normalizes CRLF newlines to LF newlines.
*/
public function getReformattedText() {
$text = $this->text;
public function getReformattedText(): string {
$text = str_replace("\r\n", "\n", $this->text);
$newlinePos = strpos($text, "\n");
if (false === $newlinePos) {
// Single line comments don't need further processing
return $text;
}
if (preg_match('((*BSR_ANYCRLF)(*ANYCRLF)^.*(?:\R\s+\*.*)+$)', $text)) {
if (preg_match('(^.*(?:\n\s+\*.*)+$)', $text)) {
// Multi line comment of the type
//
// /*
@@ -164,9 +131,9 @@ class Comment implements \JsonSerializable {
// */
//
// is handled by replacing the whitespace sequences before the * by a single space
return preg_replace('(^\s+\*)m', ' *', $this->text);
return preg_replace('(^\s+\*)m', ' *', $text);
}
if (preg_match('(^/\*\*?\s*[\r\n])', $text) && preg_match('(\n(\s*)\*/$)', $text, $matches)) {
if (preg_match('(^/\*\*?\s*\n)', $text) && preg_match('(\n(\s*)\*/$)', $text, $matches)) {
// Multi line comment of the type
//
// /*
@@ -208,7 +175,7 @@ class Comment implements \JsonSerializable {
*/
private function getShortestWhitespacePrefixLen(string $str): int {
$lines = explode("\n", $str);
$shortestPrefixLen = \INF;
$shortestPrefixLen = \PHP_INT_MAX;
foreach ($lines as $line) {
preg_match('(^\s*)', $line, $matches);
$prefixLen = strlen($matches[0]);
@@ -220,8 +187,7 @@ class Comment implements \JsonSerializable {
}
/**
* @return array
* @psalm-return array{nodeType:string, text:mixed, line:mixed, filePos:mixed}
* @return array{nodeType:string, text:mixed, line:mixed, filePos:mixed}
*/
public function jsonSerialize(): array {
// Technically not a node, but we make it look like one anyway

@@ -27,6 +27,7 @@ use function array_merge;
* affected by the LC_NUMERIC locale.
*/
class ConstExprEvaluator {
/** @var callable|null */
private $fallbackEvaluator;
/**
@@ -101,6 +102,7 @@ class ConstExprEvaluator {
return $this->evaluate($expr);
}
/** @return mixed */
private function evaluate(Expr $expr) {
if ($expr instanceof Scalar\Int_
|| $expr instanceof Scalar\Float_
@@ -146,7 +148,7 @@ class ConstExprEvaluator {
return ($this->fallbackEvaluator)($expr);
}
private function evaluateArray(Expr\Array_ $expr) {
private function evaluateArray(Expr\Array_ $expr): array {
$array = [];
foreach ($expr->items as $item) {
if (null !== $item->key) {
@@ -160,6 +162,7 @@ class ConstExprEvaluator {
return $array;
}
/** @return mixed */
private function evaluateTernary(Expr\Ternary $expr) {
if (null === $expr->if) {
return $this->evaluate($expr->cond) ?: $this->evaluate($expr->else);
@@ -170,6 +173,7 @@ class ConstExprEvaluator {
: $this->evaluate($expr->else);
}
/** @return mixed */
private function evaluateBinaryOp(Expr\BinaryOp $expr) {
if ($expr instanceof Expr\BinaryOp\Coalesce
&& $expr->left instanceof Expr\ArrayDimFetch
@@ -216,6 +220,7 @@ class ConstExprEvaluator {
throw new \Exception('Should not happen');
}
/** @return mixed */
private function evaluateConstFetch(Expr\ConstFetch $expr) {
$name = $expr->name->toLowerString();
switch ($name) {

@@ -3,23 +3,19 @@
namespace PhpParser;
class Error extends \RuntimeException {
protected $rawMessage;
protected $attributes;
protected string $rawMessage;
/** @var array<string, mixed> */
protected array $attributes;
/**
* Creates an Exception signifying a parse error.
*
* @param string $message Error message
* @param array|int $attributes Attributes of node/token where error occurred
* (or start line of error -- deprecated)
* @param string $message Error message
* @param array<string, mixed> $attributes Attributes of node/token where error occurred
*/
public function __construct(string $message, $attributes = []) {
public function __construct(string $message, array $attributes = []) {
$this->rawMessage = $message;
if (is_array($attributes)) {
$this->attributes = $attributes;
} else {
$this->attributes = ['startLine' => $attributes];
}
$this->attributes = $attributes;
$this->updateMessage();
}
@@ -53,7 +49,7 @@ class Error extends \RuntimeException {
/**
* Gets the attributes of the node/token the error occurred at.
*
* @return array
* @return array<string, mixed>
*/
public function getAttributes(): array {
return $this->attributes;
@@ -62,9 +58,9 @@ class Error extends \RuntimeException {
/**
* Sets the attributes of the node/token the error occurred at.
*
* @param array $attributes
* @param array<string, mixed> $attributes
*/
public function setAttributes(array $attributes) {
public function setAttributes(array $attributes): void {
$this->attributes = $attributes;
$this->updateMessage();
}
@@ -74,7 +70,7 @@ class Error extends \RuntimeException {
*
* @param string $message Error message
*/
public function setRawMessage(string $message) {
public function setRawMessage(string $message): void {
$this->rawMessage = $message;
$this->updateMessage();
}
@@ -84,7 +80,7 @@ class Error extends \RuntimeException {
*
* @param int $line Error start line
*/
public function setStartLine(int $line) {
public function setStartLine(int $line): void {
$this->attributes['startLine'] = $line;
$this->updateMessage();
}
@@ -93,8 +89,6 @@ class Error extends \RuntimeException {
* Returns whether the error has start and end column information.
*
* For column information enable the startFilePos and endFilePos in the lexer options.
*
* @return bool
*/
public function hasColumnInfo(): bool {
return isset($this->attributes['startFilePos'], $this->attributes['endFilePos']);
@@ -104,7 +98,6 @@ class Error extends \RuntimeException {
* Gets the start column (1-based) into the line where the error started.
*
* @param string $code Source code of the file
* @return int
*/
public function getStartColumn(string $code): int {
if (!$this->hasColumnInfo()) {
@@ -118,7 +111,6 @@ class Error extends \RuntimeException {
* Gets the end column (1-based) into the line where the error ended.
*
* @param string $code Source code of the file
* @return int
*/
public function getEndColumn(string $code): int {
if (!$this->hasColumnInfo()) {
@@ -147,7 +139,7 @@ class Error extends \RuntimeException {
* Converts a file offset into a column.
*
* @param string $code Source code that $pos indexes into
* @param int $pos 0-based position in $code
* @param int $pos 0-based position in $code
*
* @return int 1-based column (relative to start of line)
*/
@@ -167,7 +159,7 @@ class Error extends \RuntimeException {
/**
* Updates the exception message after a change to rawMessage or rawLine.
*/
protected function updateMessage() {
protected function updateMessage(): void {
$this->message = $this->rawMessage;
if (-1 === $this->getStartLine()) {

@@ -8,5 +8,5 @@ interface ErrorHandler {
*
* @param Error $error The error that needs to be handled
*/
public function handleError(Error $error);
public function handleError(Error $error): void;
}

@@ -12,9 +12,9 @@ use PhpParser\ErrorHandler;
*/
class Collecting implements ErrorHandler {
/** @var Error[] Collected errors */
private $errors = [];
private array $errors = [];
public function handleError(Error $error) {
public function handleError(Error $error): void {
$this->errors[] = $error;
}
@@ -29,8 +29,6 @@ class Collecting implements ErrorHandler {
/**
* Check whether there are any errors.
*
* @return bool
*/
public function hasErrors(): bool {
return !empty($this->errors);
@@ -39,7 +37,7 @@ class Collecting implements ErrorHandler {
/**
* Reset/clear collected errors.
*/
public function clearErrors() {
public function clearErrors(): void {
$this->errors = [];
}
}

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

@@ -12,12 +12,17 @@ class DiffElem {
public const TYPE_REPLACE = 3;
/** @var int One of the TYPE_* constants */
public $type;
public int $type;
/** @var mixed Is null for add operations */
public $old;
/** @var mixed Is null for remove operations */
public $new;
/**
* @param int $type One of the TYPE_* constants
* @param mixed $old Is null for add operations
* @param mixed $new Is null for remove operations
*/
public function __construct(int $type, $old, $new) {
$this->type = $type;
$this->old = $old;

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

@@ -17,35 +17,46 @@ use PhpParser\Node\Expr;
*/
class PrintableNewAnonClassNode extends Expr {
/** @var Node\AttributeGroup[] PHP attribute groups */
public $attrGroups;
/** @var Node\Arg[] Arguments */
public $args;
public array $attrGroups;
/** @var int Modifiers */
public int $flags;
/** @var (Node\Arg|Node\VariadicPlaceholder)[] Arguments */
public array $args;
/** @var null|Node\Name Name of extended class */
public $extends;
public ?Node\Name $extends;
/** @var Node\Name[] Names of implemented interfaces */
public $implements;
public array $implements;
/** @var Node\Stmt[] Statements */
public $stmts;
public array $stmts;
/**
* @param Node\AttributeGroup[] $attrGroups PHP attribute groups
* @param (Node\Arg|Node\VariadicPlaceholder)[] $args Arguments
* @param Node\Name|null $extends Name of extended class
* @param Node\Name[] $implements Names of implemented interfaces
* @param Node\Stmt[] $stmts Statements
* @param array<string, mixed> $attributes Attributes
*/
public function __construct(
array $attrGroups, array $args, ?Node\Name $extends, array $implements,
array $attrGroups, int $flags, array $args, ?Node\Name $extends, array $implements,
array $stmts, array $attributes
) {
parent::__construct($attributes);
$this->attrGroups = $attrGroups;
$this->flags = $flags;
$this->args = $args;
$this->extends = $extends;
$this->implements = $implements;
$this->stmts = $stmts;
}
public static function fromNewNode(Expr\New_ $newNode) {
public static function fromNewNode(Expr\New_ $newNode): self {
$class = $newNode->class;
assert($class instanceof Node\Stmt\Class_);
// We don't assert that $class->name is null here, to allow consumers to assign unique names
// to anonymous classes for their own purposes. We simplify ignore the name here.
return new self(
$class->attrGroups, $newNode->args, $class->extends, $class->implements,
$class->attrGroups, $class->flags, $newNode->args, $class->extends, $class->implements,
$class->stmts, $newNode->getAttributes()
);
}
@@ -55,6 +66,6 @@ class PrintableNewAnonClassNode extends Expr {
}
public function getSubNodeNames(): array {
return ['attrGroups', 'args', 'extends', 'implements', 'stmts'];
return ['attrGroups', 'flags', 'args', 'extends', 'implements', 'stmts'];
}
}

@@ -17,15 +17,15 @@ if (\PHP_VERSION_ID >= 80000) {
*/
class TokenPolyfill {
/** @var int The ID of the token. Either a T_* constant of a character code < 256. */
public $id;
public int $id;
/** @var string The textual content of the token. */
public $text;
public string $text;
/** @var int The 1-based starting line of the token (or -1 if unknown). */
public $line;
public int $line;
/** @var int The 0-based starting position of the token (or -1 if unknown). */
public $pos;
public int $pos;
/** @var bool[] Tokens ignored by the PHP parser. */
/** @var array<int, bool> Tokens ignored by the PHP parser. */
private const IGNORABLE_TOKENS = [
\T_WHITESPACE => true,
\T_COMMENT => true,
@@ -33,8 +33,8 @@ class TokenPolyfill {
\T_OPEN_TAG => true,
];
/** @var bool[] Tokens that may be part of a T_NAME_* identifier. */
private static $identifierTokens;
/** @var array<int, bool> Tokens that may be part of a T_NAME_* identifier. */
private static array $identifierTokens;
/**
* Create a Token with the given ID and text, as well optional line and position information.
@@ -64,7 +64,7 @@ class TokenPolyfill {
* the token ID, a string that matches the token text, or an array of integers/strings. In the
* latter case, the function returns true if any of the kinds in the array match.
*
* @param int|string|array $kind
* @param int|string|(int|string)[] $kind
*/
public function is($kind): bool {
if (\is_int($kind)) {
@@ -119,7 +119,7 @@ class TokenPolyfill {
* T_WHITESPACE token.
* * Namespaced names are represented using T_NAME_* tokens.
*
* @returns static[]
* @return static[]
*/
public static function tokenize(string $code, int $flags = 0): array {
self::init();
@@ -128,9 +128,6 @@ class TokenPolyfill {
$line = 1;
$pos = 0;
$origTokens = \token_get_all($code, $flags);
if (\PHP_VERSION_ID < 70400) {
$origTokens = self::fixupBadCharacters($code, $origTokens);
}
$numTokens = \count($origTokens);
for ($i = 0; $i < $numTokens; $i++) {
@@ -217,38 +214,6 @@ class TokenPolyfill {
return $tokens;
}
/**
* Prior to PHP 7.4, token_get_all() simply dropped invalid characters from the token stream.
* Detect such cases and replace them with T_BAD_CHARACTER.
*/
private static function fixupBadCharacters(string $code, array $origTokens): array {
$newTokens = [];
$pos = 0;
foreach ($origTokens as $token) {
$text = \is_string($token) ? $token : $token[1];
$len = \strlen($text);
if (substr($code, $pos, $len) !== $text) {
$nextPos = strpos($code, $text, $pos);
for ($i = $pos; $i < $nextPos; $i++) {
// Don't bother including the line, we're not going to use it anyway.
$newTokens[] = [\T_BAD_CHARACTER, $code[$i]];
}
$pos = $nextPos;
}
$pos += $len;
$newTokens[] = $token;
}
// Handle trailing invalid characters.
$codeLen = \strlen($code);
if ($pos !== $codeLen) {
for ($i = $pos; $i < $codeLen; $i++) {
$newTokens[] = [\T_BAD_CHARACTER, $code[$i]];
}
}
return $newTokens;
}
/** Initialize private static state needed by tokenize(). */
private static function init(): void {
if (isset(self::$identifierTokens)) {

@@ -11,9 +11,9 @@ use PhpParser\Token;
*/
class TokenStream {
/** @var Token[] Tokens (in PhpToken::tokenize() format) */
private $tokens;
private array $tokens;
/** @var int[] Map from position to indentation */
private $indentMap;
private array $indentMap;
/**
* Create token stream instance.
@@ -29,9 +29,7 @@ class TokenStream {
* Whether the given position is immediately surrounded by parenthesis.
*
* @param int $startPos Start position
* @param int $endPos End position
*
* @return bool
* @param int $endPos End position
*/
public function haveParens(int $startPos, int $endPos): bool {
return $this->haveTokenImmediatelyBefore($startPos, '(')
@@ -42,9 +40,7 @@ class TokenStream {
* Whether the given position is immediately surrounded by braces.
*
* @param int $startPos Start position
* @param int $endPos End position
*
* @return bool
* @param int $endPos End position
*/
public function haveBraces(int $startPos, int $endPos): bool {
return ($this->haveTokenImmediatelyBefore($startPos, '{')
@@ -57,7 +53,7 @@ class TokenStream {
*
* During this check whitespace and comments are skipped.
*
* @param int $pos Position before which the token should occur
* @param int $pos Position before which the token should occur
* @param int|string $expectedTokenType Token to check for
*
* @return bool Whether the expected token was found
@@ -82,7 +78,7 @@ class TokenStream {
*
* During this check whitespace and comments are skipped.
*
* @param int $pos Position after which the token should occur
* @param int $pos Position after which the token should occur
* @param int|string $expectedTokenType Token to check for
*
* @return bool Whether the expected token was found
@@ -102,7 +98,8 @@ class TokenStream {
return false;
}
public function skipLeft(int $pos, $skipTokenType) {
/** @param int|string|(int|string)[] $skipTokenType */
public function skipLeft(int $pos, $skipTokenType): int {
$tokens = $this->tokens;
$pos = $this->skipLeftWhitespace($pos);
@@ -119,7 +116,8 @@ class TokenStream {
return $this->skipLeftWhitespace($pos);
}
public function skipRight(int $pos, $skipTokenType) {
/** @param int|string|(int|string)[] $skipTokenType */
public function skipRight(int $pos, $skipTokenType): int {
$tokens = $this->tokens;
$pos = $this->skipRightWhitespace($pos);
@@ -168,7 +166,8 @@ class TokenStream {
return $pos;
}
public function findRight(int $pos, $findTokenType) {
/** @param int|string|(int|string)[] $findTokenType */
public function findRight(int $pos, $findTokenType): int {
$tokens = $this->tokens;
for ($count = \count($tokens); $pos < $count; $pos++) {
if ($tokens[$pos]->is($findTokenType)) {
@@ -196,10 +195,9 @@ class TokenStream {
return false;
}
public function haveBracesInRange(int $startPos, int $endPos) {
return $this->haveTokenInRange($startPos, $endPos, '{')
|| $this->haveTokenInRange($startPos, $endPos, T_CURLY_OPEN)
|| $this->haveTokenInRange($startPos, $endPos, '}');
public function haveTagInRange(int $startPos, int $endPos): bool {
return $this->haveTokenInRange($startPos, $endPos, \T_OPEN_TAG)
|| $this->haveTokenInRange($startPos, $endPos, \T_CLOSE_TAG);
}
/**
@@ -216,8 +214,8 @@ class TokenStream {
/**
* Get the code corresponding to a token offset range, optionally adjusted for indentation.
*
* @param int $from Token start position (inclusive)
* @param int $to Token end position (exclusive)
* @param int $from Token start position (inclusive)
* @param int $to Token end position (exclusive)
* @param int $indent By how much the code should be indented (can be negative as well)
*
* @return string Code corresponding to token range, adjusted for indentation
@@ -253,7 +251,7 @@ class TokenStream {
private function calcIndentMap(): array {
$indentMap = [];
$indent = 0;
foreach ($this->tokens as $token) {
foreach ($this->tokens as $i => $token) {
$indentMap[] = $indent;
if ($token->id === \T_WHITESPACE) {
@@ -261,6 +259,10 @@ class TokenStream {
$newlinePos = \strrpos($content, "\n");
if (false !== $newlinePos) {
$indent = \strlen($content) - $newlinePos - 1;
} elseif ($i === 1 && $this->tokens[0]->id === \T_OPEN_TAG &&
$this->tokens[0]->text[\strlen($this->tokens[0]->text) - 1] === "\n") {
// Special case: Newline at the end of opening tag followed by whitespace.
$indent = \strlen($content);
}
}
}

@@ -3,9 +3,10 @@
namespace PhpParser;
class JsonDecoder {
/** @var \ReflectionClass[] Node type to reflection class map */
private $reflectionClassCache;
/** @var \ReflectionClass<Node>[] Node type to reflection class map */
private array $reflectionClassCache;
/** @return mixed */
public function decode(string $json) {
$value = json_decode($json, true);
if (json_last_error()) {
@@ -15,6 +16,10 @@ class JsonDecoder {
return $this->decodeRecursive($value);
}
/**
* @param mixed $value
* @return mixed
*/
private function decodeRecursive($value) {
if (\is_array($value)) {
if (isset($value['nodeType'])) {
@@ -43,7 +48,6 @@ class JsonDecoder {
}
$reflectionClass = $this->reflectionClassFromNodeType($nodeType);
/** @var Node $node */
$node = $reflectionClass->newInstanceWithoutConstructor();
if (isset($value['attributes'])) {
@@ -78,6 +82,7 @@ class JsonDecoder {
);
}
/** @return \ReflectionClass<Node> */
private function reflectionClassFromNodeType(string $nodeType): \ReflectionClass {
if (!isset($this->reflectionClassCache[$nodeType])) {
$className = $this->classNameFromNodeType($nodeType);
@@ -86,6 +91,7 @@ class JsonDecoder {
return $this->reflectionClassCache[$nodeType];
}
/** @return class-string<Node> */
private function classNameFromNodeType(string $nodeType): string {
$className = 'PhpParser\\Node\\' . strtr($nodeType, '_', '\\');
if (class_exists($className)) {

@@ -2,88 +2,40 @@
namespace PhpParser;
use PhpParser\Parser\Tokens;
require __DIR__ . '/compatibility_tokens.php';
class Lexer {
/** @var string Code being tokenized */
protected $code;
/** @var Token[] Array of tokens */
protected $tokens;
/** @var int Current position in the token array */
protected $pos;
protected $prevCloseTagHasNewline;
protected $dropTokens;
private $attributeStartLineUsed;
private $attributeEndLineUsed;
private $attributeStartTokenPosUsed;
private $attributeEndTokenPosUsed;
private $attributeStartFilePosUsed;
private $attributeEndFilePosUsed;
private $attributeCommentsUsed;
/**
* Creates a Lexer.
* Tokenize the provided source code.
*
* @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 = []) {
// 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.
* The token array is in the same format as provided by the PhpToken::tokenize() method in
* PHP 8.0. The tokens are instances of PhpParser\Token, to abstract over a polyfill
* implementation in earlier PHP version.
*
* This function does not throw if lexing errors occur. Instead, errors may be retrieved using
* the getErrors() method.
* The token array is terminated by a sentinel token with token ID 0.
* The token array does not discard any tokens (i.e. whitespace and comments are included).
* The token position attributes are against this token array.
*
* @param string $code The source code to lex
* @param string $code The source code to tokenize.
* @param ErrorHandler|null $errorHandler Error handler to use for lexing errors. Defaults to
* ErrorHandler\Throwing
* ErrorHandler\Throwing.
* @return Token[] Tokens
*/
public function startLexing(string $code, ?ErrorHandler $errorHandler = null) {
public function tokenize(string $code, ?ErrorHandler $errorHandler = null): array {
if (null === $errorHandler) {
$errorHandler = new ErrorHandler\Throwing();
}
$this->code = $code; // keep the code around for __halt_compiler() handling
$this->pos = -1;
// 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::tokenize($code);
$this->postprocessTokens($errorHandler);
$tokens = @Token::tokenize($code);
$this->postprocessTokens($tokens, $errorHandler);
if (false !== $scream) {
ini_set('xdebug.scream', $scream);
}
return $tokens;
}
private function handleInvalidCharacter(Token $token, ErrorHandler $errorHandler): void {
@@ -111,33 +63,36 @@ class Lexer {
&& substr($token->text, -2) !== '*/';
}
protected function postprocessTokens(ErrorHandler $errorHandler) {
/**
* @param list<Token> $tokens
*/
protected function postprocessTokens(array &$tokens, ErrorHandler $errorHandler): void {
// This function reports errors (bad characters and unterminated comments) in the token
// array, and performs certain canonicalizations:
// * 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.
// * Add a sentinel token with ID 0.
$numTokens = \count($this->tokens);
$numTokens = \count($tokens);
if ($numTokens === 0) {
// Empty input edge case: Just add the sentinel token.
$this->tokens[] = new Token(0, "\0", 1, 0);
$tokens[] = new Token(0, "\0", 1, 0);
return;
}
for ($i = 0; $i < $numTokens; $i++) {
$token = $this->tokens[$i];
$token = $tokens[$i];
if ($token->id === \T_BAD_CHARACTER) {
$this->handleInvalidCharacter($token, $errorHandler);
}
if ($token->id === \ord('&')) {
$next = $i + 1;
while (isset($this->tokens[$next]) && $this->tokens[$next]->id === \T_WHITESPACE) {
while (isset($tokens[$next]) && $tokens[$next]->id === \T_WHITESPACE) {
$next++;
}
$followedByVarOrVarArg = isset($this->tokens[$next]) &&
$this->tokens[$next]->is([\T_VARIABLE, \T_ELLIPSIS]);
$followedByVarOrVarArg = isset($tokens[$next]) &&
$tokens[$next]->is([\T_VARIABLE, \T_ELLIPSIS]);
$token->id = $followedByVarOrVarArg
? \T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
: \T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG;
@@ -145,7 +100,7 @@ class Lexer {
}
// Check for unterminated comment
$lastToken = $this->tokens[$numTokens - 1];
$lastToken = $tokens[$numTokens - 1];
if ($this->isUnterminatedComment($lastToken)) {
$errorHandler->handleError(new Error('Unterminated comment', [
'startLine' => $lastToken->line,
@@ -156,115 +111,6 @@ class Lexer {
}
// Add sentinel token.
$this->tokens[] = new Token(0, "\0", $lastToken->getEndLine(), $lastToken->getEndPos());
}
/**
* 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) {
$token = $this->tokens[++$this->pos];
if ($this->attributeStartLineUsed) {
$startAttributes['startLine'] = $token->line;
}
if ($this->attributeStartTokenPosUsed) {
$startAttributes['startTokenPos'] = $this->pos;
}
if ($this->attributeStartFilePosUsed) {
$startAttributes['startFilePos'] = $token->pos;
}
$id = $token->id;
if (isset($this->dropTokens[$id])) {
if (\T_COMMENT === $id || \T_DOC_COMMENT === $id) {
if ($this->attributeCommentsUsed) {
$comment = \T_DOC_COMMENT === $id
? new Comment\Doc($token->text, $token->line, $token->pos, $this->pos,
$token->getEndLine(), $token->getEndPos() - 1, $this->pos)
: new Comment($token->text, $token->line, $token->pos, $this->pos,
$token->getEndLine(), $token->getEndPos() - 1, $this->pos);
$startAttributes['comments'][] = $comment;
}
}
continue;
}
$value = $token->text;
if (\T_CLOSE_TAG === $token->id) {
$this->prevCloseTagHasNewline = false !== strpos($value, "\n")
|| false !== strpos($value, "\r");
} elseif (\T_INLINE_HTML === $token->id) {
$startAttributes['hasLeadingNewline'] = $this->prevCloseTagHasNewline;
}
// Fetch the end line/pos from the next token (if available) instead of recomputing it.
$nextToken = $this->tokens[$this->pos + 1] ?? null;
if ($this->attributeEndLineUsed) {
$endAttributes['endLine'] = $nextToken ? $nextToken->line : $token->getEndLine();
}
if ($this->attributeEndTokenPosUsed) {
$endAttributes['endTokenPos'] = $this->pos;
}
if ($this->attributeEndFilePosUsed) {
$endAttributes['endFilePos'] = ($nextToken ? $nextToken->pos : $token->getEndPos()) - 1;
}
return $id;
}
}
/**
* Returns the token array for current code.
*
* The token array is in the same format as provided by the PhpToken::tokenize() method in
* PHP 8.0. The tokens are instances of PhpParser\Token, to abstract over a polyfill
* implementation in earlier PHP version.
*
* The token array is terminated by a sentinel token with token ID 0.
* The token array does not discard any tokens (i.e. whitespace and comments are included).
* The token position attributes are against this token array.
*
* @return Token[] Array of tokens
*/
public function getTokens(): array {
return $this->tokens;
}
/**
* Handles __halt_compiler() by returning the text after it.
*
* @return string Remaining text
*/
public function handleHaltCompiler(): string {
// Prevent the lexer from returning any further tokens.
$nextToken = $this->tokens[$this->pos + 1];
$this->pos = \count($this->tokens) - 2;
// Return text after __halt_compiler.
return $nextToken->id === \T_INLINE_HTML ? $nextToken->text : '';
$tokens[] = new Token(0, "\0", $lastToken->getEndLine(), $lastToken->getEndPos());
}
}

@@ -14,50 +14,39 @@ use PhpParser\Lexer\TokenEmulator\FnTokenEmulator;
use PhpParser\Lexer\TokenEmulator\MatchTokenEmulator;
use PhpParser\Lexer\TokenEmulator\NullsafeTokenEmulator;
use PhpParser\Lexer\TokenEmulator\NumericLiteralSeparatorEmulator;
use PhpParser\Lexer\TokenEmulator\ReadonlyFunctionTokenEmulator;
use PhpParser\Lexer\TokenEmulator\ReadonlyTokenEmulator;
use PhpParser\Lexer\TokenEmulator\ReverseEmulator;
use PhpParser\Lexer\TokenEmulator\TokenEmulator;
use PhpParser\PhpVersion;
use PhpParser\Token;
class Emulative extends Lexer {
/** @var mixed[] Patches used to reverse changes introduced in the code */
private $patches = [];
/** @var array{int, string, string}[] Patches used to reverse changes introduced in the code */
private array $patches = [];
/** @var TokenEmulator[] */
private $emulators = [];
/** @var list<TokenEmulator> */
private array $emulators = [];
/** @var PhpVersion */
private $targetPhpVersion;
/** @var PhpVersion */
private $hostPhpVersion;
private PhpVersion $targetPhpVersion;
private PhpVersion $hostPhpVersion;
/**
* @param mixed[] $options Lexer options. In addition to the usual options, accepts a
* 'phpVersion' (PhpVersion object or string) that specifies the
* version to emulate. Defaults to newest supported.
* @param PhpVersion|null $phpVersion PHP version to emulate. Defaults to newest supported.
*/
public function __construct(array $options = []) {
$version = $options['phpVersion'] ?? PhpVersion::getNewestSupported();
if (!$version instanceof PhpVersion) {
$version = PhpVersion::fromString($version);
}
$this->targetPhpVersion = $version;
public function __construct(?PhpVersion $phpVersion = null) {
$this->targetPhpVersion = $phpVersion ?? PhpVersion::getNewestSupported();
$this->hostPhpVersion = PhpVersion::getHostVersion();
unset($options['phpVersion']);
parent::__construct($options);
$emulators = [
new FlexibleDocStringEmulator(),
new FnTokenEmulator(),
new MatchTokenEmulator(),
new CoaleseEqualTokenEmulator(),
new NumericLiteralSeparatorEmulator(),
new NullsafeTokenEmulator(),
new AttributeEmulator(),
new EnumTokenEmulator(),
new ReadonlyTokenEmulator(),
new ExplicitOctalEmulator(),
new ReadonlyFunctionTokenEmulator(),
];
// Collect emulators that are relevant for the PHP version we're running
@@ -72,15 +61,18 @@ class Emulative extends Lexer {
}
}
public function startLexing(string $code, ?ErrorHandler $errorHandler = null) {
public function tokenize(string $code, ?ErrorHandler $errorHandler = null): array {
$emulators = array_filter($this->emulators, function ($emulator) use ($code) {
return $emulator->isEmulationNeeded($code);
});
if (empty($emulators)) {
// Nothing to emulate, yay
parent::startLexing($code, $errorHandler);
return;
return parent::tokenize($code, $errorHandler);
}
if ($errorHandler === null) {
$errorHandler = new ErrorHandler\Throwing();
}
$this->patches = [];
@@ -89,9 +81,9 @@ class Emulative extends Lexer {
}
$collector = new ErrorHandler\Collecting();
parent::startLexing($code, $collector);
$tokens = parent::tokenize($code, $collector);
$this->sortPatches();
$this->fixupTokens();
$tokens = $this->fixupTokens($tokens);
$errors = $collector->getErrors();
if (!empty($errors)) {
@@ -102,8 +94,10 @@ class Emulative extends Lexer {
}
foreach ($emulators as $emulator) {
$this->tokens = $emulator->emulate($code, $this->tokens);
$tokens = $emulator->emulate($code, $tokens);
}
return $tokens;
}
private function isForwardEmulationNeeded(PhpVersion $emulatorPhpVersion): bool {
@@ -116,7 +110,7 @@ class Emulative extends Lexer {
&& $this->targetPhpVersion->older($emulatorPhpVersion);
}
private function sortPatches() {
private function sortPatches(): void {
// Patches may be contributed by different emulators.
// Make sure they are sorted by increasing patch position.
usort($this->patches, function ($p1, $p2) {
@@ -124,9 +118,13 @@ class Emulative extends Lexer {
});
}
private function fixupTokens() {
/**
* @param list<Token> $tokens
* @return list<Token>
*/
private function fixupTokens(array $tokens): array {
if (\count($this->patches) === 0) {
return;
return $tokens;
}
// Load first patch
@@ -135,10 +133,12 @@ class Emulative extends Lexer {
// We use a manual loop over the tokens, because we modify the array on the fly
$posDelta = 0;
for ($i = 0, $c = \count($this->tokens); $i < $c; $i++) {
$token = $this->tokens[$i];
$lineDelta = 0;
for ($i = 0, $c = \count($tokens); $i < $c; $i++) {
$token = $tokens[$i];
$pos = $token->pos;
$token->pos += $posDelta;
$token->line += $lineDelta;
$localPosDelta = 0;
$len = \strlen($token->text);
while ($patchPos >= $pos && $patchPos < $pos + $len) {
@@ -146,7 +146,7 @@ class Emulative extends Lexer {
if ($patchType === 'remove') {
if ($patchPos === $pos && $patchTextLen === $len) {
// Remove token entirely
array_splice($this->tokens, $i, 1, []);
array_splice($tokens, $i, 1, []);
$i--;
$c--;
} else {
@@ -156,12 +156,14 @@ class Emulative extends Lexer {
);
$localPosDelta -= $patchTextLen;
}
$lineDelta -= \substr_count($patchText, "\n");
} elseif ($patchType === 'add') {
// Insert into the token string
$token->text = substr_replace(
$token->text, $patchText, $patchPos - $pos + $localPosDelta, 0
);
$localPosDelta += $patchTextLen;
$lineDelta += \substr_count($patchText, "\n");
} elseif ($patchType === 'replace') {
// Replace inside the token string
$token->text = substr_replace(
@@ -184,6 +186,7 @@ class Emulative extends Lexer {
$posDelta += $localPosDelta;
}
return $tokens;
}
/**
@@ -191,7 +194,7 @@ class Emulative extends Lexer {
*
* @param Error[] $errors
*/
private function fixupErrors(array $errors) {
private function fixupErrors(array $errors): void {
foreach ($errors as $error) {
$attrs = $error->getAttributes();

@@ -1,40 +0,0 @@
<?php declare(strict_types=1);
namespace PhpParser\Lexer\TokenEmulator;
use PhpParser\PhpVersion;
use PhpParser\Token;
final class CoaleseEqualTokenEmulator extends TokenEmulator {
public function getPhpVersion(): PhpVersion {
return PhpVersion::fromComponents(7, 4);
}
public function isEmulationNeeded(string $code): bool {
return strpos($code, '??=') !== false;
}
public function emulate(string $code, array $tokens): array {
// We need to manually iterate and manage a count because we'll change
// the tokens array on the way
for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
$token = $tokens[$i];
if (isset($tokens[$i + 1])) {
if ($token->id === T_COALESCE && $tokens[$i + 1]->text === '=') {
array_splice($tokens, $i, 2, [
new Token(\T_COALESCE_EQUAL, '??=', $token->line, $token->pos),
]);
$c--;
continue;
}
}
}
return $tokens;
}
public function reverseEmulate(string $code, array $tokens): array {
// ??= was not valid code previously, don't bother.
return $tokens;
}
}

@@ -1,71 +0,0 @@
<?php declare(strict_types=1);
namespace PhpParser\Lexer\TokenEmulator;
use PhpParser\PhpVersion;
final class FlexibleDocStringEmulator extends TokenEmulator {
private const FLEXIBLE_DOC_STRING_REGEX = <<<'REGEX'
/<<<[ \t]*(['"]?)([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)\1\r?\n
(?:.*\r?\n)*?
(?<indentation>\h*)\2(?![a-zA-Z0-9_\x80-\xff])(?<separator>(?:;?[\r\n])?)/x
REGEX;
public function getPhpVersion(): PhpVersion {
return PhpVersion::fromComponents(7, 3);
}
public function isEmulationNeeded(string $code): bool {
return strpos($code, '<<<') !== false;
}
public function emulate(string $code, array $tokens): array {
// Handled by preprocessing + fixup.
return $tokens;
}
public function reverseEmulate(string $code, array $tokens): array {
// Not supported.
return $tokens;
}
public function preprocessCode(string $code, array &$patches): string {
if (!preg_match_all(self::FLEXIBLE_DOC_STRING_REGEX, $code, $matches, PREG_SET_ORDER|PREG_OFFSET_CAPTURE)) {
// No heredoc/nowdoc found
return $code;
}
// Keep track of how much we need to adjust string offsets due to the modifications we
// already made
$posDelta = 0;
foreach ($matches as $match) {
$indentation = $match['indentation'][0];
$indentationStart = $match['indentation'][1];
$separator = $match['separator'][0];
$separatorStart = $match['separator'][1];
if ($indentation === '' && $separator !== '') {
// Ordinary heredoc/nowdoc
continue;
}
if ($indentation !== '') {
// Remove indentation
$indentationLen = strlen($indentation);
$code = substr_replace($code, '', $indentationStart + $posDelta, $indentationLen);
$patches[] = [$indentationStart + $posDelta, 'add', $indentation];
$posDelta -= $indentationLen;
}
if ($separator === '') {
// Insert newline as separator
$code = substr_replace($code, "\n", $separatorStart + $posDelta, 0);
$patches[] = [$separatorStart + $posDelta, 'remove', "\n"];
$posDelta += 1;
}
}
return $code;
}
}

@@ -1,19 +0,0 @@
<?php declare(strict_types=1);
namespace PhpParser\Lexer\TokenEmulator;
use PhpParser\PhpVersion;
final class FnTokenEmulator extends KeywordEmulator {
public function getPhpVersion(): PhpVersion {
return PhpVersion::fromComponents(7, 4);
}
public function getKeywordString(): string {
return 'fn';
}
public function getKeywordToken(): int {
return \T_FN;
}
}

@@ -45,7 +45,7 @@ abstract class KeywordEmulator extends TokenEmulator {
public function reverseEmulate(string $code, array $tokens): array {
$keywordToken = $this->getKeywordToken();
foreach ($tokens as $i => $token) {
foreach ($tokens as $token) {
if ($token->id === $keywordToken) {
$token->id = \T_STRING;
}

@@ -1,95 +0,0 @@
<?php declare(strict_types=1);
namespace PhpParser\Lexer\TokenEmulator;
use PhpParser\PhpVersion;
use PhpParser\Token;
final class NumericLiteralSeparatorEmulator extends TokenEmulator {
private const BIN = '(?:0b[01]+(?:_[01]+)*)';
private const HEX = '(?:0x[0-9a-f]+(?:_[0-9a-f]+)*)';
private const DEC = '(?:[0-9]+(?:_[0-9]+)*)';
private const SIMPLE_FLOAT = '(?:' . self::DEC . '\.' . self::DEC . '?|\.' . self::DEC . ')';
private const EXP = '(?:e[+-]?' . self::DEC . ')';
private const FLOAT = '(?:' . self::SIMPLE_FLOAT . self::EXP . '?|' . self::DEC . self::EXP . ')';
private const NUMBER = '~' . self::FLOAT . '|' . self::BIN . '|' . self::HEX . '|' . self::DEC . '~iA';
public function getPhpVersion(): PhpVersion {
return PhpVersion::fromComponents(7, 4);
}
public function isEmulationNeeded(string $code): bool {
return preg_match('~[0-9]_[0-9]~', $code)
|| preg_match('~0x[0-9a-f]+_[0-9a-f]~i', $code);
}
public function emulate(string $code, array $tokens): array {
// We need to manually iterate and manage a count because we'll change
// the tokens array on the way
for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
$token = $tokens[$i];
$tokenLen = \strlen($token->text);
if ($token->id !== \T_LNUMBER && $token->id !== \T_DNUMBER) {
continue;
}
$res = preg_match(self::NUMBER, $code, $matches, 0, $token->pos);
assert($res, "No number at number token position");
$match = $matches[0];
$matchLen = \strlen($match);
if ($matchLen === $tokenLen) {
// Original token already holds the full number.
continue;
}
$tokenKind = $this->resolveIntegerOrFloatToken($match);
$newTokens = [new Token($tokenKind, $match, $token->line, $token->pos)];
$numTokens = 1;
$len = $tokenLen;
while ($matchLen > $len) {
$nextToken = $tokens[$i + $numTokens];
$nextTokenText = $nextToken->text;
$nextTokenLen = \strlen($nextTokenText);
$numTokens++;
if ($matchLen < $len + $nextTokenLen) {
// Split trailing characters into a partial token.
$partialText = substr($nextTokenText, $matchLen - $len);
$newTokens[] = new Token($nextToken->id, $partialText, $nextToken->line, $nextToken->pos);
break;
}
$len += $nextTokenLen;
}
array_splice($tokens, $i, $numTokens, $newTokens);
$c -= $numTokens - \count($newTokens);
}
return $tokens;
}
private function resolveIntegerOrFloatToken(string $str): int {
$str = str_replace('_', '', $str);
if (stripos($str, '0b') === 0) {
$num = bindec($str);
} elseif (stripos($str, '0x') === 0) {
$num = hexdec($str);
} elseif (stripos($str, '0') === 0 && ctype_digit($str)) {
$num = octdec($str);
} else {
$num = +$str;
}
return is_float($num) ? T_DNUMBER : T_LNUMBER;
}
public function reverseEmulate(string $code, array $tokens): array {
// Numeric separators were not legal code previously, don't bother.
return $tokens;
}
}

@@ -0,0 +1,31 @@
<?php declare(strict_types=1);
namespace PhpParser\Lexer\TokenEmulator;
use PhpParser\PhpVersion;
/*
* In PHP 8.1, "readonly(" was special cased in the lexer in order to support functions with
* name readonly. In PHP 8.2, this may conflict with readonly properties having a DNF type. For
* this reason, PHP 8.2 instead treats this as T_READONLY and then handles it specially in the
* parser. This emulator only exists to handle this special case, which is skipped by the
* PHP 8.1 ReadonlyTokenEmulator.
*/
class ReadonlyFunctionTokenEmulator extends KeywordEmulator {
public function getKeywordString(): string {
return 'readonly';
}
public function getKeywordToken(): int {
return \T_READONLY;
}
public function getPhpVersion(): PhpVersion {
return PhpVersion::fromComponents(8, 2);
}
public function reverseEmulate(string $code, array $tokens): array {
// Don't bother
return $tokens;
}
}

@@ -9,7 +9,7 @@ use PhpParser\PhpVersion;
*/
final class ReverseEmulator extends TokenEmulator {
/** @var TokenEmulator Inner emulator */
private $emulator;
private TokenEmulator $emulator;
public function __construct(TokenEmulator $emulator) {
$this->emulator = $emulator;

@@ -12,16 +12,18 @@ abstract class TokenEmulator {
abstract public function isEmulationNeeded(string $code): bool;
/**
* @param Token[] Original tokens
* @param Token[] $tokens Original tokens
* @return Token[] Modified Tokens
*/
abstract public function emulate(string $code, array $tokens): array;
/**
* @param Token[] $tokens Original tokens
* @return Token[] Modified Tokens
*/
abstract public function reverseEmulate(string $code, array $tokens): array;
/** @param array{int, string, string}[] $patches */
public function preprocessCode(string $code, array &$patches): string {
return $code;
}

@@ -16,4 +16,54 @@ final class Modifiers {
public const READONLY = 64;
public const VISIBILITY_MASK = 1 | 2 | 4;
/**
* @internal
*/
public static function verifyClassModifier(int $a, int $b): void {
if ($a & Modifiers::ABSTRACT && $b & Modifiers::ABSTRACT) {
throw new Error('Multiple abstract modifiers are not allowed');
}
if ($a & Modifiers::FINAL && $b & Modifiers::FINAL) {
throw new Error('Multiple final modifiers are not allowed');
}
if ($a & Modifiers::READONLY && $b & Modifiers::READONLY) {
throw new Error('Multiple readonly modifiers are not allowed');
}
if ($a & 48 && $b & 48) {
throw new Error('Cannot use the final modifier on an abstract class');
}
}
/**
* @internal
*/
public static function verifyModifier(int $a, int $b): void {
if ($a & Modifiers::VISIBILITY_MASK && $b & Modifiers::VISIBILITY_MASK) {
throw new Error('Multiple access type modifiers are not allowed');
}
if ($a & Modifiers::ABSTRACT && $b & Modifiers::ABSTRACT) {
throw new Error('Multiple abstract modifiers are not allowed');
}
if ($a & Modifiers::STATIC && $b & Modifiers::STATIC) {
throw new Error('Multiple static modifiers are not allowed');
}
if ($a & Modifiers::FINAL && $b & Modifiers::FINAL) {
throw new Error('Multiple final modifiers are not allowed');
}
if ($a & Modifiers::READONLY && $b & Modifiers::READONLY) {
throw new Error('Multiple readonly modifiers are not allowed');
}
if ($a & 48 && $b & 48) {
throw new Error('Cannot use the final modifier on an abstract class member');
}
}
}

@@ -8,16 +8,16 @@ use PhpParser\Node\Stmt;
class NameContext {
/** @var null|Name Current namespace */
protected $namespace;
protected ?Name $namespace;
/** @var Name[][] Map of format [aliasType => [aliasName => originalName]] */
protected $aliases = [];
protected array $aliases = [];
/** @var Name[][] Same as $aliases but preserving original case */
protected $origAliases = [];
protected array $origAliases = [];
/** @var ErrorHandler Error handler */
protected $errorHandler;
protected ErrorHandler $errorHandler;
/**
* Create a name context.
@@ -35,7 +35,7 @@ class NameContext {
*
* @param Name|null $namespace Null is the global namespace
*/
public function startNamespace(?Name $namespace = null) {
public function startNamespace(?Name $namespace = null): void {
$this->namespace = $namespace;
$this->origAliases = $this->aliases = [
Stmt\Use_::TYPE_NORMAL => [],
@@ -47,12 +47,12 @@ class NameContext {
/**
* Add an alias / import.
*
* @param Name $name Original name
* @param string $aliasName Aliased name
* @param int $type One of Stmt\Use_::TYPE_*
* @param array $errorAttrs Attributes to use to report an error
* @param Name $name Original name
* @param string $aliasName Aliased name
* @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
* @param array<string, mixed> $errorAttrs Attributes to use to report an error
*/
public function addAlias(Name $name, string $aliasName, int $type, array $errorAttrs = []) {
public function addAlias(Name $name, string $aliasName, int $type, array $errorAttrs = []): void {
// Constant names are case sensitive, everything else case insensitive
if ($type === Stmt\Use_::TYPE_CONSTANT) {
$aliasLookupName = $aliasName;
@@ -94,7 +94,7 @@ class NameContext {
* Get resolved name.
*
* @param Name $name Name to resolve
* @param int $type One of Stmt\Use_::TYPE_{FUNCTION|CONSTANT}
* @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_{FUNCTION|CONSTANT}
*
* @return null|Name Resolved name, or null if static resolution is not possible
*/
@@ -149,7 +149,7 @@ class NameContext {
* Get possible ways of writing a fully qualified name (e.g., by making use of aliases).
*
* @param string $name Fully-qualified name (without leading namespace separator)
* @param int $type One of Stmt\Use_::TYPE_*
* @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
*
* @return Name[] Possible representations of the name
*/
@@ -205,7 +205,7 @@ class NameContext {
* Get shortest representation of this fully-qualified name.
*
* @param string $name Fully-qualified name (without leading namespace separator)
* @param int $type One of Stmt\Use_::TYPE_*
* @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
*
* @return Name Shortest representation
*/
@@ -226,7 +226,7 @@ class NameContext {
return $shortestName;
}
private function resolveAlias(Name $name, $type) {
private function resolveAlias(Name $name, int $type): ?FullyQualified {
$firstPart = $name->getFirst();
if ($name->isQualified()) {
@@ -249,7 +249,7 @@ class NameContext {
return null;
}
private function getNamespaceRelativeName(string $name, string $lcName, int $type) {
private function getNamespaceRelativeName(string $name, string $lcName, int $type): ?Name {
if (null === $this->namespace) {
return new Name($name);
}
@@ -270,7 +270,7 @@ class NameContext {
return null;
}
private function normalizeConstName(string $name) {
private function normalizeConstName(string $name): string {
$nsSep = strrpos($name, '\\');
if (false === $nsSep) {
return $name;

@@ -13,7 +13,7 @@ interface Node {
/**
* Gets the names of the sub nodes.
*
* @return array Names of sub nodes
* @return string[] Names of sub nodes
*/
public function getSubNodeNames(): array;
@@ -21,6 +21,8 @@ interface Node {
* Gets line the node started in (alias of getStartLine).
*
* @return int Start line (or -1 if not available)
*
* @deprecated Use getStartLine() instead
*/
public function getLine(): int;
@@ -105,30 +107,24 @@ interface Node {
*
* @param Comment\Doc $docComment Doc comment to set
*/
public function setDocComment(Comment\Doc $docComment);
public function setDocComment(Comment\Doc $docComment): void;
/**
* Sets an attribute on a node.
*
* @param string $key
* @param mixed $value
* @param mixed $value
*/
public function setAttribute(string $key, $value);
public function setAttribute(string $key, $value): void;
/**
* Returns whether an attribute exists.
*
* @param string $key
*
* @return bool
*/
public function hasAttribute(string $key): bool;
/**
* Returns the value of an attribute.
*
* @param string $key
* @param mixed $default
* @param mixed $default
*
* @return mixed
*/
@@ -137,14 +133,14 @@ interface Node {
/**
* Returns all the attributes of this node.
*
* @return array
* @return array<string, mixed>
*/
public function getAttributes(): array;
/**
* Replaces all the attributes of this node.
*
* @param array $attributes
* @param array<string, mixed> $attributes
*/
public function setAttributes(array $attributes);
public function setAttributes(array $attributes): void;
}

@@ -6,21 +6,21 @@ use PhpParser\NodeAbstract;
class Arg extends NodeAbstract {
/** @var Identifier|null Parameter name (for named parameters) */
public $name;
public ?Identifier $name;
/** @var Expr Value to pass */
public $value;
public Expr $value;
/** @var bool Whether to pass by ref */
public $byRef;
public bool $byRef;
/** @var bool Whether to unpack the argument */
public $unpack;
public bool $unpack;
/**
* Constructs a function call argument node.
*
* @param Expr $value Value to pass
* @param bool $byRef Whether to pass by ref
* @param bool $unpack Whether to unpack the argument
* @param array $attributes Additional attributes
* @param Expr $value Value to pass
* @param bool $byRef Whether to pass by ref
* @param bool $unpack Whether to unpack the argument
* @param array<string, mixed> $attributes Additional attributes
* @param Identifier|null $name Parameter name (for named parameters)
*/
public function __construct(

@@ -6,21 +6,21 @@ use PhpParser\NodeAbstract;
class ArrayItem extends NodeAbstract {
/** @var null|Expr Key */
public $key;
public ?Expr $key;
/** @var Expr Value */
public $value;
public Expr $value;
/** @var bool Whether to assign by reference */
public $byRef;
public bool $byRef;
/** @var bool Whether to unpack the argument */
public $unpack;
public bool $unpack;
/**
* Constructs an array item node.
*
* @param Expr $value Value
* @param null|Expr $key Key
* @param bool $byRef Whether to assign by reference
* @param array $attributes Additional attributes
* @param Expr $value Value
* @param null|Expr $key Key
* @param bool $byRef Whether to assign by reference
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $value, ?Expr $key = null, bool $byRef = false, array $attributes = [], bool $unpack = false) {
$this->attributes = $attributes;

@@ -7,15 +7,15 @@ use PhpParser\NodeAbstract;
class Attribute extends NodeAbstract {
/** @var Name Attribute name */
public $name;
public Name $name;
/** @var Arg[] Attribute arguments */
public $args;
/** @var list<Arg> Attribute arguments */
public array $args;
/**
* @param Node\Name $name Attribute name
* @param Arg[] $args Attribute arguments
* @param array $attributes Additional node attributes
* @param Node\Name $name Attribute name
* @param list<Arg> $args Attribute arguments
* @param array<string, mixed> $attributes Additional node attributes
*/
public function __construct(Name $name, array $args = [], array $attributes = []) {
$this->attributes = $attributes;

@@ -6,11 +6,11 @@ use PhpParser\NodeAbstract;
class AttributeGroup extends NodeAbstract {
/** @var Attribute[] Attributes */
public $attrs;
public array $attrs;
/**
* @param Attribute[] $attrs PHP attributes
* @param array $attributes Additional node attributes
* @param array<string, mixed> $attributes Additional node attributes
*/
public function __construct(array $attrs, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,16 +6,16 @@ use PhpParser\NodeAbstract;
class ClosureUse extends NodeAbstract {
/** @var Expr\Variable Variable to use */
public $var;
public Expr\Variable $var;
/** @var bool Whether to use by reference */
public $byRef;
public bool $byRef;
/**
* Constructs a closure use node.
*
* @param Expr\Variable $var Variable to use
* @param bool $byRef Whether to use by reference
* @param array $attributes Additional attributes
* @param Expr\Variable $var Variable to use
* @param bool $byRef Whether to use by reference
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr\Variable $var, bool $byRef = false, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,19 +6,19 @@ use PhpParser\NodeAbstract;
class Const_ extends NodeAbstract {
/** @var Identifier Name */
public $name;
public Identifier $name;
/** @var Expr Value */
public $value;
public Expr $value;
/** @var Name|null Namespaced name (if using NameResolver) */
public $namespacedName;
public ?Name $namespacedName;
/**
* Constructs a const node for use in class const and const statements.
*
* @param string|Identifier $name Name
* @param Expr $value Value
* @param array $attributes Additional attributes
* @param string|Identifier $name Name
* @param Expr $value Value
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct($name, Expr $value, array $attributes = []) {
$this->attributes = $attributes;

@@ -7,16 +7,16 @@ use PhpParser\NodeAbstract;
class DeclareItem extends NodeAbstract {
/** @var Node\Identifier Key */
public $key;
public Identifier $key;
/** @var Node\Expr Value */
public $value;
public Expr $value;
/**
* Constructs a declare key=>value pair node.
*
* @param string|Node\Identifier $key Key
* @param Node\Expr $value Value
* @param array $attributes Additional attributes
* @param string|Node\Identifier $key Key
* @param Node\Expr $value Value
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct($key, Node\Expr $value, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,16 +6,16 @@ use PhpParser\Node\Expr;
class ArrayDimFetch extends Expr {
/** @var Expr Variable */
public $var;
public Expr $var;
/** @var null|Expr Array index / dim */
public $dim;
public ?Expr $dim;
/**
* Constructs an array index fetch node.
*
* @param Expr $var Variable
* @param null|Expr $dim Array index / dim
* @param array $attributes Additional attributes
* @param Expr $var Variable
* @param null|Expr $dim Array index / dim
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $var, ?Expr $dim = null, array $attributes = []) {
$this->attributes = $attributes;

@@ -11,13 +11,13 @@ class Array_ extends Expr {
public const KIND_SHORT = 2; // [] syntax
/** @var ArrayItem[] Items */
public $items;
public array $items;
/**
* Constructs an array node.
*
* @param ArrayItem[] $items Items of the array
* @param array $attributes Additional attributes
* @param ArrayItem[] $items Items of the array
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(array $items = [], array $attributes = []) {
$this->attributes = $attributes;

@@ -7,40 +7,46 @@ use PhpParser\Node\Expr;
use PhpParser\Node\FunctionLike;
class ArrowFunction extends Expr implements FunctionLike {
/** @var bool */
public $static;
/** @var bool Whether the closure is static */
public bool $static;
/** @var bool */
public $byRef;
/** @var bool Whether to return by reference */
public bool $byRef;
/** @var Node\Param[] */
public $params = [];
public array $params = [];
/** @var null|Node\Identifier|Node\Name|Node\ComplexType */
public $returnType;
public ?Node $returnType;
/** @var Expr */
public $expr;
/** @var Expr Expression body */
public Expr $expr;
/** @var Node\AttributeGroup[] */
public $attrGroups;
public array $attrGroups;
/**
* @param array $subNodes Array of the following optional subnodes:
* 'static' => false : Whether the closure is static
* 'byRef' => false : Whether to return by reference
* 'params' => array() : Parameters
* 'returnType' => null : Return type
* 'expr' => Expr : Expression body
* 'attrGroups' => array() : PHP attribute groups
* @param array $attributes Additional attributes
* @param array{
* expr: Expr,
* static?: bool,
* byRef?: bool,
* params?: Node\Param[],
* returnType?: null|Node\Identifier|Node\Name|Node\ComplexType,
* attrGroups?: Node\AttributeGroup[]
* } $subNodes Array of the following subnodes:
* 'expr' : Expression body
* 'static' => false : Whether the closure is static
* 'byRef' => false : Whether to return by reference
* 'params' => array() : Parameters
* 'returnType' => null : Return type
* 'attrGroups' => array() : PHP attribute groups
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(array $subNodes = [], array $attributes = []) {
public function __construct(array $subNodes, array $attributes = []) {
$this->attributes = $attributes;
$this->static = $subNodes['static'] ?? false;
$this->byRef = $subNodes['byRef'] ?? false;
$this->params = $subNodes['params'] ?? [];
$returnType = $subNodes['returnType'] ?? null;
$this->returnType = \is_string($returnType) ? new Node\Identifier($returnType) : $returnType;
$this->returnType = $subNodes['returnType'] ?? null;
$this->expr = $subNodes['expr'];
$this->attrGroups = $subNodes['attrGroups'] ?? [];
}

@@ -6,16 +6,16 @@ use PhpParser\Node\Expr;
class Assign extends Expr {
/** @var Expr Variable */
public $var;
public Expr $var;
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs an assignment node.
*
* @param Expr $var Variable
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $var Variable
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $var, Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,16 +6,16 @@ use PhpParser\Node\Expr;
abstract class AssignOp extends Expr {
/** @var Expr Variable */
public $var;
public Expr $var;
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs a compound assignment operation node.
*
* @param Expr $var Variable
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $var Variable
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $var, Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,16 +6,16 @@ use PhpParser\Node\Expr;
class AssignRef extends Expr {
/** @var Expr Variable reference is assigned to */
public $var;
public Expr $var;
/** @var Expr Variable which is referenced */
public $expr;
public Expr $expr;
/**
* Constructs an assignment node.
*
* @param Expr $var Variable
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $var Variable
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $var, Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,16 +6,16 @@ use PhpParser\Node\Expr;
abstract class BinaryOp extends Expr {
/** @var Expr The left hand side expression */
public $left;
public Expr $left;
/** @var Expr The right hand side expression */
public $right;
public Expr $right;
/**
* Constructs a binary operator node.
*
* @param Expr $left The left hand side expression
* @param Expr $right The right hand side expression
* @param array $attributes Additional attributes
* @param Expr $left The left hand side expression
* @param Expr $right The right hand side expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $left, Expr $right, array $attributes = []) {
$this->attributes = $attributes;
@@ -32,8 +32,6 @@ abstract class BinaryOp extends Expr {
*
* In the case there are multiple possible sigils for an operator, this method does not
* necessarily return the one used in the parsed code.
*
* @return string
*/
abstract public function getOperatorSigil(): string;
}

@@ -6,13 +6,13 @@ use PhpParser\Node\Expr;
class BitwiseNot extends Expr {
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs a bitwise not node.
*
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,13 +6,13 @@ use PhpParser\Node\Expr;
class BooleanNot extends Expr {
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs a boolean not node.
*
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -19,12 +19,8 @@ abstract class CallLike extends Expr {
* Returns whether this call expression is actually a first class callable.
*/
public function isFirstClassCallable(): bool {
foreach ($this->getRawArgs() as $arg) {
if ($arg instanceof VariadicPlaceholder) {
return true;
}
}
return false;
$rawArgs = $this->getRawArgs();
return count($rawArgs) === 1 && current($rawArgs) instanceof VariadicPlaceholder;
}
/**

@@ -6,13 +6,13 @@ use PhpParser\Node\Expr;
abstract class Cast extends Expr {
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs a cast node.
*
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -2,24 +2,25 @@
namespace PhpParser\Node\Expr;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Identifier;
use PhpParser\Node\Name;
class ClassConstFetch extends Expr {
/** @var Name|Expr Class name */
public $class;
/** @var Identifier|Error Constant name */
public $name;
public Node $class;
/** @var Identifier|Expr|Error Constant name */
public Node $name;
/**
* Constructs a class const fetch node.
*
* @param Name|Expr $class Class name
* @param string|Identifier|Error $name Constant name
* @param array $attributes Additional attributes
* @param Name|Expr $class Class name
* @param string|Identifier|Expr|Error $name Constant name
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct($class, $name, array $attributes = []) {
public function __construct(Node $class, $name, array $attributes = []) {
$this->attributes = $attributes;
$this->class = $class;
$this->name = \is_string($name) ? new Identifier($name) : $name;

@@ -6,13 +6,13 @@ use PhpParser\Node\Expr;
class Clone_ extends Expr {
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs a clone node.
*
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -9,32 +9,40 @@ use PhpParser\Node\FunctionLike;
class Closure extends Expr implements FunctionLike {
/** @var bool Whether the closure is static */
public $static;
public bool $static;
/** @var bool Whether to return by reference */
public $byRef;
public bool $byRef;
/** @var Node\Param[] Parameters */
public $params;
public array $params;
/** @var ClosureUse[] use()s */
public $uses;
public array $uses;
/** @var null|Node\Identifier|Node\Name|Node\ComplexType Return type */
public $returnType;
public ?Node $returnType;
/** @var Node\Stmt[] Statements */
public $stmts;
public array $stmts;
/** @var Node\AttributeGroup[] PHP attribute groups */
public $attrGroups;
public array $attrGroups;
/**
* Constructs a lambda function node.
*
* @param array $subNodes Array of the following optional subnodes:
* 'static' => false : Whether the closure is static
* 'byRef' => false : Whether to return by reference
* 'params' => array(): Parameters
* 'uses' => array(): use()s
* 'returnType' => null : Return type
* 'stmts' => array(): Statements
* 'attrGroups' => array(): PHP attributes groups
* @param array $attributes Additional attributes
* @param array{
* static?: bool,
* byRef?: bool,
* params?: Node\Param[],
* uses?: ClosureUse[],
* returnType?: null|Node\Identifier|Node\Name|Node\ComplexType,
* stmts?: Node\Stmt[],
* attrGroups?: Node\AttributeGroup[],
* } $subNodes Array of the following optional subnodes:
* 'static' => false : Whether the closure is static
* 'byRef' => false : Whether to return by reference
* 'params' => array(): Parameters
* 'uses' => array(): use()s
* 'returnType' => null : Return type
* 'stmts' => array(): Statements
* 'attrGroups' => array(): PHP attributes groups
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(array $subNodes = [], array $attributes = []) {
$this->attributes = $attributes;
@@ -42,8 +50,7 @@ class Closure extends Expr implements FunctionLike {
$this->byRef = $subNodes['byRef'] ?? false;
$this->params = $subNodes['params'] ?? [];
$this->uses = $subNodes['uses'] ?? [];
$returnType = $subNodes['returnType'] ?? null;
$this->returnType = \is_string($returnType) ? new Node\Identifier($returnType) : $returnType;
$this->returnType = $subNodes['returnType'] ?? null;
$this->stmts = $subNodes['stmts'] ?? [];
$this->attrGroups = $subNodes['attrGroups'] ?? [];
}

@@ -7,13 +7,13 @@ use PhpParser\Node\Name;
class ConstFetch extends Expr {
/** @var Name Constant name */
public $name;
public Name $name;
/**
* Constructs a const fetch node.
*
* @param Name $name Constant name
* @param array $attributes Additional attributes
* @param Name $name Constant name
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Name $name, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,13 +6,13 @@ use PhpParser\Node\Expr;
class Empty_ extends Expr {
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs an empty() node.
*
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -14,7 +14,7 @@ class Error extends Expr {
/**
* Constructs an error node.
*
* @param array $attributes Additional attributes
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(array $attributes = []) {
$this->attributes = $attributes;

@@ -6,13 +6,13 @@ use PhpParser\Node\Expr;
class ErrorSuppress extends Expr {
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs an error suppress node.
*
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -6,13 +6,13 @@ use PhpParser\Node\Expr;
class Eval_ extends Expr {
/** @var Expr Expression */
public $expr;
public Expr $expr;
/**
* Constructs an eval() node.
*
* @param Expr $expr Expression
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, array $attributes = []) {
$this->attributes = $attributes;

@@ -10,13 +10,13 @@ class Exit_ extends Expr {
public const KIND_DIE = 2;
/** @var null|Expr Expression */
public $expr;
public ?Expr $expr;
/**
* Constructs an exit() node.
*
* @param null|Expr $expr Expression
* @param array $attributes Additional attributes
* @param null|Expr $expr Expression
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(?Expr $expr = null, array $attributes = []) {
$this->attributes = $attributes;

@@ -7,18 +7,18 @@ use PhpParser\Node\Expr;
class FuncCall extends CallLike {
/** @var Node\Name|Expr Function name */
public $name;
public Node $name;
/** @var array<Node\Arg|Node\VariadicPlaceholder> Arguments */
public $args;
public array $args;
/**
* Constructs a function call node.
*
* @param Node\Name|Expr $name Function name
* @param array<Node\Arg|Node\VariadicPlaceholder> $args Arguments
* @param array $attributes Additional attributes
* @param Node\Name|Expr $name Function name
* @param array<Node\Arg|Node\VariadicPlaceholder> $args Arguments
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct($name, array $args = [], array $attributes = []) {
public function __construct(Node $name, array $args = [], array $attributes = []) {
$this->attributes = $attributes;
$this->name = $name;
$this->args = $args;

@@ -11,16 +11,16 @@ class Include_ extends Expr {
public const TYPE_REQUIRE_ONCE = 4;
/** @var Expr Expression */
public $expr;
public Expr $expr;
/** @var int Type of include */
public $type;
public int $type;
/**
* Constructs an include node.
*
* @param Expr $expr Expression
* @param int $type Type of include
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param int $type Type of include
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, int $type, array $attributes = []) {
$this->attributes = $attributes;

@@ -2,23 +2,24 @@
namespace PhpParser\Node\Expr;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Name;
class Instanceof_ extends Expr {
/** @var Expr Expression */
public $expr;
public Expr $expr;
/** @var Name|Expr Class name */
public $class;
public Node $class;
/**
* Constructs an instanceof check node.
*
* @param Expr $expr Expression
* @param Name|Expr $class Class name
* @param array $attributes Additional attributes
* @param Expr $expr Expression
* @param Name|Expr $class Class name
* @param array<string, mixed> $attributes Additional attributes
*/
public function __construct(Expr $expr, $class, array $attributes = []) {
public function __construct(Expr $expr, Node $class, array $attributes = []) {
$this->attributes = $attributes;
$this->expr = $expr;
$this->class = $class;

Some files were not shown because too many files have changed in this diff Show More