Release PHP-Parser 4.12.0

Implement support for readonly properties (https://wiki.php.net/rfc/readonly_properties_v2) and
final class contstants (https://wiki.php.net/rfc/final_class_const).

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.y]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4

.gitattributes

@@ -1,9 +1,9 @@
-/doc export-ignore
-/test export-ignore
-/test_old export-ignore
-.gitattributes export-ignore
-.gitignore export-ignore
-.travis.yml export-ignore
-CHANGELOG.md export-ignore
+/.github         export-ignore
+/doc             export-ignore
+/test            export-ignore
+/test_old        export-ignore
+.gitattributes   export-ignore
+.gitignore       export-ignore
+CHANGELOG.md     export-ignore
 phpunit.xml.dist export-ignore
-UPGRADE-*.md export-ignore
+UPGRADE-*.md     export-ignore

.github/workflows/main.yml

@@ -0,0 +1,90 @@
+# https://help.github.com/en/categories/automating-your-workflow-with-github-actions
+name: Main
+on:
+  push:
+  pull_request:
+
+jobs:
+  tests_70:
+    runs-on: "ubuntu-latest"
+    name: "PHP 7.0 Unit Tests"
+    steps:
+      - name: "Checkout"
+        uses: "actions/checkout@v2"
+      - name: "Install PHP"
+        uses: "shivammathur/setup-php@v2"
+        with:
+          coverage: "xdebug"
+          php-version: "7.0"
+          tools: composer:v2
+      - name: "Install dependencies"
+        run: |
+          composer require php-coveralls/php-coveralls:^2.2 --dev --no-update
+          composer update --no-progress --prefer-dist
+      - name: "Tests"
+        run: "php vendor/bin/phpunit --coverage-clover build/logs/clover.xml"
+      - name: Coveralls
+        env:
+          COVERALLS_REPO_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: "php vendor/bin/php-coveralls"
+        if: ${{ success() }}
+  tests:
+    runs-on: "ubuntu-latest"
+    name: "PHP ${{ matrix.php-version }} Unit Tests"
+    strategy:
+      matrix:
+        php-version:
+          - "7.1"
+          - "7.2"
+          - "7.3"
+          - "7.4"
+          - "8.0"
+          - "8.1"
+        include:
+          - php-version: "8.1"
+            flags: "--ignore-platform-req=php"
+    steps:
+      - name: "Checkout"
+        uses: "actions/checkout@v2"
+      - name: "Install PHP"
+        uses: "shivammathur/setup-php@v2"
+        with:
+          coverage: "none"
+          php-version: "${{ matrix.php-version }}"
+          tools: composer:v2
+      - name: "Install dependencies"
+        run: "composer update --no-progress --prefer-dist ${{ matrix.flags }}"
+      - name: "PHPUnit"
+        run: "php vendor/bin/phpunit"
+  test_old_73_80:
+    runs-on: "ubuntu-latest"
+    name: "PHP 7.3 Code on PHP 8.0 Integration Tests"
+    steps:
+      - name: "Checkout"
+        uses: "actions/checkout@v2"
+      - name: "Install PHP"
+        uses: "shivammathur/setup-php@v2"
+        with:
+          coverage: "none"
+          php-version: "8.0"
+          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"
+  test_old_80_70:
+    runs-on: "ubuntu-latest"
+    name: "PHP 8.0 Code on PHP 7.0 Integration Tests"
+    steps:
+      - name: "Checkout"
+        uses: "actions/checkout@v2"
+      - name: "Install PHP"
+        uses: "shivammathur/setup-php@v2"
+        with:
+          coverage: "none"
+          php-version: "7.0"
+          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.0.0"

.travis.yml

@@ -1,35 +0,0 @@
-language: php
-dist: xenial
-
-cache:
-  directories:
-    - $HOME/.composer/cache
-
-php:
-  - 7.0
-  - 7.1
-  - 7.2
-  - 7.3
-  - 7.4
-  - nightly
-
-install:
-  - if [ $TRAVIS_PHP_VERSION = '7.0' ]; then composer require satooshi/php-coveralls '~1.0'; fi
-  - |
-    if [ $TRAVIS_PHP_VERSION = 'nightly' ]; then
-      composer install --prefer-dist --ignore-platform-reqs;
-    else
-      composer install --prefer-dist;
-    fi
-
-matrix:
-  allow_failures:
-    - php: nightly
-  fast_finish: true
-
-script:
-  - if [ $TRAVIS_PHP_VERSION = '7.0' ]; then vendor/bin/phpunit --coverage-clover build/logs/clover.xml; else vendor/bin/phpunit; fi
-  - if [ $TRAVIS_PHP_VERSION = '7.2' ]; then test_old/run-php-src.sh; fi
-
-after_success:
-  - if [ $TRAVIS_PHP_VERSION = '7.0' ]; then php vendor/bin/coveralls; fi

CHANGELOG.md

@@ -1,5 +1,155 @@
-Version 4.7.1-dev
------------------
+Version 4.12.1-dev
+------------------
+
+Nothing yet.
+
+Version 4.12.0 (2021-07-21)
+---------------------------
+
+### Added
+
+* [PHP 8.1] Added support for readonly properties (through a new `MODIFIER_READONLY`).
+* [PHP 8.1] Added support for final class constants.
+
+### Fixed
+
+* Fixed compatibility with PHP 8.1. `&` tokens are now canonicalized to the
+  `T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG` and `T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG` tokens
+  used in PHP 8.1. This happens unconditionally, regardless of whether the emulative lexer is used.
+
+Version 4.11.0 (2021-07-03)
+---------------------------
+
+### Added
+
+* `BuilderFactory::args()` now accepts named arguments.
+* `BuilderFactory::attribute()` has been added.
+* An `addAttribute()` method accepting an `Attribute` or `AttributeGroup` has been adde to all
+  builders that accept attributes, such as `Builder\Class_`.
+
+### Fixed
+
+* `NameResolver` now handles enums.
+* `PrettyPrinter` now prints backing enum type.
+* Builder methods for types now property handle `never` type.
+
+Version 4.10.5 (2021-05-03)
+---------------------------
+
+### Added
+
+* [PHP 8.1] Added support for enums. These are represented using the `Stmt\Enum_` and
+  `Stmt\EnumCase` nodes.
+* [PHP 8.1] Added support for never type. This type will now be returned as an `Identifier` rather
+  than `Name`.
+* Added `ClassConst` builder.
+
+### Changed
+
+* Non-UTF-8 code units in strings will now be hex-encoded.
+
+### Fixed
+
+* Fixed precedence of arrow functions.
+
+Version 4.10.4 (2020-12-20)
+---------------------------
+
+### Fixed
+
+* Fixed position information for variable-variables (#741).
+* Fixed position information for traits/interfaces preceded by if statement (#738).
+
+Version 4.10.3 (2020-12-03)
+---------------------------
+
+### Fixed
+
+* Fixed formatting-preserving pretty printing for `"{$x}"`.
+* Ternary expressions are now treated as non-associative in the pretty printer, in order to
+  generate code that is compatible with the parentheses requirement introduced in PHP 8.
+* Removed no longer necessary `error_clear_last()` call in lexer, which may interfere with fatal
+  error handlers if invoked during shutdown.
+
+
+Version 4.10.2 (2020-09-26)
+------------------
+
+### Fixed
+
+* Fixed check for token emulation conflicts with other libraries.
+
+Version 4.10.1 (2020-09-23)
+---------------------------
+
+### Added
+
+* Added support for recovering from a missing semicolon after a property or class constant
+  declaration.
+
+### Fixed
+
+* Fix spurious whitespace in formatting-preserving pretty printer when both removing and adding
+  elements at the start of a list.
+* Fix incorrect case-sensitivity in keyword token emulation.
+
+Version 4.10.0 (2020-09-19)
+---------------------------
+
+### Added
+
+* [PHP 8.0] Added support for attributes. These are represented using a new `AttributeGroup` node
+  containing `Attribute` nodes. A new `attrGroups` subnode is available on all node types that
+  support attributes, i.e. `Stmt\Class_`, `Stmt\Trait_`, `Stmt\Interface_`, `Stmt\Function_`,
+  `Stmt\ClassMethod`, `Stmt\ClassConst`, `Stmt\Property`, `Expr\Closure`, `Expr\ArrowFunction` and
+  `Param`.
+* [PHP 8.0] Added support for nullsafe properties inside interpolated strings, in line with an
+  upstream change.
+
+### Fixed
+
+* Improved compatibility with other libraries that use forward compatibility defines for PHP tokens.
+
+Version 4.9.1 (2020-08-30)
+--------------------------
+
+### Added
+
+* Added support for removing the first element of a list to the formatting-preserving pretty
+  printer.
+
+### Fixed
+
+* Allow member modifiers as part of namespaced names. These were missed when support for other
+  keywords was added.
+
+Version 4.9.0 (2020-08-18)
+--------------------------
+
+### Added
+
+* [PHP 8.0] Added support for named arguments, represented using a new `name` subnode on `Arg`.
+* [PHP 8.0] Added support for static return type, represented like a normal class return type.
+* [PHP 8.0] Added support for throw expression, represented using a new `Expr\Throw_` node. For
+  backwards compatibility reasons, throw expressions in statement context continue to be
+  represented using `Stmt\Throw_`.
+* [PHP 8.0] Added support for keywords as parts of namespaced names.
+
+### Fixed
+
+* Emit parentheses for class constant fetch with complex left-hand-side.
+* Emit parentheses for new/instanceof on complex class expression.
+
+Version 4.8.0 (2020-08-09)
+--------------------------
+
+### Added
+
+* [PHP 8.0] Added support for nullsafe operator, represented using the new
+  `Expr\NullsafePropertyFetch` and `Expr\NullsafeMethodCall` nodes.
+* Added `phpVersion` option to the emulative lexer, which allows controlling the target version to
+  emulate (defaults to the latest available, currently PHP 8.0). This is useful to parse code that
+  uses reserved keywords from newer PHP versions as identifiers.
 
 Version 4.7.0 (2020-07-25)
 --------------------------

README.md

@@ -1,12 +1,12 @@
 PHP Parser
 ==========
 
-[![Build Status](https://travis-ci.org/nikic/PHP-Parser.svg?branch=master)](https://travis-ci.org/nikic/PHP-Parser) [![Coverage Status](https://coveralls.io/repos/github/nikic/PHP-Parser/badge.svg?branch=master)](https://coveralls.io/github/nikic/PHP-Parser?branch=master)
+[![Coverage Status](https://coveralls.io/repos/github/nikic/PHP-Parser/badge.svg?branch=master)](https://coveralls.io/github/nikic/PHP-Parser?branch=master)
 
-This is a PHP 5.2 to PHP 7.4 parser written in PHP. Its purpose is to simplify static code analysis and
+This is a PHP 5.2 to PHP 8.0 parser written in PHP. Its purpose is to simplify static code analysis and
 manipulation.
 
-[**Documentation for version 4.x**][doc_master] (stable; for running on PHP >= 7.0; for parsing PHP 5.2 to PHP 7.4).
+[**Documentation for version 4.x**][doc_master] (stable; for running on PHP >= 7.0; for parsing PHP 5.2 to PHP 8.0).
 
 [Documentation for version 3.x][doc_3_x] (unsupported; for running on PHP >= 5.5; for parsing PHP 5.2 to PHP 7.2).
 
@@ -15,7 +15,7 @@ Features
 
 The main features provided by this library are:
 
- * Parsing PHP 5 and PHP 7 code into an abstract syntax tree (AST).
+ * Parsing PHP 5, PHP 7, and PHP 8 code into an abstract syntax tree (AST).
    * Invalid code can be parsed into a partial AST.
    * The AST contains accurate location information.
  * Dumping the AST in human-readable form.
@@ -215,7 +215,7 @@ Component documentation:
  * [JSON representation](doc/component/JSON_representation.markdown)
    * JSON encoding and decoding of ASTs
  * [Performance](doc/component/Performance.markdown)
-   * Disabling XDebug
+   * Disabling Xdebug
    * Reusing objects
    * Garbage collection impact
  * [Frequently asked questions](doc/component/FAQ.markdown)

bin/php-parse

@@ -10,7 +10,7 @@ foreach ([__DIR__ . '/../../../autoload.php', __DIR__ . '/../vendor/autoload.php
 
 ini_set('xdebug.max_nesting_level', 3000);
 
-// Disable XDebug var_dump() output truncation
+// Disable Xdebug var_dump() output truncation
 ini_set('xdebug.var_display_max_children', -1);
 ini_set('xdebug.var_display_max_data', -1);
 ini_set('xdebug.var_display_max_depth', -1);

composer.json

@@ -17,12 +17,12 @@
         "ext-tokenizer": "*"
     },
     "require-dev": {
-        "phpunit/phpunit": "^6.5 || ^7.0 || ^8.0",
-        "ircmaxell/php-yacc": "0.0.5"
+        "phpunit/phpunit": "^6.5 || ^7.0 || ^8.0 || ^9.0",
+        "ircmaxell/php-yacc": "^0.0.7"
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "4.7-dev"
+            "dev-master": "4.9-dev"
         }
     },
     "autoload": {

doc/0_Introduction.markdown

@@ -1,7 +1,7 @@
 Introduction
 ============
 
-This project is a PHP 5.2 to PHP 7.4 parser **written in PHP itself**.
+This project is a PHP 5.2 to PHP 8.0 parser **written in PHP itself**.
 
 What is this for?
 -----------------
@@ -26,7 +26,11 @@ programmatic PHP code analysis are incidentally PHP developers, not C developers
 What can it parse?
 ------------------
 
-The parser supports parsing PHP 5.2-7.4.
+The parser supports parsing PHP 5.2-8.0, with the following exceptions:
+
+ * Namespaced names containing whitespace (e.g. `Foo \ Bar` instead of `Foo\Bar`) are not supported.
+   These are illegal in PHP 8, but are legal in earlier version. However, PHP-Parser does not
+   support them for any version.
 
 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.

doc/2_Usage_of_basic_components.markdown

@@ -19,7 +19,7 @@ ini_set('xdebug.max_nesting_level', 3000);
 ```
 
 This ensures that there will be no errors when traversing highly nested node trees. However, it is
-preferable to disable XDebug completely, as it can easily make this library more than five times
+preferable to disable Xdebug completely, as it can easily make this library more than five times
 slower.
 
 Parsing

doc/README.md

@@ -39,7 +39,7 @@ Component documentation
   * [JSON representation](component/JSON_representation.markdown)
     * JSON encoding and decoding of ASTs
   * [Performance](component/Performance.markdown)
-    * Disabling XDebug
+    * Disabling Xdebug
     * Reusing objects
     * Garbage collection impact
   * [Frequently asked questions](component/FAQ.markdown)

doc/component/Error_handling.markdown

@@ -36,7 +36,7 @@ if ($e->hasColumnInfo()) {
     echo $e->getRawMessage() . ' from ' . $e->getStartLine() . ':' . $e->getStartColumn($code)
         . ' to ' . $e->getEndLine() . ':' . $e->getEndColumn($code);
     // or:
-    echo $e->getMessageWithColumnInfo();
+    echo $e->getMessageWithColumnInfo($code);
 } else {
     echo $e->getMessage();
 }
@@ -72,4 +72,4 @@ if (null !== $stmts) {
 }
 ```
 
-The `NameResolver` visitor also accepts an `ErrorHandler` as a constructor argument.
+The `NameResolver` visitor also accepts an `ErrorHandler` as a constructor argument.

doc/component/Performance.markdown

@@ -8,20 +8,20 @@ described in the following.
 Xdebug
 ------
 
-Running PHP with XDebug adds a lot of overhead, especially for code that performs many method calls.
-Just by loading XDebug (without enabling profiling or other more intrusive XDebug features), you
+Running PHP with Xdebug adds a lot of overhead, especially for code that performs many method calls.
+Just by loading Xdebug (without enabling profiling or other more intrusive Xdebug features), you
 can expect that code using PHP-Parser will be approximately *five times slower*.
 
-As such, you should make sure that XDebug is not loaded when using this library. Note that setting
-the `xdebug.default_enable=0` ini option does *not* disable XDebug. The *only* way to disable
-XDebug is to not load the extension in the first place.
+As such, you should make sure that Xdebug is not loaded when using this library. Note that setting
+the `xdebug.default_enable=0` ini option does *not* disable Xdebug. The *only* way to disable
+Xdebug is to not load the extension in the first place.
 
-If you are building a command-line utility for use by developers (who often have XDebug enabled),
-you may want to consider automatically restarting PHP with XDebug unloaded. The
+If you are building a command-line utility for use by developers (who often have Xdebug enabled),
+you may want to consider automatically restarting PHP with Xdebug unloaded. The
 [composer/xdebug-handler](https://github.com/composer/xdebug-handler) package can be used to do
 this.
 
-If you do run with XDebug, you may need to increase the `xdebug.max_nesting_level` option to a
+If you do run with Xdebug, you may need to increase the `xdebug.max_nesting_level` option to a
 higher level, such as 3000. While the parser itself is recursion free, most other code working on
 the AST uses recursion and will generate an error if the value of this option is too low.
 
@@ -62,4 +62,4 @@ 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.
+approached with care.

grammar/php5.y

@@ -20,6 +20,11 @@ top_statement_list:
             if ($nop !== null) { $1[] = $nop; } $$ = $1; }
 ;
 
+ampersand:
+      T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
+    | T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG
+;
+
 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
@@ -246,7 +251,12 @@ variables_list:
 
 optional_ref:
       /* empty */                                           { $$ = false; }
-    | '&'                                                   { $$ = true; }
+    | ampersand                                             { $$ = true; }
+;
+
+optional_arg_ref:
+      /* empty */                                           { $$ = false; }
+    | T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG                 { $$ = true; }
 ;
 
 optional_ellipsis:
@@ -378,7 +388,7 @@ new_else_single:
 
 foreach_variable:
       variable                                              { $$ = array($1, false); }
-    | '&' variable                                          { $$ = array($2, true); }
+    | ampersand variable                                    { $$ = array($2, true); }
     | list_expr                                             { $$ = array($1, false); }
 ;
 
@@ -393,9 +403,9 @@ non_empty_parameter_list:
 ;
 
 parameter:
-      optional_param_type optional_ref optional_ellipsis plain_variable
+      optional_param_type optional_arg_ref optional_ellipsis plain_variable
           { $$ = Node\Param[$4, null, $1, $2, $3]; $this->checkParam($$); }
-    | optional_param_type optional_ref optional_ellipsis plain_variable '=' static_scalar
+    | optional_param_type optional_arg_ref optional_ellipsis plain_variable '=' static_scalar
           { $$ = Node\Param[$4, $6, $1, $2, $3]; $this->checkParam($$); }
 ;
 
@@ -428,7 +438,7 @@ non_empty_argument_list:
 
 argument:
       expr                                                  { $$ = Node\Arg[$1, false, false]; }
-    | '&' variable                                          { $$ = Node\Arg[$2, true, false]; }
+    | ampersand variable                                    { $$ = Node\Arg[$2, true, false]; }
     | T_ELLIPSIS expr                                       { $$ = Node\Arg[$2, false, true]; }
 ;
 
@@ -562,8 +572,8 @@ expr:
       variable                                              { $$ = $1; }
     | list_expr '=' expr                                    { $$ = Expr\Assign[$1, $3]; }
     | variable '=' expr                                     { $$ = Expr\Assign[$1, $3]; }
-    | variable '=' '&' variable                             { $$ = Expr\AssignRef[$1, $4]; }
-    | variable '=' '&' new_expr                             { $$ = Expr\AssignRef[$1, $4]; }
+    | variable '=' ampersand variable                       { $$ = Expr\AssignRef[$1, $4]; }
+    | variable '=' ampersand new_expr                       { $$ = Expr\AssignRef[$1, $4]; }
     | new_expr                                              { $$ = $1; }
     | T_CLONE expr                                          { $$ = Expr\Clone_[$2]; }
     | variable T_PLUS_EQUAL expr                            { $$ = Expr\AssignOp\Plus      [$1, $3]; }
@@ -589,7 +599,8 @@ expr:
     | expr T_LOGICAL_AND expr                               { $$ = Expr\BinaryOp\LogicalAnd[$1, $3]; }
     | expr T_LOGICAL_XOR expr                               { $$ = Expr\BinaryOp\LogicalXor[$1, $3]; }
     | expr '|' expr                                         { $$ = Expr\BinaryOp\BitwiseOr [$1, $3]; }
-    | expr '&' expr                                         { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
+    | expr T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG expr   { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
+    | expr T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG expr       { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
     | expr '^' expr                                         { $$ = Expr\BinaryOp\BitwiseXor[$1, $3]; }
     | expr '.' expr                                         { $$ = Expr\BinaryOp\Concat    [$1, $3]; }
     | expr '+' expr                                         { $$ = Expr\BinaryOp\Plus      [$1, $3]; }
@@ -816,7 +827,10 @@ static_operation:
     | static_scalar T_LOGICAL_AND static_scalar             { $$ = Expr\BinaryOp\LogicalAnd[$1, $3]; }
     | static_scalar T_LOGICAL_XOR static_scalar             { $$ = Expr\BinaryOp\LogicalXor[$1, $3]; }
     | static_scalar '|' static_scalar                       { $$ = Expr\BinaryOp\BitwiseOr [$1, $3]; }
-    | static_scalar '&' static_scalar                       { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
+    | static_scalar T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG static_scalar
+          { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
+    | static_scalar T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG static_scalar
+          { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
     | static_scalar '^' static_scalar                       { $$ = Expr\BinaryOp\BitwiseXor[$1, $3]; }
     | static_scalar '.' static_scalar                       { $$ = Expr\BinaryOp\Concat    [$1, $3]; }
     | static_scalar '+' static_scalar                       { $$ = Expr\BinaryOp\Plus      [$1, $3]; }
@@ -986,8 +1000,8 @@ non_empty_array_pair_list:
 array_pair:
       expr T_DOUBLE_ARROW expr                              { $$ = Expr\ArrayItem[$3, $1,   false]; }
     | expr                                                  { $$ = Expr\ArrayItem[$1, null, false]; }
-    | expr T_DOUBLE_ARROW '&' variable                      { $$ = Expr\ArrayItem[$4, $1,   true]; }
-    | '&' variable                                          { $$ = Expr\ArrayItem[$2, null, true]; }
+    | expr T_DOUBLE_ARROW ampersand variable                { $$ = Expr\ArrayItem[$4, $1,   true]; }
+    | ampersand variable                                    { $$ = Expr\ArrayItem[$2, null, true]; }
     | T_ELLIPSIS expr                                       { $$ = Expr\ArrayItem[$2, null, false, attributes(), true]; }
 ;
 

grammar/php7.y

@@ -20,6 +20,11 @@ top_statement_list:
             if ($nop !== null) { $1[] = $nop; } $$ = $1; }
 ;
 
+ampersand:
+      T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
+    | T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG
+;
+
 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
@@ -28,12 +33,12 @@ reserved_non_modifiers:
     | T_FUNCTION | T_CONST | T_RETURN | T_PRINT | T_YIELD | T_LIST | T_SWITCH | T_ENDSWITCH | T_CASE | T_DEFAULT
     | T_BREAK | T_ARRAY | T_CALLABLE | T_EXTENDS | T_IMPLEMENTS | T_NAMESPACE | T_TRAIT | T_INTERFACE | T_CLASS
     | T_CLASS_C | T_TRAIT_C | T_FUNC_C | T_METHOD_C | T_LINE | T_FILE | T_DIR | T_NS_C | T_HALT_COMPILER | T_FN
-    | T_MATCH
+    | T_MATCH | T_ENUM
 ;
 
 semi_reserved:
       reserved_non_modifiers
-    | T_STATIC | T_ABSTRACT | T_FINAL | T_PRIVATE | T_PROTECTED | T_PUBLIC
+    | T_STATIC | T_ABSTRACT | T_FINAL | T_PRIVATE | T_PROTECTED | T_PUBLIC | T_READONLY
 ;
 
 identifier_ex:
@@ -49,6 +54,12 @@ reserved_non_modifiers_identifier:
       reserved_non_modifiers                                { $$ = Node\Identifier[$1]; }
 ;
 
+namespace_declaration_name:
+      T_STRING                                              { $$ = Name[$1]; }
+    | semi_reserved                                         { $$ = Name[$1]; }
+    | T_NAME_QUALIFIED                                      { $$ = Name[$1]; }
+;
+
 namespace_name:
       T_STRING                                              { $$ = Name[$1]; }
     | T_NAME_QUALIFIED                                      { $$ = Name[$1]; }
@@ -76,6 +87,31 @@ no_comma:
 optional_comma:
       /* empty */
     | ','
+;
+
+attribute_decl:
+      class_name                                            { $$ = Node\Attribute[$1, []]; }
+    | class_name argument_list                              { $$ = Node\Attribute[$1, $2]; }
+;
+
+attribute_group:
+      attribute_decl                                        { init($1); }
+    | attribute_group ',' attribute_decl                    { push($1, $3); }
+;
+
+attribute:
+      T_ATTRIBUTE attribute_group optional_comma ']'        { $$ = Node\AttributeGroup[$2]; }
+;
+
+attributes:
+      attribute                                             { init($1); }
+    | attributes attribute                                  { push($1, $2); }
+;
+
+optional_attributes:
+      /* empty */                                           { $$ = []; }
+    | attributes                                            { $$ = $1; }
+;
 
 top_statement:
       statement                                             { $$ = $1; }
@@ -83,11 +119,11 @@ top_statement:
     | class_declaration_statement                           { $$ = $1; }
     | T_HALT_COMPILER
           { $$ = Stmt\HaltCompiler[$this->lexer->handleHaltCompiler()]; }
-    | T_NAMESPACE namespace_name semi
+    | T_NAMESPACE namespace_declaration_name semi
           { $$ = Stmt\Namespace_[$2, null];
             $$->setAttribute('kind', Stmt\Namespace_::KIND_SEMICOLON);
             $this->checkNamespace($$); }
-    | T_NAMESPACE namespace_name '{' top_statement_list '}'
+    | T_NAMESPACE namespace_declaration_name '{' top_statement_list '}'
           { $$ = Stmt\Namespace_[$2, $4];
             $$->setAttribute('kind', Stmt\Namespace_::KIND_BRACED);
             $this->checkNamespace($$); }
@@ -233,7 +269,16 @@ non_empty_statement:
     | 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                                             { $$ = Stmt\Expression[$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_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]]; }
@@ -244,7 +289,6 @@ non_empty_statement:
     | T_DECLARE '(' declare_list ')' declare_statement      { $$ = Stmt\Declare_[$3, $5]; }
     | T_TRY '{' inner_statement_list '}' catches optional_finally
           { $$ = Stmt\TryCatch[$3, $5, $6]; $this->checkTryCatch($$); }
-    | T_THROW expr semi                                     { $$ = Stmt\Throw_[$2]; }
     | T_GOTO identifier semi                                { $$ = Stmt\Goto_[$2]; }
     | identifier ':'                                        { $$ = Stmt\Label[$1]; }
     | error                                                 { $$ = array(); /* means: no statement */ }
@@ -288,7 +332,12 @@ non_empty_variables_list:
 
 optional_ref:
       /* empty */                                           { $$ = false; }
-    | '&'                                                   { $$ = true; }
+    | ampersand                                             { $$ = true; }
+;
+
+optional_arg_ref:
+      /* empty */                                           { $$ = false; }
+    | T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG                 { $$ = true; }
 ;
 
 optional_ellipsis:
@@ -302,19 +351,33 @@ block_or_error:
 ;
 
 function_declaration_statement:
-    T_FUNCTION optional_ref identifier '(' parameter_list ')' optional_return_type block_or_error
-        { $$ = Stmt\Function_[$3, ['byRef' => $2, 'params' => $5, 'returnType' => $7, 'stmts' => $8]]; }
+      T_FUNCTION optional_ref identifier '(' 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 '(' parameter_list ')' optional_return_type block_or_error
+          { $$ = Stmt\Function_[$4, ['byRef' => $3, 'params' => $6, 'returnType' => $8, 'stmts' => $9, 'attrGroups' => $1]]; }
 ;
 
 class_declaration_statement:
-      class_entry_type identifier extends_from implements_list '{' class_statement_list '}'
-          { $$ = Stmt\Class_[$2, ['type' => $1, 'extends' => $3, 'implements' => $4, 'stmts' => $6]];
-            $this->checkClass($$, #2); }
-    | T_INTERFACE identifier interface_extends_list '{' class_statement_list '}'
-          { $$ = Stmt\Interface_[$2, ['extends' => $3, 'stmts' => $5]];
-            $this->checkInterface($$, #2); }
-    | T_TRAIT identifier '{' class_statement_list '}'
-          { $$ = Stmt\Trait_[$2, ['stmts' => $4]]; }
+      optional_attributes class_entry_type identifier 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 interface_extends_list '{' class_statement_list '}'
+          { $$ = Stmt\Interface_[$3, ['extends' => $4, 'stmts' => $6, 'attrGroups' => $1]];
+            $this->checkInterface($$, #3); }
+    | optional_attributes T_TRAIT identifier '{' class_statement_list '}'
+          { $$ = Stmt\Trait_[$3, ['stmts' => $5, 'attrGroups' => $1]]; }
+    | optional_attributes T_ENUM identifier enum_scalar_type implements_list '{' class_statement_list '}'
+          { $$ = Stmt\Enum_[$3, ['scalarType' => $4, 'implements' => $5, 'stmts' => $7, 'attrGroups' => $1]];
+            $this->checkEnum($$, #3); }
+;
+
+enum_scalar_type:
+      /* empty */                                           { $$ = null; }
+    | ':' type                                              { $$ = $2; }
+
+enum_case_expr:
+      /* empty */                                           { $$ = null; }
+    | '=' expr                                              { $$ = $2; }
 ;
 
 class_entry_type:
@@ -452,7 +515,7 @@ new_else_single:
 
 foreach_variable:
       variable                                              { $$ = array($1, false); }
-    | '&' variable                                          { $$ = array($2, true); }
+    | ampersand variable                                    { $$ = array($2, true); }
     | list_expr                                             { $$ = array($1, false); }
     | array_short_syntax                                    { $$ = array($1, false); }
 ;
@@ -472,17 +535,21 @@ optional_visibility_modifier:
     | T_PUBLIC                  { $$ = Stmt\Class_::MODIFIER_PUBLIC; }
     | T_PROTECTED               { $$ = Stmt\Class_::MODIFIER_PROTECTED; }
     | T_PRIVATE                 { $$ = Stmt\Class_::MODIFIER_PRIVATE; }
+    | T_READONLY                { $$ = Stmt\Class_::MODIFIER_READONLY; }
 ;
 
 parameter:
-      optional_visibility_modifier optional_type optional_ref optional_ellipsis plain_variable
-          { $$ = new Node\Param($5, null, $2, $3, $4, attributes(), $1);
+      optional_attributes optional_visibility_modifier optional_type_without_static
+      optional_arg_ref optional_ellipsis plain_variable
+          { $$ = new Node\Param($6, null, $3, $4, $5, attributes(), $2, $1);
             $this->checkParam($$); }
-    | optional_visibility_modifier optional_type optional_ref optional_ellipsis plain_variable '=' expr
-          { $$ = new Node\Param($5, $7, $2, $3, $4, attributes(), $1);
+    | optional_attributes optional_visibility_modifier optional_type_without_static
+      optional_arg_ref optional_ellipsis plain_variable '=' expr
+          { $$ = new Node\Param($6, $8, $3, $4, $5, attributes(), $2, $1);
             $this->checkParam($$); }
-    | optional_visibility_modifier optional_type optional_ref optional_ellipsis error
-          { $$ = new Node\Param(Expr\Error[], null, $2, $3, $4, attributes(), $1); }
+    | optional_attributes optional_visibility_modifier optional_type_without_static
+      optional_arg_ref optional_ellipsis error
+          { $$ = new Node\Param(Expr\Error[], null, $3, $4, $5, attributes(), $2, $1); }
 ;
 
 type_expr:
@@ -492,6 +559,11 @@ type_expr:
 ;
 
 type:
+      type_without_static                                   { $$ = $1; }
+    | T_STATIC                                              { $$ = Node\Name['static']; }
+;
+
+type_without_static:
       name                                                  { $$ = $this->handleBuiltinTypes($1); }
     | T_ARRAY                                               { $$ = Node\Identifier['array']; }
     | T_CALLABLE                                            { $$ = Node\Identifier['callable']; }
@@ -502,9 +574,20 @@ union_type:
     | union_type '|' type                                   { push($1, $3); }
 ;
 
-optional_type:
+union_type_without_static:
+      type_without_static '|' type_without_static           { init($1, $3); }
+    | union_type_without_static '|' type_without_static     { push($1, $3); }
+;
+
+type_expr_without_static:
+      type_without_static                                   { $$ = $1; }
+    | '?' type_without_static                               { $$ = Node\NullableType[$2]; }
+    | union_type_without_static                             { $$ = Node\UnionType[$1]; }
+;
+
+optional_type_without_static:
       /* empty */                                           { $$ = null; }
-    | type_expr                                             { $$ = $1; }
+    | type_expr_without_static                              { $$ = $1; }
 ;
 
 optional_return_type:
@@ -525,8 +608,10 @@ non_empty_argument_list:
 
 argument:
       expr                                                  { $$ = Node\Arg[$1, false, false]; }
-    | '&' variable                                          { $$ = Node\Arg[$2, true, false]; }
+    | ampersand variable                                    { $$ = Node\Arg[$2, true, false]; }
     | T_ELLIPSIS expr                                       { $$ = Node\Arg[$2, false, true]; }
+    | identifier_ex ':' expr
+          { $$ = new Node\Arg($3, false, false, attributes(), $1); }
 ;
 
 global_var_list:
@@ -539,7 +624,7 @@ non_empty_global_var_list:
 ;
 
 global_var:
-      simple_variable                                       { $$ = Expr\Variable[$1]; }
+      simple_variable                                       { $$ = $1; }
 ;
 
 static_var_list:
@@ -568,15 +653,18 @@ class_statement_list:
 ;
 
 class_statement:
-      variable_modifiers optional_type property_declaration_list ';'
-          { $attrs = attributes();
-            $$ = new Stmt\Property($1, $3, $attrs, $2); $this->checkProperty($$, #1); }
-    | method_modifiers T_CONST class_const_list ';'
-          { $$ = Stmt\ClassConst[$3, $1]; $this->checkClassConst($$, #1); }
-    | method_modifiers T_FUNCTION optional_ref identifier_ex '(' parameter_list ')' optional_return_type method_body
-          { $$ = Stmt\ClassMethod[$4, ['type' => $1, 'byRef' => $3, 'params' => $6, 'returnType' => $8, 'stmts' => $9]];
-            $this->checkClassMethod($$, #1); }
+      optional_attributes variable_modifiers optional_type_without_static property_declaration_list semi
+          { $$ = new Stmt\Property($2, $4, attributes(), $3, $1);
+            $this->checkProperty($$, #2); }
+    | 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_FUNCTION optional_ref identifier_ex '(' parameter_list ')' optional_return_type method_body
+          { $$ = Stmt\ClassMethod[$5, ['type' => $2, 'byRef' => $4, 'params' => $7, 'returnType' => $9, 'stmts' => $10, 'attrGroups' => $1]];
+            $this->checkClassMethod($$, #2); }
     | T_USE class_name_list trait_adaptations               { $$ = Stmt\TraitUse[$2, $3]; }
+    | optional_attributes T_CASE identifier enum_case_expr semi
+         { $$ = Stmt\EnumCase[$3, $4, $1]; }
     | error                                                 { $$ = null; /* will be skipped */ }
 ;
 
@@ -638,6 +726,7 @@ member_modifier:
     | T_STATIC                                              { $$ = Stmt\Class_::MODIFIER_STATIC; }
     | T_ABSTRACT                                            { $$ = Stmt\Class_::MODIFIER_ABSTRACT; }
     | T_FINAL                                               { $$ = Stmt\Class_::MODIFIER_FINAL; }
+    | T_READONLY                                            { $$ = Stmt\Class_::MODIFIER_READONLY; }
 ;
 
 property_declaration_list:
@@ -682,7 +771,7 @@ expr:
     | list_expr '=' expr                                    { $$ = Expr\Assign[$1, $3]; }
     | array_short_syntax '=' expr                           { $$ = Expr\Assign[$1, $3]; }
     | variable '=' expr                                     { $$ = Expr\Assign[$1, $3]; }
-    | variable '=' '&' variable                             { $$ = Expr\AssignRef[$1, $4]; }
+    | variable '=' ampersand variable                       { $$ = Expr\AssignRef[$1, $4]; }
     | new_expr                                              { $$ = $1; }
     | match                                                 { $$ = $1; }
     | T_CLONE expr                                          { $$ = Expr\Clone_[$2]; }
@@ -709,7 +798,8 @@ expr:
     | expr T_LOGICAL_AND expr                               { $$ = Expr\BinaryOp\LogicalAnd[$1, $3]; }
     | expr T_LOGICAL_XOR expr                               { $$ = Expr\BinaryOp\LogicalXor[$1, $3]; }
     | expr '|' expr                                         { $$ = Expr\BinaryOp\BitwiseOr [$1, $3]; }
-    | expr '&' expr                                         { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
+    | expr T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG expr   { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
+    | expr T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG expr       { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
     | expr '^' expr                                         { $$ = Expr\BinaryOp\BitwiseXor[$1, $3]; }
     | expr '.' expr                                         { $$ = Expr\BinaryOp\Concat    [$1, $3]; }
     | expr '+' expr                                         { $$ = Expr\BinaryOp\Plus      [$1, $3]; }
@@ -767,23 +857,30 @@ expr:
     | T_YIELD expr                                          { $$ = Expr\Yield_[$2, null]; }
     | T_YIELD expr T_DOUBLE_ARROW expr                      { $$ = Expr\Yield_[$4, $2]; }
     | T_YIELD_FROM expr                                     { $$ = Expr\YieldFrom[$2]; }
+    | T_THROW expr                                          { $$ = Expr\Throw_[$2]; }
 
-    | T_FN optional_ref '(' parameter_list ')' optional_return_type T_DOUBLE_ARROW expr
-          { $$ = Expr\ArrowFunction[['static' => false, 'byRef' => $2, 'params' => $4, 'returnType' => $6, 'expr' => $8]]; }
-    | T_STATIC T_FN optional_ref '(' parameter_list ')' optional_return_type T_DOUBLE_ARROW expr
-          { $$ = Expr\ArrowFunction[['static' => true, 'byRef' => $3, 'params' => $5, 'returnType' => $7, 'expr' => $9]]; }
+    | T_FN optional_ref '(' parameter_list ')' optional_return_type T_DOUBLE_ARROW expr %prec T_THROW
+          { $$ = Expr\ArrowFunction[['static' => false, 'byRef' => $2, 'params' => $4, 'returnType' => $6, 'expr' => $8, 'attrGroups' => []]]; }
+    | T_STATIC T_FN optional_ref '(' parameter_list ')' optional_return_type T_DOUBLE_ARROW expr %prec T_THROW
+          { $$ = Expr\ArrowFunction[['static' => true, 'byRef' => $3, 'params' => $5, 'returnType' => $7, 'expr' => $9, 'attrGroups' => []]]; }
+    | T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type block_or_error
+          { $$ = Expr\Closure[['static' => false, 'byRef' => $2, 'params' => $4, 'uses' => $6, 'returnType' => $7, 'stmts' => $8, 'attrGroups' => []]]; }
+    | T_STATIC T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type       block_or_error
+          { $$ = Expr\Closure[['static' => true, 'byRef' => $3, 'params' => $5, 'uses' => $7, 'returnType' => $8, 'stmts' => $9, 'attrGroups' => []]]; }
 
-    | T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type
-      block_or_error
-          { $$ = Expr\Closure[['static' => false, 'byRef' => $2, 'params' => $4, 'uses' => $6, 'returnType' => $7, 'stmts' => $8]]; }
-    | T_STATIC T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type
-      block_or_error
-          { $$ = Expr\Closure[['static' => true, 'byRef' => $3, 'params' => $5, 'uses' => $7, 'returnType' => $8, 'stmts' => $9]]; }
+    | attributes T_FN optional_ref '(' parameter_list ')' optional_return_type T_DOUBLE_ARROW expr %prec T_THROW
+          { $$ = Expr\ArrowFunction[['static' => false, 'byRef' => $3, 'params' => $5, 'returnType' => $7, 'expr' => $9, 'attrGroups' => $1]]; }
+    | attributes T_STATIC T_FN optional_ref '(' parameter_list ')' optional_return_type T_DOUBLE_ARROW expr %prec T_THROW
+          { $$ = Expr\ArrowFunction[['static' => true, 'byRef' => $4, 'params' => $6, 'returnType' => $8, 'expr' => $10, 'attrGroups' => $1]]; }
+    | attributes T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type block_or_error
+          { $$ = Expr\Closure[['static' => false, 'byRef' => $3, 'params' => $5, 'uses' => $7, 'returnType' => $8, 'stmts' => $9, 'attrGroups' => $1]]; }
+    | attributes T_STATIC T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type       block_or_error
+          { $$ = Expr\Closure[['static' => true, 'byRef' => $4, 'params' => $6, 'uses' => $8, 'returnType' => $9, 'stmts' => $10, 'attrGroups' => $1]]; }
 ;
 
 anonymous_class:
-      T_CLASS ctor_arguments extends_from implements_list '{' class_statement_list '}'
-          { $$ = array(Stmt\Class_[null, ['type' => 0, 'extends' => $3, 'implements' => $4, 'stmts' => $6]], $2);
+      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);
             $this->checkClass($$[0], -1); }
 ;
 
@@ -937,12 +1034,14 @@ callable_expr:
 ;
 
 callable_variable:
-      simple_variable                                       { $$ = Expr\Variable[$1]; }
+      simple_variable                                       { $$ = $1; }
     | array_object_dereferencable '[' optional_expr ']'     { $$ = Expr\ArrayDimFetch[$1, $3]; }
     | array_object_dereferencable '{' expr '}'              { $$ = Expr\ArrayDimFetch[$1, $3]; }
     | function_call                                         { $$ = $1; }
     | 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
+          { $$ = Expr\NullsafeMethodCall[$1, $3, $4]; }
 ;
 
 optional_plain_variable:
@@ -955,18 +1054,20 @@ variable:
     | static_member                                         { $$ = $1; }
     | array_object_dereferencable T_OBJECT_OPERATOR property_name
           { $$ = Expr\PropertyFetch[$1, $3]; }
+    | array_object_dereferencable T_NULLSAFE_OBJECT_OPERATOR property_name
+          { $$ = Expr\NullsafePropertyFetch[$1, $3]; }
 ;
 
 simple_variable:
-      T_VARIABLE                                            { $$ = parseVar($1); }
-    | '$' '{' expr '}'                                      { $$ = $3; }
+      plain_variable                                        { $$ = $1; }
+    | '$' '{' expr '}'                                      { $$ = Expr\Variable[$3]; }
     | '$' simple_variable                                   { $$ = Expr\Variable[$2]; }
-    | '$' error                                             { $$ = Expr\Error[]; $this->errorState = 2; }
+    | '$' error                                             { $$ = Expr\Variable[Expr\Error[]]; $this->errorState = 2; }
 ;
 
 static_member_prop_name:
       simple_variable
-          { $var = $1; $$ = \is_string($var) ? Node\VarLikeIdentifier[$var] : $var; }
+          { $var = $1->name; $$ = \is_string($var) ? Node\VarLikeIdentifier[$var] : $var; }
 ;
 
 static_member:
@@ -975,10 +1076,11 @@ static_member:
 ;
 
 new_variable:
-      simple_variable                                       { $$ = Expr\Variable[$1]; }
+      simple_variable                                       { $$ = $1; }
     | 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]; }
+    | new_variable T_NULLSAFE_OBJECT_OPERATOR property_name { $$ = Expr\NullsafePropertyFetch[$1, $3]; }
     | class_name T_PAAMAYIM_NEKUDOTAYIM static_member_prop_name
           { $$ = Expr\StaticPropertyFetch[$1, $3]; }
     | new_variable T_PAAMAYIM_NEKUDOTAYIM static_member_prop_name
@@ -988,13 +1090,13 @@ new_variable:
 member_name:
       identifier_ex                                         { $$ = $1; }
     | '{' expr '}'                                          { $$ = $2; }
-    | simple_variable                                       { $$ = Expr\Variable[$1]; }
+    | simple_variable                                       { $$ = $1; }
 ;
 
 property_name:
       identifier                                            { $$ = $1; }
     | '{' expr '}'                                          { $$ = $2; }
-    | simple_variable                                       { $$ = Expr\Variable[$1]; }
+    | simple_variable                                       { $$ = $1; }
     | error                                                 { $$ = Expr\Error[]; $this->errorState = 2; }
 ;
 
@@ -1020,10 +1122,10 @@ inner_array_pair_list:
 
 array_pair:
       expr                                                  { $$ = Expr\ArrayItem[$1, null, false]; }
-    | '&' variable                                          { $$ = Expr\ArrayItem[$2, null, true]; }
+    | ampersand variable                                    { $$ = Expr\ArrayItem[$2, null, true]; }
     | list_expr                                             { $$ = Expr\ArrayItem[$1, null, false]; }
     | expr T_DOUBLE_ARROW expr                              { $$ = Expr\ArrayItem[$3, $1,   false]; }
-    | expr T_DOUBLE_ARROW '&' variable                      { $$ = Expr\ArrayItem[$4, $1,   true]; }
+    | expr T_DOUBLE_ARROW ampersand variable                { $$ = Expr\ArrayItem[$4, $1,   true]; }
     | expr T_DOUBLE_ARROW list_expr                         { $$ = Expr\ArrayItem[$3, $1,   false]; }
     | T_ELLIPSIS expr                                       { $$ = Expr\ArrayItem[$2, null, false, attributes(), true]; }
     | /* empty */                                           { $$ = null; }
@@ -1048,6 +1150,7 @@ encaps_var:
       plain_variable                                        { $$ = $1; }
     | plain_variable '[' encaps_var_offset ']'              { $$ = Expr\ArrayDimFetch[$1, $3]; }
     | plain_variable T_OBJECT_OPERATOR identifier           { $$ = Expr\PropertyFetch[$1, $3]; }
+    | plain_variable T_NULLSAFE_OBJECT_OPERATOR identifier  { $$ = Expr\NullsafePropertyFetch[$1, $3]; }
     | T_DOLLAR_OPEN_CURLY_BRACES expr '}'                   { $$ = Expr\Variable[$2]; }
     | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '}'       { $$ = Expr\Variable[$2]; }
     | T_DOLLAR_OPEN_CURLY_BRACES encaps_str_varname '[' expr ']' '}'

grammar/phpyLang.php

@@ -0,0 +1,192 @@
+<?php
+
+///////////////////////////////
+/// Utility regex constants ///
+///////////////////////////////
+
+const LIB = '(?(DEFINE)
+    (?<singleQuotedString>\'[^\\\\\']*+(?:\\\\.[^\\\\\']*+)*+\')
+    (?<doubleQuotedString>"[^\\\\"]*+(?:\\\\.[^\\\\"]*+)*+")
+    (?<string>(?&singleQuotedString)|(?&doubleQuotedString))
+    (?<comment>/\*[^*]*+(?:\*(?!/)[^*]*+)*+\*/)
+    (?<code>\{[^\'"/{}]*+(?:(?:(?&string)|(?&comment)|(?&code)|/)[^\'"/{}]*+)*+})
+)';
+
+const PARAMS = '\[(?<params>[^[\]]*+(?:\[(?&params)\][^[\]]*+)*+)\]';
+const ARGS   = '\((?<args>[^()]*+(?:\((?&args)\)[^()]*+)*+)\)';
+
+///////////////////////////////
+/// Preprocessing functions ///
+///////////////////////////////
+
+function preprocessGrammar($code) {
+    $code = resolveNodes($code);
+    $code = resolveMacros($code);
+    $code = resolveStackAccess($code);
+
+    return $code;
+}
+
+function resolveNodes($code) {
+    return preg_replace_callback(
+        '~\b(?<name>[A-Z][a-zA-Z_\\\\]++)\s*' . PARAMS . '~',
+        function($matches) {
+            // recurse
+            $matches['params'] = resolveNodes($matches['params']);
+
+            $params = magicSplit(
+                '(?:' . PARAMS . '|' . ARGS . ')(*SKIP)(*FAIL)|,',
+                $matches['params']
+            );
+
+            $paramCode = '';
+            foreach ($params as $param) {
+                $paramCode .= $param . ', ';
+            }
+
+            return 'new ' . $matches['name'] . '(' . $paramCode . 'attributes())';
+        },
+        $code
+    );
+}
+
+function resolveMacros($code) {
+    return preg_replace_callback(
+        '~\b(?<!::|->)(?!array\()(?<name>[a-z][A-Za-z]++)' . ARGS . '~',
+        function($matches) {
+            // recurse
+            $matches['args'] = resolveMacros($matches['args']);
+
+            $name = $matches['name'];
+            $args = magicSplit(
+                '(?:' . PARAMS . '|' . ARGS . ')(*SKIP)(*FAIL)|,',
+                $matches['args']
+            );
+
+            if ('attributes' === $name) {
+                assertArgs(0, $args, $name);
+                return '$this->startAttributeStack[#1] + $this->endAttributes';
+            }
+
+            if ('stackAttributes' === $name) {
+                assertArgs(1, $args, $name);
+                return '$this->startAttributeStack[' . $args[0] . ']'
+                       . ' + $this->endAttributeStack[' . $args[0] . ']';
+            }
+
+            if ('init' === $name) {
+                return '$$ = array(' . implode(', ', $args) . ')';
+            }
+
+            if ('push' === $name) {
+                assertArgs(2, $args, $name);
+
+                return $args[0] . '[] = ' . $args[1] . '; $$ = ' . $args[0];
+            }
+
+            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] . '; }';
+            }
+
+            if ('toArray' == $name) {
+                assertArgs(1, $args, $name);
+
+                return 'is_array(' . $args[0] . ') ? ' . $args[0] . ' : array(' . $args[0] . ')';
+            }
+
+            if ('parseVar' === $name) {
+                assertArgs(1, $args, $name);
+
+                return 'substr(' . $args[0] . ', 1)';
+            }
+
+            if ('parseEncapsed' === $name) {
+                assertArgs(3, $args, $name);
+
+                return 'foreach (' . $args[0] . ' as $s) { if ($s instanceof Node\Scalar\EncapsedStringPart) {'
+                       . ' $s->value = Node\Scalar\String_::parseEscapeSequences($s->value, ' . $args[1] . ', ' . $args[2] . '); } }';
+            }
+
+            if ('makeNop' === $name) {
+                assertArgs(3, $args, $name);
+
+                return '$startAttributes = ' . $args[1] . ';'
+                       . ' if (isset($startAttributes[\'comments\']))'
+                       . ' { ' . $args[0] . ' = new Stmt\Nop($startAttributes + ' . $args[2] . '); }'
+                       . ' else { ' . $args[0] . ' = null; }';
+            }
+
+            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 ('strKind' === $name) {
+                assertArgs(1, $args, $name);
+
+                return '(' . $args[0] . '[0] === "\'" || (' . $args[0] . '[1] === "\'" && '
+                       . '(' . $args[0] . '[0] === \'b\' || ' . $args[0] . '[0] === \'B\')) '
+                       . '? Scalar\String_::KIND_SINGLE_QUOTED : Scalar\String_::KIND_DOUBLE_QUOTED)';
+            }
+
+            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 $matches[0];
+        },
+        $code
+    );
+}
+
+function assertArgs($num, $args, $name) {
+    if ($num != count($args)) {
+        die('Wrong argument count for ' . $name . '().');
+    }
+}
+
+function resolveStackAccess($code) {
+    $code = preg_replace('/\$\d+/', '$this->semStack[$0]', $code);
+    $code = preg_replace('/#(\d+)/', '$$1', $code);
+    return $code;
+}
+
+function removeTrailingWhitespace($code) {
+    $lines = explode("\n", $code);
+    $lines = array_map('rtrim', $lines);
+    return implode("\n", $lines);
+}
+
+//////////////////////////////
+/// Regex helper functions ///
+//////////////////////////////
+
+function regex($regex) {
+    return '~' . LIB . '(?:' . str_replace('~', '\~', $regex) . ')~';
+}
+
+function magicSplit($regex, $string) {
+    $pieces = preg_split(regex('(?:(?&string)|(?&comment)|(?&code))(*SKIP)(*FAIL)|' . $regex), $string);
+
+    foreach ($pieces as &$piece) {
+        $piece = trim($piece);
+    }
+
+    if ($pieces === ['']) {
+        return [];
+    }
+
+    return $pieces;
+}

grammar/rebuildParsers.php

@@ -1,5 +1,7 @@
 <?php
 
+require __DIR__ . '/phpyLang.php';
+
 $grammarFileToName = [
     __DIR__ . '/php5.y' => 'Php5',
     __DIR__ . '/php7.y' => 'Php7',
@@ -23,21 +25,6 @@ $options = array_flip($argv);
 $optionDebug = isset($options['--debug']);
 $optionKeepTmpGrammar = isset($options['--keep-tmp-grammar']);
 
-///////////////////////////////
-/// Utility regex constants ///
-///////////////////////////////
-
-const LIB = '(?(DEFINE)
-    (?<singleQuotedString>\'[^\\\\\']*+(?:\\\\.[^\\\\\']*+)*+\')
-    (?<doubleQuotedString>"[^\\\\"]*+(?:\\\\.[^\\\\"]*+)*+")
-    (?<string>(?&singleQuotedString)|(?&doubleQuotedString))
-    (?<comment>/\*[^*]*+(?:\*(?!/)[^*]*+)*+\*/)
-    (?<code>\{[^\'"/{}]*+(?:(?:(?&string)|(?&comment)|(?&code)|/)[^\'"/{}]*+)*+})
-)';
-
-const PARAMS = '\[(?<params>[^[\]]*+(?:\[(?&params)\][^[\]]*+)*+)\]';
-const ARGS   = '\((?<args>[^()]*+(?:\((?&args)\)[^()]*+)*+)\)';
-
 ///////////////////
 /// Main script ///
 ///////////////////
@@ -49,10 +36,7 @@ foreach ($grammarFileToName as $grammarFile => $name) {
 
     $grammarCode = file_get_contents($grammarFile);
     $grammarCode = str_replace('%tokens', $tokens, $grammarCode);
-
-    $grammarCode = resolveNodes($grammarCode);
-    $grammarCode = resolveMacros($grammarCode);
-    $grammarCode = resolveStackAccess($grammarCode);
+    $grammarCode = preprocessGrammar($grammarCode);
 
     file_put_contents($tmpGrammarFile, $grammarCode);
 
@@ -77,151 +61,9 @@ foreach ($grammarFileToName as $grammarFile => $name) {
     }
 }
 
-///////////////////////////////
-/// Preprocessing functions ///
-///////////////////////////////
-
-function resolveNodes($code) {
-    return preg_replace_callback(
-        '~\b(?<name>[A-Z][a-zA-Z_\\\\]++)\s*' . PARAMS . '~',
-        function($matches) {
-            // recurse
-            $matches['params'] = resolveNodes($matches['params']);
-
-            $params = magicSplit(
-                '(?:' . PARAMS . '|' . ARGS . ')(*SKIP)(*FAIL)|,',
-                $matches['params']
-            );
-
-            $paramCode = '';
-            foreach ($params as $param) {
-                $paramCode .= $param . ', ';
-            }
-
-            return 'new ' . $matches['name'] . '(' . $paramCode . 'attributes())';
-        },
-        $code
-    );
-}
-
-function resolveMacros($code) {
-    return preg_replace_callback(
-        '~\b(?<!::|->)(?!array\()(?<name>[a-z][A-Za-z]++)' . ARGS . '~',
-        function($matches) {
-            // recurse
-            $matches['args'] = resolveMacros($matches['args']);
-
-            $name = $matches['name'];
-            $args = magicSplit(
-                '(?:' . PARAMS . '|' . ARGS . ')(*SKIP)(*FAIL)|,',
-                $matches['args']
-            );
-
-            if ('attributes' == $name) {
-                assertArgs(0, $args, $name);
-                return '$this->startAttributeStack[#1] + $this->endAttributes';
-            }
-
-            if ('stackAttributes' == $name) {
-                assertArgs(1, $args, $name);
-                return '$this->startAttributeStack[' . $args[0] . ']'
-                     . ' + $this->endAttributeStack[' . $args[0] . ']';
-            }
-
-            if ('init' == $name) {
-                return '$$ = array(' . implode(', ', $args) . ')';
-            }
-
-            if ('push' == $name) {
-                assertArgs(2, $args, $name);
-
-                return $args[0] . '[] = ' . $args[1] . '; $$ = ' . $args[0];
-            }
-
-            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] . '; }';
-            }
-
-            if ('toArray' == $name) {
-                assertArgs(1, $args, $name);
-
-                return 'is_array(' . $args[0] . ') ? ' . $args[0] . ' : array(' . $args[0] . ')';
-            }
-
-            if ('parseVar' == $name) {
-                assertArgs(1, $args, $name);
-
-                return 'substr(' . $args[0] . ', 1)';
-            }
-
-            if ('parseEncapsed' == $name) {
-                assertArgs(3, $args, $name);
-
-                return 'foreach (' . $args[0] . ' as $s) { if ($s instanceof Node\Scalar\EncapsedStringPart) {'
-                     . ' $s->value = Node\Scalar\String_::parseEscapeSequences($s->value, ' . $args[1] . ', ' . $args[2] . '); } }';
-            }
-
-            if ('makeNop' == $name) {
-                assertArgs(3, $args, $name);
-
-                return '$startAttributes = ' . $args[1] . ';'
-                . ' if (isset($startAttributes[\'comments\']))'
-                . ' { ' . $args[0] . ' = new Stmt\Nop($startAttributes + ' . $args[2] . '); }'
-                . ' else { ' . $args[0] . ' = null; }';
-            }
-
-            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 ('strKind' == $name) {
-                assertArgs(1, $args, $name);
-
-                return '(' . $args[0] . '[0] === "\'" || (' . $args[0] . '[1] === "\'" && '
-                     . '(' . $args[0] . '[0] === \'b\' || ' . $args[0] . '[0] === \'B\')) '
-                     . '? Scalar\String_::KIND_SINGLE_QUOTED : Scalar\String_::KIND_DOUBLE_QUOTED)';
-            }
-
-            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 $matches[0];
-        },
-        $code
-    );
-}
-
-function assertArgs($num, $args, $name) {
-    if ($num != count($args)) {
-        die('Wrong argument count for ' . $name . '().');
-    }
-}
-
-function resolveStackAccess($code) {
-    $code = preg_replace('/\$\d+/', '$this->semStack[$0]', $code);
-    $code = preg_replace('/#(\d+)/', '$$1', $code);
-    return $code;
-}
-
-function removeTrailingWhitespace($code) {
-    $lines = explode("\n", $code);
-    $lines = array_map('rtrim', $lines);
-    return implode("\n", $lines);
-}
+////////////////////////////////
+/// Utility helper functions ///
+////////////////////////////////
 
 function ensureDirExists($dir) {
     if (!is_dir($dir)) {
@@ -237,25 +79,3 @@ function execCmd($cmd) {
     }
     return $output;
 }
-
-//////////////////////////////
-/// Regex helper functions ///
-//////////////////////////////
-
-function regex($regex) {
-    return '~' . LIB . '(?:' . str_replace('~', '\~', $regex) . ')~';
-}
-
-function magicSplit($regex, $string) {
-    $pieces = preg_split(regex('(?:(?&string)|(?&comment)|(?&code))(*SKIP)(*FAIL)|' . $regex), $string);
-
-    foreach ($pieces as &$piece) {
-        $piece = trim($piece);
-    }
-
-    if ($pieces === ['']) {
-        return [];
-    }
-
-    return $pieces;
-}

grammar/tokens.y

@@ -1,6 +1,7 @@
 /* We currently rely on the token ID mapping to be the same between PHP 5 and PHP 7 - so the same lexer can be used for
  * both. This is enforced by sharing this token file. */
 
+%right T_THROW
 %left T_INCLUDE T_INCLUDE_ONCE T_EVAL T_REQUIRE T_REQUIRE_ONCE
 %left ','
 %left T_LOGICAL_OR
@@ -17,7 +18,7 @@
 %left T_BOOLEAN_AND
 %left '|'
 %left '^'
-%left '&'
+%left T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
 %nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL T_SPACESHIP
 %nonassoc '<' T_IS_SMALLER_OR_EQUAL '>' T_IS_GREATER_OR_EQUAL
 %left T_SL T_SR
@@ -41,8 +42,6 @@
 %token T_VARIABLE
 %token T_NUM_STRING
 %token T_INLINE_HTML
-%token T_CHARACTER
-%token T_BAD_CHARACTER
 %token T_ENCAPSED_AND_WHITESPACE
 %token T_CONSTANT_ENCAPSED_STRING
 %token T_ECHO
@@ -75,7 +74,7 @@
 %token T_USE
 %token T_INSTEADOF
 %token T_GLOBAL
-%right T_STATIC T_ABSTRACT T_FINAL T_PRIVATE T_PROTECTED T_PUBLIC
+%right T_STATIC T_ABSTRACT T_FINAL T_PRIVATE T_PROTECTED T_PUBLIC T_READONLY
 %token T_VAR
 %token T_UNSET
 %token T_ISSET
@@ -84,9 +83,11 @@
 %token T_CLASS
 %token T_TRAIT
 %token T_INTERFACE
+%token T_ENUM
 %token T_EXTENDS
 %token T_IMPLEMENTS
 %token T_OBJECT_OPERATOR
+%token T_NULLSAFE_OBJECT_OPERATOR
 %token T_DOUBLE_ARROW
 %token T_LIST
 %token T_ARRAY
@@ -97,12 +98,6 @@
 %token T_FUNC_C
 %token T_LINE
 %token T_FILE
-%token T_COMMENT
-%token T_DOC_COMMENT
-%token T_OPEN_TAG
-%token T_OPEN_TAG_WITH_ECHO
-%token T_CLOSE_TAG
-%token T_WHITESPACE
 %token T_START_HEREDOC
 %token T_END_HEREDOC
 %token T_DOLLAR_OPEN_CURLY_BRACES
@@ -115,4 +110,6 @@
 %token T_ELLIPSIS
 %token T_NAME_FULLY_QUALIFIED
 %token T_NAME_QUALIFIED
-%token T_NAME_RELATIVE
+%token T_NAME_RELATIVE
+%token T_ATTRIBUTE
+%token T_ENUM

lib/PhpParser/Builder/ClassConst.php

@@ -0,0 +1,132 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\BuilderHelpers;
+use PhpParser\Node;
+use PhpParser\Node\Const_;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Stmt;
+
+class ClassConst implements PhpParser\Builder
+{
+    protected $flags = 0;
+    protected $attributes = [];
+    protected $constants = [];
+
+    /** @var Node\AttributeGroup[] */
+    protected $attributeGroups = [];
+
+    /**
+     * Creates a class constant builder
+     *
+     * @param string|Identifier                          $name  Name
+     * @param Node\Expr|bool|null|int|float|string|array $value Value
+     */
+    public function __construct($name, $value) {
+        $this->constants = [new Const_($name, BuilderHelpers::normalizeValue($value))];
+    }
+
+    /**
+     * Add another constant to const group
+     *
+     * @param string|Identifier                          $name  Name
+     * @param Node\Expr|bool|null|int|float|string|array $value Value
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addConst($name, $value) {
+        $this->constants[] = new Const_($name, BuilderHelpers::normalizeValue($value));
+
+        return $this;
+    }
+
+    /**
+     * Makes the constant public.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makePublic() {
+        $this->flags = BuilderHelpers::addModifier($this->flags, Stmt\Class_::MODIFIER_PUBLIC);
+
+        return $this;
+    }
+
+    /**
+     * Makes the constant protected.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeProtected() {
+        $this->flags = BuilderHelpers::addModifier($this->flags, Stmt\Class_::MODIFIER_PROTECTED);
+
+        return $this;
+    }
+
+    /**
+     * Makes the constant private.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makePrivate() {
+        $this->flags = BuilderHelpers::addModifier($this->flags, Stmt\Class_::MODIFIER_PRIVATE);
+
+        return $this;
+    }
+
+    /**
+     * Makes the constant final.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeFinal() {
+        $this->flags = BuilderHelpers::addModifier($this->flags, Stmt\Class_::MODIFIER_FINAL);
+
+        return $this;
+    }
+
+    /**
+     * Sets doc comment for the constant.
+     *
+     * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function setDocComment($docComment) {
+        $this->attributes = [
+            'comments' => [BuilderHelpers::normalizeDocComment($docComment)]
+        ];
+
+        return $this;
+    }
+
+    /**
+     * Adds an attribute group.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addAttribute($attribute) {
+        $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+        return $this;
+    }
+
+    /**
+     * Returns the built class node.
+     *
+     * @return Stmt\ClassConst The built constant node
+     */
+    public function getNode(): PhpParser\Node {
+        return new Stmt\ClassConst(
+            $this->constants,
+            $this->flags,
+            $this->attributes,
+            $this->attributeGroups
+        );
+    }
+}

lib/PhpParser/Builder/Class_.php

@@ -4,6 +4,7 @@ namespace PhpParser\Builder;
 
 use PhpParser;
 use PhpParser\BuilderHelpers;
+use PhpParser\Node;
 use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
 
@@ -20,6 +21,9 @@ class Class_ extends Declaration
     protected $properties = [];
     protected $methods = [];
 
+    /** @var Node\AttributeGroup[] */
+    protected $attributeGroups = [];
+
     /**
      * Creates a class builder.
      *
@@ -106,6 +110,19 @@ class Class_ extends Declaration
         return $this;
     }
 
+    /**
+     * Adds an attribute group.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addAttribute($attribute) {
+        $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+        return $this;
+    }
+
     /**
      * Returns the built class node.
      *
@@ -117,6 +134,7 @@ class Class_ extends Declaration
             'extends' => $this->extends,
             'implements' => $this->implements,
             'stmts' => array_merge($this->uses, $this->constants, $this->properties, $this->methods),
+            'attrGroups' => $this->attributeGroups,
         ], $this->attributes);
     }
 }

lib/PhpParser/Builder/Function_.php

@@ -12,6 +12,9 @@ class Function_ extends FunctionLike
     protected $name;
     protected $stmts = [];
 
+    /** @var Node\AttributeGroup[] */
+    protected $attributeGroups = [];
+
     /**
      * Creates a function builder.
      *
@@ -34,6 +37,19 @@ class Function_ extends FunctionLike
         return $this;
     }
 
+    /**
+     * Adds an attribute group.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addAttribute($attribute) {
+        $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+        return $this;
+    }
+
     /**
      * Returns the built function node.
      *
@@ -45,6 +61,7 @@ class Function_ extends FunctionLike
             'params'     => $this->params,
             'returnType' => $this->returnType,
             'stmts'      => $this->stmts,
+            'attrGroups' => $this->attributeGroups,
         ], $this->attributes);
     }
 }

lib/PhpParser/Builder/Interface_.php

@@ -4,6 +4,7 @@ namespace PhpParser\Builder;
 
 use PhpParser;
 use PhpParser\BuilderHelpers;
+use PhpParser\Node;
 use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
 
@@ -14,6 +15,9 @@ class Interface_ extends Declaration
     protected $constants = [];
     protected $methods = [];
 
+    /** @var Node\AttributeGroup[] */
+    protected $attributeGroups = [];
+
     /**
      * Creates an interface builder.
      *
@@ -61,6 +65,19 @@ class Interface_ extends Declaration
         return $this;
     }
 
+    /**
+     * Adds an attribute group.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addAttribute($attribute) {
+        $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+        return $this;
+    }
+
     /**
      * Returns the built interface node.
      *
@@ -70,6 +87,7 @@ class Interface_ extends Declaration
         return new Stmt\Interface_($this->name, [
             'extends' => $this->extends,
             'stmts' => array_merge($this->constants, $this->methods),
+            'attrGroups' => $this->attributeGroups,
         ], $this->attributes);
     }
 }

lib/PhpParser/Builder/Method.php

@@ -15,6 +15,9 @@ class Method extends FunctionLike
     /** @var array|null */
     protected $stmts = [];
 
+    /** @var Node\AttributeGroup[] */
+    protected $attributeGroups = [];
+
     /**
      * Creates a method builder.
      *
@@ -112,6 +115,19 @@ class Method extends FunctionLike
         return $this;
     }
 
+    /**
+     * Adds an attribute group.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addAttribute($attribute) {
+        $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+        return $this;
+    }
+
     /**
      * Returns the built method node.
      *
@@ -124,6 +140,7 @@ class Method extends FunctionLike
             'params'     => $this->params,
             'returnType' => $this->returnType,
             'stmts'      => $this->stmts,
+            'attrGroups' => $this->attributeGroups,
         ], $this->attributes);
     }
 }

lib/PhpParser/Builder/Namespace_.php

@@ -37,7 +37,7 @@ class Namespace_ extends Declaration
     /**
      * Returns the built node.
      *
-     * @return Node The built node
+     * @return Stmt\Namespace_ The built node
      */
     public function getNode() : Node {
         return new Stmt\Namespace_($this->name, $this->stmts, $this->attributes);

lib/PhpParser/Builder/Param.php

@@ -19,6 +19,9 @@ class Param implements PhpParser\Builder
 
     protected $variadic = false;
 
+    /** @var Node\AttributeGroup[] */
+    protected $attributeGroups = [];
+
     /**
      * Creates a parameter builder.
      *
@@ -92,6 +95,19 @@ class Param implements PhpParser\Builder
         return $this;
     }
 
+    /**
+     * Adds an attribute group.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addAttribute($attribute) {
+        $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+        return $this;
+    }
+
     /**
      * Returns the built parameter node.
      *
@@ -100,7 +116,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
+            $this->default, $this->type, $this->byRef, $this->variadic, [], 0, $this->attributeGroups
         );
     }
 }

lib/PhpParser/Builder/Property.php

@@ -4,6 +4,7 @@ namespace PhpParser\Builder;
 
 use PhpParser;
 use PhpParser\BuilderHelpers;
+use PhpParser\Node;
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
 use PhpParser\Node\NullableType;
@@ -20,6 +21,9 @@ class Property implements PhpParser\Builder
     /** @var null|Identifier|Name|NullableType */
     protected $type;
 
+    /** @var Node\AttributeGroup[] */
+    protected $attributeGroups = [];
+
     /**
      * Creates a property builder.
      *
@@ -73,6 +77,17 @@ class Property implements PhpParser\Builder
         return $this;
     }
 
+    /**
+     * Makes the property readonly.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeReadonly() {
+        $this->flags = BuilderHelpers::addModifier($this->flags, Stmt\Class_::MODIFIER_READONLY);
+
+        return $this;
+    }
+
     /**
      * Sets default value for the property.
      *
@@ -114,6 +129,19 @@ class Property implements PhpParser\Builder
         return $this;
     }
 
+    /**
+     * Adds an attribute group.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addAttribute($attribute) {
+        $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+        return $this;
+    }
+
     /**
      * Returns the built class node.
      *
@@ -126,7 +154,8 @@ class Property implements PhpParser\Builder
                 new Stmt\PropertyProperty($this->name, $this->default)
             ],
             $this->attributes,
-            $this->type
+            $this->type,
+            $this->attributeGroups
         );
     }
 }

lib/PhpParser/Builder/Trait_.php

@@ -4,6 +4,7 @@ namespace PhpParser\Builder;
 
 use PhpParser;
 use PhpParser\BuilderHelpers;
+use PhpParser\Node;
 use PhpParser\Node\Stmt;
 
 class Trait_ extends Declaration
@@ -13,6 +14,9 @@ class Trait_ extends Declaration
     protected $properties = [];
     protected $methods = [];
 
+    /** @var Node\AttributeGroup[] */
+    protected $attributeGroups = [];
+
     /**
      * Creates an interface builder.
      *
@@ -45,6 +49,19 @@ class Trait_ extends Declaration
         return $this;
     }
 
+    /**
+     * Adds an attribute group.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addAttribute($attribute) {
+        $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+        return $this;
+    }
+
     /**
      * Returns the built trait node.
      *
@@ -53,7 +70,8 @@ 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->properties, $this->methods),
+                'attrGroups' => $this->attributeGroups,
             ], $this->attributes
         );
     }

lib/PhpParser/Builder/Use_.php

@@ -39,7 +39,7 @@ class Use_ implements Builder
     /**
      * Returns the built node.
      *
-     * @return Node The built node
+     * @return Stmt\Use_ The built node
      */
     public function getNode() : Node {
         return new Stmt\Use_([

lib/PhpParser/BuilderFactory.php

@@ -12,6 +12,21 @@ use PhpParser\Node\Stmt\Use_;
 
 class BuilderFactory
 {
+    /**
+     * Creates an attribute node.
+     *
+     * @param string|Name $name Name of the attribute
+     * @param array       $args Attribute named arguments
+     *
+     * @return Node\Attribute
+     */
+    public function attribute($name, array $args = []) : Node\Attribute {
+        return new Node\Attribute(
+            BuilderHelpers::normalizeName($name),
+            $this->args($args)
+        );
+    }
+
     /**
      * Creates a namespace builder.
      *
@@ -161,6 +176,18 @@ class BuilderFactory
         return new Builder\Use_($name, Use_::TYPE_CONSTANT);
     }
 
+    /**
+     * Creates a class constant builder.
+     *
+     * @param string|Identifier                          $name  Name
+     * @param Node\Expr|bool|null|int|float|string|array $value Value
+     *
+     * @return Builder\ClassConst The created use const builder
+     */
+    public function classConst($name, $value) : Builder\ClassConst {
+        return new Builder\ClassConst($name, $value);
+    }
+
     /**
      * Creates node a for a literal value.
      *
@@ -198,12 +225,14 @@ class BuilderFactory
      */
     public function args(array $args) : array {
         $normalizedArgs = [];
-        foreach ($args as $arg) {
-            if ($arg instanceof Arg) {
-                $normalizedArgs[] = $arg;
-            } else {
-                $normalizedArgs[] = new Arg(BuilderHelpers::normalizeValue($arg));
+        foreach ($args as $key => $arg) {
+            if (!($arg instanceof Arg)) {
+                $arg = new Arg(BuilderHelpers::normalizeValue($arg));
             }
+            if (\is_string($key)) {
+                $arg->name = BuilderHelpers::normalizeIdentifier($key);
+            }
+            $normalizedArgs[] = $arg;
         }
         return $normalizedArgs;
     }

lib/PhpParser/BuilderHelpers.php

@@ -27,7 +27,9 @@ final class BuilderHelpers
     public static function normalizeNode($node) : Node {
         if ($node instanceof Builder) {
             return $node->getNode();
-        } elseif ($node instanceof Node) {
+        }
+
+        if ($node instanceof Node) {
             return $node;
         }
 
@@ -127,18 +129,22 @@ final class BuilderHelpers
     private static function normalizeNameCommon($name, bool $allowExpr) {
         if ($name instanceof Name) {
             return $name;
-        } elseif (is_string($name)) {
+        }
+
+        if (is_string($name)) {
             if (!$name) {
                 throw new \LogicException('Name cannot be empty');
             }
 
             if ($name[0] === '\\') {
                 return new Name\FullyQualified(substr($name, 1));
-            } elseif (0 === strpos($name, 'namespace\\')) {
-                return new Name\Relative(substr($name, strlen('namespace\\')));
-            } else {
-                return new Name($name);
             }
+
+            if (0 === strpos($name, 'namespace\\')) {
+                return new Name\Relative(substr($name, strlen('namespace\\')));
+            }
+
+            return new Name($name);
         }
 
         if ($allowExpr) {
@@ -148,9 +154,9 @@ final class BuilderHelpers
             throw new \LogicException(
                 'Name must be a string or an instance of Node\Name or Node\Expr'
             );
-        } else {
-            throw new \LogicException('Name must be a string or an instance of Node\Name');
         }
+
+        throw new \LogicException('Name must be a string or an instance of Node\Name');
     }
 
     /**
@@ -183,7 +189,7 @@ final class BuilderHelpers
         }
 
         $builtinTypes = [
-            'array', 'callable', 'string', 'int', 'float', 'bool', 'iterable', 'void', 'object', 'mixed'
+            'array', 'callable', 'string', 'int', 'float', 'bool', 'iterable', 'void', 'object', 'mixed', 'never',
         ];
 
         $lowerType = strtolower($type);
@@ -193,12 +199,11 @@ final class BuilderHelpers
             $type = self::normalizeName($type);
         }
 
-        if ($nullable && (string) $type === 'void') {
-            throw new \LogicException('void type cannot be nullable');
-        }
-
-        if ($nullable && (string) $type === 'mixed') {
-            throw new \LogicException('mixed type cannot be nullable');
+        $notNullableTypes = [
+            'void', 'mixed', 'never',
+        ];
+        if ($nullable && in_array((string) $type, $notNullableTypes)) {
+            throw new \LogicException(sprintf('%s type cannot be nullable', $type));
         }
 
         return $nullable ? new NullableType($type) : $type;
@@ -215,21 +220,33 @@ final class BuilderHelpers
     public static function normalizeValue($value) : Expr {
         if ($value instanceof Node\Expr) {
             return $value;
-        } elseif (is_null($value)) {
+        }
+
+        if (is_null($value)) {
             return new Expr\ConstFetch(
                 new Name('null')
             );
-        } elseif (is_bool($value)) {
+        }
+
+        if (is_bool($value)) {
             return new Expr\ConstFetch(
                 new Name($value ? 'true' : 'false')
             );
-        } elseif (is_int($value)) {
+        }
+
+        if (is_int($value)) {
             return new Scalar\LNumber($value);
-        } elseif (is_float($value)) {
+        }
+
+        if (is_float($value)) {
             return new Scalar\DNumber($value);
-        } elseif (is_string($value)) {
+        }
+
+        if (is_string($value)) {
             return new Scalar\String_($value);
-        } elseif (is_array($value)) {
+        }
+
+        if (is_array($value)) {
             $items = [];
             $lastKey = -1;
             foreach ($value as $itemKey => $itemValue) {
@@ -248,9 +265,9 @@ final class BuilderHelpers
             }
 
             return new Expr\Array_($items);
-        } else {
-            throw new \LogicException('Invalid value');
         }
+
+        throw new \LogicException('Invalid value');
     }
 
     /**
@@ -263,11 +280,33 @@ final class BuilderHelpers
     public static function normalizeDocComment($docComment) : Comment\Doc {
         if ($docComment instanceof Comment\Doc) {
             return $docComment;
-        } elseif (is_string($docComment)) {
-            return new Comment\Doc($docComment);
-        } else {
-            throw new \LogicException('Doc comment must be a string or an instance of PhpParser\Comment\Doc');
         }
+
+        if (is_string($docComment)) {
+            return new Comment\Doc($docComment);
+        }
+
+        throw new \LogicException('Doc comment must be a string or an instance of PhpParser\Comment\Doc');
+    }
+
+    /**
+     * Normalizes a attribute: Converts attribute to the Attribute Group if needed.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return Node\AttributeGroup The Attribute Group
+     */
+    public static function normalizeAttribute($attribute) : Node\AttributeGroup
+    {
+        if ($attribute instanceof Node\AttributeGroup) {
+            return $attribute;
+        }
+
+        if (!($attribute instanceof Node\Attribute)) {
+            throw new \LogicException('Attribute must be an instance of PhpParser\Node\Attribute or PhpParser\Node\AttributeGroup');
+        }
+
+        return new Node\AttributeGroup([$attribute]);
     }
 
     /**

lib/PhpParser/Internal/PrintableNewAnonClassNode.php

@@ -17,6 +17,8 @@ use PhpParser\Node\Expr;
  */
 class PrintableNewAnonClassNode extends Expr
 {
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public $attrGroups;
     /** @var Node\Arg[] Arguments */
     public $args;
     /** @var null|Node\Name Name of extended class */
@@ -27,9 +29,11 @@ class PrintableNewAnonClassNode extends Expr
     public $stmts;
 
     public function __construct(
-        array $args, Node\Name $extends = null, array $implements, array $stmts, array $attributes
+        array $attrGroups, array $args, Node\Name $extends = null, array $implements,
+        array $stmts, array $attributes
     ) {
         parent::__construct($attributes);
+        $this->attrGroups = $attrGroups;
         $this->args = $args;
         $this->extends = $extends;
         $this->implements = $implements;
@@ -42,7 +46,7 @@ class PrintableNewAnonClassNode extends Expr
         // 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(
-            $newNode->args, $class->extends, $class->implements,
+            $class->attrGroups, $newNode->args, $class->extends, $class->implements,
             $class->stmts, $newNode->getAttributes()
         );
     }
@@ -52,6 +56,6 @@ class PrintableNewAnonClassNode extends Expr
     }
 
     public function getSubNodeNames() : array {
-        return ['args', 'extends', 'implements', 'stmts'];
+        return ['attrGroups', 'args', 'extends', 'implements', 'stmts'];
     }
 }

lib/PhpParser/Internal/TokenStream.php

@@ -33,7 +33,7 @@ class TokenStream
      * @return bool
      */
     public function haveParens(int $startPos, int $endPos) : bool {
-        return $this->haveTokenImmediativelyBefore($startPos, '(')
+        return $this->haveTokenImmediatelyBefore($startPos, '(')
             && $this->haveTokenImmediatelyAfter($endPos, ')');
     }
 
@@ -46,7 +46,8 @@ class TokenStream
      * @return bool
      */
     public function haveBraces(int $startPos, int $endPos) : bool {
-        return $this->haveTokenImmediativelyBefore($startPos, '{')
+        return ($this->haveTokenImmediatelyBefore($startPos, '{')
+                || $this->haveTokenImmediatelyBefore($startPos, T_CURLY_OPEN))
             && $this->haveTokenImmediatelyAfter($endPos, '}');
     }
 
@@ -60,7 +61,7 @@ class TokenStream
      *
      * @return bool Whether the expected token was found
      */
-    public function haveTokenImmediativelyBefore(int $pos, $expectedTokenType) : bool {
+    public function haveTokenImmediatelyBefore(int $pos, $expectedTokenType) : bool {
         $tokens = $this->tokens;
         $pos--;
         for (; $pos >= 0; $pos--) {
@@ -170,7 +171,7 @@ class TokenStream
         return $pos;
     }
 
-    public function findRight($pos, $findTokenType) {
+    public function findRight(int $pos, $findTokenType) {
         $tokens = $this->tokens;
         for ($count = \count($tokens); $pos < $count; $pos++) {
             $type = $tokens[$pos][0];
@@ -181,6 +182,30 @@ class TokenStream
         return -1;
     }
 
+    /**
+     * Whether the given position range contains a certain token type.
+     *
+     * @param int $startPos Starting position (inclusive)
+     * @param int $endPos Ending position (exclusive)
+     * @param int|string $tokenType Token type to look for
+     * @return bool Whether the token occurs in the given range
+     */
+    public function haveTokenInRange(int $startPos, int $endPos, $tokenType) {
+        $tokens = $this->tokens;
+        for ($pos = $startPos; $pos < $endPos; $pos++) {
+            if ($tokens[$pos][0] === $tokenType) {
+                return true;
+            }
+        }
+        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, '}');
+    }
+
     /**
      * Get indentation before token position.
      *

lib/PhpParser/Lexer.php

@@ -15,6 +15,7 @@ class Lexer
 
     protected $tokenMap;
     protected $dropTokens;
+    protected $identifierTokens;
 
     private $attributeStartLineUsed;
     private $attributeEndLineUsed;
@@ -34,24 +35,10 @@ class Lexer
      *                       first three. For more info see getNextToken() docs.
      */
     public function __construct(array $options = []) {
-        // Compatibility define for PHP < 7.4.
-        if (!defined('T_BAD_CHARACTER')) {
-            \define('T_BAD_CHARACTER', -1);
-        }
-
-        // Compatibility defines for PHP < 8.0.
-        if (!defined('T_NAME_QUALIFIED')) {
-            \define('T_NAME_QUALIFIED', -2);
-        }
-        if (!defined('T_NAME_FULLY_QUALIFIED')) {
-            \define('T_NAME_FULLY_QUALIFIED', -3);
-        }
-        if (!defined('T_NAME_RELATIVE')) {
-            \define('T_NAME_RELATIVE', -4);
-        }
-
         // Create Map from internal tokens to PhpParser tokens.
+        $this->defineCompatibilityTokens();
         $this->tokenMap = $this->createTokenMap();
+        $this->identifierTokens = $this->createIdentifierTokenMap();
 
         // map of tokens to drop while lexing (the map is only used for isset lookup,
         // that's why the value is simply set to 1; the value is never actually used.)
@@ -98,7 +85,6 @@ class Lexer
 
         $scream = ini_set('xdebug.scream', '0');
 
-        error_clear_last();
         $this->tokens = @token_get_all($code);
         $this->postprocessTokens($errorHandler);
 
@@ -148,10 +134,11 @@ class Lexer
         // detected by finding "gaps" in the token array. Unterminated comments are detected
         // by checking if a trailing comment has a "*/" at the end.
         //
-        // Additionally, we canonicalize to the PHP 8 comment format here, which does not include
-        // the trailing whitespace anymore.
-        //
-        // We also canonicalize to the PHP 8 T_NAME_* tokens.
+        // Additionally, we perform a number of canonicalizations here:
+        //  * Use the PHP 8.0 comment format, which does not include trailing whitespace anymore.
+        //  * Use PHP 8.0 T_NAME_* tokens.
+        //  * Use PHP 8.1 T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG and
+        //    T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG tokens used to disambiguate intersection types.
 
         $filePos = 0;
         $line = 1;
@@ -185,14 +172,13 @@ class Lexer
 
             // Emulate PHP 8 T_NAME_* tokens, by combining sequences of T_NS_SEPARATOR and T_STRING
             // into a single token.
-            // TODO: Also handle reserved keywords in namespaced names.
             if (\is_array($token)
-                    && ($token[0] === \T_NS_SEPARATOR || $token[0] === \T_STRING || $token[0] === \T_NAMESPACE)) {
+                    && ($token[0] === \T_NS_SEPARATOR || isset($this->identifierTokens[$token[0]]))) {
                 $lastWasSeparator = $token[0] === \T_NS_SEPARATOR;
                 $text = $token[1];
                 for ($j = $i + 1; isset($this->tokens[$j]); $j++) {
                     if ($lastWasSeparator) {
-                        if ($this->tokens[$j][0] !== \T_STRING) {
+                        if (!isset($this->identifierTokens[$this->tokens[$j][0]])) {
                             break;
                         }
                         $lastWasSeparator = false;
@@ -223,6 +209,22 @@ class Lexer
                 }
             }
 
+            if ($token === '&') {
+                $next = $i + 1;
+                while (isset($this->tokens[$next]) && $this->tokens[$next][0] === \T_WHITESPACE) {
+                    $next++;
+                }
+                $followedByVarOrVarArg = isset($this->tokens[$next]) &&
+                    ($this->tokens[$next][0] === \T_VARIABLE || $this->tokens[$next][0] === \T_ELLIPSIS);
+                $this->tokens[$i] = $token = [
+                    $followedByVarOrVarArg
+                        ? \T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
+                        : \T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG,
+                    '&',
+                    $line,
+                ];
+            }
+
             $tokenValue = \is_string($token) ? $token : $token[1];
             $tokenLen = \strlen($tokenValue);
 
@@ -337,7 +339,8 @@ class Lexer
                 $value = $token[1];
                 $id = $this->tokenMap[$token[0]];
                 if (\T_CLOSE_TAG === $token[0]) {
-                    $this->prevCloseTagHasNewline = false !== strpos($token[1], "\n");
+                    $this->prevCloseTagHasNewline = false !== strpos($token[1], "\n")
+                        || false !== strpos($token[1], "\r");
                 } elseif (\T_INLINE_HTML === $token[0]) {
                     $startAttributes['hasLeadingNewline'] = $this->prevCloseTagHasNewline;
                 }
@@ -418,6 +421,66 @@ class Lexer
         return substr($textAfter, strlen($matches[0]));
     }
 
+    private function defineCompatibilityTokens() {
+        static $compatTokensDefined = false;
+        if ($compatTokensDefined) {
+            return;
+        }
+
+        $compatTokens = [
+            // PHP 7.4
+            'T_BAD_CHARACTER',
+            'T_FN',
+            'T_COALESCE_EQUAL',
+            // PHP 8.0
+            'T_NAME_QUALIFIED',
+            'T_NAME_FULLY_QUALIFIED',
+            'T_NAME_RELATIVE',
+            'T_MATCH',
+            'T_NULLSAFE_OBJECT_OPERATOR',
+            'T_ATTRIBUTE',
+            // PHP 8.1
+            'T_ENUM',
+            'T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG',
+            'T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG',
+            'T_READONLY',
+        ];
+
+        // PHP-Parser might be used together with another library that also emulates some or all
+        // of these tokens. Perform a sanity-check that all already defined tokens have been
+        // assigned a unique ID.
+        $usedTokenIds = [];
+        foreach ($compatTokens as $token) {
+            if (\defined($token)) {
+                $tokenId = \constant($token);
+                $clashingToken = $usedTokenIds[$tokenId] ?? null;
+                if ($clashingToken !== null) {
+                    throw new \Error(sprintf(
+                        'Token %s has same ID as token %s, ' .
+                        'you may be using a library with broken token emulation',
+                        $token, $clashingToken
+                    ));
+                }
+                $usedTokenIds[$tokenId] = $token;
+            }
+        }
+
+        // Now define any tokens that have not yet been emulated. Try to assign IDs from -1
+        // downwards, but skip any IDs that may already be in use.
+        $newTokenId = -1;
+        foreach ($compatTokens as $token) {
+            if (!\defined($token)) {
+                while (isset($usedTokenIds[$newTokenId])) {
+                    $newTokenId--;
+                }
+                \define($token, $newTokenId);
+                $newTokenId--;
+            }
+        }
+
+        $compatTokensDefined = true;
+    }
+
     /**
      * Creates the token map.
      *
@@ -463,10 +526,35 @@ class Lexer
         }
 
         // Assign tokens for which we define compatibility constants, as token_name() does not know them.
+        $tokenMap[\T_FN] = Tokens::T_FN;
+        $tokenMap[\T_COALESCE_EQUAL] = Tokens::T_COALESCE_EQUAL;
         $tokenMap[\T_NAME_QUALIFIED] = Tokens::T_NAME_QUALIFIED;
         $tokenMap[\T_NAME_FULLY_QUALIFIED] = Tokens::T_NAME_FULLY_QUALIFIED;
         $tokenMap[\T_NAME_RELATIVE] = Tokens::T_NAME_RELATIVE;
+        $tokenMap[\T_MATCH] = Tokens::T_MATCH;
+        $tokenMap[\T_NULLSAFE_OBJECT_OPERATOR] = Tokens::T_NULLSAFE_OBJECT_OPERATOR;
+        $tokenMap[\T_ATTRIBUTE] = Tokens::T_ATTRIBUTE;
+        $tokenMap[\T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG] = Tokens::T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG;
+        $tokenMap[\T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG] = Tokens::T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG;
+        $tokenMap[\T_ENUM] = Tokens::T_ENUM;
+        $tokenMap[\T_READONLY] = Tokens::T_READONLY;
 
         return $tokenMap;
     }
+
+    private function createIdentifierTokenMap(): array {
+        // Based on semi_reserved production.
+        return array_fill_keys([
+            \T_STRING,
+            \T_STATIC, \T_ABSTRACT, \T_FINAL, \T_PRIVATE, \T_PROTECTED, \T_PUBLIC, \T_READONLY,
+            \T_INCLUDE, \T_INCLUDE_ONCE, \T_EVAL, \T_REQUIRE, \T_REQUIRE_ONCE, \T_LOGICAL_OR, \T_LOGICAL_XOR, \T_LOGICAL_AND,
+            \T_INSTANCEOF, \T_NEW, \T_CLONE, \T_EXIT, \T_IF, \T_ELSEIF, \T_ELSE, \T_ENDIF, \T_ECHO, \T_DO, \T_WHILE,
+            \T_ENDWHILE, \T_FOR, \T_ENDFOR, \T_FOREACH, \T_ENDFOREACH, \T_DECLARE, \T_ENDDECLARE, \T_AS, \T_TRY, \T_CATCH,
+            \T_FINALLY, \T_THROW, \T_USE, \T_INSTEADOF, \T_GLOBAL, \T_VAR, \T_UNSET, \T_ISSET, \T_EMPTY, \T_CONTINUE, \T_GOTO,
+            \T_FUNCTION, \T_CONST, \T_RETURN, \T_PRINT, \T_YIELD, \T_LIST, \T_SWITCH, \T_ENDSWITCH, \T_CASE, \T_DEFAULT,
+            \T_BREAK, \T_ARRAY, \T_CALLABLE, \T_EXTENDS, \T_IMPLEMENTS, \T_NAMESPACE, \T_TRAIT, \T_INTERFACE, \T_CLASS,
+            \T_CLASS_C, \T_TRAIT_C, \T_FUNC_C, \T_METHOD_C, \T_LINE, \T_FILE, \T_DIR, \T_NS_C, \T_HALT_COMPILER, \T_FN,
+            \T_MATCH,
+        ], true);
+    }
 }

lib/PhpParser/Lexer/Emulative.php

@@ -5,66 +5,89 @@ namespace PhpParser\Lexer;
 use PhpParser\Error;
 use PhpParser\ErrorHandler;
 use PhpParser\Lexer;
+use PhpParser\Lexer\TokenEmulator\AttributeEmulator;
+use PhpParser\Lexer\TokenEmulator\EnumTokenEmulator;
 use PhpParser\Lexer\TokenEmulator\CoaleseEqualTokenEmulator;
+use PhpParser\Lexer\TokenEmulator\FlexibleDocStringEmulator;
 use PhpParser\Lexer\TokenEmulator\FnTokenEmulator;
 use PhpParser\Lexer\TokenEmulator\MatchTokenEmulator;
+use PhpParser\Lexer\TokenEmulator\NullsafeTokenEmulator;
 use PhpParser\Lexer\TokenEmulator\NumericLiteralSeparatorEmulator;
-use PhpParser\Lexer\TokenEmulator\TokenEmulatorInterface;
-use PhpParser\Parser\Tokens;
+use PhpParser\Lexer\TokenEmulator\ReadonlyTokenEmulator;
+use PhpParser\Lexer\TokenEmulator\ReverseEmulator;
+use PhpParser\Lexer\TokenEmulator\TokenEmulator;
 
 class Emulative extends Lexer
 {
-    const PHP_7_3 = '7.3.0dev';
-    const PHP_7_4 = '7.4.0dev';
-    const PHP_8_0 = '8.0.0dev';
-
-    const T_COALESCE_EQUAL = 1007;
-    const T_FN = 1008;
-    const T_MATCH = 1009;
-
-    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;
+    const PHP_7_3 = '7.3dev';
+    const PHP_7_4 = '7.4dev';
+    const PHP_8_0 = '8.0dev';
+    const PHP_8_1 = '8.1dev';
 
     /** @var mixed[] Patches used to reverse changes introduced in the code */
     private $patches = [];
 
-    /** @var TokenEmulatorInterface[] */
-    private $tokenEmulators = [];
+    /** @var TokenEmulator[] */
+    private $emulators = [];
+
+    /** @var string */
+    private $targetPhpVersion;
 
     /**
-     * @param mixed[] $options
+     * @param mixed[] $options Lexer options. In addition to the usual options,
+     *                         accepts a 'phpVersion' string that specifies the
+     *                         version to emulated. Defaults to newest supported.
      */
     public function __construct(array $options = [])
     {
+        $this->targetPhpVersion = $options['phpVersion'] ?? Emulative::PHP_8_1;
+        unset($options['phpVersion']);
+
         parent::__construct($options);
 
-        $this->tokenEmulators[] = new FnTokenEmulator();
-        $this->tokenEmulators[] = new MatchTokenEmulator();
-        $this->tokenEmulators[] = new CoaleseEqualTokenEmulator();
-        $this->tokenEmulators[] = new NumericLiteralSeparatorEmulator();
+        $emulators = [
+            new FlexibleDocStringEmulator(),
+            new FnTokenEmulator(),
+            new MatchTokenEmulator(),
+            new CoaleseEqualTokenEmulator(),
+            new NumericLiteralSeparatorEmulator(),
+            new NullsafeTokenEmulator(),
+            new AttributeEmulator(),
+            new EnumTokenEmulator(),
+            new ReadonlyTokenEmulator(),
+        ];
 
-        $this->tokenMap[self::T_COALESCE_EQUAL] = Tokens::T_COALESCE_EQUAL;
-        $this->tokenMap[self::T_FN] = Tokens::T_FN;
-        $this->tokenMap[self::T_MATCH] = Tokens::T_MATCH;
+        // Collect emulators that are relevant for the PHP version we're running
+        // and the PHP version we're targeting for emulation.
+        foreach ($emulators as $emulator) {
+            $emulatorPhpVersion = $emulator->getPhpVersion();
+            if ($this->isForwardEmulationNeeded($emulatorPhpVersion)) {
+                $this->emulators[] = $emulator;
+            } else if ($this->isReverseEmulationNeeded($emulatorPhpVersion)) {
+                $this->emulators[] = new ReverseEmulator($emulator);
+            }
+        }
     }
 
     public function startLexing(string $code, ErrorHandler $errorHandler = null) {
-        $this->patches = [];
+        $emulators = array_filter($this->emulators, function($emulator) use($code) {
+            return $emulator->isEmulationNeeded($code);
+        });
 
-        if ($this->isEmulationNeeded($code) === false) {
+        if (empty($emulators)) {
             // Nothing to emulate, yay
             parent::startLexing($code, $errorHandler);
             return;
         }
 
-        $collector = new ErrorHandler\Collecting();
+        $this->patches = [];
+        foreach ($emulators as $emulator) {
+            $code = $emulator->preprocessCode($code, $this->patches);
+        }
 
-        // 1. emulation of heredoc and nowdoc new syntax
-        $preparedCode = $this->processHeredocNowdoc($code);
-        parent::startLexing($preparedCode, $collector);
+        $collector = new ErrorHandler\Collecting();
+        parent::startLexing($code, $collector);
+        $this->sortPatches();
         $this->fixupTokens();
 
         $errors = $collector->getErrors();
@@ -75,78 +98,28 @@ REGEX;
             }
         }
 
-        // add token emulation
-        foreach ($this->tokenEmulators as $emulativeToken) {
-            if ($emulativeToken->isEmulationNeeded($code)) {
-                $this->tokens = $emulativeToken->emulate($code, $this->tokens);
-            }
+        foreach ($emulators as $emulator) {
+            $this->tokens = $emulator->emulate($code, $this->tokens);
         }
     }
 
-    private function isHeredocNowdocEmulationNeeded(string $code): bool
-    {
-        // skip version where this works without emulation
-        if (version_compare(\PHP_VERSION, self::PHP_7_3, '>=')) {
-            return false;
-        }
-
-        return strpos($code, '<<<') !== false;
+    private function isForwardEmulationNeeded(string $emulatorPhpVersion): bool {
+        return version_compare(\PHP_VERSION, $emulatorPhpVersion, '<')
+            && version_compare($this->targetPhpVersion, $emulatorPhpVersion, '>=');
     }
 
-    private function processHeredocNowdoc(string $code): string
-    {
-        if ($this->isHeredocNowdocEmulationNeeded($code) === false) {
-            return $code;
-        }
-
-        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);
-                $this->patches[] = [$indentationStart + $posDelta, 'add', $indentation];
-                $posDelta -= $indentationLen;
-            }
-
-            if ($separator === '') {
-                // Insert newline as separator
-                $code = substr_replace($code, "\n", $separatorStart + $posDelta, 0);
-                $this->patches[] = [$separatorStart + $posDelta, 'remove', "\n"];
-                $posDelta += 1;
-            }
-        }
-
-        return $code;
+    private function isReverseEmulationNeeded(string $emulatorPhpVersion): bool {
+        return version_compare(\PHP_VERSION, $emulatorPhpVersion, '>=')
+            && version_compare($this->targetPhpVersion, $emulatorPhpVersion, '<');
     }
 
-    private function isEmulationNeeded(string $code): bool
+    private function sortPatches()
     {
-        foreach ($this->tokenEmulators as $emulativeToken) {
-            if ($emulativeToken->isEmulationNeeded($code)) {
-                return true;
-            }
-        }
-
-        return $this->isHeredocNowdocEmulationNeeded($code);
+        // Patches may be contributed by different emulators.
+        // Make sure they are sorted by increasing patch position.
+        usort($this->patches, function($p1, $p2) {
+            return $p1[0] <=> $p2[0];
+        });
     }
 
     private function fixupTokens()
@@ -165,7 +138,20 @@ REGEX;
         for ($i = 0, $c = \count($this->tokens); $i < $c; $i++) {
             $token = $this->tokens[$i];
             if (\is_string($token)) {
-                // We assume that patches don't apply to string tokens
+                if ($patchPos === $pos) {
+                    // Only support replacement for string tokens.
+                    assert($patchType === 'replace');
+                    $this->tokens[$i] = $patchText;
+
+                    // Fetch the next patch
+                    $patchIdx++;
+                    if ($patchIdx >= \count($this->patches)) {
+                        // No more patches, we're done
+                        return;
+                    }
+                    list($patchPos, $patchType, $patchText) = $this->patches[$patchIdx];
+                }
+
                 $pos += \strlen($token);
                 continue;
             }
@@ -193,6 +179,11 @@ REGEX;
                         $token[1], $patchText, $patchPos - $pos + $posDelta, 0
                     );
                     $posDelta += $patchTextLen;
+                } else if ($patchType === 'replace') {
+                    // Replace inside the token string
+                    $this->tokens[$i][1] = substr_replace(
+                        $token[1], $patchText, $patchPos - $pos + $posDelta, $patchTextLen
+                    );
                 } else {
                     assert(false);
                 }
@@ -239,7 +230,7 @@ REGEX;
                 if ($patchType === 'add') {
                     $posDelta += strlen($patchText);
                     $lineDelta += substr_count($patchText, "\n");
-                } else {
+                } else if ($patchType === 'remove') {
                     $posDelta -= strlen($patchText);
                     $lineDelta -= substr_count($patchText, "\n");
                 }

lib/PhpParser/Lexer/TokenEmulator/AttributeEmulator.php

@@ -0,0 +1,56 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class AttributeEmulator extends TokenEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_0;
+    }
+
+    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.
+        $line = 1;
+        for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+            if ($tokens[$i] === '#' && isset($tokens[$i + 1]) && $tokens[$i + 1] === '[') {
+                array_splice($tokens, $i, 2, [
+                    [\T_ATTRIBUTE, '#[', $line]
+                ]);
+                $c--;
+                continue;
+            }
+            if (\is_array($tokens[$i])) {
+                $line += substr_count($tokens[$i][1], "\n");
+            }
+        }
+
+        return $tokens;
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array
+    {
+        // TODO
+        return $tokens;
+    }
+
+    public function preprocessCode(string $code, array &$patches): string {
+        $pos = 0;
+        while (false !== $pos = strpos($code, '#[', $pos)) {
+            // Replace #[ with %[
+            $code[$pos] = '%';
+            $patches[] = [$pos, 'replace', '#'];
+            $pos += 2;
+        }
+        return $code;
+    }
+}

lib/PhpParser/Lexer/TokenEmulator/CoaleseEqualTokenEmulator.php

@@ -4,15 +4,15 @@ namespace PhpParser\Lexer\TokenEmulator;
 
 use PhpParser\Lexer\Emulative;
 
-final class CoaleseEqualTokenEmulator implements TokenEmulatorInterface
+final class CoaleseEqualTokenEmulator extends TokenEmulator
 {
-    public function isEmulationNeeded(string $code) : bool
+    public function getPhpVersion(): string
     {
-        // skip version where this is supported
-        if (version_compare(\PHP_VERSION, Emulative::PHP_7_4, '>=')) {
-            return false;
-        }
+        return Emulative::PHP_7_4;
+    }
 
+    public function isEmulationNeeded(string $code): bool
+    {
         return strpos($code, '??=') !== false;
     }
 
@@ -25,7 +25,7 @@ final class CoaleseEqualTokenEmulator implements TokenEmulatorInterface
             if (isset($tokens[$i + 1])) {
                 if ($tokens[$i][0] === T_COALESCE && $tokens[$i + 1] === '=') {
                     array_splice($tokens, $i, 2, [
-                        [Emulative::T_COALESCE_EQUAL, '??=', $line]
+                        [\T_COALESCE_EQUAL, '??=', $line]
                     ]);
                     $c--;
                     continue;
@@ -38,4 +38,10 @@ final class CoaleseEqualTokenEmulator implements TokenEmulatorInterface
 
         return $tokens;
     }
+
+    public function reverseEmulate(string $code, array $tokens): array
+    {
+        // ??= was not valid code previously, don't bother.
+        return $tokens;
+    }
 }

lib/PhpParser/Lexer/TokenEmulator/EnumTokenEmulator.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class EnumTokenEmulator extends KeywordEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_1;
+    }
+
+    public function getKeywordString(): string
+    {
+        return 'enum';
+    }
+
+    public function getKeywordToken(): int
+    {
+        return \T_ENUM;
+    }
+
+    protected function isKeywordContext(array $tokens, int $pos): bool
+    {
+        return parent::isKeywordContext($tokens, $pos)
+            && isset($tokens[$pos + 2])
+            && $tokens[$pos + 1][0] === \T_WHITESPACE
+            && $tokens[$pos + 2][0] === \T_STRING;
+    }
+}

lib/PhpParser/Lexer/TokenEmulator/FlexibleDocStringEmulator.php

@@ -0,0 +1,76 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class FlexibleDocStringEmulator extends TokenEmulator
+{
+    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(): string
+    {
+        return Emulative::PHP_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;
+    }
+}

lib/PhpParser/Lexer/TokenEmulator/FnTokenEmulator.php

@@ -4,48 +4,20 @@ namespace PhpParser\Lexer\TokenEmulator;
 
 use PhpParser\Lexer\Emulative;
 
-final class FnTokenEmulator implements TokenEmulatorInterface
+final class FnTokenEmulator extends KeywordEmulator
 {
-    public function isEmulationNeeded(string $code) : bool
+    public function getPhpVersion(): string
     {
-        // skip version where this is supported
-        if (version_compare(\PHP_VERSION, Emulative::PHP_7_4, '>=')) {
-            return false;
-        }
-
-        return strpos($code, 'fn') !== false;
+        return Emulative::PHP_7_4;
     }
 
-    public function emulate(string $code, array $tokens): array
+    public function getKeywordString(): string
     {
-        foreach ($tokens as $i => $token) {
-            if ($token[0] === T_STRING && strtolower($token[1]) === 'fn') {
-                $previousNonSpaceToken = $this->getPreviousNonSpaceToken($tokens, $i);
-                if ($previousNonSpaceToken !== null && $previousNonSpaceToken[0] === T_OBJECT_OPERATOR) {
-                    continue;
-                }
-
-                $tokens[$i][0] = Emulative::T_FN;
-            }
-        }
-
-        return $tokens;
+        return 'fn';
     }
 
-    /**
-     * @param mixed[] $tokens
-     * @return mixed[]|null
-     */
-    private function getPreviousNonSpaceToken(array $tokens, int $start)
+    public function getKeywordToken(): int
     {
-        for ($i = $start - 1; $i >= 0; --$i) {
-            if ($tokens[$i][0] === T_WHITESPACE) {
-                continue;
-            }
-
-            return $tokens[$i];
-        }
-
-        return null;
+        return \T_FN;
     }
-}
+}

lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php

@@ -0,0 +1,62 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+abstract class KeywordEmulator extends TokenEmulator
+{
+    abstract function getKeywordString(): string;
+    abstract function getKeywordToken(): int;
+
+    public function isEmulationNeeded(string $code): bool
+    {
+        return strpos(strtolower($code), $this->getKeywordString()) !== false;
+    }
+
+    protected function isKeywordContext(array $tokens, int $pos): bool
+    {
+        $previousNonSpaceToken = $this->getPreviousNonSpaceToken($tokens, $pos);
+        return $previousNonSpaceToken === null || $previousNonSpaceToken[0] !== \T_OBJECT_OPERATOR;
+    }
+
+    public function emulate(string $code, array $tokens): array
+    {
+        $keywordString = $this->getKeywordString();
+        foreach ($tokens as $i => $token) {
+            if ($token[0] === T_STRING && strtolower($token[1]) === $keywordString
+                    && $this->isKeywordContext($tokens, $i)) {
+                $tokens[$i][0] = $this->getKeywordToken();
+            }
+        }
+
+        return $tokens;
+    }
+
+    /**
+     * @param mixed[] $tokens
+     * @return mixed[]|null
+     */
+    private function getPreviousNonSpaceToken(array $tokens, int $start)
+    {
+        for ($i = $start - 1; $i >= 0; --$i) {
+            if ($tokens[$i][0] === T_WHITESPACE) {
+                continue;
+            }
+
+            return $tokens[$i];
+        }
+
+        return null;
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array
+    {
+        $keywordToken = $this->getKeywordToken();
+        foreach ($tokens as $i => $token) {
+            if ($token[0] === $keywordToken) {
+                $tokens[$i][0] = \T_STRING;
+            }
+        }
+
+        return $tokens;
+    }
+}

lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php

@@ -4,48 +4,20 @@ namespace PhpParser\Lexer\TokenEmulator;
 
 use PhpParser\Lexer\Emulative;
 
-final class MatchTokenEmulator implements TokenEmulatorInterface
+final class MatchTokenEmulator extends KeywordEmulator
 {
-    public function isEmulationNeeded(string $code) : bool
+    public function getPhpVersion(): string
     {
-        // skip version where this is supported
-        if (version_compare(\PHP_VERSION, Emulative::PHP_8_0, '>=')) {
-            return false;
-        }
-
-        return strpos($code, 'match') !== false;
+        return Emulative::PHP_8_0;
     }
 
-    public function emulate(string $code, array $tokens): array
+    public function getKeywordString(): string
     {
-        foreach ($tokens as $i => $token) {
-            if ($token[0] === T_STRING && strtolower($token[1]) === 'match') {
-                $previousNonSpaceToken = $this->getPreviousNonSpaceToken($tokens, $i);
-                if ($previousNonSpaceToken !== null && $previousNonSpaceToken[0] === T_OBJECT_OPERATOR) {
-                    continue;
-                }
-
-                $tokens[$i][0] = Emulative::T_MATCH;
-            }
-        }
-
-        return $tokens;
+        return 'match';
     }
 
-    /**
-     * @param mixed[] $tokens
-     * @return mixed[]|null
-     */
-    private function getPreviousNonSpaceToken(array $tokens, int $start)
+    public function getKeywordToken(): int
     {
-        for ($i = $start - 1; $i >= 0; --$i) {
-            if ($tokens[$i][0] === T_WHITESPACE) {
-                continue;
-            }
-
-            return $tokens[$i];
-        }
-
-        return null;
+        return \T_MATCH;
     }
 }

lib/PhpParser/Lexer/TokenEmulator/NullsafeTokenEmulator.php

@@ -0,0 +1,67 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class NullsafeTokenEmulator extends TokenEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_0;
+    }
+
+    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
+        $line = 1;
+        for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+            if ($tokens[$i] === '?' && isset($tokens[$i + 1]) && $tokens[$i + 1][0] === \T_OBJECT_OPERATOR) {
+                array_splice($tokens, $i, 2, [
+                    [\T_NULLSAFE_OBJECT_OPERATOR, '?->', $line]
+                ]);
+                $c--;
+                continue;
+            }
+
+            // Handle ?-> inside encapsed string.
+            if ($tokens[$i][0] === \T_ENCAPSED_AND_WHITESPACE && isset($tokens[$i - 1])
+                && $tokens[$i - 1][0] === \T_VARIABLE
+                && preg_match('/^\?->([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)/', $tokens[$i][1], $matches)
+            ) {
+                $replacement = [
+                    [\T_NULLSAFE_OBJECT_OPERATOR, '?->', $line],
+                    [\T_STRING, $matches[1], $line],
+                ];
+                if (\strlen($matches[0]) !== \strlen($tokens[$i][1])) {
+                    $replacement[] = [
+                        \T_ENCAPSED_AND_WHITESPACE,
+                        \substr($tokens[$i][1], \strlen($matches[0])),
+                        $line
+                    ];
+                }
+                array_splice($tokens, $i, 1, $replacement);
+                $c += \count($replacement) - 1;
+                continue;
+            }
+
+            if (\is_array($tokens[$i])) {
+                $line += substr_count($tokens[$i][1], "\n");
+            }
+        }
+
+        return $tokens;
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array
+    {
+        // ?-> was not valid code previously, don't bother.
+        return $tokens;
+    }
+}

lib/PhpParser/Lexer/TokenEmulator/NumericLiteralSeparatorEmulator.php

@@ -4,7 +4,7 @@ namespace PhpParser\Lexer\TokenEmulator;
 
 use PhpParser\Lexer\Emulative;
 
-final class NumericLiteralSeparatorEmulator implements TokenEmulatorInterface
+final class NumericLiteralSeparatorEmulator extends TokenEmulator
 {
     const BIN = '(?:0b[01]+(?:_[01]+)*)';
     const HEX = '(?:0x[0-9a-f]+(?:_[0-9a-f]+)*)';
@@ -14,13 +14,13 @@ final class NumericLiteralSeparatorEmulator implements TokenEmulatorInterface
     const FLOAT = '(?:' . self::SIMPLE_FLOAT . self::EXP . '?|' . self::DEC . self::EXP . ')';
     const NUMBER = '~' . self::FLOAT . '|' . self::BIN . '|' . self::HEX . '|' . self::DEC . '~iA';
 
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_7_4;
+    }
+
     public function isEmulationNeeded(string $code) : bool
     {
-        // skip version where this is supported
-        if (version_compare(\PHP_VERSION, Emulative::PHP_7_4, '>=')) {
-            return false;
-        }
-
         return preg_match('~[0-9]_[0-9]~', $code)
             || preg_match('~0x[0-9a-f]+_[0-9a-f]~i', $code);
     }
@@ -96,4 +96,10 @@ final class NumericLiteralSeparatorEmulator implements TokenEmulatorInterface
 
         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;
+    }
 }

lib/PhpParser/Lexer/TokenEmulator/ReadonlyTokenEmulator.php

@@ -0,0 +1,23 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class ReadonlyTokenEmulator extends KeywordEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_1;
+    }
+
+    public function getKeywordString(): string
+    {
+        return 'readonly';
+    }
+
+    public function getKeywordToken(): int
+    {
+        return \T_READONLY;
+    }
+}

lib/PhpParser/Lexer/TokenEmulator/ReverseEmulator.php

@@ -0,0 +1,36 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+/**
+ * Reverses emulation direction of the inner emulator.
+ */
+final class ReverseEmulator extends TokenEmulator
+{
+    /** @var TokenEmulator Inner emulator */
+    private $emulator;
+
+    public function __construct(TokenEmulator $emulator) {
+        $this->emulator = $emulator;
+    }
+
+    public function getPhpVersion(): string {
+        return $this->emulator->getPhpVersion();
+    }
+
+    public function isEmulationNeeded(string $code): bool {
+        return $this->emulator->isEmulationNeeded($code);
+    }
+
+    public function emulate(string $code, array $tokens): array {
+        return $this->emulator->reverseEmulate($code, $tokens);
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array {
+        return $this->emulator->emulate($code, $tokens);
+    }
+
+    public function preprocessCode(string $code, array &$patches): string {
+        return $code;
+    }
+}

lib/PhpParser/Lexer/TokenEmulator/TokenEmulator.php

@@ -0,0 +1,25 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+/** @internal */
+abstract class TokenEmulator
+{
+    abstract public function getPhpVersion(): string;
+
+    abstract public function isEmulationNeeded(string $code): bool;
+
+    /**
+     * @return array Modified Tokens
+     */
+    abstract public function emulate(string $code, array $tokens): array;
+
+    /**
+     * @return array Modified Tokens
+     */
+    abstract public function reverseEmulate(string $code, array $tokens): array;
+
+    public function preprocessCode(string $code, array &$patches): string {
+        return $code;
+    }
+}

lib/PhpParser/Lexer/TokenEmulator/TokenEmulatorInterface.php

@@ -1,14 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace PhpParser\Lexer\TokenEmulator;
-
-/** @internal */
-interface TokenEmulatorInterface
-{
-    public function isEmulationNeeded(string $code): bool;
-
-    /**
-     * @return array Modified Tokens
-     */
-    public function emulate(string $code, array $tokens): array;
-}

lib/PhpParser/Node/Arg.php

@@ -6,6 +6,8 @@ use PhpParser\NodeAbstract;
 
 class Arg extends NodeAbstract
 {
+    /** @var Identifier|null Parameter name (for named parameters) */
+    public $name;
     /** @var Expr Value to pass */
     public $value;
     /** @var bool Whether to pass by ref */
@@ -20,16 +22,21 @@ class Arg extends NodeAbstract
      * @param bool  $byRef      Whether to pass by ref
      * @param bool  $unpack     Whether to unpack the argument
      * @param array $attributes Additional attributes
+     * @param Identifier|null $name Parameter name (for named parameters)
      */
-    public function __construct(Expr $value, bool $byRef = false, bool $unpack = false, array $attributes = []) {
+    public function __construct(
+        Expr $value, bool $byRef = false, bool $unpack = false, array $attributes = [],
+        Identifier $name = null
+    ) {
         $this->attributes = $attributes;
+        $this->name = $name;
         $this->value = $value;
         $this->byRef = $byRef;
         $this->unpack = $unpack;
     }
 
     public function getSubNodeNames() : array {
-        return ['value', 'byRef', 'unpack'];
+        return ['name', 'value', 'byRef', 'unpack'];
     }
     
     public function getType() : string {

lib/PhpParser/Node/Attribute.php

@@ -0,0 +1,34 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+
+class Attribute extends NodeAbstract
+{
+    /** @var Name Attribute name */
+    public $name;
+
+    /** @var Arg[] Attribute arguments */
+    public $args;
+
+    /**
+     * @param Node\Name $name       Attribute name
+     * @param Arg[]     $args       Attribute arguments
+     * @param array     $attributes Additional node attributes
+     */
+    public function __construct(Name $name, array $args = [], array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->name = $name;
+        $this->args = $args;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['name', 'args'];
+    }
+
+    public function getType() : string {
+        return 'Attribute';
+    }
+}

lib/PhpParser/Node/AttributeGroup.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+
+class AttributeGroup extends NodeAbstract
+{
+    /** @var Attribute[] Attributes */
+    public $attrs;
+
+    /**
+     * @param Attribute[] $attrs PHP attributes
+     * @param array $attributes Additional node attributes
+     */
+    public function __construct(array $attrs, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->attrs = $attrs;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['attrs'];
+    }
+
+    public function getType() : string {
+        return 'AttributeGroup';
+    }
+}

lib/PhpParser/Node/Const_.php

@@ -5,7 +5,7 @@ namespace PhpParser\Node;
 use PhpParser\NodeAbstract;
 
 /**
- * @property Name $namespacedName Namespaced name (for class constants, if using NameResolver)
+ * @property Name $namespacedName Namespaced name (for global constants, if using NameResolver)
  */
 class Const_ extends NodeAbstract
 {

lib/PhpParser/Node/Expr/Array_.php

@@ -10,13 +10,13 @@ class Array_ extends Expr
     const KIND_LONG = 1;  // array() syntax
     const KIND_SHORT = 2; // [] syntax
 
-    /** @var ArrayItem[] Items */
+    /** @var (ArrayItem|null)[] Items */
     public $items;
 
     /**
      * Constructs an array node.
      *
-     * @param ArrayItem[] $items      Items of the array
+     * @param (ArrayItem|null)[] $items      Items of the array
      * @param array       $attributes Additional attributes
      */
     public function __construct(array $items = [], array $attributes = []) {

lib/PhpParser/Node/Expr/ArrowFunction.php

@@ -22,6 +22,8 @@ class ArrowFunction extends Expr implements FunctionLike
 
     /** @var Expr */
     public $expr;
+    /** @var Node\AttributeGroup[] */
+    public $attrGroups;
 
     /**
      * @param array $subNodes   Array of the following optional subnodes:
@@ -30,6 +32,7 @@ class ArrowFunction extends Expr implements FunctionLike
      *                          'params'     => array() : Parameters
      *                          'returnType' => null    : Return type
      *                          'expr'       => Expr    : Expression body
+     *                          'attrGroups' => array() : PHP attribute groups
      * @param array $attributes Additional attributes
      */
     public function __construct(array $subNodes = [], array $attributes = []) {
@@ -40,10 +43,11 @@ class ArrowFunction extends Expr implements FunctionLike
         $returnType = $subNodes['returnType'] ?? null;
         $this->returnType = \is_string($returnType) ? new Node\Identifier($returnType) : $returnType;
         $this->expr = $subNodes['expr'] ?? null;
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
     }
 
     public function getSubNodeNames() : array {
-        return ['static', 'byRef', 'params', 'returnType', 'expr'];
+        return ['attrGroups', 'static', 'byRef', 'params', 'returnType', 'expr'];
     }
 
     public function returnsByRef() : bool {
@@ -58,6 +62,10 @@ class ArrowFunction extends Expr implements FunctionLike
         return $this->returnType;
     }
 
+    public function getAttrGroups() : array {
+        return $this->attrGroups;
+    }
+
     /**
      * @return Node\Stmt\Return_[]
      */

lib/PhpParser/Node/Expr/Closure.php

@@ -20,6 +20,8 @@ class Closure extends Expr implements FunctionLike
     public $returnType;
     /** @var Node\Stmt[] Statements */
     public $stmts;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public $attrGroups;
 
     /**
      * Constructs a lambda function node.
@@ -31,6 +33,7 @@ class Closure extends Expr implements FunctionLike
      *                          'uses'       => array(): use()s
      *                          'returnType' => null   : Return type
      *                          'stmts'      => array(): Statements
+     *                          'attrGroups' => array(): PHP attributes groups
      * @param array $attributes Additional attributes
      */
     public function __construct(array $subNodes = [], array $attributes = []) {
@@ -42,10 +45,11 @@ class Closure extends Expr implements FunctionLike
         $returnType = $subNodes['returnType'] ?? null;
         $this->returnType = \is_string($returnType) ? new Node\Identifier($returnType) : $returnType;
         $this->stmts = $subNodes['stmts'] ?? [];
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
     }
 
     public function getSubNodeNames() : array {
-        return ['static', 'byRef', 'params', 'uses', 'returnType', 'stmts'];
+        return ['attrGroups', 'static', 'byRef', 'params', 'uses', 'returnType', 'stmts'];
     }
 
     public function returnsByRef() : bool {
@@ -64,7 +68,11 @@ class Closure extends Expr implements FunctionLike
     public function getStmts() : array {
         return $this->stmts;
     }
-    
+
+    public function getAttrGroups() : array {
+        return $this->attrGroups;
+    }
+
     public function getType() : string {
         return 'Expr_Closure';
     }

lib/PhpParser/Node/Expr/NullsafeMethodCall.php

@@ -0,0 +1,40 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Identifier;
+
+class NullsafeMethodCall extends Expr
+{
+    /** @var Expr Variable holding object */
+    public $var;
+    /** @var Identifier|Expr Method name */
+    public $name;
+    /** @var Arg[] Arguments */
+    public $args;
+
+    /**
+     * Constructs a nullsafe method call node.
+     *
+     * @param Expr                   $var        Variable holding object
+     * @param string|Identifier|Expr $name       Method name
+     * @param Arg[]                  $args       Arguments
+     * @param array                  $attributes Additional attributes
+     */
+    public function __construct(Expr $var, $name, array $args = [], array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->var = $var;
+        $this->name = \is_string($name) ? new Identifier($name) : $name;
+        $this->args = $args;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['var', 'name', 'args'];
+    }
+    
+    public function getType() : string {
+        return 'Expr_NullsafeMethodCall';
+    }
+}

lib/PhpParser/Node/Expr/NullsafePropertyFetch.php

@@ -0,0 +1,35 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Identifier;
+
+class NullsafePropertyFetch extends Expr
+{
+    /** @var Expr Variable holding object */
+    public $var;
+    /** @var Identifier|Expr Property name */
+    public $name;
+
+    /**
+     * Constructs a nullsafe property fetch node.
+     *
+     * @param Expr                   $var        Variable holding object
+     * @param string|Identifier|Expr $name       Property name
+     * @param array                  $attributes Additional attributes
+     */
+    public function __construct(Expr $var, $name, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->var = $var;
+        $this->name = \is_string($name) ? new Identifier($name) : $name;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['var', 'name'];
+    }
+    
+    public function getType() : string {
+        return 'Expr_NullsafePropertyFetch';
+    }
+}

lib/PhpParser/Node/Expr/Throw_.php

@@ -0,0 +1,30 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node;
+
+class Throw_ extends Node\Expr
+{
+    /** @var Node\Expr Expression */
+    public $expr;
+
+    /**
+     * Constructs a throw expression node.
+     *
+     * @param Node\Expr $expr       Expression
+     * @param array     $attributes Additional attributes
+     */
+    public function __construct(Node\Expr $expr, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['expr'];
+    }
+
+    public function getType() : string {
+        return 'Expr_Throw';
+    }
+}

lib/PhpParser/Node/Expr/Variable.php

@@ -13,7 +13,7 @@ class Variable extends Expr
      * Constructs a variable node.
      *
      * @param string|Expr $name       Name
-     * @param array                      $attributes Additional attributes
+     * @param array       $attributes Additional attributes
      */
     public function __construct($name, array $attributes = []) {
         $this->attributes = $attributes;

lib/PhpParser/Node/FunctionLike.php

@@ -16,21 +16,28 @@ interface FunctionLike extends Node
     /**
      * List of parameters
      *
-     * @return Node\Param[]
+     * @return Param[]
      */
     public function getParams() : array;
 
     /**
      * Get the declared return type or null
      *
-     * @return null|Identifier|Node\Name|Node\NullableType|Node\UnionType
+     * @return null|Identifier|Name|NullableType|UnionType
      */
     public function getReturnType();
 
     /**
      * The function body
      *
-     * @return Node\Stmt[]|null
+     * @return Stmt[]|null
      */
     public function getStmts();
+
+    /**
+     * Get PHP attribute groups.
+     *
+     * @return AttributeGroup[]
+     */
+    public function getAttrGroups() : array;
 }

lib/PhpParser/Node/Name.php

@@ -85,7 +85,7 @@ class Name extends NodeAbstract
     }
 
     /**
-     * Returns a string representation of the name itself, without taking taking the name type into
+     * Returns a string representation of the name itself, without taking the name type into
      * account (e.g., not including a leading backslash for fully qualified names).
      *
      * @return string String representation

lib/PhpParser/Node/Param.php

@@ -18,6 +18,8 @@ class Param extends NodeAbstract
     public $default;
     /** @var int */
     public $flags;
+    /** @var AttributeGroup[] PHP attribute groups */
+    public $attrGroups;
 
     /**
      * Constructs a parameter node.
@@ -27,14 +29,16 @@ class Param extends NodeAbstract
      * @param null|string|Identifier|Name|NullableType|UnionType $type       Type declaration
      * @param bool                                               $byRef      Whether is passed by reference
      * @param bool                                               $variadic   Whether this is a variadic argument
-     * @param array                                              $flags      Optional visibility flags
      * @param array                                              $attributes Additional attributes
+     * @param int                                                $flags      Optional visibility flags
+     * @param AttributeGroup[]                                   $attrGroups PHP attribute groups
      */
     public function __construct(
         $var, Expr $default = null, $type = null,
         bool $byRef = false, bool $variadic = false,
         array $attributes = [],
-        int $flags = 0
+        int $flags = 0,
+        array $attrGroups = []
     ) {
         $this->attributes = $attributes;
         $this->type = \is_string($type) ? new Identifier($type) : $type;
@@ -43,10 +47,11 @@ class Param extends NodeAbstract
         $this->var = $var;
         $this->default = $default;
         $this->flags = $flags;
+        $this->attrGroups = $attrGroups;
     }
 
     public function getSubNodeNames() : array {
-        return ['flags', 'type', 'byRef', 'variadic', 'var', 'default'];
+        return ['attrGroups', 'flags', 'type', 'byRef', 'variadic', 'var', 'default'];
     }
 
     public function getType() : string {

lib/PhpParser/Node/Stmt/ClassConst.php

@@ -10,22 +10,31 @@ class ClassConst extends Node\Stmt
     public $flags;
     /** @var Node\Const_[] Constant declarations */
     public $consts;
+    /** @var Node\AttributeGroup[] */
+    public $attrGroups;
 
     /**
      * Constructs a class const list node.
      *
-     * @param Node\Const_[] $consts     Constant declarations
-     * @param int           $flags      Modifiers
-     * @param array         $attributes Additional attributes
+     * @param Node\Const_[]         $consts     Constant declarations
+     * @param int                   $flags      Modifiers
+     * @param array                 $attributes Additional attributes
+     * @param Node\AttributeGroup[] $attrGroups PHP attribute groups
      */
-    public function __construct(array $consts, int $flags = 0, array $attributes = []) {
+    public function __construct(
+        array $consts,
+        int $flags = 0,
+        array $attributes = [],
+        array $attrGroups = []
+    ) {
         $this->attributes = $attributes;
         $this->flags = $flags;
         $this->consts = $consts;
+        $this->attrGroups = $attrGroups;
     }
 
     public function getSubNodeNames() : array {
-        return ['flags', 'consts'];
+        return ['attrGroups', 'flags', 'consts'];
     }
 
     /**
@@ -55,7 +64,16 @@ class ClassConst extends Node\Stmt
     public function isPrivate() : bool {
         return (bool) ($this->flags & Class_::MODIFIER_PRIVATE);
     }
-    
+
+    /**
+     * Whether constant is final.
+     *
+     * @return bool
+     */
+    public function isFinal() : bool {
+        return (bool) ($this->flags & Class_::MODIFIER_FINAL);
+    }
+
     public function getType() : string {
         return 'Stmt_ClassConst';
     }

lib/PhpParser/Node/Stmt/ClassLike.php

@@ -13,6 +13,8 @@ abstract class ClassLike extends Node\Stmt
     public $name;
     /** @var Node\Stmt[] Statements */
     public $stmts;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public $attrGroups;
 
     /**
      * @return TraitUse[]

lib/PhpParser/Node/Stmt/ClassMethod.php

@@ -19,6 +19,8 @@ class ClassMethod extends Node\Stmt implements FunctionLike
     public $returnType;
     /** @var Node\Stmt[]|null Statements */
     public $stmts;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public $attrGroups;
 
     private static $magicNames = [
         '__construct'  => true,
@@ -48,6 +50,7 @@ class ClassMethod extends Node\Stmt implements FunctionLike
      *                          'params'     => array()        : Parameters
      *                          'returnType' => null           : Return type
      *                          'stmts'      => array()        : Statements
+     *                          'attrGroups' => array()        : PHP attribute groups
      * @param array $attributes Additional attributes
      */
     public function __construct($name, array $subNodes = [], array $attributes = []) {
@@ -59,10 +62,11 @@ class ClassMethod extends Node\Stmt implements FunctionLike
         $returnType = $subNodes['returnType'] ?? null;
         $this->returnType = \is_string($returnType) ? new Node\Identifier($returnType) : $returnType;
         $this->stmts = array_key_exists('stmts', $subNodes) ? $subNodes['stmts'] : [];
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
     }
 
     public function getSubNodeNames() : array {
-        return ['flags', 'byRef', 'name', 'params', 'returnType', 'stmts'];
+        return ['attrGroups', 'flags', 'byRef', 'name', 'params', 'returnType', 'stmts'];
     }
 
     public function returnsByRef() : bool {
@@ -81,6 +85,10 @@ class ClassMethod extends Node\Stmt implements FunctionLike
         return $this->stmts;
     }
 
+    public function getAttrGroups() : array {
+        return $this->attrGroups;
+    }
+
     /**
      * Whether the method is explicitly or implicitly public.
      *
@@ -120,7 +128,7 @@ class ClassMethod extends Node\Stmt implements FunctionLike
 
     /**
      * Whether the method is final.
-     * 
+     *
      * @return bool
      */
     public function isFinal() : bool {
@@ -144,7 +152,7 @@ class ClassMethod extends Node\Stmt implements FunctionLike
     public function isMagic() : bool {
         return isset(self::$magicNames[$this->name->toLowerString()]);
     }
-    
+
     public function getType() : string {
         return 'Stmt_ClassMethod';
     }

lib/PhpParser/Node/Stmt/Class_.php

@@ -13,6 +13,7 @@ class Class_ extends ClassLike
     const MODIFIER_STATIC    =  8;
     const MODIFIER_ABSTRACT  = 16;
     const MODIFIER_FINAL     = 32;
+    const MODIFIER_READONLY  = 64;
 
     const VISIBILITY_MODIFIER_MASK = 7; // 1 | 2 | 4
 
@@ -28,10 +29,11 @@ class Class_ extends ClassLike
      *
      * @param string|Node\Identifier|null $name Name
      * @param array       $subNodes   Array of the following optional subnodes:
-     *                                'flags'      => 0      : Flags
-     *                                'extends'    => null   : Name of extended class
-     *                                'implements' => array(): Names of implemented interfaces
-     *                                'stmts'      => array(): Statements
+     *                                'flags'       => 0      : Flags
+     *                                'extends'     => null   : Name of extended class
+     *                                'implements'  => array(): Names of implemented interfaces
+     *                                'stmts'       => array(): Statements
+     *                                'attrGroups'  => array(): PHP attribute groups
      * @param array       $attributes Additional attributes
      */
     public function __construct($name, array $subNodes = [], array $attributes = []) {
@@ -41,10 +43,11 @@ class Class_ extends ClassLike
         $this->extends = $subNodes['extends'] ?? null;
         $this->implements = $subNodes['implements'] ?? [];
         $this->stmts = $subNodes['stmts'] ?? [];
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
     }
 
     public function getSubNodeNames() : array {
-        return ['flags', 'name', 'extends', 'implements', 'stmts'];
+        return ['attrGroups', 'flags', 'name', 'extends', 'implements', 'stmts'];
     }
 
     /**
@@ -94,6 +97,10 @@ class Class_ extends ClassLike
             throw new Error('Multiple final modifiers are not allowed');
         }
 
+        if ($a & self::MODIFIER_READONLY && $b & self::MODIFIER_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');
         }

lib/PhpParser/Node/Stmt/EnumCase.php

@@ -0,0 +1,37 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+use PhpParser\Node\AttributeGroup;
+
+class EnumCase extends Node\Stmt
+{
+    /** @var Node\Identifier Enum case name */
+    public $name;
+    /** @var Node\Expr|null Enum case expression */
+    public $expr;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public $attrGroups;
+
+    /**
+     * @param string|Node\Identifier    $name       Enum case name
+     * @param Node\Expr|null            $expr       Enum case expression
+     * @param AttributeGroup[]          $attrGroups PHP attribute groups
+     * @param array                     $attributes Additional attributes
+     */
+    public function __construct($name, Node\Expr $expr = null, array $attrGroups = [], array $attributes = []) {
+        parent::__construct($attributes);
+        $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+        $this->expr = $expr;
+        $this->attrGroups = $attrGroups;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['attrGroups', 'name', 'expr'];
+    }
+
+    public function getType() : string {
+        return 'Stmt_EnumCase';
+    }
+}

lib/PhpParser/Node/Stmt/Enum_.php

@@ -0,0 +1,40 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Enum_ extends ClassLike
+{
+    /** @var null|Node\Identifier Scalar Type */
+    public $scalarType;
+    /** @var Node\Name[] Names of implemented interfaces */
+    public $implements;
+
+    /**
+     * @param string|Node\Identifier|null $name       Name
+     * @param array                       $subNodes   Array of the following optional subnodes:
+     *                                                'scalarType'  => null    : Scalar type
+     *                                                'implements'  => array() : Names of implemented interfaces
+     *                                                'stmts'       => array() : Statements
+     *                                                'attrGroups'  => array() : PHP attribute groups
+     * @param array                       $attributes Additional attributes
+     */
+    public function __construct($name, array $subNodes = [], array $attributes = []) {
+        $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+        $this->scalarType = $subNodes['scalarType'] ?? null;
+        $this->implements = $subNodes['implements'] ?? [];
+        $this->stmts = $subNodes['stmts'] ?? [];
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
+
+        parent::__construct($attributes);
+    }
+
+    public function getSubNodeNames() : array {
+        return ['attrGroups', 'name', 'scalarType', 'implements', 'stmts'];
+    }
+
+    public function getType() : string {
+        return 'Stmt_Enum';
+    }
+}

lib/PhpParser/Node/Stmt/Function_.php

@@ -20,6 +20,8 @@ class Function_ extends Node\Stmt implements FunctionLike
     public $returnType;
     /** @var Node\Stmt[] Statements */
     public $stmts;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public $attrGroups;
 
     /**
      * Constructs a function node.
@@ -30,6 +32,7 @@ class Function_ extends Node\Stmt implements FunctionLike
      *                           'params'     => array(): Parameters
      *                           'returnType' => null   : Return type
      *                           'stmts'      => array(): Statements
+     *                           'attrGroups' => array(): PHP attribute groups
      * @param array  $attributes Additional attributes
      */
     public function __construct($name, array $subNodes = [], array $attributes = []) {
@@ -40,10 +43,11 @@ class Function_ extends Node\Stmt implements FunctionLike
         $returnType = $subNodes['returnType'] ?? null;
         $this->returnType = \is_string($returnType) ? new Node\Identifier($returnType) : $returnType;
         $this->stmts = $subNodes['stmts'] ?? [];
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
     }
 
     public function getSubNodeNames() : array {
-        return ['byRef', 'name', 'params', 'returnType', 'stmts'];
+        return ['attrGroups', 'byRef', 'name', 'params', 'returnType', 'stmts'];
     }
 
     public function returnsByRef() : bool {
@@ -58,11 +62,15 @@ class Function_ extends Node\Stmt implements FunctionLike
         return $this->returnType;
     }
 
+    public function getAttrGroups() : array {
+        return $this->attrGroups;
+    }
+
     /** @return Node\Stmt[] */
     public function getStmts() : array {
         return $this->stmts;
     }
-    
+
     public function getType() : string {
         return 'Stmt_Function';
     }

lib/PhpParser/Node/Stmt/Interface_.php

@@ -14,8 +14,9 @@ class Interface_ extends ClassLike
      *
      * @param string|Node\Identifier $name Name
      * @param array  $subNodes   Array of the following optional subnodes:
-     *                           'extends' => array(): Name of extended interfaces
-     *                           'stmts'   => array(): Statements
+     *                           'extends'    => array(): Name of extended interfaces
+     *                           'stmts'      => array(): Statements
+     *                           'attrGroups' => array(): PHP attribute groups
      * @param array  $attributes Additional attributes
      */
     public function __construct($name, array $subNodes = [], array $attributes = []) {
@@ -23,10 +24,11 @@ class Interface_ extends ClassLike
         $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
         $this->extends = $subNodes['extends'] ?? [];
         $this->stmts = $subNodes['stmts'] ?? [];
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
     }
 
     public function getSubNodeNames() : array {
-        return ['name', 'extends', 'stmts'];
+        return ['attrGroups', 'name', 'extends', 'stmts'];
     }
 
     public function getType() : string {

lib/PhpParser/Node/Stmt/Property.php

@@ -16,6 +16,8 @@ class Property extends Node\Stmt
     public $props;
     /** @var null|Identifier|Name|NullableType|UnionType Type declaration */
     public $type;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public $attrGroups;
 
     /**
      * Constructs a class property list node.
@@ -24,16 +26,18 @@ class Property extends Node\Stmt
      * @param PropertyProperty[]                                 $props      Properties
      * @param array                                              $attributes Additional attributes
      * @param null|string|Identifier|Name|NullableType|UnionType $type       Type declaration
+     * @param Node\AttributeGroup[]                              $attrGroups PHP attribute groups
      */
-    public function __construct(int $flags, array $props, array $attributes = [], $type = null) {
+    public function __construct(int $flags, array $props, array $attributes = [], $type = null, array $attrGroups = []) {
         $this->attributes = $attributes;
         $this->flags = $flags;
         $this->props = $props;
         $this->type = \is_string($type) ? new Identifier($type) : $type;
+        $this->attrGroups = $attrGroups;
     }
 
     public function getSubNodeNames() : array {
-        return ['flags', 'type', 'props'];
+        return ['attrGroups', 'flags', 'type', 'props'];
     }
 
     /**
@@ -73,6 +77,15 @@ class Property extends Node\Stmt
         return (bool) ($this->flags & Class_::MODIFIER_STATIC);
     }
 
+    /**
+     * Whether the property is readonly.
+     *
+     * @return bool
+     */
+    public function isReadonly() : bool {
+        return (bool) ($this->flags & Class_::MODIFIER_READONLY);
+    }
+
     public function getType() : string {
         return 'Stmt_Property';
     }

lib/PhpParser/Node/Stmt/Throw_.php

@@ -10,7 +10,7 @@ class Throw_ extends Node\Stmt
     public $expr;
 
     /**
-     * Constructs a throw node.
+     * Constructs a legacy throw statement node.
      *
      * @param Node\Expr $expr       Expression
      * @param array     $attributes Additional attributes

lib/PhpParser/Node/Stmt/Trait_.php

@@ -11,17 +11,19 @@ class Trait_ extends ClassLike
      *
      * @param string|Node\Identifier $name Name
      * @param array  $subNodes   Array of the following optional subnodes:
-     *                           'stmts' => array(): Statements
+     *                           'stmts'      => array(): Statements
+     *                           'attrGroups' => array(): PHP attribute groups
      * @param array  $attributes Additional attributes
      */
     public function __construct($name, array $subNodes = [], array $attributes = []) {
         $this->attributes = $attributes;
         $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
         $this->stmts = $subNodes['stmts'] ?? [];
+        $this->attrGroups = $subNodes['attrGroups'] ?? [];
     }
 
     public function getSubNodeNames() : array {
-        return ['name', 'stmts'];
+        return ['attrGroups', 'name', 'stmts'];
     }
 
     public function getType() : string {

lib/PhpParser/NodeDumper.php

@@ -128,6 +128,9 @@ class NodeDumper
         if ($flags & Class_::MODIFIER_FINAL) {
             $strs[] = 'MODIFIER_FINAL';
         }
+        if ($flags & Class_::MODIFIER_READONLY) {
+            $strs[] = 'MODIFIER_READONLY';
+        }
 
         if ($strs) {
             return implode(' | ', $strs) . ' (' . $flags . ')';

lib/PhpParser/NodeVisitor/NameResolver.php

@@ -75,6 +75,7 @@ class NameResolver extends NodeVisitorAbstract
                 $interface = $this->resolveClassName($interface);
             }
 
+            $this->resolveAttrGroups($node);
             if (null !== $node->name) {
                 $this->addNamespacedName($node);
             }
@@ -83,25 +84,43 @@ class NameResolver extends NodeVisitorAbstract
                 $interface = $this->resolveClassName($interface);
             }
 
+            $this->resolveAttrGroups($node);
             $this->addNamespacedName($node);
+         } elseif ($node instanceof Stmt\Enum_) {
+            foreach ($node->implements as &$interface) {
+                $interface = $this->resolveClassName($interface);
+            }
+
+            $this->resolveAttrGroups($node);
+            if (null !== $node->name) {
+                $this->addNamespacedName($node);
+            }
         } elseif ($node instanceof Stmt\Trait_) {
+            $this->resolveAttrGroups($node);
             $this->addNamespacedName($node);
         } elseif ($node instanceof Stmt\Function_) {
-            $this->addNamespacedName($node);
             $this->resolveSignature($node);
+            $this->resolveAttrGroups($node);
+            $this->addNamespacedName($node);
         } elseif ($node instanceof Stmt\ClassMethod
                   || $node instanceof Expr\Closure
                   || $node instanceof Expr\ArrowFunction
         ) {
             $this->resolveSignature($node);
+            $this->resolveAttrGroups($node);
         } elseif ($node instanceof Stmt\Property) {
             if (null !== $node->type) {
                 $node->type = $this->resolveType($node->type);
             }
+            $this->resolveAttrGroups($node);
         } elseif ($node instanceof Stmt\Const_) {
             foreach ($node->consts as $const) {
                 $this->addNamespacedName($const);
             }
+        } else if ($node instanceof Stmt\ClassConst) {
+            $this->resolveAttrGroups($node);
+        } else if ($node instanceof Stmt\EnumCase) {
+            $this->resolveAttrGroups($node);
         } elseif ($node instanceof Expr\StaticCall
                   || $node instanceof Expr\StaticPropertyFetch
                   || $node instanceof Expr\ClassConstFetch
@@ -157,6 +176,7 @@ class NameResolver extends NodeVisitorAbstract
     private function resolveSignature($node) {
         foreach ($node->params as $param) {
             $param->type = $this->resolveType($param->type);
+            $this->resolveAttrGroups($param);
         }
         $node->returnType = $this->resolveType($node->returnType);
     }
@@ -225,4 +245,13 @@ class NameResolver extends NodeVisitorAbstract
         $node->namespacedName = Name::concat(
             $this->nameContext->getNamespace(), (string) $node->name);
     }
+
+    protected function resolveAttrGroups(Node $node)
+    {
+        foreach ($node->attrGroups as $attrGroup) {
+            foreach ($attrGroup->attrs as $attr) {
+                $attr->name = $this->resolveClassName($attr->name);
+            }
+        }
+    }
 }

lib/PhpParser/Parser/Tokens.php

@@ -6,99 +6,99 @@ namespace PhpParser\Parser;
 final class Tokens
 {
     const YYERRTOK = 256;
-    const T_INCLUDE = 257;
-    const T_INCLUDE_ONCE = 258;
-    const T_EVAL = 259;
-    const T_REQUIRE = 260;
-    const T_REQUIRE_ONCE = 261;
-    const T_LOGICAL_OR = 262;
-    const T_LOGICAL_XOR = 263;
-    const T_LOGICAL_AND = 264;
-    const T_PRINT = 265;
-    const T_YIELD = 266;
-    const T_DOUBLE_ARROW = 267;
-    const T_YIELD_FROM = 268;
-    const T_PLUS_EQUAL = 269;
-    const T_MINUS_EQUAL = 270;
-    const T_MUL_EQUAL = 271;
-    const T_DIV_EQUAL = 272;
-    const T_CONCAT_EQUAL = 273;
-    const T_MOD_EQUAL = 274;
-    const T_AND_EQUAL = 275;
-    const T_OR_EQUAL = 276;
-    const T_XOR_EQUAL = 277;
-    const T_SL_EQUAL = 278;
-    const T_SR_EQUAL = 279;
-    const T_POW_EQUAL = 280;
-    const T_COALESCE_EQUAL = 281;
-    const T_COALESCE = 282;
-    const T_BOOLEAN_OR = 283;
-    const T_BOOLEAN_AND = 284;
-    const T_IS_EQUAL = 285;
-    const T_IS_NOT_EQUAL = 286;
-    const T_IS_IDENTICAL = 287;
-    const T_IS_NOT_IDENTICAL = 288;
-    const T_SPACESHIP = 289;
-    const T_IS_SMALLER_OR_EQUAL = 290;
-    const T_IS_GREATER_OR_EQUAL = 291;
-    const T_SL = 292;
-    const T_SR = 293;
-    const T_INSTANCEOF = 294;
-    const T_INC = 295;
-    const T_DEC = 296;
-    const T_INT_CAST = 297;
-    const T_DOUBLE_CAST = 298;
-    const T_STRING_CAST = 299;
-    const T_ARRAY_CAST = 300;
-    const T_OBJECT_CAST = 301;
-    const T_BOOL_CAST = 302;
-    const T_UNSET_CAST = 303;
-    const T_POW = 304;
-    const T_NEW = 305;
-    const T_CLONE = 306;
-    const T_EXIT = 307;
-    const T_IF = 308;
-    const T_ELSEIF = 309;
-    const T_ELSE = 310;
-    const T_ENDIF = 311;
-    const T_LNUMBER = 312;
-    const T_DNUMBER = 313;
-    const T_STRING = 314;
-    const T_STRING_VARNAME = 315;
-    const T_VARIABLE = 316;
-    const T_NUM_STRING = 317;
-    const T_INLINE_HTML = 318;
-    const T_CHARACTER = 319;
-    const T_BAD_CHARACTER = 320;
-    const T_ENCAPSED_AND_WHITESPACE = 321;
-    const T_CONSTANT_ENCAPSED_STRING = 322;
-    const T_ECHO = 323;
-    const T_DO = 324;
-    const T_WHILE = 325;
-    const T_ENDWHILE = 326;
-    const T_FOR = 327;
-    const T_ENDFOR = 328;
-    const T_FOREACH = 329;
-    const T_ENDFOREACH = 330;
-    const T_DECLARE = 331;
-    const T_ENDDECLARE = 332;
-    const T_AS = 333;
-    const T_SWITCH = 334;
-    const T_MATCH = 335;
-    const T_ENDSWITCH = 336;
-    const T_CASE = 337;
-    const T_DEFAULT = 338;
-    const T_BREAK = 339;
-    const T_CONTINUE = 340;
-    const T_GOTO = 341;
-    const T_FUNCTION = 342;
-    const T_FN = 343;
-    const T_CONST = 344;
-    const T_RETURN = 345;
-    const T_TRY = 346;
-    const T_CATCH = 347;
-    const T_FINALLY = 348;
-    const T_THROW = 349;
+    const T_THROW = 257;
+    const T_INCLUDE = 258;
+    const T_INCLUDE_ONCE = 259;
+    const T_EVAL = 260;
+    const T_REQUIRE = 261;
+    const T_REQUIRE_ONCE = 262;
+    const T_LOGICAL_OR = 263;
+    const T_LOGICAL_XOR = 264;
+    const T_LOGICAL_AND = 265;
+    const T_PRINT = 266;
+    const T_YIELD = 267;
+    const T_DOUBLE_ARROW = 268;
+    const T_YIELD_FROM = 269;
+    const T_PLUS_EQUAL = 270;
+    const T_MINUS_EQUAL = 271;
+    const T_MUL_EQUAL = 272;
+    const T_DIV_EQUAL = 273;
+    const T_CONCAT_EQUAL = 274;
+    const T_MOD_EQUAL = 275;
+    const T_AND_EQUAL = 276;
+    const T_OR_EQUAL = 277;
+    const T_XOR_EQUAL = 278;
+    const T_SL_EQUAL = 279;
+    const T_SR_EQUAL = 280;
+    const T_POW_EQUAL = 281;
+    const T_COALESCE_EQUAL = 282;
+    const T_COALESCE = 283;
+    const T_BOOLEAN_OR = 284;
+    const T_BOOLEAN_AND = 285;
+    const T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG = 286;
+    const T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG = 287;
+    const T_IS_EQUAL = 288;
+    const T_IS_NOT_EQUAL = 289;
+    const T_IS_IDENTICAL = 290;
+    const T_IS_NOT_IDENTICAL = 291;
+    const T_SPACESHIP = 292;
+    const T_IS_SMALLER_OR_EQUAL = 293;
+    const T_IS_GREATER_OR_EQUAL = 294;
+    const T_SL = 295;
+    const T_SR = 296;
+    const T_INSTANCEOF = 297;
+    const T_INC = 298;
+    const T_DEC = 299;
+    const T_INT_CAST = 300;
+    const T_DOUBLE_CAST = 301;
+    const T_STRING_CAST = 302;
+    const T_ARRAY_CAST = 303;
+    const T_OBJECT_CAST = 304;
+    const T_BOOL_CAST = 305;
+    const T_UNSET_CAST = 306;
+    const T_POW = 307;
+    const T_NEW = 308;
+    const T_CLONE = 309;
+    const T_EXIT = 310;
+    const T_IF = 311;
+    const T_ELSEIF = 312;
+    const T_ELSE = 313;
+    const T_ENDIF = 314;
+    const T_LNUMBER = 315;
+    const T_DNUMBER = 316;
+    const T_STRING = 317;
+    const T_STRING_VARNAME = 318;
+    const T_VARIABLE = 319;
+    const T_NUM_STRING = 320;
+    const T_INLINE_HTML = 321;
+    const T_ENCAPSED_AND_WHITESPACE = 322;
+    const T_CONSTANT_ENCAPSED_STRING = 323;
+    const T_ECHO = 324;
+    const T_DO = 325;
+    const T_WHILE = 326;
+    const T_ENDWHILE = 327;
+    const T_FOR = 328;
+    const T_ENDFOR = 329;
+    const T_FOREACH = 330;
+    const T_ENDFOREACH = 331;
+    const T_DECLARE = 332;
+    const T_ENDDECLARE = 333;
+    const T_AS = 334;
+    const T_SWITCH = 335;
+    const T_MATCH = 336;
+    const T_ENDSWITCH = 337;
+    const T_CASE = 338;
+    const T_DEFAULT = 339;
+    const T_BREAK = 340;
+    const T_CONTINUE = 341;
+    const T_GOTO = 342;
+    const T_FUNCTION = 343;
+    const T_FN = 344;
+    const T_CONST = 345;
+    const T_RETURN = 346;
+    const T_TRY = 347;
+    const T_CATCH = 348;
+    const T_FINALLY = 349;
     const T_USE = 350;
     const T_INSTEADOF = 351;
     const T_GLOBAL = 352;
@@ -108,43 +108,41 @@ final class Tokens
     const T_PRIVATE = 356;
     const T_PROTECTED = 357;
     const T_PUBLIC = 358;
-    const T_VAR = 359;
-    const T_UNSET = 360;
-    const T_ISSET = 361;
-    const T_EMPTY = 362;
-    const T_HALT_COMPILER = 363;
-    const T_CLASS = 364;
-    const T_TRAIT = 365;
-    const T_INTERFACE = 366;
-    const T_EXTENDS = 367;
-    const T_IMPLEMENTS = 368;
-    const T_OBJECT_OPERATOR = 369;
-    const T_LIST = 370;
-    const T_ARRAY = 371;
-    const T_CALLABLE = 372;
-    const T_CLASS_C = 373;
-    const T_TRAIT_C = 374;
-    const T_METHOD_C = 375;
-    const T_FUNC_C = 376;
-    const T_LINE = 377;
-    const T_FILE = 378;
-    const T_COMMENT = 379;
-    const T_DOC_COMMENT = 380;
-    const T_OPEN_TAG = 381;
-    const T_OPEN_TAG_WITH_ECHO = 382;
-    const T_CLOSE_TAG = 383;
-    const T_WHITESPACE = 384;
-    const T_START_HEREDOC = 385;
-    const T_END_HEREDOC = 386;
-    const T_DOLLAR_OPEN_CURLY_BRACES = 387;
-    const T_CURLY_OPEN = 388;
-    const T_PAAMAYIM_NEKUDOTAYIM = 389;
-    const T_NAMESPACE = 390;
-    const T_NS_C = 391;
-    const T_DIR = 392;
-    const T_NS_SEPARATOR = 393;
-    const T_ELLIPSIS = 394;
-    const T_NAME_FULLY_QUALIFIED = 395;
-    const T_NAME_QUALIFIED = 396;
-    const T_NAME_RELATIVE = 397;
+    const T_READONLY = 359;
+    const T_VAR = 360;
+    const T_UNSET = 361;
+    const T_ISSET = 362;
+    const T_EMPTY = 363;
+    const T_HALT_COMPILER = 364;
+    const T_CLASS = 365;
+    const T_TRAIT = 366;
+    const T_INTERFACE = 367;
+    const T_ENUM = 368;
+    const T_EXTENDS = 369;
+    const T_IMPLEMENTS = 370;
+    const T_OBJECT_OPERATOR = 371;
+    const T_NULLSAFE_OBJECT_OPERATOR = 372;
+    const T_LIST = 373;
+    const T_ARRAY = 374;
+    const T_CALLABLE = 375;
+    const T_CLASS_C = 376;
+    const T_TRAIT_C = 377;
+    const T_METHOD_C = 378;
+    const T_FUNC_C = 379;
+    const T_LINE = 380;
+    const T_FILE = 381;
+    const T_START_HEREDOC = 382;
+    const T_END_HEREDOC = 383;
+    const T_DOLLAR_OPEN_CURLY_BRACES = 384;
+    const T_CURLY_OPEN = 385;
+    const T_PAAMAYIM_NEKUDOTAYIM = 386;
+    const T_NAMESPACE = 387;
+    const T_NS_C = 388;
+    const T_DIR = 389;
+    const T_NS_SEPARATOR = 390;
+    const T_ELLIPSIS = 391;
+    const T_NAME_FULLY_QUALIFIED = 392;
+    const T_NAME_QUALIFIED = 393;
+    const T_NAME_RELATIVE = 394;
+    const T_ATTRIBUTE = 395;
 }

lib/PhpParser/ParserAbstract.php

@@ -16,6 +16,7 @@ use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassConst;
 use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Enum_;
 use PhpParser\Node\Stmt\Interface_;
 use PhpParser\Node\Stmt\Namespace_;
 use PhpParser\Node\Stmt\Property;
@@ -60,7 +61,7 @@ abstract class ParserAbstract implements Parser
 
     /** @var int[] Map of states to a displacement into the $action table. The corresponding action for this
      *             state/symbol pair is $action[$actionBase[$state] + $symbol]. If $actionBase[$state] is 0, the
-                   action is defaulted, i.e. $actionDefault[$state] should be used instead. */
+     *             action is defaulted, i.e. $actionDefault[$state] should be used instead. */
     protected $actionBase;
     /** @var int[] Table of actions. Indexed according to $actionBase comment. */
     protected $action;
@@ -219,10 +220,7 @@ abstract class ParserAbstract implements Parser
                         ));
                     }
 
-                    // This is necessary to assign some meaningful attributes to /* empty */ productions. They'll get
-                    // the attributes of the next token, even though they don't contain it themselves.
-                    $this->startAttributeStack[$stackPos+1] = $startAttributes;
-                    $this->endAttributeStack[$stackPos+1] = $endAttributes;
+                    // Allow productions to access the start attributes of the lookahead token.
                     $this->lookaheadStartAttributes = $startAttributes;
 
                     //$this->traceRead($symbol);
@@ -294,7 +292,8 @@ abstract class ParserAbstract implements Parser
 
                     /* Goto - shift nonterminal */
                     $lastEndAttributes = $this->endAttributeStack[$stackPos];
-                    $stackPos -= $this->ruleToLength[$rule];
+                    $ruleLength = $this->ruleToLength[$rule];
+                    $stackPos -= $ruleLength;
                     $nonTerminal = $this->ruleToNonTerminal[$rule];
                     $idx = $this->gotoBase[$nonTerminal] + $stateStack[$stackPos];
                     if ($idx >= 0 && $idx < $this->gotoTableSize && $this->gotoCheck[$idx] === $nonTerminal) {
@@ -307,6 +306,10 @@ abstract class ParserAbstract implements Parser
                     $stateStack[$stackPos]     = $state;
                     $this->semStack[$stackPos] = $this->semValue;
                     $this->endAttributeStack[$stackPos] = $lastEndAttributes;
+                    if ($ruleLength === 0) {
+                        // Empty productions use the start attributes of the lookahead token.
+                        $this->startAttributeStack[$stackPos] = $this->lookaheadStartAttributes;
+                    }
                 } else {
                     /* error */
                     switch ($this->errorState) {
@@ -340,6 +343,7 @@ abstract class ParserAbstract implements Parser
 
                             // We treat the error symbol as being empty, so we reset the end attributes
                             // to the end attributes of the last non-error symbol
+                            $this->startAttributeStack[$stackPos] = $this->lookaheadStartAttributes;
                             $this->endAttributeStack[$stackPos] = $this->endAttributeStack[$stackPos - 1];
                             $this->endAttributes = $this->endAttributeStack[$stackPos - 1];
                             break;
@@ -659,6 +663,7 @@ abstract class ParserAbstract implements Parser
             'null'     => true,
             'false'    => true,
             'mixed'    => true,
+            'never'    => true,
         ];
 
         if (!$name->isUnqualified()) {
@@ -898,13 +903,6 @@ abstract class ParserAbstract implements Parser
     }
 
     protected function checkNamespace(Namespace_ $node) {
-        if ($node->name && $node->name->isSpecialClassName()) {
-            $this->emitError(new Error(
-                sprintf('Cannot use \'%s\' as namespace name', $node->name),
-                $node->name->getAttributes()
-            ));
-        }
-
         if (null !== $node->stmts) {
             foreach ($node->stmts as $stmt) {
                 if ($stmt instanceof Namespace_) {
@@ -916,22 +914,17 @@ abstract class ParserAbstract implements Parser
         }
     }
 
-    protected function checkClass(Class_ $node, $namePos) {
-        if (null !== $node->name && $node->name->isSpecialClassName()) {
+    private function checkClassName($name, $namePos) {
+        if (null !== $name && $name->isSpecialClassName()) {
             $this->emitError(new Error(
-                sprintf('Cannot use \'%s\' as class name as it is reserved', $node->name),
+                sprintf('Cannot use \'%s\' as class name as it is reserved', $name),
                 $this->getAttributesAt($namePos)
             ));
         }
+    }
 
-        if ($node->extends && $node->extends->isSpecialClassName()) {
-            $this->emitError(new Error(
-                sprintf('Cannot use \'%s\' as class name as it is reserved', $node->extends),
-                $node->extends->getAttributes()
-            ));
-        }
-
-        foreach ($node->implements as $interface) {
+    private function checkImplementedInterfaces(array $interfaces) {
+        foreach ($interfaces as $interface) {
             if ($interface->isSpecialClassName()) {
                 $this->emitError(new Error(
                     sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
@@ -941,22 +934,27 @@ abstract class ParserAbstract implements Parser
         }
     }
 
-    protected function checkInterface(Interface_ $node, $namePos) {
-        if (null !== $node->name && $node->name->isSpecialClassName()) {
+    protected function checkClass(Class_ $node, $namePos) {
+        $this->checkClassName($node->name, $namePos);
+
+        if ($node->extends && $node->extends->isSpecialClassName()) {
             $this->emitError(new Error(
-                sprintf('Cannot use \'%s\' as class name as it is reserved', $node->name),
-                $this->getAttributesAt($namePos)
+                sprintf('Cannot use \'%s\' as class name as it is reserved', $node->extends),
+                $node->extends->getAttributes()
             ));
         }
 
-        foreach ($node->extends as $interface) {
-            if ($interface->isSpecialClassName()) {
-                $this->emitError(new Error(
-                    sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
-                    $interface->getAttributes()
-                ));
-            }
-        }
+        $this->checkImplementedInterfaces($node->implements);
+    }
+
+    protected function checkInterface(Interface_ $node, $namePos) {
+        $this->checkClassName($node->name, $namePos);
+        $this->checkImplementedInterfaces($node->extends);
+    }
+
+    protected function checkEnum(Enum_ $node, $namePos) {
+        $this->checkClassName($node->name, $namePos);
+        $this->checkImplementedInterfaces($node->implements);
     }
 
     protected function checkClassMethod(ClassMethod $node, $modifierPos) {
@@ -979,6 +977,12 @@ abstract class ParserAbstract implements Parser
                     break;
             }
         }
+
+        if ($node->flags & Class_::MODIFIER_READONLY) {
+            $this->emitError(new Error(
+                sprintf('Method %s() cannot be readonly', $node->name),
+                $this->getAttributesAt($modifierPos)));
+        }
     }
 
     protected function checkClassConst(ClassConst $node, $modifierPos) {
@@ -992,9 +996,9 @@ abstract class ParserAbstract implements Parser
                 "Cannot use 'abstract' as constant modifier",
                 $this->getAttributesAt($modifierPos)));
         }
-        if ($node->flags & Class_::MODIFIER_FINAL) {
+        if ($node->flags & Class_::MODIFIER_READONLY) {
             $this->emitError(new Error(
-                "Cannot use 'final' as constant modifier",
+                "Cannot use 'readonly' as constant modifier",
                 $this->getAttributesAt($modifierPos)));
         }
     }

lib/PhpParser/PrettyPrinter/Standard.php

@@ -18,7 +18,8 @@ class Standard extends PrettyPrinterAbstract
     // Special nodes
 
     protected function pParam(Node\Param $node) {
-        return ($this->pModifiers($node->flags))
+        return $this->pAttrGroups($node->attrGroups, true)
+             . $this->pModifiers($node->flags)
              . ($node->type ? $this->p($node->type) . ' ' : '')
              . ($node->byRef ? '&' : '')
              . ($node->variadic ? '...' : '')
@@ -27,7 +28,9 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pArg(Node\Arg $node) {
-        return ($node->byRef ? '&' : '') . ($node->unpack ? '...' : '') . $this->p($node->value);
+        return ($node->name ? $node->name->toString() . ': ' : '')
+             . ($node->byRef ? '&' : '') . ($node->unpack ? '...' : '')
+             . $this->p($node->value);
     }
 
     protected function pConst(Node\Const_ $node) {
@@ -50,6 +53,15 @@ class Standard extends PrettyPrinterAbstract
         return '$' . $node->name;
     }
 
+    protected function pAttribute(Node\Attribute $node) {
+        return $this->p($node->name)
+             . ($node->args ? '(' . $this->pCommaSeparated($node->args) . ')' : '');
+    }
+
+    protected function pAttributeGroup(Node\AttributeGroup $node) {
+        return '#[' . $this->pCommaSeparated($node->attrs) . ']';
+    }
+
     // Names
 
     protected function pName(Name $node) {
@@ -385,7 +397,10 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pExpr_Instanceof(Expr\Instanceof_ $node) {
-        return $this->pInfixOp(Expr\Instanceof_::class, $node->expr, ' instanceof ', $node->class);
+        list($precedence, $associativity) = $this->precedenceMap[Expr\Instanceof_::class];
+        return $this->pPrec($node->expr, $precedence, $associativity, -1)
+             . ' instanceof '
+             . $this->pNewVariable($node->class);
     }
 
     // Unary expressions
@@ -492,6 +507,11 @@ class Standard extends PrettyPrinterAbstract
              . '(' . $this->pMaybeMultiline($node->args) . ')';
     }
 
+    protected function pExpr_NullsafeMethodCall(Expr\NullsafeMethodCall $node) {
+        return $this->pDereferenceLhs($node->var) . '?->' . $this->pObjectProperty($node->name)
+            . '(' . $this->pMaybeMultiline($node->args) . ')';
+    }
+
     protected function pExpr_StaticCall(Expr\StaticCall $node) {
         return $this->pDereferenceLhs($node->class) . '::'
              . ($node->name instanceof Expr
@@ -570,13 +590,17 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pExpr_ClassConstFetch(Expr\ClassConstFetch $node) {
-        return $this->p($node->class) . '::' . $this->p($node->name);
+        return $this->pDereferenceLhs($node->class) . '::' . $this->p($node->name);
     }
 
     protected function pExpr_PropertyFetch(Expr\PropertyFetch $node) {
         return $this->pDereferenceLhs($node->var) . '->' . $this->pObjectProperty($node->name);
     }
 
+    protected function pExpr_NullsafePropertyFetch(Expr\NullsafePropertyFetch $node) {
+        return $this->pDereferenceLhs($node->var) . '?->' . $this->pObjectProperty($node->name);
+    }
+
     protected function pExpr_StaticPropertyFetch(Expr\StaticPropertyFetch $node) {
         return $this->pDereferenceLhs($node->class) . '::$' . $this->pObjectProperty($node->name);
     }
@@ -586,7 +610,8 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pExpr_Closure(Expr\Closure $node) {
-        return ($node->static ? 'static ' : '')
+        return $this->pAttrGroups($node->attrGroups, true)
+             . ($node->static ? 'static ' : '')
              . 'function ' . ($node->byRef ? '&' : '')
              . '(' . $this->pCommaSeparated($node->params) . ')'
              . (!empty($node->uses) ? ' use(' . $this->pCommaSeparated($node->uses) . ')' : '')
@@ -607,7 +632,8 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pExpr_ArrowFunction(Expr\ArrowFunction $node) {
-        return ($node->static ? 'static ' : '')
+        return $this->pAttrGroups($node->attrGroups, true)
+            . ($node->static ? 'static ' : '')
             . 'fn' . ($node->byRef ? '&' : '')
             . '(' . $this->pCommaSeparated($node->params) . ')'
             . (null !== $node->returnType ? ': ' . $this->p($node->returnType) : '')
@@ -624,7 +650,8 @@ class Standard extends PrettyPrinterAbstract
             $args = $node->args ? '(' . $this->pMaybeMultiline($node->args) . ')' : '';
             return 'new ' . $this->pClassCommon($node->class, $args);
         }
-        return 'new ' . $this->p($node->class) . '(' . $this->pMaybeMultiline($node->args) . ')';
+        return 'new ' . $this->pNewVariable($node->class)
+            . '(' . $this->pMaybeMultiline($node->args) . ')';
     }
 
     protected function pExpr_Clone(Expr\Clone_ $node) {
@@ -645,6 +672,10 @@ class Standard extends PrettyPrinterAbstract
              . (null !== $node->expr ? '(' . $this->p($node->expr) . ')' : '');
     }
 
+    protected function pExpr_Throw(Expr\Throw_ $node) {
+        return 'throw ' . $this->p($node->expr);
+    }
+
     protected function pExpr_Yield(Expr\Yield_ $node) {
         if ($node->value === null) {
             return 'yield';
@@ -690,20 +721,37 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pStmt_Interface(Stmt\Interface_ $node) {
-        return 'interface ' . $node->name
+        return $this->pAttrGroups($node->attrGroups)
+             . 'interface ' . $node->name
              . (!empty($node->extends) ? ' extends ' . $this->pCommaSeparated($node->extends) : '')
              . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
     }
 
+    protected function pStmt_Enum(Stmt\Enum_ $node) {
+        return $this->pAttrGroups($node->attrGroups)
+             . 'enum ' . $node->name
+             . ($node->scalarType ? " : $node->scalarType" : '')
+             . (!empty($node->implements) ? ' implements ' . $this->pCommaSeparated($node->implements) : '')
+             . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
+    }
+
     protected function pStmt_Class(Stmt\Class_ $node) {
         return $this->pClassCommon($node, ' ' . $node->name);
     }
 
     protected function pStmt_Trait(Stmt\Trait_ $node) {
-        return 'trait ' . $node->name
+        return $this->pAttrGroups($node->attrGroups)
+             . 'trait ' . $node->name
              . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
     }
 
+    protected function pStmt_EnumCase(Stmt\EnumCase $node) {
+        return $this->pAttrGroups($node->attrGroups)
+             . 'case ' . $node->name
+             . ($node->expr ? ' = ' . $this->p($node->expr) : '')
+             . ';';
+    }
+
     protected function pStmt_TraitUse(Stmt\TraitUse $node) {
         return 'use ' . $this->pCommaSeparated($node->traits)
              . (empty($node->adaptations)
@@ -725,7 +773,8 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pStmt_Property(Stmt\Property $node) {
-        return (0 === $node->flags ? 'var ' : $this->pModifiers($node->flags))
+        return $this->pAttrGroups($node->attrGroups)
+            . (0 === $node->flags ? 'var ' : $this->pModifiers($node->flags))
             . ($node->type ? $this->p($node->type) . ' ' : '')
             . $this->pCommaSeparated($node->props) . ';';
     }
@@ -736,7 +785,8 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pStmt_ClassMethod(Stmt\ClassMethod $node) {
-        return $this->pModifiers($node->flags)
+        return $this->pAttrGroups($node->attrGroups)
+             . $this->pModifiers($node->flags)
              . 'function ' . ($node->byRef ? '&' : '') . $node->name
              . '(' . $this->pMaybeMultiline($node->params) . ')'
              . (null !== $node->returnType ? ' : ' . $this->p($node->returnType) : '')
@@ -746,12 +796,14 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pStmt_ClassConst(Stmt\ClassConst $node) {
-        return $this->pModifiers($node->flags)
+        return $this->pAttrGroups($node->attrGroups)
+             . $this->pModifiers($node->flags)
              . 'const ' . $this->pCommaSeparated($node->consts) . ';';
     }
 
     protected function pStmt_Function(Stmt\Function_ $node) {
-        return 'function ' . ($node->byRef ? '&' : '') . $node->name
+        return $this->pAttrGroups($node->attrGroups)
+             . 'function ' . ($node->byRef ? '&' : '') . $node->name
              . '(' . $this->pCommaSeparated($node->params) . ')'
              . (null !== $node->returnType ? ' : ' . $this->p($node->returnType) : '')
              . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
@@ -906,11 +958,12 @@ class Standard extends PrettyPrinterAbstract
     // Helpers
 
     protected function pClassCommon(Stmt\Class_ $node, $afterClassToken) {
-        return $this->pModifiers($node->flags)
-        . 'class' . $afterClassToken
-        . (null !== $node->extends ? ' extends ' . $this->p($node->extends) : '')
-        . (!empty($node->implements) ? ' implements ' . $this->pCommaSeparated($node->implements) : '')
-        . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
+        return $this->pAttrGroups($node->attrGroups, $node->name === null)
+            . $this->pModifiers($node->flags)
+            . 'class' . $afterClassToken
+            . (null !== $node->extends ? ' extends ' . $this->p($node->extends) : '')
+            . (!empty($node->implements) ? ' implements ' . $this->pCommaSeparated($node->implements) : '')
+            . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
     }
 
     protected function pObjectProperty($node) {
@@ -946,14 +999,27 @@ class Standard extends PrettyPrinterAbstract
             $escaped = addcslashes($string, "\n\r\t\f\v$" . $quote . "\\");
         }
 
-        // Escape other control characters
-        return preg_replace_callback('/([\0-\10\16-\37])(?=([0-7]?))/', function ($matches) {
-            $oct = decoct(ord($matches[1]));
-            if ($matches[2] !== '') {
-                // If there is a trailing digit, use the full three character form
-                return '\\' . str_pad($oct, 3, '0', \STR_PAD_LEFT);
-            }
-            return '\\' . $oct;
+        // Escape control characters and non-UTF-8 characters.
+        // Regex based on https://stackoverflow.com/a/11709412/385378.
+        $regex = '/(
+              [\x00-\x08\x0E-\x1F] # Control characters
+            | [\xC0-\xC1] # Invalid UTF-8 Bytes
+            | [\xF5-\xFF] # Invalid UTF-8 Bytes
+            | \xE0(?=[\x80-\x9F]) # Overlong encoding of prior code point
+            | \xF0(?=[\x80-\x8F]) # Overlong encoding of prior code point
+            | [\xC2-\xDF](?![\x80-\xBF]) # Invalid UTF-8 Sequence Start
+            | [\xE0-\xEF](?![\x80-\xBF]{2}) # Invalid UTF-8 Sequence Start
+            | [\xF0-\xF4](?![\x80-\xBF]{3}) # Invalid UTF-8 Sequence Start
+            | (?<=[\x00-\x7F\xF5-\xFF])[\x80-\xBF] # Invalid UTF-8 Sequence Middle
+            | (?<![\xC2-\xDF]|[\xE0-\xEF]|[\xE0-\xEF][\x80-\xBF]|[\xF0-\xF4]|[\xF0-\xF4][\x80-\xBF]|[\xF0-\xF4][\x80-\xBF]{2})[\x80-\xBF] # Overlong Sequence
+            | (?<=[\xE0-\xEF])[\x80-\xBF](?![\x80-\xBF]) # Short 3 byte sequence
+            | (?<=[\xF0-\xF4])[\x80-\xBF](?![\x80-\xBF]{2}) # Short 4 byte sequence
+            | (?<=[\xF0-\xF4][\x80-\xBF])[\x80-\xBF](?![\x80-\xBF]) # Short 4 byte sequence (2)
+        )/x';
+        return preg_replace_callback($regex, function ($matches) {
+            assert(strlen($matches[0]) === 1);
+            $hex = dechex(ord($matches[0]));;
+            return '\\x' . str_pad($hex, 2, '0', \STR_PAD_LEFT);
         }, $escaped);
     }
 
@@ -993,11 +1059,16 @@ class Standard extends PrettyPrinterAbstract
         }
     }
 
+    protected function pNewVariable(Node $node) {
+        // TODO: This is not fully accurate.
+        return $this->pDereferenceLhs($node);
+    }
+
     /**
      * @param Node[] $nodes
      * @return bool
      */
-    private function hasNodeWithComments(array $nodes) {
+    protected function hasNodeWithComments(array $nodes) {
         foreach ($nodes as $node) {
             if ($node && $node->getComments()) {
                 return true;
@@ -1006,11 +1077,21 @@ class Standard extends PrettyPrinterAbstract
         return false;
     }
 
-    private function pMaybeMultiline(array $nodes, $trailingComma = false) {
+    protected function pMaybeMultiline(array $nodes, bool $trailingComma = false) {
         if (!$this->hasNodeWithComments($nodes)) {
             return $this->pCommaSeparated($nodes);
         } else {
             return $this->pCommaSeparatedMultiline($nodes, $trailingComma) . $this->nl;
         }
     }
+
+    protected function pAttrGroups(array $nodes, bool $inline = false): string {
+        $result = '';
+        $sep = $inline ? ' ' : $this->nl;
+        foreach ($nodes as $node) {
+            $result .= $this->p($node) . $sep;
+        }
+
+        return $result;
+    }
 }

lib/PhpParser/PrettyPrinterAbstract.php

@@ -66,7 +66,7 @@ abstract class PrettyPrinterAbstract
         BinaryOp\BooleanAnd::class     => [120, -1],
         BinaryOp\BooleanOr::class      => [130, -1],
         BinaryOp\Coalesce::class       => [140,  1],
-        Expr\Ternary::class            => [150, -1],
+        Expr\Ternary::class            => [150,  0],
         // parser uses %left for assignments, but they really behave as %right
         Expr\Assign::class             => [160,  1],
         Expr\AssignRef::class          => [160,  1],
@@ -704,8 +704,10 @@ abstract class PrettyPrinterAbstract
 
         $mapKey = $parentNodeType . '->' . $subNodeName;
         $insertStr = $this->listInsertionMap[$mapKey] ?? null;
+        $isStmtList = $subNodeName === 'stmts';
 
         $beforeFirstKeepOrReplace = true;
+        $skipRemovedNode = false;
         $delayedAdd = [];
         $lastElemIndentLevel = $this->indentLevel;
 
@@ -715,7 +717,7 @@ abstract class PrettyPrinterAbstract
             $insertNewline = true;
         }
 
-        if ($subNodeName === 'stmts' && \count($origNodes) === 1 && \count($nodes) !== 1) {
+        if ($isStmtList && \count($origNodes) === 1 && \count($nodes) !== 1) {
             $startPos = $origNodes[0]->getStartTokenPos();
             $endPos = $origNodes[0]->getEndTokenPos();
             \assert($startPos >= 0 && $endPos >= 0);
@@ -754,7 +756,7 @@ abstract class PrettyPrinterAbstract
 
                 $itemStartPos = $origArrItem->getStartTokenPos();
                 $itemEndPos = $origArrItem->getEndTokenPos();
-                \assert($itemStartPos >= 0 && $itemEndPos >= 0);
+                \assert($itemStartPos >= 0 && $itemEndPos >= 0 && $itemStartPos >= $pos);
 
                 $origIndentLevel = $this->indentLevel;
                 $lastElemIndentLevel = $this->origTokens->getIndentationBefore($itemStartPos) + $indentAdjustment;
@@ -765,16 +767,25 @@ abstract class PrettyPrinterAbstract
                 $commentStartPos = $origComments ? $origComments[0]->getStartTokenPos() : $itemStartPos;
                 \assert($commentStartPos >= 0);
 
-                $commentsChanged = $comments !== $origComments;
-                if ($commentsChanged) {
-                    // Remove old comments
-                    $itemStartPos = $commentStartPos;
+                if ($commentStartPos < $pos) {
+                    // Comments may be assigned to multiple nodes if they start at the same position.
+                    // Make sure we don't try to print them multiple times.
+                    $commentStartPos = $itemStartPos;
+                }
+
+                if ($skipRemovedNode) {
+                    if ($isStmtList && $this->origTokens->haveBracesInRange($pos, $itemStartPos)) {
+                        // We'd remove the brace of a code block.
+                        // TODO: Preserve formatting.
+                        $this->setIndentLevel($origIndentLevel);
+                        return null;
+                    }
+                } else {
+                    $result .= $this->origTokens->getTokenCode(
+                        $pos, $commentStartPos, $indentAdjustment);
                 }
 
                 if (!empty($delayedAdd)) {
-                    $result .= $this->origTokens->getTokenCode(
-                        $pos, $commentStartPos, $indentAdjustment);
-
                     /** @var Node $delayedAddNode */
                     foreach ($delayedAdd as $delayedAddNode) {
                         if ($insertNewline) {
@@ -793,19 +804,20 @@ abstract class PrettyPrinterAbstract
                         }
                     }
 
-                    $result .= $this->origTokens->getTokenCode(
-                        $commentStartPos, $itemStartPos, $indentAdjustment);
-
                     $delayedAdd = [];
+                }
+
+                if ($comments !== $origComments) {
+                    if ($comments) {
+                        $result .= $this->pComments($comments) . $this->nl;
+                    }
                 } else {
                     $result .= $this->origTokens->getTokenCode(
-                        $pos, $itemStartPos, $indentAdjustment);
+                        $commentStartPos, $itemStartPos, $indentAdjustment);
                 }
 
-                if ($commentsChanged && $comments) {
-                    // Add new comments
-                    $result .= $this->pComments($comments) . $this->nl;
-                }
+                // If we had to remove anything, we have done so now.
+                $skipRemovedNode = false;
             } elseif ($diffType === DiffElem::TYPE_ADD) {
                 if (null === $insertStr) {
                     // We don't have insertion information for this list type
@@ -839,18 +851,34 @@ abstract class PrettyPrinterAbstract
                     $result .= $insertStr;
                 }
             } elseif ($diffType === DiffElem::TYPE_REMOVE) {
-                if ($i === 0) {
-                    // TODO Handle removal at the start
-                    return null;
-                }
-
                 if (!$origArrItem instanceof Node) {
                     // We only support removal for nodes
                     return null;
                 }
 
+                $itemStartPos = $origArrItem->getStartTokenPos();
                 $itemEndPos = $origArrItem->getEndTokenPos();
-                \assert($itemEndPos >= 0);
+                \assert($itemStartPos >= 0 && $itemEndPos >= 0);
+
+                // Consider comments part of the node.
+                $origComments = $origArrItem->getComments();
+                if ($origComments) {
+                    $itemStartPos = $origComments[0]->getStartTokenPos();
+                }
+
+                if ($i === 0) {
+                    // If we're removing from the start, keep the tokens before the node and drop those after it,
+                    // instead of the other way around.
+                    $result .= $this->origTokens->getTokenCode(
+                        $pos, $itemStartPos, $indentAdjustment);
+                    $skipRemovedNode = true;
+                } else {
+                    if ($isStmtList && $this->origTokens->haveBracesInRange($pos, $itemStartPos)) {
+                        // We'd remove the brace of a code block.
+                        // TODO: Preserve formatting.
+                        return null;
+                    }
+                }
 
                 $pos = $itemEndPos + 1;
                 continue;
@@ -869,6 +897,11 @@ abstract class PrettyPrinterAbstract
             $pos = $itemEndPos + 1;
         }
 
+        if ($skipRemovedNode) {
+            // TODO: Support removing single node.
+            return null;
+        }
+
         if (!empty($delayedAdd)) {
             if (!isset($this->emptyListInsertionMap[$mapKey])) {
                 return null;
@@ -999,6 +1032,7 @@ abstract class PrettyPrinterAbstract
             || $node instanceof Expr\ArrayDimFetch
             || $node instanceof Expr\FuncCall
             || $node instanceof Expr\MethodCall
+            || $node instanceof Expr\NullsafeMethodCall
             || $node instanceof Expr\StaticCall
             || $node instanceof Expr\Array_);
     }
@@ -1015,9 +1049,11 @@ abstract class PrettyPrinterAbstract
             || $node instanceof Node\Name
             || $node instanceof Expr\ArrayDimFetch
             || $node instanceof Expr\PropertyFetch
+            || $node instanceof Expr\NullsafePropertyFetch
             || $node instanceof Expr\StaticPropertyFetch
             || $node instanceof Expr\FuncCall
             || $node instanceof Expr\MethodCall
+            || $node instanceof Expr\NullsafeMethodCall
             || $node instanceof Expr\StaticCall
             || $node instanceof Expr\Array_
             || $node instanceof Scalar\String_
@@ -1038,7 +1074,8 @@ abstract class PrettyPrinterAbstract
              . ($modifiers & Stmt\Class_::MODIFIER_PRIVATE   ? 'private '   : '')
              . ($modifiers & Stmt\Class_::MODIFIER_STATIC    ? 'static '    : '')
              . ($modifiers & Stmt\Class_::MODIFIER_ABSTRACT  ? 'abstract '  : '')
-             . ($modifiers & Stmt\Class_::MODIFIER_FINAL     ? 'final '     : '');
+             . ($modifiers & Stmt\Class_::MODIFIER_FINAL     ? 'final '     : '')
+             . ($modifiers & Stmt\Class_::MODIFIER_READONLY  ? 'readonly '  : '');
     }
 
     /**
@@ -1087,7 +1124,8 @@ abstract class PrettyPrinterAbstract
         for ($i = 0; $i < 256; $i++) {
             // Since PHP 7.1 The lower range is 0x80. However, we also want to support code for
             // older versions.
-            $this->labelCharMap[chr($i)] = $i >= 0x7f || ctype_alnum($i);
+            $chr = chr($i);
+            $this->labelCharMap[$chr] = $i >= 0x7f || ctype_alnum($chr);
         }
     }
 
@@ -1124,7 +1162,7 @@ abstract class PrettyPrinterAbstract
             Expr\PostDec::class => ['var' => self::FIXUP_PREC_LEFT],
             Expr\Instanceof_::class => [
                 'expr' => self::FIXUP_PREC_LEFT,
-                'class' => self::FIXUP_PREC_RIGHT,
+                'class' => self::FIXUP_PREC_RIGHT, // TODO: FIXUP_NEW_VARIABLE
             ],
             Expr\Ternary::class => [
                 'cond' => self::FIXUP_PREC_LEFT,
@@ -1134,10 +1172,16 @@ abstract class PrettyPrinterAbstract
             Expr\FuncCall::class => ['name' => self::FIXUP_CALL_LHS],
             Expr\StaticCall::class => ['class' => self::FIXUP_DEREF_LHS],
             Expr\ArrayDimFetch::class => ['var' => self::FIXUP_DEREF_LHS],
+            Expr\ClassConstFetch::class => ['var' => self::FIXUP_DEREF_LHS],
+            Expr\New_::class => ['class' => self::FIXUP_DEREF_LHS], // TODO: FIXUP_NEW_VARIABLE
             Expr\MethodCall::class => [
                 'var' => self::FIXUP_DEREF_LHS,
                 'name' => self::FIXUP_BRACED_NAME,
             ],
+            Expr\NullsafeMethodCall::class => [
+                'var' => self::FIXUP_DEREF_LHS,
+                'name' => self::FIXUP_BRACED_NAME,
+            ],
             Expr\StaticPropertyFetch::class => [
                 'class' => self::FIXUP_DEREF_LHS,
                 'name' => self::FIXUP_VAR_BRACED_NAME,
@@ -1146,6 +1190,10 @@ abstract class PrettyPrinterAbstract
                 'var' => self::FIXUP_DEREF_LHS,
                 'name' => self::FIXUP_BRACED_NAME,
             ],
+            Expr\NullsafePropertyFetch::class => [
+                'var' => self::FIXUP_DEREF_LHS,
+                'name' => self::FIXUP_BRACED_NAME,
+            ],
             Scalar\Encapsed::class => [
                 'parts' => self::FIXUP_ENCAPSED,
             ],
@@ -1196,7 +1244,7 @@ abstract class PrettyPrinterAbstract
     /**
      * Lazily initializes the removal map.
      *
-     * The removal map is used to determine which additional tokens should be returned when a
+     * The removal map is used to determine which additional tokens should be removed when a
      * certain node is replaced by null.
      */
     protected function initializeRemovalMap() {
@@ -1223,6 +1271,8 @@ abstract class PrettyPrinterAbstract
             'Stmt_Catch->var' => $stripLeft,
             'Stmt_ClassMethod->returnType' => $stripColon,
             'Stmt_Class->extends' => ['left' => \T_EXTENDS],
+            'Stmt_Enum->scalarType' => $stripColon,
+            'Stmt_EnumCase->expr' => $stripEquals,
             'Expr_PrintableNewAnonClass->extends' => ['left' => \T_EXTENDS],
             'Stmt_Continue->num' => $stripBoth,
             'Stmt_Foreach->keyVar' => $stripDoubleArrow,
@@ -1261,6 +1311,8 @@ abstract class PrettyPrinterAbstract
             'Stmt_Catch->var' => [null, false, ' ', null],
             'Stmt_ClassMethod->returnType' => [')', false, ' : ', null],
             'Stmt_Class->extends' => [null, false, ' extends ', null],
+            'Stmt_Enum->scalarType' => [null, false, ' : ', null],
+            'Stmt_EnumCase->expr' => [null, false, ' = ', null],
             'Expr_PrintableNewAnonClass->extends' => [null, ' extends ', null],
             'Stmt_Continue->num' => [\T_CONTINUE, false, ' ', null],
             'Stmt_Foreach->keyVar' => [\T_AS, false, null, ' => '],
@@ -1303,12 +1355,14 @@ abstract class PrettyPrinterAbstract
             'Expr_Isset->vars' => ', ',
             'Expr_List->items' => ', ',
             'Expr_MethodCall->args' => ', ',
+            'Expr_NullsafeMethodCall->args' => ', ',
             'Expr_New->args' => ', ',
             'Expr_PrintableNewAnonClass->args' => ', ',
             'Expr_StaticCall->args' => ', ',
             'Stmt_ClassConst->consts' => ', ',
             'Stmt_ClassMethod->params' => ', ',
             'Stmt_Class->implements' => ', ',
+            'Stmt_Enum->implements' => ', ',
             'Expr_PrintableNewAnonClass->implements' => ', ',
             'Stmt_Const->consts' => ', ',
             'Stmt_Declare->declares' => ', ',
@@ -1328,12 +1382,14 @@ abstract class PrettyPrinterAbstract
             'Stmt_Unset->vars' => ', ',
             'Stmt_Use->uses' => ', ',
             'MatchArm->conds' => ', ',
+            'AttributeGroup->attrs' => ', ',
 
             // statement lists
             'Expr_Closure->stmts' => "\n",
             'Stmt_Case->stmts' => "\n",
             'Stmt_Catch->stmts' => "\n",
             'Stmt_Class->stmts' => "\n",
+            'Stmt_Enum->stmts' => "\n",
             'Expr_PrintableNewAnonClass->stmts' => "\n",
             'Stmt_Interface->stmts' => "\n",
             'Stmt_Trait->stmts' => "\n",
@@ -1348,6 +1404,19 @@ abstract class PrettyPrinterAbstract
             'Stmt_Function->stmts' => "\n",
             'Stmt_If->stmts' => "\n",
             'Stmt_Namespace->stmts' => "\n",
+            'Stmt_Class->attrGroups' => "\n",
+            'Stmt_Enum->attrGroups' => "\n",
+            'Stmt_EnumCase->attrGroups' => "\n",
+            'Stmt_Interface->attrGroups' => "\n",
+            'Stmt_Trait->attrGroups' => "\n",
+            'Stmt_Function->attrGroups' => "\n",
+            'Stmt_ClassMethod->attrGroups' => "\n",
+            'Stmt_ClassConst->attrGroups' => "\n",
+            'Stmt_Property->attrGroups' => "\n",
+            'Expr_PrintableNewAnonClass->attrGroups' => ' ',
+            'Expr_Closure->attrGroups' => ' ',
+            'Expr_ArrowFunction->attrGroups' => ' ',
+            'Param->attrGroups' => ' ',
             'Stmt_Switch->cases' => "\n",
             'Stmt_TraitUse->adaptations' => "\n",
             'Stmt_TryCatch->stmts' => "\n",
@@ -1370,11 +1439,13 @@ abstract class PrettyPrinterAbstract
             'Expr_Closure->params' => ['(', '', ''],
             'Expr_FuncCall->args' => ['(', '', ''],
             'Expr_MethodCall->args' => ['(', '', ''],
+            'Expr_NullsafeMethodCall->args' => ['(', '', ''],
             'Expr_New->args' => ['(', '', ''],
             'Expr_PrintableNewAnonClass->args' => ['(', '', ''],
             'Expr_PrintableNewAnonClass->implements' => [null, ' implements ', ''],
             'Expr_StaticCall->args' => ['(', '', ''],
             'Stmt_Class->implements' => [null, ' implements ', ''],
+            'Stmt_Enum->implements' => [null, ' implements ', ''],
             'Stmt_ClassMethod->params' => ['(', '', ''],
             'Stmt_Interface->extends' => [null, ' extends ', ''],
             'Stmt_Function->params' => ['(', '', ''],

test/PhpParser/Builder/ClassConstTest.php

@@ -0,0 +1,209 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Builder;
+
+use PhpParser\Comment;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
+use PhpParser\Node\Const_;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar;
+use PhpParser\Node\Scalar\LNumber;
+use PhpParser\Node\Stmt;
+
+class ClassConstTest extends \PHPUnit\Framework\TestCase
+{
+    public function createClassConstBuilder($name, $value) {
+        return new ClassConst($name, $value);
+    }
+
+    public function testModifiers() {
+        $node = $this->createClassConstBuilder("TEST", 1)
+            ->makePrivate()
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new Stmt\ClassConst(
+                [
+                    new Const_("TEST", new LNumber(1))
+                ],
+                Stmt\Class_::MODIFIER_PRIVATE
+            ),
+            $node
+        );
+
+        $node = $this->createClassConstBuilder("TEST", 1)
+            ->makeProtected()
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new Stmt\ClassConst(
+                [
+                    new Const_("TEST", new LNumber(1) )
+                ],
+                Stmt\Class_::MODIFIER_PROTECTED
+            ),
+            $node
+        );
+
+        $node = $this->createClassConstBuilder("TEST", 1)
+            ->makePublic()
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new Stmt\ClassConst(
+                [
+                    new Const_("TEST", new LNumber(1) )
+                ],
+                Stmt\Class_::MODIFIER_PUBLIC
+            ),
+            $node
+        );
+
+        $node = $this->createClassConstBuilder("TEST", 1)
+            ->makeFinal()
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new Stmt\ClassConst(
+                [
+                    new Const_("TEST", new LNumber(1) )
+                ],
+                Stmt\Class_::MODIFIER_FINAL
+            ),
+            $node
+        );
+    }
+
+    public function testDocComment() {
+        $node = $this->createClassConstBuilder('TEST',1)
+            ->setDocComment('/** Test */')
+            ->makePublic()
+            ->getNode();
+
+        $this->assertEquals(
+            new Stmt\ClassConst(
+                [
+                    new Const_("TEST", new LNumber(1) )
+                ],
+                Stmt\Class_::MODIFIER_PUBLIC,
+                [
+                    'comments' => [new Comment\Doc('/** Test */')]
+                ]
+            ),
+            $node
+        );
+    }
+
+    public function testAddConst() {
+        $node = $this->createClassConstBuilder('FIRST_TEST',1)
+            ->addConst("SECOND_TEST",2)
+            ->getNode();
+
+        $this->assertEquals(
+            new Stmt\ClassConst(
+                [
+                    new Const_("FIRST_TEST", new LNumber(1)),
+                    new Const_("SECOND_TEST", new LNumber(2))
+                ]
+            ),
+            $node
+        );
+    }
+
+    public function testAddAttribute() {
+        $attribute = new Attribute(
+            new Name('Attr'),
+            [new Arg(new LNumber(1), false, false, [], new Identifier('name'))]
+        );
+        $attributeGroup = new AttributeGroup([$attribute]);
+
+        $node = $this->createClassConstBuilder('ATTR_GROUP', 1)
+            ->addAttribute($attributeGroup)
+            ->getNode();
+
+        $this->assertEquals(
+            new Stmt\ClassConst(
+                [
+                    new Const_("ATTR_GROUP", new LNumber(1) )
+                ],
+                0,
+                [],
+                [$attributeGroup]
+            ),
+            $node
+        );
+    }
+
+    /**
+     * @dataProvider provideTestDefaultValues
+     */
+    public function testValues($value, $expectedValueNode) {
+        $node = $this->createClassConstBuilder('TEST', $value)
+            ->getNode()
+        ;
+
+        $this->assertEquals($expectedValueNode, $node->consts[0]->value);
+    }
+
+    public function provideTestDefaultValues() {
+        return [
+            [
+                null,
+                new Expr\ConstFetch(new Name('null'))
+            ],
+            [
+                true,
+                new Expr\ConstFetch(new Name('true'))
+            ],
+            [
+                false,
+                new Expr\ConstFetch(new Name('false'))
+            ],
+            [
+                31415,
+                new Scalar\LNumber(31415)
+            ],
+            [
+                3.1415,
+                new Scalar\DNumber(3.1415)
+            ],
+            [
+                'Hallo World',
+                new Scalar\String_('Hallo World')
+            ],
+            [
+                [1, 2, 3],
+                new Expr\Array_([
+                    new Expr\ArrayItem(new Scalar\LNumber(1)),
+                    new Expr\ArrayItem(new Scalar\LNumber(2)),
+                    new Expr\ArrayItem(new Scalar\LNumber(3)),
+                ])
+            ],
+            [
+                ['foo' => 'bar', 'bar' => 'foo'],
+                new Expr\Array_([
+                    new Expr\ArrayItem(
+                        new Scalar\String_('bar'),
+                        new Scalar\String_('foo')
+                    ),
+                    new Expr\ArrayItem(
+                        new Scalar\String_('foo'),
+                        new Scalar\String_('bar')
+                    ),
+                ])
+            ],
+            [
+                new Scalar\MagicConst\Dir,
+                new Scalar\MagicConst\Dir
+            ]
+        ];
+    }
+}

test/PhpParser/Builder/ClassTest.php

@@ -4,7 +4,12 @@ namespace PhpParser\Builder;
 
 use PhpParser\Comment;
 use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Stmt;
 
 class ClassTest extends \PHPUnit\Framework\TestCase
@@ -122,6 +127,27 @@ DOC;
         );
     }
 
+    public function testAddAttribute() {
+        $attribute = new Attribute(
+            new Name('Attr'),
+            [new Arg(new LNumber(1), false, false, [], new Identifier('name'))]
+        );
+        $attributeGroup = new AttributeGroup([$attribute]);
+
+        $class = $this->createClassBuilder('ATTR_GROUP')
+            ->addAttribute($attributeGroup)
+            ->getNode();
+
+        $this->assertEquals(
+            new Stmt\Class_('ATTR_GROUP', [
+                'attrGroups' => [
+                    $attributeGroup,
+                ]
+            ], []),
+            $class
+        );
+    }
+
     public function testInvalidStmtError() {
         $this->expectException(\LogicException::class);
         $this->expectExceptionMessage('Unexpected node of type "Stmt_Echo"');

test/PhpParser/Builder/FunctionTest.php

@@ -4,8 +4,14 @@ namespace PhpParser\Builder;
 
 use PhpParser\Comment;
 use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
 use PhpParser\Node\Expr\Print_;
 use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt;
 
@@ -81,6 +87,22 @@ class FunctionTest extends \PHPUnit\Framework\TestCase
         ]), $node);
     }
 
+    public function testAddAttribute() {
+        $attribute = new Attribute(
+            new Name('Attr'),
+            [new Arg(new LNumber(1), false, false, [], new Identifier('name'))]
+        );
+        $attributeGroup = new AttributeGroup([$attribute]);
+
+        $node = $this->createFunctionBuilder('attrGroup')
+            ->addAttribute($attributeGroup)
+            ->getNode();
+
+        $this->assertEquals(new Stmt\Function_('attrGroup', [
+            'attrGroups' => [$attributeGroup],
+        ], []), $node);
+    }
+
     public function testReturnType() {
         $node = $this->createFunctionBuilder('test')
             ->setReturnType('void')

test/PhpParser/Builder/InterfaceTest.php

@@ -4,7 +4,13 @@ namespace PhpParser\Builder;
 
 use PhpParser\Comment;
 use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
 use PhpParser\Node\Scalar\DNumber;
+use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Stmt;
 
 class InterfaceTest extends \PHPUnit\Framework\TestCase
@@ -76,6 +82,22 @@ class InterfaceTest extends \PHPUnit\Framework\TestCase
         ]), $node);
     }
 
+    public function testAddAttribute() {
+        $attribute = new Attribute(
+            new Name('Attr'),
+            [new Arg(new LNumber(1), false, false, [], new Identifier('name'))]
+        );
+        $attributeGroup = new AttributeGroup([$attribute]);
+
+        $node = $this->createInterfaceBuilder()
+            ->addAttribute($attributeGroup)
+            ->getNode();
+
+        $this->assertEquals(new Stmt\Interface_('Contract', [
+            'attrGroups' => [$attributeGroup],
+        ], []), $node);
+    }
+
     public function testInvalidStmtError() {
         $this->expectException(\LogicException::class);
         $this->expectExceptionMessage('Unexpected node of type "Stmt_PropertyProperty"');

test/PhpParser/Builder/MethodTest.php

@@ -4,8 +4,14 @@ namespace PhpParser\Builder;
 
 use PhpParser\Comment;
 use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
 use PhpParser\Node\Expr\Print_;
 use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt;
 
@@ -125,6 +131,22 @@ class MethodTest extends \PHPUnit\Framework\TestCase
         ]), $node);
     }
 
+    public function testAddAttribute() {
+        $attribute = new Attribute(
+            new Name('Attr'),
+            [new Arg(new LNumber(1), false, false, [], new Identifier('name'))]
+        );
+        $attributeGroup = new AttributeGroup([$attribute]);
+
+        $node = $this->createMethodBuilder('attributeGroup')
+            ->addAttribute($attributeGroup)
+            ->getNode();
+
+        $this->assertEquals(new Stmt\ClassMethod('attributeGroup', [
+            'attrGroups' => [$attributeGroup],
+        ], []), $node);
+    }
+
     public function testReturnType() {
         $node = $this->createMethodBuilder('test')
             ->setReturnType('bool')

test/PhpParser/Builder/ParamTest.php

@@ -3,8 +3,14 @@
 namespace PhpParser\Builder;
 
 use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
 use PhpParser\Node\Scalar;
+use PhpParser\Node\Scalar\LNumber;
 
 class ParamTest extends \PHPUnit\Framework\TestCase
 {
@@ -198,4 +204,21 @@ class ParamTest extends \PHPUnit\Framework\TestCase
             $node
         );
     }
+
+    public function testAddAttribute() {
+        $attribute = new Attribute(
+            new Name('Attr'),
+            [new Arg(new LNumber(1), false, false, [], new Identifier('name'))]
+        );
+        $attributeGroup = new AttributeGroup([$attribute]);
+
+        $node = $this->createParamBuilder('attributeGroup')
+            ->addAttribute($attributeGroup)
+            ->getNode();
+
+        $this->assertEquals(
+            new Node\Param(new Expr\Variable('attributeGroup'), null, null, false, false, [], 0, [$attributeGroup]),
+            $node
+        );
+    }
 }

test/PhpParser/Builder/PropertyTest.php

@@ -3,9 +3,14 @@
 namespace PhpParser\Builder;
 
 use PhpParser\Comment;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
 use PhpParser\Node\Scalar;
+use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Stmt;
 
 class PropertyTest extends \PHPUnit\Framework\TestCase
@@ -61,6 +66,21 @@ class PropertyTest extends \PHPUnit\Framework\TestCase
             ),
             $node
         );
+
+        $node = $this->createPropertyBuilder('test')
+            ->makeReadonly()
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new Stmt\Property(
+                Stmt\Class_::MODIFIER_READONLY,
+                [
+                    new Stmt\PropertyProperty('test')
+                ]
+            ),
+            $node
+        );
     }
 
     public function testDocComment() {
@@ -91,6 +111,32 @@ class PropertyTest extends \PHPUnit\Framework\TestCase
         $this->assertEquals($expectedValueNode, $node->props[0]->default);
     }
 
+    public function testAddAttribute() {
+        $attribute = new Attribute(
+            new Name('Attr'),
+            [new Arg(new LNumber(1), false, false, [], new Identifier('name'))]
+        );
+        $attributeGroup = new AttributeGroup([$attribute]);
+
+        $node = $this->createPropertyBuilder('test')
+            ->addAttribute($attributeGroup)
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new Stmt\Property(
+                Stmt\Class_::MODIFIER_PUBLIC,
+                [
+                    new Stmt\PropertyProperty('test')
+                ],
+                [],
+                null,
+                [$attributeGroup]
+            ),
+            $node
+        );
+    }
+
     public function provideTestDefaultValues() {
         return [
             [

test/PhpParser/Builder/TraitTest.php

@@ -3,7 +3,12 @@
 namespace PhpParser\Builder;
 
 use PhpParser\Comment;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Stmt;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassConst;
@@ -88,4 +93,27 @@ class TraitTest extends \PHPUnit\Framework\TestCase
 
         $this->assertSame($properties, $trait->getProperties());
     }
+
+    public function testAddAttribute() {
+        $attribute = new Attribute(
+            new Name('Attr'),
+            [new Arg(new LNumber(1), false, false, [], new Identifier('name'))]
+        );
+        $attributeGroup = new AttributeGroup([$attribute]);
+
+        $node = $this->createTraitBuilder('AttributeGroup')
+            ->addAttribute($attributeGroup)
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new Stmt\Trait_(
+                'AttributeGroup',
+                [
+                    'attrGroups' => [$attributeGroup],
+                ]
+            ),
+            $node
+        );
+    }
 }

test/PhpParser/BuilderFactoryTest.php

@@ -3,6 +3,7 @@
 namespace PhpParser;
 
 use PhpParser\Node\Arg;
+use PhpParser\Node\Attribute;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\BinaryOp\Concat;
 use PhpParser\Node\Identifier;
@@ -36,6 +37,21 @@ class BuilderFactoryTest extends \PHPUnit\Framework\TestCase
         ];
     }
 
+    public function testFactoryClassConst() {
+        $factory = new BuilderFactory;
+        $this->assertInstanceOf(Builder\ClassConst::class, $factory->classConst('TEST',1));
+    }
+
+    public function testAttribute() {
+        $factory = new BuilderFactory();
+        $this->assertEquals(
+            new Attribute(new Name('AttributeName'), [new Arg(
+                new String_('bar'), false, false, [], new Identifier('foo')
+            )]),
+            $factory->attribute('AttributeName', ['foo' => 'bar'])
+        );
+    }
+
     public function testVal() {
         // This method is a wrapper around BuilderHelpers::normalizeValue(),
         // which is already tested elsewhere
@@ -91,6 +107,17 @@ class BuilderFactoryTest extends \PHPUnit\Framework\TestCase
         );
     }
 
+    public function testNamedArgs() {
+        $factory = new BuilderFactory();
+        $this->assertEquals(
+            [
+                new Arg(new String_('foo')),
+                new Arg(new String_('baz'), false, false, [], new Identifier('bar')),
+            ],
+            $factory->args(['foo', 'bar' => 'baz'])
+        );
+    }
+
     public function testCalls() {
         $factory = new BuilderFactory();
 
@@ -246,6 +273,7 @@ class BuilderFactoryTest extends \PHPUnit\Framework\TestCase
                 ->class('SomeClass')
                 ->extend('SomeOtherClass')
                 ->implement('A\Few', '\Interfaces')
+                ->addAttribute($factory->attribute('ClassAttribute', ['repository' => 'fqcn']))
                 ->makeAbstract()
 
                 ->addStmt($factory->useTrait('FirstTrait'))
@@ -256,7 +284,9 @@ class BuilderFactoryTest extends \PHPUnit\Framework\TestCase
                     ->with($factory->traitUseAdaptation('AnotherTrait', 'baz')->as('test'))
                     ->with($factory->traitUseAdaptation('AnotherTrait', 'func')->insteadof('SecondTrait')))
 
-                ->addStmt($factory->method('firstMethod'))
+                ->addStmt($factory->method('firstMethod')
+                    ->addAttribute($factory->attribute('Route', ['/index', 'name' => 'homepage']))
+                )
 
                 ->addStmt($factory->method('someMethod')
                     ->makePublic()
@@ -270,13 +300,28 @@ class BuilderFactoryTest extends \PHPUnit\Framework\TestCase
 
                 ->addStmt($factory->method('anotherMethod')
                     ->makeProtected()
-                    ->addParam($factory->param('someParam')->setDefault('test'))
+                    ->addParam($factory->param('someParam')
+                        ->setDefault('test')
+                        ->addAttribute($factory->attribute('TaggedIterator', ['app.handlers']))
+                    )
                     ->addStmt(new Expr\Print_(new Expr\Variable('someParam'))))
 
                 ->addStmt($factory->property('someProperty')->makeProtected())
                 ->addStmt($factory->property('anotherProperty')
                     ->makePrivate()
-                    ->setDefault([1, 2, 3])))
+                    ->setDefault([1, 2, 3]))
+                ->addStmt($factory->property('integerProperty')
+                    ->setType('int')
+                    ->addAttribute($factory->attribute('Column', ['options' => ['unsigned' => true]]))
+                    ->setDefault(1))
+                ->addStmt($factory->classConst('CONST_WITH_ATTRIBUTE', 1)
+                    ->makePublic()
+                    ->addAttribute($factory->attribute('ConstAttribute'))
+                )
+
+                ->addStmt($factory->classConst("FIRST_CLASS_CONST", 1)
+                    ->addConst("SECOND_CLASS_CONST",2)
+                    ->makePrivate()))
             ->getNode()
         ;
 
@@ -289,6 +334,7 @@ use Foo\Bar\SomeOtherClass;
 use Foo\Bar as A;
 use function strlen;
 use const PHP_VERSION;
+#[ClassAttribute(repository: 'fqcn')]
 abstract class SomeClass extends SomeOtherClass implements A\Few, \Interfaces
 {
     use FirstTrait;
@@ -297,8 +343,14 @@ abstract class SomeClass extends SomeOtherClass implements A\Few, \Interfaces
         AnotherTrait::baz as test;
         AnotherTrait::func insteadof SecondTrait;
     }
+    #[ConstAttribute]
+    public const CONST_WITH_ATTRIBUTE = 1;
+    private const FIRST_CLASS_CONST = 1, SECOND_CLASS_CONST = 2;
     protected $someProperty;
     private $anotherProperty = array(1, 2, 3);
+    #[Column(options: array('unsigned' => true))]
+    public int $integerProperty = 1;
+    #[Route('/index', name: 'homepage')]
     function firstMethod()
     {
     }
@@ -308,7 +360,7 @@ abstract class SomeClass extends SomeOtherClass implements A\Few, \Interfaces
      * @param SomeClass And takes a parameter
      */
     public abstract function someMethod(SomeClass $someParam);
-    protected function anotherMethod($someParam = 'test')
+    protected function anotherMethod(#[TaggedIterator('app.handlers')] $someParam = 'test')
     {
         print $someParam;
     }

test/PhpParser/BuilderHelpersTest.php

@@ -0,0 +1,219 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser;
+
+use PhpParser\Builder\Class_;
+use PhpParser\Node\Scalar;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Expr;
+
+class BuilderHelpersTest extends \PHPUnit\Framework\TestCase
+{
+    public function testNormalizeNode() {
+        $builder = new Class_('SomeClass');
+        $this->assertEquals($builder->getNode(), BuilderHelpers::normalizeNode($builder));
+
+        $attribute = new Node\Attribute(new Node\Name('Test'));
+        $this->assertSame($attribute, BuilderHelpers::normalizeNode($attribute));
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Expected node or builder object');
+        BuilderHelpers::normalizeNode('test');
+    }
+
+    public function testNormalizeStmt() {
+        $stmt = new Node\Stmt\Class_('Class');
+        $this->assertSame($stmt, BuilderHelpers::normalizeStmt($stmt));
+
+        $expr = new Expr\Variable('fn');
+        $normalizedExpr = BuilderHelpers::normalizeStmt($expr);
+        $this->assertEquals(new Stmt\Expression($expr), $normalizedExpr);
+        $this->assertSame($expr, $normalizedExpr->expr);
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Expected statement or expression node');
+        BuilderHelpers::normalizeStmt(new Node\Attribute(new Node\Name('Test')));
+    }
+
+    public function testNormalizeStmtInvalidType() {
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Expected node or builder object');
+        BuilderHelpers::normalizeStmt('test');
+    }
+
+    public function testNormalizeIdentifier() {
+        $identifier = new Node\Identifier('fn');
+        $this->assertSame($identifier, BuilderHelpers::normalizeIdentifier($identifier));
+        $this->assertEquals($identifier, BuilderHelpers::normalizeIdentifier('fn'));
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Expected string or instance of Node\Identifier');
+        BuilderHelpers::normalizeIdentifier(1);
+    }
+
+    public function testNormalizeIdentifierOrExpr() {
+        $identifier = new Node\Identifier('fn');
+        $this->assertSame($identifier, BuilderHelpers::normalizeIdentifierOrExpr($identifier));
+
+        $expr = new Expr\Variable('fn');
+        $this->assertSame($expr, BuilderHelpers::normalizeIdentifierOrExpr($expr));
+        $this->assertEquals($identifier, BuilderHelpers::normalizeIdentifierOrExpr('fn'));
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Expected string or instance of Node\Identifier');
+        BuilderHelpers::normalizeIdentifierOrExpr(1);
+    }
+
+    public function testNormalizeName() {
+        $name = new Node\Name('test');
+        $this->assertSame($name, BuilderHelpers::normalizeName($name));
+        $this->assertEquals(
+            new Node\Name\FullyQualified(['Namespace', 'Test']),
+            BuilderHelpers::normalizeName('\\Namespace\\Test')
+        );
+        $this->assertEquals(
+            new Node\Name\Relative(['Test']),
+            BuilderHelpers::normalizeName('namespace\\Test')
+        );
+        $this->assertEquals($name, BuilderHelpers::normalizeName('test'));
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Name cannot be empty');
+        BuilderHelpers::normalizeName('');
+    }
+
+    public function testNormalizeNameInvalidType() {
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Name must be a string or an instance of Node\Name');
+        BuilderHelpers::normalizeName(1);
+    }
+
+    public function testNormalizeNameOrExpr() {
+        $expr = new Expr\Variable('fn');
+        $this->assertSame($expr, BuilderHelpers::normalizeNameOrExpr($expr));
+
+        $name = new Node\Name('test');
+        $this->assertSame($name, BuilderHelpers::normalizeNameOrExpr($name));
+        $this->assertEquals(
+            new Node\Name\FullyQualified(['Namespace', 'Test']),
+            BuilderHelpers::normalizeNameOrExpr('\\Namespace\\Test')
+        );
+        $this->assertEquals(
+            new Node\Name\Relative(['Test']),
+            BuilderHelpers::normalizeNameOrExpr('namespace\\Test')
+        );
+        $this->assertEquals($name, BuilderHelpers::normalizeNameOrExpr('test'));
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Name cannot be empty');
+        BuilderHelpers::normalizeNameOrExpr('');
+    }
+
+    public function testNormalizeNameOrExpInvalidType() {
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Name must be a string or an instance of Node\Name or Node\Expr');
+        BuilderHelpers::normalizeNameOrExpr(1);
+    }
+
+    public function testNormalizeType() {
+        $this->assertEquals(new Node\Identifier('array'), BuilderHelpers::normalizeType('array'));
+        $this->assertEquals(new Node\Identifier('callable'), BuilderHelpers::normalizeType('callable'));
+        $this->assertEquals(new Node\Identifier('string'), BuilderHelpers::normalizeType('string'));
+        $this->assertEquals(new Node\Identifier('int'), BuilderHelpers::normalizeType('int'));
+        $this->assertEquals(new Node\Identifier('float'), BuilderHelpers::normalizeType('float'));
+        $this->assertEquals(new Node\Identifier('bool'), BuilderHelpers::normalizeType('bool'));
+        $this->assertEquals(new Node\Identifier('iterable'), BuilderHelpers::normalizeType('iterable'));
+        $this->assertEquals(new Node\Identifier('void'), BuilderHelpers::normalizeType('void'));
+        $this->assertEquals(new Node\Identifier('object'), BuilderHelpers::normalizeType('object'));
+        $this->assertEquals(new Node\Identifier('mixed'), BuilderHelpers::normalizeType('mixed'));
+        $this->assertEquals(new Node\Identifier('never'), BuilderHelpers::normalizeType('never'));
+
+        $intIdentifier = new Node\Identifier('int');
+        $this->assertSame($intIdentifier, BuilderHelpers::normalizeType($intIdentifier));
+
+        $intName = new Node\Name('int');
+        $this->assertSame($intName, BuilderHelpers::normalizeType($intName));
+
+        $intNullable = new Node\NullableType('int');
+        $this->assertSame($intNullable, BuilderHelpers::normalizeType($intNullable));
+
+        $unionType = new Node\UnionType([new Node\Identifier('int'), new Node\Identifier('string')]);
+        $this->assertSame($unionType, BuilderHelpers::normalizeType($unionType));
+
+        $expectedNullable = new Node\NullableType($intIdentifier);
+        $nullable = BuilderHelpers::normalizeType('?int');
+        $this->assertEquals($expectedNullable, $nullable);
+        $this->assertEquals($intIdentifier, $nullable->type);
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Type must be a string, or an instance of Name, Identifier, NullableType or UnionType');
+        BuilderHelpers::normalizeType(1);
+    }
+
+    public function testNormalizeTypeNullableVoid() {
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('void type cannot be nullable');
+        BuilderHelpers::normalizeType('?void');
+    }
+
+    public function testNormalizeTypeNullableMixed() {
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('mixed type cannot be nullable');
+        BuilderHelpers::normalizeType('?mixed');
+    }
+
+    public function testNormalizeTypeNullableNever() {
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('never type cannot be nullable');
+        BuilderHelpers::normalizeType('?never');
+    }
+
+    public function testNormalizeValue() {
+        $expression = new Scalar\LNumber(1);
+        $this->assertSame($expression, BuilderHelpers::normalizeValue($expression));
+
+        $this->assertEquals(new Expr\ConstFetch(new Node\Name('null')), BuilderHelpers::normalizeValue(null));
+        $this->assertEquals(new Expr\ConstFetch(new Node\Name('true')), BuilderHelpers::normalizeValue(true));
+        $this->assertEquals(new Expr\ConstFetch(new Node\Name('false')), BuilderHelpers::normalizeValue(false));
+        $this->assertEquals(new Scalar\LNumber(2), BuilderHelpers::normalizeValue(2));
+        $this->assertEquals(new Scalar\DNumber(2.5), BuilderHelpers::normalizeValue(2.5));
+        $this->assertEquals(new Scalar\String_('text'), BuilderHelpers::normalizeValue('text'));
+        $this->assertEquals(
+            new Expr\Array_([
+                new Expr\ArrayItem(new Scalar\LNumber(0)),
+                new Expr\ArrayItem(new Scalar\LNumber(1), new Scalar\String_('test')),
+            ]),
+            BuilderHelpers::normalizeValue([
+                0,
+                'test' => 1,
+            ])
+        );
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Invalid value');
+        BuilderHelpers::normalizeValue(new \stdClass());
+    }
+
+    public function testNormalizeDocComment() {
+        $docComment = new Comment\Doc('Some doc comment');
+        $this->assertSame($docComment, BuilderHelpers::normalizeDocComment($docComment));
+
+        $this->assertEquals($docComment, BuilderHelpers::normalizeDocComment('Some doc comment'));
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Doc comment must be a string or an instance of PhpParser\Comment\Doc');
+        BuilderHelpers::normalizeDocComment(1);
+    }
+
+    public function testNormalizeAttribute() {
+        $attribute = new Node\Attribute(new Node\Name('Test'));
+        $attributeGroup = new Node\AttributeGroup([$attribute]);
+
+        $this->assertEquals($attributeGroup, BuilderHelpers::normalizeAttribute($attribute));
+        $this->assertSame($attributeGroup, BuilderHelpers::normalizeAttribute($attributeGroup));
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Attribute must be an instance of PhpParser\Node\Attribute or PhpParser\Node\AttributeGroup');
+        BuilderHelpers::normalizeAttribute('test');
+    }
+}

test/PhpParser/CodeParsingTest.php

@@ -107,8 +107,11 @@ class CodeParsingTest extends CodeTestAbstract
                     $endFilePos < $startFilePos ||
                     $endTokenPos < $startTokenPos
                 ) {
-                    // Nops and error can have inverted order, if they are empty
-                    if (!$node instanceof Stmt\Nop && !$node instanceof Expr\Error) {
+                    // Nop and Error can have inverted order, if they are empty.
+                    // This can also happen for a Param containing an Error.
+                    if (!$node instanceof Stmt\Nop && !$node instanceof Expr\Error &&
+                        !$node instanceof Node\Param
+                    ) {
                         throw new \Exception('End < start on ' . $node->getType());
                     }
                 }

test/PhpParser/ConstExprEvaluatorTest.php

@@ -121,9 +121,11 @@ class ConstExprEvaluatorTest extends \PHPUnit\Framework\TestCase
                 'Modulo by zero'
             ],
             [
-                new Expr\BinaryOp\Div(new Scalar\LNumber(42), new Scalar\LNumber(0)),
+                new Expr\BinaryOp\Plus(new Scalar\LNumber(42), new Scalar\String_("1foo")),
                 \ErrorException::class,
-                'Division by zero'
+                \PHP_VERSION_ID >= 80000
+                    ? 'A non-numeric value encountered'
+                    : 'A non well formed numeric value encountered'
             ],
         ];
     }

test/PhpParser/Lexer/EmulativeTest.php

@@ -3,6 +3,7 @@
 namespace PhpParser\Lexer;
 
 use PhpParser\ErrorHandler;
+use PhpParser\Lexer;
 use PhpParser\LexerTest;
 use PhpParser\Parser\Tokens;
 
@@ -23,6 +24,17 @@ class EmulativeTest extends LexerTest
         $this->assertSame(0, $lexer->getNextToken());
     }
 
+    /**
+     * @dataProvider provideTestReplaceKeywords
+     */
+    public function testReplaceKeywordsUppercase($keyword, $expectedToken) {
+        $lexer = $this->getLexer();
+        $lexer->startLexing('<?php ' . strtoupper($keyword));
+
+        $this->assertSame($expectedToken, $lexer->getNextToken());
+        $this->assertSame(0, $lexer->getNextToken());
+    }
+
     /**
      * @dataProvider provideTestReplaceKeywords
      */
@@ -47,8 +59,23 @@ class EmulativeTest extends LexerTest
         $this->assertSame(0, $lexer->getNextToken());
     }
 
+    /**
+     * @dataProvider provideTestReplaceKeywords
+     */
+    public function testNoReplaceKeywordsAfterNullsafeObjectOperator(string $keyword) {
+        $lexer = $this->getLexer();
+        $lexer->startLexing('<?php ?->' . $keyword);
+
+        $this->assertSame(Tokens::T_NULLSAFE_OBJECT_OPERATOR, $lexer->getNextToken());
+        $this->assertSame(Tokens::T_STRING, $lexer->getNextToken());
+        $this->assertSame(0, $lexer->getNextToken());
+    }
+
     public function provideTestReplaceKeywords() {
         return [
+            // PHP 8.0
+            ['match',         Tokens::T_MATCH],
+
             // PHP 7.4
             ['fn',            Tokens::T_FN],
 
@@ -70,18 +97,21 @@ class EmulativeTest extends LexerTest
         ];
     }
 
+    private function assertSameTokens(array $expectedTokens, Lexer $lexer) {
+        $tokens = [];
+        while (0 !== $token = $lexer->getNextToken($text)) {
+            $tokens[] = [$token, $text];
+        }
+        $this->assertSame($expectedTokens, $tokens);
+    }
+
     /**
      * @dataProvider provideTestLexNewFeatures
      */
     public function testLexNewFeatures($code, array $expectedTokens) {
         $lexer = $this->getLexer();
         $lexer->startLexing('<?php ' . $code);
-
-        $tokens = [];
-        while (0 !== $token = $lexer->getNextToken($text)) {
-            $tokens[] = [$token, $text];
-        }
-        $this->assertSame($expectedTokens, $tokens);
+        $this->assertSameTokens($expectedTokens, $lexer);
     }
 
     /**
@@ -253,6 +283,102 @@ class EmulativeTest extends LexerTest
                 [Tokens::T_LNUMBER, '1_0'],
                 [Tokens::T_STRING, 'abc'],
             ]],
+            ['?->', [
+                [Tokens::T_NULLSAFE_OBJECT_OPERATOR, '?->'],
+            ]],
+            ['#[Attr]', [
+                [Tokens::T_ATTRIBUTE, '#['],
+                [Tokens::T_STRING, 'Attr'],
+                [ord(']'), ']'],
+            ]],
+            ["#[\nAttr\n]", [
+                [Tokens::T_ATTRIBUTE, '#['],
+                [Tokens::T_STRING, 'Attr'],
+                [ord(']'), ']'],
+            ]],
+            // Test interaction of two patch-based emulators
+            ["<<<LABEL\n    LABEL, #[Attr]", [
+                [Tokens::T_START_HEREDOC, "<<<LABEL\n"],
+                [Tokens::T_END_HEREDOC, "    LABEL"],
+                [ord(','), ','],
+                [Tokens::T_ATTRIBUTE, '#['],
+                [Tokens::T_STRING, 'Attr'],
+                [ord(']'), ']'],
+            ]],
+            ["#[Attr] <<<LABEL\n    LABEL,", [
+                [Tokens::T_ATTRIBUTE, '#['],
+                [Tokens::T_STRING, 'Attr'],
+                [ord(']'), ']'],
+                [Tokens::T_START_HEREDOC, "<<<LABEL\n"],
+                [Tokens::T_END_HEREDOC, "    LABEL"],
+                [ord(','), ','],
+            ]],
+            // Enums use a contextual keyword
+            ['enum Foo {}', [
+                [Tokens::T_ENUM, 'enum'],
+                [Tokens::T_STRING, 'Foo'],
+                [ord('{'), '{'],
+                [ord('}'), '}'],
+            ]],
+            ['class Enum {}', [
+                [Tokens::T_CLASS, 'class'],
+                [Tokens::T_STRING, 'Enum'],
+                [ord('{'), '{'],
+                [ord('}'), '}'],
+            ]],
+            ['class Enum extends X {}', [
+                [Tokens::T_CLASS, 'class'],
+                [Tokens::T_STRING, 'Enum'],
+                [Tokens::T_EXTENDS, 'extends'],
+                [Tokens::T_STRING, 'X'],
+                [ord('{'), '{'],
+                [ord('}'), '}'],
+            ]],
+            ['class Enum implements X {}', [
+                [Tokens::T_CLASS, 'class'],
+                [Tokens::T_STRING, 'Enum'],
+                [Tokens::T_IMPLEMENTS, 'implements'],
+                [Tokens::T_STRING, 'X'],
+                [ord('{'), '{'],
+                [ord('}'), '}'],
+            ]],
+        ];
+    }
+
+    /**
+     * @dataProvider provideTestTargetVersion
+     */
+    public function testTargetVersion(string $phpVersion, string $code, array $expectedTokens) {
+        $lexer = $this->getLexer(['phpVersion' => $phpVersion]);
+        $lexer->startLexing('<?php ' . $code);
+        $this->assertSameTokens($expectedTokens, $lexer);
+    }
+
+    public function provideTestTargetVersion() {
+        return [
+            ['8.0', 'match', [[Tokens::T_MATCH, 'match']]],
+            ['7.4', 'match', [[Tokens::T_STRING, 'match']]],
+            // Keywords are not case-sensitive.
+            ['7.4', 'fn', [[Tokens::T_FN, 'fn']]],
+            ['7.4', 'FN', [[Tokens::T_FN, 'FN']]],
+            ['7.3', 'fn', [[Tokens::T_STRING, 'fn']]],
+            ['7.3', 'FN', [[Tokens::T_STRING, 'FN']]],
+            // Tested here to skip testLeaveStuffAloneInStrings.
+            ['8.0', '"$foo?->bar"', [
+                [ord('"'), '"'],
+                [Tokens::T_VARIABLE, '$foo'],
+                [Tokens::T_NULLSAFE_OBJECT_OPERATOR, '?->'],
+                [Tokens::T_STRING, 'bar'],
+                [ord('"'), '"'],
+            ]],
+            ['8.0', '"$foo?->bar baz"', [
+                [ord('"'), '"'],
+                [Tokens::T_VARIABLE, '$foo'],
+                [Tokens::T_NULLSAFE_OBJECT_OPERATOR, '?->'],
+                [Tokens::T_STRING, 'bar'],
+                [Tokens::T_ENCAPSED_AND_WHITESPACE, ' baz'],
+                [ord('"'), '"'],
+            ]],
         ];
     }
 }

test/PhpParser/LexerTest.php

@@ -227,6 +227,18 @@ class LexerTest extends \PHPUnit\Framework\TestCase
                     [Tokens::T_NS_SEPARATOR, '\\', [], []],
                 ]
             ],
+            // tests PHP 8 T_NAME_* emulation with reserved keywords
+            [
+                '<?php fn\use \fn\use namespace\fn\use fn\use\\',
+                ['usedAttributes' => []],
+                [
+                    [Tokens::T_NAME_QUALIFIED, 'fn\use', [], []],
+                    [Tokens::T_NAME_FULLY_QUALIFIED, '\fn\use', [], []],
+                    [Tokens::T_NAME_RELATIVE, 'namespace\fn\use', [], []],
+                    [Tokens::T_NAME_QUALIFIED, 'fn\use', [], []],
+                    [Tokens::T_NS_SEPARATOR, '\\', [], []],
+                ]
+            ],
         ];
     }
 

test/PhpParser/Node/Stmt/ClassConstTest.php

@@ -22,6 +22,7 @@ class ClassConstTest extends \PHPUnit\Framework\TestCase
         $this->assertTrue($node->isPublic());
         $this->assertFalse($node->isProtected());
         $this->assertFalse($node->isPrivate());
+        $this->assertFalse($node->isFinal());
     }
 
     public function provideModifiers() {
@@ -29,6 +30,7 @@ class ClassConstTest extends \PHPUnit\Framework\TestCase
             ['public'],
             ['protected'],
             ['private'],
+            ['final'],
         ];
     }
 }

test/PhpParser/Node/Stmt/PropertyTest.php

@@ -23,6 +23,7 @@ class PropertyTest extends \PHPUnit\Framework\TestCase
         $this->assertFalse($node->isProtected());
         $this->assertFalse($node->isPrivate());
         $this->assertFalse($node->isStatic());
+        $this->assertFalse($node->isReadonly());
     }
 
     public function testStaticImplicitlyPublic() {
@@ -31,6 +32,12 @@ class PropertyTest extends \PHPUnit\Framework\TestCase
         $this->assertFalse($node->isProtected());
         $this->assertFalse($node->isPrivate());
         $this->assertTrue($node->isStatic());
+        $this->assertFalse($node->isReadonly());
+    }
+
+    public function testReadonly() {
+        $node = new Property(Class_::MODIFIER_READONLY, []);
+        $this->assertTrue($node->isReadonly());
     }
 
     public function provideModifiers() {

test/PhpParser/NodeAbstractTest.php

@@ -248,6 +248,7 @@ PHP;
                     }
                 },
                 "flags": 0,
+                "attrGroups": [],
                 "attributes": {
                     "startLine": 4,
                     "endLine": 4
@@ -275,6 +276,7 @@ PHP;
                     }
                 },
                 "flags": 0,
+                "attrGroups": [],
                 "attributes": {
                     "startLine": 4,
                     "endLine": 4
@@ -302,6 +304,7 @@ PHP;
                 }
             }
         ],
+        "attrGroups": [],
         "attributes": {
             "startLine": 4,
             "comments": [
@@ -331,6 +334,133 @@ PHP;
     }
 ]
 JSON;
+        $expected81 = <<<'JSON'
+[
+    {
+        "nodeType": "Stmt_Function",
+        "attributes": {
+            "startLine": 4,
+            "comments": [
+                {
+                    "nodeType": "Comment",
+                    "text": "\/\/ comment",
+                    "line": 2,
+                    "filePos": 6,
+                    "tokenPos": 1,
+                    "endLine": 2,
+                    "endFilePos": 15,
+                    "endTokenPos": 1
+                },
+                {
+                    "nodeType": "Comment_Doc",
+                    "text": "\/** doc comment *\/",
+                    "line": 3,
+                    "filePos": 17,
+                    "tokenPos": 3,
+                    "endLine": 3,
+                    "endFilePos": 34,
+                    "endTokenPos": 3
+                }
+            ],
+            "endLine": 6
+        },
+        "byRef": false,
+        "name": {
+            "nodeType": "Identifier",
+            "attributes": {
+                "startLine": 4,
+                "endLine": 4
+            },
+            "name": "functionName"
+        },
+        "params": [
+            {
+                "nodeType": "Param",
+                "attributes": {
+                    "startLine": 4,
+                    "endLine": 4
+                },
+                "type": null,
+                "byRef": true,
+                "variadic": false,
+                "var": {
+                    "nodeType": "Expr_Variable",
+                    "attributes": {
+                        "startLine": 4,
+                        "endLine": 4
+                    },
+                    "name": "a"
+                },
+                "default": {
+                    "nodeType": "Scalar_LNumber",
+                    "attributes": {
+                        "startLine": 4,
+                        "endLine": 4,
+                        "kind": 10
+                    },
+                    "value": 0
+                },
+                "flags": 0,
+                "attrGroups": []
+            },
+            {
+                "nodeType": "Param",
+                "attributes": {
+                    "startLine": 4,
+                    "endLine": 4
+                },
+                "type": null,
+                "byRef": false,
+                "variadic": false,
+                "var": {
+                    "nodeType": "Expr_Variable",
+                    "attributes": {
+                        "startLine": 4,
+                        "endLine": 4
+                    },
+                    "name": "b"
+                },
+                "default": {
+                    "nodeType": "Scalar_DNumber",
+                    "attributes": {
+                        "startLine": 4,
+                        "endLine": 4
+                    },
+                    "value": 1
+                },
+                "flags": 0,
+                "attrGroups": []
+            }
+        ],
+        "returnType": null,
+        "stmts": [
+            {
+                "nodeType": "Stmt_Echo",
+                "attributes": {
+                    "startLine": 5,
+                    "endLine": 5
+                },
+                "exprs": [
+                    {
+                        "nodeType": "Scalar_String",
+                        "attributes": {
+                            "startLine": 5,
+                            "endLine": 5,
+                            "kind": 1
+                        },
+                        "value": "Foo"
+                    }
+                ]
+            }
+        ],
+        "attrGroups": []
+    }
+]
+JSON;
+
+        if (version_compare(PHP_VERSION, '8.1', '>=')) {
+            $expected = $expected81;
+        }
 
         $parser = new Parser\Php7(new Lexer());
         $stmts = $parser->parse(canonicalize($code));

test/PhpParser/NodeTraverserTest.php

@@ -13,21 +13,21 @@ class NodeTraverserTest extends \PHPUnit\Framework\TestCase
         $echoNode = new Node\Stmt\Echo_([$str1Node, $str2Node]);
         $stmts    = [$echoNode];
 
-        $visitor = $this->getMockBuilder(NodeVisitor::class)->getMock();
-
-        $visitor->expects($this->at(0))->method('beforeTraverse')->with($stmts);
-        $visitor->expects($this->at(1))->method('enterNode')->with($echoNode);
-        $visitor->expects($this->at(2))->method('enterNode')->with($str1Node);
-        $visitor->expects($this->at(3))->method('leaveNode')->with($str1Node);
-        $visitor->expects($this->at(4))->method('enterNode')->with($str2Node);
-        $visitor->expects($this->at(5))->method('leaveNode')->with($str2Node);
-        $visitor->expects($this->at(6))->method('leaveNode')->with($echoNode);
-        $visitor->expects($this->at(7))->method('afterTraverse')->with($stmts);
-
+        $visitor = new NodeVisitorForTesting();
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor);
 
         $this->assertEquals($stmts, $traverser->traverse($stmts));
+        $this->assertEquals([
+            ['beforeTraverse', $stmts],
+            ['enterNode', $echoNode],
+            ['enterNode', $str1Node],
+            ['leaveNode', $str1Node],
+            ['enterNode', $str2Node],
+            ['leaveNode', $str2Node],
+            ['leaveNode', $echoNode],
+            ['afterTraverse', $stmts],
+        ], $visitor->trace);
     }
 
     public function testModifying() {
@@ -36,38 +36,15 @@ class NodeTraverserTest extends \PHPUnit\Framework\TestCase
         $printNode = new Expr\Print_($str1Node);
 
         // first visitor changes the node, second verifies the change
-        $visitor1 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor2 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-
-        // replace empty statements with string1 node
-        $visitor1->expects($this->at(0))->method('beforeTraverse')->with([])
-                 ->willReturn([$str1Node]);
-        $visitor2->expects($this->at(0))->method('beforeTraverse')->with([$str1Node]);
-
-        // replace string1 node with print node
-        $visitor1->expects($this->at(1))->method('enterNode')->with($str1Node)
-                 ->willReturn($printNode);
-        $visitor2->expects($this->at(1))->method('enterNode')->with($printNode);
-
-        // replace string1 node with string2 node
-        $visitor1->expects($this->at(2))->method('enterNode')->with($str1Node)
-                 ->willReturn($str2Node);
-        $visitor2->expects($this->at(2))->method('enterNode')->with($str2Node);
-
-        // replace string2 node with string1 node again
-        $visitor1->expects($this->at(3))->method('leaveNode')->with($str2Node)
-                 ->willReturn($str1Node);
-        $visitor2->expects($this->at(3))->method('leaveNode')->with($str1Node);
-
-        // replace print node with string1 node again
-        $visitor1->expects($this->at(4))->method('leaveNode')->with($printNode)
-                 ->willReturn($str1Node);
-        $visitor2->expects($this->at(4))->method('leaveNode')->with($str1Node);
-
-        // replace string1 node with empty statements again
-        $visitor1->expects($this->at(5))->method('afterTraverse')->with([$str1Node])
-                 ->willReturn([]);
-        $visitor2->expects($this->at(5))->method('afterTraverse')->with([]);
+        $visitor1 = new NodeVisitorForTesting([
+            ['beforeTraverse', [], [$str1Node]],
+            ['enterNode', $str1Node, $printNode],
+            ['enterNode', $str1Node, $str2Node],
+            ['leaveNode', $str2Node, $str1Node],
+            ['leaveNode', $printNode, $str1Node],
+            ['afterTraverse', [$str1Node], []],
+        ]);
+        $visitor2 = new NodeVisitorForTesting();
 
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor1);
@@ -75,17 +52,23 @@ class NodeTraverserTest extends \PHPUnit\Framework\TestCase
 
         // as all operations are reversed we end where we start
         $this->assertEquals([], $traverser->traverse([]));
+        $this->assertEquals([
+            ['beforeTraverse', [$str1Node]],
+            ['enterNode', $printNode],
+            ['enterNode', $str2Node],
+            ['leaveNode', $str1Node],
+            ['leaveNode', $str1Node],
+            ['afterTraverse', []],
+        ], $visitor2->trace);
     }
 
     public function testRemove() {
         $str1Node = new String_('Foo');
         $str2Node = new String_('Bar');
 
-        $visitor = $this->getMockBuilder(NodeVisitor::class)->getMock();
-
-        // remove the string1 node, leave the string2 node
-        $visitor->expects($this->at(2))->method('leaveNode')->with($str1Node)
-                ->willReturn(NodeTraverser::REMOVE_NODE);
+        $visitor = new NodeVisitorForTesting([
+            ['leaveNode', $str1Node, NodeTraverser::REMOVE_NODE],
+        ]);
 
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor);
@@ -100,11 +83,9 @@ class NodeTraverserTest extends \PHPUnit\Framework\TestCase
         $strR1     = new String_('Replacement 1');
         $strR2     = new String_('Replacement 2');
 
-        $visitor = $this->getMockBuilder(NodeVisitor::class)->getMock();
-
-        // replace strMiddle with strR1 and strR2 by merge
-        $visitor->expects($this->at(4))->method('leaveNode')->with($strMiddle)
-                ->willReturn([$strR1, $strR2]);
+        $visitor = new NodeVisitorForTesting([
+            ['leaveNode', $strMiddle, [$strR1, $strR2]],
+        ]);
 
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor);
@@ -133,34 +114,31 @@ class NodeTraverserTest extends \PHPUnit\Framework\TestCase
         $negNode = new Expr\UnaryMinus($mulNode);
         $stmts = [$printNode, $negNode];
 
-        $visitor1 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor2 = $this->getMockBuilder(NodeVisitor::class)->getMock();
+        $visitor1 = new NodeVisitorForTesting([
+            ['enterNode', $printNode, NodeTraverser::DONT_TRAVERSE_CHILDREN],
+        ]);
+        $visitor2 = new NodeVisitorForTesting([
+            ['enterNode', $mulNode, NodeTraverser::DONT_TRAVERSE_CHILDREN],
+        ]);
 
-        $visitor1->expects($this->at(1))->method('enterNode')->with($printNode)
-            ->willReturn(NodeTraverser::DONT_TRAVERSE_CHILDREN);
-        $visitor2->expects($this->at(1))->method('enterNode')->with($printNode);
-
-        $visitor1->expects($this->at(2))->method('leaveNode')->with($printNode);
-        $visitor2->expects($this->at(2))->method('leaveNode')->with($printNode);
-
-        $visitor1->expects($this->at(3))->method('enterNode')->with($negNode);
-        $visitor2->expects($this->at(3))->method('enterNode')->with($negNode);
-
-        $visitor1->expects($this->at(4))->method('enterNode')->with($mulNode);
-        $visitor2->expects($this->at(4))->method('enterNode')->with($mulNode)
-            ->willReturn(NodeTraverser::DONT_TRAVERSE_CHILDREN);
-
-        $visitor1->expects($this->at(5))->method('leaveNode')->with($mulNode);
-        $visitor2->expects($this->at(5))->method('leaveNode')->with($mulNode);
-
-        $visitor1->expects($this->at(6))->method('leaveNode')->with($negNode);
-        $visitor2->expects($this->at(6))->method('leaveNode')->with($negNode);
+        $expectedTrace = [
+            ['beforeTraverse', $stmts],
+            ['enterNode', $printNode],
+            ['leaveNode', $printNode],
+            ['enterNode', $negNode],
+            ['enterNode', $mulNode],
+            ['leaveNode', $mulNode],
+            ['leaveNode', $negNode],
+            ['afterTraverse', $stmts],
+        ];
 
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor1);
         $traverser->addVisitor($visitor2);
 
         $this->assertEquals($stmts, $traverser->traverse($stmts));
+        $this->assertEquals($expectedTrace, $visitor1->trace);
+        $this->assertEquals($expectedTrace, $visitor2->trace);
     }
 
     public function testDontTraverseCurrentAndChildren() {
@@ -173,30 +151,36 @@ class NodeTraverserTest extends \PHPUnit\Framework\TestCase
         $negNode = new Expr\UnaryMinus($mulNode);
         $stmts = [$printNode, $negNode];
 
-        $visitor1 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor2 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-
-        $visitor1->expects($this->at(1))->method('enterNode')->with($printNode)
-            ->willReturn(NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN);
-        $visitor1->expects($this->at(2))->method('leaveNode')->with($printNode);
-
-        $visitor1->expects($this->at(3))->method('enterNode')->with($negNode);
-        $visitor2->expects($this->at(1))->method('enterNode')->with($negNode);
-
-        $visitor1->expects($this->at(4))->method('enterNode')->with($mulNode)
-            ->willReturn(NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN);
-        $visitor1->expects($this->at(5))->method('leaveNode')->with($mulNode)->willReturn($divNode);
-
-        $visitor1->expects($this->at(6))->method('leaveNode')->with($negNode);
-        $visitor2->expects($this->at(2))->method('leaveNode')->with($negNode);
+        $visitor1 = new NodeVisitorForTesting([
+            ['enterNode', $printNode, NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN],
+            ['enterNode', $mulNode, NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN],
+            ['leaveNode', $mulNode, $divNode],
+        ]);
+        $visitor2 = new NodeVisitorForTesting();
 
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor1);
         $traverser->addVisitor($visitor2);
 
         $resultStmts = $traverser->traverse($stmts);
-
         $this->assertInstanceOf(Expr\BinaryOp\Div::class, $resultStmts[1]->expr);
+
+        $this->assertEquals([
+            ['beforeTraverse', $stmts],
+            ['enterNode', $printNode],
+            ['leaveNode', $printNode],
+            ['enterNode', $negNode],
+            ['enterNode', $mulNode],
+            ['leaveNode', $mulNode],
+            ['leaveNode', $negNode],
+            ['afterTraverse', $resultStmts],
+        ], $visitor1->trace);
+        $this->assertEquals([
+            ['beforeTraverse', $stmts],
+            ['enterNode', $negNode],
+            ['leaveNode', $negNode],
+            ['afterTraverse', $resultStmts],
+        ], $visitor2->trace);
     }
 
     public function testStopTraversal() {
@@ -208,58 +192,90 @@ class NodeTraverserTest extends \PHPUnit\Framework\TestCase
         $stmts = [$mulNode, $printNode];
 
         // From enterNode() with array parent
-        $visitor = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor->expects($this->at(1))->method('enterNode')->with($mulNode)
-            ->willReturn(NodeTraverser::STOP_TRAVERSAL);
-        $visitor->expects($this->at(2))->method('afterTraverse');
+        $visitor = new NodeVisitorForTesting([
+            ['enterNode', $mulNode, NodeTraverser::STOP_TRAVERSAL],
+        ]);
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor);
         $this->assertEquals($stmts, $traverser->traverse($stmts));
+        $this->assertEquals([
+            ['beforeTraverse', $stmts],
+            ['enterNode', $mulNode],
+            ['afterTraverse', $stmts],
+        ], $visitor->trace);
 
         // From enterNode with Node parent
-        $visitor = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor->expects($this->at(2))->method('enterNode')->with($varNode1)
-            ->willReturn(NodeTraverser::STOP_TRAVERSAL);
-        $visitor->expects($this->at(3))->method('afterTraverse');
+        $visitor = new NodeVisitorForTesting([
+            ['enterNode', $varNode1, NodeTraverser::STOP_TRAVERSAL],
+        ]);
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor);
         $this->assertEquals($stmts, $traverser->traverse($stmts));
+        $this->assertEquals([
+            ['beforeTraverse', $stmts],
+            ['enterNode', $mulNode],
+            ['enterNode', $varNode1],
+            ['afterTraverse', $stmts],
+        ], $visitor->trace);
 
         // From leaveNode with Node parent
-        $visitor = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor->expects($this->at(3))->method('leaveNode')->with($varNode1)
-            ->willReturn(NodeTraverser::STOP_TRAVERSAL);
-        $visitor->expects($this->at(4))->method('afterTraverse');
+        $visitor = new NodeVisitorForTesting([
+            ['leaveNode', $varNode1, NodeTraverser::STOP_TRAVERSAL],
+        ]);
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor);
         $this->assertEquals($stmts, $traverser->traverse($stmts));
+        $this->assertEquals([
+            ['beforeTraverse', $stmts],
+            ['enterNode', $mulNode],
+            ['enterNode', $varNode1],
+            ['leaveNode', $varNode1],
+            ['afterTraverse', $stmts],
+        ], $visitor->trace);
 
         // From leaveNode with array parent
-        $visitor = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor->expects($this->at(6))->method('leaveNode')->with($mulNode)
-            ->willReturn(NodeTraverser::STOP_TRAVERSAL);
-        $visitor->expects($this->at(7))->method('afterTraverse');
+        $visitor = new NodeVisitorForTesting([
+            ['leaveNode', $mulNode, NodeTraverser::STOP_TRAVERSAL],
+        ]);
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor);
         $this->assertEquals($stmts, $traverser->traverse($stmts));
+        $this->assertEquals([
+            ['beforeTraverse', $stmts],
+            ['enterNode', $mulNode],
+            ['enterNode', $varNode1],
+            ['leaveNode', $varNode1],
+            ['enterNode', $varNode2],
+            ['leaveNode', $varNode2],
+            ['leaveNode', $mulNode],
+            ['afterTraverse', $stmts],
+        ], $visitor->trace);
 
         // Check that pending array modifications are still carried out
-        $visitor = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor->expects($this->at(6))->method('leaveNode')->with($mulNode)
-            ->willReturn(NodeTraverser::REMOVE_NODE);
-        $visitor->expects($this->at(7))->method('enterNode')->with($printNode)
-            ->willReturn(NodeTraverser::STOP_TRAVERSAL);
-        $visitor->expects($this->at(8))->method('afterTraverse');
+        $visitor = new NodeVisitorForTesting([
+            ['leaveNode', $mulNode, NodeTraverser::REMOVE_NODE],
+            ['enterNode', $printNode, NodeTraverser::STOP_TRAVERSAL],
+        ]);
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor);
         $this->assertEquals([$printNode], $traverser->traverse($stmts));
-
+        $this->assertEquals([
+            ['beforeTraverse', $stmts],
+            ['enterNode', $mulNode],
+            ['enterNode', $varNode1],
+            ['leaveNode', $varNode1],
+            ['enterNode', $varNode2],
+            ['leaveNode', $varNode2],
+            ['leaveNode', $mulNode],
+            ['enterNode', $printNode],
+            ['afterTraverse', [$printNode]],
+        ], $visitor->trace);
     }
 
     public function testRemovingVisitor() {
-        $visitor1 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor2 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor3 = $this->getMockBuilder(NodeVisitor::class)->getMock();
+        $visitor1 = new class extends NodeVisitorAbstract {};
+        $visitor2 = new class extends NodeVisitorAbstract {};
+        $visitor3 = new class extends NodeVisitorAbstract {};
 
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor1);
@@ -290,59 +306,54 @@ class NodeTraverserTest extends \PHPUnit\Framework\TestCase
     /**
      * @dataProvider provideTestInvalidReturn
      */
-    public function testInvalidReturn($visitor, $message) {
+    public function testInvalidReturn($stmts, $visitor, $message) {
         $this->expectException(\LogicException::class);
         $this->expectExceptionMessage($message);
 
-        $stmts = [new Node\Stmt\Expression(new Node\Scalar\LNumber(42))];
-
         $traverser = new NodeTraverser();
         $traverser->addVisitor($visitor);
         $traverser->traverse($stmts);
     }
 
     public function provideTestInvalidReturn() {
-        $visitor1 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor1->expects($this->at(1))->method('enterNode')
-            ->willReturn('foobar');
+        $num = new Node\Scalar\LNumber(42);
+        $expr = new Node\Stmt\Expression($num);
+        $stmts = [$expr];
 
-        $visitor2 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor2->expects($this->at(2))->method('enterNode')
-            ->willReturn('foobar');
-
-        $visitor3 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor3->expects($this->at(3))->method('leaveNode')
-            ->willReturn('foobar');
-
-        $visitor4 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor4->expects($this->at(4))->method('leaveNode')
-            ->willReturn('foobar');
-
-        $visitor5 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor5->expects($this->at(3))->method('leaveNode')
-            ->willReturn([new Node\Scalar\DNumber(42.0)]);
-
-        $visitor6 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor6->expects($this->at(4))->method('leaveNode')
-            ->willReturn(false);
-
-        $visitor7 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor7->expects($this->at(1))->method('enterNode')
-            ->willReturn(new Node\Scalar\LNumber(42));
-
-        $visitor8 = $this->getMockBuilder(NodeVisitor::class)->getMock();
-        $visitor8->expects($this->at(2))->method('enterNode')
-            ->willReturn(new Node\Stmt\Return_());
+        $visitor1 = new NodeVisitorForTesting([
+            ['enterNode', $expr, 'foobar'],
+        ]);
+        $visitor2 = new NodeVisitorForTesting([
+            ['enterNode', $num, 'foobar'],
+        ]);
+        $visitor3 = new NodeVisitorForTesting([
+            ['leaveNode', $num, 'foobar'],
+        ]);
+        $visitor4 = new NodeVisitorForTesting([
+            ['leaveNode', $expr, 'foobar'],
+        ]);
+        $visitor5 = new NodeVisitorForTesting([
+            ['leaveNode', $num, [new Node\Scalar\DNumber(42.0)]],
+        ]);
+        $visitor6 = new NodeVisitorForTesting([
+            ['leaveNode', $expr, false],
+        ]);
+        $visitor7 = new NodeVisitorForTesting([
+            ['enterNode', $expr, new Node\Scalar\LNumber(42)],
+        ]);
+        $visitor8 = new NodeVisitorForTesting([
+            ['enterNode', $num, new Node\Stmt\Return_()],
+        ]);
 
         return [
-            [$visitor1, 'enterNode() returned invalid value of type string'],
-            [$visitor2, 'enterNode() returned invalid value of type string'],
-            [$visitor3, 'leaveNode() returned invalid value of type string'],
-            [$visitor4, 'leaveNode() returned invalid value of type string'],
-            [$visitor5, 'leaveNode() may only return an array if the parent structure is an array'],
-            [$visitor6, 'bool(false) return from leaveNode() no longer supported. Return NodeTraverser::REMOVE_NODE instead'],
-            [$visitor7, 'Trying to replace statement (Stmt_Expression) with expression (Scalar_LNumber). Are you missing a Stmt_Expression wrapper?'],
-            [$visitor8, 'Trying to replace expression (Scalar_LNumber) with statement (Stmt_Return)'],
+            [$stmts, $visitor1, 'enterNode() returned invalid value of type string'],
+            [$stmts, $visitor2, 'enterNode() returned invalid value of type string'],
+            [$stmts, $visitor3, 'leaveNode() returned invalid value of type string'],
+            [$stmts, $visitor4, 'leaveNode() returned invalid value of type string'],
+            [$stmts, $visitor5, 'leaveNode() may only return an array if the parent structure is an array'],
+            [$stmts, $visitor6, 'bool(false) return from leaveNode() no longer supported. Return NodeTraverser::REMOVE_NODE instead'],
+            [$stmts, $visitor7, 'Trying to replace statement (Stmt_Expression) with expression (Scalar_LNumber). Are you missing a Stmt_Expression wrapper?'],
+            [$stmts, $visitor8, 'Trying to replace expression (Scalar_LNumber) with statement (Stmt_Return)'],
         ];
     }
 }

test/PhpParser/NodeVisitor/NameResolverTest.php

@@ -165,13 +165,8 @@ namespace Baz {
 }
 EOC;
 
-        $parser        = new PhpParser\Parser\Php7(new PhpParser\Lexer\Emulative);
         $prettyPrinter = new PhpParser\PrettyPrinter\Standard;
-        $traverser     = new PhpParser\NodeTraverser;
-        $traverser->addVisitor(new NameResolver);
-
-        $stmts = $parser->parse($code);
-        $stmts = $traverser->traverse($stmts);
+        $stmts = $this->parseAndResolve($code);
 
         $this->assertSame(
             $this->canonicalize($expectedCode),
@@ -187,33 +182,49 @@ EOC;
 <?php
 namespace NS;
 
+#[X]
 class A extends B implements C, D {
     use E, F, G {
         f as private g;
         E::h as i;
         E::j insteadof F, G;
     }
+    
+    #[X]
+    public float $php = 7.4;
+    public ?Foo $person;
+    protected static ?bool $probability;
+    public A|B|int $prop;
+
+    #[X]
+    const C = 1;
 }
 
+#[X]
 interface A extends C, D {
     public function a(A $a) : A;
     public function b(A|B|int $a): A|B|int;
 }
 
-class ClassWithTypeProperties {
-    public float $php = 7.4;
-    public ?Foo $person;
-    protected static ?bool $probability;
-    public A|B|int $prop;
+#[X]
+enum E: int {
+    #[X]
+    case A = 1;
 }
 
-function f(A $a) : A {}
-function f2(array $a) : array {}
-function(A $a) : A {};
+#[X]
+trait A {}
 
+#[X]
+function f(#[X] A $a) : A {}
+function f2(array $a) : array {}
 function fn3(?A $a) : ?A {}
 function fn4(?array $a) : ?array {}
 
+#[X]
+function(A $a) : A {};
+
+#[X]
 fn(array $a): array => $a;
 fn(A $a): A => $a;
 fn(?A $a): ?A => $a;
@@ -236,6 +247,7 @@ EOC;
         $expectedCode = <<<'EOC'
 namespace NS;
 
+#[\NS\X]
 class A extends \NS\B implements \NS\C, \NS\D
 {
     use \NS\E, \NS\F, \NS\G {
@@ -243,34 +255,46 @@ class A extends \NS\B implements \NS\C, \NS\D
         \NS\E::h as i;
         \NS\E::j insteadof \NS\F, \NS\G;
     }
+    #[\NS\X]
+    public float $php = 7.4;
+    public ?\NS\Foo $person;
+    protected static ?bool $probability;
+    public \NS\A|\NS\B|int $prop;
+    #[\NS\X]
+    const C = 1;
 }
+#[\NS\X]
 interface A extends \NS\C, \NS\D
 {
     public function a(\NS\A $a) : \NS\A;
     public function b(\NS\A|\NS\B|int $a) : \NS\A|\NS\B|int;
 }
-class ClassWithTypeProperties
+#[\NS\X]
+enum E : int
 {
-    public float $php = 7.4;
-    public ?\NS\Foo $person;
-    protected static ?bool $probability;
-    public \NS\A|\NS\B|int $prop;
+    #[\NS\X]
+    case A = 1;
 }
-function f(\NS\A $a) : \NS\A
+#[\NS\X]
+trait A
+{
+}
+#[\NS\X]
+function f(#[\NS\X] \NS\A $a) : \NS\A
 {
 }
 function f2(array $a) : array
 {
 }
-function (\NS\A $a) : \NS\A {
-};
 function fn3(?\NS\A $a) : ?\NS\A
 {
 }
 function fn4(?array $a) : ?array
 {
 }
-fn(array $a): array => $a;
+#[\NS\X] function (\NS\A $a) : \NS\A {
+};
+#[\NS\X] fn(array $a): array => $a;
 fn(\NS\A $a): \NS\A => $a;
 fn(?\NS\A $a): ?\NS\A => $a;
 \NS\A::b();
@@ -287,13 +311,8 @@ try {
 }
 EOC;
 
-        $parser        = new PhpParser\Parser\Php7(new PhpParser\Lexer\Emulative);
         $prettyPrinter = new PhpParser\PrettyPrinter\Standard;
-        $traverser     = new PhpParser\NodeTraverser;
-        $traverser->addVisitor(new NameResolver);
-
-        $stmts = $parser->parse($code);
-        $stmts = $traverser->traverse($stmts);
+        $stmts = $this->parseAndResolve($code);
 
         $this->assertSame(
             $this->canonicalize($expectedCode),
@@ -320,6 +339,7 @@ EOC;
             ]),
             new Stmt\Trait_('E'),
             new Expr\New_(new Stmt\Class_(null)),
+            new Stmt\Enum_('F'),
         ];
 
         $traverser = new PhpParser\NodeTraverser;
@@ -332,6 +352,7 @@ EOC;
         $this->assertSame('NS\\D', (string) $stmts[0]->stmts[3]->consts[0]->namespacedName);
         $this->assertSame('NS\\E', (string) $stmts[0]->stmts[4]->namespacedName);
         $this->assertObjectNotHasAttribute('namespacedName', $stmts[0]->stmts[5]->class);
+        $this->assertSame('NS\\F', (string) $stmts[0]->stmts[6]->namespacedName);
 
         $stmts = $traverser->traverse([new Stmt\Namespace_(null, $nsStmts)]);
         $this->assertSame('A',     (string) $stmts[0]->stmts[0]->namespacedName);
@@ -340,6 +361,7 @@ EOC;
         $this->assertSame('D',     (string) $stmts[0]->stmts[3]->consts[0]->namespacedName);
         $this->assertSame('E',     (string) $stmts[0]->stmts[4]->namespacedName);
         $this->assertObjectNotHasAttribute('namespacedName', $stmts[0]->stmts[5]->class);
+        $this->assertSame('F',     (string) $stmts[0]->stmts[6]->namespacedName);
     }
 
     public function testAddRuntimeResolvedNamespacedName() {
@@ -512,4 +534,14 @@ EOC;
         $this->assertEquals(
             new Name\FullyQualified('Foo\bar'), $n2->getAttribute('namespacedName'));
     }
+
+    private function parseAndResolve(string $code): array
+    {
+        $parser = new PhpParser\Parser\Php7(new PhpParser\Lexer\Emulative);
+        $traverser = new PhpParser\NodeTraverser;
+        $traverser->addVisitor(new NameResolver);
+
+        $stmts = $parser->parse($code);
+        return $traverser->traverse($stmts);
+    }
 }

test/PhpParser/NodeVisitorForTesting.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpParser;
+
+class NodeVisitorForTesting implements NodeVisitor {
+    public $trace = [];
+    private $returns;
+    private $returnsPos;
+
+    public function __construct(array $returns = []) {
+        $this->returns = $returns;
+        $this->returnsPos = 0;
+    }
+
+    public function beforeTraverse(array $nodes) {
+        return $this->traceEvent('beforeTraverse', $nodes);
+    }
+
+    public function enterNode(Node $node) {
+        return $this->traceEvent('enterNode', $node);
+    }
+
+    public function leaveNode(Node $node) {
+        return $this->traceEvent('leaveNode', $node);
+    }
+
+    public function afterTraverse(array $nodes) {
+        return $this->traceEvent('afterTraverse', $nodes);
+    }
+
+    private function traceEvent(string $method, $param) {
+        $this->trace[] = [$method, $param];
+        if ($this->returnsPos < count($this->returns)) {
+            $currentReturn = $this->returns[$this->returnsPos];
+            if ($currentReturn[0] === $method && $currentReturn[1] === $param) {
+                $this->returnsPos++;
+                return $currentReturn[2];
+            }
+        }
+        return null;
+    }
+
+    public function __destruct() {
+        if ($this->returnsPos !== count($this->returns)) {
+            throw new \Exception("Expected event did not occur");
+        }
+    }
+}