Release PHP-Parser 1.0.0 Beta 2

Earlier releases come with incorrect tokenizer data for T_POW and
T_POW_EQUAL.

.travis.yml

@@ -1,6 +1,13 @@
 language: php
 
 php:
- - 5.2
- - 5.3
- - 5.4
+  - 5.3
+  - 5.4
+  - 5.5
+  - 5.6
+  - hhvm
+
+matrix:
+  allow_failures:
+    - php: hhvm
+  fast_finish: true

CHANGELOG.md

@@ -1,82 +1,90 @@
-Version 0.9.3-dev
+Version 1.0.0-dev
 -----------------
 
 Nothing yet.
 
-Version 0.9.2 (07.07.2012)
---------------------------
-* Add `Class->getMethods()` function, which returns all methods contained in the `stmts` array of the class node. This
-  does not take inherited methods into account.
+Version 1.0.0-beta2 (31.08.2014)
+--------------------------------
 
-* Add `isPublic()`, `isProtected()`, `isPrivate()`. `isAbstract()`, `isFinal()` and `isStatic()` accessors to the
-  `ClassMethod`, `Property` and `Class` nodes. (`Property` and `Class` obviously only have the accessors relevant to
-  them.)
+* [PHP 5.6] Updated support for constant scalar expressions to comply with latest changes. This means that arrays
+  and array dimension fetches are now supported as well.
 
-* Fix parsing of new expressions in parentheses, e.g. `return(new Foo);`.
+* [PHP 5.6] Direct array dereferencing of constants is supported now, i.e. both `FOO[0]` and `Foo::BAR[0]` are valid
+  now.
 
-* [BC] Due to the below changes nodes now optionally accept an `$attributes` array as the
-  last parameter, instead of the previously used `$line` and `$docComment` parameters.
+* Fixed handling of special class names (`self`, `parent` and `static`) in the name resolver to be case insensitive.
+  Additionally the name resolver now enforces that special class names are only used as unqualified names, e.g. `\self`
+  is considered invalid.
 
-* Add mechanism for adding attributes to nodes in the lexer.
+* The case of references to the `static` class name is now preserved. Previously `static` was always lowercased,
+  regardless of the case used in the source code.
 
-  The following attributes are now added by default:
+* The autoloader now only requires a file if it exists. This allows usages like
+  `class_exists('PhpParser\NotExistingClass')`.
 
-   * `startLine`: The line the node started in.
-   * `endLine`: The line the node ended in.
-   * `comments`: An array of comments. The comments are instances of `PHPParser_Comment`
-     (or `PHPParser_Comment_Doc` for doc comments).
+* Added experimental ``bin/php-parse.php`` script, which is intended to help exploring and debugging the node tree.
 
-  The methods `getLine()` and `setLine()` still exist and function as before, but internally
-  operator on the `startLine` attribute.
+* 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.
 
-  `getDocComment()` also continues to exist. It returns the last comment in the `comments`
-  attribute if it is a doc comment, otherwise `null`. As `getDocComment()` now returns a
-  comment object (which can be modified using `->setText()`) the `setDocComment()` method was
-  removed. Comment objects implement a `__toString()` method, so `getDocComment()` should
-  continue to work properly with old code.
+Version 1.0.0-beta1 (27.03.2014)
+--------------------------------
 
-* [BC] Use inject-once approach for lexer:
+* [BC] 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.
 
-  Now the lexer is injected only once when creating the parser. Instead of
+* [BC] 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.
 
-        $parser = new PHPParser_Parser;
-        $parser->parse(new PHPParser_Lexer($code));
-        $parser->parse(new PHPParser_Lexer($code2));
+  However, code performing dispatch operations on `Node::getType()` may be affected by some of the name changes. For
+  example a `+` node will now return type `Expr_BinaryOp_Plus` instead of `Expr_Plus`. In particular this may affect
+  custom pretty printers.
 
-  you write:
+  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)
 
-        $parser = new PHPParser_Parser(new PHPParser_Lexer);
-        $parser->parse($code);
-        $parser->parse($code2);
+* [PHP 5.6] Added support for the power operator `**` (node `Expr\BinaryOp\Pow`) and the compound power assignment
+  operator `**=` (node `Expr\AssignOp\Pow`).
 
-* Fix `NameResolver` visitor to also resolve class names in `catch` blocks.
+* [PHP 5.6] Added support for variadic functions: `Param` nodes now have `variadic` as a boolean subnode.
 
-Version 0.9.1 (24.04.2012)
---------------------------
+* [PHP 5.6] Added support for argument unpacking: `Arg` nodes now have `unpack` as a boolean subnode.
 
-* Add ability to add attributes to nodes:
+* [PHP 5.6] Added support for aliasing of functions and constants. `Stmt\Use_` nodes now have an integral `type`
+  subnode, which is one of `Stmt\Use_::TYPE_NORMAL` (`use`), `Stmt\Use_::TYPE_FUNCTION` (`use function`) or
+  `Stmt\Use_::TYPE_CONSTANT` (`use const`).
 
-  It is now possible to add attributes to a node using `$node->setAttribute('name', 'value')` and to retrieve them using
-  `$node->getAttribute('name' [, 'default'])`. Additionally the existance of an attribute can be checked with
-  `$node->hasAttribute('name')` and all attributes can be returned using `$node->getAttributes()`.
+  The `NameResolver` now also supports resolution of such aliases.
 
-* Add code generation features: Builders and templates.
+* [PHP 5.6] Added support for constant scalar expressions. This means that certain expressions are now allowed as the
+  initializer for constants, properties, parameters, static variables, etc.
 
-  For more infos, see the [code generation documentation][1].
+* [BC] Improved pretty printing of empty statements lists, which are now printed as `{\n}` instead of `{\n    \n}`.
+  This changes the behavior of the protected `PrettyPrinterAbstract::pStmts()` method, so custom pretty printing code
+  making use it of may need to be adjusted.
 
-* [BC] Don't traverse nodes merged by another visitor:
+* Changed the order of some subnodes to be consistent with their order in the sour code. For example `Stmt\If->cond`
+  will now appear before `Stmt\If->stmts` etc.
 
-  If a NodeVisitor returns an array of nodes to merge, these will no longer be traversed by all other visitors. This
-  behavior only caused problems.
+* Added `Scalar\MagicConstant->getName()`, which returns the name of the magic constant (e.g. `__CLASS__`).
 
-* Fix line numbers for some list structures.
-* Fix XML unserialization of empty nodes.
-* Fix parsing of integers that overflow into floats.
-* Fix emulation of NOWDOC and binary floats.
+**The following changes are also included in 0.9.5**:
 
-Version 0.9.0 (05.01.2012)
---------------------------
+* [BC] Deprecated `PHPParser_Template` and `PHPParser_TemplateLoader`. This functionality does not belong in the main project
+  and - as far as I know - nobody is using it.
 
-First version.
+* Add `NodeTraverser::removeVisitor()` method, which removes a visitor from the node traverser. This also modifies the
+  corresponding `NodeTraverserInterface`.
 
- [1]: https://github.com/nikic/PHP-Parser/blob/master/doc/3_Code_generation.markdown
+* Fix alias resolution in `NameResolver`: Class names are now correctly handled as case-insensitive.
+
+* The undefined variable error, which is used to the lexer to reset the error state, will no longer interfere with
+  custom error handlers.
+
+---
+
+**This changelog only includes changes from the 1.0 series. For older changes see the [0.9 series changelog][1].**
+
+ [1]: https://github.com/nikic/PHP-Parser/blob/0.9/CHANGELOG.md

README.md

@@ -1,10 +1,12 @@
 PHP Parser
 ==========
 
-This is a PHP 5.4 (and older) parser written in PHP. It's purpose is to simplify static code analysis and
+This is a PHP 5.6 (and older) parser written in PHP. It's purpose is to simplify static code analysis and
 manipulation.
 
-Documentation can be found in the [`doc/`][1] directory.
+[**Documentation for version 0.9.x**][doc_0_9] (stable; for running on PHP 5.2).
+
+[**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.***
 
@@ -73,6 +75,7 @@ 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][1].
+So, that's it, in a nutshell. You can find everything else in the [docs][doc_master].
 
- [1]: https://github.com/nikic/PHP-Parser/tree/master/doc
+ [doc_0_9]: https://github.com/nikic/PHP-Parser/tree/0.9/doc
+ [doc_master]: https://github.com/nikic/PHP-Parser/tree/master/doc

bin/php-parse.php

@@ -0,0 +1,132 @@
+<?php
+
+require __DIR__ . '/../lib/bootstrap.php';
+
+ini_set('xdebug.max_nesting_level', 2000);
+
+/* 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);
+
+list($operations, $files) = parseArgs($argv);
+
+/* Dump nodes by default */
+if (empty($operations)) {
+    $operations[] = 'dump';
+}
+
+if (empty($files)) {
+    showHelp("Must specify at least one file.");
+}
+
+$parser = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
+$dumper = new PhpParser\NodeDumper;
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
+$serializer = new PhpParser\Serializer\XML;
+
+$traverser = new PhpParser\NodeTraverser();
+$traverser->addVisitor(new PhpParser\NodeVisitor\NameResolver);
+
+foreach ($files as $file) {
+    if (!file_exists($file)) {
+        die("File $file does not exist.\n");
+    }
+
+    echo "====> File $file:\n";
+
+    $code = file_get_contents($file);
+    try {
+        $stmts = $parser->parse($code);
+    } catch (PhpParser\Error $e) {
+        die("==> Parse Error: {$e->getMessage()}\n");
+    }
+
+    foreach ($operations as $operation) {
+        if ('dump' === $operation) {
+            echo "==> Node dump:\n";
+            echo $dumper->dump($stmts), "\n";
+        } elseif ('pretty-print' === $operation) {
+            echo "==> Pretty print:\n";
+            echo $prettyPrinter->prettyPrintFile($stmts), "\n";
+        } elseif ('serialize-xml' === $operation) {
+            echo "==> Serialized XML:\n";
+            echo $serializer->serialize($stmts), "\n";
+        } elseif ('var-dump' === $operation) {
+            echo "==> var_dump():\n";
+            var_dump($stmts);
+        } elseif ('resolve-names' === $operation) {
+            echo "==> Resolved names.\n";
+            $stmts = $traverser->traverse($stmts);
+        }
+    }
+}
+
+function showHelp($error) {
+    die($error . "\n\n" .
+        <<<OUTPUT
+Usage:
+
+    php php-parse.php [operations] file1.php [file2.php ...]
+
+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
+    --serialize-xml      Serialize nodes using Serializer\XML
+    --var-dump           var_dump() nodes (for exact structure)
+    --resolve-names  -N  Resolve names using NodeVisitor\NameResolver
+
+Example:
+
+    php php-parse.php -d -p -N -d file.php
+
+    Dumps nodes, pretty prints them, then resolves names and dumps them again.
+OUTPUT
+    );
+}
+
+function parseArgs($args) {
+    $operations = array();
+    $files = array();
+
+    array_shift($args);
+    $parseOptions = true;
+    foreach ($args as $arg) {
+        if (!$parseOptions) {
+            $files[] = $arg;
+            continue;
+        }
+
+        switch ($arg) {
+            case '--dump':
+            case '-d':
+                $operations[] = 'dump';
+                break;
+            case '--pretty-print':
+            case '-p':
+                $operations[] = 'pretty-print';
+                break;
+            case '--serialize-xml':
+                $operations[] = 'serialize-xml';
+                break;
+            case '--var-dump':
+                $operations[] = 'var-dump';
+                break;
+            case '--resolve-names':
+            case '-N';
+                $operations[] = 'resolve-names';
+                break;
+            case '--':
+                $parseOptions = false;
+                break;
+            default:
+                if ($arg[0] === '-') {
+                    showHelp("Invalid operation $arg.");
+                } else {
+                    $files[] = $arg;
+                }
+        }
+    }
+
+    return array($operations, $files);
+}

composer.json

@@ -3,16 +3,22 @@
     "description": "A PHP parser written in PHP",
     "keywords": ["php", "parser"],
     "type": "library",
-    "license": "BSD",
+    "license": "BSD-3-Clause",
     "authors": [
         {
             "name": "Nikita Popov"
         }
     ],
     "require": {
-        "php": ">=5.2"
+        "php": ">=5.3",
+        "ext-tokenizer": "*"
     },
     "autoload": {
-        "psr-0": { "PHPParser": "lib/" }
+        "files": ["lib/bootstrap.php"]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.0-dev"
+        }
     }
 }

doc/0_Introduction.markdown

@@ -1,7 +1,7 @@
 Introduction
 ============
 
-This project is a PHP 5.4 (and older) parser **written in PHP itself**.
+This project is a PHP 5.5 (and older) parser **written in PHP itself**.
 
 What is this for?
 -----------------
@@ -12,7 +12,7 @@ application dealing with code programmatically. A parser constructs an [Abstract
 
 There are other ways of dealing with 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 analyize the exact formating of
+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.
 For example an AST abstracts away the fact that in PHP variables can be written as `$foo`, but also
 as `$$bar`, `${'foobar'}` or even `${!${''}=barfoo()}`. You don't have to worry about recognizing
@@ -21,17 +21,17 @@ all the different syntaxes from a stream of tokens.
 Another questions is: Why would I want to have a PHP parser *written in PHP*? Well, PHP might not be
 a language especially suited for fast parsing, but processing the AST is much easier in PHP than it
 would be in other, faster languages like C. Furthermore the people most probably wanting to do
-programmatic PHP code analysis are incidentially PHP developers, not C developers.
+programmatic PHP code analysis are incidentally PHP developers, not C developers.
 
 What can it parse?
 ------------------
 
-The parser uses a PHP 5.4 compliant grammar, which is backwards compatible with at least PHP 5.3 and PHP
-5.2 (and maybe older).
+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).
 
 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 and 5.4 is provided. This
-allows to parse PHP 5.4 source code running on PHP 5.2, for example. This emulation is very hacky and not
+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.
 
 What output does it produce?

doc/1_Installation.markdown

@@ -15,7 +15,7 @@ Create a `composer.json` file in your project root and use it to define your dep
 
     {
         "require": {
-            "nikic/php-parser": "0.9.2"
+            "nikic/php-parser": "1.0.0-beta2"
         }
     }
 
@@ -27,14 +27,6 @@ And finally ask Composer to install the dependencies:
 
     php composer.phar install
 
-Installing as a PEAR package
-----------------------------
-
-Run the following two commands:
-
-    pear channel-discover nikic.github.com/pear
-    pear install channel://nikic.github.com/pear/PHPParser-0.9.2
-
 Installing as a Git Submodule
 -----------------------------
 

doc/2_Usage_of_basic_components.markdown

@@ -26,20 +26,20 @@ 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
+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.
 
 ```php
 <?php
 $code = '<?php // some code';
 
-$parser = new PHPParser_Parser(new PHPParser_Lexer);
+$parser = new PhpParser\Parser(new PhpParser\Lexer);
 
 try {
     $stmts = $parser->parse($code);
-} catch (PHPParser_Error $e) {
+} catch (PhpParser\Error $e) {
     echo 'Parse Error: ', $e->getMessage();
 }
 ```
@@ -48,8 +48,8 @@ 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.4 on PHP 5.2, for example. So if you want to parse
+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.
 
 Node tree
@@ -81,37 +81,41 @@ array(
 ```
 
 Thus `$stmts` will contain an array with only one node, with this node being an instance of
-`PHPParser_Node_Stmt_Echo`.
+`PhpParser\Node\Stmt\Echo_`.
 
 As PHP is a large language there are approximately 140 different nodes. In order to make work
 with them easier they are grouped into three categories:
 
- * `PHPParser_Node_Stmt`s are statement nodes, i.e. language constructs that do not return
+ * `PhpParser\Node\Stmt`s are statement nodes, i.e. language constructs that do not return
    a value and can not occur in an expression. For example a class definition is a statement.
    It doesn't return a value and you can't write something like `func(class A {});`.
- * `PHPParser_Node_Expr`s are expression nodes, i.e. language constructs that return a value
+ * `PhpParser\Node\Expr`s are expression nodes, i.e. language constructs that return a value
    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
-   like `__FILE__` (`PHPParser_Node_Scalar_FileConst`). 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`)
-   and call arguments (`PHPParser_Node_Arg`).
+   (`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
+   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`)
+   and call arguments (`PhpParser\Node\Arg`).
+
+Some node class names have a trailing `_`. This is used whenever the class name would otherwise clash
+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
+`$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
 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
-without the `PHPParser_Node_` prefix).
+All nodes also define a `getType()` method that returns the node type. The type is the class name
+without the `PhpParser\Node\` prefix and `\` replaced with `_`. It also does not contain a trailing
+`_` for reserved-keyword class names.
 
 It is possible to associate custom metadata with a node using the `setAttribute()` method. This data
 can then be retrieved using `hasAttribute()`, `getAttribute()` and `getAttributes()`.
 
 By default the lexer adds the `startLine`, `endLine` and `comments` attributes. `comments` is an array
-of `PHPParser_Comment[_Doc]` instances.
+of `PhpParser\Comment[\Doc]` instances.
 
 The start line can also be accessed using `getLine()`/`setLine()` (instead of `getAttribute('startLine')`).
 The last doc comment from the `comments` attribute can be obtained using `getDocComment()`.
@@ -121,15 +125,14 @@ Pretty printer
 
 The pretty printer component compiles the AST back to PHP code. As the parser does not retain formatting
 information the formatting is done using a specified scheme. Currently there is only one scheme available,
-namely `PHPParser_PrettyPrinter_Zend` (the name "Zend" might be misleading. It does not strictly adhere
-to the Zend Coding Standard.)
+namely `PhpParser\PrettyPrinter\Standard`.
 
 ```php
 <?php
 $code = "<?php echo 'Hi ', hi\\getTarget();";
 
