Support hashbang before namespace declaration

Fixes issue #243.

.travis.yml

@@ -5,9 +5,10 @@ php:
   - 5.4
   - 5.5
   - 5.6
+  - 7.0
   - hhvm
 
 matrix:
   allow_failures:
-    - php: hhvm
+    - php: 7.0
   fast_finish: true

CHANGELOG.md

@@ -1,9 +1,172 @@
-Version 1.0.0-dev
+Version 1.4.2-dev
 -----------------
 
 Nothing yet.
 
-Version 1.0.0-beta2 (31.08.2014)
+Version 1.4.1 (2015-09-19)
+--------------------------
+
+### Fixed
+
+* Fixed issue with too many newlines being stripped at the end of heredoc/nowdoc strings in some
+  cases. (#227)
+
+Version 1.4.0 (2015-07-14)
+--------------------------
+
+### Added
+
+* Added interface `PhpParser\Node\FunctionLike`, which is implemented by `Stmt\ClassMethod`,
+  `Stmt\Function_` and `Expr\Closure` nodes. This interface provides getters for their common
+  subnodes.
+* Added `Node\Stmt\ClassLike::getMethod()` to look up a specific method on a class/interface/trait.
+
+### Fixed
+
+* Fixed `isPublic()` return value for implicitly public properties and methods that define and
+  additional modifier like `static` or `abstract`.
+* Properties are now accepted by the trait builder.
+* Fixed `__HALT_COMPILER_OFFSET__` support on HHVM.
+
+Version 1.3.0 (2015-05-02)
+--------------------------
+
+### Added
+
+* Errors can now store the attributes of the node/token where the error occurred. Previously only the start line was
+  stored.
+* If file positions are enabled in the lexer, errors can now provide column information if it is available. See
+  [documentation](https://github.com/nikic/PHP-Parser/blob/master/doc/component/Error.markdown#column-information).
+* The parser now provides an experimental error recovery mode, which can be enabled by disabling the `throwOnError`
+  parser option. In this mode the parser will try to construct a partial AST even if the code is not valid PHP. See
+  [documentation](https://github.com/nikic/PHP-Parser/blob/master/doc/component/Error.markdown#error-recovery).
+* Added support for PHP 7 `yield from` expression. It is represented by `Expr\YieldFrom`.
+* Added support for PHP 7 anonymous classes. These are represented by ordinary `Stmt\Class_` nodes with the name set to
+  `null`. Furthermore this implies that `Expr\New_` can now contain a `Stmt\Class_` in its `class` subnode.
+
+### Fixed
+
+* Fixed registration of PHP 7 aliases, for the case where the old name was used before the new name.
+* Fixed handling of precedence when pretty-printing `print` expressions.
+* Floating point numbers are now pretty-printed with a higher precision.
+* Checks for special class names like `self` are now case-insensitive.
+
+Version 1.2.2 (2015-04-03)
+--------------------------
+
+* The `NameResolver` now resolves parameter type hints when entering the function/method/closure node. As such other
+  visitors running after it will be able to make use of the resolved names at that point already.
+* The autoloader no longer sets the `unserialize_callback_func` ini option on registration - this is not necessary and
+  may cause issues when running PhpUnit tests with process isolation.
+
+Version 1.2.1 (2015-03-24)
+--------------------------
+
+* Fixed registration of the aliases introduced in 1.2.0. Previously the old class names could not be used in
+  `instanceof` checks under some circumstances.
+
+Version 1.2.0 (2015-03-22)
+--------------------------
+
+### Changed
+
+* To ensure compatibility with PHP 7, the following node classes have been renamed:
+
+        OLD                             => NEW
+        PhpParser\Node\Expr\Cast\Bool   => PhpParser\Node\Expr\Cast\Bool_
+        PhpParser\Node\Expr\Cast\Int    => PhpParser\Node\Expr\Cast\Int_
+        PhpParser\Node\Expr\Cast\Object => PhpParser\Node\Expr\Cast\Object_
+        PhpParser\Node\Expr\Cast\String => PhpParser\Node\Expr\Cast\String_
+        PhpParser\Node\Scalar\String    => PhpParser\Node\Scalar\String_
+
+  **The previous class names are still supported as aliases.** However it is strongly encouraged to use the new names
+  in order to make your code compatible with PHP 7.
+
+* Subnodes are now stored using real properties instead of an array. This improves performance and memory usage of the
+  initial parse and subsequent node tree operations. The `NodeAbstract` class still supports the old way of specifying
+  subnodes, however this is *deprecated*. In any case properties that are assigned to a node after creation will no
+  longer be considered as subnodes.
+
+* Methods and property declarations will no longer set the `Stmt\Class_::MODIFIER_PUBLIC` flag if no visibility is
+  explicitly given. However the `isPublic()` method will continue to return true. This allows you to distinguish whether
+  a method/property is explicitly or implicitly public and control the pretty printer output more precisely.
+
+* The `Stmt\Class_`, `Stmt\Interface_` and `Stmt\Trait_` nodes now inherit from `Stmt\ClassLike`, which provides a
+  `getMethods()` method. Previously this method was only available on `Stmt\Class_`.
+
+* Support including the `bootstrap.php` file multiple times.
+
+* Make documentation and tests part of the release tarball again.
+
+* Improve support for HHVM and PHP 7.
+
+### Added
+
+* Added support for PHP 7 return type declarations. This adds an additional `returnType` subnode to `Stmt\Function_`,
+  `Stmt\ClassMethod` and `Expr\Closure`.
+
+* Added support for the PHP 7 null coalesce operator `??`. The operator is represented by `Expr\BinaryOp\Coalesce`.
+
+* Added support for the PHP 7 spaceship operator `<=>`. The operator is represented by `Expr\BinaryOp\Spaceship`.
+
+* Added use builder.
+
+* Added global namespace support to the namespace builder.
+
+* Added a constructor flag to `NodeTraverser`, which disables cloning of nodes.
+
+Version 1.1.0 (2015-01-18)
+--------------------------
+
+* Methods that do not specify an explicit visibility (e.g. `function method()`) will now have the `MODIFIER_PUBLIC`
+  flag set. This also means that their `isPublic()` method will return true.
+
+* Declaring a property as abstract or final is now an error.
+
+* The `Lexer` and `Lexer\Emulative` classes now accept an `$options` array in their constructors. Currently only the
+  `usedAttributes` option is supported, which determines which attributes will be added to AST nodes. In particular
+  it is now possible to add information on the token and file positions corresponding to a node. For more details see
+  the [Lexer component](https://github.com/nikic/PHP-Parser/blob/master/doc/component/Lexer.markdown) documentation.
+
+* Node visitors can now return `NodeTraverser::DONT_TRAVERSE_CHILDREN` from `enterNode()` in order to skip all children
+  of the current node, for all visitors.
+
+* Added builders for traits and namespaces.
+
+* The class, interface, trait, function, method and property builders now support adding doc comments using the
+  `setDocComment()` method.
+
+* Added support for fully-qualified and namespace-relative names in builders. No longer allow use of name component
+  arrays.
+
+* Do not add documentation and tests to distribution archive files.
+
+Version 1.0.2 (2014-11-04)
+--------------------------
+
+* The `NameResolver` visitor now also resolves names in trait adaptations (aliases and precedence declarations).
+
+* Remove stray whitespace when pretty-printing trait adaptations that only change visibility.
+
+Version 1.0.1 (2014-10-14)
+--------------------------
+
+* Disallow `new` expressions without a class name. Previously `new;` was accidentally considered to be valid code.
+
+* Support T_ONUMBER token used by HHVM.
+
+* Add ability to directly pass code to the `php-parse.php` script.
+
+* Prevent truncation of `var_dump()` output in the `php-parse.php` script if XDebug is used.
+
+Version 1.0.0 (2014-09-12)
+--------------------------
+
+* [BC] Removed deprecated `Template` and `TemplateLoader` classes.
+
+* Fixed XML unserializer to properly work with new namespaced node names.
+
+Version 1.0.0-beta2 (2014-08-31)
 --------------------------------
 
 * [PHP 5.6] Updated support for constant scalar expressions to comply with latest changes. This means that arrays
@@ -22,13 +185,13 @@ Version 1.0.0-beta2 (31.08.2014)
 * The autoloader now only requires a file if it exists. This allows usages like
   `class_exists('PhpParser\NotExistingClass')`.
 
-* Added experimental ``bin/php-parse.php`` script, which is intended to help exploring and debugging the node tree.
+* Added experimental `bin/php-parse.php` script, which is intended to help exploring and debugging the node tree.
 
 * Separated the parser implemention (in `lib/PhpParser/ParserAbstract.php`) and the generated data (in
   `lib/PhpParser/Parser.php`). Furthermore the parser now uses meaningful variable names and contains comments
   explaining their usage.
 
-Version 1.0.0-beta1 (27.03.2014)
+Version 1.0.0-beta1 (2014-03-27)
 --------------------------------
 
 * [BC] PHP-Parser now requires PHP 5.3 or newer to run. It is however still possible to *parse* PHP 5.2 source code,

README.md

@@ -1,23 +1,18 @@
 PHP Parser
 ==========
 
-This is a PHP 5.6 (and older) parser written in PHP. It's purpose is to simplify static code analysis and
+This is a PHP 5.2 to PHP 5.6 parser written in PHP. Its purpose is to simplify static code analysis and
 manipulation.
 
-[**Documentation for version 0.9.x**][doc_0_9] (stable; for running on PHP 5.2).
+[**Documentation for version 1.x**][doc_1_x] (stable; for running on PHP >= 5.3).
 
-[**Documentation for version 1.0.x**][doc_master] (beta; for running on PHP >= 5.3).
-
-***Note: This project is experimental, so the API is subject to change.***
+[Documentation for version 0.9.x][doc_0_9] (unsupported; for running on PHP 5.2).
 
 In a Nutshell
 -------------
 
-Basically, the parser does nothing more than turn some PHP code into an abstract syntax tree. ("nothing
-more" is kind of sarcastic here as PHP has a ... uhm, let's just say "not nice" ... grammar, which makes
-parsing PHP very hard.)
-
-For example, if you stick this code in the parser:
+The parser turns PHP source code into an abstract syntax tree. For example, if you pass the following code into the
+parser:
 
 ```php
 <?php
@@ -27,7 +22,7 @@ hello\world('foo', 'bar' . 'baz');
 
 You'll get a syntax tree looking roughly like this:
 
-```
+```php
 array(
     0: Stmt_Echo(
         exprs: array(
@@ -75,7 +70,18 @@ programming errors or security issues).
 Additionally, you can convert a syntax tree back to PHP code. This allows you to do code preprocessing
 (like automatedly porting code to older PHP versions).
 
-So, that's it, in a nutshell. You can find everything else in the [docs][doc_master].
+Documentation
+-------------
+
+ 1. [Introduction](doc/0_Introduction.markdown)
+ 2. [Installation](doc/1_Installation.markdown)
+ 3. [Usage of basic components](doc/2_Usage_of_basic_components.markdown)
+ 4. [Other node tree representations](doc/3_Other_node_tree_representations.markdown)
+ 5. [Code generation](doc/4_Code_generation.markdown)
+
+Component documentation:
+
+ 1. [Lexer](doc/component/Lexer.markdown)
 
  [doc_0_9]: https://github.com/nikic/PHP-Parser/tree/0.9/doc
- [doc_master]: https://github.com/nikic/PHP-Parser/tree/master/doc
+ [doc_1_x]: https://github.com/nikic/PHP-Parser/tree/1.x/doc

UPGRADE-1.0.md

@@ -0,0 +1,121 @@
+Upgrading from PHP-Parser 0.9 to 1.0
+====================================
+
+### PHP version requirements
+
+PHP-Parser now requires PHP 5.3 or newer to run. It is however still possible to *parse* PHP 5.2 source code, while
+running on a newer version.
+
+### Move to namespaced names
+
+The library has been moved to use namespaces with the `PhpParser` vendor prefix. However, the old names using
+underscores are still available as aliases, as such most code should continue running on the new version without
+further changes.
+
+Old (still works, but discouraged):
+
+```php
+$parser = new \PHPParser_Parser(new \PHPParser_Lexer_Emulative);
+$prettyPrinter = new \PHPParser_PrettyPrinter_Default;
+```
+
+New:
+
+```php
+$parser = new \PhpParser\Parser(new PhpParser\Lexer\Emulative);
+$prettyPrinter = new \PhpParser\PrettyPrinter\Standard;
+```
+
+Note that the `PHPParser` prefix was changed to `PhpParser`. While PHP class names are technically case-insensitive,
+the autoloader will not be able to load `PHPParser\Parser` or other case variants.
+
+Due to conflicts with reserved keywords, some class names now end with an underscore, e.g. `PHPParser_Node_Stmt_Class`
+is now `PhpParser\Node\Stmt\Class_`. (But as usual, the old name is still available.)
+
+### Changes to `Node::getType()`
+
+The `Node::getType()` method continues to return names using underscores instead of namespace separators and also does
+not contain the trailing underscore that may be present in the class name. As such its output will not change in many
+cases.
+
+However, some node classes have been moved to a different namespace or renamed, which will result in a different
+`Node::getType()` output:
+
+```
+Expr_AssignBitwiseAnd => Expr_AssignOp_BitwiseAnd
+Expr_AssignBitwiseOr  => Expr_AssignOp_BitwiseOr
+Expr_AssignBitwiseXor => Expr_AssignOp_BitwiseXor
+Expr_AssignConcat     => Expr_AssignOp_Concat
+Expr_AssignDiv        => Expr_AssignOp_Div
+Expr_AssignMinus      => Expr_AssignOp_Minus
+Expr_AssignMod        => Expr_AssignOp_Mod
+Expr_AssignMul        => Expr_AssignOp_Mul
+Expr_AssignPlus       => Expr_AssignOp_Plus
+Expr_AssignShiftLeft  => Expr_AssignOp_ShiftLeft
+Expr_AssignShiftRight => Expr_AssignOp_ShiftRight
+
+Expr_BitwiseAnd       => Expr_BinaryOp_BitwiseAnd
+Expr_BitwiseOr        => Expr_BinaryOp_BitwiseOr
+Expr_BitwiseXor       => Expr_BinaryOp_BitwiseXor
+Expr_BooleanAnd       => Expr_BinaryOp_BooleanAnd
+Expr_BooleanOr        => Expr_BinaryOp_BooleanOr
+Expr_Concat           => Expr_BinaryOp_Concat
+Expr_Div              => Expr_BinaryOp_Div
+Expr_Equal            => Expr_BinaryOp_Equal
+Expr_Greater          => Expr_BinaryOp_Greater
+Expr_GreaterOrEqual   => Expr_BinaryOp_GreaterOrEqual
+Expr_Identical        => Expr_BinaryOp_Identical
+Expr_LogicalAnd       => Expr_BinaryOp_LogicalAnd
+Expr_LogicalOr        => Expr_BinaryOp_LogicalOr
+Expr_LogicalXor       => Expr_BinaryOp_LogicalXor
+Expr_Minus            => Expr_BinaryOp_Minus
+Expr_Mod              => Expr_BinaryOp_Mod
+Expr_Mul              => Expr_BinaryOp_Mul
+Expr_NotEqual         => Expr_BinaryOp_NotEqual
+Expr_NotIdentical     => Expr_BinaryOp_NotIdentical
+Expr_Plus             => Expr_BinaryOp_Plus
+Expr_ShiftLeft        => Expr_BinaryOp_ShiftLeft
+Expr_ShiftRight       => Expr_BinaryOp_ShiftRight
+Expr_Smaller          => Expr_BinaryOp_Smaller
+Expr_SmallerOrEqual   => Expr_BinaryOp_SmallerOrEqual
+
+Scalar_ClassConst     => Scalar_MagicConst_Class
+Scalar_DirConst       => Scalar_MagicConst_Dir
+Scalar_FileConst      => Scalar_MagicConst_File
+Scalar_FuncConst      => Scalar_MagicConst_Function
+Scalar_LineConst      => Scalar_MagicConst_Line
+Scalar_MethodConst    => Scalar_MagicConst_Method
+Scalar_NSConst        => Scalar_MagicConst_Namespace
+Scalar_TraitConst     => Scalar_MagicConst_Trait
+```
+
+These changes may affect custom pretty printers and code comparing the return value of `Node::getType()` to specific
+strings.
+
+### Miscellaneous
+
+  * The classes `Template` and `TemplateLoader` have been removed. You should use some other [code generation][code_gen]
+    project built on top of PHP-Parser instead.
+
+  * The `PrettyPrinterAbstract::pStmts()` method now emits a leading newline if the statement list is not empty.
+    Custom pretty printers should remove the explicit newline before `pStmts()` calls.
+
+    Old:
+
+    ```php
+    public function pStmt_Trait(PHPParser_Node_Stmt_Trait $node) {
+        return 'trait ' . $node->name
+             . "\n" . '{' . "\n" . $this->pStmts($node->stmts) . "\n" . '}';
+    }
+    ```
+
+    New:
+
+    ```php
+    public function pStmt_Trait(Stmt\Trait_ $node) {
+        return 'trait ' . $node->name
+             . "\n" . '{' . $this->pStmts($node->stmts) . "\n" . '}';
+    }
+    ```
+
+  [code_gen]: https://github.com/nikic/PHP-Parser/wiki/Projects-using-the-PHP-Parser#code-generation

bin/php-parse.php

@@ -1,14 +1,16 @@
+#!/usr/bin/env php
 <?php
 
 require __DIR__ . '/../lib/bootstrap.php';
 
-ini_set('xdebug.max_nesting_level', 2000);
+ini_set('xdebug.max_nesting_level', 3000);
 
-/* The fancy var_dump function provided by XDebug will cut off the output way too
- * early to be of use. */
-ini_set('xdebug.overload_var_dump', 0);
+// Disable XDebug var_dump() output truncation
+ini_set('xdebug.var_display_max_children', -1);
+ini_set('xdebug.var_display_max_data', -1);
+ini_set('xdebug.var_display_max_depth', -1);
 
-list($operations, $files) = parseArgs($argv);
+list($operations, $files, $attributes) = parseArgs($argv);
 
 /* Dump nodes by default */
 if (empty($operations)) {
@@ -19,7 +21,10 @@ if (empty($files)) {
     showHelp("Must specify at least one file.");
 }
 
-$parser = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
+$lexer = new PhpParser\Lexer\Emulative(array('usedAttributes' => array(
+    'startLine', 'endLine', 'startFilePos', 'endFilePos'
+)));
+$parser = new PhpParser\Parser($lexer);
 $dumper = new PhpParser\NodeDumper;
 $prettyPrinter = new PhpParser\PrettyPrinter\Standard;
 $serializer = new PhpParser\Serializer\XML;
@@ -28,17 +33,32 @@ $traverser = new PhpParser\NodeTraverser();
 $traverser->addVisitor(new PhpParser\NodeVisitor\NameResolver);
 
 foreach ($files as $file) {
+    if (strpos($file, '<?php') === 0) {
+        $code = $file;
+        echo "====> Code $code\n";
+    } else {
         if (!file_exists($file)) {
             die("File $file does not exist.\n");
         }
 
-    echo "====> File $file:\n";
-
         $code = file_get_contents($file);
+        echo "====> File $file:\n";
+    }
+
     try {
         $stmts = $parser->parse($code);
     } catch (PhpParser\Error $e) {
-        die("==> Parse Error: {$e->getMessage()}\n");
+        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();
+        }
+
+        die($message . "\n");
     }
 
     foreach ($operations as $operation) {
@@ -64,23 +84,25 @@ foreach ($files as $file) {
 function showHelp($error) {
     die($error . "\n\n" .
         <<<OUTPUT
-Usage:
-
-    php php-parse.php [operations] file1.php [file2.php ...]
+Usage: php php-parse.php [operations] file1.php [file2.php ...]
+   or: php php-parse.php [operations] "<?php code"
+Turn PHP source code into an abstract syntax tree.
 
 Operations is a list of the following options (--dump by default):
 
-    --dump           -d  Dump nodes using NodeDumper
-    --pretty-print   -p  Pretty print file using PrettyPrinter\Standard
+    -d, --dump              Dump nodes using NodeDumper
+    -p, --pretty-print      Pretty print file using PrettyPrinter\Standard
         --serialize-xml     Serialize nodes using Serializer\XML
         --var-dump          var_dump() nodes (for exact structure)
-    --resolve-names  -N  Resolve names using NodeVisitor\NameResolver
+    -N, --resolve-names     Resolve names using NodeVisitor\NameResolver
+    -c, --with-column-info  Show column-numbers for errors (if available)
 
 Example:
-
     php php-parse.php -d -p -N -d file.php
 
     Dumps nodes, pretty prints them, then resolves names and dumps them again.
+
+
 OUTPUT
     );
 }
@@ -88,6 +110,9 @@ OUTPUT
 function parseArgs($args) {
     $operations = array();
     $files = array();
+    $attributes = array(
+        'with-column-info' => false,
+    );
 
     array_shift($args);
     $parseOptions = true;
@@ -116,6 +141,10 @@ function parseArgs($args) {
             case '-N';
                 $operations[] = 'resolve-names';
                 break;
+            case '--with-column-info':
+            case '-c';
+                $attributes['with-column-info'] = true;
+                break;
             case '--':
                 $parseOptions = false;
                 break;
@@ -128,5 +157,5 @@ function parseArgs($args) {
         }
     }
 
-    return array($operations, $files);
+    return array($operations, $files, $attributes);
 }

composer.json

@@ -18,7 +18,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "1.0-dev"
+            "dev-master": "1.4-dev"
         }
     }
 }

doc/0_Introduction.markdown

@@ -1,16 +1,16 @@
 Introduction
 ============
 
-This project is a PHP 5.5 (and older) parser **written in PHP itself**.
+This project is a PHP 5.2 to PHP 5.6 parser **written in PHP itself**.
 
 What is this for?
 -----------------
 
-A parser is useful for [static analysis][0] and manipulation of code and basically any other
+A parser is useful for [static analysis][0], manipulation of code and basically any other
 application dealing with code programmatically. A parser constructs an [Abstract Syntax Tree][1]
 (AST) of the code and thus allows dealing with it in an abstract and robust way.
 
-There are other ways of dealing with source code. One that PHP supports natively is using the
+There are other ways of processing source code. One that PHP supports natively is using the
 token stream generated by [`token_get_all`][2]. The token stream is much more low level than
 the AST and thus has different applications: It allows to also analyze the exact formatting of
 a file. On the other hand the token stream is much harder to deal with for more complex analysis.
@@ -26,13 +26,13 @@ programmatic PHP code analysis are incidentally PHP developers, not C developers
 What can it parse?
 ------------------
 
-The parser uses a PHP 5.5 compliant grammar, which is backwards compatible with at least PHP 5.4, PHP 5.3
-and PHP 5.2 (and maybe older).
+The parser uses a PHP 5.6 compliant grammar, which is backwards compatible with all PHP version from PHP 5.2
+upwards (and maybe older).
 
 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.3, 5.4 and 5.5 is provided. This
-allows to parse PHP 5.5 source code running on PHP 5.2, for example. This emulation is very hacky and not
-yet perfect, but it should work well on any sane code.
+version it runs on), additionally a wrapper for emulating new tokens from 5.3, 5.4, 5.5 and 5.6 is provided.
+This allows to parse PHP 5.6 source code running on PHP 5.3, for example. This emulation is very hacky and not
+perfect, but it should work well on any sane code.
 
 What output does it produce?
 ----------------------------
@@ -56,7 +56,7 @@ array(
 )
 ```
 
-This matches the semantics the program had: An echo statement, which takes two strings as expressions,
+This matches the structure of the code: An echo statement, which takes two strings as expressions,
 with the values `Hi` and `World!`.
 
 You can also see that the AST does not contain any whitespace information (but most comments are saved).

doc/1_Installation.markdown

@@ -3,30 +3,17 @@ Installation
 
 There are multiple ways to include the PHP parser into your project:
 
-Installing from the Zip- or Tarball
------------------------------------
-
-Download the latest version from [the download page][2], unpack it and move the files somewhere into your project.
-
 Installing via Composer
 -----------------------
 
-Create a `composer.json` file in your project root and use it to define your dependencies:
+Run the following command inside your project:
 
-    {
-        "require": {
-            "nikic/php-parser": "1.0.0-beta2"
-        }
-    }
+    php composer.phar require nikic/php-parser
 
-Then install Composer in your project (or [download the composer.phar][1] directly):
+If you haven't installed [Composer][1] yet, you can do so using:
 
     curl -s http://getcomposer.org/installer | php
 
-And finally ask Composer to install the dependencies:
-
-    php composer.phar install
-
 Installing as a Git Submodule
 -----------------------------
 
@@ -34,7 +21,11 @@ Run the following command to install the parser into the `vendor/PHP-Parser` fol
 
     git submodule add git://github.com/nikic/PHP-Parser.git vendor/PHP-Parser
 
+Installing from the Zip- or Tarball
+-----------------------------------
+
+Download the latest version from [the download page][2], unpack it and move the files somewhere into your project.
 
 
- [1]: http://getcomposer.org/composer.phar
+ [1]: https://getcomposer.org/
  [2]: https://github.com/nikic/PHP-Parser/tags

doc/2_Usage_of_basic_components.markdown

@@ -6,19 +6,21 @@ This document explains how to use the parser, the pretty printer and the node tr
 Bootstrapping
 -------------
 
-The library needs to register a class autoloader; this is done by including the
-`bootstrap.php` file:
+The library needs to register a class autoloader. You can either use the `vendor/autoload.php` file generated by
+Composer or by including the bundled `lib/bootstrap.php` file:
 
 ```php
 <?php
 require 'path/to/PHP-Parser/lib/bootstrap.php';
+// Or, if you're using Composer:
+require 'path/to/vendor/autoload.php';
 ```
 
 Additionally you may want to set the `xdebug.max_nesting_level` ini option to a higher value:
 
 ```php
 <?php
-ini_set('xdebug.max_nesting_level', 2000);
+ini_set('xdebug.max_nesting_level', 3000);
 ```
 
 This ensures that there will be no errors when traversing highly nested node trees.
@@ -26,31 +28,38 @@ This ensures that there will be no errors when traversing highly nested node tre
 Parsing
 -------
 
-In order to parse some source code you first have to create a `PhpParser\Parser` object (which
-needs to be passed a `PhpParser\Lexer` instance) and then pass the code (including `<?php` opening
-tags) to the `parse` method. If a syntax error is encountered `PhpParser\Error` is thrown, so this
-exception should be `catch`ed.
+In order to parse some source code you first have to create a `PhpParser\Parser` object, which
+needs to be passed a `PhpParser\Lexer` instance:
+
+```php
+<?php
+
+$parser = new PhpParser\Parser(new PhpParser\Lexer);
+// or
+$parser = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
+```
+
+Use of the emulative lexer is required if you want to parse PHP code from newer versions than the one
+you're running on. For example it will allow you to parse PHP 5.6 code while running on PHP 5.3.
+
+Subsequently you can pass PHP code (including the opening `<?php` tag) to the `parse` method in order to
+create a syntax tree. If a syntax error is encountered, an `PhpParser\Error` exception will be thrown:
 
 ```php
 <?php
 $code = '<?php // some code';
 
-$parser = new PhpParser\Parser(new PhpParser\Lexer);
+$parser = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
 
 try {
     $stmts = $parser->parse($code);
+    // $stmts is an array of statement nodes
 } catch (PhpParser\Error $e) {
     echo 'Parse Error: ', $e->getMessage();
 }
 ```
 
-The `parse` method will return an array of statement nodes (`$stmts`).
-
-### Emulative lexer
-
-Instead of `PhpParser\Lexer` one can also use `PhpParser\Lexer\Emulative`. This class will emulate tokens
-of newer PHP versions and as such allow parsing PHP 5.5 on PHP 5.2, for example. So if you want to parse
-PHP code of newer versions than the one you are running, you should use the emulative lexer.
+A parser instance can be reused to parse multiple files.
 
 Node tree
 ---------
@@ -93,7 +102,7 @@ with them easier they are grouped into three categories:
    and thus can occur in other expressions. Examples of expressions are `$var`
    (`PhpParser\Node\Expr\Variable`) and `func()` (`PhpParser\Node\Expr\FuncCall`).
  * `PhpParser\Node\Scalar`s are nodes representing scalar values, like `'string'`
-   (`PhpParser\Node\Scalar\String`), `0` (`PhpParser\Node\Scalar\LNumber`) or magic constants
+   (`PhpParser\Node\Scalar\String_`), `0` (`PhpParser\Node\Scalar\LNumber`) or magic constants
    like `__FILE__` (`PhpParser\Node\Scalar\MagicConst\File`). All `PhpParser\Node\Scalar`s extend
    `PhpParser\Node\Expr`, as scalars are expressions, too.
  * There are some nodes not in either of these groups, for example names (`PhpParser\Node\Name`)
@@ -104,7 +113,7 @@ with a PHP keyword.
 
 Every node has a (possibly zero) number of subnodes. You can access subnodes by writing
 `$node->subNodeName`. The `Stmt\Echo_` node has only one subnode `exprs`. So in order to access it
-in the above example you would write `$stmts[0]->exprs`. If you wanted to access name of the function
+in the above example you would write `$stmts[0]->exprs`. If you wanted to access the name of the function
 call, you would write `$stmts[0]->exprs[1]->name`.
 
 All nodes also define a `getType()` method that returns the node type. The type is the class name
@@ -143,10 +152,10 @@ try {
           ->exprs     // sub expressions
           [0]         // the first of them (the string node)
           ->value     // it's value, i.e. 'Hi '
-          = 'Hallo '; // change to 'Hallo '
+          = 'Hello '; // change to 'Hello '
 
     // pretty print
-    $code = '<?php ' . $prettyPrinter->prettyPrint($stmts);
+    $code = $prettyPrinter->prettyPrint($stmts);
 
     echo $code;
 } catch (PhpParser\Error $e) {
@@ -156,7 +165,7 @@ try {
 
 The above code will output:
 
-    <?php echo 'Hallo ', hi\getTarget();
+    <?php echo 'Hello ', hi\getTarget();
 
 As you can see the source code was first parsed using `PhpParser\Parser->parse()`, then changed and then
 again converted to code using `PhpParser\PrettyPrinter\Standard->prettyPrint()`.
@@ -164,8 +173,8 @@ again converted to code using `PhpParser\PrettyPrinter\Standard->prettyPrint()`.
 The `prettyPrint()` method pretty prints a statements array. It is also possible to pretty print only a
 single expression using `prettyPrintExpr()`.
 
-The `prettyPrintFile()` method can be used to print an entire file. This will include the opening `<?php` tag and handle
-inline HTML as the first/last sentence more gracefully.
+The `prettyPrintFile()` method can be used to print an entire file. This will include the opening `<?php` tag
+and handle inline HTML as the first/last statement more gracefully.
 
 Node traversation
 -----------------
@@ -180,9 +189,8 @@ structure of a program using this `PhpParser\NodeTraverser` looks like this:
 
 ```php
 <?php
-$code = "<?php // some code";
 
-$parser        = new PhpParser\Parser(new PhpParser\Lexer);
+$parser        = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
 $traverser     = new PhpParser\NodeTraverser;
 $prettyPrinter = new PhpParser\PrettyPrinter\Standard;
 
@@ -190,6 +198,8 @@ $prettyPrinter = new PhpParser\PrettyPrinter\Standard;
 $traverser->addVisitor(new MyNodeVisitor);
 
 try {
+    $code = file_get_contents($fileName);
+
     // parse
     $stmts = $parser->parse($code);
 
@@ -197,7 +207,7 @@ try {
     $stmts = $traverser->traverse($stmts);
 
     // pretty print
-    $code = '<?php ' . $prettyPrinter->prettyPrint($stmts);
+    $code = $prettyPrinter->prettyPrintFile($stmts);
 
     echo $code;
 } catch (PhpParser\Error $e) {
@@ -205,14 +215,16 @@ try {
 }
 ```
 
-A same node visitor for this code might look like this:
+The corresponding node visitor might look like this:
 
 ```php
 <?php
+use PhpParser\Node;
+
 class MyNodeVisitor extends PhpParser\NodeVisitorAbstract
 {
-    public function leaveNode(PhpParser\Node $node) {
-        if ($node instanceof PhpParser\Node\Scalar\String) {
+    public function leaveNode(Node $node) {
+        if ($node instanceof Node\Scalar\String_) {
             $node->value = 'foo';
         }
     }
@@ -221,7 +233,7 @@ class MyNodeVisitor extends PhpParser\NodeVisitorAbstract
 
 The above node visitor would change all string literals in the program to `'foo'`.
 
-All visitors must implement the `PhpParser\NodeVisitor` interface, which defined the following four
+All visitors must implement the `PhpParser\NodeVisitor` interface, which defines the following four
 methods:
 
     public function beforeTraverse(array $nodes);
@@ -229,22 +241,27 @@ methods:
     public function leaveNode(PhpParser\Node $node);
     public function afterTraverse(array $nodes);
 
-The `beforeTraverse` method is called once before the traversal begins and is passed the nodes the
+The `beforeTraverse()` method is called once before the traversal begins and is passed the nodes the
 traverser was called with. This method can be used for resetting values before traversation or
 preparing the tree for traversal.
 
-The `afterTraverse` method is similar to the `beforeTraverse` method, with the only difference that
+The `afterTraverse()` method is similar to the `beforeTraverse()` method, with the only difference that
 it is called once after the traversal.
 
-The `enterNode` and `leaveNode` methods are called on every node, the former when it is entered,
+The `enterNode()` and `leaveNode()` methods are called on every node, the former when it is entered,
 i.e. before its subnodes are traversed, the latter when it is left.
 
 All four methods can either return the changed node or not return at all (i.e. `null`) in which
-case the current node is not changed. The `leaveNode` method can furthermore return two special
-values: If `false` is returned the current node will be removed from the parent array. If an `array`
-is returned the current node will be merged into the parent array at the offset of the current node.
-I.e. if in `array(A, B, C)` the node `B` should be replaced with `array(X, Y, Z)` the result will be
-`array(A, X, Y, Z, C)`.
+case the current node is not changed.
+
+The `enterNode()` method can additionally return the value `NodeTraverser::DONT_TRAVERSE_CHILDREN`,
+which instructs the traverser to skip all children of the current node.
+
+The `leaveNode()` method can additionally return the value `NodeTraverser::REMOVE_NODE`, in which
+case the current node will be removed from the parent array. Furthermove it is possible to return
+an array of nodes, which will be merged into the parent array at the offset of the current node.
+I.e. if in `array(A, B, C)` the node `B` should be replaced with `array(X, Y, Z)` the result will
+be `array(A, X, Y, Z, C)`.
 
 Instead of manually implementing the `NodeVisitor` interface you can also extend the `NodeVisitorAbstract`
 class, which will define empty default implementations for all the above methods.
@@ -283,10 +300,9 @@ We start off with the following base code:
 
 ```php
 <?php
-const IN_DIR  = '/some/path';
-const OUT_DIR = '/some/other/path';
+$inDir  = '/some/path';
+$outDir = '/some/other/path';
 
-// use the emulative lexer here, as we are running PHP 5.2 but want to parse PHP 5.3
 $parser        = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
 $traverser     = new PhpParser\NodeTraverser;
 $prettyPrinter = new PhpParser\PrettyPrinter\Standard;
@@ -295,7 +311,7 @@ $traverser->addVisitor(new PhpParser\NodeVisitor\NameResolver); // we will need
 $traverser->addVisitor(new NodeVisitor\NamespaceConverter);     // our own node visitor
 
 // iterate over all .php files in the directory
-$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator(IN_DIR));
+$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($inDir));
 $files = new RegexIterator($files, '/\.php$/');
 
 foreach ($files as $file) {
@@ -310,11 +326,11 @@ foreach ($files as $file) {
         $stmts = $traverser->traverse($stmts);
 
         // pretty print
-        $code = '<?php ' . $prettyPrinter->prettyPrint($stmts);
+        $code = $prettyPrinter->prettyPrintFile($stmts);
 
         // write the converted file to the target directory
         file_put_contents(
-            substr_replace($file->getPathname(), OUT_DIR, 0, strlen(IN_DIR)),
+            substr_replace($file->getPathname(), $outDir, 0, strlen($inDir)),
             $code
         );
     } catch (PhpParser\Error $e) {
@@ -323,7 +339,7 @@ foreach ($files as $file) {
 }
 ```
 
-Now lets start with the main code, the `NodeVisitor_NamespaceConverter`. One thing it needs to do
+Now lets start with the main code, the `NodeVisitor\NamespaceConverter`. One thing it needs to do
 is convert `A\\B` style names to `A_B` style ones.
 
 ```php
@@ -340,14 +356,14 @@ class NodeVisitor_NamespaceConverter extends PhpParser\NodeVisitorAbstract
 ```
 
 The above code profits from the fact that the `NameResolver` already resolved all names as far as
-possible, so we don't need to do that. All the need to create a string with the name parts separated
+possible, so we don't need to do that. We only need to create a string with the name parts separated
 by underscores instead of backslashes. This is what `$node->toString('_')` does. (If you want to
 create a name with backslashes either write `$node->toString()` or `(string) $node`.) Then we create
 a new name from the string and return it. Returning a new node replaces the old node.
 
 Another thing we need to do is change the class/function/const declarations. Currently they contain
-only the shortname (i.e. the last part of the name), but they need to contain the complete class
-name:
+only the shortname (i.e. the last part of the name), but they need to contain the complete name inclduing
+the namespace prefix:
 
 ```php
 <?php

doc/3_Other_node_tree_representations.markdown

@@ -1,7 +1,7 @@
 Other node tree representations
 ===============================
 
-It is possible to convert the AST in several textual representations, which serve different uses.
+It is possible to convert the AST into several textual representations, which serve different uses.
 
 Simple serialization
 --------------------
@@ -13,18 +13,19 @@ but PHP, but it is compact and generates fast. The main application thus is in c
 Human readable dumping
 ----------------------
 
-Furthermore it is possible to dump nodes into a human readable form using the `dump` method of
+Furthermore it is possible to dump nodes into a human readable format using the `dump` method of
 `PhpParser\NodeDumper`. This can be used for debugging.
 
 ```php
 <?php
 $code = <<<'CODE'
 <?php
+
 function printLine($msg) {
     echo $msg, "\n";
 }
 
-    printLine('Hallo World!!!');
+printLine('Hello World!!!');
 CODE;
 
 $parser = new PhpParser\Parser(new PhpParser\Lexer);
@@ -33,13 +34,13 @@ $nodeDumper = new PhpParser\NodeDumper;
 try {
     $stmts = $parser->parse($code);
 
-    echo '<pre>' . htmlspecialchars($nodeDumper->dump($stmts)) . '</pre>';
+    echo $nodeDumper->dump($stmts), "\n";
 } catch (PhpParser\Error $e) {
     echo 'Parse Error: ', $e->getMessage();
 }
 ```
 
-The above output will have an output looking roughly like this:
+The above script will have an output looking roughly like this:
 
 ```
 array(
@@ -77,7 +78,7 @@ array(
         args: array(
             0: Arg(
                 value: Scalar_String(
-                    value: Hallo World!!!
+                    value: Hello World!!!
                 )
                 byRef: false
             )
@@ -97,11 +98,12 @@ interfacing with other languages and applications or for doing transformation us
 <?php
 $code = <<<'CODE'
 <?php
+
 function printLine($msg) {
     echo $msg, "\n";
 }
 
-    printLine('Hallo World!!!');
+printLine('Hello World!!!');
 CODE;
 
 $parser = new PhpParser\Parser(new PhpParser\Lexer);
@@ -110,7 +112,7 @@ $serializer = new PhpParser\Serializer\XML;
 try {
     $stmts = $parser->parse($code);
 
-    echo '<pre>' . htmlspecialchars($serializer->serialize($stmts)) . '</pre>';
+    echo $serializer->serialize($stmts);
 } catch (PhpParser\Error $e) {
     echo 'Parse Error: ', $e->getMessage();
 }
@@ -185,7 +187,7 @@ Produces:
       <subNode:value>
        <node:Scalar_String line="6">
         <subNode:value>
-         <scalar:string>Hallo World!!!</scalar:string>
+         <scalar:string>Hello World!!!</scalar:string>
         </subNode:value>
        </node:Scalar_String>
       </subNode:value>

doc/4_Code_generation.markdown

@@ -2,28 +2,36 @@ Code generation
 ===============
 
 It is also possible to generate code using the parser, by first creating an Abstract Syntax Tree and then using the
-pretty printer to convert it to PHP code. To simplify code generation, the project comes with a set of builders for
-common structures as well as simple templating support. Both features are described in the following:
+pretty printer to convert it to PHP code. To simplify code generation, the project comes with builders which allow
+creating node trees using a fluid interface, instead of instantiating all nodes manually. Builders are available for
+the following syntactic elements:
 
-Builders
---------
-
-The project provides builders for classes, interfaces, methods, functions, parameters and properties, which
-allow creating node trees with a fluid interface, instead of instantiating all nodes manually.
+ * namespaces and use statements
+ * classes, interfaces and traits
+ * methods, functions and parameters
+ * properties
 
 Here is an example:
 
 ```php
 <?php
 $factory = new PhpParser\BuilderFactory;
-$node = $factory->class('SomeClass')
+$node = $factory->namespace('Name\Space')
+    ->addStmt($factory->use('Some\Other\Thingy')->as('SomeOtherClass'))
+    ->addStmt($factory->class('SomeClass')
         ->extend('SomeOtherClass')
-    ->implement('A\Few', 'Interfaces')
+        ->implement('A\Few', '\Interfaces')
         ->makeAbstract() // ->makeFinal()
 
         ->addStmt($factory->method('someMethod')
+            ->makePublic()
             ->makeAbstract() // ->makeFinal()
             ->addParam($factory->param('someParam')->setTypeHint('SomeClass'))
+            ->setDocComment('/**
+                              * This method does something.
+                              *
+                              * @param SomeClass And takes a parameter
+                              */')
         )
 
         ->addStmt($factory->method('anotherMethod')
@@ -36,232 +44,37 @@ $node = $factory->class('SomeClass')
         // properties will be correctly reordered above the methods
         ->addStmt($factory->property('someProperty')->makeProtected())
         ->addStmt($factory->property('anotherProperty')->makePrivate()->setDefault(array(1, 2, 3)))
+    )
 
     ->getNode()
 ;
 
 $stmts = array($node);
-echo $prettyPrinter->prettyPrint($stmts);
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard();
+echo $prettyPrinter->prettyPrintFile($stmts);
 ```
 
-This will produce the following output with the default pretty printer:
+This will produce the following output with the standard pretty printer:
 
 ```php
 <?php
-abstract class SomeClass extends SomeOtherClass implements A\Few, Interfaces
+
+namespace Name\Space;
+
+use Some\Other\Thingy as SomeClass;
+abstract class SomeClass extends SomeOtherClass implements A\Few, \Interfaces
 {
     protected $someProperty;
     private $anotherProperty = array(1, 2, 3);
-    abstract function someMethod(SomeClass $someParam);
+    /**
+     * This method does something.
+     *
+     * @param SomeClass And takes a parameter
+     */
+    public abstract function someMethod(SomeClass $someParam);
     protected function anotherMethod($someParam = 'test')
     {
         print $someParam;
     }
 }
 ```
-
-Templates
----------
-
-> **DEPRECATED**: This feature is deprecated and will be removed in PHP-Parser 1.0.
-
-Additionally it is possible to generate code from reusable templates.
-
-As an example consider the following template, which defines a general getter/setter skeleton in terms of a property
-`__name__` and its `__type__`:
-
-```php
-<?php
-
-class GetterSetterTemplate
-{
-    /**
-     * @var __type__ The __name__
-     */
-    protected $__name__;
-
-    /**
-     * Gets the __name__.
-     *
-     * @return __type__ The __name__
-     */
-    public function get__Name__() {
-        return $this->__name__;
-    }
-
-    /**
-     * Sets the __name__.
-     *
-     * @param __type__ $__name__ The new __name__
-     */
-    public function set__Name__($__name__) {
-        $this->__name__ = $__name__;
-    }
-}
-```
-
-Using this template we can easily create a class with multiple properties and their respective getters and setters:
-
-```php
-<?php
-
-// $templateString contains the above template
-$template = new PhpParser\Template($parser, $templateString);
-
-// We only have to specify the __name__ placeholder, as the
-// capitalized __Name__ placeholder is automatically created
-$properties = [
-    ['name' => 'title',     'type' => 'string'],
-    ['name' => 'body',      'type' => 'string'],
-    ['name' => 'author',    'type' => 'User'],
-    ['name' => 'timestamp', 'type' => 'DateTime'],
-];
-
-$class = $factory->class('BlogPost')->implement('Post');
-
-foreach ($properties as $propertyPlaceholders) {
-    $stmts = $template->getStmts($propertyPlaceholders);
-
-    $class->addStmts(
-        // $stmts contains all statements from the template. So [0] fetches the class statement
-        // and ->stmts retrieves the methods.
-        $stmts[0]->stmts
-    );
-}
-
-echo $prettyPrinter->prettyPrint(array($class->getNode()));
-```
-
-The result would look roughly like this:
-
-```php
-<?php
-
-class BlogPost implements Post
-{
-    /**
-     * @var string The title
-     */
-    protected $title;
-
-    /**
-     * @var string The body
-     */
-    protected $body;
-
-    /**
-     * @var User The author
-     */
-    protected $author;
-
-    /**
-     * @var DateTime The timestamp
-     */
-    protected $timestamp;
-
-    /**
-     * Gets the title.
-     *
-     * @return string The title
-     */
-    public function getTitle()
-    {
-        return $this->title;
-    }
-
-    /**
-     * Sets the title.
-     *
-     * @param string $title The new title
-     */
-    public function setTitle($title)
-    {
-        $this->title = $title;
-    }
-
-    /**
-     * Gets the body.
-     *
-     * @return string The body
-     */
-    public function getBody()
-    {
-        return $this->body;
-    }
-
-    /**
-     * Sets the body.
-     *
-     * @param string $body The new body
-     */
-    public function setBody($body)
-    {
-        $this->body = $body;
-    }
-
-    /**
-     * Gets the author.
-     *
-     * @return User The author
-     */
-    public function getAuthor()
-    {
-        return $this->author;
-    }
-
-    /**
-     * Sets the author.
-     *
-     * @param User $author The new author
-     */
-    public function setAuthor($author)
-    {
-        $this->author = $author;
-    }
-
-    /**
-     * Gets the timestamp.
-     *
-     * @return DateTime The timestamp
-     */
-    public function getTimestamp()
-    {
-        return $this->timestamp;
-    }
-
-    /**
-     * Sets the timestamp.
-     *
-     * @param DateTime $timestamp The new timestamp
-     */
-    public function setTimestamp($timestamp)
-    {
-        $this->timestamp = $timestamp;
-    }
-}
-```
-
-When using multiple templates it is easier to manage them on the filesystem. They can be loaded using the
-`TemplateLoader`:
-
-```php
-<?php
-
-// We'll store our templates in ./templates and give them a .php suffix
-$loader = new PhpParser\TemplateLoader($parser, './templates', '.php');
-
-// loads ./templates/GetterSetter.php
-$getterSetterTemplate = $loader->load('GetterSetter');
-
-// loads ./templates/Collection.php
-$collectionTemplate = $loader->load('Collection');
-
-// The use of a suffix is optional. The following code for example is equivalent:
-$loader = new PhpParser\TemplateLoader($parser, './templates');
-
-// loads ./templates/GetterSetter.php
-$getterSetterTemplate = $loader->load('GetterSetter.php');
-
-// loads ./templates/Collection.php
-$collectionTemplate = $loader->load('Collection.php');
-```

doc/component/Error.markdown

@@ -0,0 +1,77 @@
+Error handling
+==============
+
+Errors during parsing or analysis are represented using the `PhpParser\Error` exception class. In addition to an error
+message, an error can also store additional information about the location the error occurred at.
+
+How much location information is available depends on the origin of the error and how many lexer attributes have been
+enabled. At a minimum the start line of the error is usually available.
+
+Column information
+------------------
+
+In order to receive information about not only the line, but also the column span an error occurred at, the file
+position attributes in the lexer need to be enabled:
+
+```php
+$lexer = new PhpParser\Lexer(array(
+    'usedAttributes' => array('comments', 'startLine', 'endLine', 'startFilePos', 'endFilePos'),
+));
+$parser = new PhpParser\Parser($lexer);
+
+try {
+    $stmts = $parser->parse($code);
+    // ...
+} catch (PhpParser\Error $e) {
+    // ...
+}
+```
+
+Before using column information its availability needs to be checked with `$e->hasColumnInfo()`, as the precise
+location of an error cannot always be determined. The methods for retrieving column information also have to be passed
+the source code of the parsed file. An example for printing an error:
+
+```php
+if ($e->hasColumnInfo()) {
+    echo $e->getRawMessage() . ' from ' . $e->getStartLine() . ':' . $e->getStartColumn($code)
+        . ' to ' . $e->getEndLine() . ':' . $e->getEndColumn($code);
+} else {
+    echo $e->getMessage();
+}
+```
+
+Both line numbers and column numbers are 1-based. EOF errors will be located at the position one past the end of the
+file.
+
+Error recovery
+--------------
+
+> **EXPERIMENTAL**
+
+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:
+
+```php
+$parser = new PhpParser\Parser(new PhpParser\Lexer, array(
+    'throwOnError' => false,
+));
+
+$stmts = $parser->parse($code);
+$errors = $parser->getErrors();
+
+foreach ($errors as $error) {
+    // $error is an ordinary PhpParser\Error
+}
+
+if (null !== $stmts) {
+    // $stmts is a best-effort partial AST
+}
+```
+
+The error recovery implementation is experimental -- it currently won't be able to recover from many types of errors.

doc/component/Lexer.markdown

@@ -5,47 +5,115 @@ The lexer is responsible for providing tokens to the parser. The project comes w
 `PhpParser\Lexer\Emulative`. The latter is an extension of the former, which adds the ability to emulate tokens of
 newer PHP versions and thus allows parsing of new code on older versions.
 
-A lexer has to define the following public interface:
+This documentation discusses options available for the default lexers and explains how lexers can be extended.
 
-    startLexing($code);
-    getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null);
-    handleHaltCompiler();
+Lexer options
+-------------
 
-startLexing
------------
-
-The `startLexing` method is invoked when the `parse()` method of the parser is called. It's argument will be whatever
-was passed to the `parse()` method.
-
-Even though `startLexing` is meant to accept a source code string, you could for example overwrite it to accept a file:
+The two default lexers accept an `$options` array in the constructor. Currently only the `'usedAttributes'` option is
+supported, which allows you to specify which attributes will be added to the AST nodes. The attributes can then be
+accessed using `$node->getAttribute()`, `$node->setAttribute()`, `$node->hasAttribute()` and `$node->getAttributes()`
+methods. A sample options array:
 
 ```php
-<?php
-
-class FileLexer extends PhpParser\Lexer {
-    public function startLexing($fileName) {
-        if (!file_exists($fileName)) {
-            throw new InvalidArgumentException(sprintf('File "%s" does not exist', $fileName));
-        }
-
-        parent::startLexing(file_get_contents($fileName));
-    }
-}
-
-$parser = new PhpParser\Parser(new FileLexer);
-
-var_dump($parser->parse('someFile.php'));
-var_dump($parser->parse('someOtherFile.php'));
+$lexer = new PhpParser\Lexer(array(
+    'usedAttributes' => array(
+        'comments', 'startLine', 'endLine'
+    )
+));
 ```
 
-getNextToken
-------------
+The attributes used in this example match the default behavior of the lexer. The following attributes are supported:
 
-`getNextToken` returns the ID of the next token and sets some additional information in the three variables which it
-accepts by-ref. If no more tokens are available it has to return `0`, which is the ID of the `EOF` token.
+ * `comments`: Array of `PhpParser\Comment` or `PhpParser\Comment\Doc` instances, representing all comments that occurred
+   between the previous non-discarded token and the current one. Use of this attribute is required for the
+   `$node->getDocComment()` method to work. The attribute is also needed if you wish the pretty printer to retain
+   comments present in the original code.
+ * `startLine`: Line in which the node starts. This attribute is required for the `$node->getLine()` to work. It is also
+   required if syntax errors should contain line number information.
+ * `endLine`: Line in which the node ends.
+ * `startTokenPos`: Offset into the token array of the first token in the node.
+ * `endTokenPos`: Offset into the token array of the last token in the node.
+ * `startFilePos`: Offset into the code string of the first character that is part of the node.
+ * `endFilePos`: Offset into the code string of the last character that is part of the node.
 
-The first by-ref variable `$value` should contain the textual content of the token. It is what will be available as `$1`
-etc in the parser.
+### Using token positions
+
+The token offset information is useful if you wish to examine the exact formatting used for a node. For example the AST
+does not distinguish whether a property was declared using `public` or using `var`, but you can retrieve this
+information based on the token position:
+
+```php
+function isDeclaredUsingVar(array $tokens, PhpParser\Node\Stmt\Property $prop) {
+    $i = $prop->getAttribute('startTokenPos');
+    return $tokens[$i][0] === T_VAR;
+}
+```
+
+In order to make use of this function, you will have to provide the tokens from the lexer to your node visitor using
+code similar to the following:
+
+```php
+class MyNodeVisitor extends PhpParser\NodeVisitorAbstract {
+    private $tokens;
+    public function setTokens(array $tokens) {
+        $this->tokens = $tokens;
+    }
+
+    public function leaveNode(PhpParser\Node $node) {
+        if ($node instanceof PhpParser\Node\Stmt\Property) {
+            var_dump(isDeclaredUsingVar($this->tokens, $node));
+        }
+    }
+}
+
+$lexer = new PhpParser\Lexer(array(
+    'usedAttributes' => array(
+        'comments', 'startLine', 'endLine', 'startTokenPos', 'endTokenPos'
+    )
+));
+$parser = new PhpParser\Parser($lexer);
+
+$visitor = new MyNodeVisitor();
+$traverser = new PhpParser\NodeTraverser();
+$traverser->addVisitor($visitor);
+
+try {
+    $stmts = $parser->parse($code);
+    $visitor->setTokens($lexer->getTokens());
+    $stmts = $traverser->traverse($stmts);
+} catch (PhpParser\Error $e) {
+    echo 'Parse Error: ', $e->getMessage();
+}
+```
+
+The same approach can also be used to perform specific modifications in the code, without changing the formatting in
+other places (which is the case when using the pretty printer).
+
+Lexer extension
+---------------
+
+A lexer has to define the following public interface:
+
+    void startLexing(string $code);
+    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.
+
+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.
+
+The `handleHaltCompiler()` method is called whenever a `T_HALT_COMPILER` token is encountered. It has to return the
+remaining string after the construct (not including `();`).
+
+The `getNextToken()` method returns the ID of the next token (as defined by the `Parser::T_*` constants). If no more
+tokens are available it must return `0`, which is the ID of the `EOF` token. Furthermore the string content of the
+token should be written into the by-reference `$value` parameter (which will then be available as `$n` in the parser).
+
+### Attribute handling
 
 The other two by-ref variables `$startAttributes` and `$endAttributes` define which attributes will eventually be
 assigned to the generated nodes: The parser will take the `$startAttributes` from the first token which is part of the
@@ -54,61 +122,25 @@ 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.
 
-By default the lexer creates the attributes `startLine`, `comments` (both part of `$startAttributes`) and `endLine`
-(part of `$endAttributes`).
-
-If you don't want all these attributes to be added (to reduce memory usage of the AST) you can simply remove them by
-overriding the method:
+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:
 
 ```php
-<?php
-
-class LessAttributesLexer extends PhpParser\Lexer {
+class KeepOriginalValueLexer extends PHPParser\Lexer // or PHPParser\Lexer\Emulative
+{
     public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
         $tokenId = parent::getNextToken($value, $startAttributes, $endAttributes);
 
-        // only keep startLine attribute
-        unset($startAttributes['comments']);
-        unset($endAttributes['endLine']);
+        if ($tokenId == PHPParser\Parser::T_CONSTANT_ENCAPSED_STRING // non-interpolated string
+            || $tokenId == PHPParser\Parser::T_LNUMBER               // integer
+            || $tokenId == PHPParser\Parser::T_DNUMBER               // floating point number
+        ) {
+            // could also use $startAttributes, doesn't really matter here
+            $endAttributes['originalValue'] = $value;
+        }
 
         return $tokenId;
     }
 }
 ```
-
-You can obviously also add additional attributes. E.g. in conjunction with the above `FileLexer` you might want to add
-a `fileName` attribute to all nodes:
-
-```php
-<?php
-
-class FileLexer extends PhpParser\Lexer {
-    protected $fileName;
-
-    public function startLexing($fileName) {
-        if (!file_exists($fileName)) {
-            throw new InvalidArgumentException(sprintf('File "%s" does not exist', $fileName));
-        }
-
-        $this->fileName = $fileName;
-        parent::startLexing(file_get_contents($fileName));
-    }
-
-    public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
-        $tokenId = parent::getNextToken($value, $startAttributes, $endAttributes);
-
-        // we could use either $startAttributes or $endAttributes here, because the fileName is always the same
-        // (regardless of whether it is the start or end token). We choose $endAttributes, because it is slightly
-        // more efficient (as the parser has to keep a stack for the $startAttributes).
-        $endAttributes['fileName'] = $this->fileName;
-
-        return $tokenId;
-    }
-}
-```
-
-handleHaltCompiler
-------------------
-
-The method is invoked whenever a `T_HALT_COMPILER` token is encountered. It has to return the remaining string after the
-construct (not including `();`).

grammar/README.md

@@ -13,8 +13,7 @@ The `.phpy` file is a normal grammer in `kmyacc` (`yacc`) style, with some trans
 applied to it:
 
  * Nodes are created using the syntax `Name[..., ...]`. This is transformed into
-   `new Node\Name(..., ..., $attributes)`
- * `Name::abc` is transformed to `Node\Name::abc`
+   `new Name(..., ..., attributes())`
  * Some function-like constructs are resolved (see `rebuildParser.php` for a list)
  * Associative arrays are written as `[key: value, ...]`, which is transformed to
    `array('key' => value, ...)`
@@ -25,5 +24,5 @@ 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.
 
-By default only the `Parser.php` is built. If you want to additionally build `Parser/Debug.php` and `y.output` run the
+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/kmyacc.php.parser

@@ -2,11 +2,11 @@
 $meta #
 #semval($) $this->semValue
 #semval($,%t) $this->semValue
-#semval(%n) $this->semStack[$this->stackPos-(%l-%n)]
-#semval(%n,%t) $this->semStack[$this->stackPos-(%l-%n)]
-#include;
+#semval(%n) $this->stackPos-(%l-%n)
+#semval(%n,%t) $this->stackPos-(%l-%n)
 
 namespace PhpParser;
+#include;
 
 /* This is an automatically GENERATED file, which should not be manually edited.
  * Instead edit one of the following:
@@ -20,7 +20,8 @@ class Parser extends ParserAbstract
     protected $actionTableSize = #(YYLAST);
     protected $gotoTableSize = #(YYGLAST);
 
-    protected $invalidToken = #(YYBADCH);
+    protected $invalidSymbol = #(YYBADCH);
+    protected $errorSymbol = #(YYINTERRTOK);
     protected $defaultAction = #(YYDEFAULT);
     protected $unexpectedTokenRule = #(YYUNEXPECTED);
 
@@ -86,7 +87,7 @@ class Parser extends ParserAbstract
 #endif
 #reduce
 
-    protected function reduceRule%n($attributes) {
+    protected function reduceRule%n() {
         %b
     }
 #noact

grammar/rebuildParser.php

@@ -39,10 +39,10 @@ echo 'Building temporary preproprocessed grammar file.', "\n";
 
 $grammarCode = file_get_contents($grammarFile);
 
-$grammarCode = resolveConstants($grammarCode);
 $grammarCode = resolveNodes($grammarCode);
 $grammarCode = resolveMacros($grammarCode);
 $grammarCode = resolveArrays($grammarCode);
+$grammarCode = resolveStackAccess($grammarCode);
 
 file_put_contents($tmpGrammarFile, $grammarCode);
 
@@ -52,7 +52,12 @@ echo "Building parser.\n";
 $output = trim(shell_exec("$kmyacc $additionalArgs -l -m $skeletonFile $tmpGrammarFile 2>&1"));
 echo "Output: \"$output\"\n";
 
-moveFileWithDirCheck($tmpResultFile, $parserResultFile);
+$resultCode = file_get_contents($tmpResultFile);
+$resultCode = removeTrailingWhitespace($resultCode);
+
+ensureDirExists(dirname($parserResultFile));
+file_put_contents($parserResultFile, $resultCode);
+unlink($tmpResultFile);
 
 if (!$optionKeepTmpGrammar) {
     unlink($tmpGrammarFile);
@@ -62,10 +67,6 @@ if (!$optionKeepTmpGrammar) {
 /// Preprocessing functions ///
 ///////////////////////////////
 
-function resolveConstants($code) {
-    return preg_replace('~[A-Z][a-zA-Z_\\\\]++::~', 'Node\\\\$0', $code);
-}
-
 function resolveNodes($code) {
     return preg_replace_callback(
         '~(?<name>[A-Z][a-zA-Z_\\\\]++)\s*' . PARAMS . '~',
@@ -83,7 +84,7 @@ function resolveNodes($code) {
                 $paramCode .= $param . ', ';
             }
 
-            return 'new Node\\' . $matches['name'] . '(' . $paramCode . '$attributes)';
+            return 'new ' . $matches['name'] . '(' . $paramCode . 'attributes())';
         },
         $code
     );
@@ -102,10 +103,9 @@ function resolveMacros($code) {
                 $matches['args']
             );
 
-            if ('error' == $name) {
-                assertArgs(1, $args, $name);
-
-                return 'throw new Error(' . $args[0] . ')';
+            if ('attributes' == $name) {
+                assertArgs(0, $args, $name);
+                return '$this->startAttributeStack[#1] + $this->endAttributes';
             }
 
             if ('init' == $name) {
@@ -139,16 +139,16 @@ function resolveMacros($code) {
             if ('parseEncapsed' == $name) {
                 assertArgs(2, $args, $name);
 
-                return 'foreach (' . $args[0] . ' as &$s) { if (is_string($s)) { $s = Node\Scalar\String::parseEscapeSequences($s, ' . $args[1] . '); } }';
+                return 'foreach (' . $args[0] . ' as &$s) { if (is_string($s)) { $s = Node\Scalar\String_::parseEscapeSequences($s, ' . $args[1] . '); } }';
             }
 
             if ('parseEncapsedDoc' == $name) {
                 assertArgs(1, $args, $name);
 
-                return 'foreach (' . $args[0] . ' as &$s) { if (is_string($s)) { $s = Node\Scalar\String::parseEscapeSequences($s, null); } } $s = preg_replace(\'~(\r\n|\n|\r)$~\', \'\', $s); if (\'\' === $s) array_pop(' . $args[0] . ');';
+                return 'foreach (' . $args[0] . ' as &$s) { if (is_string($s)) { $s = Node\Scalar\String_::parseEscapeSequences($s, null); } } $s = preg_replace(\'~(\r\n|\n|\r)\z~\', \'\', $s); if (\'\' === $s) array_pop(' . $args[0] . ');';
             }
 
-            throw new Exception(sprintf('Unknown macro "%s"', $name));
+            return $matches[0];
         },
         $code
     );
@@ -191,12 +191,22 @@ function resolveArrays($code) {
     );
 }
 
-function moveFileWithDirCheck($fromPath, $toPath) {
-    $dir = dirname($toPath);
+function resolveStackAccess($code) {
+    $code = preg_replace('/\$\d+/', '$this->semStack[$0]', $code);
+    $code = preg_replace('/#(\d+)/', '$$1', $code);
+    return $code;
+}
+
+function removeTrailingWhitespace($code) {
+    $lines = explode("\n", $code);
+    $lines = array_map('rtrim', $lines);
+    return implode("\n", $lines);
+}
+
+function ensureDirExists($dir) {
     if (!is_dir($dir)) {
         mkdir($dir, 0777, true);
     }
-    rename($fromPath, $toPath);
 }
 
 //////////////////////////////

grammar/zend_language_parser.phpy

@@ -8,14 +8,16 @@
 %left T_LOGICAL_AND
 %right T_PRINT
 %right T_YIELD
+%right T_YIELD_FROM
 %left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL T_POW_EQUAL
 %left '?' ':'
+%right T_COALESCE
 %left T_BOOLEAN_OR
 %left T_BOOLEAN_AND
 %left '|'
 %left '^'
 %left '&'
-%nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL
+%nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL T_SPACESHIP
 %nonassoc '<' T_IS_SMALLER_OR_EQUAL '>' T_IS_GREATER_OR_EQUAL
 %left T_SL T_SR
 %left '+' '-' '.'
@@ -109,6 +111,13 @@
 %token T_NS_SEPARATOR
 %token T_ELLIPSIS
 
+%{
+use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar;
+use PhpParser\Node\Stmt;
+%}
+
 %%
 
 start:
@@ -162,7 +171,7 @@ constant_declaration_list:
 ;
 
 constant_declaration:
-    T_STRING '=' static_scalar                              { $$ = Const_[$1, $3]; }
+    T_STRING '=' static_scalar                              { $$ = Node\Const_[$1, $3]; }
 ;
 
 inner_statement_list:
@@ -174,7 +183,8 @@ inner_statement:
       statement                                             { $$ = $1; }
     | function_declaration_statement                        { $$ = $1; }
     | class_declaration_statement                           { $$ = $1; }
-    | T_HALT_COMPILER                                       { error('__HALT_COMPILER() can only be used from the outermost scope'); }
+    | T_HALT_COMPILER
+          { throw new Error('__HALT_COMPILER() can only be used from the outermost scope', attributes()); }
 ;
 
 statement:
@@ -212,6 +222,7 @@ statement:
     | T_THROW expr ';'                                      { $$ = Stmt\Throw_[$2]; }
     | T_GOTO T_STRING ';'                                   { $$ = Stmt\Goto_[$2]; }
     | T_STRING ':'                                          { $$ = Stmt\Label[$1]; }
+    | error                                                 { $$ = array(); /* means: no statement */ }
 ;
 
 catches:
@@ -245,8 +256,8 @@ optional_ellipsis:
 ;
 
 function_declaration_statement:
-    T_FUNCTION optional_ref T_STRING '(' parameter_list ')' '{' inner_statement_list '}'
-        { $$ = Stmt\Function_[$3, [byRef: $2, params: $5, stmts: $8]]; }
+    T_FUNCTION optional_ref T_STRING '(' parameter_list ')' optional_return_type '{' inner_statement_list '}'
+        { $$ = Stmt\Function_[$3, [byRef: $2, params: $5, returnType: $7, stmts: $9]]; }
 ;
 
 class_declaration_statement:
@@ -380,23 +391,32 @@ non_empty_parameter_list:
 ;
 
 parameter:
-      optional_class_type optional_ref optional_ellipsis T_VARIABLE
-          { $$ = Param[parseVar($4), null, $1, $2, $3]; }
-    | optional_class_type optional_ref optional_ellipsis T_VARIABLE '=' static_scalar
-          { $$ = Param[parseVar($4), $6, $1, $2, $3]; }
+      optional_param_type optional_ref optional_ellipsis T_VARIABLE
+          { $$ = Node\Param[parseVar($4), null, $1, $2, $3]; }
+    | optional_param_type optional_ref optional_ellipsis T_VARIABLE '=' static_scalar
+          { $$ = Node\Param[parseVar($4), $6, $1, $2, $3]; }
 ;
 
-optional_class_type:
-      /* empty */                                           { $$ = null; }
-    | name                                                  { $$ = $1; }
+type:
+      name                                                  { $$ = $1; }
     | T_ARRAY                                               { $$ = 'array'; }
     | T_CALLABLE                                            { $$ = 'callable'; }
 ;
 
+optional_param_type:
+      /* empty */                                           { $$ = null; }
+    | type                                                  { $$ = $1; }
+;
+
+optional_return_type:
+      /* empty */                                           { $$ = null; }
+    | ':' type                                              { $$ = $2; }
+;
+
 argument_list:
       '(' ')'                                               { $$ = array(); }
     | '(' non_empty_argument_list ')'                       { $$ = $2; }
-    | '(' yield_expr ')'                                    { $$ = array(Arg[$2, false, false]); }
+    | '(' yield_expr ')'                                    { $$ = array(Node\Arg[$2, false, false]); }
 ;
 
 non_empty_argument_list:
@@ -405,9 +425,9 @@ non_empty_argument_list:
 ;
 
 argument:
-      expr                                                  { $$ = Arg[$1, false, false]; }
-    | '&' variable                                          { $$ = Arg[$2, true, false]; }
-    | T_ELLIPSIS expr                                       { $$ = Arg[$2, false, true]; }
+      expr                                                  { $$ = Node\Arg[$1, false, false]; }
+    | '&' variable                                          { $$ = Node\Arg[$2, true, false]; }
+    | T_ELLIPSIS expr                                       { $$ = Node\Arg[$2, false, true]; }
 ;
 
 global_var_list:
@@ -439,8 +459,8 @@ class_statement_list:
 class_statement:
       variable_modifiers property_declaration_list ';'      { $$ = Stmt\Property[$1, $2]; }
     | T_CONST constant_declaration_list ';'                 { $$ = Stmt\ClassConst[$2]; }
-    | method_modifiers T_FUNCTION optional_ref T_STRING '(' parameter_list ')' method_body
-          { $$ = Stmt\ClassMethod[$4, [type: $1, byRef: $3, params: $6, stmts: $8]]; }
+    | method_modifiers T_FUNCTION optional_ref T_STRING '(' parameter_list ')' optional_return_type method_body
+          { $$ = Stmt\ClassMethod[$4, [type: $1, byRef: $3, params: $6, returnType: $8, stmts: $9]]; }
     | T_USE name_list trait_adaptations                     { $$ = Stmt\TraitUse[$2, $3]; }
 ;
 
@@ -480,11 +500,11 @@ method_body:
 
 variable_modifiers:
       non_empty_member_modifiers                            { $$ = $1; }
-    | T_VAR                                                 { $$ = Stmt\Class_::MODIFIER_PUBLIC; }
+    | T_VAR                                                 { $$ = 0; }
 ;
 
 method_modifiers:
-      /* empty */                                           { $$ = Stmt\Class_::MODIFIER_PUBLIC; }
+      /* empty */                                           { $$ = 0; }
     | non_empty_member_modifiers                            { $$ = $1; }
 ;
 
@@ -571,6 +591,7 @@ expr:
     | expr T_IS_NOT_IDENTICAL expr                          { $$ = Expr\BinaryOp\NotIdentical  [$1, $3]; }
     | expr T_IS_EQUAL expr                                  { $$ = Expr\BinaryOp\Equal         [$1, $3]; }
     | expr T_IS_NOT_EQUAL expr                              { $$ = Expr\BinaryOp\NotEqual      [$1, $3]; }
+    | expr T_SPACESHIP expr                                 { $$ = Expr\BinaryOp\Spaceship     [$1, $3]; }
     | expr '<' expr                                         { $$ = Expr\BinaryOp\Smaller       [$1, $3]; }
     | expr T_IS_SMALLER_OR_EQUAL expr                       { $$ = Expr\BinaryOp\SmallerOrEqual[$1, $3]; }
     | expr '>' expr                                         { $$ = Expr\BinaryOp\Greater       [$1, $3]; }
@@ -581,6 +602,7 @@ expr:
     | '(' new_expr ')'                                      { $$ = $2; }
     | expr '?' expr ':' expr                                { $$ = Expr\Ternary[$1, $3,   $5]; }
     | expr '?' ':' expr                                     { $$ = Expr\Ternary[$1, null, $4]; }
+    | expr T_COALESCE expr                                  { $$ = Expr\BinaryOp\Coalesce[$1, $3]; }
     | T_ISSET '(' variables_list ')'                        { $$ = Expr\Isset_[$3]; }
     | T_EMPTY '(' expr ')'                                  { $$ = Expr\Empty_[$3]; }
     | T_INCLUDE expr                                        { $$ = Expr\Include_[$2, Expr\Include_::TYPE_INCLUDE]; }
@@ -588,12 +610,12 @@ expr:
     | T_EVAL parentheses_expr                               { $$ = Expr\Eval_[$2]; }
     | T_REQUIRE expr                                        { $$ = Expr\Include_[$2, Expr\Include_::TYPE_REQUIRE]; }
     | T_REQUIRE_ONCE expr                                   { $$ = Expr\Include_[$2, Expr\Include_::TYPE_REQUIRE_ONCE]; }
-    | T_INT_CAST expr                                       { $$ = Expr\Cast\Int     [$2]; }
+    | T_INT_CAST expr                                       { $$ = Expr\Cast\Int_    [$2]; }
     | T_DOUBLE_CAST expr                                    { $$ = Expr\Cast\Double  [$2]; }
-    | T_STRING_CAST expr                                    { $$ = Expr\Cast\String  [$2]; }
+    | T_STRING_CAST expr                                    { $$ = Expr\Cast\String_ [$2]; }
     | T_ARRAY_CAST expr                                     { $$ = Expr\Cast\Array_  [$2]; }
-    | T_OBJECT_CAST expr                                    { $$ = Expr\Cast\Object  [$2]; }
-    | T_BOOL_CAST expr                                      { $$ = Expr\Cast\Bool    [$2]; }
+    | T_OBJECT_CAST expr                                    { $$ = Expr\Cast\Object_ [$2]; }
+    | T_BOOL_CAST expr                                      { $$ = Expr\Cast\Bool_   [$2]; }
     | T_UNSET_CAST expr                                     { $$ = Expr\Cast\Unset_  [$2]; }
     | T_EXIT exit_expr                                      { $$ = Expr\Exit_        [$2]; }
     | '@' expr                                              { $$ = Expr\ErrorSuppress[$2]; }
@@ -603,10 +625,13 @@ expr:
     | '`' backticks_expr '`'                                { $$ = Expr\ShellExec[$2]; }
     | T_PRINT expr                                          { $$ = Expr\Print_[$2]; }
     | T_YIELD                                               { $$ = Expr\Yield_[null, null]; }
-    | T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars '{' inner_statement_list '}'
-          { $$ = Expr\Closure[[static: false, byRef: $2, params: $4, uses: $6, stmts: $8]]; }
-    | T_STATIC T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars '{' inner_statement_list '}'
-          { $$ = Expr\Closure[[static: true, byRef: $3, params: $5, uses: $7, stmts: $9]]; }
+    | T_YIELD_FROM expr                                     { $$ = Expr\YieldFrom[$2]; }
+    | T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type
+      '{' inner_statement_list '}'
+          { $$ = Expr\Closure[[static: false, byRef: $2, params: $4, uses: $6, returnType: $7, stmts: $9]]; }
+    | T_STATIC T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type
+      '{' inner_statement_list '}'
+          { $$ = Expr\Closure[[static: true, byRef: $3, params: $5, uses: $7, returnType: $8, stmts: $10]]; }
 ;
 
 parentheses_expr:
@@ -627,14 +652,20 @@ array_expr:
 scalar_dereference:
       array_expr '[' dim_offset ']'                         { $$ = Expr\ArrayDimFetch[$1, $3]; }
     | T_CONSTANT_ENCAPSED_STRING '[' dim_offset ']'
-          { $$ = Expr\ArrayDimFetch[Scalar\String[Scalar\String::parse($1)], $3]; }
+          { $$ = Expr\ArrayDimFetch[Scalar\String_[Scalar\String_::parse($1)], $3]; }
     | constant '[' dim_offset ']'                           { $$ = Expr\ArrayDimFetch[$1, $3]; }
     | scalar_dereference '[' dim_offset ']'                 { $$ = Expr\ArrayDimFetch[$1, $3]; }
     /* alternative array syntax missing intentionally */
 ;
 
+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); }
+
 new_expr:
       T_NEW class_name_reference ctor_arguments             { $$ = Expr\New_[$2, $3]; }
+    | T_NEW anonymous_class
+          { list($class, $ctorArgs) = $2; $$ = Expr\New_[$class, $ctorArgs]; }
 ;
 
 lexical_vars:
@@ -705,7 +736,7 @@ class_name_or_var:
 ;
 
 object_access_for_dcnr:
-    | base_variable T_OBJECT_OPERATOR object_property
+      base_variable T_OBJECT_OPERATOR object_property
           { $$ = Expr\PropertyFetch[$1, $3]; }
     | object_access_for_dcnr T_OBJECT_OPERATOR object_property
           { $$ = Expr\PropertyFetch[$1, $3]; }
@@ -721,7 +752,7 @@ exit_expr:
 
 backticks_expr:
       /* empty */                                           { $$ = array(); }
-    | T_ENCAPSED_AND_WHITESPACE                             { $$ = array(Scalar\String::parseEscapeSequences($1, '`')); }
+    | T_ENCAPSED_AND_WHITESPACE                             { $$ = array(Scalar\String_::parseEscapeSequences($1, '`')); }
     | encaps_list                                           { parseEncapsed($1, '`'); $$ = $1; }
 ;
 
@@ -733,7 +764,7 @@ ctor_arguments:
 common_scalar:
       T_LNUMBER                                             { $$ = Scalar\LNumber[Scalar\LNumber::parse($1)]; }
     | T_DNUMBER                                             { $$ = Scalar\DNumber[Scalar\DNumber::parse($1)]; }
-    | T_CONSTANT_ENCAPSED_STRING                            { $$ = Scalar\String[Scalar\String::parse($1)]; }
+    | T_CONSTANT_ENCAPSED_STRING                            { $$ = Scalar\String_[Scalar\String_::parse($1)]; }
     | T_LINE                                                { $$ = Scalar\MagicConst\Line[]; }
     | T_FILE                                                { $$ = Scalar\MagicConst\File[]; }
     | T_DIR                                                 { $$ = Scalar\MagicConst\Dir[]; }
@@ -743,9 +774,9 @@ common_scalar:
     | T_FUNC_C                                              { $$ = Scalar\MagicConst\Function_[]; }
     | T_NS_C                                                { $$ = Scalar\MagicConst\Namespace_[]; }
     | T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC
-          { $$ = Scalar\String[Scalar\String::parseDocString($1, $2)]; }
+          { $$ = Scalar\String_[Scalar\String_::parseDocString($1, $2)]; }
     | T_START_HEREDOC T_END_HEREDOC
-          { $$ = Scalar\String['']; }
+          { $$ = Scalar\String_['']; }
 ;
 
 static_scalar:
@@ -955,8 +986,8 @@ encaps_var:
 ;
 
 encaps_var_offset:
-      T_STRING                                              { $$ = Scalar\String[$1]; }
-    | T_NUM_STRING                                          { $$ = Scalar\String[$1]; }
+      T_STRING                                              { $$ = Scalar\String_[$1]; }
+    | T_NUM_STRING                                          { $$ = Scalar\String_[$1]; }
     | T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
 ;
 

lib/PhpParser/Autoloader.php

@@ -7,14 +7,25 @@ namespace PhpParser;
  */
 class Autoloader
 {
+    /** @var bool Whether the autoloader has been registered. */
+    private static $registered = false;
+
+    /** @var bool Whether we're running on PHP 7. */
+    private static $runningOnPhp7;
+
     /**
      * Registers PhpParser\Autoloader as an SPL autoloader.
      *
      * @param bool $prepend Whether to prepend the autoloader instead of appending
      */
     static public function register($prepend = false) {
-        ini_set('unserialize_callback_func', 'spl_autoload_call');
+        if (self::$registered === true) {
+            return;
+        }
+
         spl_autoload_register(array(__CLASS__, 'autoload'), true, $prepend);
+        self::$registered = true;
+        self::$runningOnPhp7 = version_compare(PHP_VERSION, '7.0-dev', '>=');
     }
 
     /**
@@ -24,24 +35,58 @@ class Autoloader
      */
     static public function autoload($class) {
         if (0 === strpos($class, 'PhpParser\\')) {
+            if (isset(self::$php7AliasesOldToNew[$class])) {
+                if (self::$runningOnPhp7) {
+                    return;
+                }
+
+                // Load the new class, alias will be registered afterwards
+                $class = self::$php7AliasesOldToNew[$class];
+            }
+
             $fileName = dirname(__DIR__) . '/' . strtr($class, '\\', '/') . '.php';
             if (file_exists($fileName)) {
                 require $fileName;
             }
+
+            if (isset(self::$php7AliasesNewToOld[$class])) {
+                // New class name was used, register alias for old one, otherwise
+                // it won't be usable in "instanceof" and other non-autoloading places.
+                if (!self::$runningOnPhp7) {
+                    class_alias($class, self::$php7AliasesNewToOld[$class]);
+                }
+            }
         } else if (0 === strpos($class, 'PHPParser_')) {
-            if (isset(self::$oldToNewMap[$class])) {
-                self::registerLegacyAliases();
+            if (isset(self::$nonNamespacedAliases[$class])) {
+                // Register all aliases at once to avoid dependency issues
+                self::registerNonNamespacedAliases();
             }
         }
     }
 
-    private static function registerLegacyAliases() {
-        foreach (self::$oldToNewMap as $old => $new) {
+    private static function registerNonNamespacedAliases() {
+        foreach (self::$nonNamespacedAliases as $old => $new) {
             class_alias($new, $old);
         }
     }
 
-    private static $oldToNewMap = array(
+    private static $php7AliasesOldToNew = array(
+        'PhpParser\Node\Expr\Cast\Bool' => 'PhpParser\Node\Expr\Cast\Bool_',
+        'PhpParser\Node\Expr\Cast\Int' => 'PhpParser\Node\Expr\Cast\Int_',
+        'PhpParser\Node\Expr\Cast\Object' => 'PhpParser\Node\Expr\Cast\Object_',
+        'PhpParser\Node\Expr\Cast\String' => 'PhpParser\Node\Expr\Cast\String_',
+        'PhpParser\Node\Scalar\String' => 'PhpParser\Node\Scalar\String_',
+    );
+
+    private static $php7AliasesNewToOld = array(
+        'PhpParser\Node\Expr\Cast\Bool_' => 'PhpParser\Node\Expr\Cast\Bool',
+        'PhpParser\Node\Expr\Cast\Int_' => 'PhpParser\Node\Expr\Cast\Int',
+        'PhpParser\Node\Expr\Cast\Object_' => 'PhpParser\Node\Expr\Cast\Object',
+        'PhpParser\Node\Expr\Cast\String_' => 'PhpParser\Node\Expr\Cast\String',
+        'PhpParser\Node\Scalar\String_' => 'PhpParser\Node\Scalar\String',
+    );
+
+    private static $nonNamespacedAliases = array(
         'PHPParser_Builder' => 'PhpParser\Builder',
         'PHPParser_BuilderAbstract' => 'PhpParser\BuilderAbstract',
         'PHPParser_BuilderFactory' => 'PhpParser\BuilderFactory',
@@ -64,8 +109,6 @@ class Autoloader
         'PHPParser_PrettyPrinter_Zend' => 'PhpParser\PrettyPrinter\Standard',
         'PHPParser_Serializer' => 'PhpParser\Serializer',
         'PHPParser_Serializer_XML' => 'PhpParser\Serializer\XML',
-        'PHPParser_Template' => 'PhpParser\Template',
-        'PHPParser_TemplateLoader' => 'PhpParser\TemplateLoader',
         'PHPParser_Unserializer' => 'PhpParser\Unserializer',
         'PHPParser_Unserializer_XML' => 'PhpParser\Unserializer\XML',
 
@@ -143,11 +186,11 @@ class Autoloader
 
         'PHPParser_Node_Expr_Cast' => 'PhpParser\Node\Expr\Cast',
         'PHPParser_Node_Expr_Cast_Array' => 'PhpParser\Node\Expr\Cast\Array_',
-        'PHPParser_Node_Expr_Cast_Bool' => 'PhpParser\Node\Expr\Cast\Bool',
+        'PHPParser_Node_Expr_Cast_Bool' => 'PhpParser\Node\Expr\Cast\Bool_',
         'PHPParser_Node_Expr_Cast_Double' => 'PhpParser\Node\Expr\Cast\Double',
-        'PHPParser_Node_Expr_Cast_Int' => 'PhpParser\Node\Expr\Cast\Int',
-        'PHPParser_Node_Expr_Cast_Object' => 'PhpParser\Node\Expr\Cast\Object',
-        'PHPParser_Node_Expr_Cast_String' => 'PhpParser\Node\Expr\Cast\String',
+        'PHPParser_Node_Expr_Cast_Int' => 'PhpParser\Node\Expr\Cast\Int_',
+        'PHPParser_Node_Expr_Cast_Object' => 'PhpParser\Node\Expr\Cast\Object_',
+        'PHPParser_Node_Expr_Cast_String' => 'PhpParser\Node\Expr\Cast\String_',
         'PHPParser_Node_Expr_Cast_Unset' => 'PhpParser\Node\Expr\Cast\Unset_',
 
         'PHPParser_Node_Expr_BitwiseAnd' => 'PhpParser\Node\Expr\BinaryOp\BitwiseAnd',
@@ -225,7 +268,7 @@ class Autoloader
         'PHPParser_Node_Scalar_DNumber' => 'PhpParser\Node\Scalar\DNumber',
         'PHPParser_Node_Scalar_Encapsed' => 'PhpParser\Node\Scalar\Encapsed',
         'PHPParser_Node_Scalar_LNumber' => 'PhpParser\Node\Scalar\LNumber',
-        'PHPParser_Node_Scalar_String' => 'PhpParser\Node\Scalar\String',
+        'PHPParser_Node_Scalar_String' => 'PhpParser\Node\Scalar\String_',
     );
 }
 

lib/PhpParser/Builder/Class_.php

@@ -6,18 +6,18 @@ use PhpParser;
 use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
 
-class Class_ extends PhpParser\BuilderAbstract
+class Class_ extends Declaration
 {
     protected $name;
 
-    protected $extends;
-    protected $implements;
-    protected $type;
+    protected $extends = null;
+    protected $implements = array();
+    protected $type = 0;
 
-    protected $uses;
-    protected $constants;
-    protected $properties;
-    protected $methods;
+    protected $uses = array();
+    protected $constants = array();
+    protected $properties = array();
+    protected $methods = array();
 
     /**
      * Creates a class builder.
@@ -26,12 +26,6 @@ class Class_ extends PhpParser\BuilderAbstract
      */
     public function __construct($name) {
         $this->name = $name;
-
-        $this->type = 0;
-        $this->extends = null;
-        $this->implements = array();
-
-        $this->uses = $this->constants = $this->properties = $this->methods = array();
     }
 
     /**
@@ -39,7 +33,7 @@ class Class_ extends PhpParser\BuilderAbstract
      *
      * @param Name|string $class Name of class to extend
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function extend($class) {
         $this->extends = $this->normalizeName($class);
@@ -53,7 +47,7 @@ class Class_ extends PhpParser\BuilderAbstract
      * @param Name|string $interface Name of interface to implement
      * @param Name|string $...       More interfaces to implement
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function implement() {
         foreach (func_get_args() as $interface) {
@@ -66,7 +60,7 @@ class Class_ extends PhpParser\BuilderAbstract
     /**
      * Makes the class abstract.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeAbstract() {
         $this->setModifier(Stmt\Class_::MODIFIER_ABSTRACT);
@@ -77,7 +71,7 @@ class Class_ extends PhpParser\BuilderAbstract
     /**
      * Makes the class final.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeFinal() {
         $this->setModifier(Stmt\Class_::MODIFIER_FINAL);
@@ -90,7 +84,7 @@ class Class_ extends PhpParser\BuilderAbstract
      *
      * @param Stmt|PhpParser\Builder $stmt The statement to add
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function addStmt($stmt) {
         $stmt = $this->normalizeNode($stmt);
@@ -112,21 +106,6 @@ class Class_ extends PhpParser\BuilderAbstract
         return $this;
     }
 
-    /**
-     * Adds multiple statements.
-     *
-     * @param array $stmts The statements to add
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function addStmts(array $stmts) {
-        foreach ($stmts as $stmt) {
-            $this->addStmt($stmt);
-        }
-
-        return $this;
-    }
-
     /**
      * Returns the built class node.
      *
@@ -138,6 +117,6 @@ class Class_ extends PhpParser\BuilderAbstract
             'extends' => $this->extends,
             'implements' => $this->implements,
             'stmts' => array_merge($this->uses, $this->constants, $this->properties, $this->methods),
-        ));
+        ), $this->attributes);
     }
 }

lib/PhpParser/Builder/Declaration.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+
+abstract class Declaration extends PhpParser\BuilderAbstract
+{
+    protected $attributes = array();
+
+    abstract public function addStmt($stmt);
+
+    /**
+     * Adds multiple statements.
+     *
+     * @param array $stmts The statements to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addStmts(array $stmts) {
+        foreach ($stmts as $stmt) {
+            $this->addStmt($stmt);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Sets doc comment for the declaration.
+     *
+     * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function setDocComment($docComment) {
+        $this->attributes['comments'] = array(
+            $this->normalizeDocComment($docComment)
+        );
+
+        return $this;
+    }
+}

lib/PhpParser/Builder/FunctionLike.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+
+abstract class FunctionLike extends Declaration
+{
+    protected $returnByRef = false;
+    protected $params = array();
+
+    /**
+     * Make the function return by reference.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeReturnByRef() {
+        $this->returnByRef = true;
+
+        return $this;
+    }
+
+    /**
+     * Adds a parameter.
+     *
+     * @param Node\Param|Param $param The parameter to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addParam($param) {
+        $param = $this->normalizeNode($param);
+
+        if (!$param instanceof Node\Param) {
+            throw new \LogicException(sprintf('Expected parameter node, got "%s"', $param->getType()));
+        }
+
+        $this->params[] = $param;
+
+        return $this;
+    }
+
+    /**
+     * Adds multiple parameters.
+     *
+     * @param array $params The parameters to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addParams(array $params) {
+        foreach ($params as $param) {
+            $this->addParam($param);
+        }
+
+        return $this;
+    }
+}

lib/PhpParser/Builder/Function_.php

@@ -6,13 +6,10 @@ use PhpParser;
 use PhpParser\Node;
 use PhpParser\Node\Stmt;
 
-class Function_ extends PhpParser\BuilderAbstract
+class Function_ extends FunctionLike
 {
     protected $name;
-
-    protected $returnByRef;
-    protected $params;
-    protected $stmts;
+    protected $stmts = array();
 
     /**
      * Creates a function builder.
@@ -21,55 +18,6 @@ class Function_ extends PhpParser\BuilderAbstract
      */
     public function __construct($name) {
         $this->name = $name;
-
-        $this->returnByRef = false;
-        $this->params = array();
-        $this->stmts = array();
-    }
-
-    /**
-     * Make the function return by reference.
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function makeReturnByRef() {
-        $this->returnByRef = true;
-
-        return $this;
-    }
-
-    /**
-     * Adds a parameter.
-     *
-     * @param Node\Param|Param $param The parameter to add
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function addParam($param) {
-        $param = $this->normalizeNode($param);
-
-        if (!$param instanceof Node\Param) {
-            throw new \LogicException(sprintf('Expected parameter node, got "%s"', $param->getType()));
-        }
-
-        $this->params[] = $param;
-
-        return $this;
-    }
-
-    /**
-     * Adds multiple parameters.
-     *
-     * @param array $params The parameters to add
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function addParams(array $params) {
-        foreach ($params as $param) {
-            $this->addParam($param);
-        }
-
-        return $this;
     }
 
     /**
@@ -77,7 +25,7 @@ class Function_ extends PhpParser\BuilderAbstract
      *
      * @param Node|PhpParser\Builder $stmt The statement to add
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function addStmt($stmt) {
         $this->stmts[] = $this->normalizeNode($stmt);
@@ -85,21 +33,6 @@ class Function_ extends PhpParser\BuilderAbstract
         return $this;
     }
 
-    /**
-     * Adds multiple statements.
-     *
-     * @param array $stmts The statements to add
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function addStmts(array $stmts) {
-        foreach ($stmts as $stmt) {
-            $this->addStmt($stmt);
-        }
-
-        return $this;
-    }
-
     /**
      * Returns the built function node.
      *
@@ -110,6 +43,6 @@ class Function_ extends PhpParser\BuilderAbstract
             'byRef'  => $this->returnByRef,
             'params' => $this->params,
             'stmts'  => $this->stmts,
-        ));
+        ), $this->attributes);
     }
 }

lib/PhpParser/Builder/Interface_.php

@@ -6,12 +6,12 @@ use PhpParser;
 use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
 
-class Interface_ extends PhpParser\BuilderAbstract
+class Interface_ extends Declaration
 {
     protected $name;
-    protected $extends;
-    protected $constants;
-    protected $methods;
+    protected $extends = array();
+    protected $constants = array();
+    protected $methods = array();
 
     /**
      * Creates an interface builder.
@@ -20,8 +20,6 @@ class Interface_ extends PhpParser\BuilderAbstract
      */
     public function __construct($name) {
         $this->name = $name;
-        $this->extends = array();
-        $this->constants = $this->methods = array();
     }
 
     /**
@@ -30,7 +28,7 @@ class Interface_ extends PhpParser\BuilderAbstract
      * @param Name|string $interface Name of interface to extend
      * @param Name|string $...       More interfaces to extend
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function extend() {
         foreach (func_get_args() as $interface) {
@@ -45,7 +43,7 @@ class Interface_ extends PhpParser\BuilderAbstract
      *
      * @param Stmt|PhpParser\Builder $stmt The statement to add
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function addStmt($stmt) {
         $stmt = $this->normalizeNode($stmt);
@@ -70,22 +68,7 @@ class Interface_ extends PhpParser\BuilderAbstract
     }
 
     /**
-     * Adds multiple statements.
-     *
-     * @param array $stmts The statements to add
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function addStmts(array $stmts) {
-        foreach ($stmts as $stmt) {
-            $this->addStmt($stmt);
-        }
-
-        return $this;
-    }
-
-    /**
-     * Returns the built class node.
+     * Returns the built interface node.
      *
      * @return Stmt\Interface_ The built interface node
      */
@@ -93,6 +76,6 @@ class Interface_ extends PhpParser\BuilderAbstract
         return new Stmt\Interface_($this->name, array(
             'extends' => $this->extends,
             'stmts' => array_merge($this->constants, $this->methods),
-        ));
+        ), $this->attributes);
     }
 }

lib/PhpParser/Builder/Method.php

@@ -6,14 +6,11 @@ use PhpParser;
 use PhpParser\Node;
 use PhpParser\Node\Stmt;
 
-class Method extends PhpParser\BuilderAbstract
+class Method extends FunctionLike
 {
     protected $name;
-
-    protected $type;
-    protected $returnByRef;
-    protected $params;
-    protected $stmts;
+    protected $type = 0;
+    protected $stmts = array();
 
     /**
      * Creates a method builder.
@@ -22,17 +19,12 @@ class Method extends PhpParser\BuilderAbstract
      */
     public function __construct($name) {
         $this->name = $name;
-
-        $this->type = 0;
-        $this->returnByRef = false;
-        $this->params = array();
-        $this->stmts = array();
     }
 
     /**
      * Makes the method public.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makePublic() {
         $this->setModifier(Stmt\Class_::MODIFIER_PUBLIC);
@@ -43,7 +35,7 @@ class Method extends PhpParser\BuilderAbstract
     /**
      * Makes the method protected.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeProtected() {
         $this->setModifier(Stmt\Class_::MODIFIER_PROTECTED);
@@ -54,7 +46,7 @@ class Method extends PhpParser\BuilderAbstract
     /**
      * Makes the method private.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makePrivate() {
         $this->setModifier(Stmt\Class_::MODIFIER_PRIVATE);
@@ -65,7 +57,7 @@ class Method extends PhpParser\BuilderAbstract
     /**
      * Makes the method static.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeStatic() {
         $this->setModifier(Stmt\Class_::MODIFIER_STATIC);
@@ -76,7 +68,7 @@ class Method extends PhpParser\BuilderAbstract
     /**
      * Makes the method abstract.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeAbstract() {
         if (!empty($this->stmts)) {
@@ -92,7 +84,7 @@ class Method extends PhpParser\BuilderAbstract
     /**
      * Makes the method final.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeFinal() {
         $this->setModifier(Stmt\Class_::MODIFIER_FINAL);
@@ -100,57 +92,12 @@ class Method extends PhpParser\BuilderAbstract
         return $this;
     }
 
-    /**
-     * Make the method return by reference.
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function makeReturnByRef() {
-        $this->returnByRef = true;
-
-        return $this;
-    }
-
-    /**
-     * Adds a parameter.
-     *
-     * @param Node\Param|Param $param The parameter to add
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function addParam($param) {
-        $param = $this->normalizeNode($param);
-
-        if (!$param instanceof Node\Param) {
-            throw new \LogicException(sprintf('Expected parameter node, got "%s"', $param->getType()));
-        }
-
-        $this->params[] = $param;
-
-        return $this;
-    }
-
-    /**
-     * Adds multiple parameters.
-     *
-     * @param array $params The parameters to add
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function addParams(array $params) {
-        foreach ($params as $param) {
-            $this->addParam($param);
-        }
-
-        return $this;
-    }
-
     /**
      * Adds a statement.
      *
      * @param Node|PhpParser\Builder $stmt The statement to add
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function addStmt($stmt) {
         if (null === $this->stmts) {
@@ -162,21 +109,6 @@ class Method extends PhpParser\BuilderAbstract
         return $this;
     }
 
-    /**
-     * Adds multiple statements.
-     *
-     * @param array $stmts The statements to add
-     *
-     * @return self The builder instance (for fluid interface)
-     */
-    public function addStmts(array $stmts) {
-        foreach ($stmts as $stmt) {
-            $this->addStmt($stmt);
-        }
-
-        return $this;
-    }
-
     /**
      * Returns the built method node.
      *
@@ -184,10 +116,10 @@ class Method extends PhpParser\BuilderAbstract
      */
     public function getNode() {
         return new Stmt\ClassMethod($this->name, array(
-            'type'   => $this->type !== 0 ? $this->type : Stmt\Class_::MODIFIER_PUBLIC,
+            'type'   => $this->type,
             'byRef'  => $this->returnByRef,
             'params' => $this->params,
             'stmts'  => $this->stmts,
-        ));
+        ), $this->attributes);
     }
 }

lib/PhpParser/Builder/Namespace_.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+
+class Namespace_ extends PhpParser\BuilderAbstract
+{
+    private $name;
+    private $stmts = array();
+
+    /**
+     * Creates a namespace builder.
+     *
+     * @param Node\Name|string|null $name Name of the namespace
+     */
+    public function __construct($name) {
+        $this->name = null !== $name ? $this->normalizeName($name) : null;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param Node|PhpParser\Builder $stmt The statement to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addStmt($stmt) {
+        $this->stmts[] = $this->normalizeNode($stmt);
+
+        return $this;
+    }
+
+    /**
+     * Adds multiple statements.
+     *
+     * @param array $stmts The statements to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addStmts(array $stmts) {
+        foreach ($stmts as $stmt) {
+            $this->addStmt($stmt);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns the built node.
+     *
+     * @return Node The built node
+     */
+    public function getNode() {
+        return new Stmt\Namespace_($this->name, $this->stmts);
+    }
+}

lib/PhpParser/Builder/Param.php

@@ -9,9 +9,9 @@ class Param extends PhpParser\BuilderAbstract
 {
     protected $name;
 
-    protected $default;
-    protected $type;
-    protected $byRef;
+    protected $default = null;
+    protected $type = null;
+    protected $byRef = false;
 
     /**
      * Creates a parameter builder.
@@ -20,10 +20,6 @@ class Param extends PhpParser\BuilderAbstract
      */
     public function __construct($name) {
         $this->name = $name;
-
-        $this->default = null;
-        $this->type = null;
-        $this->byRef = false;
     }
 
     /**
@@ -31,7 +27,7 @@ class Param extends PhpParser\BuilderAbstract
      *
      * @param mixed $value Default value to use
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function setDefault($value) {
         $this->default = $this->normalizeValue($value);
@@ -44,7 +40,7 @@ class Param extends PhpParser\BuilderAbstract
      *
      * @param string|Node\Name $type Type hint to use
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function setTypeHint($type) {
         if ($type === 'array' || $type === 'callable') {
@@ -59,7 +55,7 @@ class Param extends PhpParser\BuilderAbstract
     /**
      * Make the parameter accept the value by reference.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeByRef() {
         $this->byRef = true;

lib/PhpParser/Builder/Property.php

@@ -9,8 +9,9 @@ class Property extends PhpParser\BuilderAbstract
 {
     protected $name;
 
-    protected $type;
-    protected $default;
+    protected $type = 0;
+    protected $default = null;
+    protected $attributes = array();
 
     /**
      * Creates a property builder.
@@ -19,15 +20,12 @@ class Property extends PhpParser\BuilderAbstract
      */
     public function __construct($name) {
         $this->name = $name;
-
-        $this->type = 0;
-        $this->default = null;
     }
 
     /**
      * Makes the property public.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makePublic() {
         $this->setModifier(Stmt\Class_::MODIFIER_PUBLIC);
@@ -38,7 +36,7 @@ class Property extends PhpParser\BuilderAbstract
     /**
      * Makes the property protected.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeProtected() {
         $this->setModifier(Stmt\Class_::MODIFIER_PROTECTED);
@@ -49,7 +47,7 @@ class Property extends PhpParser\BuilderAbstract
     /**
      * Makes the property private.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makePrivate() {
         $this->setModifier(Stmt\Class_::MODIFIER_PRIVATE);
@@ -60,7 +58,7 @@ class Property extends PhpParser\BuilderAbstract
     /**
      * Makes the property static.
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function makeStatic() {
         $this->setModifier(Stmt\Class_::MODIFIER_STATIC);
@@ -73,7 +71,7 @@ class Property extends PhpParser\BuilderAbstract
      *
      * @param mixed $value Default value to use
      *
-     * @return self The builder instance (for fluid interface)
+     * @return $this The builder instance (for fluid interface)
      */
     public function setDefault($value) {
         $this->default = $this->normalizeValue($value);
@@ -81,6 +79,21 @@ class Property extends PhpParser\BuilderAbstract
         return $this;
     }
 
+    /**
+     * Sets doc comment for the property.
+     *
+     * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function setDocComment($docComment) {
+        $this->attributes = array(
+            'comments' => array($this->normalizeDocComment($docComment))
+        );
+
+        return $this;
+    }
+
     /**
      * Returns the built class node.
      *
@@ -91,7 +104,8 @@ class Property extends PhpParser\BuilderAbstract
             $this->type !== 0 ? $this->type : Stmt\Class_::MODIFIER_PUBLIC,
             array(
                 new Stmt\PropertyProperty($this->name, $this->default)
-            )
+            ),
+            $this->attributes
         );
     }
 }

lib/PhpParser/Builder/Trait_.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
+
+class Trait_ extends Declaration
+{
+    protected $name;
+    protected $properties = array();
+    protected $methods = array();
+
+    /**
+     * Creates an interface builder.
+     *
+     * @param string $name Name of the interface
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param Stmt|PhpParser\Builder $stmt The statement to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addStmt($stmt) {
+        $stmt = $this->normalizeNode($stmt);
+
+        if ($stmt instanceof Stmt\Property) {
+            $this->properties[] = $stmt;
+        } else if ($stmt instanceof Stmt\ClassMethod) {
+            $this->methods[] = $stmt;
+        } else {
+            throw new \LogicException(sprintf('Unexpected node of type "%s"', $stmt->getType()));
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns the built trait node.
+     *
+     * @return Stmt\Trait_ The built interface node
+     */
+    public function getNode() {
+        return new Stmt\Trait_(
+            $this->name, array_merge($this->properties, $this->methods), $this->attributes
+        );
+    }
+}

lib/PhpParser/Builder/Use_.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser\BuilderAbstract;
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+
+/**
+ * @method $this as(string $alias) Sets alias for used name.
+ */
+class Use_ extends BuilderAbstract {
+    protected $name;
+    protected $type;
+    protected $alias = null;
+
+    /**
+     * Creates a name use (alias) builder.
+     *
+     * @param Node\Name|string $name Name of the entity (namespace, class, function, constant) to alias
+     * @param int              $type One of the Stmt\Use_::TYPE_* constants
+     */
+    public function __construct($name, $type) {
+        $this->name = $this->normalizeName($name);
+        $this->type = $type;
+    }
+
+    /**
+     * Sets alias for used name.
+     *
+     * @param string $alias Alias to use (last component of full name by default)
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    protected function as_($alias) {
+        $this->alias = $alias;
+        return $this;
+    }
+    public function __call($name, $args) {
+        if (method_exists($this, $name . '_')) {
+            return call_user_func_array(array($this, $name . '_'), $args);
+        }
+
+        throw new \LogicException(sprintf('Method "%s" does not exist', $name));
+    }
+
+    /**
+     * Returns the built node.
+     *
+     * @return Node The built node
+     */
+    public function getNode() {
+        $alias = null !== $this->alias ? $this->alias : $this->name->getLast();
+        return new Stmt\Use_(array(
+            new Stmt\UseUse($this->name, $alias)
+        ), $this->type);
+    }
+}

lib/PhpParser/BuilderAbstract.php

@@ -6,6 +6,7 @@ use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Stmt;
 use PhpParser\Node\Scalar;
+use PhpParser\Comment;
 
 abstract class BuilderAbstract implements Builder {
     /**
@@ -35,11 +36,23 @@ abstract class BuilderAbstract implements Builder {
     protected function normalizeName($name) {
         if ($name instanceof Name) {
             return $name;
+        } elseif (is_string($name)) {
+            if (!$name) {
+                throw new \LogicException('Name cannot be empty');
+            }
+
+            if ($name[0] == '\\') {
+                return new Name\FullyQualified(substr($name, 1));
+            } elseif (0 === strpos($name, 'namespace\\')) {
+                return new Name\Relative(substr($name, strlen('namespace\\')));
             } else {
                 return new Name($name);
             }
         }
 
+        throw new \LogicException('Name must be a string or an instance of PhpParser\Node\Name');
+    }
+
     /**
      * Normalizes a value: Converts nulls, booleans, integers,
      * floats, strings and arrays into their respective nodes
@@ -64,7 +77,7 @@ abstract class BuilderAbstract implements Builder {
         } elseif (is_float($value)) {
             return new Scalar\DNumber($value);
         } elseif (is_string($value)) {
-            return new Scalar\String($value);
+            return new Scalar\String_($value);
         } elseif (is_array($value)) {
             $items = array();
             $lastKey = -1;
@@ -89,6 +102,23 @@ abstract class BuilderAbstract implements Builder {
         }
     }
 
+    /**
+     * Normalizes a doc comment: Converts plain strings to PhpParser\Comment\Doc.
+     *
+     * @param Comment\Doc|string $docComment The doc comment to normalize
+     *
+     * @return Comment\Doc The normalized doc comment
+     */
+    protected function normalizeDocComment($docComment) {
+        if ($docComment instanceof Comment\Doc) {
+            return $docComment;
+        } else if (is_string($docComment)) {
+            return new Comment\Doc($docComment);
+        } else {
+            throw new \LogicException('Doc comment must be a string or an instance of PhpParser\Comment\Doc');
+        }
+    }
+
     /**
      * Sets a modifier in the $this->type property.
      *

lib/PhpParser/BuilderFactory.php

@@ -3,18 +3,32 @@
 namespace PhpParser;
 
 use PhpParser\Builder;
+use PhpParser\Node\Stmt\Use_;
 
 /**
- * "class", "interface" and "function" are reserved keywords, so the methods are defined as _class(),
- * _interface() and _function() in the class and are made available as class(), interface() and function()
- * through __call() magic.
+ * The following methods use reserved keywords, so their implementation is defined with an underscore and made available
+ * with the reserved name through __call() magic.
  *
+ * @method Builder\Namespace_ namespace(string $name) Creates a namespace builder.
  * @method Builder\Class_     class(string $name)     Creates a class builder.
- * @method Builder\Function_  function(string $name)  Creates a function builder
  * @method Builder\Interface_ interface(string $name) Creates an interface builder.
+ * @method Builder\Trait_     trait(string $name)     Creates a trait builder.
+ * @method Builder\Function_  function(string $name)  Creates a function builder.
+ * @method Builder\Use_       use(string $name)       Creates a namespace/class use builder.
  */
 class BuilderFactory
 {
+    /**
+     * Creates a namespace builder.
+     * 
+     * @param null|string|Node\Name $name Name of the namespace
+     *
+     * @return Builder\Namespace_ The created namespace builder
+     */
+    protected function _namespace($name) {
+        return new Builder\Namespace_($name);
+    }
+
     /**
      * Creates a class builder.
      *
@@ -27,7 +41,7 @@ class BuilderFactory
     }
 
     /**
-     * Creates a interface builder.
+     * Creates an interface builder.
      *
      * @param string $name Name of the interface
      *
@@ -37,6 +51,17 @@ class BuilderFactory
         return new Builder\Interface_($name);
     }
 
+    /**
+     * Creates a trait builder.
+     *
+     * @param string $name Name of the trait
+     *
+     * @return Builder\Trait_ The created trait builder
+     */
+    protected function _trait($name) {
+        return new Builder\Trait_($name);
+    }
+
     /**
      * Creates a method builder.
      *
@@ -81,6 +106,17 @@ class BuilderFactory
         return new Builder\Function_($name);
     }
 
+    /**
+     * Creates a namespace/class use builder.
+     *
+     * @param string|Node\Name Name to alias
+     *
+     * @return Builder\Use_ The create use builder
+     */
+    protected function _use($name) {
+        return new Builder\Use_($name, Use_::TYPE_NORMAL);
+    }
+
     public function __call($name, array $args) {
         if (method_exists($this, '_' . $name)) {
             return call_user_func_array(array($this, '_' . $name), $args);

lib/PhpParser/Error.php

@@ -5,17 +5,22 @@ namespace PhpParser;
 class Error extends \RuntimeException
 {
     protected $rawMessage;
-    protected $rawLine;
+    protected $attributes;
 
     /**
      * Creates an Exception signifying a parse error.
      *
      * @param string    $message    Error message
-     * @param int    $line    Error line in PHP file
+     * @param array|int $attributes Attributes of node/token where error occurred
+     *                              (or start line of error -- deprecated)
      */
-    public function __construct($message, $line = -1) {
+    public function __construct($message, $attributes = array()) {
         $this->rawMessage = (string) $message;
-        $this->rawLine    = (int) $line;
+        if (is_array($attributes)) {
+            $this->attributes = $attributes;
+        } else {
+            $this->attributes = array('startLine' => $attributes);
+        }
         $this->updateMessage();
     }
 
@@ -28,6 +33,34 @@ class Error extends \RuntimeException
         return $this->rawMessage;
     }
 
+    /**
+     * Gets the line the error starts in.
+     *
+     * @return int Error start line
+     */
+    public function getStartLine() {
+        return isset($this->attributes['startLine']) ? $this->attributes['startLine'] : -1;
+    }
+
+    /**
+     * Gets the line the error ends in.
+     *
+     * @return int Error end line
+     */
+    public function getEndLine() {
+        return isset($this->attributes['endLine']) ? $this->attributes['endLine'] : -1;
+    }
+
+
+    /**
+     * Gets the attributes of the node/token the error occurred at.
+     *
+     * @return array
+     */
+    public function getAttributes() {
+        return $this->attributes;
+    }
+
     /**
      * Sets the line of the PHP file the error occurred in.
      *
@@ -39,22 +72,65 @@ class Error extends \RuntimeException
     }
 
     /**
-     * Gets the error line in the PHP file.
+     * Sets the line the error starts in.
      *
-     * @return int Error line in the PHP file
+     * @param int $line Error start line
      */
-    public function getRawLine() {
-        return $this->rawLine;
+    public function setStartLine($line) {
+        $this->attributes['startLine'] = (int) $line;
+        $this->updateMessage();
     }
 
     /**
-     * Sets the line of the PHP file the error occurred in.
+     * Returns whether the error has start and end column information.
      *
-     * @param int $line Error line in the PHP file
+     * For column information enable the startFilePos and endFilePos in the lexer options.
+     *
+     * @return bool
      */
-    public function setRawLine($line) {
-        $this->rawLine = (int) $line;
-        $this->updateMessage();
+    public function hasColumnInfo() {
+        return isset($this->attributes['startFilePos']) && isset($this->attributes['endFilePos']);
+    }
+
+    /**
+     * Gets the start column (1-based) into the line where the error started.
+     *
+     * @param string $code Source code of the file
+     * @return int
+     */
+    public function getStartColumn($code) {
+        if (!$this->hasColumnInfo()) {
+            throw new \RuntimeException('Error does not have column information');
+        }
+
+        return $this->toColumn($code, $this->attributes['startFilePos']);
+    }
+
+    /**
+     * Gets the end column (1-based) into the line where the error ended.
+     *
+     * @param string $code Source code of the file
+     * @return int
+     */
+    public function getEndColumn($code) {
+        if (!$this->hasColumnInfo()) {
+            throw new \RuntimeException('Error does not have column information');
+        }
+
+        return $this->toColumn($code, $this->attributes['endFilePos']);
+    }
+
+    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;
     }
 
     /**
@@ -63,10 +139,20 @@ class Error extends \RuntimeException
     protected function updateMessage() {
         $this->message = $this->rawMessage;
 
-        if (-1 === $this->rawLine) {
+        if (-1 === $this->getStartLine()) {
             $this->message .= ' on unknown line';
         } else {
-            $this->message .= ' on line ' . $this->rawLine;
+            $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/Lexer.php

@@ -8,20 +8,36 @@ class Lexer
     protected $tokens;
     protected $pos;
     protected $line;
+    protected $filePos;
 
     protected $tokenMap;
     protected $dropTokens;
 
+    protected $usedAttributes;
+
     /**
      * Creates a Lexer.
+     *
+     * @param array $options Options array. Currently only the 'usedAttributes' option is supported,
+     *                       which is an array of attributes to add to the AST nodes. Possible attributes
+     *                       are: 'comments', 'startLine', 'endLine', 'startTokenPos', 'endTokenPos',
+     *                       'startFilePos', 'endFilePos'. The option defaults to the first three.
+     *                       For more info see getNextToken() docs.
      */
-    public function __construct() {
+    public function __construct(array $options = array()) {
         // map from internal tokens to PhpParser tokens
         $this->tokenMap = $this->createTokenMap();
 
         // map of tokens to drop while lexing (the map is only used for isset lookup,
         // that's why the value is simply set to 1; the value is never actually used.)
         $this->dropTokens = array_fill_keys(array(T_WHITESPACE, T_OPEN_TAG), 1);
+
+        // the usedAttributes member is a map of the used attribute names to a dummy
+        // value (here "true")
+        $options += array(
+            'usedAttributes' => array('comments', 'startLine', 'endLine'),
+        );
+        $this->usedAttributes = array_fill_keys($options['usedAttributes'], true);
     }
 
     /**
@@ -32,17 +48,20 @@ class Lexer
      * @throws Error on lexing errors (unterminated comment or unexpected character)
      */
     public function startLexing($code) {
-        $scream = ini_set('xdebug.scream', 0);
+        $scream = ini_set('xdebug.scream', '0');
 
         $this->resetErrors();
         $this->tokens = @token_get_all($code);
         $this->handleErrors();
 
+        if (false !== $scream) {
             ini_set('xdebug.scream', $scream);
+        }
 
         $this->code = $code; // keep the code around for __halt_compiler() handling
         $this->pos  = -1;
         $this->line =  1;
+        $this->filePos = 0;
     }
 
     protected function resetErrors() {
@@ -59,7 +78,7 @@ class Lexer
             '~^Unterminated comment starting line ([0-9]+)$~',
             $error['message'], $matches
         )) {
-            throw new Error('Unterminated comment', $matches[1]);
+            throw new Error('Unterminated comment', (int) $matches[1]);
         }
 
         if (preg_match(
@@ -81,6 +100,19 @@ class Lexer
     /**
      * Fetches the next token.
      *
+     * The available attributes are determined by the 'usedAttributes' option, which can
+     * be specified in the constructor. The following attributes are supported:
+     *
+     *  * 'comments'      => Array of PhpParser\Comment or PhpParser\Comment\Doc instances,
+     *                       representing all comments that occurred between the previous
+     *                       non-discarded token and the current one.
+     *  * 'startLine'     => Line in which the node starts.
+     *  * 'endLine'       => Line in which the node ends.
+     *  * 'startTokenPos' => Offset into the token array of the first token in the node.
+     *  * 'endTokenPos'   => Offset into the token array of the last token in the node.
+     *  * 'startFilePos'  => Offset into the code string of the first character that is part of the node.
+     *  * 'endFilePos'    => Offset into the code string of the last character that is part of the node
+     *
      * @param mixed $value           Variable to store token content in
      * @param mixed $startAttributes Variable to store start attributes in
      * @param mixed $endAttributes   Variable to store end attributes in
@@ -91,42 +123,95 @@ class Lexer
         $startAttributes = array();
         $endAttributes   = array();
 
-        while (isset($this->tokens[++$this->pos])) {
+        while (1) {
+            if (isset($this->tokens[++$this->pos])) {
                 $token = $this->tokens[$this->pos];
+            } else {
+                // EOF token with ID 0
+                $token = "\0";
+            }
+
+            if (isset($this->usedAttributes['startTokenPos'])) {
+                $startAttributes['startTokenPos'] = $this->pos;
+            }
+            if (isset($this->usedAttributes['startFilePos'])) {
+                $startAttributes['startFilePos'] = $this->filePos;
+            }
 
             if (is_string($token)) {
-                $startAttributes['startLine'] = $this->line;
-                $endAttributes['endLine']     = $this->line;
-
                 // bug in token_get_all
                 if ('b"' === $token) {
                     $value = 'b"';
-                    return ord('"');
+                    $this->filePos += 2;
+                    $id = ord('"');
                 } else {
                     $value = $token;
-                    return ord($token);
+                    $this->filePos += 1;
+                    $id = ord($token);
                 }
+
+                if (isset($this->usedAttributes['startLine'])) {
+                    $startAttributes['startLine'] = $this->line;
+                }
+                if (isset($this->usedAttributes['endLine'])) {
+                    $endAttributes['endLine'] = $this->line;
+                }
+                if (isset($this->usedAttributes['endTokenPos'])) {
+                    $endAttributes['endTokenPos'] = $this->pos;
+                }
+                if (isset($this->usedAttributes['endFilePos'])) {
+                    $endAttributes['endFilePos'] = $this->filePos - 1;
+                }
+
+                return $id;
             } else {
                 $this->line += substr_count($token[1], "\n");
+                $this->filePos += strlen($token[1]);
 
                 if (T_COMMENT === $token[0]) {
+                    if (isset($this->usedAttributes['comments'])) {
                         $startAttributes['comments'][] = new Comment($token[1], $token[2]);
+                    }
                 } elseif (T_DOC_COMMENT === $token[0]) {
+                    if (isset($this->usedAttributes['comments'])) {
                         $startAttributes['comments'][] = new Comment\Doc($token[1], $token[2]);
+                    }
                 } elseif (!isset($this->dropTokens[$token[0]])) {
                     $value = $token[1];
+
+                    if (isset($this->usedAttributes['startLine'])) {
                         $startAttributes['startLine'] = $token[2];
+                    }
+                    if (isset($this->usedAttributes['endLine'])) {
                         $endAttributes['endLine'] = $this->line;
+                    }
+                    if (isset($this->usedAttributes['endTokenPos'])) {
+                        $endAttributes['endTokenPos'] = $this->pos;
+                    }
+                    if (isset($this->usedAttributes['endFilePos'])) {
+                        $endAttributes['endFilePos'] = $this->filePos - 1;
+                    }
 
                     return $this->tokenMap[$token[0]];
                 }
             }
         }
 
-        $startAttributes['startLine'] = $this->line;
+        throw new \RuntimeException('Reached end of lexer loop');
+    }
 
-        // 0 is the EOF token
-        return 0;
+    /**
+     * Returns the token array for current code.
+     *
+     * The token array is in the same format as provided by the
+     * token_get_all() function and does not discard tokens (i.e.
+     * whitespace and comments are included). The token position
+     * attributes are against this token array.
+     *
+     * @return array Array of tokens in token_get_all() format
+     */
+    public function getTokens() {
+        return $this->tokens;
     }
 
     /**
@@ -135,23 +220,13 @@ class Lexer
      * @return string Remaining text
      */
     public function handleHaltCompiler() {
-        // get the length of the text before the T_HALT_COMPILER token
-        $textBefore = '';
-        for ($i = 0; $i <= $this->pos; ++$i) {
-            if (is_string($this->tokens[$i])) {
-                $textBefore .= $this->tokens[$i];
-            } else {
-                $textBefore .= $this->tokens[$i][1];
-            }
-        }
-
         // text after T_HALT_COMPILER, still including ();
-        $textAfter = substr($this->code, strlen($textBefore));
+        $textAfter = substr($this->code, $this->filePos);
 
         // ensure that it is followed by ();
         // this simplifies the situation, by not allowing any comments
         // in between of the tokens.
-        if (!preg_match('~\s*\(\s*\)\s*(?:;|\?>\r?\n?)~', $textAfter, $matches)) {
+        if (!preg_match('~^\s*\(\s*\)\s*(?:;|\?>\r?\n?)~', $textAfter, $matches)) {
             throw new Error('__HALT_COMPILER must be followed by "();"');
         }
 
@@ -177,22 +252,34 @@ class Lexer
         // 256 is the minimum possible token number, as everything below
         // it is an ASCII value
         for ($i = 256; $i < 1000; ++$i) {
-            // T_DOUBLE_COLON is equivalent to T_PAAMAYIM_NEKUDOTAYIM
             if (T_DOUBLE_COLON === $i) {
+                // T_DOUBLE_COLON is equivalent to T_PAAMAYIM_NEKUDOTAYIM
                 $tokenMap[$i] = Parser::T_PAAMAYIM_NEKUDOTAYIM;
-            // T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
             } elseif(T_OPEN_TAG_WITH_ECHO === $i) {
+                // T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
                 $tokenMap[$i] = Parser::T_ECHO;
-            // T_CLOSE_TAG is equivalent to ';'
             } elseif(T_CLOSE_TAG === $i) {
+                // T_CLOSE_TAG is equivalent to ';'
                 $tokenMap[$i] = ord(';');
-            // and the others can be mapped directly
-            } elseif ('UNKNOWN' !== ($name = token_name($i))
-                      && defined($name = 'PhpParser\Parser::' . $name)
-            ) {
+            } elseif ('UNKNOWN' !== $name = token_name($i)) {
+                if ('T_HASHBANG' === $name) {
+                    // HHVM uses a special token for #! hashbang lines
+                    $tokenMap[$i] = Parser::T_INLINE_HTML;
+                } else if (defined($name = 'PhpParser\Parser::' . $name)) {
+                    // Other tokens can be mapped directly
                     $tokenMap[$i] = constant($name);
                 }
             }
+        }
+
+        // HHVM uses a special token for numbers that overflow to double
+        if (defined('T_ONUMBER')) {
+            $tokenMap[T_ONUMBER] = Parser::T_DNUMBER;
+        }
+        // HHVM also has a separate token for the __COMPILER_HALT_OFFSET__ constant
+        if (defined('T_COMPILER_HALT_OFFSET')) {
+            $tokenMap[T_COMPILER_HALT_OFFSET] = Parser::T_STRING;
+        }
 
         return $tokenMap;
     }

lib/PhpParser/Lexer/Emulative.php

@@ -15,13 +15,17 @@ class Emulative extends \PhpParser\Lexer
     const T_ELLIPSIS   = 1001;
     const T_POW        = 1002;
     const T_POW_EQUAL  = 1003;
+    const T_COALESCE   = 1004;
+    const T_SPACESHIP  = 1005;
+    const T_YIELD_FROM = 1006;
 
+    const PHP_7_0 = '7.0.0dev';
     const PHP_5_6 = '5.6.0rc1';
     const PHP_5_5 = '5.5.0beta1';
     const PHP_5_4 = '5.4.0beta1';
 
-    public function __construct() {
-        parent::__construct();
+    public function __construct(array $options = array()) {
+        parent::__construct($options);
 
         $newKeywordsPerVersion = array(
             self::PHP_5_5 => array(
@@ -45,12 +49,20 @@ class Emulative extends \PhpParser\Lexer
             $this->newKeywords += $newKeywords;
         }
 
-        if (version_compare(PHP_VERSION, self::PHP_5_6, '<')) {
+        if (version_compare(PHP_VERSION, self::PHP_7_0, '>=')) {
+            return;
+        }
+        $this->tokenMap[self::T_COALESCE] = Parser::T_COALESCE;
+        $this->tokenMap[self::T_SPACESHIP] = Parser::T_SPACESHIP;
+        $this->tokenMap[self::T_YIELD_FROM] = Parser::T_YIELD_FROM;
+
+        if (version_compare(PHP_VERSION, self::PHP_5_6, '>=')) {
+            return;
+        }
         $this->tokenMap[self::T_ELLIPSIS]  = Parser::T_ELLIPSIS;
         $this->tokenMap[self::T_POW]       = Parser::T_POW;
         $this->tokenMap[self::T_POW_EQUAL] = Parser::T_POW_EQUAL;
     }
-    }
 
     public function startLexing($code) {
         $this->inObjectAccess = false;
@@ -60,6 +72,10 @@ class Emulative extends \PhpParser\Lexer
         if ($preprocessedCode !== $code) {
             $this->postprocessTokens();
         }
+
+        // Set code property back to the original code, so __halt_compiler()
+        // handling and (start|end)FilePos attributes use the correct offsets
+        $this->code = $code;
     }
 
     /*
@@ -71,6 +87,17 @@ class Emulative extends \PhpParser\Lexer
      * inside a string, i.e. a place where they don't have a special meaning).
      */
     protected function preprocessCode($code) {
+        if (version_compare(PHP_VERSION, self::PHP_7_0, '>=')) {
+            return $code;
+        }
+
+        $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 (version_compare(PHP_VERSION, self::PHP_5_6, '>=')) {
             return $code;
         }
@@ -106,8 +133,9 @@ class Emulative extends \PhpParser\Lexer
                 if ('BINARY' === $matches[1]) {
                     // the binary number can either be an integer or a double, so return a LNUMBER
                     // or DNUMBER respectively
+                    $isInt = is_int(bindec($matches[2]));
                     $replace = array(
-                        array(is_int(bindec($matches[2])) ? T_LNUMBER : T_DNUMBER, $matches[2], $this->tokens[$i + 1][2])
+                        array($isInt ? T_LNUMBER : T_DNUMBER, $matches[2], $this->tokens[$i + 1][2])
                     );
                 } else if ('ELLIPSIS' === $matches[1]) {
                     $replace = array(
@@ -121,9 +149,21 @@ class Emulative extends \PhpParser\Lexer
                     $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 = $this->hex2bin($matches[2]);
+                    $replace = array(
+                        array(self::T_YIELD_FROM, $content, $this->tokens[$i + 1][2] - substr_count($content, "\n"))
+                    );
                 } else {
-                    // just ignore all other __EMU__ sequences
-                    continue;
+                    throw new \RuntimeException('Invalid __EMU__ sequence');
                 }
 
                 array_splice($this->tokens, $i, 3, $replace);
@@ -155,11 +195,22 @@ class Emulative extends \PhpParser\Lexer
             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 $this->hex2bin($matches[2]);
         } else {
             return $matches[0];
         }
     }
 
+    private function hex2bin($str) {
+        // TODO Drop when removing support for PHP 5.3
+        return pack('H*', $str);
+    }
+
     public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
         $token = parent::getNextToken($value, $startAttributes, $endAttributes);
 
@@ -170,11 +221,9 @@ class Emulative extends \PhpParser\Lexer
             if (isset($this->newKeywords[strtolower($value)])) {
                 return $this->newKeywords[strtolower($value)];
             }
-        // keep track of whether we currently are in an object access (after ->)
-        } elseif (Parser::T_OBJECT_OPERATOR === $token) {
-            $this->inObjectAccess = true;
         } else {
-            $this->inObjectAccess = false;
+            // keep track of whether we currently are in an object access (after ->)
+            $this->inObjectAccess = Parser::T_OBJECT_OPERATOR === $token;
         }
 
         return $token;

lib/PhpParser/Node/Arg.php

@@ -4,13 +4,15 @@ namespace PhpParser\Node;
 
 use PhpParser\NodeAbstract;
 
-/**
- * @property Expr $value  Value to pass
- * @property bool $byRef  Whether to pass by ref
- * @property bool $unpack Whether to unpack the argument
- */
 class Arg extends NodeAbstract
 {
+    /** @var Expr Value to pass */
+    public $value;
+    /** @var bool Whether to pass by ref */
+    public $byRef;
+    /** @var bool Whether to unpack the argument */
+    public $unpack;
+
     /**
      * Constructs a function call argument node.
      *
@@ -20,13 +22,13 @@ class Arg extends NodeAbstract
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $value, $byRef = false, $unpack = false, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'value'  => $value,
-                'byRef'  => $byRef,
-                'unpack' => $unpack,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->value = $value;
+        $this->byRef = $byRef;
+        $this->unpack = $unpack;
+    }
+
+    public function getSubNodeNames() {
+        return array('value', 'byRef', 'unpack');
     }
 }

lib/PhpParser/Node/Const_.php

@@ -4,12 +4,13 @@ namespace PhpParser\Node;
 
 use PhpParser\NodeAbstract;
 
-/**
- * @property string              $name  Name
- * @property Expr $value Value
- */
 class Const_ extends NodeAbstract
 {
+    /** @var string Name */
+    public $name;
+    /** @var Expr Value */
+    public $value;
+
     /**
      * Constructs a const node for use in class const and const statements.
      *
@@ -18,12 +19,12 @@ class Const_ extends NodeAbstract
      * @param array   $attributes Additional attributes
      */
     public function __construct($name, Expr $value, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'name'  => $name,
-                'value' => $value,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->name = $name;
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames() {
+        return array('name', 'value');
     }
 }

lib/PhpParser/Node/Expr/ArrayDimFetch.php

@@ -4,12 +4,13 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr      $var Variable
- * @property null|Expr $dim Array index / dim
- */
 class ArrayDimFetch extends Expr
 {
+    /** @var Expr Variable */
+    public $var;
+    /** @var null|Expr Array index / dim */
+    public $dim;
+
     /**
      * Constructs an array index fetch node.
      *
@@ -18,12 +19,12 @@ class ArrayDimFetch extends Expr
      * @param array     $attributes Additional attributes
      */
     public function __construct(Expr $var, Expr $dim = null, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var,
-                'dim' => $dim
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->dim = $dim;
+    }
+
+    public function getSubnodeNames() {
+        return array('var', 'dim');
     }
 }

lib/PhpParser/Node/Expr/ArrayItem.php

@@ -4,13 +4,15 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr      $value Value
- * @property null|Expr $key   Key
- * @property bool                     $byRef Whether to assign by reference
- */
 class ArrayItem extends Expr
 {
+    /** @var null|Expr Key */
+    public $key;
+    /** @var Expr Value */
+    public $value;
+    /** @var bool Whether to assign by reference */
+    public $byRef;
+
     /**
      * Constructs an array item node.
      *
@@ -20,13 +22,13 @@ class ArrayItem extends Expr
      * @param array     $attributes Additional attributes
      */
     public function __construct(Expr $value, Expr $key = null, $byRef = false, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'key'   => $key,
-                'value' => $value,
-                'byRef' => $byRef
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->key = $key;
+        $this->value = $value;
+        $this->byRef = $byRef;
+    }
+
+    public function getSubNodeNames() {
+        return array('key', 'value', 'byRef');
     }
 }

lib/PhpParser/Node/Expr/Array_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property ArrayItem[] $items Items
- */
 class Array_ extends Expr
 {
+    /** @var ArrayItem[] Items */
+    public $items;
+
     /**
      * Constructs an array node.
      *
@@ -16,11 +16,11 @@ class Array_ extends Expr
      * @param array       $attributes Additional attributes
      */
     public function __construct(array $items = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'items' => $items
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->items = $items;
+    }
+
+    public function getSubNodeNames() {
+        return array('items');
     }
 }

lib/PhpParser/Node/Expr/Assign.php

@@ -4,12 +4,13 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $var  Variable
- * @property Expr $expr Expression
- */
 class Assign extends Expr
 {
+    /** @var Expr Variable */
+    public $var;
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs an assignment node.
      *
@@ -18,12 +19,12 @@ class Assign extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $var, Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('var', 'expr');
     }
 }

lib/PhpParser/Node/Expr/AssignOp.php

@@ -10,6 +10,11 @@ use PhpParser\Node\Expr;
  */
 abstract class AssignOp extends Expr
 {
+    /** @var Expr Variable */
+    public $var;
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs a compound assignment operation node.
      *
@@ -18,12 +23,12 @@ abstract class AssignOp extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $var, Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('var', 'expr');
     }
 }

lib/PhpParser/Node/Expr/AssignRef.php

@@ -10,6 +10,11 @@ use PhpParser\Node\Expr;
  */
 class AssignRef extends Expr
 {
+    /** @var Expr Variable reference is assigned to */
+    public $var;
+    /** @var Expr Variable which is referenced */
+    public $expr;
+
     /**
      * Constructs an assignment node.
      *
@@ -18,12 +23,12 @@ class AssignRef extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $var, Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('var', 'expr');
     }
 }

lib/PhpParser/Node/Expr/BinaryOp.php

@@ -4,12 +4,13 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $left  The left hand side expression
- * @property Expr $right The right hand side expression
- */
-class BinaryOp extends Expr
+abstract class BinaryOp extends Expr
 {
+    /** @var Expr The left hand side expression */
+    public $left;
+    /** @var Expr The right hand side expression */
+    public $right;
+
     /**
      * Constructs a bitwise and node.
      *
@@ -18,12 +19,12 @@ class BinaryOp extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $left, Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->left = $left;
+        $this->right = $right;
+    }
+
+    public function getSubNodeNames() {
+        return array('left', 'right');
     }
 }

lib/PhpParser/Node/Expr/BinaryOp/Coalesce.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace PhpParser\Node\Expr\BinaryOp;
+
+use PhpParser\Node\Expr\BinaryOp;
+
+class Coalesce extends BinaryOp
+{
+}

lib/PhpParser/Node/Expr/BinaryOp/Spaceship.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace PhpParser\Node\Expr\BinaryOp;
+
+use PhpParser\Node\Expr\BinaryOp;
+
+class Spaceship extends BinaryOp
+{
+}

lib/PhpParser/Node/Expr/BitwiseNot.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class BitwiseNot extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs a bitwise not node.
      *
@@ -16,11 +16,11 @@ class BitwiseNot extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/BooleanNot.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class BooleanNot extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs a boolean not node.
      *
@@ -16,11 +16,11 @@ class BooleanNot extends Expr
      * @param array               $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/Cast.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 abstract class Cast extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs a cast node.
      *
@@ -16,11 +16,11 @@ abstract class Cast extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/Cast/Bool_.php

@@ -4,6 +4,6 @@ namespace PhpParser\Node\Expr\Cast;
 
 use PhpParser\Node\Expr\Cast;
 
-class Int extends Cast
+class Bool_ extends Cast
 {
 }

lib/PhpParser/Node/Expr/Cast/Int_.php

@@ -4,6 +4,6 @@ namespace PhpParser\Node\Expr\Cast;
 
 use PhpParser\Node\Expr\Cast;
 
-class Bool extends Cast
+class Int_ extends Cast
 {
 }

lib/PhpParser/Node/Expr/Cast/Object_.php

@@ -4,6 +4,6 @@ namespace PhpParser\Node\Expr\Cast;
 
 use PhpParser\Node\Expr\Cast;
 
-class Object extends Cast
+class Object_ extends Cast
 {
 }

lib/PhpParser/Node/Expr/Cast/String_.php

@@ -4,6 +4,6 @@ namespace PhpParser\Node\Expr\Cast;
 
 use PhpParser\Node\Expr\Cast;
 
-class String extends Cast
+class String_ extends Cast
 {
 }

lib/PhpParser/Node/Expr/ClassConstFetch.php

@@ -5,12 +5,13 @@ namespace PhpParser\Node\Expr;
 use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
 
-/**
- * @property Name|Expr $class Class name
- * @property string    $name  Constant name
- */
 class ClassConstFetch extends Expr
 {
+    /** @var Name|Expr Class name */
+    public $class;
+    /** @var string Constant name */
+    public $name;
+
     /**
      * Constructs a class const fetch node.
      *
@@ -19,12 +20,12 @@ class ClassConstFetch extends Expr
      * @param array     $attributes Additional attributes
      */
     public function __construct($class, $name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'class' => $class,
-                'name'  => $name
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->class = $class;
+        $this->name = $name;
+    }
+
+    public function getSubNodeNames() {
+        return array('class', 'name');
     }
 }

lib/PhpParser/Node/Expr/Clone_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class Clone_ extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs a clone node.
      *
@@ -16,11 +16,11 @@ class Clone_ extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/Closure.php

@@ -4,16 +4,23 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node;
 use PhpParser\Node\Expr;
+use PhpParser\Node\FunctionLike;
 
-/**
- * @property Node[]       $stmts  Statements
- * @property Node\Param[] $params Parameters
- * @property ClosureUse[] $uses   use()s
- * @property bool         $byRef  Whether to return by reference
- * @property bool         $static Whether the closure is static
- */
-class Closure extends Expr
+class Closure extends Expr implements FunctionLike
 {
+    /** @var bool Whether the closure is static */
+    public $static;
+    /** @var bool Whether to return by reference */
+    public $byRef;
+    /** @var Node\Param[] Parameters */
+    public $params;
+    /** @var ClosureUse[] use()s */
+    public $uses;
+    /** @var null|string|Node\Name Return type */
+    public $returnType;
+    /** @var Node[] Statements */
+    public $stmts;
+
     /**
      * Constructs a lambda function node.
      *
@@ -22,19 +29,37 @@ class Closure extends Expr
      *                          'byRef'      => false  : Whether to return by reference
      *                          'params'     => array(): Parameters
      *                          'uses'       => array(): use()s
+     *                          'returnType' => null   : Return type
      *                          'stmts'      => array(): Statements
      * @param array $attributes Additional attributes
      */
     public function __construct(array $subNodes = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'static' => isset($subNodes['static']) ? $subNodes['static'] : false,
-                'byRef'  => isset($subNodes['byRef'])  ? $subNodes['byRef']  : false,
-                'params' => isset($subNodes['params']) ? $subNodes['params'] : array(),
-                'uses'   => isset($subNodes['uses'])   ? $subNodes['uses']   : array(),
-                'stmts'  => isset($subNodes['stmts'])  ? $subNodes['stmts']  : array(),
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->static = isset($subNodes['static']) ? $subNodes['static'] : false;
+        $this->byRef = isset($subNodes['byRef']) ? $subNodes['byRef'] : false;
+        $this->params = isset($subNodes['params']) ? $subNodes['params'] : array();
+        $this->uses = isset($subNodes['uses']) ? $subNodes['uses'] : array();
+        $this->returnType = isset($subNodes['returnType']) ? $subNodes['returnType'] : null;
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
+    }
+
+    public function getSubNodeNames() {
+        return array('static', 'byRef', 'params', 'uses', 'returnType', 'stmts');
+    }
+
+    public function returnsByRef() {
+        return $this->byRef;
+    }
+
+    public function getParams() {
+        return $this->params;
+    }
+
+    public function getReturnType() {
+        return $this->returnType;
+    }
+
+    public function getStmts() {
+        return $this->stmts;
     }
 }

lib/PhpParser/Node/Expr/ClosureUse.php

@@ -4,12 +4,13 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property string $var   Name of variable
- * @property bool   $byRef Whether to use by reference
- */
 class ClosureUse extends Expr
 {
+    /** @var string Name of variable */
+    public $var;
+    /** @var bool Whether to use by reference */
+    public $byRef;
+
     /**
      * Constructs a closure use node.
      *
@@ -18,12 +19,12 @@ class ClosureUse extends Expr
      * @param array       $attributes Additional attributes
      */
     public function __construct($var, $byRef = false, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'   => $var,
-                'byRef' => $byRef
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->byRef = $byRef;
+    }
+
+    public function getSubNodeNames() {
+        return array('var', 'byRef');
     }
 }

lib/PhpParser/Node/Expr/ConstFetch.php

@@ -5,11 +5,11 @@ namespace PhpParser\Node\Expr;
 use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
 
-/**
- * @property Name $name Constant name
- */
 class ConstFetch extends Expr
 {
+    /** @var Name Constant name */
+    public $name;
+
     /**
      * Constructs a const fetch node.
      *
@@ -17,11 +17,11 @@ class ConstFetch extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Name $name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'name'  => $name
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->name = $name;
+    }
+
+    public function getSubNodeNames() {
+        return array('name');
     }
 }

lib/PhpParser/Node/Expr/Empty_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class Empty_ extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs an empty() node.
      *
@@ -16,11 +16,11 @@ class Empty_ extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/ErrorSuppress.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class ErrorSuppress extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs an error suppress node.
      *
@@ -16,11 +16,11 @@ class ErrorSuppress extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/Eval_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class Eval_ extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs an eval() node.
      *
@@ -16,11 +16,11 @@ class Eval_ extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/Exit_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property null|Expr $expr Expression
- */
 class Exit_ extends Expr
 {
+    /** @var null|Expr Expression */
+    public $expr;
+
     /**
      * Constructs an exit() node.
      *
@@ -16,11 +16,11 @@ class Exit_ extends Expr
      * @param array                    $attributes Additional attributes
      */
     public function __construct(Expr $expr = null, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/FuncCall.php

@@ -5,12 +5,13 @@ namespace PhpParser\Node\Expr;
 use PhpParser\Node;
 use PhpParser\Node\Expr;
 
-/**
- * @property Node\Name|Expr $name Function name
- * @property Node\Arg[]                    $args Arguments
- */
 class FuncCall extends Expr
 {
+    /** @var Node\Name|Expr Function name */
+    public $name;
+    /** @var Node\Arg[] Arguments */
+    public $args;
+
     /**
      * Constructs a function call node.
      *
@@ -19,12 +20,12 @@ class FuncCall extends Expr
      * @param array                                   $attributes Additional attributes
      */
     public function __construct($name, array $args = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'name' => $name,
-                'args' => $args
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->name = $name;
+        $this->args = $args;
+    }
+
+    public function getSubNodeNames() {
+        return array('name', 'args');
     }
 }

lib/PhpParser/Node/Expr/Include_.php

@@ -4,10 +4,6 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- * @property int  $type Type of include
- */
 class Include_ extends Expr
 {
     const TYPE_INCLUDE      = 1;
@@ -15,6 +11,11 @@ class Include_ extends Expr
     const TYPE_REQUIRE      = 3;
     const TYPE_REQUIRE_ONCE = 4;
 
+    /** @var Expr Expression */
+    public $expr;
+    /** @var int Type of include */
+    public $type;
+
     /**
      * Constructs an include node.
      *
@@ -23,12 +24,12 @@ class Include_ extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, $type, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr,
-                'type' => $type
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+        $this->type = $type;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr', 'type');
     }
 }

lib/PhpParser/Node/Expr/Instanceof_.php

@@ -5,12 +5,13 @@ namespace PhpParser\Node\Expr;
 use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr  Expression
- * @property Name|Expr $class Class name
- */
 class Instanceof_ extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+    /** @var Name|Expr Class name */
+    public $class;
+
     /**
      * Constructs an instanceof check node.
      *
@@ -19,12 +20,12 @@ class Instanceof_ extends Expr
      * @param array     $attributes Additional attributes
      */
     public function __construct(Expr $expr, $class, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr'  => $expr,
-                'class' => $class
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+        $this->class = $class;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr', 'class');
     }
 }

lib/PhpParser/Node/Expr/Isset_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr[] $vars Variables
- */
 class Isset_ extends Expr
 {
+    /** @var Expr[] Variables */
+    public $vars;
+
     /**
      * Constructs an array node.
      *
@@ -16,11 +16,11 @@ class Isset_ extends Expr
      * @param array  $attributes Additional attributes
      */
     public function __construct(array $vars, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'vars' => $vars
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->vars = $vars;
+    }
+
+    public function getSubNodeNames() {
+        return array('vars');
     }
 }

lib/PhpParser/Node/Expr/List_.php

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

lib/PhpParser/Node/Expr/MethodCall.php

@@ -5,13 +5,15 @@ namespace PhpParser\Node\Expr;
 use PhpParser\Node\Arg;
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr        $var  Variable holding object
- * @property string|Expr $name Method name
- * @property Arg[]       $args Arguments
- */
 class MethodCall extends Expr
 {
+    /** @var Expr Variable holding object */
+    public $var;
+    /** @var string|Expr Method name */
+    public $name;
+    /** @var Arg[] Arguments */
+    public $args;
+
     /**
      * Constructs a function call node.
      *
@@ -21,13 +23,13 @@ class MethodCall extends Expr
      * @param array       $attributes Additional attributes
      */
     public function __construct(Expr $var, $name, array $args = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'name' => $name,
-                'args' => $args
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->name = $name;
+        $this->args = $args;
+    }
+
+    public function getSubNodeNames() {
+        return array('var', 'name', 'args');
     }
 }

lib/PhpParser/Node/Expr/New_.php

@@ -5,26 +5,27 @@ namespace PhpParser\Node\Expr;
 use PhpParser\Node;
 use PhpParser\Node\Expr;
 
-/**
- * @property Node\Name|Expr $class Class name
- * @property Node\Arg[]     $args  Arguments
- */
 class New_ extends Expr
 {
+    /** @var Node\Name|Expr|Node\Stmt\Class_ Class name */
+    public $class;
+    /** @var Node\Arg[] Arguments */
+    public $args;
+
     /**
      * Constructs a function call node.
      *
-     * @param Node\Name|Expr $class      Class name
+     * @param Node\Name|Expr|Node\Stmt\Class_ $class      Class name (or class node for anonymous classes)
      * @param Node\Arg[]                      $args       Arguments
      * @param array                           $attributes Additional attributes
      */
     public function __construct($class, array $args = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'class' => $class,
-                'args'  => $args
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->class = $class;
+        $this->args = $args;
+    }
+
+    public function getSubNodeNames() {
+        return array('class', 'args');
     }
 }

lib/PhpParser/Node/Expr/PostDec.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $var Variable
- */
 class PostDec extends Expr
 {
+    /** @var Expr Variable */
+    public $var;
+
     /**
      * Constructs a post decrement node.
      *
@@ -16,11 +16,11 @@ class PostDec extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+    }
+
+    public function getSubNodeNames() {
+        return array('var');
     }
 }

lib/PhpParser/Node/Expr/PostInc.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $var Variable
- */
 class PostInc extends Expr
 {
+    /** @var Expr Variable */
+    public $var;
+
     /**
      * Constructs a post increment node.
      *
@@ -16,11 +16,11 @@ class PostInc extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+    }
+
+    public function getSubNodeNames() {
+        return array('var');
     }
 }

lib/PhpParser/Node/Expr/PreDec.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $var Variable
- */
 class PreDec extends Expr
 {
+    /** @var Expr Variable */
+    public $var;
+
     /**
      * Constructs a pre decrement node.
      *
@@ -16,11 +16,11 @@ class PreDec extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+    }
+
+    public function getSubNodeNames() {
+        return array('var');
     }
 }

lib/PhpParser/Node/Expr/PreInc.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $var Variable
- */
 class PreInc extends Expr
 {
+    /** @var Expr Variable */
+    public $var;
+
     /**
      * Constructs a pre increment node.
      *
@@ -16,11 +16,11 @@ class PreInc extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+    }
+
+    public function getSubNodeNames() {
+        return array('var');
     }
 }

lib/PhpParser/Node/Expr/Print_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class Print_ extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs an print() node.
      *
@@ -16,11 +16,11 @@ class Print_ extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/PropertyFetch.php

@@ -4,12 +4,13 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr        $var  Variable holding object
- * @property string|Expr $name Property Name
- */
 class PropertyFetch extends Expr
 {
+    /** @var Expr Variable holding object */
+    public $var;
+    /** @var string|Expr Property name */
+    public $name;
+
     /**
      * Constructs a function call node.
      *
@@ -18,12 +19,12 @@ class PropertyFetch extends Expr
      * @param array       $attributes Additional attributes
      */
     public function __construct(Expr $var, $name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'name' => $name
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->name = $name;
+    }
+
+    public function getSubNodeNames() {
+        return array('var', 'name');
     }
 }

lib/PhpParser/Node/Expr/ShellExec.php

@@ -4,23 +4,23 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property array $parts Encapsed string array
- */
 class ShellExec extends Expr
 {
+    /** @var array Encapsed string array */
+    public $parts;
+
     /**
      * Constructs a shell exec (backtick) node.
      *
      * @param array $parts      Encapsed string array
      * @param array $attributes Additional attributes
      */
-    public function __construct($parts, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'parts' => $parts
-            ),
-            $attributes
-        );
+    public function __construct(array $parts, array $attributes = array()) {
+        parent::__construct(null, $attributes);
+        $this->parts = $parts;
+    }
+
+    public function getSubNodeNames() {
+        return array('parts');
     }
 }

lib/PhpParser/Node/Expr/StaticCall.php

@@ -5,13 +5,15 @@ namespace PhpParser\Node\Expr;
 use PhpParser\Node;
 use PhpParser\Node\Expr;
 
-/**
- * @property Node\Name|Expr $class Class name
- * @property string|Expr    $name  Method name
- * @property Node\Arg[]     $args  Arguments
- */
 class StaticCall extends Expr
 {
+    /** @var Node\Name|Expr Class name */
+    public $class;
+    /** @var string|Expr Method name */
+    public $name;
+    /** @var Node\Arg[] Arguments */
+    public $args;
+
     /**
      * Constructs a static method call node.
      *
@@ -21,13 +23,13 @@ class StaticCall extends Expr
      * @param array          $attributes Additional attributes
      */
     public function __construct($class, $name, array $args = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'class' => $class,
-                'name'  => $name,
-                'args'  => $args
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->class = $class;
+        $this->name = $name;
+        $this->args = $args;
+    }
+
+    public function getSubNodeNames() {
+        return array('class', 'name', 'args');
     }
 }

lib/PhpParser/Node/Expr/StaticPropertyFetch.php

@@ -5,12 +5,13 @@ namespace PhpParser\Node\Expr;
 use PhpParser\Node\Name;
 use PhpParser\Node\Expr;
 
-/**
- * @property Name|Expr   $class Class name
- * @property string|Expr $name  Property name
- */
 class StaticPropertyFetch extends Expr
 {
+    /** @var Name|Expr Class name */
+    public $class;
+    /** @var string|Expr Property name */
+    public $name;
+
     /**
      * Constructs a static property fetch node.
      *
@@ -19,12 +20,12 @@ class StaticPropertyFetch extends Expr
      * @param array       $attributes Additional attributes
      */
     public function __construct($class, $name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'class' => $class,
-                'name'  => $name
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->class = $class;
+        $this->name = $name;
+    }
+
+    public function getSubNodeNames() {
+        return array('class', 'name');
     }
 }

lib/PhpParser/Node/Expr/Ternary.php

@@ -4,13 +4,15 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr      $cond Condition
- * @property null|Expr $if   Expression for true
- * @property Expr      $else Expression for false
- */
 class Ternary extends Expr
 {
+    /** @var Expr Condition */
+    public $cond;
+    /** @var null|Expr Expression for true */
+    public $if;
+    /** @var Expr Expression for false */
+    public $else;
+
     /**
      * Constructs a ternary operator node.
      *
@@ -20,13 +22,13 @@ class Ternary extends Expr
      * @param array                    $attributes Additional attributes
      */
     public function __construct(Expr $cond, $if, Expr $else, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'cond' => $cond,
-                'if'   => $if,
-                'else' => $else
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->cond = $cond;
+        $this->if = $if;
+        $this->else = $else;
+    }
+
+    public function getSubNodeNames() {
+        return array('cond', 'if', 'else');
     }
 }

lib/PhpParser/Node/Expr/UnaryMinus.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class UnaryMinus extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs a unary minus node.
      *
@@ -16,11 +16,11 @@ class UnaryMinus extends Expr
      * @param array $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/UnaryPlus.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property Expr $expr Expression
- */
 class UnaryPlus extends Expr
 {
+    /** @var Expr Expression */
+    public $expr;
+
     /**
      * Constructs a unary plus node.
      *
@@ -16,11 +16,11 @@ class UnaryPlus extends Expr
      * @param array               $attributes Additional attributes
      */
     public function __construct(Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
     }
 }

lib/PhpParser/Node/Expr/Variable.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property string|Expr $name Name
- */
 class Variable extends Expr
 {
+    /** @var string|Expr Name */
+    public $name;
+
     /**
      * Constructs a variable node.
      *
@@ -16,11 +16,11 @@ class Variable extends Expr
      * @param array                      $attributes Additional attributes
      */
     public function __construct($name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                 'name' => $name
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->name = $name;
+    }
+
+    public function getSubNodeNames() {
+        return array('name');
     }
 }

lib/PhpParser/Node/Expr/YieldFrom.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node\Expr;
+
+class YieldFrom extends Expr
+{
+    /** @var Expr Expression to yield from */
+    public $expr;
+
+    /**
+     * Constructs an "yield from" node.
+     *
+     * @param Expr  $expr       Expression
+     * @param array $attributes Additional attributes
+     */
+    public function __construct(Expr $expr, array $attributes = array()) {
+        parent::__construct(null, $attributes);
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('expr');
+    }
+}

lib/PhpParser/Node/Expr/Yield_.php

@@ -4,12 +4,13 @@ namespace PhpParser\Node\Expr;
 
 use PhpParser\Node\Expr;
 
-/**
- * @property null|Expr $value Value expression
- * @property null|Expr $key   Key expression
- */
 class Yield_ extends Expr
 {
+    /** @var null|Expr Key expression */
+    public $key;
+    /** @var null|Expr Value expression */
+    public $value;
+
     /**
      * Constructs a yield expression node.
      *
@@ -18,12 +19,12 @@ class Yield_ extends Expr
      * @param array     $attributes Additional attributes
      */
     public function __construct(Expr $value = null, Expr $key = null, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'key'   => $key,
-                'value' => $value,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->key = $key;
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames() {
+        return array('key', 'value');
     }
 }

lib/PhpParser/Node/FunctionLike.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace PhpParser\Node;
+
+use PhpParser\Node;
+
+interface FunctionLike extends Node
+{
+    /**
+     * Whether to return by reference
+     *
+     * @return bool
+     */
+    public function returnsByRef();
+
+    /**
+     * List of parameters
+     *
+     * @return Node\Param[]
+     */
+    public function getParams();
+
+    /**
+     * Get the declared return type or null
+     * 
+     * @return null|string|Node\Name
+     */
+    public function getReturnType();
+
+    /**
+     * The function body
+     *
+     * @return Node\Stmt[]
+     */
+    public function getStmts();
+}

lib/PhpParser/Node/Name.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node;
 
 use PhpParser\NodeAbstract;
 
-/**
- * @property array $parts Parts of the name
- */
 class Name extends NodeAbstract
 {
+    /** @var string[] Parts of the name */
+    public $parts;
+
     /**
      * Constructs a name node.
      *
@@ -20,12 +20,12 @@ class Name extends NodeAbstract
             $parts = explode('\\', $parts);
         }
 
-        parent::__construct(
-            array(
-                'parts' => $parts,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->parts = $parts;
+    }
+
+    public function getSubNodeNames() {
+        return array('parts');
     }
 
     /**

lib/PhpParser/Node/Param.php

@@ -5,15 +5,19 @@ namespace PhpParser\Node;
 use PhpParser\Error;
 use PhpParser\NodeAbstract;
 
-/**
- * @property null|string|Name $type     Typehint
- * @property bool             $byRef    Whether is passed by reference
- * @property bool             $variadic Whether this is a variadic argument
- * @property string           $name     Name
- * @property null|Expr        $default  Default value
- */
 class Param extends NodeAbstract
 {
+    /** @var null|string|Name Typehint */
+    public $type;
+    /** @var bool Whether parameter is passed by reference */
+    public $byRef;
+    /** @var bool Whether this is a variadic argument */
+    public $variadic;
+    /** @var string Name */
+    public $name;
+    /** @var null|Expr Default value */
+    public $default;
+
     /**
      * Constructs a parameter node.
      *
@@ -24,20 +28,20 @@ class Param extends NodeAbstract
      * @param bool             $variadic   Whether this is a variadic argument
      * @param array            $attributes Additional attributes
      */
-    public function __construct($name, $default = null, $type = null, $byRef = false, $variadic = false, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'type'     => $type,
-                'byRef'    => $byRef,
-                'variadic' => $variadic,
-                'name'     => $name,
-                'default'  => $default,
-            ),
-            $attributes
-        );
+    public function __construct($name, Expr $default = null, $type = null, $byRef = false, $variadic = false, array $attributes = array()) {
+        parent::__construct(null, $attributes);
+        $this->type = $type;
+        $this->byRef = $byRef;
+        $this->variadic = $variadic;
+        $this->name = $name;
+        $this->default = $default;
 
         if ($variadic && null !== $default) {
-            throw new Error('Variadic parameter cannot have a default value');
+            throw new Error('Variadic parameter cannot have a default value', $default->getAttributes());
         }
     }
+
+    public function getSubNodeNames() {
+        return array('type', 'byRef', 'variadic', 'name', 'default');
+    }
 }

lib/PhpParser/Node/Scalar/DNumber.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Scalar;
 
 use PhpParser\Node\Scalar;
 
-/**
- * @property float $value Number value
- */
 class DNumber extends Scalar
 {
+    /** @var float Number value */
+    public $value;
+
     /**
      * Constructs a float number scalar node.
      *
@@ -16,15 +16,17 @@ class DNumber extends Scalar
      * @param array $attributes Additional attributes
      */
     public function __construct($value = 0.0, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'value' => $value
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames() {
+        return array('value');
     }
 
     /**
+     * @internal
+     *
      * Parses a DNUMBER token like PHP would.
      *
      * @param string $str A string number

lib/PhpParser/Node/Scalar/Encapsed.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Scalar;
 
 use PhpParser\Node\Scalar;
 
-/**
- * @property array $parts Encaps list
- */
 class Encapsed extends Scalar
 {
+    /** @var array Encaps list */
+    public $parts;
+
     /**
      * Constructs an encapsed string node.
      *
@@ -16,11 +16,11 @@ class Encapsed extends Scalar
      * @param array $attributes Additional attributes
      */
     public function __construct(array $parts = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'parts' => $parts
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->parts = $parts;
+    }
+
+    public function getSubNodeNames() {
+        return array('parts');
     }
 }

lib/PhpParser/Node/Scalar/LNumber.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Scalar;
 
 use PhpParser\Node\Scalar;
 
-/**
- * @property int $value Number value
- */
 class LNumber extends Scalar
 {
+    /** @var int Number value */
+    public $value;
+
     /**
      * Constructs an integer number scalar node.
      *
@@ -16,15 +16,17 @@ class LNumber extends Scalar
      * @param array $attributes Additional attributes
      */
     public function __construct($value = 0, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'value' => $value
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames() {
+        return array('value');
     }
 
     /**
+     * @internal
+     *
      * Parses an LNUMBER token (dec, hex, oct and bin notations) like PHP would.
      *
      * @param string $str A string number

lib/PhpParser/Node/Scalar/MagicConst.php

@@ -12,7 +12,11 @@ abstract class MagicConst extends Scalar
      * @param array $attributes Additional attributes
      */
     public function __construct(array $attributes = array()) {
-        parent::__construct(array(), $attributes);
+        parent::__construct(null, $attributes);
+    }
+
+    public function getSubNodeNames() {
+        return array();
     }
 
     /**

lib/PhpParser/Node/Scalar/String_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Scalar;
 
 use PhpParser\Node\Scalar;
 
-/**
- * @property string $value String value
- */
-class String extends Scalar
+class String_ extends Scalar
 {
+    /** @var string String value */
+    public $value;
+
     protected static $replacements = array(
         '\\' => '\\',
         '$'  =>  '$',
@@ -27,15 +27,17 @@ class String extends Scalar
      * @param array  $attributes Additional attributes
      */
     public function __construct($value = '', array $attributes = array()) {
-        parent::__construct(
-            array(
-                'value' => $value
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames() {
+        return array('value');
     }
 
     /**
+     * @internal
+     *
      * Parses a string token.
      *
      * @param string $str String token content
@@ -60,6 +62,8 @@ class String extends Scalar
     }
 
     /**
+     * @internal
+     *
      * Parses escape sequences in strings (all string types apart from single quoted).
      *
      * @param string      $str   String without quotes
@@ -79,7 +83,7 @@ class String extends Scalar
         );
     }
 
-    public static function parseCallback($matches) {
+    private static function parseCallback($matches) {
         $str = $matches[1];
 
         if (isset(self::$replacements[$str])) {
@@ -92,6 +96,8 @@ class String extends Scalar
     }
 
     /**
+     * @internal
+     *
      * Parses a constant doc string.
      *
      * @param string $startToken Doc string start token content (<<<SMTHG)
@@ -101,7 +107,7 @@ class String extends Scalar
      */
     public static function parseDocString($startToken, $str) {
         // strip last newline (thanks tokenizer for sticking it into the string!)
-        $str = preg_replace('~(\r\n|\n|\r)$~', '', $str);
+        $str = preg_replace('~(\r\n|\n|\r)\z~', '', $str);
 
         // nowdoc string
         if (false !== strpos($startToken, '\'')) {

lib/PhpParser/Node/Stmt/Break_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 
-/**
- * @property null|Node\Expr $num Number of loops to break
- */
 class Break_ extends Node\Stmt
 {
+    /** @var null|Node\Expr Number of loops to break */
+    public $num;
+
     /**
      * Constructs a break node.
      *
@@ -16,11 +16,11 @@ class Break_ extends Node\Stmt
      * @param array          $attributes Additional attributes
      */
     public function __construct(Node\Expr $num = null, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'num' => $num,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->num = $num;
+    }
+
+    public function getSubNodeNames() {
+        return array('num');
     }
 }

lib/PhpParser/Node/Stmt/Case_.php

@@ -4,12 +4,13 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 
-/**
- * @property null|Node\Expr $cond  Condition (null for default)
- * @property Node[]         $stmts Statements
- */
 class Case_ extends Node\Stmt
 {
+    /** @var null|Node\Expr $cond Condition (null for default) */
+    public $cond;
+    /** @var Node[] Statements */
+    public $stmts;
+
     /**
      * Constructs a case node.
      *
@@ -18,12 +19,12 @@ class Case_ extends Node\Stmt
      * @param array          $attributes Additional attributes
      */
     public function __construct($cond, array $stmts = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'cond'  => $cond,
-                'stmts' => $stmts,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->cond = $cond;
+        $this->stmts = $stmts;
+    }
+
+    public function getSubNodeNames() {
+        return array('cond', 'stmts');
     }
 }

lib/PhpParser/Node/Stmt/Catch_.php

@@ -4,13 +4,15 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 
-/**
- * @property Node\Name $type  Class of exception
- * @property string    $var   Variable for exception
- * @property Node[]    $stmts Statements
- */
 class Catch_ extends Node\Stmt
 {
+    /** @var Node\Name Class of exception */
+    public $type;
+    /** @var string Variable for exception */
+    public $var;
+    /** @var Node[] Statements */
+    public $stmts;
+
     /**
      * Constructs a catch node.
      *
@@ -20,13 +22,13 @@ class Catch_ extends Node\Stmt
      * @param array     $attributes Additional attributes
      */
     public function __construct(Node\Name $type, $var, array $stmts = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'type'  => $type,
-                'var'   => $var,
-                'stmts' => $stmts,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->type = $type;
+        $this->var = $var;
+        $this->stmts = $stmts;
+    }
+
+    public function getSubNodeNames() {
+        return array('type', 'var', 'stmts');
     }
 }

lib/PhpParser/Node/Stmt/ClassConst.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 
-/**
- * @property Node\Const_[] $consts Constant declarations
- */
 class ClassConst extends Node\Stmt
 {
+    /** @var Node\Const_[] Constant declarations */
+    public $consts;
+
     /**
      * Constructs a class const list node.
      *
@@ -16,11 +16,11 @@ class ClassConst extends Node\Stmt
      * @param array         $attributes Additional attributes
      */
     public function __construct(array $consts, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'consts' => $consts,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->consts = $consts;
+    }
+
+    public function getSubNodeNames() {
+        return array('consts');
     }
 }

lib/PhpParser/Node/Stmt/ClassLike.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+abstract class ClassLike extends Node\Stmt {
+    /** @var string Name */
+    public $name;
+    /** @var Node[] Statements */
+    public $stmts;
+
+    /**
+     * Gets all methods defined directly in this class/interface/trait
+     *
+     * @return ClassMethod[]
+     */
+    public function getMethods() {
+        $methods = array();
+        foreach ($this->stmts as $stmt) {
+            if ($stmt instanceof ClassMethod) {
+                $methods[] = $stmt;
+            }
+        }
+        return $methods;
+    }
+
+    /**
+     * Gets method with the given name defined directly in this class/interface/trait.
+     *
+     * @param string $name Name of the method (compared case-insensitively)
+     *
+     * @return ClassMethod|null Method node or null if the method does not exist
+     */
+    public function getMethod($name) {
+        $lowerName = strtolower($name);
+        foreach ($this->stmts as $stmt) {
+            if ($stmt instanceof ClassMethod && $lowerName === strtolower($stmt->name)) {
+                return $stmt;
+            }
+        }
+        return null;
+    }
+}

lib/PhpParser/Node/Stmt/ClassMethod.php

@@ -3,17 +3,23 @@
 namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
+use PhpParser\Node\FunctionLike;
 use PhpParser\Error;
 
-/**
- * @property int          $type   Type
- * @property bool         $byRef  Whether to return by reference
- * @property string       $name   Name
- * @property Node\Param[] $params Parameters
- * @property Node[]       $stmts  Statements
- */
-class ClassMethod extends Node\Stmt
+class ClassMethod extends Node\Stmt implements FunctionLike
 {
+    /** @var int Type */
+    public $type;
+    /** @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 */
+    public $returnType;
+    /** @var Node[] Statements */
+    public $stmts;
 
     /**
      * Constructs a class method node.
@@ -23,20 +29,18 @@ class ClassMethod extends Node\Stmt
      *                                'type'       => MODIFIER_PUBLIC: Type
      *                                'byRef'      => false          : Whether to return by reference
      *                                'params'     => array()        : Parameters
+     *                                'returnType' => null           : Return type
      *                                'stmts'      => array()        : Statements
      * @param array       $attributes Additional attributes
      */
     public function __construct($name, array $subNodes = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'type'   => isset($subNodes['type'])   ? $subNodes['type']   : Class_::MODIFIER_PUBLIC,
-                'byRef'  => isset($subNodes['byRef'])  ? $subNodes['byRef']  : false,
-                'name'   => $name,
-                'params' => isset($subNodes['params']) ? $subNodes['params'] : array(),
-                'stmts'  => array_key_exists('stmts', $subNodes) ? $subNodes['stmts'] : array(),
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->type = isset($subNodes['type']) ? $subNodes['type'] : 0;
+        $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)) {
@@ -50,8 +54,29 @@ class ClassMethod extends Node\Stmt
         }
     }
 
+    public function getSubNodeNames() {
+        return array('type', 'byRef', 'name', 'params', 'returnType', 'stmts');
+    }
+
+    public function returnsByRef() {
+        return $this->byRef;
+    }
+
+    public function getParams() {
+        return $this->params;
+    }
+
+    public function getReturnType() {
+        return $this->returnType;
+    }
+
+    public function getStmts() {
+        return $this->stmts;
+    }
+
     public function isPublic() {
-        return (bool) ($this->type & Class_::MODIFIER_PUBLIC);
+        return ($this->type & Class_::MODIFIER_PUBLIC) !== 0
+            || ($this->type & Class_::VISIBILITY_MODIFER_MASK) === 0;
     }
 
     public function isProtected() {

lib/PhpParser/Node/Stmt/Class_.php

@@ -5,14 +5,7 @@ namespace PhpParser\Node\Stmt;
 use PhpParser\Node;
 use PhpParser\Error;
 
-/**
- * @property int            $type       Type
- * @property string         $name       Name
- * @property null|Node\Name $extends    Name of extended class
- * @property Node\Name[]    $implements Names of implemented interfaces
- * @property Node[]         $stmts      Statements
- */
-class Class_ extends Node\Stmt
+class Class_ extends ClassLike
 {
     const MODIFIER_PUBLIC    =  1;
     const MODIFIER_PROTECTED =  2;
@@ -21,6 +14,15 @@ class Class_ extends Node\Stmt
     const MODIFIER_ABSTRACT  = 16;
     const MODIFIER_FINAL     = 32;
 
+    const VISIBILITY_MODIFER_MASK = 7; // 1 | 2 | 4
+
+    /** @var int Type */
+    public $type;
+    /** @var null|Node\Name Name of extended class */
+    public $extends;
+    /** @var Node\Name[] Names of implemented interfaces */
+    public $implements;
+
     protected static $specialNames = array(
         'self'   => true,
         'parent' => true,
@@ -30,7 +32,7 @@ class Class_ extends Node\Stmt
     /**
      * Constructs a class node.
      *
-     * @param string      $name       Name
+     * @param string|null $name       Name
      * @param array       $subNodes   Array of the following optional subnodes:
      *                                'type'       => 0      : Type
      *                                'extends'    => null   : Name of extended class
@@ -39,32 +41,38 @@ class Class_ extends Node\Stmt
      * @param array       $attributes Additional attributes
      */
     public function __construct($name, array $subNodes = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'type'       => isset($subNodes['type'])       ? $subNodes['type']       : 0,
-                'name'       => $name,
-                'extends'    => isset($subNodes['extends'])    ? $subNodes['extends']    : null,
-                'implements' => isset($subNodes['implements']) ? $subNodes['implements'] : array(),
-                'stmts'      => isset($subNodes['stmts'])      ? $subNodes['stmts']      : array(),
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->type = isset($subNodes['type']) ? $subNodes['type'] : 0;
+        $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 (isset(self::$specialNames[(string) $this->name])) {
+        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[(string) $this->extends])) {
-            throw new Error(sprintf('Cannot use \'%s\' as class name as it is reserved', $this->extends));
+        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[(string) $interface])) {
-                throw new Error(sprintf('Cannot use \'%s\' as interface name as it is reserved', $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');
+    }
+
     public function isAbstract() {
         return (bool) ($this->type & self::MODIFIER_ABSTRACT);
     }
@@ -73,18 +81,15 @@ class Class_ extends Node\Stmt
         return (bool) ($this->type & self::MODIFIER_FINAL);
     }
 
-    public function getMethods() {
-        $methods = array();
-        foreach ($this->stmts as $stmt) {
-            if ($stmt instanceof ClassMethod) {
-                $methods[] = $stmt;
-            }
-        }
-        return $methods;
+    public function isAnonymous() {
+        return null === $this->name;
     }
 
+    /**
+     * @internal
+     */
     public static function verifyModifier($a, $b) {
-        if ($a & 7 && $b & 7) {
+        if ($a & self::VISIBILITY_MODIFER_MASK && $b & self::VISIBILITY_MODIFER_MASK) {
             throw new Error('Multiple access type modifiers are not allowed');
         }
 

lib/PhpParser/Node/Stmt/Const_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 
-/**
- * @property Node\Const_[] $consts Constant declarations
- */
 class Const_ extends Node\Stmt
 {
+    /** @var Node\Const_[] Constant declarations */
+    public $consts;
+
     /**
      * Constructs a const list node.
      *
@@ -16,11 +16,11 @@ class Const_ extends Node\Stmt
      * @param array         $attributes Additional attributes
      */
     public function __construct(array $consts, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'consts' => $consts,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->consts = $consts;
+    }
+
+    public function getSubNodeNames() {
+        return array('consts');
     }
 }

lib/PhpParser/Node/Stmt/Continue_.php

@@ -4,11 +4,11 @@ namespace PhpParser\Node\Stmt;
 
 use PhpParser\Node;
 
-/**
- * @property null|Node\Expr $num Number of loops to continue
- */
 class Continue_ extends Node\Stmt
 {
+    /** @var null|Node\Expr Number of loops to continue */
+    public $num;
+
     /**
      * Constructs a continue node.
      *
@@ -16,11 +16,11 @@ class Continue_ extends Node\Stmt
      * @param array          $attributes Additional attributes
      */
     public function __construct(Node\Expr $num = null, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'num' => $num,
-            ),
-            $attributes
-        );
+        parent::__construct(null, $attributes);
+        $this->num = $num;
+    }
+
+    public function getSubNodeNames() {
+        return array('num');
     }
 }