Release PHP-Parser 4.9.1

Support visibility modifiers in namespaced names
Fixes #704.
2025-06-21 07:21:24 +02:00 · 2020-08-30 18:15:20 +02:00 · 2020-08-29 16:35:31 +02:00 · 2020-08-29 16:28:28 +02:00 · 2020-08-23 20:57:00 +02:00 · 2020-08-23 20:54:01 +02:00
297 changed files with 9803 additions and 4185 deletions
--- a/.gitattributes
+++ b/.gitattributes
@ -0,0 +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
+phpunit.xml.dist export-ignore
+UPGRADE-*.md export-ignore
--- a/.gitignore
+++ b/.gitignore
@ -2,3 +2,4 @@ vendor/
 composer.lock
 grammar/kmyacc.exe
 grammar/y.output
+.phpunit.result.cache
--- a/.travis.yml
+++ b/.travis.yml
@ -1,30 +1,43 @@
 language: php
 dist: xenial
-sudo: false

-cache:
-  directories:
-    - $HOME/.composer/cache
+before_install: composer self-update --2

-php:
-  - 7.0
-  - 7.1
-  - 7.2
-  - 7.3
-  - nightly
-
-install:
-  - if [ $TRAVIS_PHP_VERSION = '7.0' ]; then composer require satooshi/php-coveralls '~1.0'; fi
-  - composer install --prefer-dist
+install: composer update --no-progress --prefer-dist

 matrix:
+  include:
+    - name: PHP 7.0 Unit Tests
+      php: 7.0
+      install:
+        - composer require php-coveralls/php-coveralls:^2.2 --dev --no-update
+        - composer update --no-progress --prefer-dist
+      script: vendor/bin/phpunit --coverage-clover build/logs/clover.xml
+      after_success: php vendor/bin/coveralls
+    - name: PHP 7.1 Unit Tests
+      php: 7.1
+    - name: PHP 7.2 Unit Tests
+      php: 7.2
+    - name: PHP 7.3 Unit Tests
+      php: 7.3
+    - name: PHP 7.4 Unit Tests
+      php: 7.4
+    - name: PHP 8.0 Unit Tests
+      php: nightly
+      install:
+        - composer update --ignore-platform-req=php --no-progress --prefer-dist
+    - name: PHP 7.3 Code on PHP 8.0 Integration Tests
+      php: nightly
+      install:
+        - composer update --ignore-platform-req=php --no-progress --prefer-dist
+      script:
+        - test_old/run-php-src.sh 7.3.21
+    - name: PHP 8.0 Code on PHP 7.0 Integration Tests
+      php: 7.0
+      script:
+        - test_old/run-php-src.sh 8.0.0beta1
  allow_failures:
-    - php: nightly
+    - name: PHP 8.0 Code on PHP 7.0 Integration Tests
  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
+script: vendor/bin/phpunit
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,15 +1,198 @@
-Version 4.1.2-dev
+Version 4.9.2-dev
 -----------------

 Nothing yet.

