Release PHP-Parser 3.0.3

Conflicts:
	lib/PhpParser/NodeVisitor.php

.travis.yml

@@ -7,7 +7,6 @@ cache:
     - $HOME/.composer/cache
 
 php:
-  - 5.4
   - 5.5
   - 5.6
   - 7.0

CHANGELOG.md

@@ -1,8 +1,173 @@
-Version 2.1.2-dev
+Version 3.0.4-dev
 -----------------
 
 Nothing yet.
 
+Version 3.0.3 (2017-02-03)
+--------------------------
+
+### Fixed
+
+* In `"$foo[0]"` the `0` is now parsed as an `LNumber` rather than `String`. (#325)
+* Ensure integers and floats are always pretty printed preserving semantics, even if the particular
+  value can only be manually constructed.
+* Throw a `LogicException` when trying to pretty-print an `Error` node. Previously this resulted in
+  an undefined method exception or fatal error.
+
+### Added
+
+* [PHP 7.1] Added support for negative interpolated offsets: `"$foo[-1]"`
+* Added `preserveOriginalNames` option to `NameResolver`. If this option is enabled, an
+  `originalName` attribute, containing the unresolved name, will be added to each resolved name.
+* Added `php-parse --with-positions` option, which dumps nodes with position information.
+
+### Deprecated
+
+* The XML serializer has been deprecated. In particular, the classes `Serializer\XML`,
+  `Unserializer\XML`, as well as the interfaces `Serializer` and `Unserializer` are deprecated.
+
+Version 3.0.2 (2016-12-06)
+--------------------------
+
+### Fixed
+
+* Fixed name resolution of nullable types. (#324)
+* Fixed pretty-printing of nullable types.
+
+Version 3.0.1 (2016-12-01)
+--------------------------
+
+### Fixed
+
+* Fixed handling of nested `list()`s: If the nested list was unkeyed, it was directly included in
+  the list items. If it was keyed, it was wrapped in `ArrayItem`. Now nested `List_` nodes are
+  always wrapped in `ArrayItem`s. (#321)
+
+Version 3.0.0 (2016-11-30)
+--------------------------
+
+### Added
+
+* Added support for dumping node positions in the NodeDumper through the `dumpPositions` option.
+* Added error recovery support for `$`, `new`, `Foo::`.
+
+Version 3.0.0-beta2 (2016-10-29)
+--------------------------------
+
+This release primarily improves our support for error recovery.
+
+### Added
+
+* Added `Node::setDocComment()` method.
+* Added `Error::getMessageWithColumnInfo()` method.
+* Added support for recovery from lexer errors.
+* Added support for recovering from "special" errors (i.e. non-syntax parse errors).
+* Added precise location information for lexer errors.
+* Added `ErrorHandler` interface, and `ErrorHandler\Throwing` and `ErrorHandler\Collecting` as
+  specific implementations. These provide a general mechanism for handling error recovery.
+* Added optional `ErrorHandler` argument to `Parser::parse()`, `Lexer::startLexing()` and
+  `NameResolver::__construct()`.
+* The `NameResolver` now adds a `namespacedName` attribute on name nodes that cannot be statically
+  resolved (unqualified unaliased function or constant names in namespaces).
+  
+### Fixed
+
+* Fixed attribute assignment for `GroupUse` prefix and variables in interpolated strings.
+
+### Changed
+
+* The constants on `NameTraverserInterface` have been moved into the `NameTraverser` class.
+* Due to the error handling changes, the `Parser` interface and `Lexer` API have changed.
+* The emulative lexer now directly postprocesses tokens, instead of using `~__EMU__~` sequences.
+  This changes the protected API of the lexer.
+* The `Name::slice()` method now returns `null` for empty slices, previously `new Name([])` was
+  used. `Name::concat()` now also supports concatenation with `null`.
+
+### Removed
+
+* Removed `Name::append()` and `Name::prepend()`. These mutable methods have been superseded by
+  the immutable `Name::concat()`.
+* Removed `Error::getRawLine()` and `Error::setRawLine()`. These methods have been superseded by
+  `Error::getStartLine()` and `Error::setStartLine()`.
+* Removed support for node cloning in the `NodeTraverser`.
+* Removed `$separator` argument from `Name::toString()`.
+* Removed `throw_on_error` parser option and `Parser::getErrors()` method. Use the `ErrorHandler`
+  mechanism instead.
+
+Version 3.0.0-beta1 (2016-09-16)
+--------------------------------
+
+### Added
+
+* [7.1] Function/method and parameter builders now support PHP 7.1 type hints (void, iterable and
+  nullable types).
+* Nodes and Comments now implement `JsonSerializable`. The node kind is stored in a `nodeType`
+  property.
+* The `InlineHTML` node now has an `hasLeadingNewline` attribute, that specifies whether the
+  preceding closing tag contained a newline. The pretty printer honors this attribute.
+* Partial parsing of `$obj->` (with missing property name) is now supported in error recovery mode.
+* The error recovery mode is now exposed in the `php-parse` script through the `--with-recovery`
+  or `-r` flags.
+
+The following changes are also part of PHP-Parser 2.1.1:
+
+* The PHP 7 parser will now generate a parse error for `$var =& new Obj` assignments.
+* Comments on free-standing code blocks will now be retained as comments on the first statement in
+  the code block.
+
+Version 3.0.0-alpha1 (2016-07-25)
+---------------------------------
+
+### Added
+
+* [7.1] Added support for `void` and `iterable` types. These will now be represented as strings
+  (instead of `Name` instances) similar to other builtin types.
+* [7.1] Added support for class constant visibility. The `ClassConst` node now has a `flags` subnode
+  holding the visibility modifier, as well as `isPublic()`, `isProtected()` and `isPrivate()`
+  methods. The constructor changed to accept the additional subnode.
+* [7.1] Added support for nullable types. These are represented using a new `NullableType` node
+  with a single `type` subnode.
+* [7.1] Added support for short array destructuring syntax. This means that `Array` nodes may now
+  appear as the left-hand-side of assignments and foreach value targets. Additionally the array
+  items may now contain `null` values if elements are skipped.
+* [7.1] Added support for keys in list() destructuring. The `List` subnode `vars` has been renamed
+  to `items` and now contains `ArrayItem`s instead of plain variables.
+* [7.1] Added support for multi-catch. The `Catch` subnode `type` has been renamed to `types` and
+  is now an array of `Name`s.
+* `Name::slice()` now supports lengths and negative offsets. This brings it in line with
+  `array_slice()` functionality.
+
+### Changed
+
+Due to PHP 7.1 support additions described above, the node structure changed as follows:
+
+* `void` and `iterable` types are now stored as strings if the PHP 7 parser is used.
+* The `ClassConst` constructor changed to accept an additional `flags` subnode.
+* The `Array` subnode `items` may now contain `null` elements (destructuring).
+* The `List` subnode `vars` has been renamed to `items` and now contains `ArrayItem`s instead of
+  plain variables.
+* The `Catch` subnode `type` has been renamed to `types` and is now an array of `Name`s.
+
+Additionally the following changes were made:
+
+* The `type` subnode on `Class`, `ClassMethod` and `Property` has been renamed to `flags`. The
+  `type` subnode has retained for backwards compatibility and is populated to the same value as
+  `flags`. However, writes to `type` will not update `flags`.
+* The `TryCatch` subnode `finallyStmts` has been replaced with a `finally` subnode that holds an
+  explicit `Finally` node. This allows for more accurate attribute assignment.
+* The `Trait` constructor now has the same form as the `Class` and `Interface` constructors: It
+  takes an array of subnodes. Unlike classes/interfaces, traits can only have a `stmts` subnode.
+* The `NodeDumper` now prints class/method/property/constant modifiers, as well as the include and
+  use type in a textual representation, instead of only showing the number.
+* All methods on `PrettyPrinter\Standard` are now protected. Previoulsy most of them were public.
+
+### Removed
+
+* Removed support for running on PHP 5.4. It is however still possible to parse PHP 5.2-5.4 code
+  while running on a newer version.
+* The deprecated `Comment::setLine()` and `Comment::setText()` methods have been removed.
+* The deprecated `Name::set()`, `Name::setFirst()` and `Name::setLast()` methods have been removed.
+
 Version 2.1.1 (2016-09-16)
 --------------------------
 
@@ -112,7 +277,7 @@ A more detailed description of backwards incompatible changes can be found in th
 
 ### Removed
 
-* Removed support for running on PHP 5.4. It is however still possible to parse PHP 5.2 and PHP 5.3
+* Removed support for running on PHP 5.3. It is however still possible to parse PHP 5.2 and PHP 5.3
   code while running on a newer version.
 * Removed legacy class name aliases. This includes the old non-namespaced class names and the old
   names for classes that were renamed for PHP 7 compatibility.

README.md

@@ -3,10 +3,12 @@ PHP Parser
 
 [![Build Status](https://travis-ci.org/nikic/PHP-Parser.svg?branch=master)](https://travis-ci.org/nikic/PHP-Parser) [![Coverage Status](https://coveralls.io/repos/github/nikic/PHP-Parser/badge.svg?branch=master)](https://coveralls.io/github/nikic/PHP-Parser?branch=master)
 
-This is a PHP 5.2 to PHP 7.0 parser written in PHP. Its purpose is to simplify static code analysis and
+This is a PHP 5.2 to PHP 7.1 parser written in PHP. Its purpose is to simplify static code analysis and
 manipulation.
 
-[**Documentation for version 2.x**][doc_master] (stable; for running on PHP >= 5.4; for parsing PHP 5.2 to PHP 7.0).
+[**Documentation for version 3.x**][doc_master] (stable; for running on PHP >= 5.5; for parsing PHP 5.2 to PHP 7.1).
+
+[Documentation for version 2.x][doc_2_x] (stable; for running on PHP >= 5.4; for parsing PHP 5.2 to PHP 7.0).
 
 [Documentation for version 1.x][doc_1_x] (unsupported; for running on PHP >= 5.3; for parsing PHP 5.2 to PHP 5.6).
 
@@ -89,8 +91,9 @@ Documentation
 
 Component documentation:
 
- 1. [Error](doc/component/Error.markdown)
+ 1. [Error handling](doc/component/Error_handling.markdown)
  2. [Lexer](doc/component/Lexer.markdown)
 
  [doc_1_x]: https://github.com/nikic/PHP-Parser/tree/1.x/doc
+ [doc_2_x]: https://github.com/nikic/PHP-Parser/tree/2.x/doc
  [doc_master]: https://github.com/nikic/PHP-Parser/tree/master/doc

UPGRADE-3.0.md

@@ -0,0 +1,160 @@
+Upgrading from PHP-Parser 2.x to 3.0
+====================================
+
+The backwards-incompatible changes in this release may be summarized as follows:
+
+ * The specific details of the node representation have changed in some cases, primarily to
+   accomodate new PHP 7.1 features.
+ * There have been significant changes to the error recovery implementation. This may affect you,
+   if you used the error recovery mode or have a custom lexer implementation.
+ * A number of deprecated methods were removed.
+
+### PHP version requirements
+
+PHP-Parser now requires PHP 5.5 or newer to run. It is however still possible to *parse* PHP 5.2,
+5.3 and 5.4 source code, while running on a newer version.
+
+### Changes to the node structure
+
+The following changes are likely to require code changes if the respective nodes are used:
+
+ * The `List` subnode `vars` has been renamed to `items` and now contains `ArrayItem`s instead of
+   plain variables.
+ * The `Catch` subnode `type` has been renamed to `types` and is now an array of `Name`s.
+ * The `TryCatch` subnode `finallyStmts` has been replaced with a `finally` subnode that holds an
+   explicit `Finally` node.
+ * The `type` subnode on `Class`, `ClassMethod` and `Property` has been renamed to `flags`. The
+   `type` subnode has retained for backwards compatibility and is populated to the same value as
+   `flags`. However, writes to `type` will not update `flags` and use of `type` is discouraged.
+
+The following changes are unlikely to require code changes:
+
+ * The `ClassConst` constructor changed to accept an additional `flags` subnode.
+ * The `Trait` constructor now has the same form as the `Class` and `Interface` constructors: It
+   takes an array of subnodes. Unlike classes/interfaces, traits can only have a `stmts` subnode.
+ * The `Array` subnode `items` may now contain `null` elements (due to destructuring).
+ * `void` and `iterable` types are now stored as strings if the PHP 7 parser is used. Previously
+   these would have been represented as `Name` instances.
+
+### Changes to error recovery mode
+
+Previously, error recovery mode was enabled by setting the `throwOnError` option to `false` when
+creating the parser, while collected errors were retrieved using the `getErrors()` method:
+
+```php
+$lexer = ...;
+$parser = (new ParserFactory)->create(ParserFactor::ONLY_PHP7, $lexer, [
+    'throwOnError' => true,
+]);
+
+$stmts = $parser->parse($code);
+$errors = $parser->getErrors();
+if ($errors) {
+    handleErrors($errors);
+}
+processAst($stmts);
+```
+
+Both the `throwOnError` option and the `getErrors()` method have been removed in PHP-Parser 3.0.
+Instead an instance of `ErrorHandler\Collecting` should be passed to the `parse()` method:
+
+```php
+$lexer = ...;
+$parser = (new ParserFactory)->create(ParserFactor::ONLY_PHP7, $lexer);
+
+$errorHandler = new ErrorHandler\Collecting;
+$stmts = $parser->parse($code, $errorHandler);
+if ($errorHandler->hasErrors()) {
+    handleErrors($errorHandler->getErrors());
+}
+processAst($stmts);
+```
+
+#### Multiple parser fallback in error recovery mode
+
+As a result of this change, if a `Multiple` parser is used (e.g. through the `ParserFactory` using
+`PREFER_PHP7` or `PREFER_PHP5`), it will now return the result of the first *non-throwing* parse. As
+parsing never throws in error recovery mode, the result from the first parser will always be
+returned.
+
+The PHP 7 parser is a superset of the PHP 5 parser, with the exceptions that `=& new` and
+`global $$foo->bar` are not supported (other differences are in representation only). The PHP 7
+parser will be able to recover from the error in both cases. For this reason, this change will
+likely pass unnoticed if you do not specifically test for this syntax.
+
+It is possible to restore the precise previous behavior with the following code:
+
+```php
+$lexer = ...;
+$parser7 = new Parser\Php7($lexer);
+$parser5 = new Parser\Php5($lexer);
+
+$errors7 = new ErrorHandler\Collecting();
+$stmts7 = $parser7->parse($code, $errors7);
+if ($errors7->hasErrors()) {
+    $errors5 = new ErrorHandler\Collecting();
+    $stmts5 = $parser5->parse($code, $errors5);
+    if (!$errors5->hasErrors()) {
+        // If PHP 7 parse has errors but PHP 5 parse has no errors, use PHP 5 result
+        return [$stmts5, $errors5];
+    }
+}
+// If PHP 7 succeeds or both fail use PHP 7 result
+return [$stmts7, $errors7];
+```
+
+#### Error handling in the lexer
+
+In order to support recovery from lexer errors, the signature of the `startLexing()` method changed
+to optionally accept an `ErrorHandler`:
+
+```php
+// OLD
+public function startLexing($code);
+// NEW
+public function startLexing($code, ErrorHandler $errorHandler = null);
+```
+
+If you use a custom lexer with overriden `startLexing()` method, it needs to be changed to accept
+the extra parameter. The value should be passed on to the parent method.
+
+#### Error checks in node constructors
+
+The constructors of certain nodes used to contain additional checks for semantic errors, such as
+creating a try block without either catch or finally. These checks have been moved from the node
+constructors into the parser. This allows recovery from such errors, as well as representing the
+resulting (invalid) AST.
+
+This means that certain error conditions are no longer checked for manually constructed nodes.
+
+### Removed methods, arguments, options
+
+The following methods, arguments or options have been removed:
+
+ * `Comment::setLine()`, `Comment::setText()`: Create new `Comment` instances instead.
+ * `Name::set()`, `Name::setFirst()`, `Name::setLast()`, `Name::append()`, `Name::prepend()`:
+    Use `Name::concat()` in combination with `Name::slice()` instead.
+ * `Error::getRawLine()`, `Error::setRawLine()`. Use `Error::getStartLine()` and
+   `Error::setStartLine()` instead.
+ * `Parser::getErrors()`. Use `ErrorHandler\Collecting` instead.
+ * `$separator` argument of `Name::toString()`. Use `strtr()` instead, if you really need it.
+ * `$cloneNodes` argument of `NodeTraverser::__construct()`. Explicitly clone nodes in the visitor
+   instead.
+ * `throwOnError` parser option. Use `ErrorHandler\Collecting` instead.
+
+### Miscellaneous
+
+ * The `NameResolver` will now resolve unqualified function and constant names in the global
+   namespace into fully qualified names. For example `foo()` in the global namespace resolves to
+   `\foo()`. For names where no static resolution is possible, a `namespacedName` attribute is
+   added now, containing the namespaced variant of the name.
+ * All methods on `PrettyPrinter\Standard` are now protected. Previoulsy most of them were public.
+   The pretty printer should only be invoked using the `prettyPrint()`, `prettyPrintFile()` and
+   `prettyPrintExpr()` methods.
+ * The node dumper now prints numeric values that act as enums/flags in a string representation.
+   If node dumper results are used in tests, updates may be needed to account for this.
+ * The constants on `NameTraverserInterface` have been moved into the `NameTraverser` class.
+ * The emulative lexer now directly postprocesses tokens, instead of using `~__EMU__~` sequences.
+   This changes the protected API of the emulative lexer.
+ * The `Name::slice()` method now returns `null` for empty slices, previously `new Name([])` was
+   used. `Name::concat()` now also supports concatenation with `null`.

bin/php-parse

@@ -29,8 +29,14 @@ if (empty($files)) {
 $lexer = new PhpParser\Lexer\Emulative(array('usedAttributes' => array(
     'startLine', 'endLine', 'startFilePos', 'endFilePos', 'comments'
 )));
-$parser = (new PhpParser\ParserFactory)->create(PhpParser\ParserFactory::PREFER_PHP7, $lexer);
-$dumper = new PhpParser\NodeDumper(['dumpComments' => true]);
+$parser = (new PhpParser\ParserFactory)->create(
+    PhpParser\ParserFactory::PREFER_PHP7,
+    $lexer
+);
+$dumper = new PhpParser\NodeDumper([
+    'dumpComments' => true,
+    'dumpPositions' => $attributes['with-positions'],
+]);
 $prettyPrinter = new PhpParser\PrettyPrinter\Standard;
 $serializer = new PhpParser\Serializer\XML;
 
@@ -50,26 +56,29 @@ foreach ($files as $file) {
         echo "====> File $file:\n";
     }
 
-    try {
-        $stmts = $parser->parse($code);
-    } catch (PhpParser\Error $e) {
-        if ($attributes['with-column-info'] && $e->hasColumnInfo()) {
-            $startLine = $e->getStartLine();
-            $endLine = $e->getEndLine();
-            $startColumn = $e->getStartColumn($code);
-            $endColumn   = $e->getEndColumn($code);
-            $message .= $e->getRawMessage() . " from $startLine:$startColumn to $endLine:$endColumn";
-        } else {
-            $message = $e->getMessage();
+    if ($attributes['with-recovery']) {
+        $errorHandler = new PhpParser\ErrorHandler\Collecting;
+        $stmts = $parser->parse($code, $errorHandler);
+        foreach ($errorHandler->getErrors() as $error) {
+            $message = formatErrorMessage($error, $code, $attributes['with-column-info']);
+            echo $message . "\n";
+        }
+        if (null === $stmts) {
+            continue;
+        }
+    } else {
+        try {
+            $stmts = $parser->parse($code);
+        } catch (PhpParser\Error $error) {
+            $message = formatErrorMessage($error, $code, $attributes['with-column-info']);
+            die($message . "\n");
         }
-
-        die($message . "\n");
     }
 
     foreach ($operations as $operation) {
         if ('dump' === $operation) {
             echo "==> Node dump:\n";
-            echo $dumper->dump($stmts), "\n";
+            echo $dumper->dump($stmts, $code), "\n";
         } elseif ('pretty-print' === $operation) {
             echo "==> Pretty print:\n";
             echo $prettyPrinter->prettyPrintFile($stmts), "\n";
@@ -86,6 +95,14 @@ foreach ($files as $file) {
     }
 }
 
+function formatErrorMessage(PhpParser\Error $e, $code, $withColumnInfo) {
+    if ($withColumnInfo && $e->hasColumnInfo()) {
+        return $e->getMessageWithColumnInfo($code);
+    } else {
+        return $e->getMessage();
+    }
+}
+
 function showHelp($error = '') {
     if ($error) {
         echo $error . "\n\n";
@@ -103,6 +120,8 @@ Operations is a list of the following options (--dump by default):
         --var-dump          var_dump() nodes (for exact structure)
     -N, --resolve-names     Resolve names using NodeVisitor\NameResolver
     -c, --with-column-info  Show column-numbers for errors (if available)
+    -P, --with-positions    Show positions in node dumps
+    -r, --with-recovery     Use parsing with error recovery
     -h, --help              Display this page
 
 Example:
@@ -120,6 +139,8 @@ function parseArgs($args) {
     $files = array();
     $attributes = array(
         'with-column-info' => false,
+        'with-posititions' => false,
+        'with-recovery' => false,
     );
 
     array_shift($args);
@@ -153,6 +174,14 @@ function parseArgs($args) {
             case '-c';
                 $attributes['with-column-info'] = true;
                 break;
+            case '--with-positions':
+            case '-P':
+                $attributes['with-positions'] = true;
+                break;
+            case '--with-recovery':
+            case '-r':
+                $attributes['with-recovery'] = true;
+                break;
             case '--help':
             case '-h';
                 showHelp();

composer.json

@@ -10,11 +10,11 @@
         }
     ],
     "require": {
-        "php": ">=5.4",
+        "php": ">=5.5",
         "ext-tokenizer": "*"
     },
     "require-dev": {
-        "phpunit/phpunit": "~4.0"
+        "phpunit/phpunit": "~4.0|~5.0"
     },
     "autoload": {
         "psr-4": {
@@ -24,7 +24,7 @@
     "bin": ["bin/php-parse"],
     "extra": {
         "branch-alias": {
-            "dev-master": "2.1-dev"
+            "dev-master": "3.0-dev"
         }
     }
 }

doc/0_Introduction.markdown

@@ -1,7 +1,7 @@
 Introduction
 ============
 
-This project is a PHP 5.2 to PHP 7.0 parser **written in PHP itself**.
+This project is a PHP 5.2 to PHP 7.1 parser **written in PHP itself**.
 
 What is this for?
 -----------------
@@ -29,9 +29,9 @@ What can it parse?
 The parser supports parsing PHP 5.2-5.6 and PHP 7.
 
 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 new tokens from 5.5, 5.6 and 7.0 is
-provided. This allows to parse PHP 7.0 source code running on PHP 5.4, for example. This emulation
-is somewhat hacky and not perfect, but it should work well on any sane code.
+version it runs on), additionally a wrapper for emulating tokens from newer versions is provided.
+This allows to parse PHP 7.1 source code running on PHP 5.5, for example. This emulation is somewhat
+hacky and not perfect, but it should work well on any sane code.
 
 What output does it produce?
 ----------------------------

doc/3_Other_node_tree_representations.markdown

@@ -8,7 +8,7 @@ Simple serialization
 
 It is possible to serialize the node tree using `serialize()` and also unserialize it using
 `unserialize()`. The output is not human readable and not easily processable from anything
-but PHP, but it is compact and generates fast. The main application thus is in caching.
+but PHP, but it is compact and generates quickly. The main application thus is in caching.
 
 Human readable dumping
 ----------------------
@@ -86,6 +86,134 @@ array(
 )
 ```
 
+JSON encoding
+-------------
+
+Nodes (and comments) implement the `JsonSerializable` interface. As such, it is possible to JSON
+encode the AST directly using `json_encode()`:
+
+```php
+$code = <<<'CODE'
+<?php
+
+function printLine($msg) {
+    echo $msg, "\n";
+}
+
+printLine('Hello World!!!');
+CODE;
+
+$parser = (new PhpParser\ParserFactory)->create(PhpParser\ParserFactory::PREFER_PHP7);
+$nodeDumper = new PhpParser\NodeDumper;
+
+try {
+    $stmts = $parser->parse($code);
+
+    echo json_encode($stmts, JSON_PRETTY_PRINT), "\n";
+} catch (PhpParser\Error $e) {
+    echo 'Parse Error: ', $e->getMessage();
+}
+```
+
+This will result in the following output (which includes attributes):
+
+```json
+[
+    {
+        "nodeType": "Stmt_Function",
+        "byRef": false,
+        "name": "printLine",
+        "params": [
+            {
+                "nodeType": "Param",
+                "type": null,
+                "byRef": false,
+                "variadic": false,
+                "name": "msg",
+                "default": null,
+                "attributes": {
+                    "startLine": 3,
+                    "endLine": 3
+                }
+            }
+        ],
+        "returnType": null,
+        "stmts": [
+            {
+                "nodeType": "Stmt_Echo",
+                "exprs": [
+                    {
+                        "nodeType": "Expr_Variable",
+                        "name": "msg",
+                        "attributes": {
+                            "startLine": 4,
+                            "endLine": 4
+                        }
+                    },
+                    {
+                        "nodeType": "Scalar_String",
+                        "value": "\n",
+                        "attributes": {
+                            "startLine": 4,
+                            "endLine": 4,
+                            "kind": 2
+                        }
+                    }
+                ],
+                "attributes": {
+                    "startLine": 4,
+                    "endLine": 4
+                }
+            }
+        ],
+        "attributes": {
+            "startLine": 3,
+            "endLine": 5
+        }
+    },
+    {
+        "nodeType": "Expr_FuncCall",
+        "name": {
+            "nodeType": "Name",
+            "parts": [
+                "printLine"
+            ],
+            "attributes": {
+                "startLine": 7,
+                "endLine": 7
+            }
+        },
+        "args": [
+            {
+                "nodeType": "Arg",
+                "value": {
+                    "nodeType": "Scalar_String",
+                    "value": "Hello World!!!",
+                    "attributes": {
+                        "startLine": 7,
+                        "endLine": 7,
+                        "kind": 1
+                    }
+                },
+                "byRef": false,
+                "unpack": false,
+                "attributes": {
+                    "startLine": 7,
+                    "endLine": 7
+                }
+            }
+        ],
+        "attributes": {
+            "startLine": 7,
+            "endLine": 7
+        }
+    }
+]
+```
+
+There is currently no mechanism to convert JSON back into a node tree. Furthermore, not all ASTs
+can be JSON encoded. In particular, JSON only supports UTF-8 strings.
+
 Serialization to XML
 --------------------
 

doc/component/Error_handling.markdown

@@ -35,6 +35,8 @@ the source code of the parsed file. An example for printing an error:
 if ($e->hasColumnInfo()) {
     echo $e->getRawMessage() . ' from ' . $e->getStartLine() . ':' . $e->getStartColumn($code)
         . ' to ' . $e->getEndLine() . ':' . $e->getEndColumn($code);
+    // or:
+    echo $e->getMessageWithColumnInfo();
 } else {
     echo $e->getMessage();
 }
@@ -46,27 +48,23 @@ file.
 Error recovery
 --------------
 
-> **EXPERIMENTAL**
+The error behavior of the parser (and other components) is controlled by an `ErrorHandler`. Whenever an error is
+encountered, `ErrorHandler::handleError()` is invoked. The default error handling strategy is `ErrorHandler\Throwing`,
+which will immediately throw when an error is encountered.
 
-By default the parser will throw an exception upon encountering the first error during parsing. An alternative mode is
-also supported, in which the parser will remember the error, but try to continue parsing the rest of the source code.
-
-To enable this mode the `throwOnError` parser option needs to be disabled. Any errors that occurred during parsing can
-then be retrieved using `$parser->getErrors()`. The `$parser->parse()` method will either return a partial syntax tree
-or `null` if recovery fails.
-
-A usage example:
+To instead collect all encountered errors into an array, while trying to continue parsing the rest of the source code,
+an instance of `ErrorHandler\Collecting` can be passed to the `Parser::parse()` method. A usage example:
 
 ```php
-$parser = (new PhpParser\ParserFactory)->create(PhpParser\ParserFactory::PREFER_PHP7, null, array(
-    'throwOnError' => false,
-));
+$parser = (new PhpParser\ParserFactory)->create(PhpParser\ParserFactory::ONLY_PHP7);
+$errorHandler = new PhpParser\ErrorHandler\Collecting;
 
-$stmts = $parser->parse($code);
-$errors = $parser->getErrors();
+$stmts = $parser->parse($code, $errorHandler);
 
-foreach ($errors as $error) {
-    // $error is an ordinary PhpParser\Error
+if ($errorHandler->hasErrors()) {
+    foreach ($errorHandler->getErrors() as $error) {
+        // $error is an ordinary PhpParser\Error
+    }
 }
 
 if (null !== $stmts) {
@@ -74,4 +72,4 @@ if (null !== $stmts) {
 }
 ```
 
-The error recovery implementation is experimental -- it currently won't be able to recover from many types of errors.
+The `NameResolver` visitor also accepts an `ErrorHandler` as a constructor argument.

doc/component/Lexer.markdown

@@ -95,13 +95,14 @@ Lexer extension
 
 A lexer has to define the following public interface:
 
-    void startLexing(string $code);
+    void startLexing(string $code, ErrorHandler $errorHandler = null);
     array getTokens();
     string handleHaltCompiler();
     int getNextToken(string &$value = null, array &$startAttributes = null, array &$endAttributes = null);
 
 The `startLexing()` method is invoked with the source code that is to be lexed (including the opening tag) whenever the
-`parse()` method of the parser is called. It can be used to reset state or preprocess the source code or tokens.
+`parse()` method of the parser is called. It can be used to reset state or preprocess the source code or tokens. The
+passes `ErrorHandler` should be used to report lexing errors.
 
 The `getTokens()` method returns the current token array, in the usual `token_get_all()` format. This method is not
 used by the parser (which uses `getNextToken()`), but is useful in combination with the token position attributes.
@@ -122,9 +123,10 @@ node and the `$endAttributes` from the last token that is part of the node.
 E.g. if the tokens `T_FUNCTION T_STRING ... '{' ... '}'` constitute a node, then the `$startAttributes` from the
 `T_FUNCTION` token will be taken and the `$endAttributes` from the `'}'` token.
 
-An application of custom attributes is storing the original formatting of literals: The parser does not retain
-information about the formatting of integers (like decimal vs. hexadecimal) or strings (like used quote type or used
-escape sequences). This can be remedied by storing the original value in an attribute:
+An application of custom attributes is storing the exact original formatting of literals: While the parser does retain
+some information about the formatting of integers (like decimal vs. hexadecimal) or strings (like used quote type), it
+does not preserve the exact original formatting (e.g. leading zeros for integers or escape sequences in strings). This
+can be remedied by storing the original value in an attribute:
 
 ```php
 use PhpParser\Lexer;
@@ -135,9 +137,10 @@ class KeepOriginalValueLexer extends Lexer // or Lexer\Emulative
     public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
         $tokenId = parent::getNextToken($value, $startAttributes, $endAttributes);
 
-        if ($tokenId == Tokens::T_CONSTANT_ENCAPSED_STRING // non-interpolated string
-            || $tokenId == Tokens::T_LNUMBER               // integer
-            || $tokenId == Tokens::T_DNUMBER               // floating point number
+        if ($tokenId == Tokens::T_CONSTANT_ENCAPSED_STRING   // non-interpolated string
+            || $tokenId == Tokens::T_ENCAPSED_AND_WHITESPACE // interpolated string
+            || $tokenId == Tokens::T_LNUMBER                 // integer
+            || $tokenId == Tokens::T_DNUMBER                 // floating point number
         ) {
             // could also use $startAttributes, doesn't really matter here
             $endAttributes['originalValue'] = $value;

grammar/README.md

@@ -1,13 +1,12 @@
 What do all those files mean?
 =============================
 
- * `php5.y`:            PHP 5 grammar written in a pseudo language
- * `php7.y`:            PHP 7 grammar written in a pseudo language
- * `tokens.y`:          Tokens definition shared between PHP 5 and PHP 7 grammars
- * `parser.template`:   A `kmyacc` parser prototype file for PHP
- * `tokens.template`:   A `kmyacc` prototype file for the `Tokens` class
- * `analyze.php`:       Analyzes the grammer and outputs some info about it
- * `rebuildParser.php`: Preprocesses the grammar and builds the parser using `kmyacc`
+ * `php5.y`:             PHP 5 grammar written in a pseudo language
+ * `php7.y`:             PHP 7 grammar written in a pseudo language
+ * `tokens.y`:           Tokens definition shared between PHP 5 and PHP 7 grammars
+ * `parser.template`:    A `kmyacc` parser prototype file for PHP
+ * `tokens.template`:    A `kmyacc` prototype file for the `Tokens` class
+ * `rebuildParsers.php`: Preprocesses the grammar and builds the parser using `kmyacc`
 
 .phpy pseudo language
 =====================
@@ -17,13 +16,13 @@ applied to it:
 
  * Nodes are created using the syntax `Name[..., ...]`. This is transformed into
    `new Name(..., ..., attributes())`
- * Some function-like constructs are resolved (see `rebuildParser.php` for a list)
+ * Some function-like constructs are resolved (see `rebuildParsers.php` for a list)
 
 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 `rebuildParser.php` script.
+After you compiled/installed it, run the `rebuildParsers.php` script.
 
 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`.

grammar/analyze.php

@@ -1,96 +0,0 @@
-<?php
-
-const GRAMMAR_FILE = './php5.y';
-
-const LIB = '(?(DEFINE)
-    (?<singleQuotedString>\'[^\\\\\']*+(?:\\\\.[^\\\\\']*+)*+\')
-    (?<doubleQuotedString>"[^\\\\"]*+(?:\\\\.[^\\\\"]*+)*+")
-    (?<string>(?&singleQuotedString)|(?&doubleQuotedString))
-    (?<comment>/\*[^*]*+(?:\*(?!/)[^*]*+)*+\*/)
-    (?<code>\{[^\'"/{}]*+(?:(?:(?&string)|(?&comment)|(?&code)|/)[^\'"/{}]*+)*+})
-)';
-
-const RULE_BLOCK = '(?<name>[a-z_]++):(?<rules>[^\'"/{};]*+(?:(?:(?&string)|(?&comment)|(?&code)|/|})[^\'"/{};]*+)*+);';
-
-$usedTerminals = array_flip(array(
-    'T_VARIABLE', 'T_STRING', 'T_INLINE_HTML', 'T_ENCAPSED_AND_WHITESPACE',
-    'T_LNUMBER', 'T_DNUMBER', 'T_CONSTANT_ENCAPSED_STRING', 'T_STRING_VARNAME', 'T_NUM_STRING'
-));
-$unusedNonterminals = array_flip(array(
-    'case_separator', 'optional_comma'
-));
-
-function regex($regex) {
-    return '~' . LIB . '(?:' . str_replace('~', '\~', $regex) . ')~';
-}
-
-function magicSplit($regex, $string) {
-    $pieces = preg_split(regex('(?:(?&string)|(?&comment)|(?&code))(*SKIP)(*FAIL)|' . $regex), $string);
-
-    foreach ($pieces as &$piece) {
-        $piece = trim($piece);
-    }
-
-    return array_filter($pieces);
-}
-
-echo '<pre>';
-
-////////////////////
-////////////////////
-////////////////////
-
-list($defs, $ruleBlocks) = magicSplit('%%', file_get_contents(GRAMMAR_FILE));
-
-if ('' !== trim(preg_replace(regex(RULE_BLOCK), '', $ruleBlocks))) {
-    die('Not all rule blocks were properly recognized!');
-}
-
-preg_match_all(regex(RULE_BLOCK), $ruleBlocks, $ruleBlocksMatches, PREG_SET_ORDER);
-foreach ($ruleBlocksMatches as $match) {
-    $ruleBlockName = $match['name'];
-    $rules = magicSplit('\|', $match['rules']);
-
-    foreach ($rules as &$rule) {
-        $parts = magicSplit('\s+', $rule);
-        $usedParts = array();
-
-        foreach ($parts as $part) {
-            if ('{' === $part[0]) {
-                preg_match_all('~\$([0-9]+)~', $part, $backReferencesMatches, PREG_SET_ORDER);
-                foreach ($backReferencesMatches as $match) {
-                    $usedParts[$match[1]] = true;
-                }
-            }
-        }
-
-        $i = 1;
-        foreach ($parts as &$part) {
-            if ('/' === $part[0]) {
-                continue;
-            }
-
-            if (isset($usedParts[$i])) {
-                if ('\'' === $part[0] || '{' === $part[0]
-                    || (ctype_upper($part[0]) && !isset($usedTerminals[$part]))
-                    || (ctype_lower($part[0]) && isset($unusedNonterminals[$part]))
-                ) {
-                    $part = '<span style="background-color: red; color: white;">' . $part . '</span>';
-                } else {
-                    $part = '<strong><em>' . $part . '</em></strong>';
-                }
-            } elseif ((ctype_upper($part[0]) && isset($usedTerminals[$part]))
-                      || (ctype_lower($part[0]) && !isset($unusedNonterminals[$part]))
-
-            ) {
-                $part = '<span style="background-color: blue; color: white;">' . $part . '</span>';
-            }
-
-            ++$i;
-        }
-
-        $rule = implode(' ', $parts);
-    }
-
-    echo $ruleBlockName, ':', "\n", '      ', implode("\n" . '    | ', $rules), "\n", ';', "\n\n";
-}

grammar/php5.y

@@ -55,9 +55,12 @@ top_statement:
     | class_declaration_statement                           { $$ = $1; }
     | T_HALT_COMPILER
           { $$ = Stmt\HaltCompiler[$this->lexer->handleHaltCompiler()]; }
-    | T_NAMESPACE namespace_name ';'                        { $$ = Stmt\Namespace_[$2, null]; }
-    | T_NAMESPACE namespace_name '{' top_statement_list '}' { $$ = Stmt\Namespace_[$2, $4]; }
-    | T_NAMESPACE '{' top_statement_list '}'                { $$ = Stmt\Namespace_[null,     $3]; }
+    | T_NAMESPACE namespace_name ';'
+          { $$ = Stmt\Namespace_[$2, null]; $this->checkNamespace($$); }
+    | T_NAMESPACE namespace_name '{' top_statement_list '}'
+          { $$ = Stmt\Namespace_[$2, $4]; $this->checkNamespace($$); }
+    | T_NAMESPACE '{' top_statement_list '}'
+          { $$ = Stmt\Namespace_[null, $3]; $this->checkNamespace($$); }
     | T_USE use_declarations ';'                            { $$ = Stmt\Use_[$2, Stmt\Use_::TYPE_NORMAL]; }
     | T_USE use_type use_declarations ';'                   { $$ = Stmt\Use_[$3, $2]; }
     | group_use_declaration ';'                             { $$ = $1; }
@@ -72,13 +75,13 @@ use_type:
 /* 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[Name[$3], $6, $2]; }
+          { $$ = 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[Name[$4], $7, $2]; }
+          { $$ = Stmt\GroupUse[new Name($4, stackAttributes(#4)), $7, $2]; }
     | T_USE namespace_name_parts T_NS_SEPARATOR '{' inline_use_declarations '}'
-          { $$ = Stmt\GroupUse[Name[$2], $5, Stmt\Use_::TYPE_UNKNOWN]; }
+          { $$ = 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[Name[$3], $6, Stmt\Use_::TYPE_UNKNOWN]; }
+          { $$ = Stmt\GroupUse[new Name($3, stackAttributes(#3)), $6, Stmt\Use_::TYPE_UNKNOWN]; }
 ;
 
 unprefixed_use_declarations:
@@ -98,8 +101,10 @@ inline_use_declarations:
 ;
 
 unprefixed_use_declaration:
-      namespace_name                                        { $$ = Stmt\UseUse[$1, null, Stmt\Use_::TYPE_UNKNOWN]; }
-    | namespace_name T_AS T_STRING                          { $$ = Stmt\UseUse[$1, $3, Stmt\Use_::TYPE_UNKNOWN]; }
+      namespace_name
+          { $$ = Stmt\UseUse[$1, null, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #1); }
+    | namespace_name T_AS T_STRING
+          { $$ = Stmt\UseUse[$1, $3, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #3); }
 ;
 
 use_declaration:
@@ -179,7 +184,7 @@ non_empty_statement:
           { $$ = Stmt\Foreach_[$3, $7[0], ['keyVar' => $5, 'byRef' => $7[1], 'stmts' => $9]]; }
     | T_DECLARE '(' declare_list ')' declare_statement      { $$ = Stmt\Declare_[$3, $5]; }
     | T_TRY '{' inner_statement_list '}' catches optional_finally
-          { $$ = Stmt\TryCatch[$3, $5, $6]; }
+          { $$ = Stmt\TryCatch[$3, $5, $6]; $this->checkTryCatch($$); }
     | T_THROW expr ';'                                      { $$ = Stmt\Throw_[$2]; }
     | T_GOTO T_STRING ';'                                   { $$ = Stmt\Goto_[$2]; }
     | T_STRING ':'                                          { $$ = Stmt\Label[$1]; }
@@ -201,12 +206,12 @@ catches:
 
 catch:
     T_CATCH '(' name T_VARIABLE ')' '{' inner_statement_list '}'
-        { $$ = Stmt\Catch_[$3, parseVar($4), $7]; }
+        { $$ = Stmt\Catch_[array($3), parseVar($4), $7]; }
 ;
 
 optional_finally:
       /* empty */                                           { $$ = null; }
-    | T_FINALLY '{' inner_statement_list '}'                { $$ = $3; }
+    | T_FINALLY '{' inner_statement_list '}'                { $$ = Stmt\Finally_[$3]; }
 ;
 
 variables_list:
@@ -231,11 +236,13 @@ function_declaration_statement:
 
 class_declaration_statement:
       class_entry_type T_STRING extends_from implements_list '{' class_statement_list '}'
-          { $$ = Stmt\Class_[$2, ['type' => $1, 'extends' => $3, 'implements' => $4, 'stmts' => $6]]; }
+          { $$ = Stmt\Class_[$2, ['type' => $1, 'extends' => $3, 'implements' => $4, 'stmts' => $6]];
+            $this->checkClass($$, #2); }
     | T_INTERFACE T_STRING interface_extends_list '{' class_statement_list '}'
-          { $$ = Stmt\Interface_[$2, ['extends' => $3, 'stmts' => $5]]; }
+          { $$ = Stmt\Interface_[$2, ['extends' => $3, 'stmts' => $5]];
+            $this->checkInterface($$, #2); }
     | T_TRAIT T_STRING '{' class_statement_list '}'
-          { $$ = Stmt\Trait_[$2, $4]; }
+          { $$ = Stmt\Trait_[$2, ['stmts' => $4]]; }
 ;
 
 class_entry_type:
@@ -362,9 +369,9 @@ non_empty_parameter_list:
 
 parameter:
       optional_param_type optional_ref optional_ellipsis T_VARIABLE
-          { $$ = Node\Param[parseVar($4), null, $1, $2, $3]; }
+          { $$ = Node\Param[parseVar($4), null, $1, $2, $3]; $this->checkParam($$); }
     | optional_param_type optional_ref optional_ellipsis T_VARIABLE '=' static_scalar
-          { $$ = Node\Param[parseVar($4), $6, $1, $2, $3]; }
+          { $$ = Node\Param[parseVar($4), $6, $1, $2, $3]; $this->checkParam($$); }
 ;
 
 type:
@@ -427,10 +434,12 @@ class_statement_list:
 ;
 
 class_statement:
-      variable_modifiers property_declaration_list ';'      { $$ = Stmt\Property[$1, $2]; }
-    | T_CONST class_const_list ';'                          { $$ = Stmt\ClassConst[$2]; }
+      variable_modifiers property_declaration_list ';'
+          { $$ = Stmt\Property[$1, $2]; $this->checkProperty($$, #1); }
+    | T_CONST class_const_list ';'                          { $$ = Stmt\ClassConst[$2, 0]; }
     | method_modifiers T_FUNCTION optional_ref identifier '(' parameter_list ')' optional_return_type method_body
-          { $$ = Stmt\ClassMethod[$4, ['type' => $1, 'byRef' => $3, 'params' => $6, 'returnType' => $8, 'stmts' => $9]]; }
+          { $$ = Stmt\ClassMethod[$4, ['type' => $1, 'byRef' => $3, 'params' => $6, 'returnType' => $8, 'stmts' => $9]];
+            $this->checkClassMethod($$, #1); }
     | T_USE name_list trait_adaptations                     { $$ = Stmt\TraitUse[$2, $3]; }
 ;
 
@@ -482,7 +491,7 @@ method_modifiers:
 
 non_empty_member_modifiers:
       member_modifier                                       { $$ = $1; }
-    | non_empty_member_modifiers member_modifier            { Stmt\Class_::verifyModifier($1, $2); $$ = $1 | $2; }
+    | non_empty_member_modifiers member_modifier            { $this->checkModifier($1, $2, #2); $$ = $1 | $2; }
 ;
 
 member_modifier:
@@ -640,7 +649,8 @@ scalar_dereference:
 
 anonymous_class:
       T_CLASS ctor_arguments extends_from implements_list '{' class_statement_list '}'
-          { $$ = array(Stmt\Class_[null, ['type' => 0, 'extends' => $3, 'implements' => $4, 'stmts' => $6]], $2); }
+          { $$ = array(Stmt\Class_[null, ['type' => 0, 'extends' => $3, 'implements' => $4, 'stmts' => $6]], $2);
+            $this->checkClass($$[0], -1); }
 
 new_expr:
       T_NEW class_name_reference ctor_arguments             { $$ = Expr\New_[$2, $3]; }
@@ -743,7 +753,7 @@ ctor_arguments:
 ;
 
 common_scalar:
-      T_LNUMBER                                             { $$ = Scalar\LNumber::fromString($1, attributes(), true); }
+      T_LNUMBER                                             { $$ = $this->parseLNumber($1, attributes(), true); }
     | T_DNUMBER                                             { $$ = Scalar\DNumber[Scalar\DNumber::parse($1)]; }
     | T_CONSTANT_ENCAPSED_STRING
           { $attrs = attributes(); $attrs['kind'] = strKind($1);
@@ -915,6 +925,7 @@ object_property:
       T_STRING                                              { $$ = $1; }
     | '{' expr '}'                                          { $$ = $2; }
     | variable_without_objects                              { $$ = $1; }
+    | error                                                 { $$ = Expr\Error[]; $this->errorState = 2; }
 ;
 
 list_expr:
@@ -927,8 +938,8 @@ list_expr_elements:
 ;
 
 list_expr_element:
-      variable                                              { $$ = $1; }
-    | list_expr                                             { $$ = $1; }
+      variable                                              { $$ = Expr\ArrayItem[$1, null, false]; }
+    | list_expr                                             { $$ = Expr\ArrayItem[$1, null, false]; }
     | /* empty */                                           { $$ = null; }
 ;
 
@@ -960,10 +971,14 @@ encaps_string_part:
       T_ENCAPSED_AND_WHITESPACE                             { $$ = Scalar\EncapsedStringPart[$1]; }
 ;
 
-encaps_var:
+encaps_base_var:
       T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
-    | T_VARIABLE '[' encaps_var_offset ']'                  { $$ = Expr\ArrayDimFetch[Expr\Variable[parseVar($1)], $3]; }
-    | T_VARIABLE T_OBJECT_OPERATOR T_STRING                 { $$ = Expr\PropertyFetch[Expr\Variable[parseVar($1)], $3]; }
+;
+
+encaps_var:
+      encaps_base_var                                       { $$ = $1; }
+    | encaps_base_var '[' encaps_var_offset ']'             { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | encaps_base_var T_OBJECT_OPERATOR T_STRING            { $$ = Expr\PropertyFetch[$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 T_STRING_VARNAME '[' expr ']' '}'
@@ -973,7 +988,7 @@ encaps_var:
 
 encaps_var_offset:
       T_STRING                                              { $$ = Scalar\String_[$1]; }
-    | T_NUM_STRING                                          { $$ = Scalar\String_[$1]; }
+    | T_NUM_STRING                                          { $$ = $this->parseNumString($1, attributes()); }
     | T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
 ;
 

grammar/php7.y

@@ -55,9 +55,12 @@ top_statement:
     | class_declaration_statement                           { $$ = $1; }
     | T_HALT_COMPILER
           { $$ = Stmt\HaltCompiler[$this->lexer->handleHaltCompiler()]; }
-    | T_NAMESPACE namespace_name ';'                        { $$ = Stmt\Namespace_[$2, null]; }
-    | T_NAMESPACE namespace_name '{' top_statement_list '}' { $$ = Stmt\Namespace_[$2, $4]; }
-    | T_NAMESPACE '{' top_statement_list '}'                { $$ = Stmt\Namespace_[null,     $3]; }
+    | T_NAMESPACE namespace_name ';'
+          { $$ = Stmt\Namespace_[$2, null]; $this->checkNamespace($$); }
+    | T_NAMESPACE namespace_name '{' top_statement_list '}'
+          { $$ = Stmt\Namespace_[$2, $4]; $this->checkNamespace($$); }
+    | T_NAMESPACE '{' top_statement_list '}'
+          { $$ = Stmt\Namespace_[null, $3]; $this->checkNamespace($$); }
     | T_USE use_declarations ';'                            { $$ = Stmt\Use_[$2, Stmt\Use_::TYPE_NORMAL]; }
     | T_USE use_type use_declarations ';'                   { $$ = Stmt\Use_[$3, $2]; }
     | group_use_declaration ';'                             { $$ = $1; }
@@ -72,13 +75,13 @@ use_type:
 /* 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[Name[$3], $6, $2]; }
+          { $$ = 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[Name[$4], $7, $2]; }
+          { $$ = Stmt\GroupUse[new Name($4, stackAttributes(#4)), $7, $2]; }
     | T_USE namespace_name_parts T_NS_SEPARATOR '{' inline_use_declarations '}'
-          { $$ = Stmt\GroupUse[Name[$2], $5, Stmt\Use_::TYPE_UNKNOWN]; }
+          { $$ = 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[Name[$3], $6, Stmt\Use_::TYPE_UNKNOWN]; }
+          { $$ = Stmt\GroupUse[new Name($3, stackAttributes(#3)), $6, Stmt\Use_::TYPE_UNKNOWN]; }
 ;
 
 unprefixed_use_declarations:
@@ -98,8 +101,10 @@ inline_use_declarations:
 ;
 
 unprefixed_use_declaration:
-      namespace_name                                        { $$ = Stmt\UseUse[$1, null, Stmt\Use_::TYPE_UNKNOWN]; }
-    | namespace_name T_AS T_STRING                          { $$ = Stmt\UseUse[$1, $3, Stmt\Use_::TYPE_UNKNOWN]; }
+      namespace_name
+          { $$ = Stmt\UseUse[$1, null, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #1); }
+    | namespace_name T_AS T_STRING
+          { $$ = Stmt\UseUse[$1, $3, Stmt\Use_::TYPE_UNKNOWN]; $this->checkUseUse($$, #3); }
 ;
 
 use_declaration:
@@ -175,7 +180,7 @@ non_empty_statement:
           { $$ = Stmt\Foreach_[$3, $7[0], ['keyVar' => $5, 'byRef' => $7[1], 'stmts' => $9]]; }
     | T_DECLARE '(' declare_list ')' declare_statement      { $$ = Stmt\Declare_[$3, $5]; }
     | T_TRY '{' inner_statement_list '}' catches optional_finally
-          { $$ = Stmt\TryCatch[$3, $5, $6]; }
+          { $$ = Stmt\TryCatch[$3, $5, $6]; $this->checkTryCatch($$); }
     | T_THROW expr ';'                                      { $$ = Stmt\Throw_[$2]; }
     | T_GOTO T_STRING ';'                                   { $$ = Stmt\Goto_[$2]; }
     | T_STRING ':'                                          { $$ = Stmt\Label[$1]; }
@@ -195,14 +200,19 @@ catches:
     | catches catch                                         { push($1, $2); }
 ;
 
+name_union:
+      name                                                  { init($1); }
+    | name_union '|' name                                   { push($1, $3); }
+;
+
 catch:
-    T_CATCH '(' name T_VARIABLE ')' '{' inner_statement_list '}'
+    T_CATCH '(' name_union T_VARIABLE ')' '{' inner_statement_list '}'
         { $$ = Stmt\Catch_[$3, parseVar($4), $7]; }
 ;
 
 optional_finally:
       /* empty */                                           { $$ = null; }
-    | T_FINALLY '{' inner_statement_list '}'                { $$ = $3; }
+    | T_FINALLY '{' inner_statement_list '}'                { $$ = Stmt\Finally_[$3]; }
 ;
 
 variables_list:
@@ -227,11 +237,13 @@ function_declaration_statement:
 
 class_declaration_statement:
       class_entry_type T_STRING extends_from implements_list '{' class_statement_list '}'
-          { $$ = Stmt\Class_[$2, ['type' => $1, 'extends' => $3, 'implements' => $4, 'stmts' => $6]]; }
+          { $$ = Stmt\Class_[$2, ['type' => $1, 'extends' => $3, 'implements' => $4, 'stmts' => $6]];
+            $this->checkClass($$, #2); }
     | T_INTERFACE T_STRING interface_extends_list '{' class_statement_list '}'
-          { $$ = Stmt\Interface_[$2, ['extends' => $3, 'stmts' => $5]]; }
+          { $$ = Stmt\Interface_[$2, ['extends' => $3, 'stmts' => $5]];
+            $this->checkInterface($$, #2); }
     | T_TRAIT T_STRING '{' class_statement_list '}'
-          { $$ = Stmt\Trait_[$2, $4]; }
+          { $$ = Stmt\Trait_[$2, ['stmts' => $4]]; }
 ;
 
 class_entry_type:
@@ -344,6 +356,7 @@ foreach_variable:
       variable                                              { $$ = array($1, false); }
     | '&' variable                                          { $$ = array($2, true); }
     | list_expr                                             { $$ = array($1, false); }
+    | array_short_syntax                                    { $$ = array($1, false); }
 ;
 
 parameter_list:
@@ -358,25 +371,30 @@ non_empty_parameter_list:
 
 parameter:
       optional_param_type optional_ref optional_ellipsis T_VARIABLE
-          { $$ = Node\Param[parseVar($4), null, $1, $2, $3]; }
+          { $$ = Node\Param[parseVar($4), null, $1, $2, $3]; $this->checkParam($$); }
     | optional_param_type optional_ref optional_ellipsis T_VARIABLE '=' expr
-          { $$ = Node\Param[parseVar($4), $6, $1, $2, $3]; }
+          { $$ = Node\Param[parseVar($4), $6, $1, $2, $3]; $this->checkParam($$); }
+;
+
+type_expr:
+      type                                                  { $$ = $1; }
+    | '?' type                                              { $$ = Node\NullableType[$2]; }
 ;
 
 type:
-      name                                                  { $$ = $this->handleScalarTypes($1); }
+      name                                                  { $$ = $this->handleBuiltinTypes($1); }
     | T_ARRAY                                               { $$ = 'array'; }
     | T_CALLABLE                                            { $$ = 'callable'; }
 ;
 
 optional_param_type:
       /* empty */                                           { $$ = null; }
-    | type                                                  { $$ = $1; }
+    | type_expr                                             { $$ = $1; }
 ;
 
 optional_return_type:
       /* empty */                                           { $$ = null; }
-    | ':' type                                              { $$ = $2; }
+    | ':' type_expr                                         { $$ = $2; }
 ;
 
 argument_list:
@@ -420,10 +438,13 @@ class_statement_list:
 ;
 
 class_statement:
-      variable_modifiers property_declaration_list ';'      { $$ = Stmt\Property[$1, $2]; }
-    | T_CONST class_const_list ';'                          { $$ = Stmt\ClassConst[$2]; }
+      variable_modifiers property_declaration_list ';'
+          { $$ = Stmt\Property[$1, $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 '(' parameter_list ')' optional_return_type method_body
-          { $$ = Stmt\ClassMethod[$4, ['type' => $1, 'byRef' => $3, 'params' => $6, 'returnType' => $8, 'stmts' => $9]]; }
+          { $$ = Stmt\ClassMethod[$4, ['type' => $1, 'byRef' => $3, 'params' => $6, 'returnType' => $8, 'stmts' => $9]];
+            $this->checkClassMethod($$, #1); }
     | T_USE name_list trait_adaptations                     { $$ = Stmt\TraitUse[$2, $3]; }
 ;
 
@@ -475,7 +496,7 @@ method_modifiers:
 
 non_empty_member_modifiers:
       member_modifier                                       { $$ = $1; }
-    | non_empty_member_modifiers member_modifier            { Stmt\Class_::verifyModifier($1, $2); $$ = $1 | $2; }
+    | non_empty_member_modifiers member_modifier            { $this->checkModifier($1, $2, #2); $$ = $1 | $2; }
 ;
 
 member_modifier:
@@ -510,6 +531,7 @@ for_expr:
 expr:
       variable                                              { $$ = $1; }
     | list_expr '=' expr                                    { $$ = Expr\Assign[$1, $3]; }
+    | array_short_syntax '=' expr                           { $$ = Expr\Assign[$1, $3]; }
     | variable '=' expr                                     { $$ = Expr\Assign[$1, $3]; }
     | variable '=' '&' variable                             { $$ = Expr\AssignRef[$1, $4]; }
     | new_expr                                              { $$ = $1; }
@@ -601,7 +623,8 @@ expr:
 
 anonymous_class:
       T_CLASS ctor_arguments extends_from implements_list '{' class_statement_list '}'
-          { $$ = array(Stmt\Class_[null, ['type' => 0, 'extends' => $3, 'implements' => $4, 'stmts' => $6]], $2); }
+          { $$ = array(Stmt\Class_[null, ['type' => 0, 'extends' => $3, 'implements' => $4, 'stmts' => $6]], $2);
+            $this->checkClass($$[0], -1); }
 
 new_expr:
       T_NEW class_name_reference ctor_arguments             { $$ = Expr\New_[$2, $3]; }
@@ -644,6 +667,7 @@ name:
 class_name_reference:
       class_name                                            { $$ = $1; }
     | new_variable                                          { $$ = $1; }
+    | error                                                 { $$ = Expr\Error[]; $this->errorState = 2; }
 ;
 
 class_name_or_var:
@@ -672,22 +696,30 @@ constant:
       name                                                  { $$ = Expr\ConstFetch[$1]; }
     | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM identifier
           { $$ = Expr\ClassConstFetch[$1, $3]; }
+    /* We interpret and 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, Expr\Error[]]; $this->errorState = 2; }
+;
+
+array_short_syntax:
+      '[' array_pair_list ']'
+          { $attrs = attributes(); $attrs['kind'] = Expr\Array_::KIND_SHORT;
+            $$ = new Expr\Array_($2, $attrs); }
 ;
 
 dereferencable_scalar:
       T_ARRAY '(' array_pair_list ')'
           { $attrs = attributes(); $attrs['kind'] = Expr\Array_::KIND_LONG;
             $$ = new Expr\Array_($3, $attrs); }
-    | '[' array_pair_list ']'
-          { $attrs = attributes(); $attrs['kind'] = Expr\Array_::KIND_SHORT;
-            $$ = new Expr\Array_($2, $attrs); }
+    | array_short_syntax                                    { $$ = $1; }
     | T_CONSTANT_ENCAPSED_STRING
           { $attrs = attributes(); $attrs['kind'] = strKind($1);
             $$ = new Scalar\String_(Scalar\String_::parse($1), $attrs); }
 ;
 
 scalar:
-      T_LNUMBER                                             { $$ = Scalar\LNumber::fromString($1, attributes()); }
+      T_LNUMBER                                             { $$ = $this->parseLNumber($1, attributes()); }
     | T_DNUMBER                                             { $$ = Scalar\DNumber[Scalar\DNumber::parse($1)]; }
     | T_LINE                                                { $$ = Scalar\MagicConst\Line[]; }
     | T_FILE                                                { $$ = Scalar\MagicConst\File[]; }
@@ -713,11 +745,6 @@ scalar:
             parseEncapsedDoc($2, true); $$ = new Scalar\Encapsed($2, $attrs); }
 ;
 
-optional_comma:
-      /* empty */
-    | ','
-;
-
 optional_expr:
       /* empty */                                           { $$ = null; }
     | expr                                                  { $$ = $1; }
@@ -755,6 +782,7 @@ simple_variable:
       T_VARIABLE                                            { $$ = parseVar($1); }
     | '$' '{' expr '}'                                      { $$ = $3; }
     | '$' simple_variable                                   { $$ = Expr\Variable[$2]; }
+    | '$' error                                             { $$ = Expr\Error[]; $this->errorState = 2; }
 ;
 
 static_member:
@@ -781,6 +809,7 @@ property_name:
       T_STRING                                              { $$ = $1; }
     | '{' expr '}'	                                        { $$ = $2; }
     | simple_variable	                                    { $$ = Expr\Variable[$1]; }
+    | error                                                 { $$ = Expr\Error[]; $this->errorState = 2; }
 ;
 
 list_expr:
@@ -793,18 +822,20 @@ list_expr_elements:
 ;
 
 list_expr_element:
-      variable                                              { $$ = $1; }
-    | list_expr                                             { $$ = $1; }
+      variable                                              { $$ = Expr\ArrayItem[$1, null, false]; }
+    | list_expr                                             { $$ = Expr\ArrayItem[$1, null, false]; }
+    | expr T_DOUBLE_ARROW variable                          { $$ = Expr\ArrayItem[$3, $1, false]; }
+    | expr T_DOUBLE_ARROW list_expr                         { $$ = Expr\ArrayItem[$3, $1, false]; }
     | /* empty */                                           { $$ = null; }
 ;
 
 array_pair_list:
-      /* empty */                                           { $$ = array(); }
-    | non_empty_array_pair_list optional_comma              { $$ = $1; }
+      inner_array_pair_list
+          { $$ = $1; $end = count($$)-1; if ($$[$end] === null) unset($$[$end]); }
 ;
 
-non_empty_array_pair_list:
-      non_empty_array_pair_list ',' array_pair              { push($1, $3); }
+inner_array_pair_list:
+      inner_array_pair_list ',' array_pair                  { push($1, $3); }
     | array_pair                                            { init($1); }
 ;
 
@@ -813,6 +844,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]; }
+    | /* empty */                                           { $$ = null; }
 ;
 
 encaps_list:
@@ -826,10 +858,14 @@ encaps_string_part:
       T_ENCAPSED_AND_WHITESPACE                             { $$ = Scalar\EncapsedStringPart[$1]; }
 ;
 
-encaps_var:
+encaps_base_var:
       T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
-    | T_VARIABLE '[' encaps_var_offset ']'                  { $$ = Expr\ArrayDimFetch[Expr\Variable[parseVar($1)], $3]; }
-    | T_VARIABLE T_OBJECT_OPERATOR T_STRING                 { $$ = Expr\PropertyFetch[Expr\Variable[parseVar($1)], $3]; }
+;
+
+encaps_var:
+      encaps_base_var                                       { $$ = $1; }
+    | encaps_base_var '[' encaps_var_offset ']'             { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | encaps_base_var T_OBJECT_OPERATOR T_STRING            { $$ = Expr\PropertyFetch[$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 T_STRING_VARNAME '[' expr ']' '}'
@@ -839,7 +875,8 @@ encaps_var:
 
 encaps_var_offset:
       T_STRING                                              { $$ = Scalar\String_[$1]; }
-    | T_NUM_STRING                                          { $$ = Scalar\String_[$1]; }
+    | T_NUM_STRING                                          { $$ = $this->parseNumString($1, attributes()); }
+    | '-' T_NUM_STRING                                      { $$ = $this->parseNumString('-' . $2, attributes()); }
     | T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
 ;
 

grammar/rebuildParsers.php

@@ -124,6 +124,12 @@ function resolveMacros($code) {
                 return '$this->startAttributeStack[#1] + $this->endAttributes';
             }
 
+            if ('stackAttributes' == $name) {
+                assertArgs(1, $args, $name);
+                return '$this->startAttributeStack[' . $args[0] . ']'
+                     . ' + $this->endAttributeStack[' . $args[0] . ']';
+            }
+
             if ('init' == $name) {
                 return '$$ = array(' . implode(', ', $args) . ')';
             }

lib/PhpParser/Builder/Class_.php

@@ -12,7 +12,7 @@ class Class_ extends Declaration
 
     protected $extends = null;
     protected $implements = array();
-    protected $type = 0;
+    protected $flags = 0;
 
     protected $uses = array();
     protected $constants = array();
@@ -112,7 +112,7 @@ class Class_ extends Declaration
      */
     public function getNode() {
         return new Stmt\Class_($this->name, array(
-            'type' => $this->type,
+            'flags' => $this->flags,
             'extends' => $this->extends,
             'implements' => $this->implements,
             'stmts' => array_merge($this->uses, $this->constants, $this->properties, $this->methods),

lib/PhpParser/Builder/Declaration.php

@@ -3,8 +3,6 @@
 namespace PhpParser\Builder;
 
 use PhpParser;
-use PhpParser\Node;
-use PhpParser\Node\Stmt;
 
 abstract class Declaration extends PhpParser\BuilderAbstract
 {

lib/PhpParser/Builder/FunctionLike.php

@@ -4,12 +4,13 @@ namespace PhpParser\Builder;
 
 use PhpParser;
 use PhpParser\Node;
-use PhpParser\Node\Stmt;
 
 abstract class FunctionLike extends Declaration
 {
     protected $returnByRef = false;
     protected $params = array();
+
+    /** @var string|Node\Name|Node\NullableType|null */
     protected $returnType = null;
 
     /**
@@ -60,18 +61,14 @@ abstract class FunctionLike extends Declaration
     /**
      * Sets the return type for PHP 7.
      *
-     * @param string|Node\Name $type One of array, callable, string, int, float, bool,
+     * @param string|Node\Name|Node\NullableType $type One of array, callable, string, int, float, bool, iterable,
      *                               or a class/interface name.
      *
      * @return $this The builder instance (for fluid interface)
      */
     public function setReturnType($type)
     {
-        if (in_array($type, array('array', 'callable', 'string', 'int', 'float', 'bool'))) {
-            $this->returnType = $type;
-        } else {
-            $this->returnType = $this->normalizeName($type);
-        }
+        $this->returnType = $this->normalizeType($type);
 
         return $this;
     }

lib/PhpParser/Builder/Method.php

@@ -9,7 +9,9 @@ use PhpParser\Node\Stmt;
 class Method extends FunctionLike
 {
     protected $name;
-    protected $type = 0;
+    protected $flags = 0;
+
+    /** @var array|null */
     protected $stmts = array();
 
     /**
@@ -116,7 +118,7 @@ class Method extends FunctionLike
      */
     public function getNode() {
         return new Stmt\ClassMethod($this->name, array(
-            'type'       => $this->type,
+            'flags'      => $this->flags,
             'byRef'      => $this->returnByRef,
             'params'     => $this->params,
             'returnType' => $this->returnType,

lib/PhpParser/Builder/Param.php

@@ -10,7 +10,10 @@ class Param extends PhpParser\BuilderAbstract
     protected $name;
 
     protected $default = null;
+
+    /** @var string|Node\Name|Node\NullableType|null */
     protected $type = null;
+
     protected $byRef = false;
 
     /**
@@ -38,15 +41,14 @@ class Param extends PhpParser\BuilderAbstract
     /**
      * Sets type hint for the parameter.
      *
-     * @param string|Node\Name $type Type hint to use
+     * @param string|Node\Name|Node\NullableType $type Type hint to use
      *
      * @return $this The builder instance (for fluid interface)
      */
     public function setTypeHint($type) {
-        if (in_array($type, array('array', 'callable', 'string', 'int', 'float', 'bool'))) {
-            $this->type = $type;
-        } else {
-            $this->type = $this->normalizeName($type);
+        $this->type = $this->normalizeType($type);
+        if ($this->type === 'void') {
+            throw new \LogicException('Parameter type cannot be void');
         }
 
         return $this;

lib/PhpParser/Builder/Property.php

@@ -9,7 +9,7 @@ class Property extends PhpParser\BuilderAbstract
 {
     protected $name;
 
-    protected $type = 0;
+    protected $flags = 0;
     protected $default = null;
     protected $attributes = array();
 
@@ -101,7 +101,7 @@ class Property extends PhpParser\BuilderAbstract
      */
     public function getNode() {
         return new Stmt\Property(
-            $this->type !== 0 ? $this->type : Stmt\Class_::MODIFIER_PUBLIC,
+            $this->flags !== 0 ? $this->flags : Stmt\Class_::MODIFIER_PUBLIC,
             array(
                 new Stmt\PropertyProperty($this->name, $this->default)
             ),

lib/PhpParser/Builder/Trait_.php

@@ -3,7 +3,6 @@
 namespace PhpParser\Builder;
 
 use PhpParser;
-use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
 
 class Trait_ extends Declaration
@@ -49,7 +48,9 @@ class Trait_ extends Declaration
      */
     public function getNode() {
         return new Stmt\Trait_(
-            $this->name, array_merge($this->properties, $this->methods), $this->attributes
+            $this->name, array(
+                'stmts' => array_merge($this->properties, $this->methods)
+            ), $this->attributes
         );
     }
 }

lib/PhpParser/BuilderAbstract.php

@@ -2,11 +2,12 @@
 
 namespace PhpParser;
 
-use PhpParser\Node\Name;
-use PhpParser\Node\Expr;
-use PhpParser\Node\Stmt;
-use PhpParser\Node\Scalar;
 use PhpParser\Comment;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
+use PhpParser\Node\NullableType;
+use PhpParser\Node\Scalar;
+use PhpParser\Node\Stmt;
 
 abstract class BuilderAbstract implements Builder {
     /**
@@ -53,6 +54,49 @@ abstract class BuilderAbstract implements Builder {
         throw new \LogicException('Name must be a string or an instance of PhpParser\Node\Name');
     }
 
+    /**
+     * Normalizes a type: Converts plain-text type names into proper AST representation.
+     *
+     * In particular, builtin types are left as strings, custom types become Names and nullables
+     * are wrapped in NullableType nodes.
+     *
+     * @param Name|string|NullableType $type The type to normalize
+     *
+     * @return Name|string|NullableType The normalized type
+     */
+    protected function normalizeType($type) {
+        if (!is_string($type)) {
+            if (!$type instanceof Name && !$type instanceof NullableType) {
+                throw new \LogicException(
+                    'Type must be a string, or an instance of Name or NullableType');
+            }
+            return $type;
+        }
+
+        $nullable = false;
+        if (strlen($type) > 0 && $type[0] === '?') {
+            $nullable = true;
+            $type = substr($type, 1);
+        }
+
+        $builtinTypes = array(
+            'array', 'callable', 'string', 'int', 'float', 'bool', 'iterable', 'void'
+        );
+
+        $lowerType = strtolower($type);
+        if (in_array($lowerType, $builtinTypes)) {
+            $type = $lowerType;
+        } else {
+            $type = $this->normalizeName($type);
+        }
+
+        if ($nullable && $type === 'void') {
+            throw new \LogicException('void type cannot be nullable');
+        }
+
+        return $nullable ? new Node\NullableType($type) : $type;
+    }
+
     /**
      * Normalizes a value: Converts nulls, booleans, integers,
      * floats, strings and arrays into their respective nodes
@@ -125,7 +169,7 @@ abstract class BuilderAbstract implements Builder {
      * @param int $modifier Modifier to set
      */
     protected function setModifier($modifier) {
-        Stmt\Class_::verifyModifier($this->type, $modifier);
-        $this->type |= $modifier;
+        Stmt\Class_::verifyModifier($this->flags, $modifier);
+        $this->flags |= $modifier;
     }
 }

lib/PhpParser/Comment.php

@@ -2,7 +2,7 @@
 
 namespace PhpParser;
 
-class Comment
+class Comment implements \JsonSerializable
 {
     protected $text;
     protected $line;
@@ -30,17 +30,6 @@ class Comment
         return $this->text;
     }
 
-    /**
-     * Sets the comment text.
-     *
-     * @param string $text The comment text (including comment delimiters like /*)
-     *
-     * @deprecated Construct a new comment instead
-     */
-    public function setText($text) {
-        $this->text = $text;
-    }
-
     /**
      * Gets the line number the comment started on.
      *
@@ -50,17 +39,6 @@ class Comment
         return $this->line;
     }
 
-    /**
-     * Sets the line number the comment started on.
-     *
-     * @param int $line Line number
-     *
-     * @deprecated Construct a new comment instead
-     */
-    public function setLine($line) {
-        $this->line = $line;
-    }
-
     /**
      * Gets the file offset the comment started on.
      *
@@ -148,4 +126,15 @@ class Comment
         }
         return $shortestPrefixLen;
     }
+
+    public function jsonSerialize() {
+        // Technically not a node, but we make it look like one anyway
+        $type = $this instanceof Comment\Doc ? 'Comment_Doc' : 'Comment';
+        return [
+            'nodeType' => $type,
+            'text' => $this->text,
+            'line' => $this->line,
+            'filePos' => $this->filePos,
+        ];
+    }
 }

lib/PhpParser/Error.php

@@ -61,6 +61,16 @@ class Error extends \RuntimeException
         return $this->attributes;
     }
 
+    /**
+     * Sets the attributes of the node/token the error occured at.
+     *
+     * @param array $attributes
+     */
+    public function setAttributes(array $attributes) {
+        $this->attributes = $attributes;
+        $this->updateMessage();
+    }
+
     /**
      * Sets the line of the PHP file the error occurred in.
      *
@@ -120,6 +130,14 @@ class Error extends \RuntimeException
         return $this->toColumn($code, $this->attributes['endFilePos']);
     }
 
+    public function getMessageWithColumnInfo($code) {
+        return sprintf(
+            '%s from %d:%d to %d:%d', $this->getRawMessage(),
+            $this->getStartLine(), $this->getStartColumn($code),
+            $this->getEndLine(), $this->getEndColumn($code)
+        );
+    }
+
     private function toColumn($code, $pos) {
         if ($pos > strlen($code)) {
             throw new \RuntimeException('Invalid position information');
@@ -145,14 +163,4 @@ class Error extends \RuntimeException
             $this->message .= ' on line ' . $this->getStartLine();
         }
     }
-
-    /** @deprecated Use getStartLine() instead */
-    public function getRawLine() {
-        return $this->getStartLine();
-    }
-
-    /** @deprecated Use setStartLine() instead */
-    public function setRawLine($line) {
-        $this->setStartLine($line);
-    }
 }

lib/PhpParser/ErrorHandler.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace PhpParser;
+
+interface ErrorHandler
+{
+    /**
+     * Handle an error generated during lexing, parsing or some other operation.
+     *
+     * @param Error $error The error that needs to be handled
+     */
+    public function handleError(Error $error);
+}

lib/PhpParser/ErrorHandler/Collecting.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace PhpParser\ErrorHandler;
+
+use PhpParser\Error;
+use PhpParser\ErrorHandler;
+
+/**
+ * Error handler that collects all errors into an array.
+ *
+ * This allows graceful handling of errors.
+ */
+class Collecting implements ErrorHandler
+{
+    /** @var Error[] Collected errors */
+    private $errors = [];
+
+    public function handleError(Error $error) {
+        $this->errors[] = $error;
+    }
+
+    /**
+     * Get collected errors.
+     *
+     * @return Error[]
+     */
+    public function getErrors() {
+        return $this->errors;
+    }
+
+    /**
+     * Check whether there are any errors.
+     *
+     * @return bool
+     */
+    public function hasErrors() {
+        return !empty($this->errors);
+    }
+
+    /**
+     * Reset/clear collected errors.
+     */
+    public function clearErrors() {
+        $this->errors = [];
+    }
+}

lib/PhpParser/ErrorHandler/Throwing.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace PhpParser\ErrorHandler;
+
+use PhpParser\Error;
+use PhpParser\ErrorHandler;
+
+/**
+ * Error handler that handles all errors by throwing them.
+ *
+ * This is the default strategy used by all components.
+ */
+class Throwing implements ErrorHandler
+{
+    public function handleError(Error $error) {
+        throw $error;
+    }
+}

lib/PhpParser/Lexer.php

@@ -2,7 +2,6 @@
 
 namespace PhpParser;
 
-use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Parser\Tokens;
 
 class Lexer
@@ -12,6 +11,7 @@ class Lexer
     protected $pos;
     protected $line;
     protected $filePos;
+    protected $prevCloseTagHasNewline;
 
     protected $tokenMap;
     protected $dropTokens;
@@ -48,25 +48,36 @@ class Lexer
     /**
      * Initializes the lexer for lexing the provided source code.
      *
-     * @param string $code The source code to lex
+     * This function does not throw if lexing errors occur. Instead, errors may be retrieved using
+     * the getErrors() method.
      *
-     * @throws Error on lexing errors (unterminated comment or unexpected character)
+     * @param string $code The source code to lex
+     * @param ErrorHandler|null $errorHandler Error handler to use for lexing errors. Defaults to
+     *                                        ErrorHandler\Throwing
      */
-    public function startLexing($code) {
-        $scream = ini_set('xdebug.scream', '0');
-
-        $this->resetErrors();
-        $this->tokens = @token_get_all($code);
-        $this->handleErrors();
-
-        if (false !== $scream) {
-            ini_set('xdebug.scream', $scream);
+    public function startLexing($code, ErrorHandler $errorHandler = null) {
+        if (null === $errorHandler) {
+            $errorHandler = new ErrorHandler\Throwing();
         }
 
         $this->code = $code; // keep the code around for __halt_compiler() handling
         $this->pos  = -1;
         $this->line =  1;
         $this->filePos = 0;
+
+        // If inline HTML occurs without preceding code, treat it as if it had a leading newline.
+        // This ensures proper composability, because having a newline is the "safe" assumption.
+        $this->prevCloseTagHasNewline = true;
+
+        $scream = ini_set('xdebug.scream', '0');
+
+        $this->resetErrors();
+        $this->tokens = @token_get_all($code);
+        $this->handleErrors($errorHandler);
+
+        if (false !== $scream) {
+            ini_set('xdebug.scream', $scream);
+        }
     }
 
     protected function resetErrors() {
@@ -80,32 +91,109 @@ class Lexer
         }
     }
 
-    protected function handleErrors() {
+    private function handleInvalidCharacterRange($start, $end, $line, ErrorHandler $errorHandler) {
+        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';
+            } else {
+                $errorMsg = sprintf(
+                    'Unexpected character "%s" (ASCII %d)', $chr, ord($chr)
+                );
+            }
+
+            $errorHandler->handleError(new Error($errorMsg, [
+                'startLine' => $line,
+                'endLine' => $line,
+                'startFilePos' => $i,
+                'endFilePos' => $i,
+            ]));
+        }
+    }
+
+    private function isUnterminatedComment($token) {
+        return ($token[0] === T_COMMENT || $token[0] === T_DOC_COMMENT)
+            && substr($token[1], 0, 2) === '/*'
+            && substr($token[1], -2) !== '*/';
+    }
+
+    private function errorMayHaveOccurred() {
+        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;
+        }
+
         $error = error_get_last();
-        if (null === $error) {
+        return null !== $error
+            && false === strpos($error['message'], 'Undefined variable');
+    }
+
+    protected function handleErrors(ErrorHandler $errorHandler) {
+        if (!$this->errorMayHaveOccurred()) {
             return;
         }
 
-        if (preg_match(
-            '~^Unterminated comment starting line ([0-9]+)$~',
-            $error['message'], $matches
-        )) {
-            throw new Error('Unterminated comment', (int) $matches[1]);
+        // 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.
+
+        $filePos = 0;
+        $line = 1;
+        foreach ($this->tokens as $i => $token) {
+            $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(
+                    $filePos, $nextFilePos, $line, $errorHandler);
+                $filePos = $nextFilePos;
+            }
+
+            $filePos += $tokenLen;
+            $line += substr_count($tokenValue, "\n");
         }
 
-        if (preg_match(
-            '~^Unexpected character in input:  \'(.)\' \(ASCII=([0-9]+)\)~s',
-            $error['message'], $matches
-        )) {
-            throw new Error(sprintf(
-                'Unexpected character "%s" (ASCII %d)',
-                $matches[1], $matches[2]
-            ));
+        if ($filePos !== \strlen($this->code)) {
+            if (substr($this->code, $filePos, 2) === '/*') {
+                // Unlike PHP, HHVM will drop unterminated comments entirely
+                $comment = substr($this->code, $filePos);
+                $errorHandler->handleError(new Error('Unterminated comment', [
+                    'startLine' => $line,
+                    'endLine' => $line + substr_count($comment, "\n"),
+                    'startFilePos' => $filePos,
+                    'endFilePos' => $filePos + \strlen($comment),
+                ]));
+
+                // Emulate the PHP behavior
+                $isDocComment = isset($comment[3]) && $comment[3] === '*';
+                $this->tokens[] = [$isDocComment ? T_DOC_COMMENT : T_COMMENT, $comment, $line];
+            } else {
+                // Invalid characters at the end of the input
+                $this->handleInvalidCharacterRange(
+                    $filePos, \strlen($this->code), $line, $errorHandler);
+            }
+            return;
         }
 
-        // PHP cuts error message after null byte, so need special case
-        if (preg_match('~^Unexpected character in input:  \'$~', $error['message'])) {
-            throw new Error('Unexpected null byte');
+        // Check for unterminated comment
+        $lastToken = $this->tokens[count($this->tokens) - 1];
+        if ($this->isUnterminatedComment($lastToken)) {
+            $errorHandler->handleError(new Error('Unterminated comment', [
+                'startLine' => $line - substr_count($lastToken[1], "\n"),
+                'endLine' => $line,
+                'startFilePos' => $filePos - \strlen($lastToken[1]),
+                'endFilePos' => $filePos,
+            ]));
         }
     }
 
@@ -166,6 +254,11 @@ class Lexer
             } elseif (!isset($this->dropTokens[$token[0]])) {
                 $value = $token[1];
                 $id = $this->tokenMap[$token[0]];
+                if (T_CLOSE_TAG === $token[0]) {
+                    $this->prevCloseTagHasNewline = false !== strpos($token[1], "\n");
+                } else if (T_INLINE_HTML === $token[0]) {
+                    $startAttributes['hasLeadingNewline'] = $this->prevCloseTagHasNewline;
+                }
 
                 $this->line += substr_count($value, "\n");
                 $this->filePos += \strlen($value);

lib/PhpParser/Lexer/Emulative.php

@@ -2,11 +2,9 @@
 
 namespace PhpParser\Lexer;
 
+use PhpParser\ErrorHandler;
 use PhpParser\Parser\Tokens;
 
-/**
- * ATTENTION: This code is WRITE-ONLY. Do not try to read it.
- */
 class Emulative extends \PhpParser\Lexer
 {
     protected $newKeywords;
@@ -21,16 +19,12 @@ class Emulative extends \PhpParser\Lexer
 
     const PHP_7_0 = '7.0.0dev';
     const PHP_5_6 = '5.6.0rc1';
-    const PHP_5_5 = '5.5.0beta1';
 
     public function __construct(array $options = array()) {
         parent::__construct($options);
 
         $newKeywordsPerVersion = array(
-            self::PHP_5_5 => array(
-                'finally'       => Tokens::T_FINALLY,
-                'yield'         => Tokens::T_YIELD,
-            ),
+            // No new keywords since PHP 5.5
         );
 
         $this->newKeywords = array();
@@ -57,131 +51,106 @@ class Emulative extends \PhpParser\Lexer
         $this->tokenMap[self::T_POW_EQUAL] = Tokens::T_POW_EQUAL;
     }
 
-    public function startLexing($code) {
+    public function startLexing($code, ErrorHandler $errorHandler = null) {
         $this->inObjectAccess = false;
 
-        $preprocessedCode = $this->preprocessCode($code);
-        parent::startLexing($preprocessedCode);
-        if ($preprocessedCode !== $code) {
-            $this->postprocessTokens();
+        parent::startLexing($code, $errorHandler);
+        if ($this->requiresEmulation($code)) {
+            $this->emulateTokens();
         }
-
-        // Set code property back to the original code, so __halt_compiler()
-        // handling and (start|end)FilePos attributes use the correct offsets
-        $this->code = $code;
     }
 
     /*
-     * Replaces new features in the code by ~__EMU__{NAME}__{DATA}__~ sequences.
-     * ~LABEL~ is never valid PHP code, that's why we can (to some degree) safely
-     * use it here.
-     * Later when preprocessing the tokens these sequences will either be replaced
-     * by real tokens or replaced with their original content (e.g. if they occurred
-     * inside a string, i.e. a place where they don't have a special meaning).
+     * Checks if the code is potentially using features that require emulation.
      */
-    protected function preprocessCode($code) {
+    protected function requiresEmulation($code) {
         if (version_compare(PHP_VERSION, self::PHP_7_0, '>=')) {
-            return $code;
+            return false;
         }
 
-        $code = str_replace('??', '~__EMU__COALESCE__~', $code);
-        $code = str_replace('<=>', '~__EMU__SPACESHIP__~', $code);
-        $code = preg_replace_callback('(yield[ \n\r\t]+from)', function($matches) {
-            // Encoding $0 in order to preserve exact whitespace
-            return '~__EMU__YIELDFROM__' . bin2hex($matches[0]) . '__~';
-        }, $code);
+        if (preg_match('(\?\?|<=>|yield[ \n\r\t]+from)', $code)) {
+            return true;
+        }
 
         if (version_compare(PHP_VERSION, self::PHP_5_6, '>=')) {
-            return $code;
+            return false;
         }
 
-        $code = str_replace('...', '~__EMU__ELLIPSIS__~', $code);
-        $code = preg_replace('((?<!/)\*\*=)', '~__EMU__POWEQUAL__~', $code);
-        $code = preg_replace('((?<!/)\*\*(?!/))', '~__EMU__POW__~', $code);
-
-        return $code;
+        return preg_match('(\.\.\.|(?<!/)\*\*(?!/))', $code);
     }
 
     /*
-     * Replaces the ~__EMU__...~ sequences with real tokens or their original
-     * value.
+     * Emulates tokens for newer PHP versions.
      */
-    protected function postprocessTokens() {
-        // we need to manually iterate and manage a count because we'll change
+    protected function emulateTokens() {
+        // 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($this->tokens); $i < $c; ++$i) {
-            // first check that the following tokens are of form ~LABEL~,
-            // then match the __EMU__... sequence.
-            if ('~' === $this->tokens[$i]
-                && isset($this->tokens[$i + 2])
-                && '~' === $this->tokens[$i + 2]
-                && T_STRING === $this->tokens[$i + 1][0]
-                && preg_match('(^__EMU__([A-Z]++)__(?:([A-Za-z0-9]++)__)?$)', $this->tokens[$i + 1][1], $matches)
-            ) {
-                if ('ELLIPSIS' === $matches[1]) {
-                    $replace = array(
-                        array(self::T_ELLIPSIS, '...', $this->tokens[$i + 1][2])
-                    );
-                } else if ('POW' === $matches[1]) {
-                    $replace = array(
-                        array(self::T_POW, '**', $this->tokens[$i + 1][2])
-                    );
-                } else if ('POWEQUAL' === $matches[1]) {
-                    $replace = array(
-                        array(self::T_POW_EQUAL, '**=', $this->tokens[$i + 1][2])
-                    );
-                } else if ('COALESCE' === $matches[1]) {
-                    $replace = array(
-                        array(self::T_COALESCE, '??', $this->tokens[$i + 1][2])
-                    );
-                } else if ('SPACESHIP' === $matches[1]) {
-                    $replace = array(
-                        array(self::T_SPACESHIP, '<=>', $this->tokens[$i + 1][2]),
-                    );
-                } else if ('YIELDFROM' === $matches[1]) {
-                    $content = hex2bin($matches[2]);
-                    $replace = array(
-                        array(self::T_YIELD_FROM, $content, $this->tokens[$i + 1][2] - substr_count($content, "\n"))
-                    );
-                } else {
-                    throw new \RuntimeException('Invalid __EMU__ sequence');
+            $replace = null;
+            if (isset($this->tokens[$i + 1])) {
+                if ($this->tokens[$i] === '?' && $this->tokens[$i + 1] === '?') {
+                    array_splice($this->tokens, $i, 2, array(
+                        array(self::T_COALESCE, '??', $line)
+                    ));
+                    $c--;
+                    continue;
+                }
+                if ($this->tokens[$i][0] === T_IS_SMALLER_OR_EQUAL
+                    && $this->tokens[$i + 1] === '>'
+                ) {
+                    array_splice($this->tokens, $i, 2, array(
+                        array(self::T_SPACESHIP, '<=>', $line)
+                    ));
+                    $c--;
+                    continue;
+                }
+                if ($this->tokens[$i] === '*' && $this->tokens[$i + 1] === '*') {
+                    array_splice($this->tokens, $i, 2, array(
+                        array(self::T_POW, '**', $line)
+                    ));
+                    $c--;
+                    continue;
+                }
+                if ($this->tokens[$i] === '*' && $this->tokens[$i + 1][0] === T_MUL_EQUAL) {
+                    array_splice($this->tokens, $i, 2, array(
+                        array(self::T_POW_EQUAL, '**=', $line)
+                    ));
+                    $c--;
+                    continue;
                 }
-
-                array_splice($this->tokens, $i, 3, $replace);
-                $c -= 3 - count($replace);
-            // for multichar tokens (e.g. strings) replace any ~__EMU__...~ sequences
-            // in their content with the original character sequence
-            } elseif (is_array($this->tokens[$i])
-                      && 0 !== strpos($this->tokens[$i][1], '__EMU__')
-            ) {
-                $this->tokens[$i][1] = preg_replace_callback(
-                    '(~__EMU__([A-Z]++)__(?:([A-Za-z0-9]++)__)?~)',
-                    array($this, 'restoreContentCallback'),
-                    $this->tokens[$i][1]
-                );
             }
-        }
-    }
 
-    /*
-     * This method is a callback for restoring EMU sequences in
-     * multichar tokens (like strings) to their original value.
-     */
-    public function restoreContentCallback(array $matches) {
-        if ('ELLIPSIS' === $matches[1]) {
-            return '...';
-        } else if ('POW' === $matches[1]) {
-            return '**';
-        } else if ('POWEQUAL' === $matches[1]) {
-            return '**=';
-        } else if ('COALESCE' === $matches[1]) {
-            return '??';
-        } else if ('SPACESHIP' === $matches[1]) {
-            return '<=>';
-        } else if ('YIELDFROM' === $matches[1]) {
-            return hex2bin($matches[2]);
-        } else {
-            return $matches[0];
+            if (isset($this->tokens[$i + 2])) {
+                if ($this->tokens[$i][0] === T_YIELD && $this->tokens[$i + 1][0] === T_WHITESPACE
+                    && $this->tokens[$i + 2][0] === T_STRING
+                    && !strcasecmp($this->tokens[$i + 2][1], 'from')
+                ) {
+                    array_splice($this->tokens, $i, 3, array(
+                        array(
+                            self::T_YIELD_FROM,
+                            $this->tokens[$i][1] . $this->tokens[$i + 1][1] . $this->tokens[$i + 2][1],
+                            $line
+                        )
+                    ));
+                    $c -= 2;
+                    $line += substr_count($this->tokens[$i][1], "\n");
+                    continue;
+                }
+                if ($this->tokens[$i] === '.' && $this->tokens[$i + 1] === '.'
+                    && $this->tokens[$i + 2] === '.'
+                ) {
+                    array_splice($this->tokens, $i, 3, array(
+                        array(self::T_ELLIPSIS, '...', $line)
+                    ));
+                    $c -= 2;
+                    continue;
+                }
+            }
+
+            if (\is_array($this->tokens[$i])) {
+                $line += substr_count($this->tokens[$i][1], "\n");
+            }
         }
     }
 

lib/PhpParser/Node.php

@@ -41,6 +41,15 @@ interface Node
      */
     public function getDocComment();
 
+    /**
+     * Sets the doc comment of the node.
+     *
+     * This will either replace an existing doc comment or add it to the comments array.
+     *
+     * @param Comment\Doc $docComment Doc comment to set
+     */
+    public function setDocComment(Comment\Doc $docComment);
+
     /**
      * Sets an attribute on a node.
      *

lib/PhpParser/Node/Expr/ArrayDimFetch.php

@@ -24,7 +24,7 @@ class ArrayDimFetch extends Expr
         $this->dim = $dim;
     }
 
-    public function getSubnodeNames() {
+    public function getSubNodeNames() {
         return array('var', 'dim');
     }
 }

lib/PhpParser/Node/Expr/ClassConstFetch.php

@@ -2,22 +2,22 @@
 
 namespace PhpParser\Node\Expr;
 
-use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
 
 class ClassConstFetch extends Expr
 {
     /** @var Name|Expr Class name */
     public $class;
-    /** @var string Constant name */
+    /** @var string|Error Constant name */
     public $name;
 
     /**
      * Constructs a class const fetch node.
      *
-     * @param Name|Expr $class      Class name
-     * @param string    $name       Constant name
-     * @param array     $attributes Additional attributes
+     * @param Name|Expr    $class      Class name
+     * @param string|Error $name       Constant name
+     * @param array        $attributes Additional attributes
      */
     public function __construct($class, $name, array $attributes = array()) {
         parent::__construct($attributes);

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|string|Node\Name Return type */
+    /** @var null|string|Node\Name|Node\NullableType Return type */
     public $returnType;
     /** @var Node[] Statements */
     public $stmts;

lib/PhpParser/Node/Expr/ConstFetch.php

@@ -2,8 +2,8 @@
 
 namespace PhpParser\Node\Expr;
 
-use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
 
 class ConstFetch extends Expr
 {

lib/PhpParser/Node/Expr/Error.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node\Expr;
+
+/**
+ * Error node used during parsing with error recovery.
+ *
+ * An error node may be placed at a position where an expression is required, but an error occurred.
+ * Error nodes will not be present if the parser is run in throwOnError mode (the default).
+ */
+class Error extends Expr
+{
+    /**
+     * Constructs an error node.
+     *
+     * @param array $attributes Additional attributes
+     */
+    public function __construct(array $attributes = array()) {
+        parent::__construct($attributes);
+    }
+
+    public function getSubNodeNames() {
+        return array();
+    }
+}

lib/PhpParser/Node/Expr/Instanceof_.php

@@ -2,8 +2,8 @@
 
 namespace PhpParser\Node\Expr;
 
-use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
 
 class Instanceof_ extends Expr
 {

lib/PhpParser/Node/Expr/List_.php

@@ -6,21 +6,21 @@ use PhpParser\Node\Expr;
 
 class List_ extends Expr
 {
-    /** @var Expr[] List of variables to assign to */
-    public $vars;
+    /** @var ArrayItem[] List of items to assign to */
+    public $items;
 
     /**
      * Constructs a list() destructuring node.
      *
-     * @param Expr[] $vars       List of variables to assign to
-     * @param array  $attributes Additional attributes
+     * @param ArrayItem[] $items      List of items to assign to
+     * @param array       $attributes Additional attributes
      */
-    public function __construct(array $vars, array $attributes = array()) {
+    public function __construct(array $items, array $attributes = array()) {
         parent::__construct($attributes);
-        $this->vars = $vars;
+        $this->items = $items;
     }
 
     public function getSubNodeNames() {
-        return array('vars');
+        return array('items');
     }
 }

lib/PhpParser/Node/Expr/StaticPropertyFetch.php

@@ -2,8 +2,8 @@
 
 namespace PhpParser\Node\Expr;
 
-use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
 
 class StaticPropertyFetch extends Expr
 {

lib/PhpParser/Node/FunctionLike.php

@@ -23,7 +23,7 @@ interface FunctionLike extends Node
     /**
      * Get the declared return type or null
      * 
-     * @return null|string|Node\Name
+     * @return null|string|Node\Name|Node\NullableType
      */
     public function getReturnType();
 

lib/PhpParser/Node/Name.php

@@ -6,22 +6,21 @@ use PhpParser\NodeAbstract;
 
 class Name extends NodeAbstract
 {
-    /** @var string[] Parts of the name */
+    /**
+     * @var string[] Parts of the name
+     * @deprecated Avoid directly accessing $parts, use methods instead.
+     */
     public $parts;
 
     /**
      * Constructs a name node.
      *
-     * @param string|array $parts      Parts of the name (or name as string)
-     * @param array        $attributes Additional attributes
+     * @param string|array|self $name       Name as string, part array or Name instance (copy ctor)
+     * @param array             $attributes Additional attributes
      */
-    public function __construct($parts, array $attributes = array()) {
-        if (!is_array($parts)) {
-            $parts = explode('\\', $parts);
-        }
-
+    public function __construct($name, array $attributes = array()) {
         parent::__construct($attributes);
-        $this->parts = $parts;
+        $this->parts = self::prepareName($name);
     }
 
     public function getSubNodeNames() {
@@ -83,14 +82,13 @@ class Name extends NodeAbstract
     }
 
     /**
-     * Returns a string representation of the name by imploding the namespace parts with a separator.
-     *
-     * @param string $separator The separator to use (defaults to the namespace separator \)
+     * Returns a string representation of the name by imploding the namespace parts with the
+     * namespace separator.
      *
      * @return string String representation
      */
-    public function toString($separator = '\\') {
-        return implode($separator, $this->parts);
+    public function toString() {
+        return implode('\\', $this->parts);
     }
 
     /**
@@ -103,79 +101,45 @@ class Name extends NodeAbstract
         return implode('\\', $this->parts);
     }
 
-    /**
-     * Sets the whole name.
-     *
-     * @deprecated Create a new Name instead, or manually modify the $parts property
-     *
-     * @param string|array|self $name The name to set the whole name to
-     */
-    public function set($name) {
-        $this->parts = self::prepareName($name);
-    }
-
-    /**
-     * Prepends a name to this name.
-     *
-     * @deprecated Use Name::concat($name1, $name2) instead
-     *
-     * @param string|array|self $name Name to prepend
-     */
-    public function prepend($name) {
-        $this->parts = array_merge(self::prepareName($name), $this->parts);
-    }
-
-    /**
-     * Appends a name to this name.
-     *
-     * @deprecated Use Name::concat($name1, $name2) instead
-     *
-     * @param string|array|self $name Name to append
-     */
-    public function append($name) {
-        $this->parts = array_merge($this->parts, self::prepareName($name));
-    }
-
-    /**
-     * Sets the first part of the name.
-     *
-     * @deprecated Use concat($first, $name->slice(1)) instead
-     *
-     * @param string|array|self $name The name to set the first part to
-     */
-    public function setFirst($name) {
-        array_splice($this->parts, 0, 1, self::prepareName($name));
-    }
-
-    /**
-     * Sets the last part of the name.
-     *
-     * @param string|array|self $name The name to set the last part to
-     */
-    public function setLast($name) {
-        array_splice($this->parts, -1, 1, self::prepareName($name));
-    }
-
     /**
      * Gets a slice of a name (similar to array_slice).
      *
      * This method returns a new instance of the same type as the original and with the same
      * attributes.
      *
-     * If the slice is empty, a Name with an empty parts array is returned. While this is
-     * meaningless in itself, it works correctly in conjunction with concat().
+     * If the slice is empty, null is returned. The null value will be correctly handled in
+     * concatenations using concat().
      *
-     * @param int $offset Offset to start the slice at
+     * Offset and length have the same meaning as in array_slice().
      *
-     * @return static Sliced name
+     * @param int      $offset Offset to start the slice at (may be negative)
+     * @param int|null $length Length of the slice (may be negative)
+     *
+     * @return static|null Sliced name
      */
-    public function slice($offset) {
-        // TODO negative offset and length
-        if ($offset < 0 || $offset > count($this->parts)) {
+    public function slice($offset, $length = null) {
+        $numParts = count($this->parts);
+
+        $realOffset = $offset < 0 ? $offset + $numParts : $offset;
+        if ($realOffset < 0 || $realOffset > $numParts) {
             throw new \OutOfBoundsException(sprintf('Offset %d is out of bounds', $offset));
         }
 
-        return new static(array_slice($this->parts, $offset), $this->attributes);
+        if (null === $length) {
+            $realLength = $numParts - $realOffset;
+        } else {
+            $realLength = $length < 0 ? $length + $numParts - $realOffset : $length;
+            if ($realLength < 0 || $realLength > $numParts) {
+                throw new \OutOfBoundsException(sprintf('Length %d is out of bounds', $length));
+            }
+        }
+
+        if ($realLength === 0) {
+            // Empty slice is represented as null
+            return null;
+        }
+
+        return new static(array_slice($this->parts, $realOffset, $realLength), $this->attributes);
     }
 
     /**
@@ -184,16 +148,29 @@ class Name extends NodeAbstract
      * The type of the generated instance depends on which class this method is called on, for
      * example Name\FullyQualified::concat() will yield a Name\FullyQualified instance.
      *
-     * @param string|array|self $name1      The first name
-     * @param string|array|self $name2      The second name
-     * @param array             $attributes Attributes to assign to concatenated name
+     * If one of the arguments is null, a new instance of the other name will be returned. If both
+     * arguments are null, null will be returned. As such, writing
+     *     Name::concat($namespace, $shortName)
+     * where $namespace is a Name node or null will work as expected.
      *
-     * @return static Concatenated name
+     * @param string|array|self|null $name1      The first name
+     * @param string|array|self|null $name2      The second name
+     * @param array                  $attributes Attributes to assign to concatenated name
+     *
+     * @return static|null Concatenated name
      */
     public static function concat($name1, $name2, array $attributes = []) {
-        return new static(
-            array_merge(self::prepareName($name1), self::prepareName($name2)), $attributes
-        );
+        if (null === $name1 && null === $name2) {
+            return null;
+        } elseif (null === $name1) {
+            return new static(self::prepareName($name2), $attributes);
+        } else if (null === $name2) {
+            return new static(self::prepareName($name1), $attributes);
+        } else {
+            return new static(
+                array_merge(self::prepareName($name1), self::prepareName($name2)), $attributes
+            );
+        }
     }
 
     /**
@@ -205,16 +182,16 @@ class Name extends NodeAbstract
      * @return array Prepared name
      */
     private static function prepareName($name) {
-        if (is_string($name)) {
+        if (\is_string($name)) {
             return explode('\\', $name);
-        } elseif (is_array($name)) {
+        } elseif (\is_array($name)) {
             return $name;
         } elseif ($name instanceof self) {
             return $name->parts;
         }
 
         throw new \InvalidArgumentException(
-            'When changing a name you need to pass either a string, an array or a Name node'
+            'Expected string, array of parts or Name instance'
         );
     }
 }

lib/PhpParser/Node/NullableType.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node;
+
+use PhpParser\NodeAbstract;
+
+class NullableType extends NodeAbstract
+{
+    /** @var string|Name Type */
+    public $type;
+
+    /**
+     * Constructs a nullable type (wrapping another type).
+     *
+     * @param string|Name $type       Type
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct($type, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->type = $type;
+    }
+
+    public function getSubNodeNames() {
+        return array('type');
+    }
+}

lib/PhpParser/Node/Param.php

@@ -2,12 +2,11 @@
 
 namespace PhpParser\Node;
 
-use PhpParser\Error;
 use PhpParser\NodeAbstract;
 
 class Param extends NodeAbstract
 {
-    /** @var null|string|Name Typehint */
+    /** @var null|string|Name|NullableType Typehint */
     public $type;
     /** @var bool Whether parameter is passed by reference */
     public $byRef;
@@ -21,12 +20,12 @@ class Param extends NodeAbstract
     /**
      * Constructs a parameter node.
      *
-     * @param string           $name       Name
-     * @param null|Expr        $default    Default value
-     * @param null|string|Name $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 string                        $name       Name
+     * @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
      */
     public function __construct($name, Expr $default = null, $type = null, $byRef = false, $variadic = false, array $attributes = array()) {
         parent::__construct($attributes);
@@ -35,10 +34,6 @@ class Param extends NodeAbstract
         $this->variadic = $variadic;
         $this->name = $name;
         $this->default = $default;
-
-        if ($variadic && null !== $default) {
-            throw new Error('Variadic parameter cannot have a default value', $default->getAttributes());
-        }
     }
 
     public function getSubNodeNames() {

lib/PhpParser/Node/Scalar/Encapsed.php

@@ -2,11 +2,12 @@
 
 namespace PhpParser\Node\Scalar;
 
+use PhpParser\Node\Expr;
 use PhpParser\Node\Scalar;
 
 class Encapsed extends Scalar
 {
-    /** @var array Encaps list */
+    /** @var Expr[] list of string parts */
     public $parts;
 
     /**

lib/PhpParser/Node/Stmt/Catch_.php

@@ -6,8 +6,8 @@ use PhpParser\Node;
 
 class Catch_ extends Node\Stmt
 {
-    /** @var Node\Name Class of exception */
-    public $type;
+    /** @var Node\Name[] Types of exceptions to catch */
+    public $types;
     /** @var string Variable for exception */
     public $var;
     /** @var Node[] Statements */
@@ -16,19 +16,19 @@ class Catch_ extends Node\Stmt
     /**
      * Constructs a catch node.
      *
-     * @param Node\Name $type       Class of exception
-     * @param string    $var        Variable for exception
-     * @param Node[]    $stmts      Statements
-     * @param array     $attributes Additional attributes
+     * @param Node\Name[] $types      Types of exceptions to catch
+     * @param string      $var        Variable for exception
+     * @param Node[]      $stmts      Statements
+     * @param array       $attributes Additional attributes
      */
-    public function __construct(Node\Name $type, $var, array $stmts = array(), array $attributes = array()) {
+    public function __construct(array $types, $var, array $stmts = array(), array $attributes = array()) {
         parent::__construct($attributes);
-        $this->type = $type;
+        $this->types = $types;
         $this->var = $var;
         $this->stmts = $stmts;
     }
 
     public function getSubNodeNames() {
-        return array('type', 'var', 'stmts');
+        return array('types', 'var', 'stmts');
     }
 }

lib/PhpParser/Node/Stmt/ClassConst.php

@@ -6,6 +6,8 @@ use PhpParser\Node;
 
 class ClassConst extends Node\Stmt
 {
+    /** @var int Modifiers */
+    public $flags;
     /** @var Node\Const_[] Constant declarations */
     public $consts;
 
@@ -13,14 +15,33 @@ class ClassConst extends Node\Stmt
      * Constructs a class const list node.
      *
      * @param Node\Const_[] $consts     Constant declarations
+     * @param int           $flags      Modifiers
      * @param array         $attributes Additional attributes
      */
-    public function __construct(array $consts, array $attributes = array()) {
+    public function __construct(array $consts, $flags = 0, array $attributes = array()) {
         parent::__construct($attributes);
+        $this->flags = $flags;
         $this->consts = $consts;
     }
 
     public function getSubNodeNames() {
-        return array('consts');
+        return array('flags', 'consts');
+    }
+
+    public function isPublic() {
+        return ($this->flags & Class_::MODIFIER_PUBLIC) !== 0
+            || ($this->flags & Class_::VISIBILITY_MODIFER_MASK) === 0;
+    }
+
+    public function isProtected() {
+        return (bool) ($this->flags & Class_::MODIFIER_PROTECTED);
+    }
+
+    public function isPrivate() {
+        return (bool) ($this->flags & Class_::MODIFIER_PRIVATE);
+    }
+
+    public function isStatic() {
+        return (bool) ($this->flags & Class_::MODIFIER_STATIC);
     }
 }

lib/PhpParser/Node/Stmt/ClassLike.php

@@ -5,7 +5,7 @@ namespace PhpParser\Node\Stmt;
 use PhpParser\Node;
 
 abstract class ClassLike extends Node\Stmt {
-    /** @var string Name */
+    /** @var string|null Name */
     public $name;
     /** @var Node[] Statements */
     public $stmts;

lib/PhpParser/Node/Stmt/ClassMethod.php

@@ -4,29 +4,31 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 use PhpParser\Node\FunctionLike;
-use PhpParser\Error;
 
 class ClassMethod extends Node\Stmt implements FunctionLike
 {
-    /** @var int Type */
-    public $type;
+    /** @var int Flags */
+    public $flags;
     /** @var bool Whether to return by reference */
     public $byRef;
     /** @var string Name */
     public $name;
     /** @var Node\Param[] Parameters */
     public $params;
-    /** @var null|string|Node\Name Return type */
+    /** @var null|string|Node\Name|Node\NullableType Return type */
     public $returnType;
     /** @var Node[] Statements */
     public $stmts;
 
+    /** @deprecated Use $flags instead */
+    public $type;
+
     /**
      * Constructs a class method node.
      *
      * @param string      $name       Name
      * @param array       $subNodes   Array of the following optional subnodes:
-     *                                'type'       => MODIFIER_PUBLIC: Type
+     *                                'flags       => MODIFIER_PUBLIC: Flags
      *                                'byRef'      => false          : Whether to return by reference
      *                                'params'     => array()        : Parameters
      *                                'returnType' => null           : Return type
@@ -35,27 +37,18 @@ class ClassMethod extends Node\Stmt implements FunctionLike
      */
     public function __construct($name, array $subNodes = array(), array $attributes = array()) {
         parent::__construct($attributes);
-        $this->type = isset($subNodes['type']) ? $subNodes['type'] : 0;
+        $this->flags = isset($subNodes['flags']) ? $subNodes['flags']
+            : (isset($subNodes['type']) ? $subNodes['type'] : 0);
+        $this->type = $this->flags;
         $this->byRef = isset($subNodes['byRef'])  ? $subNodes['byRef']  : false;
         $this->name = $name;
         $this->params = isset($subNodes['params']) ? $subNodes['params'] : array();
         $this->returnType = isset($subNodes['returnType']) ? $subNodes['returnType'] : null;
         $this->stmts = array_key_exists('stmts', $subNodes) ? $subNodes['stmts'] : array();
-
-        if ($this->type & Class_::MODIFIER_STATIC) {
-            switch (strtolower($this->name)) {
-                case '__construct':
-                    throw new Error(sprintf('Constructor %s() cannot be static', $this->name));
-                case '__destruct':
-                    throw new Error(sprintf('Destructor %s() cannot be static', $this->name));
-                case '__clone':
-                    throw new Error(sprintf('Clone method %s() cannot be static', $this->name));
-            }
-        }
     }
 
     public function getSubNodeNames() {
-        return array('type', 'byRef', 'name', 'params', 'returnType', 'stmts');
+        return array('flags', 'byRef', 'name', 'params', 'returnType', 'stmts');
     }
 
     public function returnsByRef() {
@@ -75,27 +68,27 @@ class ClassMethod extends Node\Stmt implements FunctionLike
     }
 
     public function isPublic() {
-        return ($this->type & Class_::MODIFIER_PUBLIC) !== 0
-            || ($this->type & Class_::VISIBILITY_MODIFER_MASK) === 0;
+        return ($this->flags & Class_::MODIFIER_PUBLIC) !== 0
+            || ($this->flags & Class_::VISIBILITY_MODIFER_MASK) === 0;
     }
 
     public function isProtected() {
-        return (bool) ($this->type & Class_::MODIFIER_PROTECTED);
+        return (bool) ($this->flags & Class_::MODIFIER_PROTECTED);
     }
 
     public function isPrivate() {
-        return (bool) ($this->type & Class_::MODIFIER_PRIVATE);
+        return (bool) ($this->flags & Class_::MODIFIER_PRIVATE);
     }
 
     public function isAbstract() {
-        return (bool) ($this->type & Class_::MODIFIER_ABSTRACT);
+        return (bool) ($this->flags & Class_::MODIFIER_ABSTRACT);
     }
 
     public function isFinal() {
-        return (bool) ($this->type & Class_::MODIFIER_FINAL);
+        return (bool) ($this->flags & Class_::MODIFIER_FINAL);
     }
 
     public function isStatic() {
-        return (bool) ($this->type & Class_::MODIFIER_STATIC);
+        return (bool) ($this->flags & Class_::MODIFIER_STATIC);
     }
 }

lib/PhpParser/Node/Stmt/Class_.php

@@ -2,8 +2,8 @@
 
 namespace PhpParser\Node\Stmt;
 
-use PhpParser\Node;
 use PhpParser\Error;
+use PhpParser\Node;
 
 class Class_ extends ClassLike
 {
@@ -17,12 +17,15 @@ class Class_ extends ClassLike
     const VISIBILITY_MODIFER_MASK = 7; // 1 | 2 | 4
 
     /** @var int Type */
-    public $type;
+    public $flags;
     /** @var null|Node\Name Name of extended class */
     public $extends;
     /** @var Node\Name[] Names of implemented interfaces */
     public $implements;
 
+    /** @deprecated Use $flags instead */
+    public $type;
+
     protected static $specialNames = array(
         'self'   => true,
         'parent' => true,
@@ -34,7 +37,7 @@ class Class_ extends ClassLike
      *
      * @param string|null $name       Name
      * @param array       $subNodes   Array of the following optional subnodes:
-     *                                'type'       => 0      : Type
+     *                                'flags'      => 0      : Flags
      *                                'extends'    => null   : Name of extended class
      *                                'implements' => array(): Names of implemented interfaces
      *                                'stmts'      => array(): Statements
@@ -42,43 +45,25 @@ class Class_ extends ClassLike
      */
     public function __construct($name, array $subNodes = array(), array $attributes = array()) {
         parent::__construct($attributes);
-        $this->type = isset($subNodes['type']) ? $subNodes['type'] : 0;
+        $this->flags = isset($subNodes['flags']) ? $subNodes['flags']
+            : (isset($subNodes['type']) ? $subNodes['type'] : 0);
+        $this->type = $this->flags;
         $this->name = $name;
         $this->extends = isset($subNodes['extends']) ? $subNodes['extends'] : null;
         $this->implements = isset($subNodes['implements']) ? $subNodes['implements'] : array();
         $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
-
-        if (null !== $this->name && isset(self::$specialNames[strtolower($this->name)])) {
-            throw new Error(sprintf('Cannot use \'%s\' as class name as it is reserved', $this->name));
-        }
-
-        if (isset(self::$specialNames[strtolower($this->extends)])) {
-            throw new Error(
-                sprintf('Cannot use \'%s\' as class name as it is reserved', $this->extends),
-                $this->extends->getAttributes()
-            );
-        }
-
-        foreach ($this->implements as $interface) {
-            if (isset(self::$specialNames[strtolower($interface)])) {
-                throw new Error(
-                    sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
-                    $interface->getAttributes()
-                );
-            }
-        }
     }
 
     public function getSubNodeNames() {
-        return array('type', 'name', 'extends', 'implements', 'stmts');
+        return array('flags', 'name', 'extends', 'implements', 'stmts');
     }
 
     public function isAbstract() {
-        return (bool) ($this->type & self::MODIFIER_ABSTRACT);
+        return (bool) ($this->flags & self::MODIFIER_ABSTRACT);
     }
 
     public function isFinal() {
-        return (bool) ($this->type & self::MODIFIER_FINAL);
+        return (bool) ($this->flags & self::MODIFIER_FINAL);
     }
 
     public function isAnonymous() {

lib/PhpParser/Node/Stmt/Declare_.php

@@ -3,6 +3,7 @@
 namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
+
 class Declare_ extends Node\Stmt
 {
     /** @var DeclareDeclare[] List of declares */

lib/PhpParser/Node/Stmt/Finally_.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Finally_ extends Node\Stmt
+{
+    /** @var Node[] Statements */
+    public $stmts;
+
+    /**
+     * Constructs a finally node.
+     *
+     * @param Node[] $stmts      Statements
+     * @param array  $attributes Additional attributes
+     */
+    public function __construct(array $stmts = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->stmts = $stmts;
+    }
+
+    public function getSubNodeNames() {
+        return array('stmts');
+    }
+}

lib/PhpParser/Node/Stmt/Function_.php

@@ -13,7 +13,7 @@ class Function_ extends Node\Stmt implements FunctionLike
     public $name;
     /** @var Node\Param[] Parameters */
     public $params;
-    /** @var null|string|Node\Name Return type */
+    /** @var null|string|Node\Name|Node\NullableType Return type */
     public $returnType;
     /** @var Node[] Statements */
     public $stmts;

lib/PhpParser/Node/Stmt/GroupUse.php

@@ -2,8 +2,8 @@
 
 namespace PhpParser\Node\Stmt;
 
-use PhpParser\Node\Stmt;
 use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
 
 class GroupUse extends Stmt
 {

lib/PhpParser/Node/Stmt/Interface_.php

@@ -3,19 +3,12 @@
 namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
-use PhpParser\Error;
 
 class Interface_ extends ClassLike
 {
     /** @var Node\Name[] Extended interfaces */
     public $extends;
 
-    protected static $specialNames = array(
-        'self'   => true,
-        'parent' => true,
-        'static' => true,
-    );
-
     /**
      * Constructs a class node.
      *
@@ -30,19 +23,6 @@ class Interface_ extends ClassLike
         $this->name = $name;
         $this->extends = isset($subNodes['extends']) ? $subNodes['extends'] : array();
         $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
-
-        if (isset(self::$specialNames[strtolower($this->name)])) {
-            throw new Error(sprintf('Cannot use \'%s\' as class name as it is reserved', $this->name));
-        }
-
-        foreach ($this->extends as $interface) {
-            if (isset(self::$specialNames[strtolower($interface)])) {
-                throw new Error(
-                    sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
-                    $interface->getAttributes()
-                );
-            }
-        }
     }
 
     public function getSubNodeNames() {

lib/PhpParser/Node/Stmt/Namespace_.php

@@ -3,7 +3,6 @@
 namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
-use PhpParser\Error;
 
 class Namespace_ extends Node\Stmt
 {
@@ -12,12 +11,6 @@ class Namespace_ extends Node\Stmt
     /** @var Node[] Statements */
     public $stmts;
 
-    protected static $specialNames = array(
-        'self'   => true,
-        'parent' => true,
-        'static' => true,
-    );
-
     /**
      * Constructs a namespace node.
      *
@@ -29,21 +22,6 @@ class Namespace_ extends Node\Stmt
         parent::__construct($attributes);
         $this->name = $name;
         $this->stmts = $stmts;
-
-        if (isset(self::$specialNames[strtolower($this->name)])) {
-            throw new Error(
-                sprintf('Cannot use \'%s\' as namespace name', $this->name),
-                $this->name->getAttributes()
-            );
-        }
-
-        if (null !== $this->stmts) {
-            foreach ($this->stmts as $stmt) {
-                if ($stmt instanceof self) {
-                    throw new Error('Namespace declarations cannot be nested', $stmt->getAttributes());
-                }
-            }
-        }
     }
 
     public function getSubNodeNames() {

lib/PhpParser/Node/Stmt/Property.php

@@ -3,54 +3,49 @@
 namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
-use PhpParser\Error;
 
 class Property extends Node\Stmt
 {
     /** @var int Modifiers */
-    public $type;
+    public $flags;
     /** @var PropertyProperty[] Properties */
     public $props;
 
+    /** @deprecated Use $flags instead */
+    public $type;
+
     /**
      * Constructs a class property list node.
      *
-     * @param int                $type       Modifiers
+     * @param int                $flags      Modifiers
      * @param PropertyProperty[] $props      Properties
      * @param array              $attributes Additional attributes
      */
-    public function __construct($type, array $props, array $attributes = array()) {
-        if ($type & Class_::MODIFIER_ABSTRACT) {
-            throw new Error('Properties cannot be declared abstract');
-        }
-
-        if ($type & Class_::MODIFIER_FINAL) {
-            throw new Error('Properties cannot be declared final');
-        }
-
+    public function __construct($flags, array $props, array $attributes = array()) {
         parent::__construct($attributes);
-        $this->type = $type;
+        $this->flags = $flags;
+        $this->type = $flags;
         $this->props = $props;
     }
 
     public function getSubNodeNames() {
-        return array('type', 'props');
+        return array('flags', 'props');
     }
 
     public function isPublic() {
-        return ($this->type & Class_::MODIFIER_PUBLIC) !== 0
-            || ($this->type & Class_::VISIBILITY_MODIFER_MASK) === 0;
+        return ($this->flags & Class_::MODIFIER_PUBLIC) !== 0
+            || ($this->flags & Class_::VISIBILITY_MODIFER_MASK) === 0;
     }
 
     public function isProtected() {
-        return (bool) ($this->type & Class_::MODIFIER_PROTECTED);
+        return (bool) ($this->flags & Class_::MODIFIER_PROTECTED);
     }
 
     public function isPrivate() {
-        return (bool) ($this->type & Class_::MODIFIER_PRIVATE);
+        return (bool) ($this->flags & Class_::MODIFIER_PRIVATE);
     }
 
     public function isStatic() {
-        return (bool) ($this->type & Class_::MODIFIER_STATIC);
+        return (bool) ($this->flags & Class_::MODIFIER_STATIC);
     }
 }

lib/PhpParser/Node/Stmt/Trait_.php

@@ -10,13 +10,14 @@ class Trait_ extends ClassLike
      * Constructs a trait node.
      *
      * @param string $name       Name
-     * @param Node[] $stmts      Statements
+     * @param array  $subNodes   Array of the following optional subnodes:
+     *                           'stmts' => array(): Statements
      * @param array  $attributes Additional attributes
      */
-    public function __construct($name, array $stmts = array(), array $attributes = array()) {
+    public function __construct($name, array $subNodes = array(), array $attributes = array()) {
         parent::__construct($attributes);
         $this->name = $name;
-        $this->stmts = $stmts;
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
     }
 
     public function getSubNodeNames() {

lib/PhpParser/Node/Stmt/TryCatch.php

@@ -3,7 +3,6 @@
 namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
-use PhpParser\Error;
 
 class TryCatch extends Node\Stmt
 {
@@ -11,29 +10,25 @@ class TryCatch extends Node\Stmt
     public $stmts;
     /** @var Catch_[] Catches */
     public $catches;
-    /** @var null|Node[] Finally statements */
-    public $finallyStmts;
+    /** @var null|Finally_ Optional finally node */
+    public $finally;
 
     /**
      * Constructs a try catch node.
      *
-     * @param Node[]      $stmts        Statements
-     * @param Catch_[]    $catches      Catches
-     * @param null|Node[] $finallyStmts Finally statements (null means no finally clause)
-     * @param array|null  $attributes   Additional attributes
+     * @param Node[]        $stmts      Statements
+     * @param Catch_[]      $catches    Catches
+     * @param null|Finally_ $finally    Optionaly finally node
+     * @param array|null    $attributes Additional attributes
      */
-    public function __construct(array $stmts, array $catches, array $finallyStmts = null, array $attributes = array()) {
-        if (empty($catches) && null === $finallyStmts) {
-            throw new Error('Cannot use try without catch or finally');
-        }
-
+    public function __construct(array $stmts, array $catches, Finally_ $finally = null, array $attributes = array()) {
         parent::__construct($attributes);
         $this->stmts = $stmts;
         $this->catches = $catches;
-        $this->finallyStmts = $finallyStmts;
+        $this->finally = $finally;
     }
 
     public function getSubNodeNames() {
-        return array('stmts', 'catches', 'finallyStmts');
+        return array('stmts', 'catches', 'finally');
     }
 }

lib/PhpParser/Node/Stmt/UseUse.php

@@ -3,7 +3,6 @@
 namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
-use PhpParser\Error;
 
 class UseUse extends Node\Stmt
 {
@@ -27,13 +26,6 @@ class UseUse extends Node\Stmt
             $alias = $name->getLast();
         }
 
-        if ('self' == strtolower($alias) || 'parent' == strtolower($alias)) {
-            throw new Error(sprintf(
-                'Cannot use %s as %s because \'%2$s\' is a special class name',
-                $name, $alias
-            ));
-        }
-
         parent::__construct($attributes);
         $this->type = $type;
         $this->name = $name;

lib/PhpParser/NodeAbstract.php

@@ -2,7 +2,7 @@
 
 namespace PhpParser;
 
-abstract class NodeAbstract implements Node
+abstract class NodeAbstract implements Node, \JsonSerializable
 {
     protected $attributes;
 
@@ -63,6 +63,28 @@ abstract class NodeAbstract implements Node
         return $lastComment;
     }
 
+    /**
+     * Sets the doc comment of the node.
+     *
+     * This will either replace an existing doc comment or add it to the comments array.
+     *
+     * @param Comment\Doc $docComment Doc comment to set
+     */
+    public function setDocComment(Comment\Doc $docComment) {
+        $comments = $this->getAttribute('comments', []);
+
+        $numComments = count($comments);
+        if ($numComments > 0 && $comments[$numComments - 1] instanceof Comment\Doc) {
+            // Replace existing doc comment
+            $comments[$numComments - 1] = $docComment;
+        } else {
+            // Append new comment
+            $comments[] = $docComment;
+        }
+
+        $this->setAttribute('comments', $comments);
+    }
+
     public function setAttribute($key, $value) {
         $this->attributes[$key] = $value;
     }
@@ -82,4 +104,8 @@ abstract class NodeAbstract implements Node
     public function getAttributes() {
         return $this->attributes;
     }
+
+    public function jsonSerialize() {
+        return ['nodeType' => $this->getType()] + get_object_vars($this);
+    }
 }

lib/PhpParser/NodeDumper.php

@@ -2,30 +2,55 @@
 
 namespace PhpParser;
 
+use PhpParser\Node\Expr\Include_;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\GroupUse;
+use PhpParser\Node\Stmt\Use_;
+use PhpParser\Node\Stmt\UseUse;
+
 class NodeDumper
 {
     private $dumpComments;
+    private $dumpPositions;
+    private $code;
 
     /**
      * Constructs a NodeDumper.
      *
-     * @param array $options Boolean option 'dumpComments' controls whether comments should be
-     *                       dumped
+     * Supported options:
+     *  * bool dumpComments: Whether comments should be dumped.
+     *  * bool dumpPositions: Whether line/offset information should be dumped. To dump offset
+     *                        information, the code needs to be passed to dump().
+     *
+     * @param array $options Options (see description)
      */
     public function __construct(array $options = []) {
         $this->dumpComments = !empty($options['dumpComments']);
+        $this->dumpPositions = !empty($options['dumpPositions']);
     }
 
     /**
      * Dumps a node or array.
      *
-     * @param array|Node $node Node or array to dump
+     * @param array|Node  $node Node or array to dump
+     * @param string|null $code Code corresponding to dumped AST. This only needs to be passed if
+     *                          the dumpPositions option is enabled and the dumping of node offsets
+     *                          is desired.
      *
      * @return string Dumped value
      */
-    public function dump($node) {
+    public function dump($node, $code = null) {
+        $this->code = $code;
+        return $this->dumpRecursive($node);
+    }
+
+    protected function dumpRecursive($node) {
         if ($node instanceof Node) {
-            $r = $node->getType() . '(';
+            $r = $node->getType();
+            if ($this->dumpPositions && null !== $p = $this->dumpPosition($node)) {
+                $r .= $p;
+            }
+            $r .= '(';
 
             foreach ($node->getSubNodeNames() as $key) {
                 $r .= "\n    " . $key . ': ';
@@ -38,14 +63,23 @@ class NodeDumper
                 } elseif (true === $value) {
                     $r .= 'true';
                 } elseif (is_scalar($value)) {
-                    $r .= $value;
+                    if ('flags' === $key || 'newModifier' === $key) {
+                        $r .= $this->dumpFlags($value);
+                    } else if ('type' === $key && $node instanceof Include_) {
+                        $r .= $this->dumpIncludeType($value);
+                    } else if ('type' === $key
+                            && ($node instanceof Use_ || $node instanceof UseUse || $node instanceof GroupUse)) {
+                        $r .= $this->dumpUseType($value);
+                    } else {
+                        $r .= $value;
+                    }
                 } else {
-                    $r .= str_replace("\n", "\n    ", $this->dump($value));
+                    $r .= str_replace("\n", "\n    ", $this->dumpRecursive($value));
                 }
             }
 
             if ($this->dumpComments && $comments = $node->getAttribute('comments')) {
-                $r .= "\n    comments: " . str_replace("\n", "\n    ", $this->dump($comments));
+                $r .= "\n    comments: " . str_replace("\n", "\n    ", $this->dumpRecursive($comments));
             }
         } elseif (is_array($node)) {
             $r = 'array(';
@@ -62,7 +96,7 @@ class NodeDumper
                 } elseif (is_scalar($value)) {
                     $r .= $value;
                 } else {
-                    $r .= str_replace("\n", "\n    ", $this->dump($value));
+                    $r .= str_replace("\n", "\n    ", $this->dumpRecursive($value));
                 }
             }
         } elseif ($node instanceof Comment) {
@@ -73,4 +107,90 @@ class NodeDumper
 
         return $r . "\n)";
     }
+
+    protected function dumpFlags($flags) {
+        $strs = [];
+        if ($flags & Class_::MODIFIER_PUBLIC) {
+            $strs[] = 'MODIFIER_PUBLIC';
+        }
+        if ($flags & Class_::MODIFIER_PROTECTED) {
+            $strs[] = 'MODIFIER_PROTECTED';
+        }
+        if ($flags & Class_::MODIFIER_PRIVATE) {
+            $strs[] = 'MODIFIER_PRIVATE';
+        }
+        if ($flags & Class_::MODIFIER_ABSTRACT) {
+            $strs[] = 'MODIFIER_ABSTRACT';
+        }
+        if ($flags & Class_::MODIFIER_STATIC) {
+            $strs[] = 'MODIFIER_STATIC';
+        }
+        if ($flags & Class_::MODIFIER_FINAL) {
+            $strs[] = 'MODIFIER_FINAL';
+        }
+
+        if ($strs) {
+            return implode(' | ', $strs) . ' (' . $flags . ')';
+        } else {
+            return $flags;
+        }
+    }
+
+    protected function dumpIncludeType($type) {
+        $map = [
+            Include_::TYPE_INCLUDE      => 'TYPE_INCLUDE',
+            Include_::TYPE_INCLUDE_ONCE => 'TYPE_INCLUDE_ONCE',
+            Include_::TYPE_REQUIRE      => 'TYPE_REQUIRE',
+            Include_::TYPE_REQUIRE_ONCE => 'TYPE_REQURE_ONCE',
+        ];
+
+        if (!isset($map[$type])) {
+            return $type;
+        }
+        return $map[$type] . ' (' . $type . ')';
+    }
+
+    protected function dumpUseType($type) {
+        $map = [
+            Use_::TYPE_UNKNOWN  => 'TYPE_UNKNOWN',
+            Use_::TYPE_NORMAL   => 'TYPE_NORMAL',
+            Use_::TYPE_FUNCTION => 'TYPE_FUNCTION',
+            Use_::TYPE_CONSTANT => 'TYPE_CONSTANT',
+        ];
+
+        if (!isset($map[$type])) {
+            return $type;
+        }
+        return $map[$type] . ' (' . $type . ')';
+    }
+
+    protected function dumpPosition(Node $node) {
+        if (!$node->hasAttribute('startLine') || !$node->hasAttribute('endLine')) {
+            return null;
+        }
+
+        $start = $node->getAttribute('startLine');
+        $end = $node->getAttribute('endLine');
+        if ($node->hasAttribute('startFilePos') && $node->hasAttribute('endFilePos')
+            && null !== $this->code
+        ) {
+            $start .= ':' . $this->toColumn($this->code, $node->getAttribute('startFilePos'));
+            $end .= ':' . $this->toColumn($this->code, $node->getAttribute('endFilePos'));
+        }
+        return "[$start - $end]";
+    }
+
+    // Copied from Error class
+    private function toColumn($code, $pos) {
+        if ($pos > strlen($code)) {
+            throw new \RuntimeException('Invalid position information');
+        }
+
+        $lineStartPos = strrpos($code, "\n", $pos - strlen($code));
+        if (false === $lineStartPos) {
+            $lineStartPos = -1;
+        }
+
+        return $pos - $lineStartPos;
+    }
 }

lib/PhpParser/NodeTraverser.php

@@ -5,23 +5,42 @@ namespace PhpParser;
 class NodeTraverser implements NodeTraverserInterface
 {
     /**
-     * @var NodeVisitor[] Visitors
+     * If NodeVisitor::enterNode() returns DONT_TRAVERSE_CHILDREN, child nodes
+     * of the current node will not be traversed for any visitors.
+     *
+     * For subsequent visitors enterNode() will still be called on the current
+     * node and leaveNode() will also be invoked for the current node.
      */
-    protected $visitors;
+    const DONT_TRAVERSE_CHILDREN = 1;
 
     /**
-     * @var bool
+     * If NodeVisitor::enterNode() or NodeVisitor::leaveNode() returns
+     * STOP_TRAVERSAL, traversal is aborted.
+     *
+     * The afterTraverse() method will still be invoked.
      */
-    private $cloneNodes;
+    const STOP_TRAVERSAL = 2;
+
+    /**
+     * If NodeVisitor::leaveNode() returns REMOVE_NODE for a node that occurs
+     * in an array, it will be removed from the array.
+     *
+     * For subsequent visitors leaveNode() will still be invoked for the
+     * removed node.
+     */
+    const REMOVE_NODE = false;
+
+    /** @var NodeVisitor[] Visitors */
+    protected $visitors;
+
+    /** @var bool Whether traversal should be stopped */
+    protected $stopTraversal;
 
     /**
      * Constructs a node traverser.
-     *
-     * @param bool $cloneNodes Should the traverser clone the nodes when traversing the AST
      */
-    public function __construct($cloneNodes = false) {
+    public function __construct() {
         $this->visitors = array();
-        $this->cloneNodes = $cloneNodes;
     }
 
     /**
@@ -55,6 +74,8 @@ class NodeTraverser implements NodeTraverserInterface
      * @return Node[] Traversed array of nodes
      */
     public function traverse(array $nodes) {
+        $this->stopTraversal = false;
+
         foreach ($this->visitors as $visitor) {
             if (null !== $return = $visitor->beforeTraverse($nodes)) {
                 $nodes = $return;
@@ -73,21 +94,23 @@ class NodeTraverser implements NodeTraverserInterface
     }
 
     protected function traverseNode(Node $node) {
-        if ($this->cloneNodes) {
-            $node = clone $node;
-        }
-
         foreach ($node->getSubNodeNames() as $name) {
             $subNode =& $node->$name;
 
             if (is_array($subNode)) {
                 $subNode = $this->traverseArray($subNode);
+                if ($this->stopTraversal) {
+                    break;
+                }
             } elseif ($subNode instanceof Node) {
                 $traverseChildren = true;
                 foreach ($this->visitors as $visitor) {
                     $return = $visitor->enterNode($subNode);
                     if (self::DONT_TRAVERSE_CHILDREN === $return) {
                         $traverseChildren = false;
+                    } else if (self::STOP_TRAVERSAL === $return) {
+                        $this->stopTraversal = true;
+                        break 2;
                     } else if (null !== $return) {
                         $subNode = $return;
                     }
@@ -95,10 +118,17 @@ class NodeTraverser implements NodeTraverserInterface
 
                 if ($traverseChildren) {
                     $subNode = $this->traverseNode($subNode);
+                    if ($this->stopTraversal) {
+                        break;
+                    }
                 }
 
                 foreach ($this->visitors as $visitor) {
-                    if (null !== $return = $visitor->leaveNode($subNode)) {
+                    $return = $visitor->leaveNode($subNode);
+                    if (self::STOP_TRAVERSAL === $return) {
+                        $this->stopTraversal = true;
+                        break 2;
+                    } else if (null !== $return) {
                         if (is_array($return)) {
                             throw new \LogicException(
                                 'leaveNode() may only return an array ' .
@@ -120,12 +150,18 @@ class NodeTraverser implements NodeTraverserInterface
         foreach ($nodes as $i => &$node) {
             if (is_array($node)) {
                 $node = $this->traverseArray($node);
+                if ($this->stopTraversal) {
+                    break;
+                }
             } elseif ($node instanceof Node) {
                 $traverseChildren = true;
                 foreach ($this->visitors as $visitor) {
                     $return = $visitor->enterNode($node);
                     if (self::DONT_TRAVERSE_CHILDREN === $return) {
                         $traverseChildren = false;
+                    } else if (self::STOP_TRAVERSAL === $return) {
+                        $this->stopTraversal = true;
+                        break 2;
                     } else if (null !== $return) {
                         $node = $return;
                     }
@@ -133,6 +169,9 @@ class NodeTraverser implements NodeTraverserInterface
 
                 if ($traverseChildren) {
                     $node = $this->traverseNode($node);
+                    if ($this->stopTraversal) {
+                        break;
+                    }
                 }
 
                 foreach ($this->visitors as $visitor) {
@@ -141,6 +180,9 @@ class NodeTraverser implements NodeTraverserInterface
                     if (self::REMOVE_NODE === $return) {
                         $doNodes[] = array($i, array());
                         break;
+                    } else if (self::STOP_TRAVERSAL === $return) {
+                        $this->stopTraversal = true;
+                        break 2;
                     } elseif (is_array($return)) {
                         $doNodes[] = array($i, $return);
                         break;

lib/PhpParser/NodeTraverserInterface.php

@@ -4,24 +4,6 @@ namespace PhpParser;
 
 interface NodeTraverserInterface
 {
-    /**
-     * If NodeVisitor::enterNode() returns DONT_TRAVERSE_CHILDREN, child nodes
-     * of the current node will not be traversed for any visitors.
-     *
-     * For subsequent visitors enterNode() will still be called on the current
-     * node and leaveNode() will also be invoked for the current node.
-     */
-    const DONT_TRAVERSE_CHILDREN = 1;
-
-    /**
-     * If NodeVisitor::leaveNode() returns REMOVE_NODE for a node that occurs
-     * in an array, it will be removed from the array.
-     *
-     * For subsequent visitors leaveNode() will still be invoked for the
-     * removed node.
-     */
-    const REMOVE_NODE = false;
-
     /**
      * Adds a visitor.
      *

lib/PhpParser/NodeVisitor.php

@@ -21,12 +21,18 @@ interface NodeVisitor
      * Called when entering a node.
      *
      * Return value semantics:
-     *  * null:      $node stays as-is
-     *  * otherwise: $node is set to the return value
+     *  * null
+     *        => $node stays as-is
+     *  * NodeTraverser::DONT_TRAVERSE_CHILDREN
+     *        => Children of $node are not traversed. $node stays as-is
+     *  * NodeTraverser::STOP_TRAVERSAL
+     *        => Traversal is aborted. $node stays as-is
+     *  * otherwise
+     *        => $node is set to the return value
      *
      * @param Node $node Node
      *
-     * @return null|Node Node
+     * @return null|int|Node Node
      */
     public function enterNode(Node $node);
 
@@ -34,14 +40,20 @@ interface NodeVisitor
      * Called when leaving a node.
      *
      * Return value semantics:
-     *  * null:      $node stays as-is
-     *  * false:     $node is removed from the parent array
-     *  * array:     The return value is merged into the parent array (at the position of the $node)
-     *  * otherwise: $node is set to the return value
+     *  * null
+     *        => $node stays as-is
+     *  * NodeTraverser::REMOVE_NODE
+     *        => $node is removed from the parent array
+     *  * NodeTraverser::STOP_TRAVERSAL
+     *        => Traversal is aborted. $node stays as-is
+     *  * array (of Nodes)
+     *        => The return value is merged into the parent array (at the position of the $node)
+     *  * otherwise
+     *        => $node is set to the return value
      *
      * @param Node $node Node
      *
-     * @return null|Node|false|Node[] Node
+     * @return null|false|int|Node|Node[] Node
      */
     public function leaveNode(Node $node);
 

lib/PhpParser/NodeVisitor/NameResolver.php

@@ -2,13 +2,14 @@
 
 namespace PhpParser\NodeVisitor;
 
-use PhpParser\NodeVisitorAbstract;
 use PhpParser\Error;
+use PhpParser\ErrorHandler;
 use PhpParser\Node;
+use PhpParser\Node\Expr;
 use PhpParser\Node\Name;
 use PhpParser\Node\Name\FullyQualified;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Stmt;
+use PhpParser\NodeVisitorAbstract;
 
 class NameResolver extends NodeVisitorAbstract
 {
@@ -18,6 +19,26 @@ class NameResolver extends NodeVisitorAbstract
     /** @var array Map of format [aliasType => [aliasName => originalName]] */
     protected $aliases;
 
+    /** @var ErrorHandler Error handler */
+    protected $errorHandler;
+
+    /** @var bool Whether to preserve original names */
+    protected $preserveOriginalNames;
+
+    /**
+     * Constructs a name resolution visitor.
+     *
+     * Options: If "preserveOriginalNames" is enabled, an "originalName" attribute will be added to
+     * all name nodes that underwent resolution.
+     *
+     * @param ErrorHandler|null $errorHandler Error handler
+     * @param array $options Options
+     */
+    public function __construct(ErrorHandler $errorHandler = null, array $options = []) {
+        $this->errorHandler = $errorHandler ?: new ErrorHandler\Throwing;
+        $this->preserveOriginalNames = !empty($options['preserveOriginalNames']);
+    }
+
     public function beforeTraverse(array $nodes) {
         $this->resetState();
     }
@@ -74,7 +95,9 @@ class NameResolver extends NodeVisitorAbstract
                 $node->class = $this->resolveClassName($node->class);
             }
         } elseif ($node instanceof Stmt\Catch_) {
-            $node->type = $this->resolveClassName($node->type);
+            foreach ($node->types as &$type) {
+                $type = $this->resolveClassName($type);
+            }
         } elseif ($node instanceof Expr\FuncCall) {
             if ($node->name instanceof Name) {
                 $node->name = $this->resolveOtherName($node->name, Stmt\Use_::TYPE_FUNCTION);
@@ -97,7 +120,10 @@ class NameResolver extends NodeVisitorAbstract
                     }
                 }
             }
-
+        } elseif ($node instanceof Node\NullableType) {
+            if ($node->type instanceof Name) {
+                $node->type = $this->resolveClassName($node->type);
+            }
         }
     }
 
@@ -130,13 +156,14 @@ class NameResolver extends NodeVisitorAbstract
                 Stmt\Use_::TYPE_CONSTANT => 'const ',
             );
 
-            throw new Error(
+            $this->errorHandler->handleError(new Error(
                 sprintf(
                     'Cannot use %s%s as %s because the name is already in use',
                     $typeStringMap[$type], $name, $use->alias
                 ),
-                $use->getLine()
-            );
+                $use->getAttributes()
+            ));
+            return;
         }
 
         $this->aliases[$type][$aliasName] = $name;
@@ -155,15 +182,21 @@ class NameResolver extends NodeVisitorAbstract
     }
 
     protected function resolveClassName(Name $name) {
+        if ($this->preserveOriginalNames) {
+            // Save the original name
+            $originalName = $name;
+            $name = clone $originalName;
+            $name->setAttribute('originalName', $originalName);
+        }
+
         // don't resolve special class names
         if (in_array(strtolower($name->toString()), array('self', 'parent', 'static'))) {
             if (!$name->isUnqualified()) {
-                throw new Error(
+                $this->errorHandler->handleError(new Error(
                     sprintf("'\\%s' is an invalid class name", $name->toString()),
-                    $name->getLine()
-                );
+                    $name->getAttributes()
+                ));
             }
-
             return $name;
         }
 
@@ -179,15 +212,18 @@ class NameResolver extends NodeVisitorAbstract
             return FullyQualified::concat($alias, $name->slice(1), $name->getAttributes());
         }
 
-        if (null !== $this->namespace) {
-            // if no alias exists prepend current namespace
-            return FullyQualified::concat($this->namespace, $name, $name->getAttributes());
-        }
-
-        return new FullyQualified($name->parts, $name->getAttributes());
+        // if no alias exists prepend current namespace
+        return FullyQualified::concat($this->namespace, $name, $name->getAttributes());
     }
 
     protected function resolveOtherName(Name $name, $type) {
+        if ($this->preserveOriginalNames) {
+            // Save the original name
+            $originalName = $name;
+            $name = clone $originalName;
+            $name->setAttribute('originalName', $originalName);
+        }
+
         // fully qualified names are already resolved
         if ($name->isFullyQualified()) {
             return $name;
@@ -206,28 +242,28 @@ class NameResolver extends NodeVisitorAbstract
                 $aliasName = $name->getFirst();
             }
 
-            if (!isset($this->aliases[$type][$aliasName])) {
-                // unqualified, unaliased names cannot be resolved at compile-time
-                return $name;
+            if (isset($this->aliases[$type][$aliasName])) {
+                // resolve unqualified aliases
+                return new FullyQualified($this->aliases[$type][$aliasName], $name->getAttributes());
             }
 
-            // resolve unqualified aliases
-            return new FullyQualified($this->aliases[$type][$aliasName], $name->getAttributes());
+            if (null === $this->namespace) {
+                // outside of a namespace unaliased unqualified is same as fully qualified
+                return new FullyQualified($name, $name->getAttributes());
+            }
+
+            // unqualified names inside a namespace cannot be resolved at compile-time
+            // add the namespaced version of the name as an attribute
+            $name->setAttribute('namespacedName',
+                FullyQualified::concat($this->namespace, $name, $name->getAttributes()));
+            return $name;
         }
 
-        if (null !== $this->namespace) {
-            // if no alias exists prepend current namespace
-            return FullyQualified::concat($this->namespace, $name, $name->getAttributes());
-        }
-
-        return new FullyQualified($name->parts, $name->getAttributes());
+        // if no alias exists prepend current namespace
+        return FullyQualified::concat($this->namespace, $name, $name->getAttributes());
     }
 
     protected function addNamespacedName(Node $node) {
-        if (null !== $this->namespace) {
-            $node->namespacedName = Name::concat($this->namespace, $node->name);
-        } else {
-            $node->namespacedName = new Name($node->name);
-        }
+        $node->namespacedName = Name::concat($this->namespace, $node->name);
     }
 }

lib/PhpParser/Parser.php

@@ -7,18 +7,11 @@ interface Parser {
      * Parses PHP code into a node tree.
      *
      * @param string $code The source code to parse
+     * @param ErrorHandler|null $errorHandler Error handler to use for lexer/parser errors, defaults
+     *                                        to ErrorHandler\Throwing.
      *
      * @return Node[]|null Array of statements (or null if the 'throwOnError' option is disabled and the parser was
      *                     unable to recover from an error).
      */
-    public function parse($code);
-
-    /**
-     * Get array of errors that occurred during the last parse.
-     *
-     * This method may only return multiple errors if the 'throwOnError' option is disabled.
-     *
-     * @return Error[]
-     */
-    public function getErrors();
+    public function parse($code, ErrorHandler $errorHandler = null);
 }

lib/PhpParser/Parser/Multiple.php

@@ -3,61 +3,52 @@
 namespace PhpParser\Parser;
 
 use PhpParser\Error;
+use PhpParser\ErrorHandler;
 use PhpParser\Parser;
 
 class Multiple implements Parser {
     /** @var Parser[] List of parsers to try, in order of preference */
     private $parsers;
-    /** @var Error[] Errors collected during last parse */
-    private $errors;
 
     /**
      * Create a parser which will try multiple parsers in an order of preference.
      *
      * Parsers will be invoked in the order they're provided to the constructor. If one of the
-     * parsers runs without errors, it's output is returned. Otherwise the errors (and
-     * PhpParser\Error exception) of the first parser are used.
+     * parsers runs without throwing, it's output is returned. Otherwise the exception that the
+     * first parser generated is thrown.
      *
      * @param Parser[] $parsers
      */
     public function __construct(array $parsers) {
         $this->parsers = $parsers;
-        $this->errors = [];
     }
 
-    public function parse($code) {
-        list($firstStmts, $firstErrors, $firstError) = $this->tryParse($this->parsers[0], $code);
-        if ($firstErrors === []) {
-            $this->errors = [];
+    public function parse($code, ErrorHandler $errorHandler = null) {
+        if (null === $errorHandler) {
+            $errorHandler = new ErrorHandler\Throwing;
+        }
+
+        list($firstStmts, $firstError) = $this->tryParse($this->parsers[0], $errorHandler, $code);
+        if ($firstError === null) {
             return $firstStmts;
         }
 
         for ($i = 1, $c = count($this->parsers); $i < $c; ++$i) {
-            list($stmts, $errors) = $this->tryParse($this->parsers[$i], $code);
-            if ($errors === []) {
-                $this->errors = [];
+            list($stmts, $error) = $this->tryParse($this->parsers[$i], $errorHandler, $code);
+            if ($error === null) {
                 return $stmts;
             }
         }
 
-        $this->errors = $firstErrors;
-        if ($firstError) {
-            throw $firstError;
-        }
-        return $firstStmts;
+        throw $firstError;
     }
 
-    public function getErrors() {
-        return $this->errors;
-    }
-
-    private function tryParse(Parser $parser, $code) {
+    private function tryParse(Parser $parser, ErrorHandler $errorHandler, $code) {
         $stmts = null;
         $error = null;
         try {
-            $stmts = $parser->parse($code);
+            $stmts = $parser->parse($code, $errorHandler);
         } catch (Error $error) {}
-        $errors = $parser->getErrors();
-        return [$stmts, $errors, $error];
+        return [$stmts, $error];
     }
 }

lib/PhpParser/ParserAbstract.php

@@ -7,6 +7,17 @@ namespace PhpParser;
  * turn is based on work by Masato Bito.
  */
 use PhpParser\Node\Name;
+use PhpParser\Node\Param;
+use PhpParser\Node\Scalar\LNumber;
+use PhpParser\Node\Scalar\String_;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\ClassConst;
+use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Interface_;
+use PhpParser\Node\Stmt\Namespace_;
+use PhpParser\Node\Stmt\Property;
+use PhpParser\Node\Stmt\TryCatch;
+use PhpParser\Node\Stmt\UseUse;
 
 abstract class ParserAbstract implements Parser
 {
@@ -86,52 +97,54 @@ abstract class ParserAbstract implements Parser
     protected $semStack;
     /** @var array[] Start attribute stack */
     protected $startAttributeStack;
+    /** @var array[] End attribute stack */
+    protected $endAttributeStack;
     /** @var array End attributes of last *shifted* token */
     protected $endAttributes;
     /** @var array Start attributes of last *read* token */
     protected $lookaheadStartAttributes;
 
-    /** @var bool Whether to throw on first error */
-    protected $throwOnError;
+    /** @var ErrorHandler Error handler */
+    protected $errorHandler;
     /** @var Error[] Errors collected during last parse */
     protected $errors;
+    /** @var int Error state, used to avoid error floods */
+    protected $errorState;
 
     /**
      * Creates a parser instance.
      *
      * @param Lexer $lexer A lexer
-     * @param array $options Options array. The boolean 'throwOnError' option determines whether an exception should be
-     *                       thrown on first error, or if the parser should try to continue parsing the remaining code
-     *                       and build a partial AST.
+     * @param array $options Options array. Currently no options are supported.
      */
     public function __construct(Lexer $lexer, array $options = array()) {
         $this->lexer = $lexer;
         $this->errors = array();
-        $this->throwOnError = isset($options['throwOnError']) ? $options['throwOnError'] : true;
-    }
 
-    /**
-     * Get array of errors that occurred during the last parse.
-     *
-     * This method may only return multiple errors if the 'throwOnError' option is disabled.
-     *
-     * @return Error[]
-     */
-    public function getErrors() {
-        return $this->errors;
+        if (isset($options['throwOnError'])) {
+            throw new \LogicException(
+                '"throwOnError" is no longer supported, use "errorHandler" instead');
+        }
     }
 
     /**
      * Parses PHP code into a node tree.
      *
+     * If a non-throwing error handler is used, the parser will continue parsing after an error
+     * occurred and attempt to build a partial AST.
+     *
      * @param string $code The source code to parse
+     * @param ErrorHandler|null $errorHandler Error handler to use for lexer/parser errors, defaults
+     *                                        to ErrorHandler\Throwing.
      *
      * @return Node[]|null Array of statements (or null if the 'throwOnError' option is disabled and the parser was
      *                     unable to recover from an error).
      */
-    public function parse($code) {
-        $this->lexer->startLexing($code);
-        $this->errors = array();
+    public function parse($code, ErrorHandler $errorHandler = null) {
+        $this->errorHandler = $errorHandler ?: new ErrorHandler\Throwing;
+
+        // Initialize the lexer
+        $this->lexer->startLexing($code, $this->errorHandler);
 
         // We start off with no lookahead-token
         $symbol = self::SYMBOL_NONE;
@@ -143,9 +156,9 @@ abstract class ParserAbstract implements Parser
         $endAttributes = '*POISON';
         $this->endAttributes = $endAttributes;
 
-        // In order to figure out the attributes for the starting token, we have to keep
-        // them in a stack
+        // Keep stack of start and end attributes
         $this->startAttributeStack = array();
+        $this->endAttributeStack = array($endAttributes);
 
         // Start off in the initial state and keep a stack of previous states
         $state = 0;
@@ -157,7 +170,7 @@ abstract class ParserAbstract implements Parser
         // Current position in the stack(s)
         $this->stackPos = 0;
 
-        $errorState = 0;
+        $this->errorState = 0;
 
         for (;;) {
             //$this->traceNewState($state, $symbol);
@@ -187,6 +200,7 @@ abstract class ParserAbstract implements Parser
                     // This is necessary to assign some meaningful attributes to /* empty */ productions. They'll get
                     // the attributes of the next token, even though they don't contain it themselves.
                     $this->startAttributeStack[$this->stackPos+1] = $startAttributes;
+                    $this->endAttributeStack[$this->stackPos+1] = $endAttributes;
                     $this->lookaheadStartAttributes = $startAttributes;
 
                     //$this->traceRead($symbol);
@@ -213,11 +227,12 @@ abstract class ParserAbstract implements Parser
                         $stateStack[$this->stackPos] = $state = $action;
                         $this->semStack[$this->stackPos] = $tokenValue;
                         $this->startAttributeStack[$this->stackPos] = $startAttributes;
+                        $this->endAttributeStack[$this->stackPos] = $endAttributes;
                         $this->endAttributes = $endAttributes;
                         $symbol = self::SYMBOL_NONE;
 
-                        if ($errorState) {
-                            --$errorState;
+                        if ($this->errorState) {
+                            --$this->errorState;
                         }
 
                         if ($action < $this->YYNLSTATES) {
@@ -250,16 +265,13 @@ abstract class ParserAbstract implements Parser
                             $e->setStartLine($startAttributes['startLine']);
                         }
 
-                        $this->errors[] = $e;
-                        if ($this->throwOnError) {
-                            throw $e;
-                        } else {
-                            // Currently can't recover from "special" errors
-                            return null;
-                        }
+                        $this->emitError($e);
+                        // Can't recover from this type of error
+                        return null;
                     }
 
                     /* Goto - shift nonterminal */
+                    $lastEndAttributes = $this->endAttributeStack[$this->stackPos];
                     $this->stackPos -= $this->ruleToLength[$rule];
                     $nonTerminal = $this->ruleToNonTerminal[$rule];
                     $idx = $this->gotoBase[$nonTerminal] + $stateStack[$this->stackPos];
@@ -272,20 +284,17 @@ abstract class ParserAbstract implements Parser
                     ++$this->stackPos;
                     $stateStack[$this->stackPos]     = $state;
                     $this->semStack[$this->stackPos] = $this->semValue;
+                    $this->endAttributeStack[$this->stackPos] = $lastEndAttributes;
                 } else {
                     /* error */
-                    switch ($errorState) {
+                    switch ($this->errorState) {
                         case 0:
                             $msg = $this->getErrorMessage($symbol, $state);
-                            $error = new Error($msg, $startAttributes + $endAttributes);
-                            $this->errors[] = $error;
-                            if ($this->throwOnError) {
-                                throw $error;
-                            }
+                            $this->emitError(new Error($msg, $startAttributes + $endAttributes));
                             // Break missing intentionally
                         case 1:
                         case 2:
-                            $errorState = 3;
+                            $this->errorState = 3;
 
                             // Pop until error-expecting state uncovered
                             while (!(
@@ -304,7 +313,9 @@ abstract class ParserAbstract implements Parser
                             }
 
                             //$this->traceShift($this->errorSymbol);
-                            $stateStack[++$this->stackPos] = $state = $action;
+                            ++$this->stackPos;
+                            $stateStack[$this->stackPos] = $state = $action;
+                            $this->endAttributes = $this->endAttributeStack[$this->stackPos];
                             break;
 
                         case 3:
@@ -331,6 +342,10 @@ abstract class ParserAbstract implements Parser
         throw new \RuntimeException('Reached end of parser loop');
     }
 
+    protected function emitError(Error $error) {
+        $this->errorHandler->handleError($error);
+    }
+
     protected function getErrorMessage($symbol, $state) {
         $expectedString = '';
         if ($expected = $this->getExpectedTokens($state)) {
@@ -353,6 +368,7 @@ abstract class ParserAbstract implements Parser
             ) {
                 if ($this->action[$idx] != $this->unexpectedTokenRule
                     && $this->action[$idx] != $this->defaultAction
+                    && $symbol != $this->errorSymbol
                 ) {
                     if (count($expected) == 4) {
                         /* Too many expected tokens */
@@ -413,6 +429,7 @@ abstract class ParserAbstract implements Parser
      * @return Node[]
      */
     protected function handleNamespaces(array $stmts) {
+        $hasErrored = false;
         $style = $this->getNamespacingStyle($stmts);
         if (null === $style) {
             // not namespaced, nothing to do
@@ -423,8 +440,11 @@ abstract class ParserAbstract implements Parser
             foreach ($stmts as $stmt) {
                 if ($stmt instanceof Node\Stmt\Namespace_) {
                     $afterFirstNamespace = true;
-                } elseif (!$stmt instanceof Node\Stmt\HaltCompiler && $afterFirstNamespace) {
-                    throw new Error('No code may exist outside of namespace {}', $stmt->getLine());
+                } elseif (!$stmt instanceof Node\Stmt\HaltCompiler
+                        && $afterFirstNamespace && !$hasErrored) {
+                    $this->emitError(new Error(
+                        'No code may exist outside of namespace {}', $stmt->getAttributes()));
+                    $hasErrored = true; // Avoid one error for every statement
                 }
             }
             return $stmts;
@@ -434,9 +454,15 @@ abstract class ParserAbstract implements Parser
             $targetStmts =& $resultStmts;
             foreach ($stmts as $stmt) {
                 if ($stmt instanceof Node\Stmt\Namespace_) {
-                    $stmt->stmts = array();
-                    $targetStmts =& $stmt->stmts;
-                    $resultStmts[] = $stmt;
+                    if ($stmt->stmts === null) {
+                        $stmt->stmts = array();
+                        $targetStmts =& $stmt->stmts;
+                        $resultStmts[] = $stmt;
+                    } else {
+                        // This handles the invalid case of mixed style namespaces
+                        $resultStmts[] = $stmt;
+                        $targetStmts =& $resultStmts;
+                    }
                 } elseif ($stmt instanceof Node\Stmt\HaltCompiler) {
                     // __halt_compiler() is not moved into the namespace
                     $resultStmts[] = $stmt;
@@ -457,10 +483,18 @@ abstract class ParserAbstract implements Parser
                 if (null === $style) {
                     $style = $currentStyle;
                     if ($hasNotAllowedStmts) {
-                        throw new Error('Namespace declaration statement has to be the very first statement in the script', $stmt->getLine());
+                        $this->emitError(new Error(
+                            'Namespace declaration statement has to be the very first statement in the script',
+                            $stmt->getLine() // Avoid marking the entire namespace as an error
+                        ));
                     }
                 } elseif ($style !== $currentStyle) {
-                    throw new Error('Cannot mix bracketed namespace declarations with unbracketed namespace declarations', $stmt->getLine());
+                    $this->emitError(new Error(
+                        'Cannot mix bracketed namespace declarations with unbracketed namespace declarations',
+                        $stmt->getLine() // Avoid marking the entire namespace as an error
+                    ));
+                    // Treat like semicolon style for namespace normalization
+                    return 'semicolon';
                 }
                 continue;
             }
@@ -483,12 +517,14 @@ abstract class ParserAbstract implements Parser
         return $style;
     }
 
-    protected function handleScalarTypes(Name $name) {
+    protected function handleBuiltinTypes(Name $name) {
         $scalarTypes = [
-            'bool'   => true,
-            'int'    => true,
-            'float'  => true,
-            'string' => true,
+            'bool'     => true,
+            'int'      => true,
+            'float'    => true,
+            'string'   => true,
+            'iterable' => true,
+            'void'     => true,
         ];
 
         if (!$name->isUnqualified()) {
@@ -498,4 +534,190 @@ abstract class ParserAbstract implements Parser
         $lowerName = strtolower($name->toString());
         return isset($scalarTypes[$lowerName]) ? $lowerName : $name;
     }
+
+    protected static $specialNames = array(
+        'self'   => true,
+        'parent' => true,
+        'static' => true,
+    );
+
+    protected function getAttributesAt($pos) {
+        return $this->startAttributeStack[$pos] + $this->endAttributeStack[$pos];
+    }
+
+    protected function parseLNumber($str, $attributes, $allowInvalidOctal = false) {
+        try {
+            return LNumber::fromString($str, $attributes, $allowInvalidOctal);
+        } catch (Error $error) {
+            $this->emitError($error);
+            // Use dummy value
+            return new LNumber(0, $attributes);
+        }
+    }
+
+    protected function parseNumString($str, $attributes) {
+        if (!preg_match('/^(?:0|-?[1-9][0-9]*)$/', $str)) {
+            return new String_($str, $attributes);
+        }
+
+        $num = +$str;
+        if (!is_int($num)) {
+            return new String_($str, $attributes);
+        }
+
+        return new LNumber($num, $attributes);
+    }
+
+    protected function checkModifier($a, $b, $modifierPos) {
+        // Jumping through some hoops here because verifyModifier() is also used elsewhere
+        try {
+            Class_::verifyModifier($a, $b);
+        } catch (Error $error) {
+            $error->setAttributes($this->getAttributesAt($modifierPos));
+            $this->emitError($error);
+        }
+    }
+
+    protected function checkParam(Param $node) {
+        if ($node->variadic && null !== $node->default) {
+            $this->emitError(new Error(
+                'Variadic parameter cannot have a default value',
+                $node->default->getAttributes()
+            ));
+        }
+    }
+
+    protected function checkTryCatch(TryCatch $node) {
+        if (empty($node->catches) && null === $node->finally) {
+            $this->emitError(new Error(
+                'Cannot use try without catch or finally', $node->getAttributes()
+            ));
+        }
+    }
+
+    protected function checkNamespace(Namespace_ $node) {
+        if (isset(self::$specialNames[strtolower($node->name)])) {
+            $this->emitError(new Error(
+                sprintf('Cannot use \'%s\' as namespace name', $node->name),
+                $node->name->getAttributes()
+            ));
+        }
+
+        if (null !== $node->stmts) {
+            foreach ($node->stmts as $stmt) {
+                if ($stmt instanceof Namespace_) {
+                    $this->emitError(new Error(
+                        'Namespace declarations cannot be nested', $stmt->getAttributes()
+                    ));
+                }
+            }
+        }
+    }
+
+    protected function checkClass(Class_ $node, $namePos) {
+        if (null !== $node->name && isset(self::$specialNames[strtolower($node->name)])) {
+            $this->emitError(new Error(
+                sprintf('Cannot use \'%s\' as class name as it is reserved', $node->name),
+                $this->getAttributesAt($namePos)
+            ));
+        }
+
+        if (isset(self::$specialNames[strtolower($node->extends)])) {
+            $this->emitError(new Error(
+                sprintf('Cannot use \'%s\' as class name as it is reserved', $node->extends),
+                $node->extends->getAttributes()
+            ));
+        }
+
+        foreach ($node->implements as $interface) {
+            if (isset(self::$specialNames[strtolower($interface)])) {
+                $this->emitError(new Error(
+                    sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
+                    $interface->getAttributes()
+                ));
+            }
+        }
+    }
+
+    protected function checkInterface(Interface_ $node, $namePos) {
+        if (null !== $node->name && isset(self::$specialNames[strtolower($node->name)])) {
+            $this->emitError(new Error(
+                sprintf('Cannot use \'%s\' as class name as it is reserved', $node->name),
+                $this->getAttributesAt($namePos)
+            ));
+        }
+
+        foreach ($node->extends as $interface) {
+            if (isset(self::$specialNames[strtolower($interface)])) {
+                $this->emitError(new Error(
+                    sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
+                    $interface->getAttributes()
+                ));
+            }
+        }
+    }
+
+    protected function checkClassMethod(ClassMethod $node, $modifierPos) {
+        if ($node->flags & Class_::MODIFIER_STATIC) {
+            switch (strtolower($node->name)) {
+                case '__construct':
+                    $this->emitError(new Error(
+                        sprintf('Constructor %s() cannot be static', $node->name),
+                        $this->getAttributesAt($modifierPos)));
+                    break;
+                case '__destruct':
+                    $this->emitError(new Error(
+                        sprintf('Destructor %s() cannot be static', $node->name),
+                        $this->getAttributesAt($modifierPos)));
+                    break;
+                case '__clone':
+                    $this->emitError(new Error(
+                        sprintf('Clone method %s() cannot be static', $node->name),
+                        $this->getAttributesAt($modifierPos)));
+                    break;
+            }
+        }
+    }
+
+    protected function checkClassConst(ClassConst $node, $modifierPos) {
+        if ($node->flags & Class_::MODIFIER_STATIC) {
+            $this->emitError(new Error(
+                "Cannot use 'static' as constant modifier",
+                $this->getAttributesAt($modifierPos)));
+        }
+        if ($node->flags & Class_::MODIFIER_ABSTRACT) {
+            $this->emitError(new Error(
+                "Cannot use 'abstract' as constant modifier",
+                $this->getAttributesAt($modifierPos)));
+        }
+        if ($node->flags & Class_::MODIFIER_FINAL) {
+            $this->emitError(new Error(
+                "Cannot use 'final' as constant modifier",
+                $this->getAttributesAt($modifierPos)));
+        }
+    }
+
+    protected function checkProperty(Property $node, $modifierPos) {
+        if ($node->flags & Class_::MODIFIER_ABSTRACT) {
+            $this->emitError(new Error('Properties cannot be declared abstract',
+                $this->getAttributesAt($modifierPos)));
+        }
+
+        if ($node->flags & Class_::MODIFIER_FINAL) {
+            $this->emitError(new Error('Properties cannot be declared final',
+                $this->getAttributesAt($modifierPos)));
+        }
+    }
+
+    protected function checkUseUse(UseUse $node, $namePos) {
+        if ('self' == strtolower($node->alias) || 'parent' == strtolower($node->alias)) {
+            $this->emitError(new Error(
+                sprintf(
+                    'Cannot use %s as %s because \'%2$s\' is a special class name',
+                    $node->name, $node->alias
+                ),
+                $this->getAttributesAt($namePos)
+            ));
+        }
+    }
 }

lib/PhpParser/PrettyPrinter/Standard.php

@@ -2,22 +2,22 @@
 
 namespace PhpParser\PrettyPrinter;
 
-use PhpParser\PrettyPrinterAbstract;
 use PhpParser\Node;
-use PhpParser\Node\Scalar;
-use PhpParser\Node\Scalar\MagicConst;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\AssignOp;
 use PhpParser\Node\Expr\BinaryOp;
 use PhpParser\Node\Expr\Cast;
-use PhpParser\Node\Stmt;
 use PhpParser\Node\Name;
+use PhpParser\Node\Scalar;
+use PhpParser\Node\Scalar\MagicConst;
+use PhpParser\Node\Stmt;
+use PhpParser\PrettyPrinterAbstract;
 
 class Standard extends PrettyPrinterAbstract
 {
     // Special nodes
 
-    public function pParam(Node\Param $node) {
+    protected function pParam(Node\Param $node) {
         return ($node->type ? $this->pType($node->type) . ' ' : '')
              . ($node->byRef ? '&' : '')
              . ($node->variadic ? '...' : '')
@@ -25,65 +25,69 @@ class Standard extends PrettyPrinterAbstract
              . ($node->default ? ' = ' . $this->p($node->default) : '');
     }
 
-    public function pArg(Node\Arg $node) {
+    protected function pArg(Node\Arg $node) {
         return ($node->byRef ? '&' : '') . ($node->unpack ? '...' : '') . $this->p($node->value);
     }
 
-    public function pConst(Node\Const_ $node) {
+    protected function pConst(Node\Const_ $node) {
         return $node->name . ' = ' . $this->p($node->value);
     }
 
+    protected function pNullableType(Node\NullableType $node) {
+        return '?' . $this->pType($node->type);
+    }
+
     // Names
 
-    public function pName(Name $node) {
+    protected function pName(Name $node) {
         return implode('\\', $node->parts);
     }
 
-    public function pName_FullyQualified(Name\FullyQualified $node) {
+    protected function pName_FullyQualified(Name\FullyQualified $node) {
         return '\\' . implode('\\', $node->parts);
     }
 
-    public function pName_Relative(Name\Relative $node) {
+    protected function pName_Relative(Name\Relative $node) {
         return 'namespace\\' . implode('\\', $node->parts);
     }
 
     // Magic Constants
 
-    public function pScalar_MagicConst_Class(MagicConst\Class_ $node) {
+    protected function pScalar_MagicConst_Class(MagicConst\Class_ $node) {
         return '__CLASS__';
     }
 
-    public function pScalar_MagicConst_Dir(MagicConst\Dir $node) {
+    protected function pScalar_MagicConst_Dir(MagicConst\Dir $node) {
         return '__DIR__';
     }
 
-    public function pScalar_MagicConst_File(MagicConst\File $node) {
+    protected function pScalar_MagicConst_File(MagicConst\File $node) {
         return '__FILE__';
     }
 
-    public function pScalar_MagicConst_Function(MagicConst\Function_ $node) {
+    protected function pScalar_MagicConst_Function(MagicConst\Function_ $node) {
         return '__FUNCTION__';
     }
 
-    public function pScalar_MagicConst_Line(MagicConst\Line $node) {
+    protected function pScalar_MagicConst_Line(MagicConst\Line $node) {
         return '__LINE__';
     }
 
-    public function pScalar_MagicConst_Method(MagicConst\Method $node) {
+    protected function pScalar_MagicConst_Method(MagicConst\Method $node) {
         return '__METHOD__';
     }
 
-    public function pScalar_MagicConst_Namespace(MagicConst\Namespace_ $node) {
+    protected function pScalar_MagicConst_Namespace(MagicConst\Namespace_ $node) {
         return '__NAMESPACE__';
     }
 
-    public function pScalar_MagicConst_Trait(MagicConst\Trait_ $node) {
+    protected function pScalar_MagicConst_Trait(MagicConst\Trait_ $node) {
         return '__TRAIT__';
     }
 
     // Scalars
 
-    public function pScalar_String(Scalar\String_ $node) {
+    protected function pScalar_String(Scalar\String_ $node) {
         $kind = $node->getAttribute('kind', Scalar\String_::KIND_SINGLE_QUOTED);
         switch ($kind) {
             case Scalar\String_::KIND_NOWDOC:
@@ -117,7 +121,7 @@ class Standard extends PrettyPrinterAbstract
         throw new \Exception('Invalid string kind');
     }
 
-    public function pScalar_Encapsed(Scalar\Encapsed $node) {
+    protected function pScalar_Encapsed(Scalar\Encapsed $node) {
         if ($node->getAttribute('kind') === Scalar\String_::KIND_HEREDOC) {
             $label = $node->getAttribute('docLabel');
             if ($label && !$this->encapsedContainsEndLabel($node->parts, $label)) {
@@ -136,22 +140,43 @@ class Standard extends PrettyPrinterAbstract
         return '"' . $this->pEncapsList($node->parts, '"') . '"';
     }
 
-    public function pScalar_LNumber(Scalar\LNumber $node) {
+    protected function pScalar_LNumber(Scalar\LNumber $node) {
+        if ($node->value === -\PHP_INT_MAX-1) {
+            // PHP_INT_MIN cannot be represented as a literal,
+            // because the sign is not part of the literal
+            return '(-' . \PHP_INT_MAX . '-1)';
+        }
+
+        $kind = $node->getAttribute('kind', Scalar\LNumber::KIND_DEC);
+        if (Scalar\LNumber::KIND_DEC === $kind) {
+            return (string) $node->value;
+        }
+
+        $sign = $node->value < 0 ? '-' : '';
         $str = (string) $node->value;
-        switch ($node->getAttribute('kind', Scalar\LNumber::KIND_DEC)) {
+        switch ($kind) {
             case Scalar\LNumber::KIND_BIN:
-                return '0b' . base_convert($str, 10, 2);
+                return $sign . '0b' . base_convert($str, 10, 2);
             case Scalar\LNumber::KIND_OCT:
-                return '0' . base_convert($str, 10, 8);
-            case Scalar\LNumber::KIND_DEC:
-                return $str;
+                return $sign . '0' . base_convert($str, 10, 8);
             case Scalar\LNumber::KIND_HEX:
-                return '0x' . base_convert($str, 10, 16);
+                return $sign . '0x' . base_convert($str, 10, 16);
         }
         throw new \Exception('Invalid number kind');
     }
 
-    public function pScalar_DNumber(Scalar\DNumber $node) {
+    protected function pScalar_DNumber(Scalar\DNumber $node) {
+        if (!is_finite($node->value)) {
+            if ($node->value === \INF) {
+                return '\INF';
+            } elseif ($node->value === -\INF) {
+                return '-\INF';
+            } else {
+                return '\NAN';
+            }
+        }
+
+        // Try to find a short full-precision representation
         $stringValue = sprintf('%.16G', $node->value);
         if ($node->value !== (double) $stringValue) {
             $stringValue = sprintf('%.17G', $node->value);
@@ -163,265 +188,265 @@ class Standard extends PrettyPrinterAbstract
 
     // Assignments
 
-    public function pExpr_Assign(Expr\Assign $node) {
+    protected function pExpr_Assign(Expr\Assign $node) {
         return $this->pInfixOp('Expr_Assign', $node->var, ' = ', $node->expr);
     }
 
-    public function pExpr_AssignRef(Expr\AssignRef $node) {
+    protected function pExpr_AssignRef(Expr\AssignRef $node) {
         return $this->pInfixOp('Expr_AssignRef', $node->var, ' =& ', $node->expr);
     }
 
-    public function pExpr_AssignOp_Plus(AssignOp\Plus $node) {
+    protected function pExpr_AssignOp_Plus(AssignOp\Plus $node) {
         return $this->pInfixOp('Expr_AssignOp_Plus', $node->var, ' += ', $node->expr);
     }
 
-    public function pExpr_AssignOp_Minus(AssignOp\Minus $node) {
+    protected function pExpr_AssignOp_Minus(AssignOp\Minus $node) {
         return $this->pInfixOp('Expr_AssignOp_Minus', $node->var, ' -= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_Mul(AssignOp\Mul $node) {
+    protected function pExpr_AssignOp_Mul(AssignOp\Mul $node) {
         return $this->pInfixOp('Expr_AssignOp_Mul', $node->var, ' *= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_Div(AssignOp\Div $node) {
+    protected function pExpr_AssignOp_Div(AssignOp\Div $node) {
         return $this->pInfixOp('Expr_AssignOp_Div', $node->var, ' /= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_Concat(AssignOp\Concat $node) {
+    protected function pExpr_AssignOp_Concat(AssignOp\Concat $node) {
         return $this->pInfixOp('Expr_AssignOp_Concat', $node->var, ' .= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_Mod(AssignOp\Mod $node) {
+    protected function pExpr_AssignOp_Mod(AssignOp\Mod $node) {
         return $this->pInfixOp('Expr_AssignOp_Mod', $node->var, ' %= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_BitwiseAnd(AssignOp\BitwiseAnd $node) {
+    protected function pExpr_AssignOp_BitwiseAnd(AssignOp\BitwiseAnd $node) {
         return $this->pInfixOp('Expr_AssignOp_BitwiseAnd', $node->var, ' &= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_BitwiseOr(AssignOp\BitwiseOr $node) {
+    protected function pExpr_AssignOp_BitwiseOr(AssignOp\BitwiseOr $node) {
         return $this->pInfixOp('Expr_AssignOp_BitwiseOr', $node->var, ' |= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_BitwiseXor(AssignOp\BitwiseXor $node) {
+    protected function pExpr_AssignOp_BitwiseXor(AssignOp\BitwiseXor $node) {
         return $this->pInfixOp('Expr_AssignOp_BitwiseXor', $node->var, ' ^= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_ShiftLeft(AssignOp\ShiftLeft $node) {
+    protected function pExpr_AssignOp_ShiftLeft(AssignOp\ShiftLeft $node) {
         return $this->pInfixOp('Expr_AssignOp_ShiftLeft', $node->var, ' <<= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_ShiftRight(AssignOp\ShiftRight $node) {
+    protected function pExpr_AssignOp_ShiftRight(AssignOp\ShiftRight $node) {
         return $this->pInfixOp('Expr_AssignOp_ShiftRight', $node->var, ' >>= ', $node->expr);
     }
 
-    public function pExpr_AssignOp_Pow(AssignOp\Pow $node) {
+    protected function pExpr_AssignOp_Pow(AssignOp\Pow $node) {
         return $this->pInfixOp('Expr_AssignOp_Pow', $node->var, ' **= ', $node->expr);
     }
 
     // Binary expressions
 
-    public function pExpr_BinaryOp_Plus(BinaryOp\Plus $node) {
+    protected function pExpr_BinaryOp_Plus(BinaryOp\Plus $node) {
         return $this->pInfixOp('Expr_BinaryOp_Plus', $node->left, ' + ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Minus(BinaryOp\Minus $node) {
+    protected function pExpr_BinaryOp_Minus(BinaryOp\Minus $node) {
         return $this->pInfixOp('Expr_BinaryOp_Minus', $node->left, ' - ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Mul(BinaryOp\Mul $node) {
+    protected function pExpr_BinaryOp_Mul(BinaryOp\Mul $node) {
         return $this->pInfixOp('Expr_BinaryOp_Mul', $node->left, ' * ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Div(BinaryOp\Div $node) {
+    protected function pExpr_BinaryOp_Div(BinaryOp\Div $node) {
         return $this->pInfixOp('Expr_BinaryOp_Div', $node->left, ' / ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Concat(BinaryOp\Concat $node) {
+    protected function pExpr_BinaryOp_Concat(BinaryOp\Concat $node) {
         return $this->pInfixOp('Expr_BinaryOp_Concat', $node->left, ' . ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Mod(BinaryOp\Mod $node) {
+    protected function pExpr_BinaryOp_Mod(BinaryOp\Mod $node) {
         return $this->pInfixOp('Expr_BinaryOp_Mod', $node->left, ' % ', $node->right);
     }
 
-    public function pExpr_BinaryOp_BooleanAnd(BinaryOp\BooleanAnd $node) {
+    protected function pExpr_BinaryOp_BooleanAnd(BinaryOp\BooleanAnd $node) {
         return $this->pInfixOp('Expr_BinaryOp_BooleanAnd', $node->left, ' && ', $node->right);
     }
 
-    public function pExpr_BinaryOp_BooleanOr(BinaryOp\BooleanOr $node) {
+    protected function pExpr_BinaryOp_BooleanOr(BinaryOp\BooleanOr $node) {
         return $this->pInfixOp('Expr_BinaryOp_BooleanOr', $node->left, ' || ', $node->right);
     }
 
-    public function pExpr_BinaryOp_BitwiseAnd(BinaryOp\BitwiseAnd $node) {
+    protected function pExpr_BinaryOp_BitwiseAnd(BinaryOp\BitwiseAnd $node) {
         return $this->pInfixOp('Expr_BinaryOp_BitwiseAnd', $node->left, ' & ', $node->right);
     }
 
-    public function pExpr_BinaryOp_BitwiseOr(BinaryOp\BitwiseOr $node) {
+    protected function pExpr_BinaryOp_BitwiseOr(BinaryOp\BitwiseOr $node) {
         return $this->pInfixOp('Expr_BinaryOp_BitwiseOr', $node->left, ' | ', $node->right);
     }
 
-    public function pExpr_BinaryOp_BitwiseXor(BinaryOp\BitwiseXor $node) {
+    protected function pExpr_BinaryOp_BitwiseXor(BinaryOp\BitwiseXor $node) {
         return $this->pInfixOp('Expr_BinaryOp_BitwiseXor', $node->left, ' ^ ', $node->right);
     }
 
-    public function pExpr_BinaryOp_ShiftLeft(BinaryOp\ShiftLeft $node) {
+    protected function pExpr_BinaryOp_ShiftLeft(BinaryOp\ShiftLeft $node) {
         return $this->pInfixOp('Expr_BinaryOp_ShiftLeft', $node->left, ' << ', $node->right);
     }
 
-    public function pExpr_BinaryOp_ShiftRight(BinaryOp\ShiftRight $node) {
+    protected function pExpr_BinaryOp_ShiftRight(BinaryOp\ShiftRight $node) {
         return $this->pInfixOp('Expr_BinaryOp_ShiftRight', $node->left, ' >> ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Pow(BinaryOp\Pow $node) {
+    protected function pExpr_BinaryOp_Pow(BinaryOp\Pow $node) {
         return $this->pInfixOp('Expr_BinaryOp_Pow', $node->left, ' ** ', $node->right);
     }
 
-    public function pExpr_BinaryOp_LogicalAnd(BinaryOp\LogicalAnd $node) {
+    protected function pExpr_BinaryOp_LogicalAnd(BinaryOp\LogicalAnd $node) {
         return $this->pInfixOp('Expr_BinaryOp_LogicalAnd', $node->left, ' and ', $node->right);
     }
 
-    public function pExpr_BinaryOp_LogicalOr(BinaryOp\LogicalOr $node) {
+    protected function pExpr_BinaryOp_LogicalOr(BinaryOp\LogicalOr $node) {
         return $this->pInfixOp('Expr_BinaryOp_LogicalOr', $node->left, ' or ', $node->right);
     }
 
-    public function pExpr_BinaryOp_LogicalXor(BinaryOp\LogicalXor $node) {
+    protected function pExpr_BinaryOp_LogicalXor(BinaryOp\LogicalXor $node) {
         return $this->pInfixOp('Expr_BinaryOp_LogicalXor', $node->left, ' xor ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Equal(BinaryOp\Equal $node) {
+    protected function pExpr_BinaryOp_Equal(BinaryOp\Equal $node) {
         return $this->pInfixOp('Expr_BinaryOp_Equal', $node->left, ' == ', $node->right);
     }
 
-    public function pExpr_BinaryOp_NotEqual(BinaryOp\NotEqual $node) {
+    protected function pExpr_BinaryOp_NotEqual(BinaryOp\NotEqual $node) {
         return $this->pInfixOp('Expr_BinaryOp_NotEqual', $node->left, ' != ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Identical(BinaryOp\Identical $node) {
+    protected function pExpr_BinaryOp_Identical(BinaryOp\Identical $node) {
         return $this->pInfixOp('Expr_BinaryOp_Identical', $node->left, ' === ', $node->right);
     }
 
-    public function pExpr_BinaryOp_NotIdentical(BinaryOp\NotIdentical $node) {
+    protected function pExpr_BinaryOp_NotIdentical(BinaryOp\NotIdentical $node) {
         return $this->pInfixOp('Expr_BinaryOp_NotIdentical', $node->left, ' !== ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Spaceship(BinaryOp\Spaceship $node) {
+    protected function pExpr_BinaryOp_Spaceship(BinaryOp\Spaceship $node) {
         return $this->pInfixOp('Expr_BinaryOp_Spaceship', $node->left, ' <=> ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Greater(BinaryOp\Greater $node) {
+    protected function pExpr_BinaryOp_Greater(BinaryOp\Greater $node) {
         return $this->pInfixOp('Expr_BinaryOp_Greater', $node->left, ' > ', $node->right);
     }
 
-    public function pExpr_BinaryOp_GreaterOrEqual(BinaryOp\GreaterOrEqual $node) {
+    protected function pExpr_BinaryOp_GreaterOrEqual(BinaryOp\GreaterOrEqual $node) {
         return $this->pInfixOp('Expr_BinaryOp_GreaterOrEqual', $node->left, ' >= ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Smaller(BinaryOp\Smaller $node) {
+    protected function pExpr_BinaryOp_Smaller(BinaryOp\Smaller $node) {
         return $this->pInfixOp('Expr_BinaryOp_Smaller', $node->left, ' < ', $node->right);
     }
 
-    public function pExpr_BinaryOp_SmallerOrEqual(BinaryOp\SmallerOrEqual $node) {
+    protected function pExpr_BinaryOp_SmallerOrEqual(BinaryOp\SmallerOrEqual $node) {
         return $this->pInfixOp('Expr_BinaryOp_SmallerOrEqual', $node->left, ' <= ', $node->right);
     }
 
-    public function pExpr_BinaryOp_Coalesce(BinaryOp\Coalesce $node) {
+    protected function pExpr_BinaryOp_Coalesce(BinaryOp\Coalesce $node) {
         return $this->pInfixOp('Expr_BinaryOp_Coalesce', $node->left, ' ?? ', $node->right);
     }
 
-    public function pExpr_Instanceof(Expr\Instanceof_ $node) {
+    protected function pExpr_Instanceof(Expr\Instanceof_ $node) {
         return $this->pInfixOp('Expr_Instanceof', $node->expr, ' instanceof ', $node->class);
     }
 
     // Unary expressions
 
-    public function pExpr_BooleanNot(Expr\BooleanNot $node) {
+    protected function pExpr_BooleanNot(Expr\BooleanNot $node) {
         return $this->pPrefixOp('Expr_BooleanNot', '!', $node->expr);
     }
 
-    public function pExpr_BitwiseNot(Expr\BitwiseNot $node) {
+    protected function pExpr_BitwiseNot(Expr\BitwiseNot $node) {
         return $this->pPrefixOp('Expr_BitwiseNot', '~', $node->expr);
     }
 
-    public function pExpr_UnaryMinus(Expr\UnaryMinus $node) {
+    protected function pExpr_UnaryMinus(Expr\UnaryMinus $node) {
         return $this->pPrefixOp('Expr_UnaryMinus', '-', $node->expr);
     }
 
-    public function pExpr_UnaryPlus(Expr\UnaryPlus $node) {
+    protected function pExpr_UnaryPlus(Expr\UnaryPlus $node) {
         return $this->pPrefixOp('Expr_UnaryPlus', '+', $node->expr);
     }
 
-    public function pExpr_PreInc(Expr\PreInc $node) {
+    protected function pExpr_PreInc(Expr\PreInc $node) {
         return $this->pPrefixOp('Expr_PreInc', '++', $node->var);
     }
 
-    public function pExpr_PreDec(Expr\PreDec $node) {
+    protected function pExpr_PreDec(Expr\PreDec $node) {
         return $this->pPrefixOp('Expr_PreDec', '--', $node->var);
     }
 
-    public function pExpr_PostInc(Expr\PostInc $node) {
+    protected function pExpr_PostInc(Expr\PostInc $node) {
         return $this->pPostfixOp('Expr_PostInc', $node->var, '++');
     }
 
-    public function pExpr_PostDec(Expr\PostDec $node) {
+    protected function pExpr_PostDec(Expr\PostDec $node) {
         return $this->pPostfixOp('Expr_PostDec', $node->var, '--');
     }
 
-    public function pExpr_ErrorSuppress(Expr\ErrorSuppress $node) {
+    protected function pExpr_ErrorSuppress(Expr\ErrorSuppress $node) {
         return $this->pPrefixOp('Expr_ErrorSuppress', '@', $node->expr);
     }
 
-    public function pExpr_YieldFrom(Expr\YieldFrom $node) {
+    protected function pExpr_YieldFrom(Expr\YieldFrom $node) {
         return $this->pPrefixOp('Expr_YieldFrom', 'yield from ', $node->expr);
     }
 
-    public function pExpr_Print(Expr\Print_ $node) {
+    protected function pExpr_Print(Expr\Print_ $node) {
         return $this->pPrefixOp('Expr_Print', 'print ', $node->expr);
     }
 
     // Casts
 
-    public function pExpr_Cast_Int(Cast\Int_ $node) {
+    protected function pExpr_Cast_Int(Cast\Int_ $node) {
         return $this->pPrefixOp('Expr_Cast_Int', '(int) ', $node->expr);
     }
 
-    public function pExpr_Cast_Double(Cast\Double $node) {
+    protected function pExpr_Cast_Double(Cast\Double $node) {
         return $this->pPrefixOp('Expr_Cast_Double', '(double) ', $node->expr);
     }
 
-    public function pExpr_Cast_String(Cast\String_ $node) {
+    protected function pExpr_Cast_String(Cast\String_ $node) {
         return $this->pPrefixOp('Expr_Cast_String', '(string) ', $node->expr);
     }
 
-    public function pExpr_Cast_Array(Cast\Array_ $node) {
+    protected function pExpr_Cast_Array(Cast\Array_ $node) {
         return $this->pPrefixOp('Expr_Cast_Array', '(array) ', $node->expr);
     }
 
-    public function pExpr_Cast_Object(Cast\Object_ $node) {
+    protected function pExpr_Cast_Object(Cast\Object_ $node) {
         return $this->pPrefixOp('Expr_Cast_Object', '(object) ', $node->expr);
     }
 
-    public function pExpr_Cast_Bool(Cast\Bool_ $node) {
+    protected function pExpr_Cast_Bool(Cast\Bool_ $node) {
         return $this->pPrefixOp('Expr_Cast_Bool', '(bool) ', $node->expr);
     }
 
-    public function pExpr_Cast_Unset(Cast\Unset_ $node) {
+    protected function pExpr_Cast_Unset(Cast\Unset_ $node) {
         return $this->pPrefixOp('Expr_Cast_Unset', '(unset) ', $node->expr);
     }
 
     // Function calls and similar constructs
 
-    public function pExpr_FuncCall(Expr\FuncCall $node) {
+    protected function pExpr_FuncCall(Expr\FuncCall $node) {
         return $this->pCallLhs($node->name)
              . '(' . $this->pCommaSeparated($node->args) . ')';
     }
 
-    public function pExpr_MethodCall(Expr\MethodCall $node) {
+    protected function pExpr_MethodCall(Expr\MethodCall $node) {
         return $this->pDereferenceLhs($node->var) . '->' . $this->pObjectProperty($node->name)
              . '(' . $this->pCommaSeparated($node->args) . ')';
     }
 
-    public function pExpr_StaticCall(Expr\StaticCall $node) {
+    protected function pExpr_StaticCall(Expr\StaticCall $node) {
         return $this->pDereferenceLhs($node->class) . '::'
              . ($node->name instanceof Expr
                 ? ($node->name instanceof Expr\Variable
@@ -431,19 +456,19 @@ class Standard extends PrettyPrinterAbstract
              . '(' . $this->pCommaSeparated($node->args) . ')';
     }
 
-    public function pExpr_Empty(Expr\Empty_ $node) {
+    protected function pExpr_Empty(Expr\Empty_ $node) {
         return 'empty(' . $this->p($node->expr) . ')';
     }
 
-    public function pExpr_Isset(Expr\Isset_ $node) {
+    protected function pExpr_Isset(Expr\Isset_ $node) {
         return 'isset(' . $this->pCommaSeparated($node->vars) . ')';
     }
 
-    public function pExpr_Eval(Expr\Eval_ $node) {
+    protected function pExpr_Eval(Expr\Eval_ $node) {
         return 'eval(' . $this->p($node->expr) . ')';
     }
 
-    public function pExpr_Include(Expr\Include_ $node) {
+    protected function pExpr_Include(Expr\Include_ $node) {
         static $map = array(
             Expr\Include_::TYPE_INCLUDE      => 'include',
             Expr\Include_::TYPE_INCLUDE_ONCE => 'include_once',
@@ -454,22 +479,17 @@ class Standard extends PrettyPrinterAbstract
         return $map[$node->type] . ' ' . $this->p($node->expr);
     }
 
-    public function pExpr_List(Expr\List_ $node) {
-        $pList = array();
-        foreach ($node->vars as $var) {
-            if (null === $var) {
-                $pList[] = '';
-            } else {
-                $pList[] = $this->p($var);
-            }
-        }
-
-        return 'list(' . implode(', ', $pList) . ')';
+    protected function pExpr_List(Expr\List_ $node) {
+        return 'list(' . $this->pCommaSeparated($node->items) . ')';
     }
 
     // Other
 
-    public function pExpr_Variable(Expr\Variable $node) {
+    protected function pExpr_Error(Expr\Error $node) {
+        throw new \LogicException('Cannot pretty-print AST with Error nodes');
+    }
+
+    protected function pExpr_Variable(Expr\Variable $node) {
         if ($node->name instanceof Expr) {
             return '${' . $this->p($node->name) . '}';
         } else {
@@ -477,7 +497,7 @@ class Standard extends PrettyPrinterAbstract
         }
     }
 
-    public function pExpr_Array(Expr\Array_ $node) {
+    protected function pExpr_Array(Expr\Array_ $node) {
         $syntax = $node->getAttribute('kind',
             $this->options['shortArraySyntax'] ? Expr\Array_::KIND_SHORT : Expr\Array_::KIND_LONG);
         if ($syntax === Expr\Array_::KIND_SHORT) {
@@ -487,37 +507,38 @@ class Standard extends PrettyPrinterAbstract
         }
     }
 
-    public function pExpr_ArrayItem(Expr\ArrayItem $node) {
+    protected function pExpr_ArrayItem(Expr\ArrayItem $node) {
         return (null !== $node->key ? $this->p($node->key) . ' => ' : '')
              . ($node->byRef ? '&' : '') . $this->p($node->value);
     }
 
-    public function pExpr_ArrayDimFetch(Expr\ArrayDimFetch $node) {
+    protected function pExpr_ArrayDimFetch(Expr\ArrayDimFetch $node) {
         return $this->pDereferenceLhs($node->var)
              . '[' . (null !== $node->dim ? $this->p($node->dim) : '') . ']';
     }
 
-    public function pExpr_ConstFetch(Expr\ConstFetch $node) {
+    protected function pExpr_ConstFetch(Expr\ConstFetch $node) {
         return $this->p($node->name);
     }
 
-    public function pExpr_ClassConstFetch(Expr\ClassConstFetch $node) {
-        return $this->p($node->class) . '::' . $node->name;
+    protected function pExpr_ClassConstFetch(Expr\ClassConstFetch $node) {
+        return $this->p($node->class) . '::'
+             . (is_string($node->name) ? $node->name : $this->p($node->name));
     }
 
-    public function pExpr_PropertyFetch(Expr\PropertyFetch $node) {
+    protected function pExpr_PropertyFetch(Expr\PropertyFetch $node) {
         return $this->pDereferenceLhs($node->var) . '->' . $this->pObjectProperty($node->name);
     }
 
-    public function pExpr_StaticPropertyFetch(Expr\StaticPropertyFetch $node) {
+    protected function pExpr_StaticPropertyFetch(Expr\StaticPropertyFetch $node) {
         return $this->pDereferenceLhs($node->class) . '::$' . $this->pObjectProperty($node->name);
     }
 
-    public function pExpr_ShellExec(Expr\ShellExec $node) {
+    protected function pExpr_ShellExec(Expr\ShellExec $node) {
         return '`' . $this->pEncapsList($node->parts, '`') . '`';
     }
 
-    public function pExpr_Closure(Expr\Closure $node) {
+    protected function pExpr_Closure(Expr\Closure $node) {
         return ($node->static ? 'static ' : '')
              . 'function ' . ($node->byRef ? '&' : '')
              . '(' . $this->pCommaSeparated($node->params) . ')'
@@ -526,11 +547,11 @@ class Standard extends PrettyPrinterAbstract
              . ' {' . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pExpr_ClosureUse(Expr\ClosureUse $node) {
+    protected function pExpr_ClosureUse(Expr\ClosureUse $node) {
         return ($node->byRef ? '&' : '') . '$' . $node->var;
     }
 
-    public function pExpr_New(Expr\New_ $node) {
+    protected function pExpr_New(Expr\New_ $node) {
         if ($node->class instanceof Stmt\Class_) {
             $args = $node->args ? '(' . $this->pCommaSeparated($node->args) . ')' : '';
             return 'new ' . $this->pClassCommon($node->class, $args);
@@ -538,11 +559,11 @@ class Standard extends PrettyPrinterAbstract
         return 'new ' . $this->p($node->class) . '(' . $this->pCommaSeparated($node->args) . ')';
     }
 
-    public function pExpr_Clone(Expr\Clone_ $node) {
+    protected function pExpr_Clone(Expr\Clone_ $node) {
         return 'clone ' . $this->p($node->expr);
     }
 
-    public function pExpr_Ternary(Expr\Ternary $node) {
+    protected function pExpr_Ternary(Expr\Ternary $node) {
         // a bit of cheating: we treat the ternary as a binary op where the ?...: part is the operator.
         // this is okay because the part between ? and : never needs parentheses.
         return $this->pInfixOp('Expr_Ternary',
@@ -550,13 +571,13 @@ class Standard extends PrettyPrinterAbstract
         );
     }
 
-    public function pExpr_Exit(Expr\Exit_ $node) {
+    protected function pExpr_Exit(Expr\Exit_ $node) {
         $kind = $node->getAttribute('kind', Expr\Exit_::KIND_DIE);
         return ($kind === Expr\Exit_::KIND_EXIT ? 'exit' : 'die')
              . (null !== $node->expr ? '(' . $this->p($node->expr) . ')' : '');
     }
 
-    public function pExpr_Yield(Expr\Yield_ $node) {
+    protected function pExpr_Yield(Expr\Yield_ $node) {
         if ($node->value === null) {
             return 'yield';
         } else {
@@ -570,7 +591,7 @@ class Standard extends PrettyPrinterAbstract
 
     // Declarations
 
-    public function pStmt_Namespace(Stmt\Namespace_ $node) {
+    protected function pStmt_Namespace(Stmt\Namespace_ $node) {
         if ($this->canUseSemicolonNamespaces) {
             return 'namespace ' . $this->p($node->name) . ';' . "\n" . $this->pStmts($node->stmts, false);
         } else {
@@ -579,17 +600,17 @@ class Standard extends PrettyPrinterAbstract
         }
     }
 
-    public function pStmt_Use(Stmt\Use_ $node) {
+    protected function pStmt_Use(Stmt\Use_ $node) {
         return 'use ' . $this->pUseType($node->type)
              . $this->pCommaSeparated($node->uses) . ';';
     }
 
-    public function pStmt_GroupUse(Stmt\GroupUse $node) {
+    protected function pStmt_GroupUse(Stmt\GroupUse $node) {
         return 'use ' . $this->pUseType($node->type) . $this->pName($node->prefix)
              . '\{' . $this->pCommaSeparated($node->uses) . '};';
     }
 
-    public function pStmt_UseUse(Stmt\UseUse $node) {
+    protected function pStmt_UseUse(Stmt\UseUse $node) {
         return $this->pUseType($node->type) . $this->p($node->name)
              . ($node->name->getLast() !== $node->alias ? ' as ' . $node->alias : '');
     }
@@ -599,34 +620,34 @@ class Standard extends PrettyPrinterAbstract
             : ($type === Stmt\Use_::TYPE_CONSTANT ? 'const ' : '');
     }
 
-    public function pStmt_Interface(Stmt\Interface_ $node) {
+    protected function pStmt_Interface(Stmt\Interface_ $node) {
         return 'interface ' . $node->name
              . (!empty($node->extends) ? ' extends ' . $this->pCommaSeparated($node->extends) : '')
              . "\n" . '{' . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_Class(Stmt\Class_ $node) {
+    protected function pStmt_Class(Stmt\Class_ $node) {
         return $this->pClassCommon($node, ' ' . $node->name);
     }
 
-    public function pStmt_Trait(Stmt\Trait_ $node) {
+    protected function pStmt_Trait(Stmt\Trait_ $node) {
         return 'trait ' . $node->name
              . "\n" . '{' . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_TraitUse(Stmt\TraitUse $node) {
+    protected function pStmt_TraitUse(Stmt\TraitUse $node) {
         return 'use ' . $this->pCommaSeparated($node->traits)
              . (empty($node->adaptations)
                 ? ';'
                 : ' {' . $this->pStmts($node->adaptations) . "\n" . '}');
     }
 
-    public function pStmt_TraitUseAdaptation_Precedence(Stmt\TraitUseAdaptation\Precedence $node) {
+    protected function pStmt_TraitUseAdaptation_Precedence(Stmt\TraitUseAdaptation\Precedence $node) {
         return $this->p($node->trait) . '::' . $node->method
              . ' insteadof ' . $this->pCommaSeparated($node->insteadof) . ';';
     }
 
-    public function pStmt_TraitUseAdaptation_Alias(Stmt\TraitUseAdaptation\Alias $node) {
+    protected function pStmt_TraitUseAdaptation_Alias(Stmt\TraitUseAdaptation\Alias $node) {
         return (null !== $node->trait ? $this->p($node->trait) . '::' : '')
              . $node->method . ' as'
              . (null !== $node->newModifier ? ' ' . rtrim($this->pModifiers($node->newModifier), ' ') : '')
@@ -634,17 +655,17 @@ class Standard extends PrettyPrinterAbstract
              . ';';
     }
 
-    public function pStmt_Property(Stmt\Property $node) {
-        return (0 === $node->type ? 'var ' : $this->pModifiers($node->type)) . $this->pCommaSeparated($node->props) . ';';
+    protected function pStmt_Property(Stmt\Property $node) {
+        return (0 === $node->flags ? 'var ' : $this->pModifiers($node->flags)) . $this->pCommaSeparated($node->props) . ';';
     }
 
-    public function pStmt_PropertyProperty(Stmt\PropertyProperty $node) {
+    protected function pStmt_PropertyProperty(Stmt\PropertyProperty $node) {
         return '$' . $node->name
              . (null !== $node->default ? ' = ' . $this->p($node->default) : '');
     }
 
-    public function pStmt_ClassMethod(Stmt\ClassMethod $node) {
-        return $this->pModifiers($node->type)
+    protected function pStmt_ClassMethod(Stmt\ClassMethod $node) {
+        return $this->pModifiers($node->flags)
              . 'function ' . ($node->byRef ? '&' : '') . $node->name
              . '(' . $this->pCommaSeparated($node->params) . ')'
              . (null !== $node->returnType ? ' : ' . $this->pType($node->returnType) : '')
@@ -653,49 +674,50 @@ class Standard extends PrettyPrinterAbstract
                 : ';');
     }
 
-    public function pStmt_ClassConst(Stmt\ClassConst $node) {
-        return 'const ' . $this->pCommaSeparated($node->consts) . ';';
+    protected function pStmt_ClassConst(Stmt\ClassConst $node) {
+        return $this->pModifiers($node->flags)
+             . 'const ' . $this->pCommaSeparated($node->consts) . ';';
     }
 
-    public function pStmt_Function(Stmt\Function_ $node) {
+    protected function pStmt_Function(Stmt\Function_ $node) {
         return 'function ' . ($node->byRef ? '&' : '') . $node->name
              . '(' . $this->pCommaSeparated($node->params) . ')'
              . (null !== $node->returnType ? ' : ' . $this->pType($node->returnType) : '')
              . "\n" . '{' . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_Const(Stmt\Const_ $node) {
+    protected function pStmt_Const(Stmt\Const_ $node) {
         return 'const ' . $this->pCommaSeparated($node->consts) . ';';
     }
 
-    public function pStmt_Declare(Stmt\Declare_ $node) {
+    protected function pStmt_Declare(Stmt\Declare_ $node) {
         return 'declare (' . $this->pCommaSeparated($node->declares) . ')'
              . (null !== $node->stmts ? ' {' . $this->pStmts($node->stmts) . "\n" . '}' : ';');
     }
 
-    public function pStmt_DeclareDeclare(Stmt\DeclareDeclare $node) {
+    protected function pStmt_DeclareDeclare(Stmt\DeclareDeclare $node) {
         return $node->key . '=' . $this->p($node->value);
     }
 
     // Control flow
 
-    public function pStmt_If(Stmt\If_ $node) {
+    protected function pStmt_If(Stmt\If_ $node) {
         return 'if (' . $this->p($node->cond) . ') {'
              . $this->pStmts($node->stmts) . "\n" . '}'
              . $this->pImplode($node->elseifs)
              . (null !== $node->else ? $this->p($node->else) : '');
     }
 
-    public function pStmt_ElseIf(Stmt\ElseIf_ $node) {
+    protected function pStmt_ElseIf(Stmt\ElseIf_ $node) {
         return ' elseif (' . $this->p($node->cond) . ') {'
              . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_Else(Stmt\Else_ $node) {
+    protected function pStmt_Else(Stmt\Else_ $node) {
         return ' else {' . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_For(Stmt\For_ $node) {
+    protected function pStmt_For(Stmt\For_ $node) {
         return 'for ('
              . $this->pCommaSeparated($node->init) . ';' . (!empty($node->cond) ? ' ' : '')
              . $this->pCommaSeparated($node->cond) . ';' . (!empty($node->loop) ? ' ' : '')
@@ -703,102 +725,105 @@ class Standard extends PrettyPrinterAbstract
              . ') {' . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_Foreach(Stmt\Foreach_ $node) {
+    protected function pStmt_Foreach(Stmt\Foreach_ $node) {
         return 'foreach (' . $this->p($node->expr) . ' as '
              . (null !== $node->keyVar ? $this->p($node->keyVar) . ' => ' : '')
              . ($node->byRef ? '&' : '') . $this->p($node->valueVar) . ') {'
              . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_While(Stmt\While_ $node) {
+    protected function pStmt_While(Stmt\While_ $node) {
         return 'while (' . $this->p($node->cond) . ') {'
              . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_Do(Stmt\Do_ $node) {
+    protected function pStmt_Do(Stmt\Do_ $node) {
         return 'do {' . $this->pStmts($node->stmts) . "\n"
              . '} while (' . $this->p($node->cond) . ');';
     }
 
-    public function pStmt_Switch(Stmt\Switch_ $node) {
+    protected function pStmt_Switch(Stmt\Switch_ $node) {
         return 'switch (' . $this->p($node->cond) . ') {'
              . $this->pStmts($node->cases) . "\n" . '}';
     }
 
-    public function pStmt_Case(Stmt\Case_ $node) {
+    protected function pStmt_Case(Stmt\Case_ $node) {
         return (null !== $node->cond ? 'case ' . $this->p($node->cond) : 'default') . ':'
              . $this->pStmts($node->stmts);
     }
 
-    public function pStmt_TryCatch(Stmt\TryCatch $node) {
+    protected function pStmt_TryCatch(Stmt\TryCatch $node) {
         return 'try {' . $this->pStmts($node->stmts) . "\n" . '}'
              . $this->pImplode($node->catches)
-             . ($node->finallyStmts !== null
-                ? ' finally {' . $this->pStmts($node->finallyStmts) . "\n" . '}'
-                : '');
+             . ($node->finally !== null ? $this->p($node->finally) : '');
     }
 
-    public function pStmt_Catch(Stmt\Catch_ $node) {
-        return ' catch (' . $this->p($node->type) . ' $' . $node->var . ') {'
+    protected function pStmt_Catch(Stmt\Catch_ $node) {
+        return ' catch (' . $this->pImplode($node->types, '|') . ' $' . $node->var . ') {'
              . $this->pStmts($node->stmts) . "\n" . '}';
     }
 
-    public function pStmt_Break(Stmt\Break_ $node) {
+    protected function pStmt_Finally(Stmt\Finally_ $node) {
+        return ' finally {' . $this->pStmts($node->stmts) . "\n" . '}';
+    }
+
+    protected function pStmt_Break(Stmt\Break_ $node) {
         return 'break' . ($node->num !== null ? ' ' . $this->p($node->num) : '') . ';';
     }
 
-    public function pStmt_Continue(Stmt\Continue_ $node) {
+    protected function pStmt_Continue(Stmt\Continue_ $node) {
         return 'continue' . ($node->num !== null ? ' ' . $this->p($node->num) : '') . ';';
     }
 
-    public function pStmt_Return(Stmt\Return_ $node) {
+    protected function pStmt_Return(Stmt\Return_ $node) {
         return 'return' . (null !== $node->expr ? ' ' . $this->p($node->expr) : '') . ';';
     }
 
-    public function pStmt_Throw(Stmt\Throw_ $node) {
+    protected function pStmt_Throw(Stmt\Throw_ $node) {
         return 'throw ' . $this->p($node->expr) . ';';
     }
 
-    public function pStmt_Label(Stmt\Label $node) {
+    protected function pStmt_Label(Stmt\Label $node) {
         return $node->name . ':';
     }
 
-    public function pStmt_Goto(Stmt\Goto_ $node) {
+    protected function pStmt_Goto(Stmt\Goto_ $node) {
         return 'goto ' . $node->name . ';';
     }
 
     // Other
 
-    public function pStmt_Echo(Stmt\Echo_ $node) {
+    protected function pStmt_Echo(Stmt\Echo_ $node) {
         return 'echo ' . $this->pCommaSeparated($node->exprs) . ';';
     }
 
-    public function pStmt_Static(Stmt\Static_ $node) {
+    protected function pStmt_Static(Stmt\Static_ $node) {
         return 'static ' . $this->pCommaSeparated($node->vars) . ';';
     }
 
-    public function pStmt_Global(Stmt\Global_ $node) {
+    protected function pStmt_Global(Stmt\Global_ $node) {
         return 'global ' . $this->pCommaSeparated($node->vars) . ';';
     }
 
-    public function pStmt_StaticVar(Stmt\StaticVar $node) {
+    protected function pStmt_StaticVar(Stmt\StaticVar $node) {
         return '$' . $node->name
              . (null !== $node->default ? ' = ' . $this->p($node->default) : '');
     }
 
-    public function pStmt_Unset(Stmt\Unset_ $node) {
+    protected function pStmt_Unset(Stmt\Unset_ $node) {
         return 'unset(' . $this->pCommaSeparated($node->vars) . ');';
     }
 
-    public function pStmt_InlineHTML(Stmt\InlineHTML $node) {
-        return '?>' . $this->pNoIndent("\n" . $node->value) . '<?php ';
+    protected function pStmt_InlineHTML(Stmt\InlineHTML $node) {
+        $newline = $node->getAttribute('hasLeadingNewline', true) ? "\n" : '';
+        return '?>' . $this->pNoIndent($newline . $node->value) . '<?php ';
     }
 
-    public function pStmt_HaltCompiler(Stmt\HaltCompiler $node) {
+    protected function pStmt_HaltCompiler(Stmt\HaltCompiler $node) {
         return '__halt_compiler();' . $node->remaining;
     }
 
-    public function pStmt_Nop(Stmt\Nop $node) {
+    protected function pStmt_Nop(Stmt\Nop $node) {
         return '';
     }
 
@@ -809,7 +834,7 @@ class Standard extends PrettyPrinterAbstract
     }
 
     protected function pClassCommon(Stmt\Class_ $node, $afterClassToken) {
-        return $this->pModifiers($node->type)
+        return $this->pModifiers($node->flags)
         . 'class' . $afterClassToken
         . (null !== $node->extends ? ' extends ' . $this->p($node->extends) : '')
         . (!empty($node->implements) ? ' implements ' . $this->pCommaSeparated($node->implements) : '')

lib/PhpParser/PrettyPrinterAbstract.php

@@ -265,7 +265,11 @@ abstract class PrettyPrinterAbstract
     protected function pImplode(array $nodes, $glue = '') {
         $pNodes = array();
         foreach ($nodes as $node) {
-            $pNodes[] = $this->p($node);
+            if (null === $node) {
+                $pNodes[] = '';
+            } else {
+                $pNodes[] = $this->p($node);
+            }
         }
 
         return implode($glue, $pNodes);

lib/PhpParser/Serializer.php

@@ -2,6 +2,9 @@
 
 namespace PhpParser;
 
+/**
+ * @deprecated
+ */
 interface Serializer
 {
     /**

lib/PhpParser/Serializer/XML.php

@@ -2,11 +2,14 @@
 
 namespace PhpParser\Serializer;
 
-use XMLWriter;
-use PhpParser\Node;
 use PhpParser\Comment;
+use PhpParser\Node;
 use PhpParser\Serializer;
+use XMLWriter;
 
+/**
+ * @deprecated
+ */
 class XML implements Serializer
 {
     protected $writer;

lib/PhpParser/Unserializer.php

@@ -2,6 +2,9 @@
 
 namespace PhpParser;
 
+/**
+ * @deprecated
+ */
 interface Unserializer
 {
     /**

lib/PhpParser/Unserializer/XML.php

@@ -2,10 +2,13 @@
 
 namespace PhpParser\Unserializer;
 
-use XMLReader;
 use DomainException;
 use PhpParser\Unserializer;
+use XMLReader;
 
+/**
+ * @deprecated
+ */
 class XML implements Unserializer
 {
     protected $reader;

test/PhpParser/AutoloaderTest.php

@@ -2,9 +2,6 @@
 
 namespace PhpParser;
 
-use PhpParser\Node\Expr;
-use PhpParser\Node\Scalar;
-
 /* The autoloader is already active at this point, so we only check effects here. */
 
 class AutoloaderTest extends \PHPUnit_Framework_TestCase {

test/PhpParser/Builder/ClassTest.php

@@ -43,7 +43,7 @@ class ClassTest extends \PHPUnit_Framework_TestCase
 
         $this->assertEquals(
             new Stmt\Class_('Test', array(
-                'type' => Stmt\Class_::MODIFIER_ABSTRACT
+                'flags' => Stmt\Class_::MODIFIER_ABSTRACT
             )),
             $node
         );
@@ -57,7 +57,7 @@ class ClassTest extends \PHPUnit_Framework_TestCase
 
         $this->assertEquals(
             new Stmt\Class_('Test', array(
-                'type' => Stmt\Class_::MODIFIER_FINAL
+                'flags' => Stmt\Class_::MODIFIER_FINAL
             )),
             $node
         );

test/PhpParser/Builder/FunctionTest.php

@@ -4,9 +4,9 @@ namespace PhpParser\Builder;
 
 use PhpParser\Comment;
 use PhpParser\Node;
-use PhpParser\Node\Stmt;
 use PhpParser\Node\Expr\Print_;
 use PhpParser\Node\Scalar\String_;
+use PhpParser\Node\Stmt;
 
 class FunctionTest extends \PHPUnit_Framework_TestCase
 {
@@ -78,14 +78,22 @@ class FunctionTest extends \PHPUnit_Framework_TestCase
 
     public function testReturnType() {
         $node = $this->createFunctionBuilder('test')
-            ->setReturnType('bool')
+            ->setReturnType('void')
             ->getNode();
 
         $this->assertEquals(new Stmt\Function_('test', array(
-            'returnType' => 'bool'
+            'returnType' => 'void'
         ), array()), $node);
     }
 
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage void type cannot be nullable
+     */
+    public function testInvalidNullableVoidType() {
+        $this->createFunctionBuilder('test')->setReturnType('?void');
+    }
+
     /**
      * @expectedException \LogicException
      * @expectedExceptionMessage Expected parameter node, got "Name"

test/PhpParser/Builder/InterfaceTest.php

@@ -2,10 +2,10 @@
 
 namespace PhpParser\Builder;
 
-use PhpParser\Node;
-use PhpParser\Node\Stmt;
-use PhpParser\Node\Scalar\DNumber;
 use PhpParser\Comment;
+use PhpParser\Node;
+use PhpParser\Node\Scalar\DNumber;
+use PhpParser\Node\Stmt;
 
 class InterfaceTest extends \PHPUnit_Framework_TestCase
 {

test/PhpParser/Builder/MethodTest.php

@@ -2,11 +2,11 @@
 
 namespace PhpParser\Builder;
 
+use PhpParser\Comment;
 use PhpParser\Node;
 use PhpParser\Node\Expr\Print_;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt;
-use PhpParser\Comment;
 
 class MethodTest extends \PHPUnit_Framework_TestCase
 {
@@ -24,9 +24,9 @@ class MethodTest extends \PHPUnit_Framework_TestCase
 
         $this->assertEquals(
             new Stmt\ClassMethod('test', array(
-                'type' => Stmt\Class_::MODIFIER_PUBLIC
-                        | Stmt\Class_::MODIFIER_ABSTRACT
-                        | Stmt\Class_::MODIFIER_STATIC,
+                'flags' => Stmt\Class_::MODIFIER_PUBLIC
+                         | Stmt\Class_::MODIFIER_ABSTRACT
+                         | Stmt\Class_::MODIFIER_STATIC,
                 'stmts' => null,
             )),
             $node
@@ -40,8 +40,8 @@ class MethodTest extends \PHPUnit_Framework_TestCase
 
         $this->assertEquals(
             new Stmt\ClassMethod('test', array(
-                'type' => Stmt\Class_::MODIFIER_PROTECTED
-                        | Stmt\Class_::MODIFIER_FINAL
+                'flags' => Stmt\Class_::MODIFIER_PROTECTED
+                         | Stmt\Class_::MODIFIER_FINAL
             )),
             $node
         );

test/PhpParser/Builder/ParamTest.php

@@ -78,36 +78,70 @@ class ParamTest extends \PHPUnit_Framework_TestCase
         );
     }
 
-    public function testTypeHints() {
+    /**
+     * @dataProvider provideTestTypeHints
+     */
+    public function testTypeHints($typeHint, $expectedType) {
         $node = $this->createParamBuilder('test')
-            ->setTypeHint('array')
+            ->setTypeHint($typeHint)
             ->getNode()
         ;
+        $type = $node->type;
 
-        $this->assertEquals(
-            new Node\Param('test', null, 'array'),
-            $node
+        /* Manually implement comparison to avoid __toString stupidity */
+        if ($expectedType instanceof Node\NullableType) {
+            $this->assertInstanceOf(get_class($expectedType), $type);
+            $expectedType = $expectedType->type;
+            $type = $type->type;
+        }
+
+        if ($expectedType instanceof Node\Name) {
+            $this->assertInstanceOf(get_class($expectedType), $type);
+            $this->assertEquals($expectedType, $type);
+        } else {
+            $this->assertSame($expectedType, $type);
+        }
+    }
+
+    public function provideTestTypeHints() {
+        return array(
+            array('array', 'array'),
+            array('callable', 'callable'),
+            array('bool', 'bool'),
+            array('int', 'int'),
+            array('float', 'float'),
+            array('string', 'string'),
+            array('iterable', 'iterable'),
+            array('Array', 'array'),
+            array('CALLABLE', 'callable'),
+            array('Some\Class', new Node\Name('Some\Class')),
+            array('\Foo', new Node\Name\FullyQualified('Foo')),
+            array('self', new Node\Name('self')),
+            array('?array', new Node\NullableType('array')),
+            array('?Some\Class', new Node\NullableType(new Node\Name('Some\Class'))),
+            array(new Node\Name('Some\Class'), new Node\Name('Some\Class')),
+            array(new Node\NullableType('int'), new Node\NullableType('int')),
+            array(
+                new Node\NullableType(new Node\Name('Some\Class')),
+                new Node\NullableType(new Node\Name('Some\Class'))
+            ),
         );
+    }
 
-        $node = $this->createParamBuilder('test')
-            ->setTypeHint('callable')
-            ->getNode()
-        ;
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Parameter type cannot be void
+     */
+    public function testVoidTypeError() {
+        $this->createParamBuilder('test')->setTypeHint('void');
+    }
 
-        $this->assertEquals(
-            new Node\Param('test', null, 'callable'),
-            $node
-        );
-
-        $node = $this->createParamBuilder('test')
-            ->setTypeHint('Some\Class')
-            ->getNode()
-        ;
-
-        $this->assertEquals(
-            new Node\Param('test', null, new Node\Name('Some\Class')),
-            $node
-        );
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Type must be a string, or an instance of Name or NullableType
+     */
+    public function testInvalidTypeError() {
+        $this->createParamBuilder('test')->setTypeHint(new \stdClass);
     }
 
     public function testByRef() {

test/PhpParser/Builder/PropertyTest.php

@@ -2,11 +2,11 @@
 
 namespace PhpParser\Builder;
 
-use PhpParser\Node\Name;
-use PhpParser\Node\Stmt;
-use PhpParser\Node\Expr;
-use PhpParser\Node\Scalar;
 use PhpParser\Comment;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar;
+use PhpParser\Node\Stmt;
 
 class PropertyTest extends \PHPUnit_Framework_TestCase
 {

test/PhpParser/Builder/TraitTest.php

@@ -3,8 +3,6 @@
 namespace PhpParser\Builder;
 
 use PhpParser\Comment;
-use PhpParser\Node;
-use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
 
 class TraitTest extends \PHPUnit_Framework_TestCase
@@ -27,7 +25,7 @@ class TraitTest extends \PHPUnit_Framework_TestCase
             ->addStmt($prop)
             ->getNode();
         $this->assertEquals(new Stmt\Trait_('TestTrait', array(
-            $prop, $method1, $method2, $method3
+            'stmts' => array($prop, $method1, $method2, $method3)
         ), array(
             'comments' => array(
                 new Comment\Doc('/** Nice trait */')

test/PhpParser/CodeParsingTest.php

@@ -2,8 +2,6 @@
 
 namespace PhpParser;
 
-use PhpParser\Comment;
-
 require_once __DIR__ . '/CodeTestAbstract.php';
 
 class CodeParsingTest extends CodeTestAbstract
@@ -11,24 +9,28 @@ class CodeParsingTest extends CodeTestAbstract
     /**
      * @dataProvider provideTestParse
      */
-    public function testParse($name, $code, $expected, $mode) {
+    public function testParse($name, $code, $expected, $modeLine) {
+        if (null !== $modeLine) {
+            $modes = array_fill_keys(explode(',', $modeLine), true);
+        } else {
+            $modes = [];
+        }
+
+
         $lexer = new Lexer\Emulative(array('usedAttributes' => array(
             'startLine', 'endLine', 'startFilePos', 'endFilePos', 'comments'
         )));
-        $parser5 = new Parser\Php5($lexer, array(
-            'throwOnError' => false,
-        ));
-        $parser7 = new Parser\Php7($lexer, array(
-            'throwOnError' => false,
-        ));
+        $parser5 = new Parser\Php5($lexer);
+        $parser7 = new Parser\Php7($lexer);
 
-        $output5 = $this->getParseOutput($parser5, $code);
-        $output7 = $this->getParseOutput($parser7, $code);
+        $dumpPositions = isset($modes['positions']);
+        $output5 = $this->getParseOutput($parser5, $code, $dumpPositions);
+        $output7 = $this->getParseOutput($parser7, $code, $dumpPositions);
 
-        if ($mode === 'php5') {
+        if (isset($modes['php5'])) {
             $this->assertSame($expected, $output5, $name);
             $this->assertNotSame($expected, $output7, $name);
-        } else if ($mode === 'php7') {
+        } else if (isset($modes['php7'])) {
             $this->assertNotSame($expected, $output5, $name);
             $this->assertSame($expected, $output7, $name);
         } else {
@@ -37,18 +39,18 @@ class CodeParsingTest extends CodeTestAbstract
         }
     }
 
-    private function getParseOutput(Parser $parser, $code) {
-        $stmts = $parser->parse($code);
-        $errors = $parser->getErrors();
+    private function getParseOutput(Parser $parser, $code, $dumpPositions) {
+        $errors = new ErrorHandler\Collecting;
+        $stmts = $parser->parse($code, $errors);
 
         $output = '';
-        foreach ($errors as $error) {
+        foreach ($errors->getErrors() as $error) {
             $output .= $this->formatErrorMessage($error, $code) . "\n";
         }
 
         if (null !== $stmts) {
-            $dumper = new NodeDumper(['dumpComments' => true]);
-            $output .= $dumper->dump($stmts);
+            $dumper = new NodeDumper(['dumpComments' => true, 'dumpPositions' => $dumpPositions]);
+            $output .= $dumper->dump($stmts, $code);
         }
 
         return canonicalize($output);
@@ -60,8 +62,7 @@ class CodeParsingTest extends CodeTestAbstract
 
     private function formatErrorMessage(Error $e, $code) {
         if ($e->hasColumnInfo()) {
-            return $e->getRawMessage() . ' from ' . $e->getStartLine() . ':' . $e->getStartColumn($code)
-                . ' to ' . $e->getEndLine() . ':' . $e->getEndColumn($code);
+            return $e->getMessageWithColumnInfo($code);
         } else {
             return $e->getMessage();
         }

test/PhpParser/CommentTest.php

@@ -11,13 +11,6 @@ class CommentTest extends \PHPUnit_Framework_TestCase
         $this->assertSame('/* Some comment */', (string) $comment);
         $this->assertSame(1, $comment->getLine());
         $this->assertSame(10, $comment->getFilePos());
-
-        $comment->setText('/* Some other comment */');
-        $comment->setLine(10);
-
-        $this->assertSame('/* Some other comment */', $comment->getText());
-        $this->assertSame('/* Some other comment */', (string) $comment);
-        $this->assertSame(10, $comment->getLine());
     }
 
     /**

test/PhpParser/ErrorHandler/CollectingTest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace PhpParser\ErrorHandler;
+
+use PhpParser\Error;
+
+class CollectingTest extends \PHPUnit_Framework_TestCase {
+    public function testHandleError() {
+        $errorHandler = new Collecting();
+        $this->assertFalse($errorHandler->hasErrors());
+        $this->assertEmpty($errorHandler->getErrors());
+
+        $errorHandler->handleError($e1 = new Error('Test 1'));
+        $errorHandler->handleError($e2 = new Error('Test 2'));
+        $this->assertTrue($errorHandler->hasErrors());
+        $this->assertSame([$e1, $e2], $errorHandler->getErrors());
+
+        $errorHandler->clearErrors();
+        $this->assertFalse($errorHandler->hasErrors());
+        $this->assertEmpty($errorHandler->getErrors());
+    }
+}

test/PhpParser/ErrorHandler/ThrowingTest.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace PhpParser\ErrorHandler;
+
+use PhpParser\Error;
+
+class ThrowingTest extends \PHPUnit_Framework_TestCase {
+    /**
+     * @expectedException \PhpParser\Error
+     * @expectedExceptionMessage Test
+     */
+    public function testHandleError() {
+        $errorHandler = new Throwing();
+        $errorHandler->handleError(new Error('Test'));
+    }
+}

test/PhpParser/ErrorTest.php

@@ -15,7 +15,6 @@ class ErrorTest extends \PHPUnit_Framework_TestCase
         $this->assertSame($attributes, $error->getAttributes());
         $this->assertSame(10, $error->getStartLine());
         $this->assertSame(11, $error->getEndLine());
-        $this->assertSame(10, $error->getRawLine());
         $this->assertSame('Some error on line 10', $error->getMessage());
 
         return $error;
@@ -31,10 +30,6 @@ class ErrorTest extends \PHPUnit_Framework_TestCase
         $error->setStartLine(15);
         $this->assertSame(15, $error->getStartLine());
         $this->assertSame('Some other error on line 15', $error->getMessage());
-
-        $error->setRawLine(17);
-        $this->assertSame(17, $error->getRawLine());
-        $this->assertSame('Some other error on line 17', $error->getMessage());
     }
 
     public function testUnknownLine() {
@@ -42,7 +37,6 @@ class ErrorTest extends \PHPUnit_Framework_TestCase
 
         $this->assertSame(-1, $error->getStartLine());
         $this->assertSame(-1, $error->getEndLine());
-        $this->assertSame(-1, $error->getRawLine());
         $this->assertSame('Some error on unknown line', $error->getMessage());
     }
 

test/PhpParser/LexerTest.php

@@ -14,28 +14,36 @@ class LexerTest extends \PHPUnit_Framework_TestCase
     /**
      * @dataProvider provideTestError
      */
-    public function testError($code, $message) {
+    public function testError($code, $messages) {
         if (defined('HHVM_VERSION')) {
             $this->markTestSkipped('HHVM does not throw warnings from token_get_all()');
         }
 
-        $lexer = $this->getLexer();
-        try {
-            $lexer->startLexing($code);
-        } catch (Error $e) {
-            $this->assertSame($message, $e->getMessage());
+        $errorHandler = new ErrorHandler\Collecting();
+        $lexer = $this->getLexer(['usedAttributes' => [
+            'comments', 'startLine', 'endLine', 'startFilePos', 'endFilePos'
+        ]]);
+        $lexer->startLexing($code, $errorHandler);
+        $errors = $errorHandler->getErrors();
 
-            return;
+        $this->assertSame(count($messages), count($errors));
+        for ($i = 0; $i < count($messages); $i++) {
+            $this->assertSame($messages[$i], $errors[$i]->getMessageWithColumnInfo($code));
         }
-
-        $this->fail('Expected PhpParser\Error');
     }
 
     public function provideTestError() {
         return array(
-            array('<?php /*', 'Unterminated comment on line 1'),
-            array('<?php ' . "\1", 'Unexpected character "' . "\1" . '" (ASCII 1) on unknown line'),
-            array('<?php ' . "\0", 'Unexpected null byte on unknown line'),
+            array("<?php /*", array("Unterminated comment from 1:7 to 1:9")),
+            array("<?php \1", array("Unexpected character \"\1\" (ASCII 1) from 1:7 to 1:7")),
+            array("<?php \0", array("Unexpected null byte from 1:7 to 1:7")),
+            // Error with potentially emulated token
+            array("<?php ?? \0", array("Unexpected null byte from 1:10 to 1:10")),
+            array("<?php\n\0\1 foo /* bar", array(
+                "Unexpected null byte from 2:1 to 2:1",
+                "Unexpected character \"\1\" (ASCII 1) from 2:2 to 2:2",
+                "Unterminated comment from 2:8 to 2:14"
+            )),
         );
     }
 
@@ -72,7 +80,8 @@ class LexerTest extends \PHPUnit_Framework_TestCase
                     ),
                     array(
                         Tokens::T_INLINE_HTML, 'plaintext',
-                        array('startLine' => 1), array('endLine' => 1)
+                        array('startLine' => 1, 'hasLeadingNewline' => false),
+                        array('endLine' => 1)
                     ),
                 )
             ),

test/PhpParser/Node/NameTest.php

@@ -10,6 +10,9 @@ class NameTest extends \PHPUnit_Framework_TestCase
 
         $name = new Name('foo\bar');
         $this->assertSame(array('foo', 'bar'), $name->parts);
+
+        $name = new Name($name);
+        $this->assertSame(array('foo', 'bar'), $name->parts);
     }
 
     public function testGet() {
@@ -27,89 +30,56 @@ class NameTest extends \PHPUnit_Framework_TestCase
 
         $this->assertSame('foo\bar', (string) $name);
         $this->assertSame('foo\bar', $name->toString());
-        $this->assertSame('foo_bar', $name->toString('_'));
-    }
-
-    public function testSet() {
-        $name = new Name('foo');
-
-        $name->set('foo\bar');
-        $this->assertSame('foo\bar', $name->toString());
-
-        $name->set(array('foo', 'bar'));
-        $this->assertSame('foo\bar', $name->toString());
-
-        $name->set(new Name('foo\bar'));
-        $this->assertSame('foo\bar', $name->toString());
-    }
-
-    public function testSetFirst() {
-        $name = new Name('foo');
-
-        $name->setFirst('bar');
-        $this->assertSame('bar', $name->toString());
-
-        $name->setFirst('A\B');
-        $this->assertSame('A\B', $name->toString());
-
-        $name->setFirst('C');
-        $this->assertSame('C\B', $name->toString());
-
-        $name->setFirst('D\E');
-        $this->assertSame('D\E\B', $name->toString());
-    }
-
-    public function testSetLast() {
-        $name = new Name('foo');
-
-        $name->setLast('bar');
-        $this->assertSame('bar', $name->toString());
-
-        $name->setLast('A\B');
-        $this->assertSame('A\B', $name->toString());
-
-        $name->setLast('C');
-        $this->assertSame('A\C', $name->toString());
-
-        $name->setLast('D\E');
-        $this->assertSame('A\D\E', $name->toString());
-    }
-
-    public function testAppend() {
-        $name = new Name('foo');
-
-        $name->append('bar');
-        $this->assertSame('foo\bar', $name->toString());
-
-        $name->append('bar\foo');
-        $this->assertSame('foo\bar\bar\foo', $name->toString());
-    }
-
-    public function testPrepend() {
-        $name = new Name('foo');
-
-        $name->prepend('bar');
-        $this->assertSame('bar\foo', $name->toString());
-
-        $name->prepend('foo\bar');
-        $this->assertSame('foo\bar\bar\foo', $name->toString());
     }
 
     public function testSlice() {
-        $name = new Name('foo\bar');
-        $this->assertEquals(new Name('foo\bar'), $name->slice(0));
-        $this->assertEquals(new Name('bar'), $name->slice(1));
-        $this->assertEquals(new Name([]), $name->slice(2));
+        $name = new Name('foo\bar\baz');
+        $this->assertEquals(new Name('foo\bar\baz'), $name->slice(0));
+        $this->assertEquals(new Name('bar\baz'), $name->slice(1));
+        $this->assertNull($name->slice(3));
+        $this->assertEquals(new Name('foo\bar\baz'), $name->slice(-3));
+        $this->assertEquals(new Name('bar\baz'), $name->slice(-2));
+        $this->assertEquals(new Name('foo\bar'), $name->slice(0, -1));
+        $this->assertNull($name->slice(0, -3));
+        $this->assertEquals(new Name('bar'), $name->slice(1, -1));
+        $this->assertNull($name->slice(1, -2));
+        $this->assertEquals(new Name('bar'), $name->slice(-2, 1));
+        $this->assertEquals(new Name('bar'), $name->slice(-2, -1));
+        $this->assertNull($name->slice(-2, -2));
     }
 
     /**
      * @expectedException \OutOfBoundsException
      * @expectedExceptionMessage Offset 4 is out of bounds
      */
-    public function testSliceException() {
+    public function testSliceOffsetTooLarge() {
         (new Name('foo\bar\baz'))->slice(4);
     }
 
+    /**
+     * @expectedException \OutOfBoundsException
+     * @expectedExceptionMessage Offset -4 is out of bounds
+     */
+    public function testSliceOffsetTooSmall() {
+        (new Name('foo\bar\baz'))->slice(-4);
+    }
+
+    /**
+     * @expectedException \OutOfBoundsException
+     * @expectedExceptionMessage Length 4 is out of bounds
+     */
+    public function testSliceLengthTooLarge() {
+        (new Name('foo\bar\baz'))->slice(0, 4);
+    }
+
+    /**
+     * @expectedException \OutOfBoundsException
+     * @expectedExceptionMessage Length -4 is out of bounds
+     */
+    public function testSliceLengthTooSmall() {
+        (new Name('foo\bar\baz'))->slice(0, -4);
+    }
+
     public function testConcat() {
         $this->assertEquals(new Name('foo\bar\baz'), Name::concat('foo', 'bar\baz'));
         $this->assertEquals(
@@ -123,8 +93,9 @@ class NameTest extends \PHPUnit_Framework_TestCase
             Name\Relative::concat(new Name\FullyQualified('foo\bar'), 'baz', $attributes)
         );
 
-        $this->assertEquals(new Name('foo'), Name::concat([], 'foo'));
-        $this->assertEquals(new Name([]), Name::concat([], []));
+        $this->assertEquals(new Name('foo'), Name::concat(null, 'foo'));
+        $this->assertEquals(new Name('foo'), Name::concat('foo', null));
+        $this->assertNull(Name::concat(null, null));
     }
 
     public function testIs() {
@@ -155,10 +126,9 @@ class NameTest extends \PHPUnit_Framework_TestCase
 
     /**
      * @expectedException        \InvalidArgumentException
-     * @expectedExceptionMessage When changing a name you need to pass either a string, an array or a Name node
+     * @expectedExceptionMessage Expected string, array of parts or Name instance
      */
     public function testInvalidArg() {
-        $name = new Name('foo');
-        $name->set(new \stdClass);
+        Name::concat('foo', new \stdClass);
     }
 }

test/PhpParser/Node/Stmt/ClassConstTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+class ClassConstTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @dataProvider provideModifiers
+     */
+    public function testModifiers($modifier) {
+        $node = new ClassConst(
+            array(), // invalid
+            constant('PhpParser\Node\Stmt\Class_::MODIFIER_' . strtoupper($modifier))
+        );
+
+        $this->assertTrue($node->{'is' . $modifier}());
+    }
+
+    public function testNoModifiers() {
+        $node = new ClassConst(array(), 0);
+
+        $this->assertTrue($node->isPublic());
+        $this->assertFalse($node->isProtected());
+        $this->assertFalse($node->isPrivate());
+        $this->assertFalse($node->isStatic());
+    }
+
+    public function provideModifiers() {
+        return array(
+            array('public'),
+            array('protected'),
+            array('private'),
+        );
+    }
+}

test/PhpParser/Node/Stmt/ClassTest.php

@@ -56,4 +56,11 @@ class ClassTest extends \PHPUnit_Framework_TestCase
         $this->assertSame($methodTest, $class->getMethod('test'));
         $this->assertNull($class->getMethod('nonExisting'));
     }
+
+    public function testDeprecatedTypeNode() {
+        $class = new Class_('Foo', array('type' => Class_::MODIFIER_ABSTRACT));
+        $this->assertTrue($class->isAbstract());
+        $this->assertSame(Class_::MODIFIER_ABSTRACT, $class->flags);
+        $this->assertSame(Class_::MODIFIER_ABSTRACT, $class->type);
+    }
 }

test/PhpParser/NodeAbstractTest.php

@@ -70,6 +70,28 @@ class NodeAbstractTest extends \PHPUnit_Framework_TestCase
         $this->assertNull($node->getDocComment());
     }
 
+    public function testSetDocComment() {
+        $node = new DummyNode(null, null, []);
+
+        // Add doc comment to node without comments
+        $docComment = new Comment\Doc('/** doc */');
+        $node->setDocComment($docComment);
+        $this->assertSame($docComment, $node->getDocComment());
+
+        // Replace it
+        $docComment = new Comment\Doc('/** doc 2 */');
+        $node->setDocComment($docComment);
+        $this->assertSame($docComment, $node->getDocComment());
+
+        // Add docmment to node with other comments
+        $c1 = new Comment('/* foo */');
+        $c2 = new Comment('/* bar */');
+        $docComment = new Comment\Doc('/** baz */');
+        $node->setAttribute('comments', [$c1, $c2]);
+        $node->setDocComment($docComment);
+        $this->assertSame([$c1, $c2, $docComment], $node->getAttribute('comments'));
+    }
+
     /**
      * @dataProvider provideNodes
      */
@@ -144,4 +166,109 @@ class NodeAbstractTest extends \PHPUnit_Framework_TestCase
             $node->getAttributes()
         );
     }
+
+    public function testJsonSerialization() {
+        $code = <<<'PHP'
+<?php
+// comment
+/** doc comment */
+function functionName(&$a = 0, $b = 1.0) {
+    echo 'Foo';
+}
+PHP;
+        $expected = <<<'JSON'
+[
+    {
+        "nodeType": "Stmt_Function",
+        "byRef": false,
+        "name": "functionName",
+        "params": [
+            {
+                "nodeType": "Param",
+                "type": null,
+                "byRef": true,
+                "variadic": false,
+                "name": "a",
+                "default": {
+                    "nodeType": "Scalar_LNumber",
+                    "value": 0,
+                    "attributes": {
+                        "startLine": 4,
+                        "endLine": 4,
+                        "kind": 10
+                    }
+                },
+                "attributes": {
+                    "startLine": 4,
+                    "endLine": 4
+                }
+            },
+            {
+                "nodeType": "Param",
+                "type": null,
+                "byRef": false,
+                "variadic": false,
+                "name": "b",
+                "default": {
+                    "nodeType": "Scalar_DNumber",
+                    "value": 1,
+                    "attributes": {
+                        "startLine": 4,
+                        "endLine": 4
+                    }
+                },
+                "attributes": {
+                    "startLine": 4,
+                    "endLine": 4
+                }
+            }
+        ],
+        "returnType": null,
+        "stmts": [
+            {
+                "nodeType": "Stmt_Echo",
+                "exprs": [
+                    {
+                        "nodeType": "Scalar_String",
+                        "value": "Foo",
+                        "attributes": {
+                            "startLine": 5,
+                            "endLine": 5,
+                            "kind": 1
+                        }
+                    }
+                ],
+                "attributes": {
+                    "startLine": 5,
+                    "endLine": 5
+                }
+            }
+        ],
+        "attributes": {
+            "startLine": 4,
+            "comments": [
+                {
+                    "nodeType": "Comment",
+                    "text": "\/\/ comment\n",
+                    "line": 2,
+                    "filePos": 6
+                },
+                {
+                    "nodeType": "Comment_Doc",
+                    "text": "\/** doc comment *\/",
+                    "line": 3,
+                    "filePos": 17
+                }
+            ],
+            "endLine": 6
+        }
+    }
+]
+JSON;
+
+        $parser = new Parser\Php7(new Lexer());
+        $stmts = $parser->parse(canonicalize($code));
+        $json = json_encode($stmts, JSON_PRETTY_PRINT);
+        $this->assertEquals(canonicalize($expected), canonicalize($json));
+    }
 }

test/PhpParser/NodeDumperTest.php

@@ -10,7 +10,6 @@ class NodeDumperTest extends \PHPUnit_Framework_TestCase
 
     /**
      * @dataProvider provideTestDump
-     * @covers PhpParser\NodeDumper::dump
      */
     public function testDump($node, $dump) {
         $dumper = new NodeDumper;
@@ -61,6 +60,40 @@ class NodeDumperTest extends \PHPUnit_Framework_TestCase
         );
     }
 
+    public function testDumpWithPositions() {
+        $parser = (new ParserFactory)->create(
+            ParserFactory::ONLY_PHP7,
+            new Lexer(['usedAttributes' => ['startLine', 'endLine', 'startFilePos', 'endFilePos']])
+        );
+        $dumper = new NodeDumper(['dumpPositions' => true]);
+
+        $code = "<?php\n\$a = 1;\necho \$a;";
+        $expected = <<<'OUT'
+array(
+    0: Expr_Assign[2:1 - 2:6](
+        var: Expr_Variable[2:1 - 2:2](
+            name: a
+        )
+        expr: Scalar_LNumber[2:6 - 2:6](
+            value: 1
+        )
+    )
+    1: Stmt_Echo[3:1 - 3:8](
+        exprs: array(
+            0: Expr_Variable[3:6 - 3:7](
+                name: a
+            )
+        )
+    )
+)
+OUT;
+
+        $stmts = $parser->parse($code);
+        $dump = $dumper->dump($stmts, $code);
+
+        $this->assertSame($this->canonicalize($expected), $this->canonicalize($dump));
+    }
+
     /**
      * @expectedException        \InvalidArgumentException
      * @expectedExceptionMessage Can only dump nodes and arrays.

test/PhpParser/NodeTraverserTest.php

@@ -2,8 +2,8 @@
 
 namespace PhpParser;
 
-use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Scalar\String_;
 
 class NodeTraverserTest extends \PHPUnit_Framework_TestCase
 {
@@ -13,7 +13,7 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
         $echoNode = new Node\Stmt\Echo_(array($str1Node, $str2Node));
         $stmts    = array($echoNode);
 
-        $visitor = $this->getMock('PhpParser\NodeVisitor');
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
 
         $visitor->expects($this->at(0))->method('beforeTraverse')->with($stmts);
         $visitor->expects($this->at(1))->method('enterNode')->with($echoNode);
@@ -36,8 +36,8 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
         $printNode = new Expr\Print_($str1Node);
 
         // first visitor changes the node, second verifies the change
-        $visitor1 = $this->getMock('PhpParser\NodeVisitor');
-        $visitor2 = $this->getMock('PhpParser\NodeVisitor');
+        $visitor1 = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor2 = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
 
         // replace empty statements with string1 node
         $visitor1->expects($this->at(0))->method('beforeTraverse')->with(array())
@@ -81,7 +81,7 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
         $str1Node = new String_('Foo');
         $str2Node = new String_('Bar');
 
-        $visitor = $this->getMock('PhpParser\NodeVisitor');
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
 
         // remove the string1 node, leave the string2 node
         $visitor->expects($this->at(2))->method('leaveNode')->with($str1Node)
@@ -100,7 +100,7 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
         $strR1     = new String_('Replacement 1');
         $strR2     = new String_('Replacement 2');
 
-        $visitor = $this->getMock('PhpParser\NodeVisitor');
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
 
         // replace strMiddle with strR1 and strR2 by merge
         $visitor->expects($this->at(4))->method('leaveNode')->with($strMiddle)
@@ -119,7 +119,7 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
         $strNode = new String_('Foo');
         $stmts = array(array(array($strNode)));
 
-        $visitor = $this->getMock('PhpParser\NodeVisitor');
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
         $visitor->expects($this->at(1))->method('enterNode')->with($strNode);
 
         $traverser = new NodeTraverser;
@@ -136,8 +136,8 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
         $negNode = new Expr\UnaryMinus($mulNode);
         $stmts = array($printNode, $negNode);
 
-        $visitor1 = $this->getMock('PhpParser\NodeVisitor');
-        $visitor2 = $this->getMock('PhpParser\NodeVisitor');
+        $visitor1 = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor2 = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
 
         $visitor1->expects($this->at(1))->method('enterNode')->with($printNode)
             ->will($this->returnValue(NodeTraverser::DONT_TRAVERSE_CHILDREN));
@@ -166,10 +166,67 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
         $this->assertEquals($stmts, $traverser->traverse($stmts));
     }
 
+    public function testStopTraversal() {
+        $varNode1 = new Expr\Variable('a');
+        $varNode2 = new Expr\Variable('b');
+        $varNode3 = new Expr\Variable('c');
+        $mulNode = new Expr\BinaryOp\Mul($varNode1, $varNode2);
+        $printNode = new Expr\Print_($varNode3);
+        $stmts = [$mulNode, $printNode];
+
+        // From enterNode() with array parent
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor->expects($this->at(1))->method('enterNode')->with($mulNode)
+            ->will($this->returnValue(NodeTraverser::STOP_TRAVERSAL));
+        $visitor->expects($this->at(2))->method('afterTraversal');
+        $traverser = new NodeTraverser;
+        $traverser->addVisitor($visitor);
+        $this->assertEquals($stmts, $traverser->traverse($stmts));
+
+        // From enterNode with Node parent
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor->expects($this->at(2))->method('enterNode')->with($varNode1)
+            ->will($this->returnValue(NodeTraverser::STOP_TRAVERSAL));
+        $visitor->expects($this->at(3))->method('afterTraversal');
+        $traverser = new NodeTraverser;
+        $traverser->addVisitor($visitor);
+        $this->assertEquals($stmts, $traverser->traverse($stmts));
+
+        // From leaveNode with Node parent
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor->expects($this->at(3))->method('leaveNode')->with($varNode1)
+            ->will($this->returnValue(NodeTraverser::STOP_TRAVERSAL));
+        $visitor->expects($this->at(4))->method('afterTraversal');
+        $traverser = new NodeTraverser;
+        $traverser->addVisitor($visitor);
+        $this->assertEquals($stmts, $traverser->traverse($stmts));
+
+        // From leaveNode with array parent
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor->expects($this->at(6))->method('leaveNode')->with($mulNode)
+            ->will($this->returnValue(NodeTraverser::STOP_TRAVERSAL));
+        $visitor->expects($this->at(7))->method('afterTraversal');
+        $traverser = new NodeTraverser;
+        $traverser->addVisitor($visitor);
+        $this->assertEquals($stmts, $traverser->traverse($stmts));
+
+        // Check that pending array modifications are still carried out
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor->expects($this->at(6))->method('leaveNode')->with($mulNode)
+            ->will($this->returnValue(NodeTraverser::REMOVE_NODE));
+        $visitor->expects($this->at(7))->method('enterNode')->with($printNode)
+            ->will($this->returnValue(NodeTraverser::STOP_TRAVERSAL));
+        $visitor->expects($this->at(8))->method('afterTraversal');
+        $traverser = new NodeTraverser;
+        $traverser->addVisitor($visitor);
+        $this->assertEquals([$printNode], $traverser->traverse($stmts));
+
+    }
+
     public function testRemovingVisitor() {
-        $visitor1 = $this->getMock('PhpParser\NodeVisitor');
-        $visitor2 = $this->getMock('PhpParser\NodeVisitor');
-        $visitor3 = $this->getMock('PhpParser\NodeVisitor');
+        $visitor1 = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor2 = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
+        $visitor3 = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
 
         $traverser = new NodeTraverser;
         $traverser->addVisitor($visitor1);
@@ -185,15 +242,7 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
         $this->assertAttributeSame($postExpected, 'visitors', $traverser, 'The appropriate visitors are not present after removal');
     }
 
-    public function testCloneNodes() {
-        $stmts = array(new Node\Stmt\Echo_(array(new String_('Foo'), new String_('Bar'))));
-
-        $traverser = new NodeTraverser(true);
-
-        $this->assertNotSame($stmts, $traverser->traverse($stmts));
-    }
-
-    public function testNoCloneNodesByDefault() {
+    public function testNoCloneNodes() {
         $stmts = array(new Node\Stmt\Echo_(array(new String_('Foo'), new String_('Bar'))));
 
         $traverser = new NodeTraverser;
@@ -208,7 +257,7 @@ class NodeTraverserTest extends \PHPUnit_Framework_TestCase
     public function testReplaceByArrayOnlyAllowedIfParentIsArray() {
         $stmts = array(new Node\Expr\UnaryMinus(new Node\Scalar\LNumber(42)));
 
-        $visitor = $this->getMock('PhpParser\NodeVisitor');
+        $visitor = $this->getMockBuilder('PhpParser\NodeVisitor')->getMock();
         $visitor->method('leaveNode')->willReturn(array(new Node\Scalar\DNumber(42.0)));
 
         $traverser = new NodeTraverser();

test/PhpParser/NodeVisitor/NameResolverTest.php

@@ -4,9 +4,9 @@ namespace PhpParser\NodeVisitor;
 
 use PhpParser;
 use PhpParser\Node;
+use PhpParser\Node\Expr;
 use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
-use PhpParser\Node\Expr;
 
 class NameResolverTest extends \PHPUnit_Framework_TestCase
 {
@@ -118,8 +118,8 @@ namespace {
     new \Hallo\Bar();
     new \Bar();
     new \Bar();
-    bar();
-    hi();
+    \bar();
+    \hi();
     \Hallo\bar();
     \foo\bar();
     \bar();
@@ -199,9 +199,12 @@ interface A extends C, D {
     public function a(A $a) : A;
 }
 
-function fn() : A {}
-function fn2() : array {}
-function() : A {};
+function fn(A $a) : A {}
+function fn2(array $a) : array {}
+function(A $a) : A {};
+
+function fn3(?A $a) : ?A {}
+function fn4(?array $a) : ?array {}
 
 A::b();
 A::$b;
@@ -233,14 +236,20 @@ interface A extends \NS\C, \NS\D
 {
     public function a(\NS\A $a) : \NS\A;
 }
-function fn() : \NS\A
+function fn(\NS\A $a) : \NS\A
 {
 }
-function fn2() : array
+function fn2(array $a) : array
 {
 }
-function () : \NS\A {
+function (\NS\A $a) : \NS\A {
 };
+function fn3(?\NS\A $a) : ?\NS\A
+{
+}
+function fn4(?array $a) : ?array
+{
+}
 \NS\A::b();
 \NS\A::$b;
 \NS\A::B;
@@ -278,7 +287,7 @@ EOC;
         $this->assertEquals($stmts, $traverser->traverse($stmts));
     }
 
-    public function testAddNamespacedName() {
+    public function testAddDeclarationNamespacedName() {
         $nsStmts = array(
             new Stmt\Class_('A'),
             new Stmt\Interface_('B'),
@@ -310,6 +319,29 @@ EOC;
         $this->assertObjectNotHasAttribute('namespacedName', $stmts[0]->stmts[5]->class);
     }
 
+    public function testAddRuntimeResolvedNamespacedName() {
+        $stmts = array(
+            new Stmt\Namespace_(new Name('NS'), array(
+                new Expr\FuncCall(new Name('foo')),
+                new Expr\ConstFetch(new Name('FOO')),
+            )),
+            new Stmt\Namespace_(null, array(
+                new Expr\FuncCall(new Name('foo')),
+                new Expr\ConstFetch(new Name('FOO')),
+            )),
+        );
+
+        $traverser = new PhpParser\NodeTraverser;
+        $traverser->addVisitor(new NameResolver);
+        $stmts = $traverser->traverse($stmts);
+        
+        $this->assertSame('NS\\foo', (string) $stmts[0]->stmts[0]->name->getAttribute('namespacedName'));
+        $this->assertSame('NS\\FOO', (string) $stmts[0]->stmts[1]->name->getAttribute('namespacedName'));
+
+        $this->assertFalse($stmts[1]->stmts[0]->name->hasAttribute('namespacedName'));
+        $this->assertFalse($stmts[1]->stmts[1]->name->hasAttribute('namespacedName'));
+    }
+
     /**
      * @dataProvider provideTestError
      */
@@ -414,4 +446,23 @@ EOC;
         $this->assertSame('PARENT', (string)$methodStmt->stmts[1]->class);
         $this->assertSame('STATIC', (string)$methodStmt->stmts[2]->class);
     }
+
+    public function testAddOriginalNames() {
+        $traverser = new PhpParser\NodeTraverser;
+        $traverser->addVisitor(new NameResolver(null, ['preserveOriginalNames' => true]));
+
+        $n1 = new Name('Bar');
+        $n2 = new Name('bar');
+        $origStmts = [
+            new Stmt\Namespace_(new Name('Foo'), [
+                new Expr\ClassConstFetch($n1, 'FOO'),
+                new Expr\FuncCall($n2),
+            ])
+        ];
+
+        $stmts = $traverser->traverse($origStmts);
+
+        $this->assertSame($n1, $stmts[0]->stmts[0]->class->getAttribute('originalName'));
+        $this->assertSame($n2, $stmts[0]->stmts[1]->name->getAttribute('originalName'));
+    }
 }

test/PhpParser/Parser/MultipleTest.php

@@ -4,10 +4,10 @@ namespace PhpParser\Parser;
 
 use PhpParser\Error;
 use PhpParser\Lexer;
-use PhpParser\Node\Scalar\LNumber;
-use PhpParser\ParserTest;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Stmt;
+use PhpParser\ParserTest;
 
 require_once __DIR__ . '/../ParserTest.php';
 
@@ -30,7 +30,6 @@ class MultipleTest extends ParserTest {
     /** @dataProvider provideTestParse */
     public function testParse($code, Multiple $parser, $expected) {
         $this->assertEquals($expected, $parser->parse($code));
-        $this->assertSame([], $parser->getErrors());
     }
 
     public function provideTestParse() {
@@ -92,22 +91,4 @@ class MultipleTest extends ParserTest {
         $parser = new Multiple([$parserA, $parserB]);
         $parser->parse('dummy');
     }
-
-    public function testGetErrors() {
-        $errorsA = [new Error('A1'), new Error('A2')];
-        $parserA = $this->getMockBuilder('PhpParser\Parser')->getMock();
-        $parserA->expects($this->at(0))->method('parse');
-        $parserA->expects($this->at(1))
-            ->method('getErrors')->will($this->returnValue($errorsA));
-
-        $errorsB = [new Error('B1'), new Error('B2')];
-        $parserB = $this->getMockBuilder('PhpParser\Parser')->getMock();
-        $parserB->expects($this->at(0))->method('parse');
-        $parserB->expects($this->at(1))
-            ->method('getErrors')->will($this->returnValue($errorsB));
-
-        $parser = new Multiple([$parserA, $parserB]);
-        $parser->parse('dummy');
-        $this->assertSame($errorsA, $parser->getErrors());
-    }
 }

test/PhpParser/ParserTest.php

@@ -30,6 +30,15 @@ abstract class ParserTest extends \PHPUnit_Framework_TestCase
         $parser->parse('<?php use foo as self;');
     }
 
+    /**
+     * @expectedException \PhpParser\Error
+     * @expectedExceptionMessage Unterminated comment on line 1
+     */
+    public function testParserThrowsLexerError() {
+        $parser = $this->getParser(new Lexer());
+        $parser->parse('<?php /*');
+    }
+
     public function testAttributeAssignment() {
         $lexer = new Lexer(array(
             'usedAttributes' => array(
@@ -110,9 +119,9 @@ EOC;
     }
 
     /**
-     * @dataProvider provideTestKindAttributes
+     * @dataProvider provideTestExtraAttributes
      */
-    public function testKindAttributes($code, $expectedAttributes) {
+    public function testExtraAttributes($code, $expectedAttributes) {
         $parser = $this->getParser(new Lexer);
         $stmts = $parser->parse("<?php $code;");
         $attributes = $stmts[0]->getAttributes();
@@ -121,7 +130,7 @@ EOC;
         }
     }
 
-    public function provideTestKindAttributes() {
+    public function provideTestExtraAttributes() {
         return array(
             array('0', ['kind' => Scalar\LNumber::KIND_DEC]),
             array('9', ['kind' => Scalar\LNumber::KIND_DEC]),
@@ -158,6 +167,8 @@ EOC;
             array("die('done')", ['kind' => Expr\Exit_::KIND_DIE]),
             array("exit", ['kind' => Expr\Exit_::KIND_EXIT]),
             array("exit(1)", ['kind' => Expr\Exit_::KIND_EXIT]),
+            array("?>Foo", ['hasLeadingNewline' => false]),
+            array("?>\nFoo", ['hasLeadingNewline' => true]),
         );
     }
 }

test/PhpParser/PrettyPrinterTest.php

@@ -4,8 +4,11 @@ namespace PhpParser;
 
 use PhpParser\Comment;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\DNumber;
 use PhpParser\Node\Scalar\Encapsed;
 use PhpParser\Node\Scalar\EncapsedStringPart;
+use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt;
 use PhpParser\PrettyPrinter\Standard;
@@ -161,4 +164,44 @@ class PrettyPrinterTest extends CodeTestAbstract
             [new Encapsed([new EncapsedStringPart("STR")], $heredoc), '"STR"'],
         ];
     }
+
+    /** @dataProvider provideTestUnnaturalLiterals */
+    public function testUnnaturalLiterals($node, $expected) {
+        $prttyPrinter = new PrettyPrinter\Standard;
+        $result = $prttyPrinter->prettyPrintExpr($node);
+        $this->assertSame($expected, $result);
+    }
+
+    public function provideTestUnnaturalLiterals() {
+        return [
+            [new LNumber(-1), '-1'],
+            [new LNumber(-PHP_INT_MAX - 1), '(-' . PHP_INT_MAX . '-1)'],
+            [new LNumber(-1, ['kind' => LNumber::KIND_BIN]), '-0b1'],
+            [new LNumber(-1, ['kind' => LNumber::KIND_OCT]), '-01'],
+            [new LNumber(-1, ['kind' => LNumber::KIND_HEX]), '-0x1'],
+            [new DNumber(\INF), '\INF'],
+            [new DNumber(-\INF), '-\INF'],
+            [new DNumber(-\NAN), '\NAN'],
+        ];
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Cannot pretty-print AST with Error nodes
+     */
+    public function testPrettyPrintWithError() {
+        $stmts = [new Expr\PropertyFetch(new Expr\Variable('a'), new Expr\Error())];
+        $prettyPrinter = new PrettyPrinter\Standard;
+        $prettyPrinter->prettyPrint($stmts);
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Cannot pretty-print AST with Error nodes
+     */
+    public function testPrettyPrintWithErrorInClassConstFetch() {
+        $stmts = [new Expr\ClassConstFetch(new Name('Foo'), new Expr\Error())];
+        $prettyPrinter = new PrettyPrinter\Standard;
+        $prettyPrinter->prettyPrint($stmts);
+    }
 }