-$parser        = new PHPParser_Parser(new PHPParser_Lexer);
-$prettyPrinter = new PHPParser_PrettyPrinter_Zend;
+$parser        = new PhpParser\Parser(new PhpParser\Lexer);
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
 
 try {
     // parse
@@ -146,7 +149,7 @@ try {
     $code = '<?php ' . $prettyPrinter->prettyPrint($stmts);
 
     echo $code;
-} catch (PHPParser_Error $e) {
+} catch (PhpParser\Error $e) {
     echo 'Parse Error: ', $e->getMessage();
 }
 ```
@@ -155,11 +158,14 @@ The above code will output:
 
     <?php echo 'Hallo ', 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_Zend->prettyPrint`.
+As you can see the source code was first parsed using `PhpParser\Parser->parse()`, then changed and then
+again converted to code using `PhpParser\PrettyPrinter\Standard->prettyPrint()`.
 
-The `prettyPrint` method pretty prints a statements array. It is also possible to pretty print only a
-single expression using `prettyPrintExpr`.
+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.
 
 Node traversation
 -----------------
@@ -170,15 +176,15 @@ Usually you want to change / analyze code in a generic way, where you don't know
 going to look like.
 
 For this purpose the parser provides a component for traversing and visiting the node tree. The basic
-structure of a program using this `PHPParser_NodeTraverser` looks like this:
+structure of a program using this `PhpParser\NodeTraverser` looks like this:
 
 ```php
 <?php
 $code = "<?php // some code";
 
-$parser        = new PHPParser_Parser(new PHPParser_Lexer);
-$traverser     = new PHPParser_NodeTraverser;
-$prettyPrinter = new PHPParser_PrettyPrinter_Zend;
+$parser        = new PhpParser\Parser(new PhpParser\Lexer);
+$traverser     = new PhpParser\NodeTraverser;
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
 
 // add your visitor
 $traverser->addVisitor(new MyNodeVisitor);
@@ -194,7 +200,7 @@ try {
     $code = '<?php ' . $prettyPrinter->prettyPrint($stmts);
 
     echo $code;
-} catch (PHPParser_Error $e) {
+} catch (PhpParser\Error $e) {
     echo 'Parse Error: ', $e->getMessage();
 }
 ```
@@ -203,10 +209,10 @@ A same node visitor for this code might look like this:
 
 ```php
 <?php
-class MyNodeVisitor extends PHPParser_NodeVisitorAbstract
+class MyNodeVisitor extends PhpParser\NodeVisitorAbstract
 {
-    public function leaveNode(PHPParser_Node $node) {
-        if ($node instanceof PHPParser_Node_Scalar_String) {
+    public function leaveNode(PhpParser\Node $node) {
+        if ($node instanceof PhpParser\Node\Scalar\String) {
             $node->value = 'foo';
         }
     }
@@ -215,12 +221,12 @@ 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 defined the following four
 methods:
 
     public function beforeTraverse(array $nodes);
-    public function enterNode(PHPParser_Node $node);
-    public function leaveNode(PHPParser_Node $node);
+    public function enterNode(PhpParser\Node $node);
+    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
@@ -246,7 +252,7 @@ class, which will define empty default implementations for all the above methods
 The NameResolver node visitor
 -----------------------------
 
-One visitor is already bundled with the package: `PHPParser_NodeVisitor_NameResolver`. This visitor
+One visitor is already bundled with the package: `PhpParser\NodeVisitor\NameResolver`. This visitor
 helps you work with namespaced code by trying to resolve most names to fully qualified ones.
 
 For example, consider the following code:
@@ -281,23 +287,18 @@ const IN_DIR  = '/some/path';
 const OUT_DIR = '/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_Zend;
+$parser        = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
+$traverser     = new PhpParser\NodeTraverser;
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
 
-$traverser->addVisitor(new PHPParser_NodeVisitor_NameResolver); // we will need resolved names
-$traverser->addVisitor(new NodeVisitor_NamespaceConverter);     // our own node visitor
+$traverser->addVisitor(new PhpParser\NodeVisitor\NameResolver); // we will need resolved names
+$traverser->addVisitor(new NodeVisitor\NamespaceConverter);     // our own node visitor
 
-// iterate over all files in the directory
-foreach (new RecursiveIteratorIterator(
-             new RecursiveDirectoryIterator(IN_DIR),
-             RecursiveIteratorIterator::LEAVES_ONLY)
-         as $file) {
-    // only convert .php files
-    if (!preg_match('~\.php$~', $file)) {
-        continue;
-    }
+// iterate over all .php files in the directory
+$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator(IN_DIR));
+$files = new RegexIterator($files, '/\.php$/');
 
+foreach ($files as $file) {
     try {
         // read the file that should be converted
         $code = file_get_contents($file);
@@ -316,7 +317,7 @@ foreach (new RecursiveIteratorIterator(
             substr_replace($file->getPathname(), OUT_DIR, 0, strlen(IN_DIR)),
             $code
         );
-    } catch (PHPParser_Error $e) {
+    } catch (PhpParser\Error $e) {
         echo 'Parse Error: ', $e->getMessage();
     }
 }
@@ -327,11 +328,12 @@ is convert `A\\B` style names to `A_B` style ones.
 
 ```php
 <?php
-class NodeVisitor_NamespaceConverter extends PHPParser_NodeVisitorAbstract
+use PhpParser\Node;
+class NodeVisitor_NamespaceConverter extends PhpParser\NodeVisitorAbstract
 {
-    public function leaveNode(PHPParser_Node $node) {
-        if ($node instanceof PHPParser_Node_Name) {
-            return new PHPParser_Node_Name($node->toString('_'));
+    public function leaveNode(Node $node) {
+        if ($node instanceof Node\Name) {
+            return new Node\Name($node->toString('_'));
         }
     }
 }
@@ -349,16 +351,18 @@ name:
 
 ```php
 <?php
-class NodeVisitor_NamespaceConverter extends PHPParser_NodeVisitorAbstract
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+class NodeVisitor_NamespaceConverter extends PhpParser\NodeVisitorAbstract
 {
-    public function leaveNode(PHPParser_Node $node) {
-        if ($node instanceof PHPParser_Node_Name) {
-            return new PHPParser_Node_Name($node->toString('_'));
-        } elseif ($node instanceof PHPParser_Node_Stmt_Class
-                  || $node instanceof PHPParser_Node_Stmt_Interface
-                  || $node instanceof PHPParser_Node_Stmt_Function) {
+    public function leaveNode(Node $node) {
+        if ($node instanceof Node\Name) {
+            return new Node\Name($node->toString('_'));
+        } elseif ($node instanceof Stmt\Class_
+                  || $node instanceof Stmt\Interface_
+                  || $node instanceof Stmt\Function_) {
             $node->name = $node->namespacedName->toString('_');
-        } elseif ($node instanceof PHPParser_Node_Stmt_Const) {
+        } elseif ($node instanceof Stmt\Const_) {
             foreach ($node->consts as $const) {
                 $const->name = $const->namespacedName->toString('_');
             }
@@ -373,23 +377,25 @@ The last thing we need to do is remove the `namespace` and `use` statements:
 
 ```php
 <?php
-class NodeVisitor_NamespaceConverter extends PHPParser_NodeVisitorAbstract
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+class NodeVisitor_NamespaceConverter extends PhpParser\NodeVisitorAbstract
 {
-    public function leaveNode(PHPParser_Node $node) {
-        if ($node instanceof PHPParser_Node_Name) {
-            return new PHPParser_Node_Name($node->toString('_'));
-        } elseif ($node instanceof PHPParser_Node_Stmt_Class
-                  || $node instanceof PHPParser_Node_Stmt_Interface
-                  || $node instanceof PHPParser_Node_Stmt_Function) {
+    public function leaveNode(Node $node) {
+        if ($node instanceof Node\Name) {
+            return new Node\Name($node->toString('_'));
+        } elseif ($node instanceof Stmt\Class_
+                  || $node instanceof Stmt\Interface_
+                  || $node instanceof Stmt\Function_) {
             $node->name = $node->namespacedName->toString('_');
-        } elseif ($node instanceof PHPParser_Node_Stmt_Const) {
+        } elseif ($node instanceof Stmt\Const_) {
             foreach ($node->consts as $const) {
                 $const->name = $const->namespacedName->toString('_');
             }
-        } elseif ($node instanceof PHPParser_Node_Stmt_Namespace) {
+        } elseif ($node instanceof Stmt\Namespace_) {
             // returning an array merges is into the parent array
             return $node->stmts;
-        } elseif ($node instanceof PHPParser_Node_Stmt_Use) {
+        } elseif ($node instanceof Stmt\Use_) {
             // returning false removed the node altogether
             return false;
         }

doc/3_Other_node_tree_representations.markdown

@@ -14,7 +14,7 @@ Human readable dumping
 ----------------------
 
 Furthermore it is possible to dump nodes into a human readable form using the `dump` method of
-`PHPParser_NodeDumper`. This can be used for debugging.
+`PhpParser\NodeDumper`. This can be used for debugging.
 
 ```php
 <?php
@@ -27,14 +27,14 @@ $code = <<<'CODE'
     printLine('Hallo World!!!');
 CODE;
 
-$parser     = new PHPParser_Parser(new PHPParser_Lexer);
-$nodeDumper = new PHPParser_NodeDumper;
+$parser     = new PhpParser\Parser(new PhpParser\Lexer);
+$nodeDumper = new PhpParser\NodeDumper;
 
 try {
     $stmts = $parser->parse($code);
 
     echo '<pre>' . htmlspecialchars($nodeDumper->dump($stmts)) . '</pre>';
-} catch (PHPParser_Error $e) {
+} catch (PhpParser\Error $e) {
     echo 'Parse Error: ', $e->getMessage();
 }
 ```
@@ -89,8 +89,8 @@ array(
 Serialization to XML
 --------------------
 
-It is also possible to serialize the node tree to XML using `PHPParser_Serializer_XML->serialize()`
-and to unserialize it using `PHPParser_Unserializer_XML->unserialize()`. This is useful for
+It is also possible to serialize the node tree to XML using `PhpParser\Serializer\XML->serialize()`
+and to unserialize it using `PhpParser\Unserializer\XML->unserialize()`. This is useful for
 interfacing with other languages and applications or for doing transformation using XSLT.
 
 ```php
@@ -104,14 +104,14 @@ $code = <<<'CODE'
     printLine('Hallo World!!!');
 CODE;
 
-$parser     = new PHPParser_Parser(new PHPParser_Lexer);
-$serializer = new PHPParser_Serializer_XML;
+$parser     = new PhpParser\Parser(new PhpParser\Lexer);
+$serializer = new PhpParser\Serializer\XML;
 
 try {
     $stmts = $parser->parse($code);
 
     echo '<pre>' . htmlspecialchars($serializer->serialize($stmts)) . '</pre>';
-} catch (PHPParser_Error $e) {
+} catch (PhpParser\Error $e) {
     echo 'Parse Error: ', $e->getMessage();
 }
 ```

doc/4_Code_generation.markdown

@@ -8,14 +8,14 @@ common structures as well as simple templating support. Both features are descri
 Builders
 --------
 
-The project provides builders for classes, methods, functions, parameters and properties, which
+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.
 
 Here is an example:
 
 ```php
 <?php
-$factory = new PHPParser_BuilderFactory;
+$factory = new PhpParser\BuilderFactory;
 $node = $factory->class('SomeClass')
     ->extend('SomeOtherClass')
     ->implement('A\Few', 'Interfaces')
@@ -30,7 +30,7 @@ $node = $factory->class('SomeClass')
         ->makeProtected() // ->makePublic() [default], ->makePrivate()
         ->addParam($factory->param('someParam')->setDefault('test'))
         // it is possible to add manually created nodes
-        ->addStmt(new PHPParser_Node_Expr_Print(new PHPParser_Node_Expr_Variable('someParam')))
+        ->addStmt(new PhpParser\Node\Expr\Print_(new PhpParser\Node\Expr\Variable('someParam')))
     )
 
     // properties will be correctly reordered above the methods
@@ -63,6 +63,8 @@ abstract class SomeClass extends SomeOtherClass implements A\Few, Interfaces
 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
@@ -104,7 +106,7 @@ Using this template we can easily create a class with multiple properties and th
 <?php
 
 // $templateString contains the above template
-$template = new PHPParser_Template($parser, $templateString);
+$template = new PhpParser\Template($parser, $templateString);
 
 // We only have to specify the __name__ placeholder, as the
 // capitalized __Name__ placeholder is automatically created
@@ -246,7 +248,7 @@ When using multiple templates it is easier to manage them on the filesystem. The
 <?php
 
 // We'll store our templates in ./templates and give them a .php suffix
-$loader = new PHPParser_TemplateLoader($parser, './templates', '.php');
+$loader = new PhpParser\TemplateLoader($parser, './templates', '.php');
 
 // loads ./templates/GetterSetter.php
 $getterSetterTemplate = $loader->load('GetterSetter');
@@ -255,7 +257,7 @@ $getterSetterTemplate = $loader->load('GetterSetter');
 $collectionTemplate = $loader->load('Collection');
 
 // The use of a suffix is optional. The following code for example is equivalent:
-$loader = new PHPParser_TemplateLoader($parser, './templates');
+$loader = new PhpParser\TemplateLoader($parser, './templates');
 
 // loads ./templates/GetterSetter.php
 $getterSetterTemplate = $loader->load('GetterSetter.php');

doc/component/Lexer.markdown

@@ -1,8 +1,8 @@
 Lexer component documentation
 =============================
 
-The lexer is responsible for providing tokens to the parser. The project comes with two lexers: `PHPParser_Lexer` and
-`PHPParser_Lexer_Emulative`. The latter is an extension of the former, which adds the ability to emulate tokens of
+The lexer is responsible for providing tokens to the parser. The project comes with two lexers: `PhpParser\Lexer` and
+`PhpParser\Lexer\Emulative`. The latter is an extension of the former, which adds the ability to emulate tokens of
 newer PHP versions and thus allows parsing of new code on older versions.
 
 A lexer has to define the following public interface:
@@ -22,7 +22,7 @@ Even though `startLexing` is meant to accept a source code string, you could for
 ```php
 <?php
 
-class FileLexer extends PHPParser_Lexer {
+class FileLexer extends PhpParser\Lexer {
     public function startLexing($fileName) {
         if (!file_exists($fileName)) {
             throw new InvalidArgumentException(sprintf('File "%s" does not exist', $fileName));
@@ -32,7 +32,7 @@ class FileLexer extends PHPParser_Lexer {
     }
 }
 
-$parser = new PHPParser_Parser(new FileLexer);
+$parser = new PhpParser\Parser(new FileLexer);
 
 var_dump($parser->parse('someFile.php'));
 var_dump($parser->parse('someOtherFile.php'));
@@ -63,7 +63,7 @@ overriding the method:
 ```php
 <?php
 
-class LessAttributesLexer extends PHPParser_Lexer {
+class LessAttributesLexer extends PhpParser\Lexer {
     public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
         $tokenId = parent::getNextToken($value, $startAttributes, $endAttributes);
 
@@ -82,7 +82,7 @@ a `fileName` attribute to all nodes:
 ```php
 <?php
 
-class FileLexer extends PHPParser_Lexer {
+class FileLexer extends PhpParser\Lexer {
     protected $fileName;
 
     public function startLexing($fileName) {
@@ -100,7 +100,7 @@ class FileLexer extends PHPParser_Lexer {
         // 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'] = $fileName;
+        $endAttributes['fileName'] = $this->fileName;
 
         return $tokenId;
     }
@@ -111,4 +111,4 @@ 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 `();`).
+construct (not including `();`).

grammar/README.md

@@ -1,7 +1,6 @@
 What do all those files mean?
 =============================
 
- * `zend_language_parser.y`:    Original PHP grammer this parser is based on
  * `zend_language_parser.phpy`: PHP grammer written in a pseudo language
  * `analyze.php`:               Analyzes the `.phpy`-grammer and outputs some info about it
  * `rebuildParser.php`:         Preprocesses the `.phpy`-grammar and builds the parser using `kmyacc`
@@ -14,8 +13,8 @@ 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 PHPParser_Node_Name(..., ..., $attributes)`
- * `Name::abc` is transformed to `PHPParser_Node_Name::abc`
+   `new Node\Name(..., ..., $attributes)`
+ * `Name::abc` is transformed to `Node\Name::abc`
  * 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, ...)`
@@ -24,7 +23,7 @@ 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` file.
+After you compiled/installed it, run the `rebuildParser.php` script.
 
-By default only the Parser.php is built. If you want to build the Parser/Debug.php and the y.output
-file you need to call the file with the debug option: `rebuildParser.php?debug`.
+By default only the `Parser.php` is built. If you want to additionally build `Parser/Debug.php` and `y.output` run the
+script with `--debug`. If you want to retain the preprocessed grammar pass `--keep-tmp-grammar`.

grammar/kmyacc.php.parser

@@ -1,330 +1,99 @@
 <?php
 $meta #
-#semval($) $this->yyval
-#semval($,%t) $this->yyval
-#semval(%n) $this->yyastk[$this->stackPos-(%l-%n)]
-#semval(%n,%t) $this->yyastk[$this->stackPos-(%l-%n)]
+#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;
 
+namespace PhpParser;
+
 /* This is an automatically GENERATED file, which should not be manually edited.
  * Instead edit one of the following:
  *  * the grammar file grammar/zend_language_parser.phpy
- *  * the parser skeleton grammar/kymacc.php.parser
+ *  * the skeleton file grammar/kymacc.php.parser
  *  * the preprocessing script grammar/rebuildParser.php
- *
- * The skeleton for this parser was written by Moriyoshi Koizumi and is based on
- * the work by Masato Bito and is in the PUBLIC DOMAIN.
  */
-#if -t
-class #(-p)_Debug extends #(-p)
-#endif
-#ifnot -t
-class #(-p)
-#endif
+class Parser extends ParserAbstract
 {
-#ifnot -t
-    const TOKEN_NONE    = -1;
-    const TOKEN_INVALID = #(YYBADCH);
+    protected $tokenToSymbolMapSize = #(YYMAXLEX);
+    protected $actionTableSize = #(YYLAST);
+    protected $gotoTableSize = #(YYGLAST);
 
-    const TOKEN_MAP_SIZE = #(YYMAXLEX);
+    protected $invalidToken = #(YYBADCH);
+    protected $defaultAction = #(YYDEFAULT);
+    protected $unexpectedTokenRule = #(YYUNEXPECTED);
 
-    const YYLAST       = #(YYLAST);
-    const YY2TBLSTATE  = #(YY2TBLSTATE);
-    const YYGLAST      = #(YYGLAST);
-    const YYNLSTATES   = #(YYNLSTATES);
-    const YYUNEXPECTED = #(YYUNEXPECTED);
-    const YYDEFAULT    = #(YYDEFAULT);
+    protected $YY2TBLSTATE  = #(YY2TBLSTATE);
+    protected $YYNLSTATES   = #(YYNLSTATES);
 
-    // {{{ Tokens
 #tokenval
     const %s = %n;
 #endtokenval
-    // }}}
 
-    /* @var array Map of token ids to their respective names */
-    protected static $terminals = array(
+    protected $symbolToName = array(
         #listvar terminals
-        , "???"
     );
 
-    /* @var Map which translates lexer tokens to internal tokens */
-    protected static $translate = array(
+    protected $tokenToSymbol = array(
         #listvar yytranslate
     );
 
-    protected static $yyaction = array(
+    protected $action = array(
         #listvar yyaction
     );
 
-    protected static $yycheck = array(
+    protected $actionCheck = array(
         #listvar yycheck
     );
 
-    protected static $yybase = array(
+    protected $actionBase = array(
         #listvar yybase
     );
 
-    protected static $yydefault = array(
+    protected $actionDefault = array(
         #listvar yydefault
     );
 
-    protected static $yygoto = array(
+    protected $goto = array(
         #listvar yygoto
     );
 
-    protected static $yygcheck = array(
+    protected $gotoCheck = array(
         #listvar yygcheck
     );
 
-    protected static $yygbase = array(
+    protected $gotoBase = array(
         #listvar yygbase
     );
 
-    protected static $yygdefault = array(
+    protected $gotoDefault = array(
         #listvar yygdefault
     );
 
-    protected static $yylhs = array(
+    protected $ruleToNonTerminal = array(
         #listvar yylhs
     );
 
-    protected static $yylen = array(
+    protected $ruleToLength = array(
         #listvar yylen
     );
-
-    protected $yyval;
-    protected $yyastk;
-    protected $stackPos;
-    protected $lexer;
-
-    /**
-     * Creates a parser instance.
-     *
-     * @param PHPParser_Lexer $lexer A lexer
-     */
-    public function __construct(PHPParser_Lexer $lexer) {
-        $this->lexer = $lexer;
-    }
-#endif
 #if -t
-    protected static $yyproduction = array(
+
+    protected $productions = array(
         #production-strings;
     );
-
-    protected function yyprintln($msg) {
-        echo $msg, "\n";
-    }
-
-    protected function YYTRACE_NEWSTATE($state, $tokenId) {
-        $this->yyprintln(
-            '% State ' . $state
-          . ', Lookahead ' . ($tokenId == self::TOKEN_NONE ? '--none--' : self::$terminals[$tokenId])
-        );
-    }
-
-    protected function YYTRACE_READ($tokenId) {
-        $this->yyprintln('% Reading ' . self::$terminals[$tokenId]);
-    }
-
-    protected function YYTRACE_SHIFT($tokenId) {
-        $this->yyprintln('% Shift ' . self::$terminals[$tokenId]);
-    }
-
-    protected function YYTRACE_ACCEPT() {
-        $this->yyprintln('% Accepted.');
-    }
-
-    protected function YYTRACE_REDUCE($n) {
-        $this->yyprintln('% Reduce by (' . $n . ') ' . self::$yyproduction[$n]);
-    }
-
-    protected function YYTRACE_POP($state) {
-        $this->yyprintln('% Recovering, uncovers state ' . $state);
-    }
-
-    protected function YYTRACE_DISCARD($tokenId) {
-        $this->yyprintln('% Discard ' . self::$terminals[$tokenId]);
-    }
 #endif
-
-    /**
-#ifnot -t
-     * Parses PHP code into a node tree.
-#endif
-#if -t
-     * Parses PHP code into a node tree and prints out debugging information.
-#endif
-     *
-     * @param string $code The source code to parse
-     *
-     * @return array Array of statements
-     */
-    public function parse($code) {
-        $this->lexer->startLexing($code);
-
-        // We start off with no lookahead-token
-        $tokenId = self::TOKEN_NONE;
-
-        // The attributes for a node are taken from the first and last token of the node.
-        // From the first token only the startAttributes are taken and from the last only
-        // the endAttributes. Both are merged using the array union operator (+).
-        $startAttributes = array('startLine' => 1);
-        $endAttributes   = array();
-
-        // In order to figure out the attributes for the starting token, we have to keep
-        // them in a stack
-        $attributeStack = array($startAttributes);
-
-        // Start off in the initial state and keep a stack of previous states
-        $state = 0;
-        $stateStack = array($state);
-
-        // AST stack (?)
-        $this->yyastk = array();
-
-        // Current position in the stack(s)
-        $this->stackPos = 0;
-
-        for (;;) {
-#if -t
-            $this->YYTRACE_NEWSTATE($state, $tokenId);
-
-#endif
-            if (self::$yybase[$state] == 0) {
-                $yyn = self::$yydefault[$state];
-            } else {
-                if ($tokenId === self::TOKEN_NONE) {
-                    // fetch the next token id from the lexer and fetch additional info by-ref
-                    $origTokenId = $this->lexer->getNextToken($tokenValue, $startAttributes, $endAttributes);
-
-                    // map the lexer token id to the internally used token id's
-                    $tokenId = $origTokenId >= 0 && $origTokenId < self::TOKEN_MAP_SIZE
-                        ? self::$translate[$origTokenId]
-                        : self::TOKEN_INVALID;
-
-                    if ($tokenId === self::TOKEN_INVALID) {
-                        throw new RangeException(sprintf(
-                            'The lexer returned an invalid token (id=%d, value=%s)',
-                            $origTokenId, $tokenValue
-                        ));
-                    }
-
-                    $attributeStack[$this->stackPos] = $startAttributes;
-#if -t
-
-                    $this->YYTRACE_READ($tokenId);
-#endif
-                }
-
-                if ((($yyn = self::$yybase[$state] + $tokenId) >= 0
-                     && $yyn < self::YYLAST && self::$yycheck[$yyn] == $tokenId
-                     || ($state < self::YY2TBLSTATE
-                        && ($yyn = self::$yybase[$state + self::YYNLSTATES] + $tokenId) >= 0
-                        && $yyn < self::YYLAST
-                        && self::$yycheck[$yyn] == $tokenId))
-                    && ($yyn = self::$yyaction[$yyn]) != self::YYDEFAULT) {
-                    /*
-                     * >= YYNLSTATE: shift and reduce
-                     * > 0: shift
-                     * = 0: accept
-                     * < 0: reduce
-                     * = -YYUNEXPECTED: error
-                     */
-                    if ($yyn > 0) {
-                        /* shift */
-#if -t
-                        $this->YYTRACE_SHIFT($tokenId);
-
-#endif
-                        ++$this->stackPos;
-
-                        $stateStack[$this->stackPos]     = $state = $yyn;
-                        $this->yyastk[$this->stackPos]   = $tokenValue;
-                        $attributeStack[$this->stackPos] = $startAttributes;
-                        $tokenId = self::TOKEN_NONE;
-
-                        if ($yyn < self::YYNLSTATES)
-                            continue;
-
-                        /* $yyn >= YYNLSTATES means shift-and-reduce */
-                        $yyn -= self::YYNLSTATES;
-                    } else {
-                        $yyn = -$yyn;
-                    }
-                } else {
-                    $yyn = self::$yydefault[$state];
-                }
-            }
-
-            for (;;) {
-                /* reduce/error */
-                if ($yyn == 0) {
-                    /* accept */
-#if -t
-                    $this->YYTRACE_ACCEPT();
-#endif
-                    return $this->yyval;
-                } elseif ($yyn != self::YYUNEXPECTED) {
-                    /* reduce */
-#if -t
-                    $this->YYTRACE_REDUCE($yyn);
-#endif
-                    try {
-                        $this->{'yyn' . $yyn}(
-                            $attributeStack[$this->stackPos - self::$yylen[$yyn]]
-                            + $endAttributes
-                        );
-                    } catch (PHPParser_Error $e) {
-                        if (-1 === $e->getRawLine()) {
-                            $e->setRawLine($startAttributes['startLine']);
-                        }
-
-                        throw $e;
-                    }
-
-                    /* Goto - shift nonterminal */
-                    $this->stackPos -= self::$yylen[$yyn];
-                    $yyn = self::$yylhs[$yyn];
-                    if (($yyp = self::$yygbase[$yyn] + $stateStack[$this->stackPos]) >= 0
-                         && $yyp < self::YYGLAST
-                         && self::$yygcheck[$yyp] == $yyn) {
-                        $state = self::$yygoto[$yyp];
-                    } else {
-                        $state = self::$yygdefault[$yyn];
-                    }
-
-                    ++$this->stackPos;
-
-                    $stateStack[$this->stackPos]     = $state;
-                    $this->yyastk[$this->stackPos]   = $this->yyval;
-                    $attributeStack[$this->stackPos] = $startAttributes;
-                } else {
-                    /* error */
-                    throw new PHPParser_Error(
-                        'Unexpected token ' . self::$terminals[$tokenId],
-                        $startAttributes['startLine']
-                    );
-                }
-
-                if ($state < self::YYNLSTATES)
-                    break;
-                /* >= YYNLSTATES means shift-and-reduce */
-                $yyn = $state - self::YYNLSTATES;
-            }
-        }
-    }
-#ifnot -t
 #reduce
 
-    protected function yyn%n($attributes) {
+    protected function reduceRule%n($attributes) {
         %b
     }
 #noact
 
-    protected function yyn%n() {
-        $this->yyval = $this->yyastk[$this->stackPos];
+    protected function reduceRule%n() {
+        $this->semValue = $this->semStack[$this->stackPos];
     }
 #endreduce
-#endif
 }
 #tailcode;

grammar/rebuildParser.php

@@ -1,8 +1,20 @@
 <?php
 
-const GRAMMAR_FILE = './zend_language_parser.phpy';
-const TMP_FILE     = './tmp_parser.phpy';
-const RESULT_FILE  = './tmp_parser.php';
+$grammarFile           = __DIR__ . '/zend_language_parser.phpy';
+$skeletonFile          = __DIR__ . '/kmyacc.php.parser';
+$tmpGrammarFile        = __DIR__ . '/tmp_parser.phpy';
+$tmpResultFile         = __DIR__ . '/tmp_parser.php';
+$parserResultFile      = __DIR__ . '/../lib/PhpParser/Parser.php';
+
+// check for kmyacc.exe binary in this directory, otherwise fall back to global name
+$kmyacc = __DIR__ . '/kmyacc.exe';
+if (!file_exists($kmyacc)) {
+    $kmyacc = 'kmyacc';
+}
+
+$options = array_flip($argv);
+$optionDebug = isset($options['--debug']);
+$optionKeepTmpGrammar = isset($options['--keep-tmp-grammar']);
 
 ///////////////////////////////
 /// Utility regex constants ///
@@ -23,54 +35,40 @@ const ARGS   = '\((?<args>[^()]*+(?:\((?&args)\)[^()]*+)*+)\)';
 /// Main script ///
 ///////////////////
 
-echo '<pre>';
-
 echo 'Building temporary preproprocessed grammar file.', "\n";
 
-$grammarCode = file_get_contents(GRAMMAR_FILE);
+$grammarCode = file_get_contents($grammarFile);
 
 $grammarCode = resolveConstants($grammarCode);
 $grammarCode = resolveNodes($grammarCode);
 $grammarCode = resolveMacros($grammarCode);
 $grammarCode = resolveArrays($grammarCode);
 
-file_put_contents(TMP_FILE, $grammarCode);
+file_put_contents($tmpGrammarFile, $grammarCode);
 
-echo 'Building parser. Output: "',
-     trim(shell_exec('kmyacc -l -m kmyacc.php.parser -p PHPParser_Parser ' . TMP_FILE . ' 2>&1')),
-     '"', "\n";
+$additionalArgs = $optionDebug ? '-t -v' : '';
 
-rename(RESULT_FILE, '../lib/PHPParser/Parser.php');
+echo "Building parser.\n";
+$output = trim(shell_exec("$kmyacc $additionalArgs -l -m $skeletonFile $tmpGrammarFile 2>&1"));
+echo "Output: \"$output\"\n";
 
-if (isset($_GET['debug'])) {
-    echo 'Building debug parser. Output: "',
-    trim(shell_exec('kmyacc -t -v -l -m kmyacc.php.parser -p PHPParser_Parser ' . TMP_FILE . ' 2>&1')),
-    '"', "\n";
+moveFileWithDirCheck($tmpResultFile, $parserResultFile);
 
-    if (!is_dir('../lib/PHPParser/Parser')) {
-        mkdir('../lib/PHPParser/Parser');
-    }
-    rename(RESULT_FILE, '../lib/PHPParser/Parser/Debug.php');
+if (!$optionKeepTmpGrammar) {
+    unlink($tmpGrammarFile);
 }
 
-
-unlink(TMP_FILE);
-
-echo 'The following temporary preproprocessed grammar file was used:', "\n", $grammarCode;
-
-echo '</pre>';
-
 ///////////////////////////////
 /// Preprocessing functions ///
 ///////////////////////////////
 
 function resolveConstants($code) {
-    return preg_replace('~[A-Z][a-zA-Z_]++::~', 'PHPParser_Node_$0', $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 . '~',
+        '~(?<name>[A-Z][a-zA-Z_\\\\]++)\s*' . PARAMS . '~',
         function($matches) {
             // recurse
             $matches['params'] = resolveNodes($matches['params']);
@@ -85,7 +83,7 @@ function resolveNodes($code) {
                 $paramCode .= $param . ', ';
             }
 
-            return 'new PHPParser_Node_' . $matches['name'] . '(' . $paramCode . '$attributes)';
+            return 'new Node\\' . $matches['name'] . '(' . $paramCode . '$attributes)';
         },
         $code
     );
@@ -107,7 +105,7 @@ function resolveMacros($code) {
             if ('error' == $name) {
                 assertArgs(1, $args, $name);
 
-                return 'throw new PHPParser_Error(' . $args[0] . ')';
+                return 'throw new Error(' . $args[0] . ')';
             }
 
             if ('init' == $name) {
@@ -141,13 +139,13 @@ function resolveMacros($code) {
             if ('parseEncapsed' == $name) {
                 assertArgs(2, $args, $name);
 
-                return 'foreach (' . $args[0] . ' as &$s) { if (is_string($s)) { $s = PHPParser_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 = PHPParser_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)$~\', \'\', $s); if (\'\' === $s) array_pop(' . $args[0] . ');';
             }
 
             throw new Exception(sprintf('Unknown macro "%s"', $name));
@@ -193,6 +191,14 @@ function resolveArrays($code) {
     );
 }
 
+function moveFileWithDirCheck($fromPath, $toPath) {
+    $dir = dirname($toPath);
+    if (!is_dir($dir)) {
+        mkdir($dir, 0777, true);
+    }
+    rename($fromPath, $toPath);
+}
+
 //////////////////////////////
 /// Regex helper functions ///
 //////////////////////////////
@@ -209,4 +215,4 @@ function magicSplit($regex, $string) {
     }
 
     return array_filter($pieces);
-}
+}

grammar/zend_language_parser.phpy

@@ -7,7 +7,8 @@
 %left T_LOGICAL_XOR
 %left T_LOGICAL_AND
 %right T_PRINT
-%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
+%right T_YIELD
+%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 '?' ':'
 %left T_BOOLEAN_OR
 %left T_BOOLEAN_AND
@@ -22,6 +23,7 @@
 %right '!'
 %nonassoc T_INSTANCEOF
 %right '~' T_INC T_DEC T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@'
+%right T_POW
 %right '['
 %nonassoc T_NEW T_CLONE
 %token T_EXIT
@@ -63,6 +65,7 @@
 %token T_RETURN
 %token T_TRY
 %token T_CATCH
+%token T_FINALLY
 %token T_THROW
 %token T_USE
 %token T_INSTEADOF
@@ -104,11 +107,12 @@
 %token T_NS_C
 %token T_DIR
 %token T_NS_SEPARATOR
+%token T_ELLIPSIS
 
 %%
 
 start:
-    top_statement_list                                      { $$ = Stmt_Namespace::postprocess($1); }
+    top_statement_list                                      { $$ = $this->handleNamespaces($1); }
 ;
 
 top_statement_list:
@@ -116,9 +120,13 @@ top_statement_list:
     | /* empty */                                           { init(); }
 ;
 
-namespace_name:
+namespace_name_parts:
       T_STRING                                              { init($1); }
-    | namespace_name T_NS_SEPARATOR T_STRING                { push($1, $3); }
+    | namespace_name_parts T_NS_SEPARATOR T_STRING          { push($1, $3); }
+;
+
+namespace_name:
+      namespace_name_parts                                  { $$ = Name[$1]; }
 ;
 
 top_statement:
@@ -126,12 +134,14 @@ top_statement:
     | function_declaration_statement                        { $$ = $1; }
     | class_declaration_statement                           { $$ = $1; }
     | T_HALT_COMPILER
-          { $$ = Stmt_HaltCompiler[$this->lexer->handleHaltCompiler()]; }
-    | T_NAMESPACE namespace_name ';'                        { $$ = Stmt_Namespace[Name[$2], null]; }
-    | T_NAMESPACE namespace_name '{' top_statement_list '}' { $$ = Stmt_Namespace[Name[$2], $4]; }
-    | T_NAMESPACE '{' top_statement_list '}'                { $$ = Stmt_Namespace[null,     $3]; }
-    | T_USE use_declarations ';'                            { $$ = Stmt_Use[$2]; }
-    | T_CONST constant_declaration_list ';'                 { $$ = Stmt_Const[$2]; }
+          { $$ = Stmt\HaltCompiler[$this->lexer->handleHaltCompiler()]; }
+    | T_NAMESPACE namespace_name ';'                        { $$ = Stmt\Namespace_[$2, null]; }
+    | T_NAMESPACE namespace_name '{' top_statement_list '}' { $$ = Stmt\Namespace_[$2, $4]; }
+    | T_NAMESPACE '{' top_statement_list '}'                { $$ = Stmt\Namespace_[null,     $3]; }
+    | T_USE use_declarations ';'                            { $$ = Stmt\Use_[$2, Stmt\Use_::TYPE_NORMAL]; }
+    | T_USE T_FUNCTION use_declarations ';'                 { $$ = Stmt\Use_[$3, Stmt\Use_::TYPE_FUNCTION]; }
+    | T_USE T_CONST use_declarations ';'                    { $$ = Stmt\Use_[$3, Stmt\Use_::TYPE_CONSTANT]; }
+    | T_CONST constant_declaration_list ';'                 { $$ = Stmt\Const_[$2]; }
 ;
 
 use_declarations:
@@ -140,10 +150,10 @@ use_declarations:
 ;
 
 use_declaration:
-      namespace_name                                        { $$ = Stmt_UseUse[Name[$1], null]; }
-    | namespace_name T_AS T_STRING                          { $$ = Stmt_UseUse[Name[$1], $3]; }
-    | T_NS_SEPARATOR namespace_name                         { $$ = Stmt_UseUse[Name[$2], null]; }
-    | T_NS_SEPARATOR namespace_name T_AS T_STRING           { $$ = Stmt_UseUse[Name[$2], $4]; }
+      namespace_name                                        { $$ = Stmt\UseUse[$1, null]; }
+    | namespace_name T_AS T_STRING                          { $$ = Stmt\UseUse[$1, $3]; }
+    | T_NS_SEPARATOR namespace_name                         { $$ = Stmt\UseUse[$2, null]; }
+    | T_NS_SEPARATOR namespace_name T_AS T_STRING           { $$ = Stmt\UseUse[$2, $4]; }
 ;
 
 constant_declaration_list:
@@ -152,7 +162,7 @@ constant_declaration_list:
 ;
 
 constant_declaration:
-    T_STRING '=' static_scalar                              { $$ = Const[$1, $3]; }
+    T_STRING '=' static_scalar                              { $$ = Const_[$1, $3]; }
 ;
 
 inner_statement_list:
@@ -164,53 +174,59 @@ 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                                       { error('__HALT_COMPILER() can only be used from the outermost scope'); }
 ;
 
 statement:
       '{' inner_statement_list '}'                          { $$ = $2; }
-    | T_IF '(' expr ')' statement elseif_list else_single   { $$ = Stmt_If[$3, [stmts: toArray($5), elseifs: $6, else: $7]]; }
-    | T_IF '(' expr ')' ':' inner_statement_list new_elseif_list new_else_single T_ENDIF ';'
-          { $$ = Stmt_If[$3, [stmts: $6, elseifs: $7, else: $8]]; }
-    | T_WHILE '(' expr ')' while_statement                  { $$ = Stmt_While[$3, $5]; }
-    | T_DO statement T_WHILE '(' expr ')' ';'               { $$ = Stmt_Do   [$5, toArray($2)]; }
+    | T_IF parentheses_expr statement elseif_list else_single
+          { $$ = Stmt\If_[$2, [stmts: toArray($3), elseifs: $4, else: $5]]; }
+    | T_IF parentheses_expr ':' inner_statement_list new_elseif_list new_else_single T_ENDIF ';'
+          { $$ = Stmt\If_[$2, [stmts: $4, elseifs: $5, else: $6]]; }
+    | T_WHILE parentheses_expr while_statement              { $$ = Stmt\While_[$2, $3]; }
+    | T_DO statement T_WHILE parentheses_expr ';'           { $$ = Stmt\Do_   [$4, toArray($2)]; }
     | T_FOR '(' for_expr ';'  for_expr ';' for_expr ')' for_statement
-          { $$ = Stmt_For[[init: $3, cond: $5, loop: $7, stmts: $9]]; }
-    | T_SWITCH '(' expr ')' switch_case_list                { $$ = Stmt_Switch[$3, $5]; }
-    | T_BREAK ';'                                           { $$ = Stmt_Break[null]; }
-    | T_BREAK expr ';'                                      { $$ = Stmt_Break[$2]; }
-    | T_CONTINUE ';'                                        { $$ = Stmt_Continue[null]; }
-    | T_CONTINUE expr ';'                                   { $$ = Stmt_Continue[$2]; }
-    | T_RETURN ';'                                          { $$ = Stmt_Return[null]; }
-    | T_RETURN expr ';'                                     { $$ = Stmt_Return[$2]; }
-    | T_GLOBAL global_var_list ';'                          { $$ = Stmt_Global[$2]; }
-    | T_STATIC static_var_list ';'                          { $$ = Stmt_Static[$2]; }
-    | T_ECHO expr_list ';'                                  { $$ = Stmt_Echo[$2]; }
-    | T_INLINE_HTML                                         { $$ = Stmt_InlineHTML[$1]; }
+          { $$ = Stmt\For_[[init: $3, cond: $5, loop: $7, stmts: $9]]; }
+    | T_SWITCH parentheses_expr switch_case_list            { $$ = Stmt\Switch_[$2, $3]; }
+    | T_BREAK ';'                                           { $$ = Stmt\Break_[null]; }
+    | T_BREAK expr ';'                                      { $$ = Stmt\Break_[$2]; }
+    | T_CONTINUE ';'                                        { $$ = Stmt\Continue_[null]; }
+    | T_CONTINUE expr ';'                                   { $$ = Stmt\Continue_[$2]; }
+    | T_RETURN ';'                                          { $$ = Stmt\Return_[null]; }
+    | T_RETURN expr ';'                                     { $$ = Stmt\Return_[$2]; }
+    | yield_expr ';'                                        { $$ = $1; }
+    | T_GLOBAL global_var_list ';'                          { $$ = Stmt\Global_[$2]; }
+    | T_STATIC static_var_list ';'                          { $$ = Stmt\Static_[$2]; }
+    | T_ECHO expr_list ';'                                  { $$ = Stmt\Echo_[$2]; }
+    | T_INLINE_HTML                                         { $$ = Stmt\InlineHTML[$1]; }
     | expr ';'                                              { $$ = $1; }
-    | T_UNSET '(' variables_list ')' ';'                    { $$ = Stmt_Unset[$3]; }
-    | T_FOREACH '(' expr T_AS variable ')' foreach_statement
-          { $$ = Stmt_Foreach[$3, $5, [keyVar: null, byRef: false, stmts: $7]]; }
-    | T_FOREACH '(' expr T_AS '&' variable ')' foreach_statement
-          { $$ = Stmt_Foreach[$3, $6, [keyVar: null, byRef: true, stmts: $8]]; }
-    | T_FOREACH '(' expr T_AS variable T_DOUBLE_ARROW optional_ref variable ')' foreach_statement
-          { $$ = Stmt_Foreach[$3, $8, [keyVar: $5, byRef: $7, stmts: $10]]; }
-    | T_DECLARE '(' declare_list ')' declare_statement      { $$ = Stmt_Declare[$3, $5]; }
+    | T_UNSET '(' variables_list ')' ';'                    { $$ = Stmt\Unset_[$3]; }
+    | T_FOREACH '(' expr T_AS foreach_variable ')' foreach_statement
+          { $$ = Stmt\Foreach_[$3, $5[0], [keyVar: null, byRef: $5[1], stmts: $7]]; }
+    | T_FOREACH '(' expr T_AS variable T_DOUBLE_ARROW foreach_variable ')' foreach_statement
+          { $$ = Stmt\Foreach_[$3, $7[0], [keyVar: $5, byRef: $7[1], stmts: $9]]; }
+    | T_DECLARE '(' declare_list ')' declare_statement      { $$ = Stmt\Declare_[$3, $5]; }
     | ';'                                                   { $$ = array(); /* means: no statement */ }
-    | T_TRY '{' inner_statement_list '}' catches            { $$ = Stmt_TryCatch[$3, $5]; }
-    | T_THROW expr ';'                                      { $$ = Stmt_Throw[$2]; }
-    | T_GOTO T_STRING ';'                                   { $$ = Stmt_Goto[$2]; }
-    | T_STRING ':'                                          { $$ = Stmt_Label[$1]; }
+    | T_TRY '{' inner_statement_list '}' catches optional_finally
+          { $$ = Stmt\TryCatch[$3, $5, $6]; }
+    | T_THROW expr ';'                                      { $$ = Stmt\Throw_[$2]; }
+    | T_GOTO T_STRING ';'                                   { $$ = Stmt\Goto_[$2]; }
+    | T_STRING ':'                                          { $$ = Stmt\Label[$1]; }
 ;
 
 catches:
-      catch                                                 { init($1); }
+      /* empty */                                           { init(); }
     | catches catch                                         { push($1, $2); }
 ;
 
 catch:
     T_CATCH '(' name T_VARIABLE ')' '{' inner_statement_list '}'
-        { $$ = Stmt_Catch[$3, parseVar($4), $7]; }
+        { $$ = Stmt\Catch_[$3, parseVar($4), $7]; }
+;
+
+optional_finally:
+      /* empty */                                           { $$ = null; }
+    | T_FINALLY '{' inner_statement_list '}'                { $$ = $3; }
 ;
 
 variables_list:
@@ -223,24 +239,29 @@ optional_ref:
     | '&'                                                   { $$ = true; }
 ;
 
+optional_ellipsis:
+      /* empty */                                           { $$ = false; }
+    | T_ELLIPSIS                                            { $$ = true; }
+;
+
 function_declaration_statement:
     T_FUNCTION optional_ref T_STRING '(' parameter_list ')' '{' inner_statement_list '}'
-        { $$ = Stmt_Function[$3, [byRef: $2, params: $5, stmts: $8]]; }
+        { $$ = Stmt\Function_[$3, [byRef: $2, params: $5, stmts: $8]]; }
 ;
 
 class_declaration_statement:
       class_entry_type T_STRING extends_from implements_list '{' class_statement_list '}'
-          { $$ = Stmt_Class[$2, [type: $1, extends: $3, implements: $4, stmts: $6]]; }
+          { $$ = Stmt\Class_[$2, [type: $1, extends: $3, implements: $4, stmts: $6]]; }
     | T_INTERFACE T_STRING interface_extends_list '{' class_statement_list '}'
-          { $$ = Stmt_Interface[$2, [extends: $3, stmts: $5]]; }
+          { $$ = Stmt\Interface_[$2, [extends: $3, stmts: $5]]; }
     | T_TRAIT T_STRING '{' class_statement_list '}'
-          { $$ = Stmt_Trait[$2, $4]; }
+          { $$ = Stmt\Trait_[$2, $4]; }
 ;
 
 class_entry_type:
       T_CLASS                                               { $$ = 0; }
-    | T_ABSTRACT T_CLASS                                    { $$ = Stmt_Class::MODIFIER_ABSTRACT; }
-    | T_FINAL T_CLASS                                       { $$ = Stmt_Class::MODIFIER_FINAL; }
+    | T_ABSTRACT T_CLASS                                    { $$ = Stmt\Class_::MODIFIER_ABSTRACT; }
+    | T_FINAL T_CLASS                                       { $$ = Stmt\Class_::MODIFIER_FINAL; }
 ;
 
 extends_from:
@@ -284,7 +305,7 @@ declare_list:
 ;
 
 declare_list_element:
-      T_STRING '=' static_scalar                            { $$ = Stmt_DeclareDeclare[$1, $3]; }
+      T_STRING '=' static_scalar                            { $$ = Stmt\DeclareDeclare[$1, $3]; }
 ;
 
 switch_case_list:
@@ -300,8 +321,8 @@ case_list:
 ;
 
 case:
-      T_CASE expr case_separator inner_statement_list       { $$ = Stmt_Case[$2, $4]; }
-    | T_DEFAULT case_separator inner_statement_list         { $$ = Stmt_Case[null, $3]; }
+      T_CASE expr case_separator inner_statement_list       { $$ = Stmt\Case_[$2, $4]; }
+    | T_DEFAULT case_separator inner_statement_list         { $$ = Stmt\Case_[null, $3]; }
 ;
 
 case_separator:
@@ -320,7 +341,7 @@ elseif_list:
 ;
 
 elseif:
-      T_ELSEIF '(' expr ')' statement                       { $$ = Stmt_ElseIf[$3, toArray($5)]; }
+      T_ELSEIF parentheses_expr statement                   { $$ = Stmt\ElseIf_[$2, toArray($3)]; }
 ;
 
 new_elseif_list:
@@ -329,17 +350,23 @@ new_elseif_list:
 ;
 
 new_elseif:
-     T_ELSEIF '(' expr ')' ':' inner_statement_list         { $$ = Stmt_ElseIf[$3, $6]; }
+     T_ELSEIF parentheses_expr ':' inner_statement_list     { $$ = Stmt\ElseIf_[$2, $4]; }
 ;
 
 else_single:
       /* empty */                                           { $$ = null; }
-    | T_ELSE statement                                      { $$ = Stmt_Else[toArray($2)]; }
+    | T_ELSE statement                                      { $$ = Stmt\Else_[toArray($2)]; }
 ;
 
 new_else_single:
       /* empty */                                           { $$ = null; }
-    | T_ELSE ':' inner_statement_list                       { $$ = Stmt_Else[$3]; }
+    | T_ELSE ':' inner_statement_list                       { $$ = Stmt\Else_[$3]; }
+;
+
+foreach_variable:
+      variable                                              { $$ = array($1, false); }
+    | '&' variable                                          { $$ = array($2, true); }
+    | list_expr                                             { $$ = array($1, false); }
 ;
 
 parameter_list:
@@ -353,10 +380,10 @@ non_empty_parameter_list:
 ;
 
 parameter:
-      optional_class_type optional_ref T_VARIABLE
-          { $$ = Param[parseVar($3), null, $1, $2]; }
-    | optional_class_type optional_ref T_VARIABLE '=' static_scalar
-          { $$ = Param[parseVar($3), $5, $1, $2]; }
+      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_class_type:
@@ -367,8 +394,9 @@ optional_class_type:
 ;
 
 argument_list:
-      non_empty_argument_list                               { $$ = $1; }
-    | /* empty */                                           { $$ = array(); }
+      '(' ')'                                               { $$ = array(); }
+    | '(' non_empty_argument_list ')'                       { $$ = $2; }
+    | '(' yield_expr ')'                                    { $$ = array(Arg[$2, false, false]); }
 ;
 
 non_empty_argument_list:
@@ -377,8 +405,9 @@ non_empty_argument_list:
 ;
 
 argument:
-      expr                                                  { $$ = Arg[$1, false]; }
-    | '&' variable                                          { $$ = Arg[$2, true]; }
+      expr                                                  { $$ = Arg[$1, false, false]; }
+    | '&' variable                                          { $$ = Arg[$2, true, false]; }
+    | T_ELLIPSIS expr                                       { $$ = Arg[$2, false, true]; }
 ;
 
 global_var_list:
@@ -387,9 +416,9 @@ global_var_list:
 ;
 
 global_var:
-      T_VARIABLE                                            { $$ = Expr_Variable[parseVar($1)]; }
-    | '$' variable                                          { $$ = Expr_Variable[$2]; }
-    | '$' '{' expr '}'                                      { $$ = Expr_Variable[$3]; }
+      T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
+    | '$' variable                                          { $$ = Expr\Variable[$2]; }
+    | '$' '{' expr '}'                                      { $$ = Expr\Variable[$3]; }
 ;
 
 static_var_list:
@@ -398,8 +427,8 @@ static_var_list:
 ;
 
 static_var:
-      T_VARIABLE                                            { $$ = Stmt_StaticVar[parseVar($1), null]; }
-    | T_VARIABLE '=' static_scalar                          { $$ = Stmt_StaticVar[parseVar($1), $3]; }
+      T_VARIABLE                                            { $$ = Stmt\StaticVar[parseVar($1), null]; }
+    | T_VARIABLE '=' static_scalar                          { $$ = Stmt\StaticVar[parseVar($1), $3]; }
 ;
 
 class_statement_list:
@@ -408,11 +437,11 @@ class_statement_list:
 ;
 
 class_statement:
-      variable_modifiers property_declaration_list ';'      { $$ = Stmt_Property[$1, $2]; }
-    | T_CONST constant_declaration_list ';'                 { $$ = Stmt_ClassConst[$2]; }
+      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]]; }
-    | T_USE name_list trait_adaptations                     { $$ = Stmt_TraitUse[$2, $3]; }
+          { $$ = Stmt\ClassMethod[$4, [type: $1, byRef: $3, params: $6, stmts: $8]]; }
+    | T_USE name_list trait_adaptations                     { $$ = Stmt\TraitUse[$2, $3]; }
 ;
 
 trait_adaptations:
@@ -427,13 +456,13 @@ trait_adaptation_list:
 
 trait_adaptation:
       trait_method_reference_fully_qualified T_INSTEADOF name_list ';'
-          { $$ = Stmt_TraitUseAdaptation_Precedence[$1[0], $1[1], $3]; }
+          { $$ = Stmt\TraitUseAdaptation\Precedence[$1[0], $1[1], $3]; }
     | trait_method_reference T_AS member_modifier T_STRING ';'
-          { $$ = Stmt_TraitUseAdaptation_Alias[$1[0], $1[1], $3, $4]; }
+          { $$ = Stmt\TraitUseAdaptation\Alias[$1[0], $1[1], $3, $4]; }
     | trait_method_reference T_AS member_modifier ';'
-          { $$ = Stmt_TraitUseAdaptation_Alias[$1[0], $1[1], $3, null]; }
+          { $$ = Stmt\TraitUseAdaptation\Alias[$1[0], $1[1], $3, null]; }
     | trait_method_reference T_AS T_STRING ';'
-          { $$ = Stmt_TraitUseAdaptation_Alias[$1[0], $1[1], null, $3]; }
+          { $$ = Stmt\TraitUseAdaptation\Alias[$1[0], $1[1], null, $3]; }
 ;
 
 trait_method_reference_fully_qualified:
@@ -451,26 +480,26 @@ method_body:
 
 variable_modifiers:
       non_empty_member_modifiers                            { $$ = $1; }
-    | T_VAR                                                 { $$ = Stmt_Class::MODIFIER_PUBLIC; }
+    | T_VAR                                                 { $$ = Stmt\Class_::MODIFIER_PUBLIC; }
 ;
 
 method_modifiers:
-      /* empty */                                           { $$ = Stmt_Class::MODIFIER_PUBLIC; }
+      /* empty */                                           { $$ = Stmt\Class_::MODIFIER_PUBLIC; }
     | non_empty_member_modifiers                            { $$ = $1; }
 ;
 
 non_empty_member_modifiers:
       member_modifier                                       { $$ = $1; }
-    | non_empty_member_modifiers member_modifier            { Stmt_Class::verifyModifier($1, $2); $$ = $1 | $2; }
+    | non_empty_member_modifiers member_modifier            { Stmt\Class_::verifyModifier($1, $2); $$ = $1 | $2; }
 ;
 
 member_modifier:
-      T_PUBLIC                                              { $$ = Stmt_Class::MODIFIER_PUBLIC; }
-    | T_PROTECTED                                           { $$ = Stmt_Class::MODIFIER_PROTECTED; }
-    | T_PRIVATE                                             { $$ = Stmt_Class::MODIFIER_PRIVATE; }
-    | T_STATIC                                              { $$ = Stmt_Class::MODIFIER_STATIC; }
-    | T_ABSTRACT                                            { $$ = Stmt_Class::MODIFIER_ABSTRACT; }
-    | T_FINAL                                               { $$ = Stmt_Class::MODIFIER_FINAL; }
+      T_PUBLIC                                              { $$ = Stmt\Class_::MODIFIER_PUBLIC; }
+    | T_PROTECTED                                           { $$ = Stmt\Class_::MODIFIER_PROTECTED; }
+    | T_PRIVATE                                             { $$ = Stmt\Class_::MODIFIER_PRIVATE; }
+    | T_STATIC                                              { $$ = Stmt\Class_::MODIFIER_STATIC; }
+    | T_ABSTRACT                                            { $$ = Stmt\Class_::MODIFIER_ABSTRACT; }
+    | T_FINAL                                               { $$ = Stmt\Class_::MODIFIER_FINAL; }
 ;
 
 property_declaration_list:
@@ -479,8 +508,8 @@ property_declaration_list:
 ;
 
 property_declaration:
-      T_VARIABLE                                            { $$ = Stmt_PropertyProperty[parseVar($1), null]; }
-    | T_VARIABLE '=' static_scalar                          { $$ = Stmt_PropertyProperty[parseVar($1), $3]; }
+      T_VARIABLE                                            { $$ = Stmt\PropertyProperty[parseVar($1), null]; }
+    | T_VARIABLE '=' static_scalar                          { $$ = Stmt\PropertyProperty[parseVar($1), $3]; }
 ;
 
 expr_list:
@@ -495,90 +524,117 @@ for_expr:
 
 expr:
       variable                                              { $$ = $1; }
-    | T_LIST '(' assignment_list ')' '=' expr               { $$ = Expr_AssignList[$3, $6]; }
-    | variable '=' expr                                     { $$ = Expr_Assign[$1, $3]; }
-    | variable '=' '&' variable                             { $$ = Expr_AssignRef[$1, $4]; }
-    | variable '=' '&' new_expr                             { $$ = Expr_Assign[$1, $4]; } /* reference dropped intentially */
+    | list_expr '=' expr                                    { $$ = Expr\Assign[$1, $3]; }
+    | variable '=' expr                                     { $$ = Expr\Assign[$1, $3]; }
+    | variable '=' '&' variable                             { $$ = Expr\AssignRef[$1, $4]; }
+    | variable '=' '&' new_expr                             { $$ = Expr\AssignRef[$1, $4]; }
     | new_expr                                              { $$ = $1; }
-    | T_CLONE expr                                          { $$ = Expr_Clone[$2]; }
-    | variable T_PLUS_EQUAL expr                            { $$ = Expr_AssignPlus      [$1, $3]; }
-    | variable T_MINUS_EQUAL expr                           { $$ = Expr_AssignMinus     [$1, $3]; }
-    | variable T_MUL_EQUAL expr                             { $$ = Expr_AssignMul       [$1, $3]; }
-    | variable T_DIV_EQUAL expr                             { $$ = Expr_AssignDiv       [$1, $3]; }
-    | variable T_CONCAT_EQUAL expr                          { $$ = Expr_AssignConcat    [$1, $3]; }
-    | variable T_MOD_EQUAL expr                             { $$ = Expr_AssignMod       [$1, $3]; }
-    | variable T_AND_EQUAL expr                             { $$ = Expr_AssignBitwiseAnd[$1, $3]; }
-    | variable T_OR_EQUAL expr                              { $$ = Expr_AssignBitwiseOr [$1, $3]; }
-    | variable T_XOR_EQUAL expr                             { $$ = Expr_AssignBitwiseXor[$1, $3]; }
-    | variable T_SL_EQUAL expr                              { $$ = Expr_AssignShiftLeft [$1, $3]; }
-    | variable T_SR_EQUAL expr                              { $$ = Expr_AssignShiftRight[$1, $3]; }
-    | variable T_INC                                        { $$ = Expr_PostInc[$1]; }
-    | T_INC variable                                        { $$ = Expr_PreInc [$2]; }
-    | variable T_DEC                                        { $$ = Expr_PostDec[$1]; }
-    | T_DEC variable                                        { $$ = Expr_PreDec [$2]; }
-    | expr T_BOOLEAN_OR expr                                { $$ = Expr_BooleanOr [$1, $3]; }
-    | expr T_BOOLEAN_AND expr                               { $$ = Expr_BooleanAnd[$1, $3]; }
-    | expr T_LOGICAL_OR expr                                { $$ = Expr_LogicalOr [$1, $3]; }
-    | expr T_LOGICAL_AND expr                               { $$ = Expr_LogicalAnd[$1, $3]; }
-    | expr T_LOGICAL_XOR expr                               { $$ = Expr_LogicalXor[$1, $3]; }
-    | expr '|' expr                                         { $$ = Expr_BitwiseOr [$1, $3]; }
-    | expr '&' expr                                         { $$ = Expr_BitwiseAnd[$1, $3]; }
-    | expr '^' expr                                         { $$ = Expr_BitwiseXor[$1, $3]; }
-    | expr '.' expr                                         { $$ = Expr_Concat    [$1, $3]; }
-    | expr '+' expr                                         { $$ = Expr_Plus      [$1, $3]; }
-    | expr '-' expr                                         { $$ = Expr_Minus     [$1, $3]; }
-    | expr '*' expr                                         { $$ = Expr_Mul       [$1, $3]; }
-    | expr '/' expr                                         { $$ = Expr_Div       [$1, $3]; }
-    | expr '%' expr                                         { $$ = Expr_Mod       [$1, $3]; }
-    | expr T_SL expr                                        { $$ = Expr_ShiftLeft [$1, $3]; }
-    | expr T_SR expr                                        { $$ = Expr_ShiftRight[$1, $3]; }
-    | '+' expr %prec T_INC                                  { $$ = Expr_UnaryPlus [$2]; }
-    | '-' expr %prec T_INC                                  { $$ = Expr_UnaryMinus[$2]; }
-    | '!' expr                                              { $$ = Expr_BooleanNot[$2]; }
-    | '~' expr                                              { $$ = Expr_BitwiseNot[$2]; }
-    | expr T_IS_IDENTICAL expr                              { $$ = Expr_Identical     [$1, $3]; }
-    | expr T_IS_NOT_IDENTICAL expr                          { $$ = Expr_NotIdentical  [$1, $3]; }
-    | expr T_IS_EQUAL expr                                  { $$ = Expr_Equal         [$1, $3]; }
-    | expr T_IS_NOT_EQUAL expr                              { $$ = Expr_NotEqual      [$1, $3]; }
-    | expr '<' expr                                         { $$ = Expr_Smaller       [$1, $3]; }
-    | expr T_IS_SMALLER_OR_EQUAL expr                       { $$ = Expr_SmallerOrEqual[$1, $3]; }
-    | expr '>' expr                                         { $$ = Expr_Greater       [$1, $3]; }
-    | expr T_IS_GREATER_OR_EQUAL expr                       { $$ = Expr_GreaterOrEqual[$1, $3]; }
-    | expr T_INSTANCEOF class_name_reference                { $$ = Expr_Instanceof    [$1, $3]; }
-    | '(' expr ')'                                          { $$ = $2; }
+    | T_CLONE expr                                          { $$ = Expr\Clone_[$2]; }
+    | variable T_PLUS_EQUAL expr                            { $$ = Expr\AssignOp\Plus      [$1, $3]; }
+    | variable T_MINUS_EQUAL expr                           { $$ = Expr\AssignOp\Minus     [$1, $3]; }
+    | variable T_MUL_EQUAL expr                             { $$ = Expr\AssignOp\Mul       [$1, $3]; }
+    | variable T_DIV_EQUAL expr                             { $$ = Expr\AssignOp\Div       [$1, $3]; }
+    | variable T_CONCAT_EQUAL expr                          { $$ = Expr\AssignOp\Concat    [$1, $3]; }
+    | variable T_MOD_EQUAL expr                             { $$ = Expr\AssignOp\Mod       [$1, $3]; }
+    | variable T_AND_EQUAL expr                             { $$ = Expr\AssignOp\BitwiseAnd[$1, $3]; }
+    | variable T_OR_EQUAL expr                              { $$ = Expr\AssignOp\BitwiseOr [$1, $3]; }
+    | variable T_XOR_EQUAL expr                             { $$ = Expr\AssignOp\BitwiseXor[$1, $3]; }
+    | variable T_SL_EQUAL expr                              { $$ = Expr\AssignOp\ShiftLeft [$1, $3]; }
+    | variable T_SR_EQUAL expr                              { $$ = Expr\AssignOp\ShiftRight[$1, $3]; }
+    | variable T_POW_EQUAL expr                             { $$ = Expr\AssignOp\Pow       [$1, $3]; }
+    | variable T_INC                                        { $$ = Expr\PostInc[$1]; }
+    | T_INC variable                                        { $$ = Expr\PreInc [$2]; }
+    | variable T_DEC                                        { $$ = Expr\PostDec[$1]; }
+    | T_DEC variable                                        { $$ = Expr\PreDec [$2]; }
+    | expr T_BOOLEAN_OR expr                                { $$ = Expr\BinaryOp\BooleanOr [$1, $3]; }
+    | expr T_BOOLEAN_AND expr                               { $$ = Expr\BinaryOp\BooleanAnd[$1, $3]; }
+    | expr T_LOGICAL_OR expr                                { $$ = Expr\BinaryOp\LogicalOr [$1, $3]; }
+    | expr T_LOGICAL_AND expr                               { $$ = Expr\BinaryOp\LogicalAnd[$1, $3]; }
+    | expr T_LOGICAL_XOR expr                               { $$ = Expr\BinaryOp\LogicalXor[$1, $3]; }
+    | expr '|' expr                                         { $$ = Expr\BinaryOp\BitwiseOr [$1, $3]; }
+    | expr '&' expr                                         { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
+    | expr '^' expr                                         { $$ = Expr\BinaryOp\BitwiseXor[$1, $3]; }
+    | expr '.' expr                                         { $$ = Expr\BinaryOp\Concat    [$1, $3]; }
+    | expr '+' expr                                         { $$ = Expr\BinaryOp\Plus      [$1, $3]; }
+    | expr '-' expr                                         { $$ = Expr\BinaryOp\Minus     [$1, $3]; }
+    | expr '*' expr                                         { $$ = Expr\BinaryOp\Mul       [$1, $3]; }
+    | expr '/' expr                                         { $$ = Expr\BinaryOp\Div       [$1, $3]; }
+    | expr '%' expr                                         { $$ = Expr\BinaryOp\Mod       [$1, $3]; }
+    | expr T_SL expr                                        { $$ = Expr\BinaryOp\ShiftLeft [$1, $3]; }
+    | expr T_SR expr                                        { $$ = Expr\BinaryOp\ShiftRight[$1, $3]; }
+    | expr T_POW expr                                       { $$ = Expr\BinaryOp\Pow       [$1, $3]; }
+    | '+' expr %prec T_INC                                  { $$ = Expr\UnaryPlus [$2]; }
+    | '-' expr %prec T_INC                                  { $$ = Expr\UnaryMinus[$2]; }
+    | '!' expr                                              { $$ = Expr\BooleanNot[$2]; }
+    | '~' expr                                              { $$ = Expr\BitwiseNot[$2]; }
+    | expr T_IS_IDENTICAL expr                              { $$ = Expr\BinaryOp\Identical     [$1, $3]; }
+    | 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 '<' 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]; }
+    | expr T_IS_GREATER_OR_EQUAL expr                       { $$ = Expr\BinaryOp\GreaterOrEqual[$1, $3]; }
+    | expr T_INSTANCEOF class_name_reference                { $$ = Expr\Instanceof_[$1, $3]; }
+    | parentheses_expr                                      { $$ = $1; }
     /* we need a separate '(' new_expr ')' rule to avoid problems caused by a s/r conflict */
     | '(' new_expr ')'                                      { $$ = $2; }
-    | expr '?' expr ':' expr                                { $$ = Expr_Ternary[$1, $3,   $5]; }
-    | expr '?' ':' expr                                     { $$ = Expr_Ternary[$1, null, $4]; }
-    | T_ISSET '(' variables_list ')'                        { $$ = Expr_Isset[$3]; }
-    | T_EMPTY '(' variable ')'                              { $$ = Expr_Empty[$3]; }
-    | T_INCLUDE expr                                        { $$ = Expr_Include[$2, Expr_Include::TYPE_INCLUDE]; }
-    | T_INCLUDE_ONCE expr                                   { $$ = Expr_Include[$2, Expr_Include::TYPE_INCLUDE_ONCE]; }
-    | T_EVAL '(' expr ')'                                   { $$ = Expr_Eval[$3]; }
-    | T_REQUIRE expr                                        { $$ = Expr_Include[$2, Expr_Include::TYPE_REQUIRE]; }
-    | T_REQUIRE_ONCE expr                                   { $$ = Expr_Include[$2, Expr_Include::TYPE_REQUIRE_ONCE]; }
-    | T_INT_CAST expr                                       { $$ = Expr_Cast_Int     [$2]; }
-    | T_DOUBLE_CAST expr                                    { $$ = Expr_Cast_Double  [$2]; }
-    | T_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_UNSET_CAST expr                                     { $$ = Expr_Cast_Unset   [$2]; }
-    | T_EXIT exit_expr                                      { $$ = Expr_Exit         [$2]; }
-    | '@' expr                                              { $$ = Expr_ErrorSuppress[$2]; }
+    | expr '?' expr ':' expr                                { $$ = Expr\Ternary[$1, $3,   $5]; }
+    | expr '?' ':' expr                                     { $$ = Expr\Ternary[$1, null, $4]; }
+    | T_ISSET '(' variables_list ')'                        { $$ = Expr\Isset_[$3]; }
+    | T_EMPTY '(' expr ')'                                  { $$ = Expr\Empty_[$3]; }
+    | T_INCLUDE expr                                        { $$ = Expr\Include_[$2, Expr\Include_::TYPE_INCLUDE]; }
+    | T_INCLUDE_ONCE expr                                   { $$ = Expr\Include_[$2, Expr\Include_::TYPE_INCLUDE_ONCE]; }
+    | 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_DOUBLE_CAST expr                                    { $$ = Expr\Cast\Double  [$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_UNSET_CAST expr                                     { $$ = Expr\Cast\Unset_  [$2]; }
+    | T_EXIT exit_expr                                      { $$ = Expr\Exit_        [$2]; }
+    | '@' expr                                              { $$ = Expr\ErrorSuppress[$2]; }
     | scalar                                                { $$ = $1; }
-    | T_ARRAY '(' array_pair_list ')'                       { $$ = Expr_Array[$3]; }
-    | '[' array_pair_list ']'                               { $$ = Expr_Array[$2]; }
-    | '`' backticks_expr '`'                                { $$ = Expr_ShellExec[$2]; }
-    | T_PRINT expr                                          { $$ = Expr_Print[$2]; }
+    | array_expr                                            { $$ = $1; }
+    | scalar_dereference                                    { $$ = $1; }
+    | '`' 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]]; }
+          { $$ = 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]]; }
+          { $$ = Expr\Closure[[static: true, byRef: $3, params: $5, uses: $7, stmts: $9]]; }
+;
+
+parentheses_expr:
+      '(' expr ')'                                          { $$ = $2; }
+    | '(' yield_expr ')'                                    { $$ = $2; }
+;
+
+yield_expr:
+      T_YIELD expr                                          { $$ = Expr\Yield_[$2, null]; }
+    | T_YIELD expr T_DOUBLE_ARROW expr                      { $$ = Expr\Yield_[$4, $2]; }
+;
+
+array_expr:
+      T_ARRAY '(' array_pair_list ')'                       { $$ = Expr\Array_[$3]; }
+    | '[' array_pair_list ']'                               { $$ = Expr\Array_[$2]; }
+;
+
+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]; }
+    | constant '[' dim_offset ']'                           { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | scalar_dereference '[' dim_offset ']'                 { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    /* alternative array syntax missing intentionally */
 ;
 
 new_expr:
-      T_NEW class_name_reference ctor_arguments             { $$ = Expr_New[$2, $3]; }
+      T_NEW class_name_reference ctor_arguments             { $$ = Expr\New_[$2, $3]; }
 ;
 
 lexical_vars:
@@ -592,45 +648,45 @@ lexical_var_list:
 ;
 
 lexical_var:
-      optional_ref T_VARIABLE                               { $$ = Expr_ClosureUse[parseVar($2), $1]; }
+      optional_ref T_VARIABLE                               { $$ = Expr\ClosureUse[parseVar($2), $1]; }
 ;
 
 function_call:
-      name '(' argument_list ')'                            { $$ = Expr_FuncCall[$1, $3]; }
-    | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM T_STRING '(' argument_list ')'
-          { $$ = Expr_StaticCall[$1, $3, $5]; }
-    | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '{' expr '}' '(' argument_list ')'
-          { $$ = Expr_StaticCall[$1, $4, $7]; }
-    | static_property '(' argument_list ')' {
-            if ($1 instanceof PHPParser_Node_Expr_StaticPropertyFetch) {
-                $$ = Expr_StaticCall[$1->class, Expr_Variable[$1->name], $3];
-            } elseif ($1 instanceof PHPParser_Node_Expr_ArrayDimFetch) {
+      name argument_list                                    { $$ = Expr\FuncCall[$1, $2]; }
+    | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM T_STRING argument_list
+          { $$ = Expr\StaticCall[$1, $3, $4]; }
+    | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '{' expr '}' argument_list
+          { $$ = Expr\StaticCall[$1, $4, $6]; }
+    | static_property argument_list {
+            if ($1 instanceof Node\Expr\StaticPropertyFetch) {
+                $$ = Expr\StaticCall[$1->class, Expr\Variable[$1->name], $2];
+            } elseif ($1 instanceof Node\Expr\ArrayDimFetch) {
                 $tmp = $1;
-                while ($tmp->var instanceof PHPParser_Node_Expr_ArrayDimFetch) {
+                while ($tmp->var instanceof Node\Expr\ArrayDimFetch) {
                     $tmp = $tmp->var;
                 }
 
-                $$ = Expr_StaticCall[$tmp->var->class, $1, $3];
-                $tmp->var = Expr_Variable[$tmp->var->name];
+                $$ = Expr\StaticCall[$tmp->var->class, $1, $2];
+                $tmp->var = Expr\Variable[$tmp->var->name];
             } else {
-                throw new Exception;
+                throw new \Exception;
             }
           }
-    | variable_without_objects '(' argument_list ')'
-          { $$ = Expr_FuncCall[$1, $3]; }
-    | function_call '[' dim_offset ']'                      { $$ = Expr_ArrayDimFetch[$1, $3]; }
+    | variable_without_objects argument_list
+          { $$ = Expr\FuncCall[$1, $2]; }
+    | function_call '[' dim_offset ']'                      { $$ = Expr\ArrayDimFetch[$1, $3]; }
       /* alternative array syntax missing intentionally */
 ;
 
 class_name:
-      T_STATIC                                              { $$ = Name['static']; }
+      T_STATIC                                              { $$ = Name[$1]; }
     | name                                                  { $$ = $1; }
 ;
 
 name:
-      namespace_name                                        { $$ = Name[$1]; }
-    | T_NS_SEPARATOR namespace_name                         { $$ = Name_FullyQualified[$2]; }
-    | T_NAMESPACE T_NS_SEPARATOR namespace_name             { $$ = Name_Relative[$3]; }
+      namespace_name_parts                                  { $$ = Name[$1]; }
+    | T_NS_SEPARATOR namespace_name_parts                   { $$ = Name\FullyQualified[$2]; }
+    | T_NAMESPACE T_NS_SEPARATOR namespace_name_parts       { $$ = Name\Relative[$3]; }
 ;
 
 class_name_reference:
@@ -650,65 +706,111 @@ class_name_or_var:
 
 object_access_for_dcnr:
     | base_variable T_OBJECT_OPERATOR object_property
-          { $$ = Expr_PropertyFetch[$1, $3]; }
+          { $$ = Expr\PropertyFetch[$1, $3]; }
     | object_access_for_dcnr T_OBJECT_OPERATOR object_property
-          { $$ = Expr_PropertyFetch[$1, $3]; }
-    | object_access_for_dcnr '[' dim_offset ']'             { $$ = Expr_ArrayDimFetch[$1, $3]; }
-    | object_access_for_dcnr '{' expr '}'                   { $$ = Expr_ArrayDimFetch[$1, $3]; }
+          { $$ = Expr\PropertyFetch[$1, $3]; }
+    | object_access_for_dcnr '[' dim_offset ']'             { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | object_access_for_dcnr '{' expr '}'                   { $$ = Expr\ArrayDimFetch[$1, $3]; }
 ;
 
 exit_expr:
       /* empty */                                           { $$ = null; }
     | '(' ')'                                               { $$ = null; }
-    | '(' expr ')'                                          { $$ = $2; }
+    | parentheses_expr                                      { $$ = $1; }
 ;
 
 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; }
 ;
 
 ctor_arguments:
       /* empty */                                           { $$ = array(); }
-    | '(' argument_list ')'                                 { $$ = $2; }
+    | argument_list                                         { $$ = $1; }
 ;
 
 common_scalar:
-      T_LNUMBER                                             { $$ = Scalar_LNumber[Scalar_LNumber::parse($1)]; }
-    | T_DNUMBER                                             { $$ = Scalar_DNumber[Scalar_DNumber::parse($1)]; }
-    | T_CONSTANT_ENCAPSED_STRING                            { $$ = Scalar_String::create($1, $attributes); }
-    | T_LINE                                                { $$ = Scalar_LineConst[]; }
-    | T_FILE                                                { $$ = Scalar_FileConst[]; }
-    | T_DIR                                                 { $$ = Scalar_DirConst[]; }
-    | T_CLASS_C                                             { $$ = Scalar_ClassConst[]; }
-    | T_TRAIT_C                                             { $$ = Scalar_TraitConst[]; }
-    | T_METHOD_C                                            { $$ = Scalar_MethodConst[]; }
-    | T_FUNC_C                                              { $$ = Scalar_FuncConst[]; }
-    | T_NS_C                                                { $$ = Scalar_NSConst[]; }
+      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_LINE                                                { $$ = Scalar\MagicConst\Line[]; }
+    | T_FILE                                                { $$ = Scalar\MagicConst\File[]; }
+    | T_DIR                                                 { $$ = Scalar\MagicConst\Dir[]; }
+    | T_CLASS_C                                             { $$ = Scalar\MagicConst\Class_[]; }
+    | T_TRAIT_C                                             { $$ = Scalar\MagicConst\Trait_[]; }
+    | T_METHOD_C                                            { $$ = Scalar\MagicConst\Method[]; }
+    | T_FUNC_C                                              { $$ = Scalar\MagicConst\Function_[]; }
+    | T_NS_C                                                { $$ = Scalar\MagicConst\Namespace_[]; }
     | 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['']; }
-    | name                                                  { $$ = Expr_ConstFetch[$1]; }
+          { $$ = Scalar\String['']; }
 ;
 
-static_scalar: /* compile-time evaluated scalars */
+static_scalar:
       common_scalar                                         { $$ = $1; }
-    | class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING            { $$ = Expr_ClassConstFetch[$1, $3]; }
-    | '+' static_scalar                                     { $$ = Expr_UnaryPlus[$2]; }
-    | '-' static_scalar                                     { $$ = Expr_UnaryMinus[$2]; }
-    | T_ARRAY '(' static_array_pair_list ')'                { $$ = Expr_Array[$3]; }
-    | '[' static_array_pair_list ']'                        { $$ = Expr_Array[$2]; }
+    | class_name T_PAAMAYIM_NEKUDOTAYIM class_const_name    { $$ = Expr\ClassConstFetch[$1, $3]; }
+    | name                                                  { $$ = Expr\ConstFetch[$1]; }
+    | T_ARRAY '(' static_array_pair_list ')'                { $$ = Expr\Array_[$3]; }
+    | '[' static_array_pair_list ']'                        { $$ = Expr\Array_[$2]; }
+    | static_operation                                      { $$ = $1; }
+;
+
+static_operation:
+      static_scalar T_BOOLEAN_OR static_scalar              { $$ = Expr\BinaryOp\BooleanOr [$1, $3]; }
+    | static_scalar T_BOOLEAN_AND static_scalar             { $$ = Expr\BinaryOp\BooleanAnd[$1, $3]; }
+    | static_scalar T_LOGICAL_OR static_scalar              { $$ = Expr\BinaryOp\LogicalOr [$1, $3]; }
+    | static_scalar T_LOGICAL_AND static_scalar             { $$ = Expr\BinaryOp\LogicalAnd[$1, $3]; }
+    | static_scalar T_LOGICAL_XOR static_scalar             { $$ = Expr\BinaryOp\LogicalXor[$1, $3]; }
+    | static_scalar '|' static_scalar                       { $$ = Expr\BinaryOp\BitwiseOr [$1, $3]; }
+    | static_scalar '&' static_scalar                       { $$ = Expr\BinaryOp\BitwiseAnd[$1, $3]; }
+    | static_scalar '^' static_scalar                       { $$ = Expr\BinaryOp\BitwiseXor[$1, $3]; }
+    | static_scalar '.' static_scalar                       { $$ = Expr\BinaryOp\Concat    [$1, $3]; }
+    | static_scalar '+' static_scalar                       { $$ = Expr\BinaryOp\Plus      [$1, $3]; }
+    | static_scalar '-' static_scalar                       { $$ = Expr\BinaryOp\Minus     [$1, $3]; }
+    | static_scalar '*' static_scalar                       { $$ = Expr\BinaryOp\Mul       [$1, $3]; }
+    | static_scalar '/' static_scalar                       { $$ = Expr\BinaryOp\Div       [$1, $3]; }
+    | static_scalar '%' static_scalar                       { $$ = Expr\BinaryOp\Mod       [$1, $3]; }
+    | static_scalar T_SL static_scalar                      { $$ = Expr\BinaryOp\ShiftLeft [$1, $3]; }
+    | static_scalar T_SR static_scalar                      { $$ = Expr\BinaryOp\ShiftRight[$1, $3]; }
+    | static_scalar T_POW static_scalar                     { $$ = Expr\BinaryOp\Pow       [$1, $3]; }
+    | '+' static_scalar %prec T_INC                         { $$ = Expr\UnaryPlus [$2]; }
+    | '-' static_scalar %prec T_INC                         { $$ = Expr\UnaryMinus[$2]; }
+    | '!' static_scalar                                     { $$ = Expr\BooleanNot[$2]; }
+    | '~' static_scalar                                     { $$ = Expr\BitwiseNot[$2]; }
+    | static_scalar T_IS_IDENTICAL static_scalar            { $$ = Expr\BinaryOp\Identical     [$1, $3]; }
+    | static_scalar T_IS_NOT_IDENTICAL static_scalar        { $$ = Expr\BinaryOp\NotIdentical  [$1, $3]; }
+    | static_scalar T_IS_EQUAL static_scalar                { $$ = Expr\BinaryOp\Equal         [$1, $3]; }
+    | static_scalar T_IS_NOT_EQUAL static_scalar            { $$ = Expr\BinaryOp\NotEqual      [$1, $3]; }
+    | static_scalar '<' static_scalar                       { $$ = Expr\BinaryOp\Smaller       [$1, $3]; }
+    | static_scalar T_IS_SMALLER_OR_EQUAL static_scalar     { $$ = Expr\BinaryOp\SmallerOrEqual[$1, $3]; }
+    | static_scalar '>' static_scalar                       { $$ = Expr\BinaryOp\Greater       [$1, $3]; }
+    | static_scalar T_IS_GREATER_OR_EQUAL static_scalar     { $$ = Expr\BinaryOp\GreaterOrEqual[$1, $3]; }
+    | static_scalar '?' static_scalar ':' static_scalar     { $$ = Expr\Ternary[$1, $3,   $5]; }
+    | static_scalar '?' ':' static_scalar                   { $$ = Expr\Ternary[$1, null, $4]; }
+    | static_scalar '[' static_scalar ']'                   { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | '(' static_scalar ')'                                 { $$ = $2; }
+;
+
+constant:
+      name                                                  { $$ = Expr\ConstFetch[$1]; }
+    | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM class_const_name
+          { $$ = Expr\ClassConstFetch[$1, $3]; }
 ;
 
 scalar:
       common_scalar                                         { $$ = $1; }
-    | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM T_STRING     { $$ = Expr_ClassConstFetch[$1, $3]; }
+    | constant                                              { $$ = $1; }
     | '"' encaps_list '"'
-          { parseEncapsed($2, '"'); $$ = Scalar_Encapsed[$2]; }
+          { parseEncapsed($2, '"'); $$ = Scalar\Encapsed[$2]; }
     | T_START_HEREDOC encaps_list T_END_HEREDOC
-          { parseEncapsedDoc($2); $$ = Scalar_Encapsed[$2]; }
+          { parseEncapsedDoc($2); $$ = Scalar\Encapsed[$2]; }
+;
+
+class_const_name:
+      T_STRING                                              { $$ = $1; }
+    | T_CLASS                                               { $$ = 'class'; }
 ;
 
 static_array_pair_list:
@@ -727,8 +829,8 @@ non_empty_static_array_pair_list:
 ;
 
 static_array_pair:
-      static_scalar T_DOUBLE_ARROW static_scalar            { $$ = Expr_ArrayItem[$3, $1,   false]; }
-    | static_scalar                                         { $$ = Expr_ArrayItem[$1, null, false]; }
+      static_scalar T_DOUBLE_ARROW static_scalar            { $$ = Expr\ArrayItem[$3, $1,   false]; }
+    | static_scalar                                         { $$ = Expr\ArrayItem[$1, null, false]; }
 ;
 
 variable:
@@ -739,19 +841,19 @@ variable:
 ;
 
 new_expr_array_deref:
-      '(' new_expr ')' '[' dim_offset ']'                   { $$ = Expr_ArrayDimFetch[$2, $5]; }
-    | new_expr_array_deref '[' dim_offset ']'               { $$ = Expr_ArrayDimFetch[$1, $3]; }
+      '(' new_expr ')' '[' dim_offset ']'                   { $$ = Expr\ArrayDimFetch[$2, $5]; }
+    | new_expr_array_deref '[' dim_offset ']'               { $$ = Expr\ArrayDimFetch[$1, $3]; }
       /* alternative array syntax missing intentionally */
 ;
 
 object_access:
       variable_or_new_expr T_OBJECT_OPERATOR object_property
-          { $$ = Expr_PropertyFetch[$1, $3]; }
-    | variable_or_new_expr T_OBJECT_OPERATOR object_property '(' argument_list ')'
-          { $$ = Expr_MethodCall[$1, $3, $5]; }
-    | object_access '(' argument_list ')'                   { $$ = Expr_FuncCall[$1, $3]; }
-    | object_access '[' dim_offset ']'                      { $$ = Expr_ArrayDimFetch[$1, $3]; }
-    | object_access '{' expr '}'                            { $$ = Expr_ArrayDimFetch[$1, $3]; }
+          { $$ = Expr\PropertyFetch[$1, $3]; }
+    | variable_or_new_expr T_OBJECT_OPERATOR object_property argument_list
+          { $$ = Expr\MethodCall[$1, $3, $4]; }
+    | object_access argument_list                           { $$ = Expr\FuncCall[$1, $2]; }
+    | object_access '[' dim_offset ']'                      { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | object_access '{' expr '}'                            { $$ = Expr\ArrayDimFetch[$1, $3]; }
 ;
 
 variable_or_new_expr:
@@ -761,7 +863,7 @@ variable_or_new_expr:
 
 variable_without_objects:
       reference_variable                                    { $$ = $1; }
-    | '$' variable_without_objects                          { $$ = Expr_Variable[$2]; }
+    | '$' variable_without_objects                          { $$ = Expr\Variable[$2]; }
 ;
 
 base_variable:
@@ -771,24 +873,24 @@ base_variable:
 
 static_property:
       class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '$' reference_variable
-          { $$ = Expr_StaticPropertyFetch[$1, $4]; }
+          { $$ = Expr\StaticPropertyFetch[$1, $4]; }
     | static_property_with_arrays                           { $$ = $1; }
 ;
 
 static_property_with_arrays:
       class_name_or_var T_PAAMAYIM_NEKUDOTAYIM T_VARIABLE
-          { $$ = Expr_StaticPropertyFetch[$1, parseVar($3)]; }
+          { $$ = Expr\StaticPropertyFetch[$1, parseVar($3)]; }
     | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '$' '{' expr '}'
-          { $$ = Expr_StaticPropertyFetch[$1, $5]; }
-    | static_property_with_arrays '[' dim_offset ']'        { $$ = Expr_ArrayDimFetch[$1, $3]; }
-    | static_property_with_arrays '{' expr '}'              { $$ = Expr_ArrayDimFetch[$1, $3]; }
+          { $$ = Expr\StaticPropertyFetch[$1, $5]; }
+    | static_property_with_arrays '[' dim_offset ']'        { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | static_property_with_arrays '{' expr '}'              { $$ = Expr\ArrayDimFetch[$1, $3]; }
 ;
 
 reference_variable:
-      reference_variable '[' dim_offset ']'                 { $$ = Expr_ArrayDimFetch[$1, $3]; }
-    | reference_variable '{' expr '}'                       { $$ = Expr_ArrayDimFetch[$1, $3]; }
-    | T_VARIABLE                                            { $$ = Expr_Variable[parseVar($1)]; }
-    | '$' '{' expr '}'                                      { $$ = Expr_Variable[$3]; }
+      reference_variable '[' dim_offset ']'                 { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | reference_variable '{' expr '}'                       { $$ = Expr\ArrayDimFetch[$1, $3]; }
+    | T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
+    | '$' '{' expr '}'                                      { $$ = Expr\Variable[$3]; }
 ;
 
 dim_offset:
@@ -802,14 +904,18 @@ object_property:
     | variable_without_objects                              { $$ = $1; }
 ;
 
-assignment_list:
-      assignment_list ',' assignment_list_element           { push($1, $3); }
-    | assignment_list_element                               { init($1); }
+list_expr:
+      T_LIST '(' list_expr_elements ')'                     { $$ = Expr\List_[$3]; }
 ;
 
-assignment_list_element:
+list_expr_elements:
+      list_expr_elements ',' list_expr_element              { push($1, $3); }
+    | list_expr_element                                     { init($1); }
+;
+
+list_expr_element:
       variable                                              { $$ = $1; }
-    | T_LIST '(' assignment_list ')'                        { $$ = $3; }
+    | list_expr                                             { $$ = $1; }
     | /* empty */                                           { $$ = null; }
 ;
 
@@ -824,10 +930,10 @@ non_empty_array_pair_list:
 ;
 
 array_pair:
-      expr T_DOUBLE_ARROW expr                              { $$ = Expr_ArrayItem[$3, $1,   false]; }
-    | expr                                                  { $$ = Expr_ArrayItem[$1, null, false]; }
-    | expr T_DOUBLE_ARROW '&' variable                      { $$ = Expr_ArrayItem[$4, $1,   true]; }
-    | '&' variable                                          { $$ = Expr_ArrayItem[$2, null, true]; }
+      expr T_DOUBLE_ARROW expr                              { $$ = Expr\ArrayItem[$3, $1,   false]; }
+    | expr                                                  { $$ = Expr\ArrayItem[$1, null, false]; }
+    | expr T_DOUBLE_ARROW '&' variable                      { $$ = Expr\ArrayItem[$4, $1,   true]; }
+    | '&' variable                                          { $$ = Expr\ArrayItem[$2, null, true]; }
 ;
 
 encaps_list:
@@ -838,20 +944,20 @@ encaps_list:
 ;
 
 encaps_var:
-      T_VARIABLE                                            { $$ = Expr_Variable[parseVar($1)]; }
-    | T_VARIABLE '[' encaps_var_offset ']'                  { $$ = Expr_ArrayDimFetch[Expr_Variable[parseVar($1)], $3]; }
-    | T_VARIABLE T_OBJECT_OPERATOR T_STRING                 { $$ = Expr_PropertyFetch[Expr_Variable[parseVar($1)], $3]; }
-    | T_DOLLAR_OPEN_CURLY_BRACES expr '}'                   { $$ = Expr_Variable[$2]; }
-    | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '}'       { $$ = Expr_Variable[$2]; }
+      T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
+    | T_VARIABLE '[' encaps_var_offset ']'                  { $$ = Expr\ArrayDimFetch[Expr\Variable[parseVar($1)], $3]; }
+    | T_VARIABLE T_OBJECT_OPERATOR T_STRING                 { $$ = Expr\PropertyFetch[Expr\Variable[parseVar($1)], $3]; }
+    | T_DOLLAR_OPEN_CURLY_BRACES expr '}'                   { $$ = Expr\Variable[$2]; }
+    | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '}'       { $$ = Expr\Variable[$2]; }
     | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
-          { $$ = Expr_ArrayDimFetch[Expr_Variable[$2], $4]; }
+          { $$ = Expr\ArrayDimFetch[Expr\Variable[$2], $4]; }
     | T_CURLY_OPEN variable '}'                             { $$ = $2; }
 ;
 
 encaps_var_offset:
-      T_STRING                                              { $$ = Scalar_String[$1]; }
-    | T_NUM_STRING                                          { $$ = Scalar_String[$1]; }
-    | T_VARIABLE                                            { $$ = Expr_Variable[parseVar($1)]; }
+      T_STRING                                              { $$ = Scalar\String[$1]; }
+    | T_NUM_STRING                                          { $$ = Scalar\String[$1]; }
+    | T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
 ;
 
 %%

lib/PHPParser/Autoloader.php

@@ -1,33 +0,0 @@
-<?php
-
-/**
- * @codeCoverageIgnore
- */
-class PHPParser_Autoloader
-{
-    /**
-    * Registers PHPParser_Autoloader as an SPL autoloader.
-    */
-    static public function register()
-    {
-        ini_set('unserialize_callback_func', 'spl_autoload_call');
-        spl_autoload_register(array(__CLASS__, 'autoload'));
-    }
-
-    /**
-    * Handles autoloading of classes.
-    *
-    * @param string $class A class name.
-    */
-    static public function autoload($class)
-    {
-        if (0 !== strpos($class, 'PHPParser')) {
-            return;
-        }
-
-        $file = dirname(dirname(__FILE__)) . '/' . strtr($class, '_', '/') . '.php';
-        if (is_file($file)) {
-            require $file;
-        }
-    }
-}

lib/PHPParser/BuilderFactory.php

@@ -1,77 +0,0 @@
-<?php
-
-/**
- * "class" and "function" are reserved keywords, so the methods are defined as _class()
- * and _function() in the class and are made available as class() and function() through
- * __call() magic.
- *
- * @method PHPParser_Builder_Class    class(string $name)    Creates a class builder.
- * @method PHPParser_Builder_Function function(string $name) Creates a function builder
- */
-class PHPParser_BuilderFactory
-{
-    /**
-     * Creates a class builder.
-     *
-     * @param string $name Name of the class
-     *
-     * @return PHPParser_Builder_Class The created class builder
-     */
-    protected function _class($name) {
-        return new PHPParser_Builder_Class($name);
-    }
-
-    /**
-     * Creates a method builder.
-     *
-     * @param string $name Name of the method
-     *
-     * @return PHPParser_Builder_Method The created method builder
-     */
-    public function method($name) {
-        return new PHPParser_Builder_Method($name);
-    }
-
-    /**
-     * Creates a parameter builder.
-     *
-     * @param string $name Name of the parameter
-     *
-     * @return PHPParser_Builder_Param The created parameter builder
-     */
-    public function param($name) {
-        return new PHPParser_Builder_Param($name);
-    }
-
-    /**
-     * Creates a property builder.
-     *
-     * @param string $name Name of the property
-     *
-     * @return PHPParser_Builder_Property The created property builder
-     */
-    public function property($name) {
-        return new PHPParser_Builder_Property($name);
-    }
-
-    /**
-     * Creates a function builder.
-     *
-     * @param string $name Name of the function
-     *
-     * @return PHPParser_Builder_Property The created function builder
-     */
-    protected function _function($name) {
-        return new PHPParser_Builder_Function($name);
-    }
-
-    public function __call($name, array $args) {
-        if ('class' === $name) {
-            return call_user_func_array(array($this, '_class'), $args);
-        } elseif ('function' === $name) {
-            return call_user_func_array(array($this, '_function'), $args);
-        }
-
-        throw new LogicException(sprintf('Method "%s" does not exist', $name));
-    }
-}

lib/PHPParser/Comment/Doc.php

@@ -1,5 +0,0 @@
-<?php
-
-class PHPParser_Comment_Doc extends PHPParser_Comment
-{
-}

lib/PHPParser/Lexer/Emulative.php

@@ -1,198 +0,0 @@
-<?php
-
-/**
- * ATTENTION: This code is WRITE-ONLY. Do not try to read it.
- */
-class PHPParser_Lexer_Emulative extends PHPParser_Lexer
-{
-    protected $newKeywords;
-    protected $inObjectAccess;
-
-    public function __construct() {
-        parent::__construct();
-
-        $this->newKeywords = array();
-
-        if (version_compare(PHP_VERSION, '5.4.0RC1', '>=')) {
-            return;
-        }
-
-        // new PHP 5.4 keywords
-        $this->newKeywords += array(
-            'callable'  => PHPParser_Parser::T_CALLABLE,
-            'insteadof' => PHPParser_Parser::T_INSTEADOF,
-            'trait'     => PHPParser_Parser::T_TRAIT,
-            '__trait__' => PHPParser_Parser::T_TRAIT_C,
-        );
-
-        if (version_compare(PHP_VERSION, '5.3.0', '>=')) {
-            return;
-        }
-
-        // new PHP 5.3 keywords
-        $this->newKeywords += array(
-            '__dir__'       => PHPParser_Parser::T_DIR,
-            'goto'          => PHPParser_Parser::T_GOTO,
-            'namespace'     => PHPParser_Parser::T_NAMESPACE,
-            '__namespace__' => PHPParser_Parser::T_NS_C,
-        );
-    }
-
-    public function startLexing($code) {
-        $this->inObjectAccess = false;
-
-        // on PHP 5.4 don't do anything
-        if (version_compare(PHP_VERSION, '5.4.0RC1', '>=')) {
-            parent::startLexing($code);
-        } else {
-            $code = $this->preprocessCode($code);
-            parent::startLexing($code);
-            $this->postprocessTokens();
-        }
-    }
-
-    /*
-     * Replaces new features in the code by ~__EMU__{NAME}__{DATA}__~ sequences.
-     * ~LABEL~ is never valid PHP code, that's why we can (to some degree) safely
-     * use it here.
-     * Later when preprocessing the tokens these sequences will either be replaced
-     * by real tokens or replaced with their original content (e.g. if they occured
-     * inside a string, i.e. a place where they don't have a special meaning).
-     */
-    protected function preprocessCode($code) {
-        // binary notation (0b010101101001...)
-        $code = preg_replace('(\b0b[01]+\b)', '~__EMU__BINARY__$0__~', $code);
-
-        if (version_compare(PHP_VERSION, '5.3.0', '<')) {
-            // namespace separator (backslash not followed by some special characters,
-            // which are not valid after a NS separator, but would cause problems with
-            // escape sequence parsing if one would replace the backslash there)
-            $code = preg_replace('(\\\\(?!["\'`${\\\\]))', '~__EMU__NS__~', $code);
-
-            // nowdoc (<<<'ABC'\ncontent\nABC;)
-            $code = preg_replace_callback(
-                '((*BSR_ANYCRLF)        # set \R to (?>\r\n|\r|\n)
-                  (b?<<<[\t ]*\'([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)\'\R) # opening token
-                  ((?:(?!\2;?\R).*\R)*) # content
-                  (\2)                  # closing token
-                  (?=;?\R)              # must be followed by newline (with optional semicolon)
-                 )x',
-                array($this, 'encodeNowdocCallback'),
-                $code
-            );
-        }
-
-        return $code;
-    }
-
-    /*
-     * As nowdocs can have arbitrary content but LABELs can only contain a certain
-     * range of characters, the nowdoc content is encoded as hex and separated by
-     * 'x' tokens. So the result of the encoding will look like this:
-     * ~__EMU__NOWDOC__{HEX(START_TOKEN)}x{HEX(CONTENT)}x{HEX(END_TOKEN)}~
-     */
-    public function encodeNowdocCallback(array $matches) {
-        return '~__EMU__NOWDOC__'
-                . bin2hex($matches[1]) . 'x' . bin2hex($matches[3]) . 'x' . bin2hex($matches[4])
-                . '__~';
-    }
-
-    /*
-     * Replaces the ~__EMU__...~ sequences with real tokens or their original
-     * value.
-     */
-    protected function postprocessTokens() {
-        // we need to manually iterate and manage a count because we'll change
-        // the tokens array on the way
-        for ($i = 0, $c = count($this->tokens); $i < $c; ++$i) {
-            // first check that the following tokens are form ~LABEL~,
-            // then match the __EMU__... sequence.
-            if ('~' === $this->tokens[$i]
-                && isset($this->tokens[$i + 2])
-                && '~' === $this->tokens[$i + 2]
-                && T_STRING === $this->tokens[$i + 1][0]
-                && preg_match('(^__EMU__([A-Z]++)__(?:([A-Za-z0-9]++)__)?$)', $this->tokens[$i + 1][1], $matches)
-            ) {
-                if ('BINARY' === $matches[1]) {
-                    // the binary number can either be an integer or a double, so return a LNUMBER
-                    // or DNUMBER respectively
-                    $replace = array(
-                        array(is_int(bindec($matches[2])) ? T_LNUMBER : T_DNUMBER, $matches[2], $this->tokens[$i + 1][2])
-                    );
-                } elseif ('NS' === $matches[1]) {
-                    // a \ single char token is returned here and replaced by a
-                    // PHPParser_Parser::T_NS_SEPARATOR token in ->getNextToken(). This hacks around
-                    // the limitations arising from T_NS_SEPARATOR not being defined on 5.3
-                    $replace = array('\\');
-                } elseif ('NOWDOC' === $matches[1]) {
-                    // decode the encoded nowdoc payload; pack('H*' is bin2hex( for 5.3
-                    list($start, $content, $end) = explode('x', $matches[2]);
-                    list($start, $content, $end) = array(pack('H*', $start), pack('H*', $content), pack('H*', $end));
-
-                    $replace = array();
-                    $replace[] = array(T_START_HEREDOC, $start, $this->tokens[$i + 1][2]);
-                    if ('' !== $content) {
-                        $replace[] = array(T_ENCAPSED_AND_WHITESPACE, $content, -1);
-                    }
-                    $replace[] = array(T_END_HEREDOC, $end, -1);
-                } else {
-                    // just ignore all other __EMU__ sequences
-                    continue;
-                }
-
-                array_splice($this->tokens, $i, 3, $replace);
-                $c -= 3 - count($replace);
-            // for multichar tokens (e.g. strings) replace any ~__EMU__...~ sequences
-            // in their content with the original character sequence
-            } elseif (is_array($this->tokens[$i])
-                      && 0 !== strpos($this->tokens[$i][1], '__EMU__')
-            ) {
-                $this->tokens[$i][1] = preg_replace_callback(
-                    '(~__EMU__([A-Z]++)__(?:([A-Za-z0-9]++)__)?~)',
-                    array($this, 'restoreContentCallback'),
-                    $this->tokens[$i][1]
-                );
-            }
-        }
-    }
-
-    /*
-     * This method is a callback for restoring EMU sequences in
-     * multichar tokens (like strings) to their original value.
-     */
-    public function restoreContentCallback(array $matches) {
-        if ('BINARY' === $matches[1]) {
-            return $matches[2];
-        } elseif ('NS' === $matches[1]) {
-            return '\\';
-        } elseif ('NOWDOC' === $matches[1]) {
-            list($start, $content, $end) = explode('x', $matches[2]);
-            return pack('H*', $start) . pack('H*', $content) . pack('H*', $end);
-        } else {
-            return $matches[0];
-        }
-    }
-
-    public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
-        $token = parent::getNextToken($value, $startAttributes, $endAttributes);
-
-        // replace new keywords by their respective tokens. This is not done
-        // if we currently are in an object access (e.g. in $obj->namespace
-        // "namespace" stays a T_STRING tokens and isn't converted to T_NAMESPACE)
-        if (PHPParser_Parser::T_STRING === $token && !$this->inObjectAccess) {
-            if (isset($this->newKeywords[strtolower($value)])) {
-                return $this->newKeywords[strtolower($value)];
-            }
-        // backslashes are replaced by T_NS_SEPARATOR tokens
-        } elseif (92 === $token) { // ord('\\')
-            return PHPParser_Parser::T_NS_SEPARATOR;
-        // keep track of whether we currently are in an object access (after ->)
-        } elseif (PHPParser_Parser::T_OBJECT_OPERATOR === $token) {
-            $this->inObjectAccess = true;
-        } else {
-            $this->inObjectAccess = false;
-        }
-
-        return $token;
-    }
-}

lib/PHPParser/Node/Arg.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $value Value to pass
- * @property bool                $byRef Whether to pass by ref
- */
-class PHPParser_Node_Arg extends PHPParser_NodeAbstract
-{
-    /**
-     * Constructs a function call argument node.
-     *
-     * @param PHPParser_Node_Expr $value      Value to pass
-     * @param bool                $byRef      Whether to pass by ref
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $value, $byRef = false, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'value' => $value,
-                'byRef' => $byRef
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Const.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property string              $name  Name
- * @property PHPParser_Node_Expr $value Value
- */
-class PHPParser_Node_Const extends PHPParser_NodeAbstract
-{
-    /**
-     * Constructs a const node for use in class const and const statements.
-     *
-     * @param string              $name       Name
-     * @param PHPParser_Node_Expr $value      Value
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct($name, PHPParser_Node_Expr $value, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'name'  => $name,
-                'value' => $value,
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr.php

@@ -1,5 +0,0 @@
-<?php
-
-abstract class PHPParser_Node_Expr extends PHPParser_NodeAbstract
-{
-}

lib/PHPParser/Node/Expr/ArrayDimFetch.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr      $var Variable
- * @property null|PHPParser_Node_Expr $dim Array index / dim
- */
-class PHPParser_Node_Expr_ArrayDimFetch extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an array index fetch node.
-     *
-     * @param PHPParser_Node_Expr      $var        Variable
-     * @param null|PHPParser_Node_Expr $dim        Array index / dim
-     * @param array                    $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $dim = null, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var,
-                'dim' => $dim
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/ArrayItem.php

@@ -1,28 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr      $value Value
- * @property null|PHPParser_Node_Expr $key   Key
- * @property bool                     $byRef Whether to assign by reference
- */
-class PHPParser_Node_Expr_ArrayItem extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an array item node.
-     *
-     * @param PHPParser_Node_Expr      $value      Value
-     * @param null|PHPParser_Node_Expr $key        Key
-     * @param bool                     $byRef      Whether to assign by reference
-     * @param array                    $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $value, PHPParser_Node_Expr $key = null, $byRef = false, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'key'   => $key,
-                'value' => $value,
-                'byRef' => $byRef
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Assign.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_Assign extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignBitwiseAnd.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignBitwiseAnd extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with bitwise and node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignBitwiseOr.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignBitwiseOr extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with bitwise or node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignBitwiseXor.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignBitwiseXor extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with bitwise xor node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignConcat.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignConcat extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with concat node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignDiv.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignDiv extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with division node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignList.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property array               $vars List of variables to assign to
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignList extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a list() assignment node.
-     *
-     * @param array               $vars       List of variables to assign to
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(array $vars, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'vars' => $vars,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignMinus.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignMinus extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with minus node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignMod.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignMod extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with modulo node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignMul.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignMul extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with multiplication node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignPlus.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignPlus extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with addition node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignRef.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable reference is assigned to
- * @property PHPParser_Node_Expr $expr Variable which is referenced
- */
-class PHPParser_Node_Expr_AssignRef extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignShiftLeft.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignShiftLeft extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with left shift node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/AssignShiftRight.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var  Variable
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_AssignShiftRight extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an assignment with right shift node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/BitwiseAnd.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_BitwiseAnd extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a bitwise and node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/BitwiseNot.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_BitwiseNot extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a bitwise not node.
-     *
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/BitwiseOr.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_BitwiseOr extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a bitwise or node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/BitwiseXor.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_BitwiseXor extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a bitwise xor node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/BooleanAnd.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_BooleanAnd extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a boolean and node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/BooleanOr.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_BooleanOr extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a boolean or node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Cast.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr Expression
- */
-abstract class PHPParser_Node_Expr_Cast extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a cast node.
-     *
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Cast/Array.php

@@ -1,5 +0,0 @@
-<?php
-
-class PHPParser_Node_Expr_Cast_Array extends PHPParser_Node_Expr_Cast
-{
-}

lib/PHPParser/Node/Expr/Cast/Bool.php

@@ -1,5 +0,0 @@
-<?php
-
-class PHPParser_Node_Expr_Cast_Bool extends PHPParser_Node_Expr_Cast
-{
-}

lib/PHPParser/Node/Expr/Cast/Double.php

@@ -1,5 +0,0 @@
-<?php
-
-class PHPParser_Node_Expr_Cast_Double extends PHPParser_Node_Expr_Cast
-{
-}

lib/PHPParser/Node/Expr/Cast/Int.php

@@ -1,5 +0,0 @@
-<?php
-
-class PHPParser_Node_Expr_Cast_Int extends PHPParser_Node_Expr_Cast
-{
-}

lib/PHPParser/Node/Expr/Cast/Object.php

@@ -1,5 +0,0 @@
-<?php
-
-class PHPParser_Node_Expr_Cast_Object extends PHPParser_Node_Expr_Cast
-{
-}

lib/PHPParser/Node/Expr/Cast/String.php

@@ -1,5 +0,0 @@
-<?php
-
-class PHPParser_Node_Expr_Cast_String extends PHPParser_Node_Expr_Cast
-{
-}

lib/PHPParser/Node/Expr/Cast/Unset.php

@@ -1,5 +0,0 @@
-<?php
-
-class PHPParser_Node_Expr_Cast_Unset extends PHPParser_Node_Expr_Cast
-{
-}

lib/PHPParser/Node/Expr/ClassConstFetch.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Name|PHPParser_Node_Expr $class Class name
- * @property string                                  $name  Constant name
- */
-class PHPParser_Node_Expr_ClassConstFetch extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a class const fetch node.
-     *
-     * @param PHPParser_Node_Name|PHPParser_Node_Expr $class      Class name
-     * @param string                                  $name       Constant name
-     * @param array                                   $attributes Additional attributes
-     */
-    public function __construct($class, $name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'class' => $class,
-                'name'  => $name
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Clone.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_Clone extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a clone node.
-     *
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Closure.php

@@ -1,35 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node[]                 $stmts  Statements
- * @property PHPParser_Node_Stmt_FuncParam[]  $params Parameters
- * @property PHPParser_Node_Expr_ClosureUse[] $uses   use()s
- * @property bool                             $byRef  Whether to return by reference
- * @property bool                             $static Whether the closure is static
- */
-class PHPParser_Node_Expr_Closure extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a lambda function node.
-     *
-     * @param array $subNodes   Array of the following optional subnodes:
-     *                          'stmts'  => array(): Statements
-     *                          'params' => array(): Parameters
-     *                          'uses'   => array(): use()s
-     *                          'byRef'  => false  : Whether to return by reference
-     *                          'static' => false  : Whether the closure is static
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(array $subNodes = array(), array $attributes = array()) {
-        parent::__construct(
-            $subNodes + array(
-                'stmts'  => array(),
-                'params' => array(),
-                'uses'   => array(),
-                'byRef'  => false,
-                'static' => false,
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Concat.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Concat extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a concat node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/ConstFetch.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Name $name Constant name
- */
-class PHPParser_Node_Expr_ConstFetch extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a const fetch node.
-     *
-     * @param PHPParser_Node_Name $name       Constant name
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Name $name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'name'  => $name
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Div.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Div extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a division node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Empty.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var Variable
- */
-class PHPParser_Node_Expr_Empty extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an empty() node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Equal.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Equal extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a equality comparison node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/ErrorSuppress.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_ErrorSuppress extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an error suppress node.
-     *
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Eval.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_Eval extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an eval() node.
-     *
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Greater.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Greater extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a greater than comparison node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/GreaterOrEqual.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_GreaterOrEqual extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a greater than or equal node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Identical.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Identical extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an identicality comparison node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Include.php

@@ -1,30 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr Expression
- * @property int                 $type Type of include
- */
-class PHPParser_Node_Expr_Include extends PHPParser_Node_Expr
-{
-    const TYPE_INCLUDE      = 1;
-    const TYPE_INCLUDE_ONCE = 2;
-    const TYPE_REQUIRE      = 3;
-    const TYPE_REQUIRE_ONCE = 4;
-
-    /**
-     * Constructs an include node.
-     *
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param int                 $type       Type of include
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, $type, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr,
-                'type' => $type
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Instanceof.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr  Expression
- * @property PHPParser_Node_Name|PHPParser_Node_Expr $class Class name
- */
-class PHPParser_Node_Expr_Instanceof extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an instanceof check node.
-     *
-     * @param PHPParser_Node_Expr                     $expr       Expression
-     * @param PHPParser_Node_Name|PHPParser_Node_Expr $class      Class name
-     * @param array                                   $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, $class, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr'  => $expr,
-                'class' => $class
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/LogicalAnd.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_LogicalAnd extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a logical and node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/LogicalOr.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_LogicalOr extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a logical or node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/LogicalXor.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_LogicalXor extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a logical xor node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/MethodCall.php

@@ -1,28 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr        $var  Variable holding object
- * @property string|PHPParser_Node_Expr $name Method name
- * @property PHPParser_Node_Arg[]       $args Arguments
- */
-class PHPParser_Node_Expr_MethodCall extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a function call node.
-     *
-     * @param PHPParser_Node_Expr        $var        Variable holding object
-     * @param string|PHPParser_Node_Expr $name       Method name
-     * @param PHPParser_Node_Arg[]       $args       Arguments
-     * @param array                      $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, $name, array $args = array(), array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'name' => $name,
-                'args' => $args
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Minus.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Minus extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a substraction node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Mod.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Mod extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a modulo node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Mul.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Mul extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a multiplication node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/New.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Name|PHPParser_Node_Expr $class Class name
- * @property PHPParser_Node_Arg[]                    $args  Arguments
- */
-class PHPParser_Node_Expr_New extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a function call node.
-     *
-     * @param PHPParser_Node_Name|PHPParser_Node_Expr $class      Class name
-     * @param PHPParser_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
-        );
-    }
-}

lib/PHPParser/Node/Expr/NotEqual.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_NotEqual extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a not equal comparison node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/NotIdentical.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_NotIdentical extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a not identical comparison node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Plus.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Plus extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an addition node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/PostDec.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var Variable
- */
-class PHPParser_Node_Expr_PostDec extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a post decrement node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/PostInc.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var Variable
- */
-class PHPParser_Node_Expr_PostInc extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a post increment node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/PreDec.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var Variable
- */
-class PHPParser_Node_Expr_PreDec extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a pre decrement node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/PreInc.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $var Variable
- */
-class PHPParser_Node_Expr_PreInc extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a pre increment node.
-     *
-     * @param PHPParser_Node_Expr $var        Variable
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var' => $var
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Print.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_Print extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs an print() node.
-     *
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/PropertyFetch.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr        $var  Variable holding object
- * @property string|PHPParser_Node_Expr $name Property Name
- */
-class PHPParser_Node_Expr_PropertyFetch extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a function call node.
-     *
-     * @param PHPParser_Node_Expr        $var        Variable holding object
-     * @param string|PHPParser_Node_Expr $name       Property name
-     * @param array                      $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $var, $name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'var'  => $var,
-                'name' => $name
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/ShiftLeft.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_ShiftLeft extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a shift left node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/ShiftRight.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_ShiftRight extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a shift right node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Smaller.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_Smaller extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a smaller than comparison node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/SmallerOrEqual.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $left  The left hand side expression
- * @property PHPParser_Node_Expr $right The right hand side expression
- */
-class PHPParser_Node_Expr_SmallerOrEqual extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a smaller than or equal comparison node.
-     *
-     * @param PHPParser_Node_Expr $left       The left hand side expression
-     * @param PHPParser_Node_Expr $right      The right hand side expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $left, PHPParser_Node_Expr $right, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'left'  => $left,
-                'right' => $right
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/StaticCall.php

@@ -1,28 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Name|PHPParser_Node_Expr $class Class name
- * @property string|PHPParser_Node_Expr              $name  Method name
- * @property PHPParser_Node_Arg[]                    $args  Arguments
- */
-class PHPParser_Node_Expr_StaticCall extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a static method call node.
-     *
-     * @param PHPParser_Node_Name|PHPParser_Node_Expr $class      Class name
-     * @param string|PHPParser_Node_Expr              $name       Method name
-     * @param PHPParser_Node_Arg[]                    $args       Arguments
-     * @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
-        );
-    }
-}

lib/PHPParser/Node/Expr/StaticPropertyFetch.php

@@ -1,25 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Name|PHPParser_Node_Expr $class Class name
- * @property string|PHPParser_Node_Expr              $name  Property name
- */
-class PHPParser_Node_Expr_StaticPropertyFetch extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a static property fetch node.
-     *
-     * @param PHPParser_Node_Name|PHPParser_Node_Expr $class      Class name
-     * @param string|PHPParser_Node_Expr              $name       Property name
-     * @param array                                   $attributes Additional attributes
-     */
-    public function __construct($class, $name, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'class' => $class,
-                'name'  => $name
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/Ternary.php

@@ -1,28 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr      $cond Condition
- * @property null|PHPParser_Node_Expr $if   Expression for true
- * @property PHPParser_Node_Expr      $else Expression for false
- */
-class PHPParser_Node_Expr_Ternary extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a ternary operator node.
-     *
-     * @param PHPParser_Node_Expr      $cond       Condition
-     * @param null|PHPParser_Node_Expr $if         Expression for true
-     * @param PHPParser_Node_Expr      $else       Expression for false
-     * @param array                    $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $cond, $if, PHPParser_Node_Expr $else, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'cond' => $cond,
-                'if'   => $if,
-                'else' => $else
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Expr/UnaryMinus.php

@@ -1,22 +0,0 @@
-<?php
-
-/**
- * @property PHPParser_Node_Expr $expr Expression
- */
-class PHPParser_Node_Expr_UnaryMinus extends PHPParser_Node_Expr
-{
-    /**
-     * Constructs a unary minus node.
-     *
-     * @param PHPParser_Node_Expr $expr       Expression
-     * @param array               $attributes Additional attributes
-     */
-    public function __construct(PHPParser_Node_Expr $expr, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'expr' => $expr
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Param.php

@@ -1,31 +0,0 @@
-<?php
-
-/**
- * @property string                          $name    Name
- * @property null|PHPParser_Node_Expr        $default Default value
- * @property null|string|PHPParser_Node_Name $type    Typehint
- * @property bool                            $byRef   Whether is passed by reference
- */
-class PHPParser_Node_Param extends PHPParser_NodeAbstract
-{
-    /**
-     * Constructs a parameter node.
-     *
-     * @param string                          $name       Name
-     * @param null|PHPParser_Node_Expr        $default    Default value
-     * @param null|string|PHPParser_Node_Name $type       Typehint
-     * @param bool                            $byRef      Whether is passed by reference
-     * @param array                           $attributes Additional attributes
-     */
-    public function __construct($name, $default = null, $type = null, $byRef = false, array $attributes = array()) {
-        parent::__construct(
-            array(
-                'name'    => $name,
-                'default' => $default,
-                'type'    => $type,
-                'byRef'   => $byRef
-            ),
-            $attributes
-        );
-    }
-}

lib/PHPParser/Node/Scalar.php

@@ -1,5 +0,0 @@
-<?php
-
-abstract class PHPParser_Node_Scalar extends PHPParser_Node_Expr
-{
-}

lib/PHPParser/Node/Scalar/ClassConst.php

@@ -1,13 +0,0 @@
-<?php
-
-class PHPParser_Node_Scalar_ClassConst extends PHPParser_Node_Scalar
-{
-    /**
-     * Constructs a __CLASS__ const node
-     *
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(array $attributes = array()) {
-        parent::__construct(array(), $attributes);
-    }
-}

lib/PHPParser/Node/Scalar/DirConst.php

@@ -1,13 +0,0 @@
-<?php
-
-class PHPParser_Node_Scalar_DirConst extends PHPParser_Node_Scalar
-{
-    /**
-     * Constructs a __DIR__ const node
-     *
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(array $attributes = array()) {
-        parent::__construct(array(), $attributes);
-    }
-}

lib/PHPParser/Node/Scalar/FileConst.php

@@ -1,13 +0,0 @@
-<?php
-
-class PHPParser_Node_Scalar_FileConst extends PHPParser_Node_Scalar
-{
-    /**
-     * Constructs a __FILE__ const node
-     *
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(array $attributes = array()) {
-        parent::__construct(array(), $attributes);
-    }
-}

lib/PHPParser/Node/Scalar/FuncConst.php

@@ -1,13 +0,0 @@
-<?php
-
-class PHPParser_Node_Scalar_FuncConst extends PHPParser_Node_Scalar
-{
-    /**
-     * Constructs a __FUNCTION__ const node
-     *
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(array $attributes = array()) {
-        parent::__construct(array(), $attributes);
-    }
-}

lib/PHPParser/Node/Scalar/LineConst.php

@@ -1,13 +0,0 @@
-<?php
-
-class PHPParser_Node_Scalar_LineConst extends PHPParser_Node_Scalar
-{
-    /**
-     * Constructs a __LINE__ const node
-     *
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(array $attributes = array()) {
-        parent::__construct(array(), $attributes);
-    }
-}

lib/PHPParser/Node/Scalar/MethodConst.php

@@ -1,13 +0,0 @@
-<?php
-
-class PHPParser_Node_Scalar_MethodConst extends PHPParser_Node_Scalar
-{
-    /**
-     * Constructs a __METHOD__ const node
-     *
-     * @param array $attributes Additional attributes
-     */
-    public function __construct(array $attributes = array()) {
-        parent::__construct(array(), $attributes);
-    }
-}