+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)
+--------------------------
+
+### Added
+
+* Add `ParentConnectingVisitor` and `NodeConnectingVisitor` classes.
+* [PHP 8.0] Added support for match expressions. These are represented using a new `Expr\Match_`
+  containing `MatchArm`s.
+* [PHP 8.0] Added support for trailing comma in closure use lists.
+
+### Fixed
+
+* Fixed missing error for unterminated comment with trailing newline (#688).
+* Compatibility with PHP 8.0 has been restored: Namespaced names are now always represented by
+  `T_NAME_*` tokens, using emulationg on older PHP versions. Full support for reserved keywords
+  in namespaced names is not yet present.
+
+Version 4.6.0 (2020-07-02)
+--------------------------
+
+### Added
+
+* [PHP 8.0] Added support for trailing commas in parameter lists.
+* [PHP 8.0] Added support for constructor promotion. The parameter visibility is stored in
+  `Node\Param::$flags`.
+
+### Fixed
+
+* Comment tokens now always follow the PHP 8 interpretation, and do not include trailing
+  whitespace.
+* As a result of the previous change, some whitespace issues when inserting a statement into a
+  method containing only a comment, and using the formatting-preserving pretty printer, have been
+  resolved.
+
+Version 4.5.0 (2020-06-03)
+--------------------------
+
+### Added
+
+* [PHP 8.0] Added support for the mixed type. This means `mixed` types are now parsed as an
+  `Identifier` rather than a `Name`.
+* [PHP 8.0] Added support for catching without capturing the exception. This means that
+  `Catch_::$var` may now be null.
+
+Version 4.4.0 (2020-04-10)
+--------------------------
+
+### Added
+
+* Added support for passing union types in builders.
+* Added end line, token position and file position information for comments.
+* Added `getProperty()` method to `ClassLike` nodes.
+
+### Fixed
+
+* Fixed generation of invalid code when using the formatting preserving pretty printer, and
+  inserting code next to certain nop statements. The formatting is still ugly though.
+* `getDocComment()` no longer requires that the very last comment before a node be a doc comment.
+  There may not be non-doc comments between the doc comment and the declaration.
+* Allowed arbitrary expressions in `isset()` and `list()`, rather than just variables.
+  In particular, this allows `isset(($x))`, which is legal PHP code.
+* [PHP 8.0] Add support for [variable syntax tweaks RFC](https://wiki.php.net/rfc/variable_syntax_tweaks).
+
+Version 4.3.0 (2019-11-08)
+--------------------------
+
+### Added
+
+* [PHP 8.0] Added support for union types using a new `UnionType` node.
+
+Version 4.2.5 (2019-10-25)
+--------------------------
+
+### Changed
+
+* Tests and documentation are no longer included in source archives. They can still be accessed
+  by cloning the repository.
+* php-yacc is now used to generate the parser. This has no impact on users of the library.
+
+Version 4.2.4 (2019-09-01)
+--------------------------
+
+### Added
+
+* Added getProperties(), getConstants() and getTraitUses() to ClassLike. (#629, #630)
+
+### Fixed
+
+* Fixed flexible heredoc emulation to check for digits after the end label. This synchronizes
+  behavior with the upcoming PHP 7.3.10 release.
+
+Version 4.2.3 (2019-08-12)
+--------------------------
+
+### Added
+
+* [PHP 7.4] Add support for numeric literal separators. (#615)
+
+### Fixed
+
+* Fixed resolution of return types for arrow functions. (#613)
+* Fixed compatibility with PHP 7.4.
+
+Version 4.2.2 (2019-05-25)
+--------------------------
+
+### Added
+
+* [PHP 7.4] Add support for arrow functions using a new `Expr\ArrowFunction` node. (#602)
+* [PHP 7.4] Add support for array spreads, using a new `unpack` subnode on `ArrayItem`. (#609)
+* Added support for inserting into empty list nodes in the formatting preserving pretty printer.
+
+### Changed
+
+* `php-parse` will now print messages to stderr, so that stdout only contains the actual result of
+  the operation (such as a JSON dump). (#605)
+
+### Fixed
+
+* Fixed attribute assignment for zero-length nop statements, and a related assertion failure in
+  the formatting-preserving pretty printer. (#589)
+
+Version 4.2.1 (2019-02-16)
+--------------------------
+
+### Added
+
+* [PHP 7.4] Add support for `??=` operator through a new `AssignOp\Coalesce` node. (#575)
+
+Version 4.2.0 (2019-01-12)
+--------------------------
+
+### Added
+
+* [PHP 7.4] Add support for typed properties through a new `type` subnode of `Stmt\Property`.
+  Additionally `Builder\Property` now has a `setType()` method. (#567)
+* Add `kind` attribute to `Cast\Double_`, which allows to distinguish between `(float)`,
+  `(double)` and `(real)`. The form of the cast will be preserved by the pretty printer. (#565)
+
+### Fixed
+
+* Remove assertion when pretty printing anonymous class with a name (#554).
+
 Version 4.1.1 (2018-12-26)
 --------------------------

 ### Fixed

 * Fix "undefined offset" notice when parsing specific malformed code (#551).
-* Remove assertion when pretty printing anonymous class with a name (#554).

 ### Added

--- a/44
+++ b/44
@ -1,31 +1,29 @@
-Copyright (c) 2011-2018 by Nikita Popov.
+BSD 3-Clause License

-Some rights reserved.
+Copyright (c) 2011, Nikita Popov
+All rights reserved.

 Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
+modification, are permitted provided that the following conditions are met:

-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.

-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.

-    * The names of the contributors may not be used to endorse or
-      promote products derived from this software without specific
-      prior written permission.
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.

-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/README.md
+++ b/README.md
@ -3,10 +3,10 @@ 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)

-This is a PHP 5.2 to PHP 7.3 parser written in PHP. Its purpose is to simplify static code analysis and
+This is a PHP 5.2 to PHP 7.4 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.3).
+[**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 3.x][doc_3_x] (unsupported; for running on PHP >= 5.5; for parsing PHP 5.2 to PHP 7.2).

--- a/bin/php-parse
+++ b/bin/php-parse
@ -45,14 +45,15 @@ $traverser->addVisitor(new PhpParser\NodeVisitor\NameResolver);
 foreach ($files as $file) {
    if (strpos($file, '<?php') === 0) {
        $code = $file;
-        echo "====> Code $code\n";
+        fwrite(STDERR, "====> Code $code\n");
    } else {
        if (!file_exists($file)) {
-            die("File $file does not exist.\n");
+            fwrite(STDERR, "File $file does not exist.\n");
+            exit(1);
        }

        $code = file_get_contents($file);
-        echo "====> File $file:\n";
+        fwrite(STDERR, "====> File $file:\n");
    }

    if ($attributes['with-recovery']) {
@ -60,7 +61,7 @@ foreach ($files as $file) {
        $stmts = $parser->parse($code, $errorHandler);
        foreach ($errorHandler->getErrors() as $error) {
            $message = formatErrorMessage($error, $code, $attributes['with-column-info']);
-            echo $message . "\n";
+            fwrite(STDERR, $message . "\n");
        }
        if (null === $stmts) {
            continue;
@ -70,25 +71,26 @@ foreach ($files as $file) {
            $stmts = $parser->parse($code);
        } catch (PhpParser\Error $error) {
            $message = formatErrorMessage($error, $code, $attributes['with-column-info']);
-            die($message . "\n");
+            fwrite(STDERR, $message . "\n");
+            exit(1);
        }
    }

    foreach ($operations as $operation) {
        if ('dump' === $operation) {
-            echo "==> Node dump:\n";
+            fwrite(STDERR, "==> Node dump:\n");
            echo $dumper->dump($stmts, $code), "\n";
        } elseif ('pretty-print' === $operation) {
-            echo "==> Pretty print:\n";
+            fwrite(STDERR, "==> Pretty print:\n");
            echo $prettyPrinter->prettyPrintFile($stmts), "\n";
        } elseif ('json-dump' === $operation) {
-            echo "==> JSON dump:\n";
+            fwrite(STDERR, "==> JSON dump:\n");
            echo json_encode($stmts, JSON_PRETTY_PRINT), "\n";
        } elseif ('var-dump' === $operation) {
-            echo "==> var_dump():\n";
+            fwrite(STDERR, "==> var_dump():\n");
            var_dump($stmts);
        } elseif ('resolve-names' === $operation) {
-            echo "==> Resolved names.\n";
+            fwrite(STDERR, "==> Resolved names.\n");
            $stmts = $traverser->traverse($stmts);
        }
    }
@ -104,9 +106,9 @@ function formatErrorMessage(PhpParser\Error $e, $code, $withColumnInfo) {

 function showHelp($error = '') {
    if ($error) {
-        echo $error . "\n\n";
+        fwrite(STDERR, $error . "\n\n");
    }
-    die(<<<OUTPUT
+    fwrite($error ? STDERR : STDOUT, <<<OUTPUT
 Usage: php-parse [operations] file1.php [file2.php ...]
   or: php-parse [operations] "<?php code"
 Turn PHP source code into an abstract syntax tree.
@ -131,6 +133,7 @@ Example:

 OUTPUT
    );
+    exit($error ? 1 : 0);
 }

 function parseArgs($args) {
--- a/composer.json
+++ b/composer.json
@ -1,8 +1,11 @@
 {
    "name": "nikic/php-parser",
-    "description": "A PHP parser written in PHP",
-    "keywords": ["php", "parser"],
    "type": "library",
+    "description": "A PHP parser written in PHP",
+    "keywords": [
+        "php",
+        "parser"
+    ],
    "license": "BSD-3-Clause",
    "authors": [
        {
@ -14,17 +17,25 @@
        "ext-tokenizer": "*"
    },
    "require-dev": {
-        "phpunit/phpunit": "^6.5 || ^7.0"
+        "phpunit/phpunit": "^6.5 || ^7.0 || ^8.0 || ^9.0",
+        "ircmaxell/php-yacc": "^0.0.7"
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "4.9-dev"
+        }
    },
    "autoload": {
        "psr-4": {
            "PhpParser\\": "lib/PhpParser"
        }
    },
-    "bin": ["bin/php-parse"],
-    "extra": {
-        "branch-alias": {
-            "dev-master": "4.1-dev"
+    "autoload-dev": {
+        "psr-4": {
+            "PhpParser\\": "test/PhpParser/"
        }
-    }
+    },
+    "bin": [
+        "bin/php-parse"
+    ]
 }
--- a/doc/0_Introduction.markdown
+++ b/doc/0_Introduction.markdown
@ -1,7 +1,7 @@
 Introduction
 ============

-This project is a PHP 5.2 to PHP 7.3 parser **written in PHP itself**.
+This project is a PHP 5.2 to PHP 7.4 parser **written in PHP itself**.

 What is this for?
 -----------------
@ -26,11 +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.3.
+The parser supports parsing PHP 5.2-7.4.

 As the parser is based on the tokens returned by `token_get_all` (which is only able to lex the PHP
 version it runs on), additionally a wrapper for emulating tokens from newer versions is provided.
-This allows to parse PHP 7.3 source code running on PHP 7.0, for example. This emulation is somewhat
+This allows to parse PHP 7.4 source code running on PHP 7.0, for example. This emulation is somewhat
 hacky and not perfect, but it should work well on any sane code.

 What output does it produce?
@ -56,7 +56,7 @@ array(
 ```

 This matches the structure of the code: An echo statement, which takes two strings as expressions,
-with the values `Hi` and `World!`.
+with the values `Hi` and `World`.

 You can also see that the AST does not contain any whitespace information (but most comments are saved).
 So using it for formatting analysis is not possible.
--- a/doc/2_Usage_of_basic_components.markdown
+++ b/doc/2_Usage_of_basic_components.markdown
@ -77,7 +77,7 @@ A parser instance can be reused to parse multiple files.
 Node dumping
 ------------

-To dump the abstact syntax tree in human readable form, a `NodeDumper` can be used:
+To dump the abstract syntax tree in human readable form, a `NodeDumper` can be used:

 ```php
 <?php
--- a/doc/component/AST_builders.markdown
+++ b/doc/component/AST_builders.markdown
@ -48,7 +48,7 @@ $node = $factory->namespace('Name\Space')
            ->makePublic()
            ->makeAbstract() // ->makeFinal()
            ->setReturnType('bool') // ->makeReturnByRef()
-            ->addParam($factory->param('someParam')->setTypeHint('SomeClass'))
+            ->addParam($factory->param('someParam')->setType('SomeClass'))
            ->setDocComment('/**
                              * This method does something.
                              *
--- a/doc/component/FAQ.markdown
+++ b/doc/component/FAQ.markdown
@ -7,28 +7,21 @@ Frequently Asked Questions
 How can the parent of a node be obtained?
 -----

-The AST does not store parent nodes by default. However, it is easy to add a custom parent node
-attribute using a custom node visitor:
+The AST does not store parent nodes by default. However, the `ParentConnectingVisitor` can be used to achieve this:

 ```php
-use PhpParser\Node;
-use PhpParser\NodeVisitorAbstract;
+use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitor\ParentConnectingVisitor;
+use PhpParser\ParserFactory;

-class ParentConnector extends NodeVisitorAbstract {
-    private $stack;
-    public function beforeTraverse(array $nodes) {
-        $this->stack = [];
-    }
-    public function enterNode(Node $node) {
-        if (!empty($this->stack)) {
-            $node->setAttribute('parent', $this->stack[count($this->stack)-1]);
-        }
-        $this->stack[] = $node;
-    }
-    public function leaveNode(Node $node) {
-        array_pop($this->stack);
-    }
-}
+$code = '...';
+
+$traverser = new NodeTraverser;
+$traverser->addVisitor(new ParentConnectingVisitor);
+
+$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
+$ast    = $parser->parse($code);
+$ast    = $traverser->traverse($ast);
 ```

 After running this visitor, the parent node can be obtained through `$node->getAttribute('parent')`.
@ -36,33 +29,27 @@ After running this visitor, the parent node can be obtained through `$node->getA
 How can the next/previous sibling of a node be obtained?
 -----

-Again, siblings are not stored by default, but the visitor from the previous entry can be easily
-extended to store the previous / next node with a common parent as well:
+Again, siblings are not stored by default, but the `NodeConnectingVisitor` can be used to store
+the previous / next node with a common parent as well:

 ```php
-use PhpParser\Node;
-use PhpParser\NodeVisitorAbstract;
+use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitor\NodeConnectingVisitor;
+use PhpParser\ParserFactory;

-class NodeConnector extends NodeVisitorAbstract {
-    private $stack;
-    private $prev;
-    public function beforeTraverse(array $nodes) {
-        $this->stack = [];
-        $this->prev = null;
-    }
-    public function enterNode(Node $node) {
-        if (!empty($this->stack)) {
-            $node->setAttribute('parent', $this->stack[count($this->stack)-1]);
-        }
-        if ($this->prev && $this->prev->getAttribute('parent') == $node->getAttribute('parent')) {
-            $node->setAttribute('prev', $this->prev);
-            $this->prev->setAttribute('next', $node);
-        }
-        $this->stack[] = $node;
-    }
-    public function leaveNode(Node $node) {
-        $this->prev = $node;
-        array_pop($this->stack);
-    }
-}
+$code = '...';
+
+$traverser = new NodeTraverser;
+$traverser->addVisitor(new NodeConnectingVisitor);
+
+$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
+$ast    = $parser->parse($code);
+$ast    = $traverser->traverse($ast);
 ```
+
+After running this visitor, the parent node can be obtained through `$node->getAttribute('parent')`,
+the previous node can be obtained through `$node->getAttribute('previous')`, and the next node can be
+obtained through `$node->getAttribute('next')`.
+
+`ParentConnectingVisitor` and `NodeConnectingVisitor` should not be used at the same time. The latter
+includes the functionality of the former.
--- a/doc/component/Walking_the_AST.markdown
+++ b/doc/component/Walking_the_AST.markdown
@ -295,7 +295,7 @@ Simple node finding

 While the node visitor mechanism is very flexible, creating a node visitor can be overly cumbersome
 for minor tasks. For this reason a `NodeFinder` is provided, which can find AST nodes that either
-satisfy a certain callback, or which are instanced of a certain node type. A couple of examples are
+satisfy a certain callback, or which are instances of a certain node type. A couple of examples are
 shown in the following:

 ```php
@ -312,7 +312,7 @@ $extendingClasses = $nodeFinder->find($stmts, function(Node $node) {
        && $node->extends !== null;
 });

-// Find first class occuring in the AST. Returns null if no class exists.
+// Find first class occurring in the AST. Returns null if no class exists.
 $class = $nodeFinder->findFirstInstanceOf($stmts, Node\Stmt\Class_::class);

 // Find first class that has name $name
--- a/grammar/README.md
+++ b/grammar/README.md
@ -21,8 +21,10 @@ applied to it:
 Building the parser
 ===================

-In order to rebuild the parser, you need [moriyoshi's fork of kmyacc](https://github.com/moriyoshi/kmyacc-forked).
-After you compiled/installed it, run the `rebuildParsers.php` script.
+Run `php grammar/rebuildParsers.php` to rebuild the parsers. Additional options:

-By default only the `Parser.php` is built. If you want to additionally emit debug symbols and create `y.output`, run the
-script with `--debug`. If you want to retain the preprocessed grammar pass `--keep-tmp-grammar`.
+ * The `KMYACC` environment variable can be used to specify an alternative `kmyacc` binary.
+   By default the `phpyacc` dev dependency will be used. To use the original `kmyacc`, you
+   need to compile [moriyoshi's fork](https://github.com/moriyoshi/kmyacc-forked).
+ * The `--debug` option enables emission of debug symbols and creates the `y.output` file.
+ * The `--keep-tmp-grammar` option preserves the preprocessed grammar file.
--- a/grammar/php5.y
+++ b/grammar/php5.y
@ -16,7 +16,7 @@ top_statement_list_ex:

 top_statement_list:
      top_statement_list_ex
-          { makeNop($nop, $this->lookaheadStartAttributes, $this->endAttributes);
+          { makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
            if ($nop !== null) { $1[] = $nop; } $$ = $1; }
 ;

@ -27,7 +27,8 @@ reserved_non_modifiers:
    | 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_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
 ;

 semi_reserved:
@ -48,13 +49,14 @@ reserved_non_modifiers_identifier:
      reserved_non_modifiers                                { $$ = Node\Identifier[$1]; }
 ;

-namespace_name_parts:
-      T_STRING                                              { init($1); }
-    | namespace_name_parts T_NS_SEPARATOR T_STRING          { push($1, $3); }
+namespace_name:
+      T_STRING                                              { $$ = Name[$1]; }
+    | T_NAME_QUALIFIED                                      { $$ = Name[$1]; }
 ;

-namespace_name:
-      namespace_name_parts                                  { $$ = Name[$1]; }
+legacy_namespace_name:
+      namespace_name                                        { $$ = $1; }
+    | T_NAME_FULLY_QUALIFIED                                { $$ = Name[substr($1, 1)]; }
 ;

 plain_variable:
@ -90,16 +92,11 @@ use_type:
    | T_CONST                                               { $$ = Stmt\Use_::TYPE_CONSTANT; }
 ;

-/* Using namespace_name_parts here to avoid s/r conflict on T_NS_SEPARATOR */
 group_use_declaration:
-      T_USE use_type namespace_name_parts T_NS_SEPARATOR '{' unprefixed_use_declarations '}'
-          { $$ = Stmt\GroupUse[new Name($3, stackAttributes(#3)), $6, $2]; }
-    | T_USE use_type T_NS_SEPARATOR namespace_name_parts T_NS_SEPARATOR '{' unprefixed_use_declarations '}'
-          { $$ = Stmt\GroupUse[new Name($4, stackAttributes(#4)), $7, $2]; }
-    | T_USE namespace_name_parts T_NS_SEPARATOR '{' inline_use_declarations '}'
-          { $$ = Stmt\GroupUse[new Name($2, stackAttributes(#2)), $5, Stmt\Use_::TYPE_UNKNOWN]; }
-    | T_USE T_NS_SEPARATOR namespace_name_parts T_NS_SEPARATOR '{' inline_use_declarations '}'
-          { $$ = Stmt\GroupUse[new Name($3, stackAttributes(#3)), $6, Stmt\Use_::TYPE_UNKNOWN]; }
+      T_USE use_type legacy_namespace_name T_NS_SEPARATOR '{' unprefixed_use_declarations '}'
+          { $$ = Stmt\GroupUse[$3, $6, $2]; }
+    | T_USE legacy_namespace_name T_NS_SEPARATOR '{' inline_use_declarations '}'
+          { $$ = Stmt\GroupUse[$2, $5, Stmt\Use_::TYPE_UNKNOWN]; }
 ;

 unprefixed_use_declarations:
@ -126,8 +123,10 @@ unprefixed_use_declaration:
 ;

 use_declaration:
-      unprefixed_use_declaration                            { $$ = $1; }
-    | T_NS_SEPARATOR unprefixed_use_declaration             { $$ = $2; }
+      legacy_namespace_name
+          { $$ = Stmt\UseUse[$1, null, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #1); }
+    | legacy_namespace_name T_AS identifier
+          { $$ = Stmt\UseUse[$1, $3, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #3); }
 ;

 inline_use_declaration:
@ -160,7 +159,7 @@ inner_statement_list_ex:

 inner_statement_list:
      inner_statement_list_ex
-          { makeNop($nop, $this->lookaheadStartAttributes, $this->endAttributes);
+          { makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
            if ($nop !== null) { $1[] = $nop; } $$ = $1; }
 ;

@ -461,7 +460,7 @@ class_statement_list_ex:

 class_statement_list:
      class_statement_list_ex
-          { makeNop($nop, $this->lookaheadStartAttributes, $this->endAttributes);
+          { makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
            if ($nop !== null) { $1[] = $nop; } $$ = $1; }
 ;

@ -579,6 +578,7 @@ expr:
    | variable T_SL_EQUAL expr                              { $$ = Expr\AssignOp\ShiftLeft [$1, $3]; }
    | variable T_SR_EQUAL expr                              { $$ = Expr\AssignOp\ShiftRight[$1, $3]; }
    | variable T_POW_EQUAL expr                             { $$ = Expr\AssignOp\Pow       [$1, $3]; }
+    | variable T_COALESCE_EQUAL expr                        { $$ = Expr\AssignOp\Coalesce  [$1, $3]; }
    | variable T_INC                                        { $$ = Expr\PostInc[$1]; }
    | T_INC variable                                        { $$ = Expr\PreInc [$2]; }
    | variable T_DEC                                        { $$ = Expr\PostDec[$1]; }
@ -628,7 +628,10 @@ expr:
    | T_REQUIRE expr                                        { $$ = Expr\Include_[$2, Expr\Include_::TYPE_REQUIRE]; }
    | T_REQUIRE_ONCE expr                                   { $$ = Expr\Include_[$2, Expr\Include_::TYPE_REQUIRE_ONCE]; }
    | T_INT_CAST expr                                       { $$ = Expr\Cast\Int_    [$2]; }
-    | T_DOUBLE_CAST expr                                    { $$ = Expr\Cast\Double  [$2]; }
+    | T_DOUBLE_CAST expr
+          { $attrs = attributes();
+            $attrs['kind'] = $this->getFloatCastKind($1);
+            $$ = new Expr\Cast\Double($2, $attrs); }
    | T_STRING_CAST expr                                    { $$ = Expr\Cast\String_ [$2]; }
    | T_ARRAY_CAST expr                                     { $$ = Expr\Cast\Array_  [$2]; }
    | T_OBJECT_CAST expr                                    { $$ = Expr\Cast\Object_ [$2]; }
@ -729,9 +732,10 @@ class_name:
 ;

 name:
-      namespace_name_parts                                  { $$ = Name[$1]; }
-    | T_NS_SEPARATOR namespace_name_parts                   { $$ = Name\FullyQualified[$2]; }
-    | T_NAMESPACE T_NS_SEPARATOR namespace_name_parts       { $$ = Name\Relative[$3]; }
+      T_STRING                                              { $$ = Name[$1]; }
+    | T_NAME_QUALIFIED                                      { $$ = Name[$1]; }
+    | T_NAME_FULLY_QUALIFIED                                { $$ = Name\FullyQualified[substr($1, 1)]; }
+    | T_NAME_RELATIVE                                       { $$ = Name\Relative[substr($1, 10)]; }
 ;

 class_name_reference:
@ -984,6 +988,7 @@ array_pair:
    | expr                                                  { $$ = Expr\ArrayItem[$1, null, false]; }
    | expr T_DOUBLE_ARROW '&' variable                      { $$ = Expr\ArrayItem[$4, $1,   true]; }
    | '&' variable                                          { $$ = Expr\ArrayItem[$2, null, true]; }
+    | T_ELLIPSIS expr                                       { $$ = Expr\ArrayItem[$2, null, false, attributes(), true]; }
 ;

 encaps_list:
--- a/grammar/php7.y
+++ b/grammar/php7.y
@ -16,7 +16,7 @@ top_statement_list_ex:

 top_statement_list:
      top_statement_list_ex
-          { makeNop($nop, $this->lookaheadStartAttributes, $this->endAttributes);
+          { makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
            if ($nop !== null) { $1[] = $nop; } $$ = $1; }
 ;

@ -27,7 +27,8 @@ reserved_non_modifiers:
    | 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_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
 ;

 semi_reserved:
@ -48,13 +49,20 @@ reserved_non_modifiers_identifier:
      reserved_non_modifiers                                { $$ = Node\Identifier[$1]; }
 ;

-namespace_name_parts:
-      T_STRING                                              { init($1); }
-    | namespace_name_parts T_NS_SEPARATOR T_STRING          { push($1, $3); }
+namespace_declaration_name:
+      T_STRING                                              { $$ = Name[$1]; }
+    | semi_reserved                                         { $$ = Name[$1]; }
+    | T_NAME_QUALIFIED                                      { $$ = Name[$1]; }
 ;

 namespace_name:
-      namespace_name_parts                                  { $$ = Name[$1]; }
+      T_STRING                                              { $$ = Name[$1]; }
+    | T_NAME_QUALIFIED                                      { $$ = Name[$1]; }
+;
+
+legacy_namespace_name:
+      namespace_name                                        { $$ = $1; }
+    | T_NAME_FULLY_QUALIFIED                                { $$ = Name[substr($1, 1)]; }
 ;

 plain_variable:
@ -81,11 +89,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($$); }
@ -104,16 +112,11 @@ use_type:
    | T_CONST                                               { $$ = Stmt\Use_::TYPE_CONSTANT; }
 ;

-/* Using namespace_name_parts here to avoid s/r conflict on T_NS_SEPARATOR */
 group_use_declaration:
-      T_USE use_type namespace_name_parts T_NS_SEPARATOR '{' unprefixed_use_declarations '}'
-          { $$ = Stmt\GroupUse[new Name($3, stackAttributes(#3)), $6, $2]; }
-    | T_USE use_type T_NS_SEPARATOR namespace_name_parts T_NS_SEPARATOR '{' unprefixed_use_declarations '}'
-          { $$ = Stmt\GroupUse[new Name($4, stackAttributes(#4)), $7, $2]; }
-    | T_USE namespace_name_parts T_NS_SEPARATOR '{' inline_use_declarations '}'
-          { $$ = Stmt\GroupUse[new Name($2, stackAttributes(#2)), $5, Stmt\Use_::TYPE_UNKNOWN]; }
-    | T_USE T_NS_SEPARATOR namespace_name_parts T_NS_SEPARATOR '{' inline_use_declarations '}'
-          { $$ = Stmt\GroupUse[new Name($3, stackAttributes(#3)), $6, Stmt\Use_::TYPE_UNKNOWN]; }
+      T_USE use_type legacy_namespace_name T_NS_SEPARATOR '{' unprefixed_use_declarations '}'
+          { $$ = Stmt\GroupUse[$3, $6, $2]; }
+    | T_USE legacy_namespace_name T_NS_SEPARATOR '{' inline_use_declarations '}'
+          { $$ = Stmt\GroupUse[$2, $5, Stmt\Use_::TYPE_UNKNOWN]; }
 ;

 unprefixed_use_declarations:
@ -153,8 +156,10 @@ unprefixed_use_declaration:
 ;

 use_declaration:
-      unprefixed_use_declaration                            { $$ = $1; }
-    | T_NS_SEPARATOR unprefixed_use_declaration             { $$ = $2; }
+      legacy_namespace_name
+          { $$ = Stmt\UseUse[$1, null, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #1); }
+    | legacy_namespace_name T_AS identifier
+          { $$ = Stmt\UseUse[$1, $3, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #3); }
 ;

 inline_use_declaration:
@ -196,7 +201,7 @@ inner_statement_list_ex:

 inner_statement_list:
      inner_statement_list_ex
-          { makeNop($nop, $this->lookaheadStartAttributes, $this->endAttributes);
+          { makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
            if ($nop !== null) { $1[] = $nop; } $$ = $1; }
 ;

@ -232,9 +237,18 @@ non_empty_statement:
    | T_RETURN optional_expr semi                           { $$ = Stmt\Return_[$2]; }
    | T_GLOBAL global_var_list semi                         { $$ = Stmt\Global_[$2]; }
    | T_STATIC static_var_list semi                         { $$ = Stmt\Static_[$2]; }
-    | T_ECHO expr_list semi                                 { $$ = Stmt\Echo_[$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]]; }
@ -245,7 +259,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 */ }
@ -269,7 +282,7 @@ name_union:
 ;

 catch:
-    T_CATCH '(' name_union plain_variable ')' '{' inner_statement_list '}'
+    T_CATCH '(' name_union optional_plain_variable ')' '{' inner_statement_list '}'
        { $$ = Stmt\Catch_[$3, $4, $7]; }
 ;

@ -399,6 +412,25 @@ case_separator:
    | ';'
 ;

+match:
+      T_MATCH '(' expr ')' '{' match_arm_list '}'           { $$ = Expr\Match_[$3, $6]; }
+;
+
+match_arm_list:
+      /* empty */                                           { $$ = []; }
+    | non_empty_match_arm_list optional_comma               { $$ = $1; }
+;
+
+non_empty_match_arm_list:
+      match_arm                                             { init($1); }
+    | non_empty_match_arm_list ',' match_arm                { push($1, $3); }
+;
+
+match_arm:
+      expr_list_allow_comma T_DOUBLE_ARROW expr             { $$ = Node\MatchArm[$1, $3]; }
+    | T_DEFAULT optional_comma T_DOUBLE_ARROW expr          { $$ = Node\MatchArm[null, $4]; }
+;
+
 while_statement:
      statement                                             { $$ = toArray($1); }
    | ':' inner_statement_list T_ENDWHILE ';'               { $$ = $2; }
@ -440,7 +472,7 @@ foreach_variable:
 ;

 parameter_list:
-      non_empty_parameter_list no_comma                     { $$ = $1; }
+      non_empty_parameter_list optional_comma               { $$ = $1; }
    | /* empty */                                           { $$ = array(); }
 ;

@ -449,29 +481,60 @@ non_empty_parameter_list:
    | non_empty_parameter_list ',' parameter                { push($1, $3); }
 ;

+optional_visibility_modifier:
+      /* empty */               { $$ = 0; }
+    | T_PUBLIC                  { $$ = Stmt\Class_::MODIFIER_PUBLIC; }
+    | T_PROTECTED               { $$ = Stmt\Class_::MODIFIER_PROTECTED; }
+    | T_PRIVATE                 { $$ = Stmt\Class_::MODIFIER_PRIVATE; }
+;
+
 parameter:
-      optional_param_type optional_ref optional_ellipsis plain_variable
-          { $$ = Node\Param[$4, null, $1, $2, $3]; $this->checkParam($$); }
-    | optional_param_type optional_ref optional_ellipsis plain_variable '=' expr
-          { $$ = Node\Param[$4, $6, $1, $2, $3]; $this->checkParam($$); }
-    | optional_param_type optional_ref optional_ellipsis error
-          { $$ = Node\Param[Expr\Error[], null, $1, $2, $3]; }
+      optional_visibility_modifier optional_type_without_static optional_ref optional_ellipsis plain_variable
+          { $$ = new Node\Param($5, null, $2, $3, $4, attributes(), $1);
+            $this->checkParam($$); }
+    | optional_visibility_modifier optional_type_without_static optional_ref optional_ellipsis plain_variable '=' expr
+          { $$ = new Node\Param($5, $7, $2, $3, $4, attributes(), $1);
+            $this->checkParam($$); }
+    | optional_visibility_modifier optional_type_without_static optional_ref optional_ellipsis error
+          { $$ = new Node\Param(Expr\Error[], null, $2, $3, $4, attributes(), $1); }
 ;

 type_expr:
      type                                                  { $$ = $1; }
    | '?' type                                              { $$ = Node\NullableType[$2]; }
+    | union_type                                            { $$ = Node\UnionType[$1]; }
 ;

 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']; }
 ;

-optional_param_type:
+union_type:
+      type '|' type                                         { init($1, $3); }
+    | union_type '|' type                                   { push($1, $3); }
+;
+
+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:
@ -494,6 +557,8 @@ argument:
      expr                                                  { $$ = Node\Arg[$1, false, false]; }
    | '&' 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:
@ -530,13 +595,14 @@ class_statement_list_ex:

 class_statement_list:
      class_statement_list_ex
-          { makeNop($nop, $this->lookaheadStartAttributes, $this->endAttributes);
+          { makeZeroLengthNop($nop, $this->lookaheadStartAttributes);
            if ($nop !== null) { $1[] = $nop; } $$ = $1; }
 ;

 class_statement:
-      variable_modifiers property_declaration_list ';'
-          { $$ = Stmt\Property[$1, $2]; $this->checkProperty($$, #1); }
+      variable_modifiers optional_type_without_static 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
@ -625,10 +691,14 @@ property_declaration:
    | property_decl_name '=' expr                           { $$ = Stmt\PropertyProperty[$1, $3]; }
 ;

-expr_list:
+expr_list_forbid_comma:
      non_empty_expr_list no_comma                          { $$ = $1; }
 ;

+expr_list_allow_comma:
+      non_empty_expr_list optional_comma                    { $$ = $1; }
+;
+
 non_empty_expr_list:
      non_empty_expr_list ',' expr                          { push($1, $3); }
    | expr                                                  { init($1); }
@ -636,7 +706,7 @@ non_empty_expr_list:

 for_expr:
      /* empty */                                           { $$ = array(); }
-    | expr_list                                             { $$ = $1; }
+    | expr_list_forbid_comma                                { $$ = $1; }
 ;

 expr:
@ -646,6 +716,7 @@ expr:
    | variable '=' expr                                     { $$ = Expr\Assign[$1, $3]; }
    | variable '=' '&' variable                             { $$ = Expr\AssignRef[$1, $4]; }
    | new_expr                                              { $$ = $1; }
+    | match                                                 { $$ = $1; }
    | T_CLONE expr                                          { $$ = Expr\Clone_[$2]; }
    | variable T_PLUS_EQUAL expr                            { $$ = Expr\AssignOp\Plus      [$1, $3]; }
    | variable T_MINUS_EQUAL expr                           { $$ = Expr\AssignOp\Minus     [$1, $3]; }
@ -659,6 +730,7 @@ expr:
    | variable T_SL_EQUAL expr                              { $$ = Expr\AssignOp\ShiftLeft [$1, $3]; }
    | variable T_SR_EQUAL expr                              { $$ = Expr\AssignOp\ShiftRight[$1, $3]; }
    | variable T_POW_EQUAL expr                             { $$ = Expr\AssignOp\Pow       [$1, $3]; }
+    | variable T_COALESCE_EQUAL expr                        { $$ = Expr\AssignOp\Coalesce  [$1, $3]; }
    | variable T_INC                                        { $$ = Expr\PostInc[$1]; }
    | T_INC variable                                        { $$ = Expr\PreInc [$2]; }
    | variable T_DEC                                        { $$ = Expr\PostDec[$1]; }
@ -698,7 +770,7 @@ expr:
    | expr '?' expr ':' expr                                { $$ = Expr\Ternary[$1, $3,   $5]; }
    | expr '?' ':' expr                                     { $$ = Expr\Ternary[$1, null, $4]; }
    | expr T_COALESCE expr                                  { $$ = Expr\BinaryOp\Coalesce[$1, $3]; }
-    | T_ISSET '(' variables_list ')'                        { $$ = Expr\Isset_[$3]; }
+    | T_ISSET '(' expr_list_allow_comma ')'                 { $$ = Expr\Isset_[$3]; }
    | T_EMPTY '(' expr ')'                                  { $$ = Expr\Empty_[$3]; }
    | T_INCLUDE expr                                        { $$ = Expr\Include_[$2, Expr\Include_::TYPE_INCLUDE]; }
    | T_INCLUDE_ONCE expr                                   { $$ = Expr\Include_[$2, Expr\Include_::TYPE_INCLUDE_ONCE]; }
@ -706,7 +778,10 @@ expr:
    | T_REQUIRE expr                                        { $$ = Expr\Include_[$2, Expr\Include_::TYPE_REQUIRE]; }
    | T_REQUIRE_ONCE expr                                   { $$ = Expr\Include_[$2, Expr\Include_::TYPE_REQUIRE_ONCE]; }
    | T_INT_CAST expr                                       { $$ = Expr\Cast\Int_    [$2]; }
-    | T_DOUBLE_CAST expr                                    { $$ = Expr\Cast\Double  [$2]; }
+    | T_DOUBLE_CAST expr
+          { $attrs = attributes();
+            $attrs['kind'] = $this->getFloatCastKind($1);
+            $$ = new Expr\Cast\Double($2, $attrs); }
    | T_STRING_CAST expr                                    { $$ = Expr\Cast\String_ [$2]; }
    | T_ARRAY_CAST expr                                     { $$ = Expr\Cast\Array_  [$2]; }
    | T_OBJECT_CAST expr                                    { $$ = Expr\Cast\Object_ [$2]; }
@ -724,6 +799,13 @@ 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_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]]; }
@ -750,7 +832,7 @@ lexical_vars:
 ;

 lexical_var_list:
-      non_empty_lexical_var_list no_comma                   { $$ = $1; }
+      non_empty_lexical_var_list optional_comma             { $$ = $1; }
 ;

 non_empty_lexical_var_list:
@ -775,20 +857,22 @@ class_name:
 ;

 name:
-      namespace_name_parts                                  { $$ = Name[$1]; }
-    | T_NS_SEPARATOR namespace_name_parts                   { $$ = Name\FullyQualified[$2]; }
-    | T_NAMESPACE T_NS_SEPARATOR namespace_name_parts       { $$ = Name\Relative[$3]; }
+      T_STRING                                              { $$ = Name[$1]; }
+    | T_NAME_QUALIFIED                                      { $$ = Name[$1]; }
+    | T_NAME_FULLY_QUALIFIED                                { $$ = Name\FullyQualified[substr($1, 1)]; }
+    | T_NAME_RELATIVE                                       { $$ = Name\Relative[substr($1, 10)]; }
 ;

 class_name_reference:
      class_name                                            { $$ = $1; }
    | new_variable                                          { $$ = $1; }
+    | '(' expr ')'                                          { $$ = $2; }
    | error                                                 { $$ = Expr\Error[]; $this->errorState = 2; }
 ;

 class_name_or_var:
      class_name                                            { $$ = $1; }
-    | dereferencable                                        { $$ = $1; }
+    | fully_dereferencable                                  { $$ = $1; }
 ;

 exit_expr:
@ -810,9 +894,20 @@ ctor_arguments:

 constant:
      name                                                  { $$ = Expr\ConstFetch[$1]; }
-    | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM identifier_ex
+    | T_LINE                                                { $$ = Scalar\MagicConst\Line[]; }
+    | T_FILE                                                { $$ = Scalar\MagicConst\File[]; }
+    | T_DIR                                                 { $$ = Scalar\MagicConst\Dir[]; }
+    | T_CLASS_C                                             { $$ = Scalar\MagicConst\Class_[]; }
+    | T_TRAIT_C                                             { $$ = Scalar\MagicConst\Trait_[]; }
+    | T_METHOD_C                                            { $$ = Scalar\MagicConst\Method[]; }
+    | T_FUNC_C                                              { $$ = Scalar\MagicConst\Function_[]; }
+    | T_NS_C                                                { $$ = Scalar\MagicConst\Namespace_[]; }
+;
+
+class_constant:
+      class_name_or_var T_PAAMAYIM_NEKUDOTAYIM identifier_ex
          { $$ = Expr\ClassConstFetch[$1, $3]; }
-    /* We interpret and isolated FOO:: as an unfinished class constant fetch. It could also be
+    /* We interpret an isolated FOO:: as an unfinished class constant fetch. It could also be
       an unfinished static property fetch or unfinished scoped call. */
    | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM error
          { $$ = Expr\ClassConstFetch[$1, new Expr\Error(stackAttributes(#3))]; $this->errorState = 2; }
@ -832,28 +927,21 @@ dereferencable_scalar:
    | T_CONSTANT_ENCAPSED_STRING
          { $attrs = attributes(); $attrs['kind'] = strKind($1);
            $$ = new Scalar\String_(Scalar\String_::parse($1), $attrs); }
+    | '"' encaps_list '"'
+          { $attrs = attributes(); $attrs['kind'] = Scalar\String_::KIND_DOUBLE_QUOTED;
+            parseEncapsed($2, '"', true); $$ = new Scalar\Encapsed($2, $attrs); }
 ;

 scalar:
      T_LNUMBER                                             { $$ = $this->parseLNumber($1, attributes()); }
    | T_DNUMBER                                             { $$ = Scalar\DNumber[Scalar\DNumber::parse($1)]; }
-    | T_LINE                                                { $$ = Scalar\MagicConst\Line[]; }
-    | T_FILE                                                { $$ = Scalar\MagicConst\File[]; }
-    | T_DIR                                                 { $$ = Scalar\MagicConst\Dir[]; }
-    | T_CLASS_C                                             { $$ = Scalar\MagicConst\Class_[]; }
-    | T_TRAIT_C                                             { $$ = Scalar\MagicConst\Trait_[]; }
-    | T_METHOD_C                                            { $$ = Scalar\MagicConst\Method[]; }
-    | T_FUNC_C                                              { $$ = Scalar\MagicConst\Function_[]; }
-    | T_NS_C                                                { $$ = Scalar\MagicConst\Namespace_[]; }
    | dereferencable_scalar                                 { $$ = $1; }
    | constant                                              { $$ = $1; }
+    | class_constant                                        { $$ = $1; }
    | T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC
          { $$ = $this->parseDocString($1, $2, $3, attributes(), stackAttributes(#3), true); }
    | T_START_HEREDOC T_END_HEREDOC
          { $$ = $this->parseDocString($1, '', $2, attributes(), stackAttributes(#2), true); }
-    | '"' encaps_list '"'
-          { $attrs = attributes(); $attrs['kind'] = Scalar\String_::KIND_DOUBLE_QUOTED;
-            parseEncapsed($2, '"', true); $$ = new Scalar\Encapsed($2, $attrs); }
    | T_START_HEREDOC encaps_list T_END_HEREDOC
          { $$ = $this->parseDocString($1, $2, $3, attributes(), stackAttributes(#3), true); }
 ;
@ -863,10 +951,16 @@ optional_expr:
    | expr                                                  { $$ = $1; }
 ;

-dereferencable:
+fully_dereferencable:
      variable                                              { $$ = $1; }
    | '(' expr ')'                                          { $$ = $2; }
    | dereferencable_scalar                                 { $$ = $1; }
+    | class_constant                                        { $$ = $1; }
+;
+
+array_object_dereferencable:
+      fully_dereferencable                                  { $$ = $1; }
+    | constant                                              { $$ = $1; }
 ;

 callable_expr:
@ -877,18 +971,27 @@ callable_expr:

 callable_variable:
      simple_variable                                       { $$ = Expr\Variable[$1]; }
-    | dereferencable '[' optional_expr ']'                  { $$ = Expr\ArrayDimFetch[$1, $3]; }
-    | constant '[' optional_expr ']'                        { $$ = Expr\ArrayDimFetch[$1, $3]; }
-    | dereferencable '{' expr '}'                           { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | array_object_dereferencable '[' optional_expr ']'     { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | array_object_dereferencable '{' expr '}'              { $$ = Expr\ArrayDimFetch[$1, $3]; }
    | function_call                                         { $$ = $1; }
-    | dereferencable T_OBJECT_OPERATOR property_name argument_list
+    | 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:
+      /* empty */                                           { $$ = null; }
+    | plain_variable                                        { $$ = $1; }
 ;

 variable:
      callable_variable                                     { $$ = $1; }
    | static_member                                         { $$ = $1; }
-    | dereferencable T_OBJECT_OPERATOR property_name        { $$ = Expr\PropertyFetch[$1, $3]; }
+    | 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:
@ -913,6 +1016,7 @@ new_variable:
    | new_variable '[' optional_expr ']'                    { $$ = Expr\ArrayDimFetch[$1, $3]; }
    | new_variable '{' expr '}'                             { $$ = Expr\ArrayDimFetch[$1, $3]; }
    | new_variable T_OBJECT_OPERATOR property_name          { $$ = Expr\PropertyFetch[$1, $3]; }
+    | 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
@ -921,34 +1025,19 @@ new_variable:

 member_name:
      identifier_ex                                         { $$ = $1; }
-    | '{' expr '}'	                                        { $$ = $2; }
-    | simple_variable	                                    { $$ = Expr\Variable[$1]; }
+    | '{' expr '}'                                          { $$ = $2; }
+    | simple_variable                                       { $$ = Expr\Variable[$1]; }
 ;

 property_name:
      identifier                                            { $$ = $1; }
-    | '{' expr '}'	                                        { $$ = $2; }
-    | simple_variable	                                    { $$ = Expr\Variable[$1]; }
+    | '{' expr '}'                                          { $$ = $2; }
+    | simple_variable                                       { $$ = Expr\Variable[$1]; }
    | error                                                 { $$ = Expr\Error[]; $this->errorState = 2; }
 ;

 list_expr:
-      T_LIST '(' list_expr_elements ')'                     { $$ = Expr\List_[$3]; }
-;
-
-list_expr_elements:
-      list_expr_elements ',' list_expr_element              { push($1, $3); }
-    | list_expr_element                                     { init($1); }
-;
-
-list_expr_element:
-      variable                                              { $$ = Expr\ArrayItem[$1, null, false]; }
-    | '&' variable                                          { $$ = Expr\ArrayItem[$2, null, true]; }
-    | list_expr                                             { $$ = Expr\ArrayItem[$1, null, false]; }
-    | expr T_DOUBLE_ARROW variable                          { $$ = Expr\ArrayItem[$3, $1, false]; }
-    | expr T_DOUBLE_ARROW '&' variable                      { $$ = Expr\ArrayItem[$4, $1, true]; }
-    | expr T_DOUBLE_ARROW list_expr                         { $$ = Expr\ArrayItem[$3, $1, false]; }
-    | /* empty */                                           { $$ = null; }
+      T_LIST '(' inner_array_pair_list ')'                  { $$ = Expr\List_[$3]; }
 ;

 array_pair_list:
@ -968,10 +1057,13 @@ inner_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]; }
+      expr                                                  { $$ = Expr\ArrayItem[$1, null, false]; }
    | '&' 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 list_expr                         { $$ = Expr\ArrayItem[$3, $1,   false]; }
+    | T_ELLIPSIS expr                                       { $$ = Expr\ArrayItem[$2, null, false, attributes(), true]; }
    | /* empty */                                           { $$ = null; }
 ;

@ -994,6 +1086,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 ']' '}'
--- a/grammar/rebuildParsers.php
+++ b/grammar/rebuildParsers.php
@ -13,10 +13,10 @@ $tmpResultFile  = __DIR__ . '/tmp_parser.php';
 $resultDir = __DIR__ . '/../lib/PhpParser/Parser';
 $tokensResultsFile = $resultDir . '/Tokens.php';

-// check for kmyacc.exe binary in this directory, otherwise fall back to global name
-$kmyacc = __DIR__ . '/kmyacc.exe';
-if (!file_exists($kmyacc)) {
-    $kmyacc = 'kmyacc';
+$kmyacc = getenv('KMYACC');
+if (!$kmyacc) {
+    // Use phpyacc from dev dependencies by default.
+    $kmyacc = __DIR__ . '/../vendor/bin/phpyacc';
 }

 $options = array_flip($argv);
@ -59,8 +59,7 @@ foreach ($grammarFileToName as $grammarFile => $name) {
    $additionalArgs = $optionDebug ? '-t -v' : '';

    echo "Building $name parser.\n";
-    $output = trim(shell_exec("$kmyacc $additionalArgs -l -m $skeletonFile -p $name $tmpGrammarFile 2>&1"));
-    echo "Output: \"$output\"\n";
+    $output = execCmd("$kmyacc $additionalArgs -m $skeletonFile -p $name $tmpGrammarFile");

    $resultCode = file_get_contents($tmpResultFile);
    $resultCode = removeTrailingWhitespace($resultCode);
@ -70,8 +69,7 @@ foreach ($grammarFileToName as $grammarFile => $name) {
    unlink($tmpResultFile);

    echo "Building token definition.\n";
-    $output = trim(shell_exec("$kmyacc -l -m $tokensTemplate $tmpGrammarFile 2>&1"));
-    assert($output === '');
+    $output = execCmd("$kmyacc -m $tokensTemplate $tmpGrammarFile");
    rename($tmpResultFile, $tokensResultsFile);

    if (!$optionKeepTmpGrammar) {
@ -175,6 +173,15 @@ function resolveMacros($code) {
                . ' 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);

@ -222,6 +229,15 @@ function ensureDirExists($dir) {
    }
 }

+function execCmd($cmd) {
+    $output = trim(shell_exec("$cmd 2>&1"));
+    if ($output !== "") {
+        echo "> " . $cmd . "\n";
+        echo $output;
+    }
+    return $output;
+}
+
 //////////////////////////////
 /// Regex helper functions ///
 //////////////////////////////
--- a/grammar/tokens.y
+++ b/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
@ -10,7 +11,7 @@
 %right T_YIELD
 %right T_DOUBLE_ARROW
 %right T_YIELD_FROM
-%left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL T_POW_EQUAL
+%left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL T_POW_EQUAL T_COALESCE_EQUAL
 %left '?' ':'
 %right T_COALESCE
 %left T_BOOLEAN_OR
@ -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
@ -57,6 +56,7 @@
 %token T_ENDDECLARE
 %token T_AS
 %token T_SWITCH
+%token T_MATCH
 %token T_ENDSWITCH
 %token T_CASE
 %token T_DEFAULT
@ -64,6 +64,7 @@
 %token T_CONTINUE
 %token T_GOTO
 %token T_FUNCTION
+%token T_FN
 %token T_CONST
 %token T_RETURN
 %token T_TRY
@ -85,6 +86,7 @@
 %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
@ -95,12 +97,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
@ -111,3 +107,6 @@
 %token T_DIR
 %token T_NS_SEPARATOR
 %token T_ELLIPSIS
+%token T_NAME_FULLY_QUALIFIED
+%token T_NAME_QUALIFIED
+%token T_NAME_RELATIVE
--- a/lib/PhpParser/Builder/Param.php
+++ b/lib/PhpParser/Builder/Param.php
@ -12,7 +12,7 @@ class Param implements PhpParser\Builder

    protected $default = null;

-    /** @var string|Node\Name|Node\NullableType|null */
+    /** @var Node\Identifier|Node\Name|Node\NullableType|null */
    protected $type = null;

    protected $byRef = false;
@ -44,7 +44,7 @@ class Param implements PhpParser\Builder
    /**
     * Sets type for the parameter.
     *
-     * @param string|Node\Name|Node\NullableType $type Parameter type
+     * @param string|Node\Name|Node\NullableType|Node\UnionType $type Parameter type
     *
     * @return $this The builder instance (for fluid interface)
     */
@ -60,7 +60,7 @@ class Param implements PhpParser\Builder
    /**
     * Sets type for the parameter.
     *
-     * @param string|Node\Name|Node\NullableType $type Parameter type
+     * @param string|Node\Name|Node\NullableType|Node\UnionType $type Parameter type
     *
     * @return $this The builder instance (for fluid interface)
     *
--- a/lib/PhpParser/Builder/Property.php
+++ b/lib/PhpParser/Builder/Property.php
@ -4,6 +4,9 @@ namespace PhpParser\Builder;

 use PhpParser;
 use PhpParser\BuilderHelpers;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\NullableType;
 use PhpParser\Node\Stmt;

 class Property implements PhpParser\Builder
@ -14,6 +17,9 @@ class Property implements PhpParser\Builder
    protected $default = null;
    protected $attributes = [];

+    /** @var null|Identifier|Name|NullableType */
+    protected $type;
+
    /**
     * Creates a property builder.
     *
@ -95,6 +101,19 @@ class Property implements PhpParser\Builder
        return $this;
    }

+    /**
+     * Sets the property type for PHP 7.4+.
+     *
+     * @param string|Name|NullableType|Identifier $type
+     *
+     * @return $this
+     */
+    public function setType($type) {
+        $this->type = BuilderHelpers::normalizeType($type);
+
+        return $this;
+    }
+
    /**
     * Returns the built class node.
     *
@ -106,7 +125,8 @@ class Property implements PhpParser\Builder
            [
                new Stmt\PropertyProperty($this->name, $this->default)
            ],
-            $this->attributes
+            $this->attributes,
+            $this->type
        );
    }
 }
--- a/lib/PhpParser/BuilderFactory.php
+++ b/lib/PhpParser/BuilderFactory.php
@ -8,7 +8,6 @@ use PhpParser\Node\Expr\BinaryOp\Concat;
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
 use PhpParser\Node\Scalar\String_;
-use PhpParser\Node\Stmt;
 use PhpParser\Node\Stmt\Use_;

 class BuilderFactory
@ -77,7 +76,7 @@ class BuilderFactory
     * @return Builder\TraitUseAdaptation The create trait use adaptation builder
     */
    public function traitUseAdaptation($trait, $method = null) : Builder\TraitUseAdaptation {
-        if (is_null($method)) {
+        if ($method === null) {
            $method = $trait;
            $trait = null;
        }
--- a/lib/PhpParser/BuilderHelpers.php
+++ b/lib/PhpParser/BuilderHelpers.php
@ -8,6 +8,7 @@ use PhpParser\Node\Name;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\Scalar;
 use PhpParser\Node\Stmt;
+use PhpParser\Node\UnionType;

 /**
 * This class defines helpers used in the implementation of builders. Don't use it directly.
@ -158,16 +159,19 @@ final class BuilderHelpers
     * In particular, builtin types become Identifiers, custom types become Names and nullables
     * are wrapped in NullableType nodes.
     *
-     * @param string|Name|Identifier|NullableType $type The type to normalize
+     * @param string|Name|Identifier|NullableType|UnionType $type The type to normalize
     *
-     * @return Name|Identifier|NullableType The normalized type
+     * @return Name|Identifier|NullableType|UnionType The normalized type
     */
    public static function normalizeType($type) {
        if (!is_string($type)) {
-            if (!$type instanceof Name && !$type instanceof Identifier
-                    && !$type instanceof NullableType) {
+            if (
+                !$type instanceof Name && !$type instanceof Identifier &&
+                !$type instanceof NullableType && !$type instanceof UnionType
+            ) {
                throw new \LogicException(
-                    'Type must be a string, or an instance of Name, Identifier or NullableType');
+                    'Type must be a string, or an instance of Name, Identifier, NullableType or UnionType'
+                );
            }
            return $type;
        }
@ -179,7 +183,7 @@ final class BuilderHelpers
        }

        $builtinTypes = [
-            'array', 'callable', 'string', 'int', 'float', 'bool', 'iterable', 'void', 'object'
+            'array', 'callable', 'string', 'int', 'float', 'bool', 'iterable', 'void', 'object', 'mixed'
        ];

        $lowerType = strtolower($type);
@ -193,7 +197,11 @@ final class BuilderHelpers
            throw new \LogicException('void type cannot be nullable');
        }

-        return $nullable ? new Node\NullableType($type) : $type;
+        if ($nullable && (string) $type === 'mixed') {
+            throw new \LogicException('mixed type cannot be nullable');
+        }
+
+        return $nullable ? new NullableType($type) : $type;
    }

    /**
--- a/lib/PhpParser/Comment.php
+++ b/lib/PhpParser/Comment.php
@ -5,9 +5,12 @@ namespace PhpParser;
 class Comment implements \JsonSerializable
 {
    protected $text;
-    protected $line;
-    protected $filePos;
-    protected $tokenPos;
+    protected $startLine;
+    protected $startFilePos;
+    protected $startTokenPos;
+    protected $endLine;
+    protected $endFilePos;
+    protected $endTokenPos;

    /**
     * Constructs a comment node.
@ -18,12 +21,17 @@ class Comment implements \JsonSerializable
     * @param int    $startTokenPos Token offset the comment started on
     */
    public function __construct(
-        string $text, int $startLine = -1, int $startFilePos = -1, int $startTokenPos = -1
+        string $text,
+        int $startLine = -1, int $startFilePos = -1, int $startTokenPos = -1,
+        int $endLine = -1, int $endFilePos = -1, int $endTokenPos = -1
    ) {
        $this->text = $text;
-        $this->line = $startLine;
-        $this->filePos = $startFilePos;
-        $this->tokenPos = $startTokenPos;
+        $this->startLine = $startLine;
+        $this->startFilePos = $startFilePos;
+        $this->startTokenPos = $startTokenPos;
+        $this->endLine = $endLine;
+        $this->endFilePos = $endFilePos;
+        $this->endTokenPos = $endTokenPos;
    }

    /**
@ -38,28 +46,88 @@ class Comment implements \JsonSerializable
    /**
     * Gets the line number the comment started on.
     *
-     * @return int Line number
+     * @return int Line number (or -1 if not available)
     */
-    public function getLine() : int {
-        return $this->line;
+    public function getStartLine() : int {
+        return $this->startLine;
    }

    /**
     * Gets the file offset the comment started on.
     *
-     * @return int File offset
+     * @return int File offset (or -1 if not available)
     */
-    public function getFilePos() : int {
-        return $this->filePos;
+    public function getStartFilePos() : int {
+        return $this->startFilePos;
    }

    /**
     * Gets the token offset the comment started on.
     *
+     * @return int Token offset (or -1 if not available)
+     */
+    public function getStartTokenPos() : int {
+        return $this->startTokenPos;
+    }
+
+    /**
+     * Gets the line number the comment ends on.
+     *
+     * @return int Line number (or -1 if not available)
+     */
+    public function getEndLine() : int {
+        return $this->endLine;
+    }
+
+    /**
+     * Gets the file offset the comment ends on.
+     *
+     * @return int File offset (or -1 if not available)
+     */
+    public function getEndFilePos() : int {
+        return $this->endFilePos;
+    }
+
+    /**
+     * Gets the token offset the comment ends on.
+     *
+     * @return int Token offset (or -1 if not available)
+     */
+    public function getEndTokenPos() : int {
+        return $this->endTokenPos;
+    }
+
+    /**
+     * Gets the line number the comment started on.
+     *
+     * @deprecated Use getStartLine() instead
+     *
+     * @return int Line number
+     */
+    public function getLine() : int {
+        return $this->startLine;
+    }
+
+    /**
+     * Gets the file offset the comment started on.
+     *
+     * @deprecated Use getStartFilePos() instead
+     *
+     * @return int File offset
+     */
+    public function getFilePos() : int {
+        return $this->startFilePos;
+    }
+
+    /**
+     * Gets the token offset the comment started on.
+     *
+     * @deprecated Use getStartTokenPos() instead
+     *
     * @return int Token offset
     */
    public function getTokenPos() : int {
-        return $this->tokenPos;
+        return $this->startTokenPos;
    }

    /**
@ -159,9 +227,13 @@ class Comment implements \JsonSerializable
        return [
            'nodeType' => $type,
            'text' => $this->text,
-            'line' => $this->line,
-            'filePos' => $this->filePos,
-            'tokenPos' => $this->tokenPos,
+            // TODO: Rename these to include "start".
+            'line' => $this->startLine,
+            'filePos' => $this->startFilePos,
+            'tokenPos' => $this->startTokenPos,
+            'endLine' => $this->endLine,
+            'endFilePos' => $this->endFilePos,
+            'endTokenPos' => $this->endTokenPos,
        ];
    }
 }
--- a/lib/PhpParser/Internal/PrintableNewAnonClassNode.php
+++ b/lib/PhpParser/Internal/PrintableNewAnonClassNode.php
@ -41,7 +41,6 @@ class PrintableNewAnonClassNode extends Expr
        assert($class instanceof Node\Stmt\Class_);
        // We don't assert that $class->name is null here, to allow consumers to assign unique names
        // to anonymous classes for their own purposes. We simplify ignore the name here.
-        assert($class->name === null);
        return new self(
            $newNode->args, $class->extends, $class->implements,
            $class->stmts, $newNode->getAttributes()
--- a/lib/PhpParser/Internal/TokenStream.php
+++ b/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,7 @@ class TokenStream
     * @return bool
     */
    public function haveBraces(int $startPos, int $endPos) : bool {
-        return $this->haveTokenImmediativelyBefore($startPos, '{')
+        return $this->haveTokenImmediatelyBefore($startPos, '{')
            && $this->haveTokenImmediatelyAfter($endPos, '}');
    }

@ -60,7 +60,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 +170,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 +181,29 @@ 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, '}');
+    }
+
    /**
     * Get indentation before token position.
     *
--- a/lib/PhpParser/JsonDecoder.php
+++ b/lib/PhpParser/JsonDecoder.php
@ -73,7 +73,9 @@ class JsonDecoder
        }

        return new $className(
-            $value['text'], $value['line'] ?? -1, $value['filePos'] ?? -1, $value['tokenPos'] ?? -1
+            $value['text'],
+            $value['line'] ?? -1, $value['filePos'] ?? -1, $value['tokenPos'] ?? -1,
+            $value['endLine'] ?? -1, $value['endFilePos'] ?? -1, $value['endTokenPos'] ?? -1
        );
    }

--- a/lib/PhpParser/Lexer.php
+++ b/lib/PhpParser/Lexer.php
@ -15,8 +15,15 @@ class Lexer

    protected $tokenMap;
    protected $dropTokens;
+    protected $identifierTokens;

-    protected $usedAttributes;
+    private $attributeStartLineUsed;
+    private $attributeEndLineUsed;
+    private $attributeStartTokenPosUsed;
+    private $attributeEndTokenPosUsed;
+    private $attributeStartFilePosUsed;
+    private $attributeEndFilePosUsed;
+    private $attributeCommentsUsed;

    /**
     * Creates a Lexer.
@ -28,21 +35,28 @@ class Lexer
     *                       first three. For more info see getNextToken() docs.
     */
    public function __construct(array $options = []) {
-        // map from internal tokens to PhpParser tokens
+        // Create Map from internal tokens to PhpParser tokens.
+        $this->defineCompatibilityTokens();
        $this->tokenMap = $this->createTokenMap();
+        $this->identifierTokens = $this->createIdentifierTokenMap();

        // map of tokens to drop while lexing (the map is only used for isset lookup,
        // that's why the value is simply set to 1; the value is never actually used.)
        $this->dropTokens = array_fill_keys(
-            [\T_WHITESPACE, \T_OPEN_TAG, \T_COMMENT, \T_DOC_COMMENT], 1
+            [\T_WHITESPACE, \T_OPEN_TAG, \T_COMMENT, \T_DOC_COMMENT, \T_BAD_CHARACTER], 1
        );

-        // the usedAttributes member is a map of the used attribute names to a dummy
-        // value (here "true")
-        $options += [
-            'usedAttributes' => ['comments', 'startLine', 'endLine'],
-        ];
-        $this->usedAttributes = array_fill_keys($options['usedAttributes'], true);
+        $defaultAttributes = ['comments', 'startLine', 'endLine'];
+        $usedAttributes = array_fill_keys($options['usedAttributes'] ?? $defaultAttributes, true);
+
+        // Create individual boolean properties to make these checks faster.
+        $this->attributeStartLineUsed = isset($usedAttributes['startLine']);
+        $this->attributeEndLineUsed = isset($usedAttributes['endLine']);
+        $this->attributeStartTokenPosUsed = isset($usedAttributes['startTokenPos']);
+        $this->attributeEndTokenPosUsed = isset($usedAttributes['endTokenPos']);
+        $this->attributeStartFilePosUsed = isset($usedAttributes['startFilePos']);
+        $this->attributeEndFilePosUsed = isset($usedAttributes['endFilePos']);
+        $this->attributeCommentsUsed = isset($usedAttributes['comments']);
    }

    /**
@ -73,7 +87,7 @@ class Lexer

        error_clear_last();
        $this->tokens = @token_get_all($code);
-        $this->handleErrors($errorHandler);
+        $this->postprocessTokens($errorHandler);

        if (false !== $scream) {
            ini_set('xdebug.scream', $scream);
@ -81,13 +95,9 @@ class Lexer
    }

    private function handleInvalidCharacterRange($start, $end, $line, ErrorHandler $errorHandler) {
+        $tokens = [];
        for ($i = $start; $i < $end; $i++) {
            $chr = $this->code[$i];
-            if ($chr === 'b' || $chr === 'B') {
-                // HHVM does not treat b" tokens correctly, so ignore these
-                continue;
-            }
-
            if ($chr === "\0") {
                // PHP cuts error message after null byte, so need special case
                $errorMsg = 'Unexpected null byte';
@ -97,6 +107,7 @@ class Lexer
                );
            }

+            $tokens[] = [\T_BAD_CHARACTER, $chr, $line];
            $errorHandler->handleError(new Error($errorMsg, [
                'startLine' => $line,
                'endLine' => $line,
@ -104,6 +115,7 @@ class Lexer
                'endFilePos' => $i,
            ]));
        }
+        return $tokens;
    }

    /**
@ -117,43 +129,99 @@ class Lexer
            && substr($token[1], -2) !== '*/';
    }

-    /**
-     * Check whether an error *may* have occurred during tokenization.
-     *
-     * @return bool
-     */
-    private function errorMayHaveOccurred() : bool {
-        if (defined('HHVM_VERSION')) {
-            // In HHVM token_get_all() does not throw warnings, so we need to conservatively
-            // assume that an error occurred
-            return true;
-        }
-
-        return null !== error_get_last();
-    }
-
-    protected function handleErrors(ErrorHandler $errorHandler) {
-        if (!$this->errorMayHaveOccurred()) {
-            return;
-        }
-
+    protected function postprocessTokens(ErrorHandler $errorHandler) {
        // PHP's error handling for token_get_all() is rather bad, so if we want detailed
        // error information we need to compute it ourselves. Invalid character errors are
        // detected by finding "gaps" in the token array. Unterminated comments are detected
        // by checking if a trailing comment has a "*/" at the end.
+        //
+        // Additionally, we 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.

        $filePos = 0;
        $line = 1;
-        foreach ($this->tokens as $token) {
+        $numTokens = \count($this->tokens);
+        for ($i = 0; $i < $numTokens; $i++) {
+            $token = $this->tokens[$i];
+
+            // Since PHP 7.4 invalid characters are represented by a T_BAD_CHARACTER token.
+            // In this case we only need to emit an error.
+            if ($token[0] === \T_BAD_CHARACTER) {
+                $this->handleInvalidCharacterRange($filePos, $filePos + 1, $line, $errorHandler);
+            }
+
+            if ($token[0] === \T_COMMENT && substr($token[1], 0, 2) !== '/*'
+                    && preg_match('/(\r\n|\n|\r)$/D', $token[1], $matches)) {
+                $trailingNewline = $matches[0];
+                $token[1] = substr($token[1], 0, -strlen($trailingNewline));
+                $this->tokens[$i] = $token;
+                if (isset($this->tokens[$i + 1]) && $this->tokens[$i + 1][0] === \T_WHITESPACE) {
+                    // Move trailing newline into following T_WHITESPACE token, if it already exists.
+                    $this->tokens[$i + 1][1] = $trailingNewline . $this->tokens[$i + 1][1];
+                    $this->tokens[$i + 1][2]--;
+                } else {
+                    // Otherwise, we need to create a new T_WHITESPACE token.
+                    array_splice($this->tokens, $i + 1, 0, [
+                        [\T_WHITESPACE, $trailingNewline, $line],
+                    ]);
+                    $numTokens++;
+                }
+            }
+
+            // Emulate PHP 8 T_NAME_* tokens, by combining sequences of T_NS_SEPARATOR and T_STRING
+            // into a single token.
+            if (\is_array($token)
+                    && ($token[0] === \T_NS_SEPARATOR || isset($this->identifierTokens[$token[0]]))) {
+                $lastWasSeparator = $token[0] === \T_NS_SEPARATOR;
+                $text = $token[1];
+                for ($j = $i + 1; isset($this->tokens[$j]); $j++) {
+                    if ($lastWasSeparator) {
+                        if (!isset($this->identifierTokens[$this->tokens[$j][0]])) {
+                            break;
+                        }
+                        $lastWasSeparator = false;
+                    } else {
+                        if ($this->tokens[$j][0] !== \T_NS_SEPARATOR) {
+                            break;
+                        }
+                        $lastWasSeparator = true;
+                    }
+                    $text .= $this->tokens[$j][1];
+                }
+                if ($lastWasSeparator) {
+                    // Trailing separator is not part of the name.
+                    $j--;
+                    $text = substr($text, 0, -1);
+                }
+                if ($j > $i + 1) {
+                    if ($token[0] === \T_NS_SEPARATOR) {
+                        $type = \T_NAME_FULLY_QUALIFIED;
+                    } else if ($token[0] === \T_NAMESPACE) {
+                        $type = \T_NAME_RELATIVE;
+                    } else {
+                        $type = \T_NAME_QUALIFIED;
+                    }
+                    $token = [$type, $text, $line];
+                    array_splice($this->tokens, $i, $j - $i, [$token]);
+                    $numTokens -= $j - $i - 1;
+                }
+            }
+
            $tokenValue = \is_string($token) ? $token : $token[1];
            $tokenLen = \strlen($tokenValue);

            if (substr($this->code, $filePos, $tokenLen) !== $tokenValue) {
                // Something is missing, must be an invalid character
                $nextFilePos = strpos($this->code, $tokenValue, $filePos);
-                $this->handleInvalidCharacterRange(
+                $badCharTokens = $this->handleInvalidCharacterRange(
                    $filePos, $nextFilePos, $line, $errorHandler);
                $filePos = (int) $nextFilePos;
+
+                array_splice($this->tokens, $i, 0, $badCharTokens);
+                $numTokens += \count($badCharTokens);
+                $i += \count($badCharTokens);
            }

            $filePos += $tokenLen;
@ -176,8 +244,9 @@ class Lexer
                $this->tokens[] = [$isDocComment ? \T_DOC_COMMENT : \T_COMMENT, $comment, $line];
            } else {
                // Invalid characters at the end of the input
-                $this->handleInvalidCharacterRange(
+                $badCharTokens = $this->handleInvalidCharacterRange(
                    $filePos, \strlen($this->code), $line, $errorHandler);
+                $this->tokens = array_merge($this->tokens, $badCharTokens);
            }
            return;
        }
@ -230,13 +299,13 @@ class Lexer
                $token = "\0";
            }

-            if (isset($this->usedAttributes['startLine'])) {
+            if ($this->attributeStartLineUsed) {
                $startAttributes['startLine'] = $this->line;
            }
-            if (isset($this->usedAttributes['startTokenPos'])) {
+            if ($this->attributeStartTokenPosUsed) {
                $startAttributes['startTokenPos'] = $this->pos;
            }
-            if (isset($this->usedAttributes['startFilePos'])) {
+            if ($this->attributeStartFilePosUsed) {
                $startAttributes['startFilePos'] = $this->filePos;
            }

@ -262,27 +331,33 @@ class Lexer
                $this->line += substr_count($value, "\n");
                $this->filePos += \strlen($value);
            } else {
+                $origLine = $this->line;
+                $origFilePos = $this->filePos;
+                $this->line += substr_count($token[1], "\n");
+                $this->filePos += \strlen($token[1]);
+
                if (\T_COMMENT === $token[0] || \T_DOC_COMMENT === $token[0]) {
-                    if (isset($this->usedAttributes['comments'])) {
+                    if ($this->attributeCommentsUsed) {
                        $comment = \T_DOC_COMMENT === $token[0]
-                            ? new Comment\Doc($token[1], $this->line, $this->filePos, $this->pos)
-                            : new Comment($token[1], $this->line, $this->filePos, $this->pos);
+                            ? new Comment\Doc($token[1],
+                                $origLine, $origFilePos, $this->pos,
+                                $this->line, $this->filePos - 1, $this->pos)
+                            : new Comment($token[1],
+                                $origLine, $origFilePos, $this->pos,
+                                $this->line, $this->filePos - 1, $this->pos);
                        $startAttributes['comments'][] = $comment;
                    }
                }
-
-                $this->line += substr_count($token[1], "\n");
-                $this->filePos += \strlen($token[1]);
                continue;
            }

-            if (isset($this->usedAttributes['endLine'])) {
+            if ($this->attributeEndLineUsed) {
                $endAttributes['endLine'] = $this->line;
            }
-            if (isset($this->usedAttributes['endTokenPos'])) {
+            if ($this->attributeEndTokenPosUsed) {
                $endAttributes['endTokenPos'] = $this->pos;
            }
-            if (isset($this->usedAttributes['endFilePos'])) {
+            if ($this->attributeEndFilePosUsed) {
                $endAttributes['endFilePos'] = $this->filePos - 1;
            }

@ -329,6 +404,36 @@ class Lexer
        return substr($textAfter, strlen($matches[0]));
    }

+    private function defineCompatibilityTokens() {
+        // PHP 7.4
+        if (!defined('T_BAD_CHARACTER')) {
+            \define('T_BAD_CHARACTER', -1);
+        }
+        if (!defined('T_FN')) {
+            \define('T_FN', -2);
+        }
+        if (!defined('T_COALESCE_EQUAL')) {
+            \define('T_COALESCE_EQUAL', -3);
+        }
+
+        // PHP 8.0
+        if (!defined('T_NAME_QUALIFIED')) {
+            \define('T_NAME_QUALIFIED', -4);
+        }
+        if (!defined('T_NAME_FULLY_QUALIFIED')) {
+            \define('T_NAME_FULLY_QUALIFIED', -5);
+        }
+        if (!defined('T_NAME_RELATIVE')) {
+            \define('T_NAME_RELATIVE', -6);
+        }
+        if (!defined('T_MATCH')) {
+            \define('T_MATCH', -7);
+        }
+        if (!defined('T_NULLSAFE_OBJECT_OPERATOR')) {
+            \define('T_NULLSAFE_OBJECT_OPERATOR', -8);
+        }
+    }
+
    /**
     * Creates the token map.
     *
@ -373,6 +478,31 @@ class Lexer
            $tokenMap[\T_COMPILER_HALT_OFFSET] = Tokens::T_STRING;
        }

+        // Assign tokens for which we define compatibility constants, as token_name() does not know them.
+        $tokenMap[\T_FN] = Tokens::T_FN;
+        $tokenMap[\T_COALESCE_EQUAL] = Tokens::T_COALESCE_EQUAL;
+        $tokenMap[\T_NAME_QUALIFIED] = Tokens::T_NAME_QUALIFIED;
+        $tokenMap[\T_NAME_FULLY_QUALIFIED] = Tokens::T_NAME_FULLY_QUALIFIED;
+        $tokenMap[\T_NAME_RELATIVE] = Tokens::T_NAME_RELATIVE;
+        $tokenMap[\T_MATCH] = Tokens::T_MATCH;
+        $tokenMap[\T_NULLSAFE_OBJECT_OPERATOR] = Tokens::T_NULLSAFE_OBJECT_OPERATOR;
+
        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_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);
+    }
 }
--- a/lib/PhpParser/Lexer/Emulative.php
+++ b/lib/PhpParser/Lexer/Emulative.php
@ -4,26 +4,68 @@ namespace PhpParser\Lexer;

 use PhpParser\Error;
 use PhpParser\ErrorHandler;
+use PhpParser\Lexer;
+use PhpParser\Lexer\TokenEmulator\CoaleseEqualTokenEmulator;
+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;

-class Emulative extends \PhpParser\Lexer
+class Emulative extends Lexer
 {
-    const PHP_7_3 = '7.3.0dev';
+    const PHP_7_3 = '7.3dev';
+    const PHP_7_4 = '7.4dev';
+    const PHP_8_0 = '8.0dev';
+
+    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;
+
+    /** @var mixed[] Patches used to reverse changes introduced in the code */
+    private $patches = [];
+
+    /** @var TokenEmulatorInterface[] */
+    private $tokenEmulators = [];
+
+    /** @var string */
+    private $targetPhpVersion;

    /**
-     * @var array Patches used to reverse changes introduced in the code
+     * @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.
     */
-    private $patches;
+    public function __construct(array $options = [])
+    {
+        $this->targetPhpVersion = $options['phpVersion'] ?? Emulative::PHP_8_0;
+        unset($options['phpVersion']);
+
+        parent::__construct($options);
+
+        $this->tokenEmulators[] = new FnTokenEmulator();
+        $this->tokenEmulators[] = new MatchTokenEmulator();
+        $this->tokenEmulators[] = new CoaleseEqualTokenEmulator();
+        $this->tokenEmulators[] = new NumericLiteralSeparatorEmulator();
+        $this->tokenEmulators[] = new NullsafeTokenEmulator();
+    }

    public function startLexing(string $code, ErrorHandler $errorHandler = null) {
        $this->patches = [];
-        $preparedCode = $this->prepareCode($code);
-        if (null === $preparedCode) {
+
+        if ($this->isEmulationNeeded($code) === false) {
            // Nothing to emulate, yay
            parent::startLexing($code, $errorHandler);
            return;
        }

        $collector = new ErrorHandler\Collecting();
+
+        // 1. emulation of heredoc and nowdoc new syntax
+        $preparedCode = $this->processHeredocNowdoc($code);
        parent::startLexing($preparedCode, $collector);
        $this->fixupTokens();

@ -34,32 +76,40 @@ class Emulative extends \PhpParser\Lexer
                $errorHandler->handleError($error);
            }
        }
+
+        foreach ($this->tokenEmulators as $tokenEmulator) {
+            $emulatorPhpVersion = $tokenEmulator->getPhpVersion();
+            if (version_compare(\PHP_VERSION, $emulatorPhpVersion, '<')
+                    && version_compare($this->targetPhpVersion, $emulatorPhpVersion, '>=')
+                    && $tokenEmulator->isEmulationNeeded($code)) {
+                $this->tokens = $tokenEmulator->emulate($code, $this->tokens);
+            } else if (version_compare(\PHP_VERSION, $emulatorPhpVersion, '>=')
+                    && version_compare($this->targetPhpVersion, $emulatorPhpVersion, '<')
+                    && $tokenEmulator->isEmulationNeeded($code)) {
+                $this->tokens = $tokenEmulator->reverseEmulate($code, $this->tokens);
+            }
+        }
    }

-    /**
-     * Prepares code for emulation. If nothing has to be emulated null is returned.
-     *
-     * @param string $code
-     * @return null|string
-     */
-    private function prepareCode(string $code) {
+    private function isHeredocNowdocEmulationNeeded(string $code): bool
+    {
+        // skip version where this works without emulation
        if (version_compare(\PHP_VERSION, self::PHP_7_3, '>=')) {
-            return null;
+            return false;
        }

-        if (strpos($code, '<<<') === false) {
-            // Definitely doesn't contain heredoc/nowdoc
-            return null;
+        return strpos($code, '<<<') !== false;
+    }
+
+    private function processHeredocNowdoc(string $code): string
+    {
+        if ($this->isHeredocNowdocEmulationNeeded($code) === false) {
+            return $code;
        }

-        $flexibleDocStringRegex = <<<'REGEX'
-/<<<[ \t]*(['"]?)([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)\1\r?\n
-(?:.*\r?\n)*?
-(?<indentation>\h*)\2(?![a-zA-Z_\x80-\xff])(?<separator>(?:;?[\r\n])?)/x
-REGEX;
-        if (!preg_match_all($flexibleDocStringRegex, $code, $matches, PREG_SET_ORDER|PREG_OFFSET_CAPTURE)) {
+        if (!preg_match_all(self::FLEXIBLE_DOC_STRING_REGEX, $code, $matches, PREG_SET_ORDER|PREG_OFFSET_CAPTURE)) {
            // No heredoc/nowdoc found
-            return null;
+            return $code;
        }

        // Keep track of how much we need to adjust string offsets due to the modifications we
@ -93,19 +143,29 @@ REGEX;
            }
        }

-        if (empty($this->patches)) {
-            // We did not end up emulating anything
-            return null;
-        }
-
        return $code;
    }

-    private function fixupTokens() {
-        assert(count($this->patches) > 0);
+    private function isEmulationNeeded(string $code): bool
+    {
+        foreach ($this->tokenEmulators as $emulativeToken) {
+            if ($emulativeToken->isEmulationNeeded($code)) {
+                return true;
+            }
+        }
+
+        return $this->isHeredocNowdocEmulationNeeded($code);
+    }
+
+    private function fixupTokens()
+    {
+        if (\count($this->patches) === 0) {
+            return;
+        }

        // Load first patch
        $patchIdx = 0;
+
        list($patchPos, $patchType, $patchText) = $this->patches[$patchIdx];

        // We use a manual loop over the tokens, because we modify the array on the fly
@ -200,4 +260,4 @@ REGEX;
            $error->setAttributes($attrs);
        }
    }
-}
+}
--- a/lib/PhpParser/Lexer/TokenEmulator/CoaleseEqualTokenEmulator.php
+++ b/lib/PhpParser/Lexer/TokenEmulator/CoaleseEqualTokenEmulator.php
@ -0,0 +1,47 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class CoaleseEqualTokenEmulator implements TokenEmulatorInterface
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_7_4;
+    }
+
+    public function isEmulationNeeded(string $code): bool
+    {
+        return strpos($code, '??=') !== false;
+    }
+
+    public function emulate(string $code, array $tokens): array
+    {
+        // We need to manually iterate and manage a count because we'll change
+        // the tokens array on the way
+        $line = 1;
+        for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+            if (isset($tokens[$i + 1])) {
+                if ($tokens[$i][0] === T_COALESCE && $tokens[$i + 1] === '=') {
+                    array_splice($tokens, $i, 2, [
+                        [\T_COALESCE_EQUAL, '??=', $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
+    {
+        // ??= was not valid code previously, don't bother.
+        return $tokens;
+    }
+}
--- a/lib/PhpParser/Lexer/TokenEmulator/FnTokenEmulator.php
+++ b/lib/PhpParser/Lexer/TokenEmulator/FnTokenEmulator.php
@ -0,0 +1,23 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class FnTokenEmulator extends KeywordEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_7_4;
+    }
+
+    public function getKeywordString(): string
+    {
+        return 'fn';
+    }
+
+    public function getKeywordToken(): int
+    {
+        return \T_FN;
+    }
+}
--- a/lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php
+++ b/lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php
@ -0,0 +1,60 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+abstract class KeywordEmulator implements TokenEmulatorInterface
+{
+    abstract function getKeywordString(): string;
+    abstract function getKeywordToken(): int;
+
+    public function isEmulationNeeded(string $code): bool
+    {
+        return strpos($code, $this->getKeywordString()) !== false;
+    }
+
+    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) {
+                $previousNonSpaceToken = $this->getPreviousNonSpaceToken($tokens, $i);
+                if ($previousNonSpaceToken !== null && $previousNonSpaceToken[0] === \T_OBJECT_OPERATOR) {
+                    continue;
+                }
+
+                $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;
+    }
+}
--- a/lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php
+++ b/lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php
@ -0,0 +1,23 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class MatchTokenEmulator extends KeywordEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_0;
+    }
+
+    public function getKeywordString(): string
+    {
+        return 'match';
+    }
+
+    public function getKeywordToken(): int
+    {
+        return \T_MATCH;
+    }
+}
--- a/lib/PhpParser/Lexer/TokenEmulator/NullsafeTokenEmulator.php
+++ b/lib/PhpParser/Lexer/TokenEmulator/NullsafeTokenEmulator.php
@ -0,0 +1,47 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class NullsafeTokenEmulator implements TokenEmulatorInterface
+{
+    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 (isset($tokens[$i + 1])) {
+                if ($tokens[$i] === '?' && $tokens[$i + 1][0] === \T_OBJECT_OPERATOR) {
+                    array_splice($tokens, $i, 2, [
+                        [\T_NULLSAFE_OBJECT_OPERATOR, '?->', $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
+    {
+        // ?-> was not valid code previously, don't bother.
+        return $tokens;
+    }
+}
--- a/lib/PhpParser/Lexer/TokenEmulator/NumericLiteralSeparatorEmulator.php
+++ b/lib/PhpParser/Lexer/TokenEmulator/NumericLiteralSeparatorEmulator.php
@ -0,0 +1,105 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class NumericLiteralSeparatorEmulator implements TokenEmulatorInterface
+{
+    const BIN = '(?:0b[01]+(?:_[01]+)*)';
+    const HEX = '(?:0x[0-9a-f]+(?:_[0-9a-f]+)*)';
+    const DEC = '(?:[0-9]+(?:_[0-9]+)*)';
+    const SIMPLE_FLOAT = '(?:' . self::DEC . '\.' . self::DEC . '?|\.' . self::DEC . ')';
+    const EXP = '(?:e[+-]?' . self::DEC . ')';
+    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
+    {
+        return preg_match('~[0-9]_[0-9]~', $code)
+            || preg_match('~0x[0-9a-f]+_[0-9a-f]~i', $code);
+    }
+
+    public function emulate(string $code, array $tokens): array
+    {
+        // We need to manually iterate and manage a count because we'll change
+        // the tokens array on the way
+        $codeOffset = 0;
+        for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+            $token = $tokens[$i];
+            $tokenLen = \strlen(\is_array($token) ? $token[1] : $token);
+
+            if ($token[0] !== T_LNUMBER && $token[0] !== T_DNUMBER) {
+                $codeOffset += $tokenLen;
+                continue;
+            }
+
+            $res = preg_match(self::NUMBER, $code, $matches, 0, $codeOffset);
+            assert($res, "No number at number token position");
+
+            $match = $matches[0];
+            $matchLen = \strlen($match);
+            if ($matchLen === $tokenLen) {
+                // Original token already holds the full number.
+                $codeOffset += $tokenLen;
+                continue;
+            }
+
+            $tokenKind = $this->resolveIntegerOrFloatToken($match);
+            $newTokens = [[$tokenKind, $match, $token[2]]];
+
+            $numTokens = 1;
+            $len = $tokenLen;
+            while ($matchLen > $len) {
+                $nextToken = $tokens[$i + $numTokens];
+                $nextTokenText = \is_array($nextToken) ? $nextToken[1] : $nextToken;
+                $nextTokenLen = \strlen($nextTokenText);
+
+                $numTokens++;
+                if ($matchLen < $len + $nextTokenLen) {
+                    // Split trailing characters into a partial token.
+                    assert(is_array($nextToken), "Partial token should be an array token");
+                    $partialText = substr($nextTokenText, $matchLen - $len);
+                    $newTokens[] = [$nextToken[0], $partialText, $nextToken[2]];
+                    break;
+                }
+
+                $len += $nextTokenLen;
+            }
+
+            array_splice($tokens, $i, $numTokens, $newTokens);
+            $c -= $numTokens - \count($newTokens);
+            $codeOffset += $matchLen;
+        }
+
+        return $tokens;
+    }
+
+    private function resolveIntegerOrFloatToken(string $str): int
+    {
+        $str = str_replace('_', '', $str);
+
+        if (stripos($str, '0b') === 0) {
+            $num = bindec($str);
+        } elseif (stripos($str, '0x') === 0) {
+            $num = hexdec($str);
+        } elseif (stripos($str, '0') === 0 && ctype_digit($str)) {
+            $num = octdec($str);
+        } else {
+            $num = +$str;
+        }
+
+        return is_float($num) ? T_DNUMBER : T_LNUMBER;
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array
+    {
+        // Numeric separators were not legal code previously, don't bother.
+        return $tokens;
+    }
+}
--- a/lib/PhpParser/Lexer/TokenEmulator/TokenEmulatorInterface.php
+++ b/lib/PhpParser/Lexer/TokenEmulator/TokenEmulatorInterface.php
@ -0,0 +1,21 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+/** @internal */
+interface TokenEmulatorInterface
+{
+    public function getPhpVersion(): string;
+
+    public function isEmulationNeeded(string $code): bool;
+
+    /**
+     * @return array Modified Tokens
+     */
+    public function emulate(string $code, array $tokens): array;
+
+    /**
+     * @return array Modified Tokens
+     */
+    public function reverseEmulate(string $code, array $tokens): array;
+}
--- a/lib/PhpParser/Node.php
+++ b/lib/PhpParser/Node.php
@ -95,8 +95,6 @@ interface Node
    /**
     * Gets the doc comment of the node.
     *
-     * The doc comment has to be the last comment associated with the node.
-     *
     * @return null|Comment\Doc Doc comment object or null
     */
    public function getDocComment();
--- a/lib/PhpParser/Node/Arg.php
+++ b/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 = []) {
-        parent::__construct($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 {
--- a/lib/PhpParser/Node/Const_.php
+++ b/lib/PhpParser/Node/Const_.php
@ -22,7 +22,7 @@ class Const_ extends NodeAbstract
     * @param array             $attributes Additional attributes
     */
    public function __construct($name, Expr $value, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->name = \is_string($name) ? new Identifier($name) : $name;
        $this->value = $value;
    }
--- a/lib/PhpParser/Node/Expr/ArrayDimFetch.php
+++ b/lib/PhpParser/Node/Expr/ArrayDimFetch.php
@ -19,7 +19,7 @@ class ArrayDimFetch extends Expr
     * @param array     $attributes Additional attributes
     */
    public function __construct(Expr $var, Expr $dim = null, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
        $this->dim = $dim;
    }
--- a/lib/PhpParser/Node/Expr/ArrayItem.php
+++ b/lib/PhpParser/Node/Expr/ArrayItem.php
@ -12,6 +12,8 @@ class ArrayItem extends Expr
    public $value;
    /** @var bool Whether to assign by reference */
    public $byRef;
+    /** @var bool Whether to unpack the argument */
+    public $unpack;

    /**
     * Constructs an array item node.
@ -21,17 +23,18 @@ class ArrayItem extends Expr
     * @param bool      $byRef      Whether to assign by reference
     * @param array     $attributes Additional attributes
     */
-    public function __construct(Expr $value, Expr $key = null, bool $byRef = false, array $attributes = []) {
-        parent::__construct($attributes);
+    public function __construct(Expr $value, Expr $key = null, bool $byRef = false, array $attributes = [], bool $unpack = false) {
+        $this->attributes = $attributes;
        $this->key = $key;
        $this->value = $value;
        $this->byRef = $byRef;
+        $this->unpack = $unpack;
    }

    public function getSubNodeNames() : array {
-        return ['key', 'value', 'byRef'];
+        return ['key', 'value', 'byRef', 'unpack'];
    }
-    
+
    public function getType() : string {
        return 'Expr_ArrayItem';
    }
--- a/lib/PhpParser/Node/Expr/Array_.php
+++ b/lib/PhpParser/Node/Expr/Array_.php
@ -10,17 +10,17 @@ 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 = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->items = $items;
    }

--- a/lib/PhpParser/Node/Expr/ArrowFunction.php
+++ b/lib/PhpParser/Node/Expr/ArrowFunction.php
@ -0,0 +1,71 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr;
+use PhpParser\Node\FunctionLike;
+
+class ArrowFunction extends Expr implements FunctionLike
+{
+    /** @var bool */
+    public $static;
+
+    /** @var bool */
+    public $byRef;
+
+    /** @var Node\Param[] */
+    public $params = [];
+
+    /** @var null|Node\Identifier|Node\Name|Node\NullableType|Node\UnionType */
+    public $returnType;
+
+    /** @var Expr */
+    public $expr;
+
+    /**
+     * @param array $subNodes   Array of the following optional subnodes:
+     *                          'static'     => false   : Whether the closure is static
+     *                          'byRef'      => false   : Whether to return by reference
+     *                          'params'     => array() : Parameters
+     *                          'returnType' => null    : Return type
+     *                          'expr'       => Expr    : Expression body
+     * @param array $attributes Additional attributes
+     */
+    public function __construct(array $subNodes = [], array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->static = $subNodes['static'] ?? false;
+        $this->byRef = $subNodes['byRef'] ?? false;
+        $this->params = $subNodes['params'] ?? [];
+        $returnType = $subNodes['returnType'] ?? null;
+        $this->returnType = \is_string($returnType) ? new Node\Identifier($returnType) : $returnType;
+        $this->expr = $subNodes['expr'] ?? null;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['static', 'byRef', 'params', 'returnType', 'expr'];
+    }
+
+    public function returnsByRef() : bool {
+        return $this->byRef;
+    }
+
+    public function getParams() : array {
+        return $this->params;
+    }
+
+    public function getReturnType() {
+        return $this->returnType;
+    }
+
+    /**
+     * @return Node\Stmt\Return_[]
+     */
+    public function getStmts() : array {
+        return [new Node\Stmt\Return_($this->expr)];
+    }
+
+    public function getType() : string {
+        return 'Expr_ArrowFunction';
+    }
+}
--- a/lib/PhpParser/Node/Expr/Assign.php
+++ b/lib/PhpParser/Node/Expr/Assign.php
@ -19,7 +19,7 @@ class Assign extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $var, Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
        $this->expr = $expr;
    }
--- a/lib/PhpParser/Node/Expr/AssignOp.php
+++ b/lib/PhpParser/Node/Expr/AssignOp.php
@ -19,7 +19,7 @@ abstract class AssignOp extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $var, Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
        $this->expr = $expr;
    }
--- a/lib/PhpParser/Node/Expr/AssignOp/Coalesce.php
+++ b/lib/PhpParser/Node/Expr/AssignOp/Coalesce.php
@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Expr\AssignOp;
+
+use PhpParser\Node\Expr\AssignOp;
+
+class Coalesce extends AssignOp
+{
+    public function getType() : string {
+        return 'Expr_AssignOp_Coalesce';
+    }
+}
--- a/lib/PhpParser/Node/Expr/AssignRef.php
+++ b/lib/PhpParser/Node/Expr/AssignRef.php
@ -19,7 +19,7 @@ class AssignRef extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $var, Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
        $this->expr = $expr;
    }
--- a/lib/PhpParser/Node/Expr/BinaryOp.php
+++ b/lib/PhpParser/Node/Expr/BinaryOp.php
@ -19,7 +19,7 @@ abstract class BinaryOp extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $left, Expr $right, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->left = $left;
        $this->right = $right;
    }
--- a/lib/PhpParser/Node/Expr/BitwiseNot.php
+++ b/lib/PhpParser/Node/Expr/BitwiseNot.php
@ -16,7 +16,7 @@ class BitwiseNot extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/BooleanNot.php
+++ b/lib/PhpParser/Node/Expr/BooleanNot.php
@ -16,7 +16,7 @@ class BooleanNot extends Expr
     * @param array               $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/Cast.php
+++ b/lib/PhpParser/Node/Expr/Cast.php
@ -16,7 +16,7 @@ abstract class Cast extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/Cast/Double.php
+++ b/lib/PhpParser/Node/Expr/Cast/Double.php
@ -6,6 +6,11 @@ use PhpParser\Node\Expr\Cast;

 class Double extends Cast
 {
+    // For use in "kind" attribute
+    const KIND_DOUBLE = 1; // "double" syntax
+    const KIND_FLOAT = 2;  // "float" syntax
+    const KIND_REAL = 3; // "real" syntax
+
    public function getType() : string {
        return 'Expr_Cast_Double';
    }
--- a/lib/PhpParser/Node/Expr/ClassConstFetch.php
+++ b/lib/PhpParser/Node/Expr/ClassConstFetch.php
@ -21,7 +21,7 @@ class ClassConstFetch extends Expr
     * @param array                   $attributes Additional attributes
     */
    public function __construct($class, $name, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->class = $class;
        $this->name = \is_string($name) ? new Identifier($name) : $name;
    }
--- a/lib/PhpParser/Node/Expr/Clone_.php
+++ b/lib/PhpParser/Node/Expr/Clone_.php
@ -16,7 +16,7 @@ class Clone_ extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/Closure.php
+++ b/lib/PhpParser/Node/Expr/Closure.php
@ -16,7 +16,7 @@ class Closure extends Expr implements FunctionLike
    public $params;
    /** @var ClosureUse[] use()s */
    public $uses;
-    /** @var null|Node\Identifier|Node\Name|Node\NullableType Return type */
+    /** @var null|Node\Identifier|Node\Name|Node\NullableType|Node\UnionType Return type */
    public $returnType;
    /** @var Node\Stmt[] Statements */
    public $stmts;
@ -34,7 +34,7 @@ class Closure extends Expr implements FunctionLike
     * @param array $attributes Additional attributes
     */
    public function __construct(array $subNodes = [], array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->static = $subNodes['static'] ?? false;
        $this->byRef = $subNodes['byRef'] ?? false;
        $this->params = $subNodes['params'] ?? [];
--- a/lib/PhpParser/Node/Expr/ClosureUse.php
+++ b/lib/PhpParser/Node/Expr/ClosureUse.php
@ -19,7 +19,7 @@ class ClosureUse extends Expr
     * @param array         $attributes Additional attributes
     */
    public function __construct(Expr\Variable $var, bool $byRef = false, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
        $this->byRef = $byRef;
    }
--- a/lib/PhpParser/Node/Expr/ConstFetch.php
+++ b/lib/PhpParser/Node/Expr/ConstFetch.php
@ -17,7 +17,7 @@ class ConstFetch extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Name $name, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->name = $name;
    }

--- a/lib/PhpParser/Node/Expr/Empty_.php
+++ b/lib/PhpParser/Node/Expr/Empty_.php
@ -16,7 +16,7 @@ class Empty_ extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/Error.php
+++ b/lib/PhpParser/Node/Expr/Error.php
@ -18,7 +18,7 @@ class Error extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
    }

    public function getSubNodeNames() : array {
--- a/lib/PhpParser/Node/Expr/ErrorSuppress.php
+++ b/lib/PhpParser/Node/Expr/ErrorSuppress.php
@ -16,7 +16,7 @@ class ErrorSuppress extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/Eval_.php
+++ b/lib/PhpParser/Node/Expr/Eval_.php
@ -16,7 +16,7 @@ class Eval_ extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/Exit_.php
+++ b/lib/PhpParser/Node/Expr/Exit_.php
@ -20,7 +20,7 @@ class Exit_ extends Expr
     * @param array                    $attributes Additional attributes
     */
    public function __construct(Expr $expr = null, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/FuncCall.php
+++ b/lib/PhpParser/Node/Expr/FuncCall.php
@ -20,7 +20,7 @@ class FuncCall extends Expr
     * @param array          $attributes Additional attributes
     */
    public function __construct($name, array $args = [], array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->name = $name;
        $this->args = $args;
    }
--- a/lib/PhpParser/Node/Expr/Include_.php
+++ b/lib/PhpParser/Node/Expr/Include_.php
@ -24,7 +24,7 @@ class Include_ extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, int $type, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
        $this->type = $type;
    }
--- a/lib/PhpParser/Node/Expr/Instanceof_.php
+++ b/lib/PhpParser/Node/Expr/Instanceof_.php
@ -20,7 +20,7 @@ class Instanceof_ extends Expr
     * @param array     $attributes Additional attributes
     */
    public function __construct(Expr $expr, $class, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
        $this->class = $class;
    }
--- a/lib/PhpParser/Node/Expr/Isset_.php
+++ b/lib/PhpParser/Node/Expr/Isset_.php
@ -16,7 +16,7 @@ class Isset_ extends Expr
     * @param array  $attributes Additional attributes
     */
    public function __construct(array $vars, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->vars = $vars;
    }

--- a/lib/PhpParser/Node/Expr/List_.php
+++ b/lib/PhpParser/Node/Expr/List_.php
@ -16,7 +16,7 @@ class List_ extends Expr
     * @param array              $attributes Additional attributes
     */
    public function __construct(array $items, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->items = $items;
    }

--- a/lib/PhpParser/Node/Expr/Match_.php
+++ b/lib/PhpParser/Node/Expr/Match_.php
@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node;
+use PhpParser\Node\MatchArm;
+
+class Match_ extends Node\Expr
+{
+    /** @var Node\Expr */
+    public $cond;
+    /** @var MatchArm[] */
+    public $arms;
+
+    /**
+     * @param MatchArm[] $arms
+     */
+    public function __construct(Node\Expr $cond, array $arms = [], array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->cond = $cond;
+        $this->arms = $arms;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['cond', 'arms'];
+    }
+
+    public function getType() : string {
+        return 'Expr_Match';
+    }
+}
--- a/lib/PhpParser/Node/Expr/MethodCall.php
+++ b/lib/PhpParser/Node/Expr/MethodCall.php
@ -24,7 +24,7 @@ class MethodCall extends Expr
     * @param array                  $attributes Additional attributes
     */
    public function __construct(Expr $var, $name, array $args = [], array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
        $this->name = \is_string($name) ? new Identifier($name) : $name;
        $this->args = $args;
--- a/lib/PhpParser/Node/Expr/New_.php
+++ b/lib/PhpParser/Node/Expr/New_.php
@ -20,7 +20,7 @@ class New_ extends Expr
     * @param array                           $attributes Additional attributes
     */
    public function __construct($class, array $args = [], array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->class = $class;
        $this->args = $args;
    }
--- a/lib/PhpParser/Node/Expr/NullsafeMethodCall.php
+++ b/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';
+    }
+}
--- a/lib/PhpParser/Node/Expr/NullsafePropertyFetch.php
+++ b/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';
+    }
+}
--- a/lib/PhpParser/Node/Expr/PostDec.php
+++ b/lib/PhpParser/Node/Expr/PostDec.php
@ -16,7 +16,7 @@ class PostDec extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $var, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
    }

--- a/lib/PhpParser/Node/Expr/PostInc.php
+++ b/lib/PhpParser/Node/Expr/PostInc.php
@ -16,7 +16,7 @@ class PostInc extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $var, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
    }

--- a/lib/PhpParser/Node/Expr/PreDec.php
+++ b/lib/PhpParser/Node/Expr/PreDec.php
@ -16,7 +16,7 @@ class PreDec extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $var, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
    }

--- a/lib/PhpParser/Node/Expr/PreInc.php
+++ b/lib/PhpParser/Node/Expr/PreInc.php
@ -16,7 +16,7 @@ class PreInc extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $var, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
    }

--- a/lib/PhpParser/Node/Expr/Print_.php
+++ b/lib/PhpParser/Node/Expr/Print_.php
@ -16,7 +16,7 @@ class Print_ extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/PropertyFetch.php
+++ b/lib/PhpParser/Node/Expr/PropertyFetch.php
@ -20,7 +20,7 @@ class PropertyFetch extends Expr
     * @param array                  $attributes Additional attributes
     */
    public function __construct(Expr $var, $name, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->var = $var;
        $this->name = \is_string($name) ? new Identifier($name) : $name;
    }
--- a/lib/PhpParser/Node/Expr/ShellExec.php
+++ b/lib/PhpParser/Node/Expr/ShellExec.php
@ -16,7 +16,7 @@ class ShellExec extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(array $parts, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->parts = $parts;
    }

--- a/lib/PhpParser/Node/Expr/StaticCall.php
+++ b/lib/PhpParser/Node/Expr/StaticCall.php
@ -24,7 +24,7 @@ class StaticCall extends Expr
     * @param array                  $attributes Additional attributes
     */
    public function __construct($class, $name, array $args = [], array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->class = $class;
        $this->name = \is_string($name) ? new Identifier($name) : $name;
        $this->args = $args;
--- a/lib/PhpParser/Node/Expr/StaticPropertyFetch.php
+++ b/lib/PhpParser/Node/Expr/StaticPropertyFetch.php
@ -21,7 +21,7 @@ class StaticPropertyFetch extends Expr
     * @param array                         $attributes Additional attributes
     */
    public function __construct($class, $name, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->class = $class;
        $this->name = \is_string($name) ? new VarLikeIdentifier($name) : $name;
    }
--- a/lib/PhpParser/Node/Expr/Ternary.php
+++ b/lib/PhpParser/Node/Expr/Ternary.php
@ -22,7 +22,7 @@ class Ternary extends Expr
     * @param array                    $attributes Additional attributes
     */
    public function __construct(Expr $cond, $if, Expr $else, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->cond = $cond;
        $this->if = $if;
        $this->else = $else;
--- a/lib/PhpParser/Node/Expr/Throw_.php
+++ b/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';
+    }
+}
--- a/lib/PhpParser/Node/Expr/UnaryMinus.php
+++ b/lib/PhpParser/Node/Expr/UnaryMinus.php
@ -16,7 +16,7 @@ class UnaryMinus extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/UnaryPlus.php
+++ b/lib/PhpParser/Node/Expr/UnaryPlus.php
@ -16,7 +16,7 @@ class UnaryPlus extends Expr
     * @param array               $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/Variable.php
+++ b/lib/PhpParser/Node/Expr/Variable.php
@ -16,7 +16,7 @@ class Variable extends Expr
     * @param array                      $attributes Additional attributes
     */
    public function __construct($name, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->name = $name;
    }

--- a/lib/PhpParser/Node/Expr/YieldFrom.php
+++ b/lib/PhpParser/Node/Expr/YieldFrom.php
@ -16,7 +16,7 @@ class YieldFrom extends Expr
     * @param array $attributes Additional attributes
     */
    public function __construct(Expr $expr, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->expr = $expr;
    }

--- a/lib/PhpParser/Node/Expr/Yield_.php
+++ b/lib/PhpParser/Node/Expr/Yield_.php
@ -19,7 +19,7 @@ class Yield_ extends Expr
     * @param array     $attributes Additional attributes
     */
    public function __construct(Expr $value = null, Expr $key = null, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->key = $key;
        $this->value = $value;
    }
--- a/lib/PhpParser/Node/FunctionLike.php
+++ b/lib/PhpParser/Node/FunctionLike.php
@ -23,7 +23,7 @@ interface FunctionLike extends Node
    /**
     * Get the declared return type or null
     *
-     * @return null|Identifier|Node\Name|Node\NullableType
+     * @return null|Identifier|Node\Name|Node\NullableType|Node\UnionType
     */
    public function getReturnType();

--- a/lib/PhpParser/Node/Identifier.php
+++ b/lib/PhpParser/Node/Identifier.php
@ -25,7 +25,7 @@ class Identifier extends NodeAbstract
     * @param array  $attributes Additional attributes
     */
    public function __construct(string $name, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->name = $name;
    }

--- a/lib/PhpParser/Node/MatchArm.php
+++ b/lib/PhpParser/Node/MatchArm.php
@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+
+class MatchArm extends NodeAbstract
+{
+    /** @var null|Node\Expr[] */
+    public $conds;
+    /** @var Node\Expr */
+    public $body;
+
+    /**
+     * @param null|Node\Expr[] $conds
+     */
+    public function __construct($conds, Node\Expr $body, array $attributes = []) {
+        $this->conds = $conds;
+        $this->body = $body;
+        $this->attributes = $attributes;
+    }
+
+    public function getSubNodeNames() : array {
+        return ['conds', 'body'];
+    }
+
+    public function getType() : string {
+        return 'MatchArm';
+    }
+}
--- a/lib/PhpParser/Node/Name.php
+++ b/lib/PhpParser/Node/Name.php
@ -6,9 +6,7 @@ use PhpParser\NodeAbstract;

 class Name extends NodeAbstract
 {
-    /**
-     * @var string[] Parts of the name
-     */
+    /** @var string[] Parts of the name */
    public $parts;

    private static $specialClassNames = [
@ -24,7 +22,7 @@ class Name extends NodeAbstract
     * @param array                $attributes Additional attributes
     */
    public function __construct($name, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->parts = self::prepareName($name);
    }

@ -87,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
@ -237,7 +235,7 @@ class Name extends NodeAbstract
            'Expected string, array of parts or Name instance'
        );
    }
-    
+
    public function getType() : string {
        return 'Name';
    }
--- a/lib/PhpParser/Node/NullableType.php
+++ b/lib/PhpParser/Node/NullableType.php
@ -16,7 +16,7 @@ class NullableType extends NodeAbstract
     * @param array                  $attributes Additional attributes
     */
    public function __construct($type, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->type = \is_string($type) ? new Identifier($type) : $type;
    }

--- a/lib/PhpParser/Node/Param.php
+++ b/lib/PhpParser/Node/Param.php
@ -6,7 +6,7 @@ use PhpParser\NodeAbstract;

 class Param extends NodeAbstract
 {
-    /** @var null|Identifier|Name|NullableType Typehint */
+    /** @var null|Identifier|Name|NullableType|UnionType Type declaration */
    public $type;
    /** @var bool Whether parameter is passed by reference */
    public $byRef;
@ -16,33 +16,39 @@ class Param extends NodeAbstract
    public $var;
    /** @var null|Expr Default value */
    public $default;
+    /** @var int */
+    public $flags;

    /**
     * Constructs a parameter node.
     *
-     * @param Expr\Variable|Expr\Error      $var        Parameter variable
-     * @param null|Expr                     $default    Default value
-     * @param null|string|Name|NullableType $type       Typehint
-     * @param bool                          $byRef      Whether is passed by reference
-     * @param bool                          $variadic   Whether this is a variadic argument
-     * @param array                         $attributes Additional attributes
+     * @param Expr\Variable|Expr\Error                           $var        Parameter variable
+     * @param null|Expr                                          $default    Default value
+     * @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
     */
    public function __construct(
        $var, Expr $default = null, $type = null,
-        bool $byRef = false, bool $variadic = false, array $attributes = []
+        bool $byRef = false, bool $variadic = false,
+        array $attributes = [],
+        int $flags = 0
    ) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->type = \is_string($type) ? new Identifier($type) : $type;
        $this->byRef = $byRef;
        $this->variadic = $variadic;
        $this->var = $var;
        $this->default = $default;
+        $this->flags = $flags;
    }

    public function getSubNodeNames() : array {
-        return ['type', 'byRef', 'variadic', 'var', 'default'];
+        return ['flags', 'type', 'byRef', 'variadic', 'var', 'default'];
    }
-    
+
    public function getType() : string {
        return 'Param';
    }
--- a/lib/PhpParser/Node/Scalar/DNumber.php
+++ b/lib/PhpParser/Node/Scalar/DNumber.php
@ -16,7 +16,7 @@ class DNumber extends Scalar
     * @param array $attributes Additional attributes
     */
    public function __construct(float $value, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->value = $value;
    }

@ -34,6 +34,8 @@ class DNumber extends Scalar
     * @return float The parsed number
     */
    public static function parse(string $str) : float {
+        $str = str_replace('_', '', $str);
+
        // if string contains any of .eE just cast it to float
        if (false !== strpbrk($str, '.eE')) {
            return (float) $str;
--- a/lib/PhpParser/Node/Scalar/Encapsed.php
+++ b/lib/PhpParser/Node/Scalar/Encapsed.php
@ -17,7 +17,7 @@ class Encapsed extends Scalar
     * @param array  $attributes Additional attributes
     */
    public function __construct(array $parts, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->parts = $parts;
    }

--- a/lib/PhpParser/Node/Scalar/EncapsedStringPart.php
+++ b/lib/PhpParser/Node/Scalar/EncapsedStringPart.php
@ -16,7 +16,7 @@ class EncapsedStringPart extends Scalar
     * @param array  $attributes Additional attributes
     */
    public function __construct(string $value, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->value = $value;
    }

--- a/lib/PhpParser/Node/Scalar/LNumber.php
+++ b/lib/PhpParser/Node/Scalar/LNumber.php
@ -23,7 +23,7 @@ class LNumber extends Scalar
     * @param array $attributes Additional attributes
     */
    public function __construct(int $value, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->value = $value;
    }

@ -41,6 +41,8 @@ class LNumber extends Scalar
     * @return LNumber The constructed LNumber, including kind attribute
     */
    public static function fromString(string $str, array $attributes = [], bool $allowInvalidOctal = false) : LNumber {
+        $str = str_replace('_', '', $str);
+
        if ('0' !== $str[0] || '0' === $str) {
            $attributes['kind'] = LNumber::KIND_DEC;
            return new LNumber((int) $str, $attributes);
--- a/lib/PhpParser/Node/Scalar/MagicConst.php
+++ b/lib/PhpParser/Node/Scalar/MagicConst.php
@ -12,7 +12,7 @@ abstract class MagicConst extends Scalar
     * @param array $attributes Additional attributes
     */
    public function __construct(array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
    }

    public function getSubNodeNames() : array {
--- a/lib/PhpParser/Node/Scalar/String_.php
+++ b/lib/PhpParser/Node/Scalar/String_.php
@ -34,7 +34,7 @@ class String_ extends Scalar
     * @param array  $attributes Additional attributes
     */
    public function __construct(string $value, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->value = $value;
    }

@ -100,7 +100,7 @@ class String_ extends Scalar
                if (isset(self::$replacements[$str])) {
                    return self::$replacements[$str];
                } elseif ('x' === $str[0] || 'X' === $str[0]) {
-                    return chr(hexdec($str));
+                    return chr(hexdec(substr($str, 1)));
                } elseif ('u' === $str[0]) {
                    return self::codePointToUtf8(hexdec($matches[2]));
                } else {
@ -134,7 +134,7 @@ class String_ extends Scalar
        }
        throw new Error('Invalid UTF-8 codepoint escape sequence: Codepoint too large');
    }
-    
+
    public function getType() : string {
        return 'Scalar_String';
    }
--- a/lib/PhpParser/Node/Stmt/Break_.php
+++ b/lib/PhpParser/Node/Stmt/Break_.php
@ -16,7 +16,7 @@ class Break_ extends Node\Stmt
     * @param array          $attributes Additional attributes
     */
    public function __construct(Node\Expr $num = null, array $attributes = []) {
-        parent::__construct($attributes);
+        $this->attributes = $attributes;
        $this->num = $num;
    }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nikita Popov	88e519766f	Release PHP-Parser 4.9.1	2020-08-30 18:15:20 +02:00
Nikita Popov	35306de32f	Support visibility modifiers in namespaced names Fixes #704.	2020-08-29 16:35:31 +02:00
Nikita Popov	ad365b1beb	FPPP: Fix code block detection during removal Instead of checking whether there is a {/} before/after the removed note, check whether {/} occurs in the between-node range. Dropping that is what we're really concerned about here.	2020-08-29 16:28:28 +02:00
Nikita Popov	4bc82432de	Only special-case brace handling for statement lists Don't interpret the } before a catch clause as a block statement and trigger a pretty printing fallback.	2020-08-23 20:57:00 +02:00
Ondrej Mirtes	fd6052e37d	FPPP failing tests	2020-08-23 20:54:01 +02:00
Nikita Popov	bd722809f7	FPPP: Support removing nodes from start of list	2020-08-23 17:35:37 +02:00
Viktor Szépe	56356e4aec	Remove repeated word from PHPDoc in Name	2020-08-23 08:59:38 +02:00
Nikita Popov	aaee038b91	Release PHP-Parser 4.9.0	2020-08-18 21:48:01 +02:00
Nikita Popov	f9d35fe11e	Fix casing of class name	2020-08-10 11:21:16 +02:00
Nikita Popov	8bcaa4261e	Add parens for new/instanceof with complex expression This is not fully accurate because the rules for "new variables" are different than the rules for dereferenceable LHS.	2020-08-09 22:07:33 +02:00
Nikita Popov	feb6bf7a0c	Wrap class const LHS in parens if necessary This looks like a very old bug in the pretty printer that showed up in PHP 8 tests.	2020-08-09 21:41:30 +02:00
Nikita Popov	0cee2088ea	Remove self/parent/static restriction for namespace names This no longer applies as of PHP 8.0.	2020-08-09 21:21:22 +02:00
Nikita Popov	78e08fc178	Allow keywords in namespace declaration	2020-08-09 21:19:59 +02:00
Nikita Popov	3aadc15e2e	Support keywords in namespaced names	2020-08-09 21:11:49 +02:00
Nikita Popov	a98350581c	Add support for throw expression	2020-08-09 20:52:55 +02:00
Nikita Popov	7f398769a0	Add support for static return type	2020-08-09 18:52:32 +02:00
Nikita Popov	98f7f39d1c	Add named argument support Not adding any explicit FPPP support, as I don't think add/remove of names can be handled any better than full reformatting.	2020-08-09 17:37:44 +02:00
Nikita Popov	722119502f	Fine grained version choice for test_old	2020-08-09 16:54:13 +02:00
Graham Campbell	544aee1671	Fix up tests	2020-08-09 16:54:09 +02:00
Nikita Popov	8c58eb4cd4	Release PHP-Parser 4.8.0	2020-08-09 12:23:20 +02:00
Nikita Popov	23d9c17770	Add support for nullsafe operator	2020-08-09 12:08:05 +02:00
Nikita Popov	31be7b4ed9	Update php-yacc, remove unused tokens	2020-08-08 19:22:28 +02:00
Nikita Popov	f6bf041583	Remove last uses of MockBuilder	2020-08-08 11:58:00 +02:00
Nikita Popov	1bf073a76c	Avoid most MockBuilder uses in NodeVisitor testing This removes all the warnings about at() usage ... even though it is still used. Apparently warnings don't get emitted if the at() usage is inside a data provider?	2020-08-08 11:49:05 +02:00
Nikita Popov	1721ae155c	Avoid one use of MockBuilder We can just use anon classes here and avoid PHPUnits unreliable MockBuilder.	2020-08-08 11:49:05 +02:00
Alex	54fc023b25	Update Array_ annotations, items are nullable (#696 ) When used to destructure, items are optional. E.g. `[$a, , $b] = [1, 2, 3];`.	2020-08-08 10:04:21 +02:00
Nikita Popov	f845568e1d	Remove an unnecessary use of at()	2020-08-07 10:19:39 +02:00
Nikita Popov	b4ca4ce0fe	Allow PHPUnit 9	2020-08-07 10:16:19 +02:00
Nikita Popov	303342630d	Fix a token reference	2020-08-01 22:36:49 +02:00
Nikita Popov	1a1300aa2a	Add reverse emulation support	2020-08-01 22:34:36 +02:00
Nikita Popov	3698f4b727	Add common KeywordEmulator The logic for keyword emulation is always going to be the same.	2020-08-01 22:02:52 +02:00
Nikita Popov	7b2ec6703f	Accept a phpVersion option in emulative lexer Testing this will require reverse emulation support.	2020-08-01 21:56:06 +02:00
Nikita Popov	61328f89da	Separate out emulator version info	2020-08-01 21:49:53 +02:00
Nikita Popov	21dce06dfb	Release PHP-Parser 4.7.0	2020-07-25 15:18:53 +02:00
Nikita Popov	acaf3fecad	Implement emulation of PHP 8 T_NAME_* tokens Like comment emulation, this is unconditional, as it is required for core functionality.	2020-07-23 12:28:13 +02:00
Nikita Popov	a63b495fe6	Migrate grammar to use PHP 8 T_NAME_* tokens This will break everything on PHP < 8.	2020-07-23 12:01:50 +02:00
Nikita Popov	2d1998938c	[PHP 8.0] Support trailing comma in closure use list RFC: https://wiki.php.net/rfc/trailing_comma_in_closure_use_list	2020-07-22 18:43:55 +02:00
Nikita Popov	739b4b4c60	Fix handling of unterminated comment with trailing newline Fixes #688.	2020-07-22 18:35:55 +02:00
Nikita Popov	17f478107a	Fix file name	2020-07-22 18:30:00 +02:00
Graham Campbell	cd7c058e76	Added missing entry to change log and correct next version indicator (#685 ) * Added missing entry to change log and correct next version indicator * Update composer.json	2020-07-19 18:36:23 +02:00
Mikaël Mayer	d8b19d7963	Fixed rebuildParsers.php (#686 ) phpyacc is a sh file and should not be run via the php interpreter, but directly.	2020-07-16 21:51:43 +02:00
Tomas Votruba	69c5d48afd	[PHP 8.0] Add match expressions (#672 ) RFC: https://wiki.php.net/rfc/match_expression_v2 Upstream implementation: php/php-src#5371 Closes #671.	2020-07-15 21:40:05 +02:00
Graham Campbell	6ec527bce7	Corrected license text	2020-07-13 22:32:20 +02:00
Graham Campbell	fc25609ecb	Fixed branch alias	2020-07-13 21:19:31 +02:00
Sebastian Bergmann	f545f18a87	Add ParentConnectingVisitor and NodeConnectingVisitor (#681 )	2020-07-11 11:31:43 +02:00
Nikita Popov	c346bbfafe	Release PHP-Parser 4.6.0	2020-07-02 19:12:47 +02:00
Nikita Popov	4abc531213	Canonicalize to PHP 8 comment token format The trailing newline is no longer part of the comment token.	2020-06-27 18:53:09 +02:00
TomasVotruba	b58b19ed1d	Add constructor promotion support	2020-06-27 17:57:47 +02:00
Nikita Popov	0d2d8f95a1	FPPP: Support catch without variable	2020-06-27 17:42:46 +02:00
TomasVotruba	244db65dd1	[PHP 8.0] Add trailing comma in parameter list	2020-06-12 20:24:25 +02:00
Nikita Popov	53c2753d75	Release PHP-Parser 4.5.0	2020-06-03 09:24:19 +02:00
TomasVotruba	b5f5313d73	[PHP 8.0] Add exception witout variable	2020-06-03 09:18:13 +02:00
Máté Kocsis	32f89662f3	Add support for the mixed type	2020-05-28 23:39:04 +02:00
Hassan Tariq	f33f081c8f	Fix a minor typo	2020-04-18 10:56:47 +02:00
Nikita Popov	bd43ec7152	Release PHP-Parser 4.4.0	2020-04-10 18:34:50 +02:00
Nikita Popov	d86ca0f745	Support arbitrary expressions in new/instanceof	2020-02-22 21:09:03 +01:00
Nikita Popov	c8d1216531	Treat magic constants like normal constants	2020-02-22 21:06:03 +01:00
Nikita Popov	8999a13cb2	Make class constants fully dereferencable	2020-02-22 21:03:53 +01:00
Nikita Popov	c1eaa0d5cd	Unify array and object dereferencability	2020-02-22 20:57:39 +01:00
Nikita Popov	ca5f7c9761	Split productions, unify {} dereferencing	2020-02-22 20:54:55 +01:00
Nikita Popov	ad696ee75d	Make encapsed strings fully dereferencable	2020-02-22 20:49:11 +01:00
Nikita Popov	6770deda3d	Check that ::class on object works	2020-02-22 20:42:11 +01:00
Nikita Popov	568236a305	Allow expressions in list() Similar to the previous commit: list() syntactically accepts any expression and non-variables are compile-time errors. The special case of ($a) ends up being legal by accident.	2020-02-19 21:29:17 +01:00
Nikita Popov	9dda080a9d	Allow expressions in isset() Partial fix for #653. PHP 7 allows expressions inside isset(), but rejects non-variables in the compiler. A side-effect of this is that isset(($x)) is allowed, though this is not intentional.	2020-02-19 21:14:33 +01:00
Nikita Popov	3ec87ef757	Don't require doc comment to be last comment Fixes #652.	2020-02-15 10:52:34 +01:00
Nikita Popov	a2443aaefa	Make check in numeric literal separator emulator more precise a) Don't check for !== false, preg_match() return 0 if there is no match. This effectively means that the check was always true. b) Check for hex characters only if there's an 0x prefix. 1_1 is very likely a numeric separator, but a_b might well be part of an identifier. Fixes #639.	2020-02-09 22:50:19 +01:00
Ruud Kamphuis	64f4d5b619	Add `getProperty` to `ClassLike`	2020-02-09 22:43:42 +01:00
Nikita Popov	f56d90d4f8	Add additional tests for modifying a Nop comment	2020-02-09 17:23:42 +01:00
Nikita Popov	40aa2282df	Remove trailing comma	2020-02-09 17:15:59 +01:00
Nikita Popov	46cbd9393a	Place Nop nodes more precisely If the Nop is created to collect comments, place it directly after the comment, instead of at the next non-whitespace character.	2020-02-09 17:10:33 +01:00
Nikita Popov	602af9060d	Add end line / file position / token position to comments	2020-02-09 16:53:46 +01:00
Nikita Popov	bf086d9833	FPPP: Remove special Nop handling This results in ugly formatting, but avoids generating invalid code.	2020-02-09 16:17:12 +01:00
Ryan Weaver	521addec91	Adding a test case for Nop causing bad new statement placement	2020-02-09 16:16:38 +01:00
Tomáš Votruba	88f3a669c1	Add union type to ParamBuilder and BuilderHelpers	2020-01-05 00:34:49 +01:00
Graham Campbell	ba9cf39999	Test on PHP 7.4 stable	2019-12-20 12:15:00 +01:00
Sam Reed	f862853987	Add .gitattributes to .gitattributes Alphasort too	2019-11-12 15:22:35 +01:00
Nikita Popov	9a9981c347	Release PHP-Parser 4.3.0	2019-11-08 14:50:10 +01:00
Nikita Popov	2c42f64475	Update php-yacc dependency This version has fixed error handling.	2019-11-08 14:46:41 +01:00
Nikita Popov	664c10121e	Add support for union types We definitely need to introduce a general "Type" abstraction in the next major version.	2019-11-08 14:45:32 +01:00
Nikita Popov	5b1cd2e4f2	Fix phpdoc for Param\Builer::$type	2019-11-02 18:29:08 +01:00
Nikita Popov	b76bbc3c51	Release PHP-Parser 4.2.5	2019-10-25 20:33:07 +02:00
Nikita Popov	eacc5dbe19	Default to using php-yacc to generate the parsers	2019-10-19 15:24:38 +02:00
Nikita Popov	3226eb4086	Accept KMYACC env var in rebuildParsers.php	2019-10-19 12:28:45 +02:00
Nikita Popov	54c37f6b3b	Remove -l flag from kmyacc invocation For PHP this doesn't do anything anyway.	2019-10-19 11:14:42 +02:00
Nikita Popov	0a80b2d8ee	Fix PHP 8 compatibility This is a fix to preserve current behavior, but this should be changed towards doing the same as PHP 8 does.	2019-10-19 10:49:37 +02:00
Nikita Popov	2f45e05042	Skip php-src test file	2019-10-19 10:44:01 +02:00
Sam Reed	69c105dde1	Add .gitignore to .gitattributes	2019-10-19 10:26:01 +02:00
Kyle	603203177e	Optimize production build by ignoring dev files	2019-09-18 11:25:40 +02:00
Nikita Popov	97e59c7a16	Release PHP-Parser 4.2.4	2019-09-01 09:51:21 +02:00
Tomas Votruba	006acba066	add getTraitUses() method to ClassLike	2019-08-31 09:26:51 +02:00
Tomas Votruba	005bb1dba7	add getProperties() and getConstants() to ClassLike	2019-08-30 20:47:14 +02:00
Tomas Votruba	40e7b67d69	gitignore: add phpunit test cache	2019-08-30 20:47:14 +02:00
Nikita Popov	5644a916bc	Sync flexible heredoc emulation with label fix This was recently fixed in PHP via `310708845f` so we should fix it here as well. I'm not adding a dedicated test as it will fail until new PHP versions are released. This is indirectly tested through the php-src tester.	2019-08-30 20:21:28 +02:00
Nikita Popov	e612609022	Release PHP-Parser 4.2.3	2019-08-12 22:17:41 +02:00
Nikita Popov	4fd36b9946	Fix compatibility with T_BAD_CHARACTER in PHP 7.4	2019-08-12 22:10:02 +02:00
Tyson Andre	a1f72690ef	Fix harmless typos in documentation	2019-07-23 12:32:37 +02:00
Tyson Andre	2e2954ccdf	Avoid notices in php 7.4 with hexdec/base_convert (#619 ) This is made to avoid notices caused by https://wiki.php.net/rfc/base_convert_improvements (seen with `php -d error_reporting=E_ALL vendor/bin/phpunit`)	2019-07-14 10:56:13 +02:00
Tomáš Votruba	3f718ee2c3	[PHP 7.4] Add support for numeric literal separators (#615 ) Implements RFC https://wiki.php.net/rfc/numeric_literal_separator. Closes #614.	2019-06-30 12:13:28 +02:00
Nikita Popov	b9b45dd2bc	Insert T_BAD_CHARACTER tokens for missing characters The token stream should cover all characters in the original code, insert a dummy token for missing illegal characters. We should really be doing this in token_get_all() as well.	2019-06-30 11:43:48 +02:00
Chris Hewitt	a4b43edb03	Fix one-character inconsistency	2019-06-30 09:25:26 +02:00
Nikita Popov	3cf61fdd26	Only ignore-platform-reqs on nightly	2019-06-23 15:11:05 +02:00
Nikita Popov	9484baf8f8	Make compatible with PhpUnit 8	2019-06-23 15:03:40 +02:00
Nikita Popov	aad0e2896f	Remove token registration from TokenEmulator interface	2019-06-23 14:50:14 +02:00
hoels	624f71fa6f	Resolve return type of arrow functions (#613 )	2019-06-04 16:25:12 +02:00
Nikita Popov	1bd73cc04c	Release PHP-Parser 4.2.2	2019-05-25 22:07:01 +02:00
Nikita Popov	94d93f27a5	Revert "Recover from error inside alternative array deref syntax" This reverts commit `9d44edf85d`.	2019-05-24 22:58:13 +02:00
Nikita Popov	a167aa2061	Optimize attribue checks in the lexer	2019-05-12 15:26:26 +02:00
Nikita Popov	993f29906b	Avoid parent constructor call during node construction Instead explicitly assign the attributes. This is a minor performance improvement.	2019-05-12 14:55:21 +02:00
Nikita Popov	9d44edf85d	Recover from error inside alternative array deref syntax This is to improve error recovery for cases like #545.	2019-05-12 11:38:15 +02:00
Nikita Popov	aa97a9bb69	Add changelog entries	2019-05-11 23:08:31 +02:00
Nikita Popov	aa72c5d674	FPPP: Support inserting into empty lists	2019-05-11 22:49:32 +02:00
Nikita Popov	60d025a914	Fix attributes for zero-length nop nodes Previously zero-length nop nodes used the lookahead start attributes and current end attributes. This choice ends up being somewhat weird, because the end attributes will be the at the last non-whitespace, non-comment token, which might be quite far back. More problematically, we may not have encountered any non-discarded token if we're at the start of the file, in which case we will have no end attributes to assign. Change things to use a canonical "zero-length" node representation, where the end position (token & file) will be exactly one before the start position. Fixes #589.	2019-05-11 20:01:25 +02:00
Nikita Popov	b2cecec6bc	Remove bogus exprStmt mode test We're always generating expression statements nowadays, this flag hasn't existed for a long while now...	2019-05-11 18:51:37 +02:00
Tomas Votruba	8012faea54	[PHP 7.4] Add array spread	2019-05-09 19:15:35 +02:00
Tomáš Votruba	f3b19c19ef	[PHP 7.4] Add support for arrow functions (#602 ) Per RFC https://wiki.php.net/rfc/arrow_functions_v2.	2019-05-09 14:17:28 +02:00
Andrea Cardaci	78d9985d11	Print messages to stderr in bin/php-parse and fix exit status Close #605.	2019-04-28 22:06:06 +02:00
Nikita Popov	57b8673ea7	Use --ignore-platform-reqs on Travis Allows testing on nightly, which is PHP 8.	2019-02-16 21:58:22 +01:00
Nikita Popov	5221f49a60	Release PHP-Parser 4.2.1	2019-02-16 21:54:15 +01:00
Nikita Popov	ae4e90d558	Add PHP 7.4 to Travis matrix	2019-02-16 21:52:44 +01:00
Tomas Votruba	9de96821f7	Add support for ??= operator Introduced in PHP 5.4, represented using an AssignOp\Coalesce node.	2019-02-09 11:16:26 +01:00
Lars Moelleken	b7e6361536	updates via "rectorphp/rector" (#573 ) - "global" -> remove unused "use" statements - "phpunit" -> fix "@covers" comments - "phpunit" -> replace "->will($this->returnValue()" with "->willReturn()" - "UseTest.php" -> add missing namespace - "composer.json" -> use "autoload-dev" - remove -> "require_once" usage in the tests (use autoload-dev via composer.json) -> most of the changes are done automatically by "https://github.com/rectorphp/rector"	2019-01-19 11:18:00 +01:00
Nikita Popov	594bcae1fc	Release PHP-Parser 4.2.0	2019-01-12 17:31:37 +01:00
Nikita Popov	d5180f0d95	Change test to use correct node type Class name is an Identifier, not a Name.	2019-01-12 17:31:37 +01:00
Nikita Popov	1f95f9215c	Tweak type annotation to include null	2019-01-12 17:31:37 +01:00
Nikita Popov	6b9dd7afe7	Avoid redundant argument	2019-01-12 17:31:37 +01:00
Andreas Möller	ba092652fe	Enhancement: Reference phpunit.xsd as installed with composer	2019-01-09 21:50:03 +01:00
Andreas Möller	ec0d834c5f	Enhancement: Normalize composer.json	2019-01-09 21:49:38 +01:00
Nikita Popov	ea3657fc5f	Bump version to 4.2.0-dev	2019-01-05 21:34:53 +01:00
Tomas Votruba	af8c729603	Add PHP 7.4 typed properties support	2019-01-05 21:34:25 +01:00
Tomas Votruba	0ef61b49bb	add float/double/real KIND support to Cast\Double node	2019-01-05 19:23:00 +01:00
Nikita Popov	90ee36a7fc	Actually remove assertion...	2018-12-26 14:19:18 +01:00