update v1.0.3.3

vendor/nikic/php-parser/.travis.yml

@@ -0,0 +1,14 @@
+language: php
+
+php:
+  - 5.3
+  - 5.4
+  - 5.5
+  - 5.6
+  - 7.0
+  - hhvm
+
+matrix:
+  allow_failures:
+    - php: 7.0
+  fast_finish: true

vendor/nikic/php-parser/CHANGELOG.md

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

vendor/nikic/php-parser/LICENSE

@@ -0,0 +1,31 @@
+Copyright (c) 2011 by Nikita Popov.
+
+Some rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * The names of the contributors may not be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/nikic/php-parser/README.md

@@ -0,0 +1,87 @@
+PHP Parser
+==========
+
+This is a PHP 5.2 to PHP 5.6 parser written in PHP. Its purpose is to simplify static code analysis and
+manipulation.
+
+[**Documentation for version 1.x**][doc_1_x] (stable; for running on PHP >= 5.3).
+
+[Documentation for version 0.9.x][doc_0_9] (unsupported; for running on PHP 5.2).
+
+In a Nutshell
+-------------
+
+The parser turns PHP source code into an abstract syntax tree. For example, if you pass the following code into the
+parser:
+
+```php
+<?php
+echo 'Hi', 'World';
+hello\world('foo', 'bar' . 'baz');
+```
+
+You'll get a syntax tree looking roughly like this:
+
+```php
+array(
+    0: Stmt_Echo(
+        exprs: array(
+            0: Scalar_String(
+                value: Hi
+            )
+            1: Scalar_String(
+                value: World
+            )
+        )
+    )
+    1: Expr_FuncCall(
+        name: Name(
+            parts: array(
+                0: hello
+                1: world
+            )
+        )
+        args: array(
+            0: Arg(
+                value: Scalar_String(
+                    value: foo
+                )
+                byRef: false
+            )
+            1: Arg(
+                value: Expr_Concat(
+                    left: Scalar_String(
+                        value: bar
+                    )
+                    right: Scalar_String(
+                        value: baz
+                    )
+                )
+                byRef: false
+            )
+        )
+    )
+)
+```
+
+You can then work with this syntax tree, for example to statically analyze the code (e.g. to find
+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).
+
+Documentation
+-------------
+
+ 1. [Introduction](doc/0_Introduction.markdown)
+ 2. [Installation](doc/1_Installation.markdown)
+ 3. [Usage of basic components](doc/2_Usage_of_basic_components.markdown)
+ 4. [Other node tree representations](doc/3_Other_node_tree_representations.markdown)
+ 5. [Code generation](doc/4_Code_generation.markdown)
+
+Component documentation:
+
+ 1. [Lexer](doc/component/Lexer.markdown)
+
+ [doc_0_9]: https://github.com/nikic/PHP-Parser/tree/0.9/doc
+ [doc_1_x]: https://github.com/nikic/PHP-Parser/tree/1.x/doc

vendor/nikic/php-parser/UPGRADE-1.0.md

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

vendor/nikic/php-parser/bin/php-parse.php

@@ -0,0 +1,161 @@
+#!/usr/bin/env php
+<?php
+
+require __DIR__ . '/../lib/bootstrap.php';
+
+ini_set('xdebug.max_nesting_level', 3000);
+
+// Disable XDebug var_dump() output truncation
+ini_set('xdebug.var_display_max_children', -1);
+ini_set('xdebug.var_display_max_data', -1);
+ini_set('xdebug.var_display_max_depth', -1);
+
+list($operations, $files, $attributes) = parseArgs($argv);
+
+/* Dump nodes by default */
+if (empty($operations)) {
+    $operations[] = 'dump';
+}
+
+if (empty($files)) {
+    showHelp("Must specify at least one file.");
+}
+
+$lexer = new PhpParser\Lexer\Emulative(array('usedAttributes' => array(
+    'startLine', 'endLine', 'startFilePos', 'endFilePos'
+)));
+$parser = new PhpParser\Parser($lexer);
+$dumper = new PhpParser\NodeDumper;
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
+$serializer = new PhpParser\Serializer\XML;
+
+$traverser = new PhpParser\NodeTraverser();
+$traverser->addVisitor(new PhpParser\NodeVisitor\NameResolver);
+
+foreach ($files as $file) {
+    if (strpos($file, '<?php') === 0) {
+        $code = $file;
+        echo "====> Code $code\n";
+    } else {
+        if (!file_exists($file)) {
+            die("File $file does not exist.\n");
+        }
+
+        $code = file_get_contents($file);
+        echo "====> File $file:\n";
+    }
+
+    try {
+        $stmts = $parser->parse($code);
+    } catch (PhpParser\Error $e) {
+        if ($attributes['with-column-info'] && $e->hasColumnInfo()) {
+            $startLine = $e->getStartLine();
+            $endLine = $e->getEndLine();
+            $startColumn = $e->getStartColumn($code);
+            $endColumn   = $e->getEndColumn($code);
+            $message .= $e->getRawMessage() . " from $startLine:$startColumn to $endLine:$endColumn";
+        } else {
+            $message = $e->getMessage();
+        }
+
+        die($message . "\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 ...]
+   or: php php-parse.php [operations] "<?php code"
+Turn PHP source code into an abstract syntax tree.
+
+Operations is a list of the following options (--dump by default):
+
+    -d, --dump              Dump nodes using NodeDumper
+    -p, --pretty-print      Pretty print file using PrettyPrinter\Standard
+        --serialize-xml     Serialize nodes using Serializer\XML
+        --var-dump          var_dump() nodes (for exact structure)
+    -N, --resolve-names     Resolve names using NodeVisitor\NameResolver
+    -c, --with-column-info  Show column-numbers for errors (if available)
+
+Example:
+    php php-parse.php -d -p -N -d file.php
+
+    Dumps nodes, pretty prints them, then resolves names and dumps them again.
+
+
+OUTPUT
+    );
+}
+
+function parseArgs($args) {
+    $operations = array();
+    $files = array();
+    $attributes = array(
+        'with-column-info' => false,
+    );
+
+    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 '--with-column-info':
+            case '-c';
+                $attributes['with-column-info'] = true;
+                break;
+            case '--':
+                $parseOptions = false;
+                break;
+            default:
+                if ($arg[0] === '-') {
+                    showHelp("Invalid operation $arg.");
+                } else {
+                    $files[] = $arg;
+                }
+        }
+    }
+
+    return array($operations, $files, $attributes);
+}

vendor/nikic/php-parser/composer.json

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

vendor/nikic/php-parser/doc/0_Introduction.markdown

@@ -0,0 +1,81 @@
+Introduction
+============
+
+This project is a PHP 5.2 to PHP 5.6 parser **written in PHP itself**.
+
+What is this for?
+-----------------
+
+A parser is useful for [static analysis][0], manipulation of code and basically any other
+application dealing with code programmatically. A parser constructs an [Abstract Syntax Tree][1]
+(AST) of the code and thus allows dealing with it in an abstract and robust way.
+
+There are other ways of processing source code. One that PHP supports natively is using the
+token stream generated by [`token_get_all`][2]. The token stream is much more low level than
+the AST and thus has different applications: It allows to also analyze the exact formatting of
+a file. On the other hand the token stream is much harder to deal with for more complex analysis.
+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
+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 incidentally PHP developers, not C developers.
+
+What can it parse?
+------------------
+
+The parser uses a PHP 5.6 compliant grammar, which is backwards compatible with all PHP version from PHP 5.2
+upwards (and maybe older).
+
+As the parser is based on the tokens returned by `token_get_all` (which is only able to lex the PHP
+version it runs on), additionally a wrapper for emulating new tokens from 5.3, 5.4, 5.5 and 5.6 is provided.
+This allows to parse PHP 5.6 source code running on PHP 5.3, for example. This emulation is very hacky and not
+perfect, but it should work well on any sane code.
+
+What output does it produce?
+----------------------------
+
+The parser produces an [Abstract Syntax Tree][1] (AST) also known as a node tree. How this looks like
+can best be seen in an example. The program `<?php echo 'Hi', 'World';` will give you a node tree
+roughly looking like this:
+
+```
+array(
+    0: Stmt_Echo(
+        exprs: array(
+            0: Scalar_String(
+                value: Hi
+            )
+            1: Scalar_String(
+                value: World
+            )
+        )
+    )
+)
+```
+
+This matches the structure of the code: An echo statement, which takes two strings as expressions,
+with the values `Hi` and `World!`.
+
+You can also see that the AST does not contain any whitespace information (but most comments are saved).
+So using it for formatting analysis is not possible.
+
+What else can it do?
+--------------------
+
+Apart from the parser itself this package also bundles support for some other, related features:
+
+ * Support for pretty printing, which is the act of converting an AST into PHP code. Please note
+   that "pretty printing" does not imply that the output is especially pretty. It's just how it's
+   called ;)
+ * Support for serializing and unserializing the node tree to XML
+ * Support for dumping the node tree in a human readable form (see the section above for an
+   example of how the output looks like)
+ * Infrastructure for traversing and changing the AST (node traverser and node visitors)
+ * A node visitor for resolving namespaced names
+
+ [0]: http://en.wikipedia.org/wiki/Static_program_analysis
+ [1]: http://en.wikipedia.org/wiki/Abstract_syntax_tree
+ [2]: http://php.net/token_get_all

vendor/nikic/php-parser/doc/1_Installation.markdown

@@ -0,0 +1,31 @@
+Installation
+============
+
+There are multiple ways to include the PHP parser into your project:
+
+Installing via Composer
+-----------------------
+
+Run the following command inside your project:
+
+    php composer.phar require nikic/php-parser
+
+If you haven't installed [Composer][1] yet, you can do so using:
+
+    curl -s http://getcomposer.org/installer | php
+
+Installing as a Git Submodule
+-----------------------------
+
+Run the following command to install the parser into the `vendor/PHP-Parser` folder:
+
+    git submodule add git://github.com/nikic/PHP-Parser.git vendor/PHP-Parser
+
+Installing from the Zip- or Tarball
+-----------------------------------
+
+Download the latest version from [the download page][2], unpack it and move the files somewhere into your project.
+
+
+ [1]: https://getcomposer.org/
+ [2]: https://github.com/nikic/PHP-Parser/tags

vendor/nikic/php-parser/doc/2_Usage_of_basic_components.markdown

@@ -0,0 +1,422 @@
+Usage of basic components
+=========================
+
+This document explains how to use the parser, the pretty printer and the node traverser.
+
+Bootstrapping
+-------------
+
+The library needs to register a class autoloader. You can either use the `vendor/autoload.php` file generated by
+Composer or by including the bundled `lib/bootstrap.php` file:
+
+```php
+<?php
+require 'path/to/PHP-Parser/lib/bootstrap.php';
+// Or, if you're using Composer:
+require 'path/to/vendor/autoload.php';
+```
+
+Additionally you may want to set the `xdebug.max_nesting_level` ini option to a higher value:
+
+```php
+<?php
+ini_set('xdebug.max_nesting_level', 3000);
+```
+
+This ensures that there will be no errors when traversing highly nested node trees.
+
+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:
+
+```php
+<?php
+
+$parser = new PhpParser\Parser(new PhpParser\Lexer);
+// or
+$parser = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
+```
+
+Use of the emulative lexer is required if you want to parse PHP code from newer versions than the one
+you're running on. For example it will allow you to parse PHP 5.6 code while running on PHP 5.3.
+
+Subsequently you can pass PHP code (including the opening `<?php` tag) to the `parse` method in order to
+create a syntax tree. If a syntax error is encountered, an `PhpParser\Error` exception will be thrown:
+
+```php
+<?php
+$code = '<?php // some code';
+
+$parser = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
+
+try {
+    $stmts = $parser->parse($code);
+    // $stmts is an array of statement nodes
+} catch (PhpParser\Error $e) {
+    echo 'Parse Error: ', $e->getMessage();
+}
+```
+
+A parser instance can be reused to parse multiple files.
+
+Node tree
+---------
+
+If you use the above code with `$code = "<?php echo 'Hi ', hi\\getTarget();"` the parser will
+generate a node tree looking like this:
+
+```
+array(
+    0: Stmt_Echo(
+        exprs: array(
+            0: Scalar_String(
+                value: Hi
+            )
+            1: Expr_FuncCall(
+                name: Name(
+                    parts: array(
+                        0: hi
+                        1: getTarget
+                    )
+                )
+                args: array(
+                )
+            )
+        )
+    )
+)
+```
+
+Thus `$stmts` will contain an array with only one node, with this node being an instance of
+`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
+   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
+   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\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
+in the above example you would write `$stmts[0]->exprs`. If you wanted to access the name of the function
+call, you would write `$stmts[0]->exprs[1]->name`.
+
+All nodes also define a `getType()` method that returns the node type. The type is the class name
+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.
+
+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()`.
+
+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\Standard`.
+
+```php
+<?php
+$code = "<?php echo 'Hi ', hi\\getTarget();";
+
+$parser = new PhpParser\Parser(new PhpParser\Lexer);
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
+
+try {
+    // parse
+    $stmts = $parser->parse($code);
+
+    // change
+    $stmts[0]         // the echo statement
+          ->exprs     // sub expressions
+          [0]         // the first of them (the string node)
+          ->value     // it's value, i.e. 'Hi '
+          = 'Hello '; // change to 'Hello '
+
+    // pretty print
+    $code = $prettyPrinter->prettyPrint($stmts);
+
+    echo $code;
+} catch (PhpParser\Error $e) {
+    echo 'Parse Error: ', $e->getMessage();
+}
+```
+
+The above code will output:
+
+    <?php echo 'Hello ', hi\getTarget();
+
+As you can see the source code was first parsed using `PhpParser\Parser->parse()`, then changed and then
+again converted to code using `PhpParser\PrettyPrinter\Standard->prettyPrint()`.
+
+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 statement more gracefully.
+
+Node traversation
+-----------------
+
+The above pretty printing example used the fact that the source code was known and thus it was easy to
+write code that accesses a certain part of a node tree and changes it. Normally this is not the case.
+Usually you want to change / analyze code in a generic way, where you don't know how the node tree is
+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:
+
+```php
+<?php
+
+$parser        = new PhpParser\Parser(new PhpParser\Lexer\Emulative);
+$traverser     = new PhpParser\NodeTraverser;
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
+
+// add your visitor
+$traverser->addVisitor(new MyNodeVisitor);
+
+try {
+    $code = file_get_contents($fileName);
+
+    // parse
+    $stmts = $parser->parse($code);
+
+    // traverse
+    $stmts = $traverser->traverse($stmts);
+
+    // pretty print
+    $code = $prettyPrinter->prettyPrintFile($stmts);
+
+    echo $code;
+} catch (PhpParser\Error $e) {
+    echo 'Parse Error: ', $e->getMessage();
+}
+```
+
+The corresponding node visitor might look like this:
+
+```php
+<?php
+use PhpParser\Node;
+
+class MyNodeVisitor extends PhpParser\NodeVisitorAbstract
+{
+    public function leaveNode(Node $node) {
+        if ($node instanceof Node\Scalar\String_) {
+            $node->value = 'foo';
+        }
+    }
+}
+```
+
+The above node visitor would change all string literals in the program to `'foo'`.
+
+All visitors must implement the `PhpParser\NodeVisitor` interface, which defines the following four
+methods:
+
+    public function beforeTraverse(array $nodes);
+    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
+traverser was called with. This method can be used for resetting values before traversation or
+preparing the tree for traversal.
+
+The `afterTraverse()` method is similar to the `beforeTraverse()` method, with the only difference that
+it is called once after the traversal.
+
+The `enterNode()` and `leaveNode()` methods are called on every node, the former when it is entered,
+i.e. before its subnodes are traversed, the latter when it is left.
+
+All four methods can either return the changed node or not return at all (i.e. `null`) in which
+case the current node is not changed.
+
+The `enterNode()` method can additionally return the value `NodeTraverser::DONT_TRAVERSE_CHILDREN`,
+which instructs the traverser to skip all children of the current node.
+
+The `leaveNode()` method can additionally return the value `NodeTraverser::REMOVE_NODE`, in which
+case the current node will be removed from the parent array. Furthermove it is possible to return
+an array of nodes, which will be merged into the parent array at the offset of the current node.
+I.e. if in `array(A, B, C)` the node `B` should be replaced with `array(X, Y, Z)` the result will
+be `array(A, X, Y, Z, C)`.
+
+Instead of manually implementing the `NodeVisitor` interface you can also extend the `NodeVisitorAbstract`
+class, which will define empty default implementations for all the above methods.
+
+The NameResolver node 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:
+
+    use A as B;
+    new B\C();
+
+In order to know that `B\C` really is `A\C` you would need to track aliases and namespaces yourself.
+The `NameResolver` takes care of that and resolves names as far as possible.
+
+After running it most names will be fully qualified. The only names that will stay unqualified are
+unqualified function and constant names. These are resolved at runtime and thus the visitor can't
+know which function they are referring to. In most cases this is a non-issue as the global functions
+are meant.
+
+Also the `NameResolver` adds a `namespacedName` subnode to class, function and constant declarations
+that contains the namespaced name instead of only the shortname that is available via `name`.
+
+Example: Converting namespaced code to pseudo namespaces
+--------------------------------------------------------
+
+A small example to understand the concept: We want to convert namespaced code to pseudo namespaces
+so it works on 5.2, i.e. names like `A\\B` should be converted to `A_B`. Note that such conversions
+are fairly complicated if you take PHP's dynamic features into account, so our conversion will
+assume that no dynamic features are used.
+
+We start off with the following base code:
+
+```php
+<?php
+$inDir  = '/some/path';
+$outDir = '/some/other/path';
+
+$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
+
+// iterate over all .php files in the directory
+$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($inDir));
+$files = new RegexIterator($files, '/\.php$/');
+
+foreach ($files as $file) {
+    try {
+        // read the file that should be converted
+        $code = file_get_contents($file);
+
+        // parse
+        $stmts = $parser->parse($code);
+
+        // traverse
+        $stmts = $traverser->traverse($stmts);
+
+        // pretty print
+        $code = $prettyPrinter->prettyPrintFile($stmts);
+
+        // write the converted file to the target directory
+        file_put_contents(
+            substr_replace($file->getPathname(), $outDir, 0, strlen($inDir)),
+            $code
+        );
+    } catch (PhpParser\Error $e) {
+        echo 'Parse Error: ', $e->getMessage();
+    }
+}
+```
+
+Now lets start with the main code, the `NodeVisitor\NamespaceConverter`. One thing it needs to do
+is convert `A\\B` style names to `A_B` style ones.
+
+```php
+<?php
+use PhpParser\Node;
+class NodeVisitor_NamespaceConverter extends PhpParser\NodeVisitorAbstract
+{
+    public function leaveNode(Node $node) {
+        if ($node instanceof Node\Name) {
+            return new Node\Name($node->toString('_'));
+        }
+    }
+}
+```
+
+The above code profits from the fact that the `NameResolver` already resolved all names as far as
+possible, so we don't need to do that. We only need to create a string with the name parts separated
+by underscores instead of backslashes. This is what `$node->toString('_')` does. (If you want to
+create a name with backslashes either write `$node->toString()` or `(string) $node`.) Then we create
+a new name from the string and return it. Returning a new node replaces the old node.
+
+Another thing we need to do is change the class/function/const declarations. Currently they contain
+only the shortname (i.e. the last part of the name), but they need to contain the complete name inclduing
+the namespace prefix:
+
+```php
+<?php
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+class NodeVisitor_NamespaceConverter extends PhpParser\NodeVisitorAbstract
+{
+    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 Stmt\Const_) {
+            foreach ($node->consts as $const) {
+                $const->name = $const->namespacedName->toString('_');
+            }
+        }
+    }
+}
+```
+
+There is not much more to it than converting the namespaced name to string with `_` as separator.
+
+The last thing we need to do is remove the `namespace` and `use` statements:
+
+```php
+<?php
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+class NodeVisitor_NamespaceConverter extends PhpParser\NodeVisitorAbstract
+{
+    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 Stmt\Const_) {
+            foreach ($node->consts as $const) {
+                $const->name = $const->namespacedName->toString('_');
+            }
+        } elseif ($node instanceof Stmt\Namespace_) {
+            // returning an array merges is into the parent array
+            return $node->stmts;
+        } elseif ($node instanceof Stmt\Use_) {
+            // returning false removed the node altogether
+            return false;
+        }
+    }
+}
+```
+
+That's all.

vendor/nikic/php-parser/doc/3_Other_node_tree_representations.markdown

@@ -0,0 +1,203 @@
+Other node tree representations
+===============================
+
+It is possible to convert the AST into several textual representations, which serve different uses.
+
+Simple serialization
+--------------------
+
+It is possible to serialize the node tree using `serialize()` and also unserialize it using
+`unserialize()`. The output is not human readable and not easily processable from anything
+but PHP, but it is compact and generates fast. The main application thus is in caching.
+
+Human readable dumping
+----------------------
+
+Furthermore it is possible to dump nodes into a human readable format using the `dump` method of
+`PhpParser\NodeDumper`. This can be used for debugging.
+
+```php
+<?php
+$code = <<<'CODE'
+<?php
+
+function printLine($msg) {
+    echo $msg, "\n";
+}
+
+printLine('Hello World!!!');
+CODE;
+
+$parser = new PhpParser\Parser(new PhpParser\Lexer);
+$nodeDumper = new PhpParser\NodeDumper;
+
+try {
+    $stmts = $parser->parse($code);
+
+    echo $nodeDumper->dump($stmts), "\n";
+} catch (PhpParser\Error $e) {
+    echo 'Parse Error: ', $e->getMessage();
+}
+```
+
+The above script will have an output looking roughly like this:
+
+```
+array(
+    0: Stmt_Function(
+        byRef: false
+        params: array(
+            0: Param(
+                name: msg
+                default: null
+                type: null
+                byRef: false
+            )
+        )
+        stmts: array(
+            0: Stmt_Echo(
+                exprs: array(
+                    0: Expr_Variable(
+                        name: msg
+                    )
+                    1: Scalar_String(
+                        value:
+
+                    )
+                )
+            )
+        )
+        name: printLine
+    )
+    1: Expr_FuncCall(
+        name: Name(
+            parts: array(
+                0: printLine
+            )
+        )
+        args: array(
+            0: Arg(
+                value: Scalar_String(
+                    value: Hello World!!!
+                )
+                byRef: false
+            )
+        )
+    )
+)
+```
+
+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
+interfacing with other languages and applications or for doing transformation using XSLT.
+
+```php
+<?php
+$code = <<<'CODE'
+<?php
+
+function printLine($msg) {
+    echo $msg, "\n";
+}
+
+printLine('Hello World!!!');
+CODE;
+
+$parser = new PhpParser\Parser(new PhpParser\Lexer);
+$serializer = new PhpParser\Serializer\XML;
+
+try {
+    $stmts = $parser->parse($code);
+
+    echo $serializer->serialize($stmts);
+} catch (PhpParser\Error $e) {
+    echo 'Parse Error: ', $e->getMessage();
+}
+```
+
+Produces:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<AST xmlns:node="http://nikic.github.com/PHPParser/XML/node" xmlns:subNode="http://nikic.github.com/PHPParser/XML/subNode" xmlns:scalar="http://nikic.github.com/PHPParser/XML/scalar">
+ <scalar:array>
+  <node:Stmt_Function line="2">
+   <subNode:byRef>
+    <scalar:false/>
+   </subNode:byRef>
+   <subNode:params>
+    <scalar:array>
+     <node:Param line="2">
+      <subNode:name>
+       <scalar:string>msg</scalar:string>
+      </subNode:name>
+      <subNode:default>
+       <scalar:null/>
+      </subNode:default>
+      <subNode:type>
+       <scalar:null/>
+      </subNode:type>
+      <subNode:byRef>
+       <scalar:false/>
+      </subNode:byRef>
+     </node:Param>
+    </scalar:array>
+   </subNode:params>
+   <subNode:stmts>
+    <scalar:array>
+     <node:Stmt_Echo line="3">
+      <subNode:exprs>
+       <scalar:array>
+        <node:Expr_Variable line="3">
+         <subNode:name>
+          <scalar:string>msg</scalar:string>
+         </subNode:name>
+        </node:Expr_Variable>
+        <node:Scalar_String line="3">
+         <subNode:value>
+          <scalar:string>
+</scalar:string>
+         </subNode:value>
+        </node:Scalar_String>
+       </scalar:array>
+      </subNode:exprs>
+     </node:Stmt_Echo>
+    </scalar:array>
+   </subNode:stmts>
+   <subNode:name>
+    <scalar:string>printLine</scalar:string>
+   </subNode:name>
+  </node:Stmt_Function>
+  <node:Expr_FuncCall line="6">
+   <subNode:name>
+    <node:Name line="6">
+     <subNode:parts>
+      <scalar:array>
+       <scalar:string>printLine</scalar:string>
+      </scalar:array>
+     </subNode:parts>
+    </node:Name>
+   </subNode:name>
+   <subNode:args>
+    <scalar:array>
+     <node:Arg line="6">
+      <subNode:value>
+       <node:Scalar_String line="6">
+        <subNode:value>
+         <scalar:string>Hello World!!!</scalar:string>
+        </subNode:value>
+       </node:Scalar_String>
+      </subNode:value>
+      <subNode:byRef>
+       <scalar:false/>
+      </subNode:byRef>
+     </node:Arg>
+    </scalar:array>
+   </subNode:args>
+  </node:Expr_FuncCall>
+ </scalar:array>
+</AST>
+```

vendor/nikic/php-parser/doc/4_Code_generation.markdown

@@ -0,0 +1,80 @@
+Code generation
+===============
+
+It is also possible to generate code using the parser, by first creating an Abstract Syntax Tree and then using the
+pretty printer to convert it to PHP code. To simplify code generation, the project comes with builders which allow
+creating node trees using a fluid interface, instead of instantiating all nodes manually. Builders are available for
+the following syntactic elements:
+
+ * namespaces and use statements
+ * classes, interfaces and traits
+ * methods, functions and parameters
+ * properties
+
+Here is an example:
+
+```php
+<?php
+$factory = new PhpParser\BuilderFactory;
+$node = $factory->namespace('Name\Space')
+    ->addStmt($factory->use('Some\Other\Thingy')->as('SomeOtherClass'))
+    ->addStmt($factory->class('SomeClass')
+        ->extend('SomeOtherClass')
+        ->implement('A\Few', '\Interfaces')
+        ->makeAbstract() // ->makeFinal()
+
+        ->addStmt($factory->method('someMethod')
+            ->makePublic()
+            ->makeAbstract() // ->makeFinal()
+            ->addParam($factory->param('someParam')->setTypeHint('SomeClass'))
+            ->setDocComment('/**
+                              * This method does something.
+                              *
+                              * @param SomeClass And takes a parameter
+                              */')
+        )
+
+        ->addStmt($factory->method('anotherMethod')
+            ->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')))
+        )
+
+        // properties will be correctly reordered above the methods
+        ->addStmt($factory->property('someProperty')->makeProtected())
+        ->addStmt($factory->property('anotherProperty')->makePrivate()->setDefault(array(1, 2, 3)))
+    )
+
+    ->getNode()
+;
+
+$stmts = array($node);
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard();
+echo $prettyPrinter->prettyPrintFile($stmts);
+```
+
+This will produce the following output with the standard pretty printer:
+
+```php
+<?php
+
+namespace Name\Space;
+
+use Some\Other\Thingy as SomeClass;
+abstract class SomeClass extends SomeOtherClass implements A\Few, \Interfaces
+{
+    protected $someProperty;
+    private $anotherProperty = array(1, 2, 3);
+    /**
+     * This method does something.
+     *
+     * @param SomeClass And takes a parameter
+     */
+    public abstract function someMethod(SomeClass $someParam);
+    protected function anotherMethod($someParam = 'test')
+    {
+        print $someParam;
+    }
+}
+```

vendor/nikic/php-parser/doc/component/Error.markdown

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

vendor/nikic/php-parser/doc/component/Lexer.markdown

@@ -0,0 +1,146 @@
+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
+newer PHP versions and thus allows parsing of new code on older versions.
+
+This documentation discusses options available for the default lexers and explains how lexers can be extended.
+
+Lexer options
+-------------
+
+The two default lexers accept an `$options` array in the constructor. Currently only the `'usedAttributes'` option is
+supported, which allows you to specify which attributes will be added to the AST nodes. The attributes can then be
+accessed using `$node->getAttribute()`, `$node->setAttribute()`, `$node->hasAttribute()` and `$node->getAttributes()`
+methods. A sample options array:
+
+```php
+$lexer = new PhpParser\Lexer(array(
+    'usedAttributes' => array(
+        'comments', 'startLine', 'endLine'
+    )
+));
+```
+
+The attributes used in this example match the default behavior of the lexer. The following attributes are supported:
+
+ * `comments`: Array of `PhpParser\Comment` or `PhpParser\Comment\Doc` instances, representing all comments that occurred
+   between the previous non-discarded token and the current one. Use of this attribute is required for the
+   `$node->getDocComment()` method to work. The attribute is also needed if you wish the pretty printer to retain
+   comments present in the original code.
+ * `startLine`: Line in which the node starts. This attribute is required for the `$node->getLine()` to work. It is also
+   required if syntax errors should contain line number information.
+ * `endLine`: Line in which the node ends.
+ * `startTokenPos`: Offset into the token array of the first token in the node.
+ * `endTokenPos`: Offset into the token array of the last token in the node.
+ * `startFilePos`: Offset into the code string of the first character that is part of the node.
+ * `endFilePos`: Offset into the code string of the last character that is part of the node.
+
+### Using token positions
+
+The token offset information is useful if you wish to examine the exact formatting used for a node. For example the AST
+does not distinguish whether a property was declared using `public` or using `var`, but you can retrieve this
+information based on the token position:
+
+```php
+function isDeclaredUsingVar(array $tokens, PhpParser\Node\Stmt\Property $prop) {
+    $i = $prop->getAttribute('startTokenPos');
+    return $tokens[$i][0] === T_VAR;
+}
+```
+
+In order to make use of this function, you will have to provide the tokens from the lexer to your node visitor using
+code similar to the following:
+
+```php
+class MyNodeVisitor extends PhpParser\NodeVisitorAbstract {
+    private $tokens;
+    public function setTokens(array $tokens) {
+        $this->tokens = $tokens;
+    }
+
+    public function leaveNode(PhpParser\Node $node) {
+        if ($node instanceof PhpParser\Node\Stmt\Property) {
+            var_dump(isDeclaredUsingVar($this->tokens, $node));
+        }
+    }
+}
+
+$lexer = new PhpParser\Lexer(array(
+    'usedAttributes' => array(
+        'comments', 'startLine', 'endLine', 'startTokenPos', 'endTokenPos'
+    )
+));
+$parser = new PhpParser\Parser($lexer);
+
+$visitor = new MyNodeVisitor();
+$traverser = new PhpParser\NodeTraverser();
+$traverser->addVisitor($visitor);
+
+try {
+    $stmts = $parser->parse($code);
+    $visitor->setTokens($lexer->getTokens());
+    $stmts = $traverser->traverse($stmts);
+} catch (PhpParser\Error $e) {
+    echo 'Parse Error: ', $e->getMessage();
+}
+```
+
+The same approach can also be used to perform specific modifications in the code, without changing the formatting in
+other places (which is the case when using the pretty printer).
+
+Lexer extension
+---------------
+
+A lexer has to define the following public interface:
+
+    void startLexing(string $code);
+    array getTokens();
+    string handleHaltCompiler();
+    int getNextToken(string &$value = null, array &$startAttributes = null, array &$endAttributes = null);
+
+The `startLexing()` method is invoked with the source code that is to be lexed (including the opening tag) whenever the
+`parse()` method of the parser is called. It can be used to reset state or preprocess the source code or tokens.
+
+The `getTokens()` method returns the current token array, in the usual `token_get_all()` format. This method is not
+used by the parser (which uses `getNextToken()`), but is useful in combination with the token position attributes.
+
+The `handleHaltCompiler()` method is called whenever a `T_HALT_COMPILER` token is encountered. It has to return the
+remaining string after the construct (not including `();`).
+
+The `getNextToken()` method returns the ID of the next token (as defined by the `Parser::T_*` constants). If no more
+tokens are available it must return `0`, which is the ID of the `EOF` token. Furthermore the string content of the
+token should be written into the by-reference `$value` parameter (which will then be available as `$n` in the parser).
+
+### Attribute handling
+
+The other two by-ref variables `$startAttributes` and `$endAttributes` define which attributes will eventually be
+assigned to the generated nodes: The parser will take the `$startAttributes` from the first token which is part of the
+node and the `$endAttributes` from the last token that is part of the node.
+
+E.g. if the tokens `T_FUNCTION T_STRING ... '{' ... '}'` constitute a node, then the `$startAttributes` from the
+`T_FUNCTION` token will be taken and the `$endAttributes` from the `'}'` token.
+
+An application of custom attributes is storing the original formatting of literals: The parser does not retain
+information about the formatting of integers (like decimal vs. hexadecimal) or strings (like used quote type or used
+escape sequences). This can be remedied by storing the original value in an attribute:
+
+```php
+class KeepOriginalValueLexer extends PHPParser\Lexer // or PHPParser\Lexer\Emulative
+{
+    public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
+        $tokenId = parent::getNextToken($value, $startAttributes, $endAttributes);
+
+        if ($tokenId == PHPParser\Parser::T_CONSTANT_ENCAPSED_STRING // non-interpolated string
+            || $tokenId == PHPParser\Parser::T_LNUMBER               // integer
+            || $tokenId == PHPParser\Parser::T_DNUMBER               // floating point number
+        ) {
+            // could also use $startAttributes, doesn't really matter here
+            $endAttributes['originalValue'] = $value;
+        }
+
+        return $tokenId;
+    }
+}
+```

vendor/nikic/php-parser/grammar/README.md

@@ -0,0 +1,28 @@
+What do all those files mean?
+=============================
+
+ * `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`
+ * `kmyacc.php.parser`:         A `kmyacc` parser prototype file for PHP
+
+.phpy pseudo language
+=====================
+
+The `.phpy` file is a normal grammer in `kmyacc` (`yacc`) style, with some transformations
+applied to it:
+
+ * Nodes are created using the syntax `Name[..., ...]`. This is transformed into
+   `new Name(..., ..., attributes())`
+ * Some function-like constructs are resolved (see `rebuildParser.php` for a list)
+ * Associative arrays are written as `[key: value, ...]`, which is transformed to
+   `array('key' => value, ...)`
+
+Building the parser
+===================
+
+In order to rebuild the parser, you need [moriyoshi's fork of kmyacc](https://github.com/moriyoshi/kmyacc-forked).
+After you compiled/installed it, run the `rebuildParser.php` script.
+
+By default only the `Parser.php` is built. If you want to additionally emit debug symbols and create `y.output`, run the
+script with `--debug`. If you want to retain the preprocessed grammar pass `--keep-tmp-grammar`.

vendor/nikic/php-parser/grammar/analyze.php

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

vendor/nikic/php-parser/grammar/kmyacc.php.parser

@@ -0,0 +1,100 @@
+<?php
+$meta #
+#semval($) $this->semValue
+#semval($,%t) $this->semValue
+#semval(%n) $this->stackPos-(%l-%n)
+#semval(%n,%t) $this->stackPos-(%l-%n)
+
+namespace PhpParser;
+#include;
+
+/* This is an automatically GENERATED file, which should not be manually edited.
+ * Instead edit one of the following:
+ *  * the grammar file grammar/zend_language_parser.phpy
+ *  * the skeleton file grammar/kymacc.php.parser
+ *  * the preprocessing script grammar/rebuildParser.php
+ */
+class Parser extends ParserAbstract
+{
+    protected $tokenToSymbolMapSize = #(YYMAXLEX);
+    protected $actionTableSize = #(YYLAST);
+    protected $gotoTableSize = #(YYGLAST);
+
+    protected $invalidSymbol = #(YYBADCH);
+    protected $errorSymbol = #(YYINTERRTOK);
+    protected $defaultAction = #(YYDEFAULT);
+    protected $unexpectedTokenRule = #(YYUNEXPECTED);
+
+    protected $YY2TBLSTATE  = #(YY2TBLSTATE);
+    protected $YYNLSTATES   = #(YYNLSTATES);
+
+#tokenval
+    const %s = %n;
+#endtokenval
+
+    protected $symbolToName = array(
+        #listvar terminals
+    );
+
+    protected $tokenToSymbol = array(
+        #listvar yytranslate
+    );
+
+    protected $action = array(
+        #listvar yyaction
+    );
+
+    protected $actionCheck = array(
+        #listvar yycheck
+    );
+
+    protected $actionBase = array(
+        #listvar yybase
+    );
+
+    protected $actionDefault = array(
+        #listvar yydefault
+    );
+
+    protected $goto = array(
+        #listvar yygoto
+    );
+
+    protected $gotoCheck = array(
+        #listvar yygcheck
+    );
+
+    protected $gotoBase = array(
+        #listvar yygbase
+    );
+
+    protected $gotoDefault = array(
+        #listvar yygdefault
+    );
+
+    protected $ruleToNonTerminal = array(
+        #listvar yylhs
+    );
+
+    protected $ruleToLength = array(
+        #listvar yylen
+    );
+#if -t
+
+    protected $productions = array(
+        #production-strings;
+    );
+#endif
+#reduce
+
+    protected function reduceRule%n() {
+        %b
+    }
+#noact
+
+    protected function reduceRule%n() {
+        $this->semValue = $this->semStack[$this->stackPos];
+    }
+#endreduce
+}
+#tailcode;

vendor/nikic/php-parser/grammar/rebuildParser.php

@@ -0,0 +1,228 @@
+<?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 ///
+///////////////////////////////
+
+const LIB = '(?(DEFINE)
+    (?<singleQuotedString>\'[^\\\\\']*+(?:\\\\.[^\\\\\']*+)*+\')
+    (?<doubleQuotedString>"[^\\\\"]*+(?:\\\\.[^\\\\"]*+)*+")
+    (?<string>(?&singleQuotedString)|(?&doubleQuotedString))
+    (?<comment>/\*[^*]*+(?:\*(?!/)[^*]*+)*+\*/)
+    (?<code>\{[^\'"/{}]*+(?:(?:(?&string)|(?&comment)|(?&code)|/)[^\'"/{}]*+)*+})
+)';
+
+const PARAMS = '\[(?<params>[^[\]]*+(?:\[(?&params)\][^[\]]*+)*+)\]';
+const ARGS   = '\((?<args>[^()]*+(?:\((?&args)\)[^()]*+)*+)\)';
+
+///////////////////
+/// Main script ///
+///////////////////
+
+echo 'Building temporary preproprocessed grammar file.', "\n";
+
+$grammarCode = file_get_contents($grammarFile);
+
+$grammarCode = resolveNodes($grammarCode);
+$grammarCode = resolveMacros($grammarCode);
+$grammarCode = resolveArrays($grammarCode);
+$grammarCode = resolveStackAccess($grammarCode);
+
+file_put_contents($tmpGrammarFile, $grammarCode);
+
+$additionalArgs = $optionDebug ? '-t -v' : '';
+
+echo "Building parser.\n";
+$output = trim(shell_exec("$kmyacc $additionalArgs -l -m $skeletonFile $tmpGrammarFile 2>&1"));
+echo "Output: \"$output\"\n";
+
+$resultCode = file_get_contents($tmpResultFile);
+$resultCode = removeTrailingWhitespace($resultCode);
+
+ensureDirExists(dirname($parserResultFile));
+file_put_contents($parserResultFile, $resultCode);
+unlink($tmpResultFile);
+
+if (!$optionKeepTmpGrammar) {
+    unlink($tmpGrammarFile);
+}
+
+///////////////////////////////
+/// Preprocessing functions ///
+///////////////////////////////
+
+function resolveNodes($code) {
+    return preg_replace_callback(
+        '~(?<name>[A-Z][a-zA-Z_\\\\]++)\s*' . PARAMS . '~',
+        function($matches) {
+            // recurse
+            $matches['params'] = resolveNodes($matches['params']);
+
+            $params = magicSplit(
+                '(?:' . PARAMS . '|' . ARGS . ')(*SKIP)(*FAIL)|,',
+                $matches['params']
+            );
+
+            $paramCode = '';
+            foreach ($params as $param) {
+                $paramCode .= $param . ', ';
+            }
+
+            return 'new ' . $matches['name'] . '(' . $paramCode . 'attributes())';
+        },
+        $code
+    );
+}
+
+function resolveMacros($code) {
+    return preg_replace_callback(
+        '~\b(?<!::|->)(?!array\()(?<name>[a-z][A-Za-z]++)' . ARGS . '~',
+        function($matches) {
+            // recurse
+            $matches['args'] = resolveMacros($matches['args']);
+
+            $name = $matches['name'];
+            $args = magicSplit(
+                '(?:' . PARAMS . '|' . ARGS . ')(*SKIP)(*FAIL)|,',
+                $matches['args']
+            );
+
+            if ('attributes' == $name) {
+                assertArgs(0, $args, $name);
+                return '$this->startAttributeStack[#1] + $this->endAttributes';
+            }
+
+            if ('init' == $name) {
+                return '$$ = array(' . implode(', ', $args) . ')';
+            }
+
+            if ('push' == $name) {
+                assertArgs(2, $args, $name);
+
+                return $args[0] . '[] = ' . $args[1] . '; $$ = ' . $args[0];
+            }
+
+            if ('pushNormalizing' == $name) {
+                assertArgs(2, $args, $name);
+
+                return 'if (is_array(' . $args[1] . ')) { $$ = array_merge(' . $args[0] . ', ' . $args[1] . '); } else { ' . $args[0] . '[] = ' . $args[1] . '; $$ = ' . $args[0] . '; }';
+            }
+
+            if ('toArray' == $name) {
+                assertArgs(1, $args, $name);
+
+                return 'is_array(' . $args[0] . ') ? ' . $args[0] . ' : array(' . $args[0] . ')';
+            }
+
+            if ('parseVar' == $name) {
+                assertArgs(1, $args, $name);
+
+                return 'substr(' . $args[0] . ', 1)';
+            }
+
+            if ('parseEncapsed' == $name) {
+                assertArgs(2, $args, $name);
+
+                return 'foreach (' . $args[0] . ' as &$s) { if (is_string($s)) { $s = Node\Scalar\String_::parseEscapeSequences($s, ' . $args[1] . '); } }';
+            }
+
+            if ('parseEncapsedDoc' == $name) {
+                assertArgs(1, $args, $name);
+
+                return 'foreach (' . $args[0] . ' as &$s) { if (is_string($s)) { $s = Node\Scalar\String_::parseEscapeSequences($s, null); } } $s = preg_replace(\'~(\r\n|\n|\r)\z~\', \'\', $s); if (\'\' === $s) array_pop(' . $args[0] . ');';
+            }
+
+            return $matches[0];
+        },
+        $code
+    );
+}
+
+function assertArgs($num, $args, $name) {
+    if ($num != count($args)) {
+        die('Wrong argument count for ' . $name . '().');
+    }
+}
+
+function resolveArrays($code) {
+    return preg_replace_callback(
+        '~' . PARAMS . '~',
+        function ($matches) {
+            $elements = magicSplit(
+                '(?:' . PARAMS . '|' . ARGS . ')(*SKIP)(*FAIL)|,',
+                $matches['params']
+            );
+
+            // don't convert [] to array, it might have different meaning
+            if (empty($elements)) {
+                return $matches[0];
+            }
+
+            $elementCodes = array();
+            foreach ($elements as $element) {
+                // convert only arrays where all elements have keys
+                if (false === strpos($element, ':')) {
+                    return $matches[0];
+                }
+
+                list($key, $value) = explode(':', $element, 2);
+                $elementCodes[] = "'" . $key . "' =>" . $value;
+            }
+
+            return 'array(' . implode(', ', $elementCodes) . ')';
+        },
+        $code
+    );
+}
+
+function resolveStackAccess($code) {
+    $code = preg_replace('/\$\d+/', '$this->semStack[$0]', $code);
+    $code = preg_replace('/#(\d+)/', '$$1', $code);
+    return $code;
+}
+
+function removeTrailingWhitespace($code) {
+    $lines = explode("\n", $code);
+    $lines = array_map('rtrim', $lines);
+    return implode("\n", $lines);
+}
+
+function ensureDirExists($dir) {
+    if (!is_dir($dir)) {
+        mkdir($dir, 0777, true);
+    }
+}
+
+//////////////////////////////
+/// Regex helper functions ///
+//////////////////////////////
+
+function regex($regex) {
+    return '~' . LIB . '(?:' . str_replace('~', '\~', $regex) . ')~';
+}
+
+function magicSplit($regex, $string) {
+    $pieces = preg_split(regex('(?:(?&string)|(?&comment)|(?&code))(*SKIP)(*FAIL)|' . $regex), $string);
+
+    foreach ($pieces as &$piece) {
+        $piece = trim($piece);
+    }
+
+    return array_filter($pieces);
+}

vendor/nikic/php-parser/grammar/zend_language_parser.phpy

@@ -0,0 +1,994 @@
+%pure_parser
+%expect 2
+
+%left T_INCLUDE T_INCLUDE_ONCE T_EVAL T_REQUIRE T_REQUIRE_ONCE
+%left ','
+%left T_LOGICAL_OR
+%left T_LOGICAL_XOR
+%left T_LOGICAL_AND
+%right T_PRINT
+%right T_YIELD
+%right T_YIELD_FROM
+%left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL T_POW_EQUAL
+%left '?' ':'
+%right T_COALESCE
+%left T_BOOLEAN_OR
+%left T_BOOLEAN_AND
+%left '|'
+%left '^'
+%left '&'
+%nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL T_SPACESHIP
+%nonassoc '<' T_IS_SMALLER_OR_EQUAL '>' T_IS_GREATER_OR_EQUAL
+%left T_SL T_SR
+%left '+' '-' '.'
+%left '*' '/' '%'
+%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
+%token T_IF
+%left T_ELSEIF
+%left T_ELSE
+%left T_ENDIF
+%token T_LNUMBER
+%token T_DNUMBER
+%token T_STRING
+%token T_STRING_VARNAME
+%token T_VARIABLE
+%token T_NUM_STRING
+%token T_INLINE_HTML
+%token T_CHARACTER
+%token T_BAD_CHARACTER
+%token T_ENCAPSED_AND_WHITESPACE
+%token T_CONSTANT_ENCAPSED_STRING
+%token T_ECHO
+%token T_DO
+%token T_WHILE
+%token T_ENDWHILE
+%token T_FOR
+%token T_ENDFOR
+%token T_FOREACH
+%token T_ENDFOREACH
+%token T_DECLARE
+%token T_ENDDECLARE
+%token T_AS
+%token T_SWITCH
+%token T_ENDSWITCH
+%token T_CASE
+%token T_DEFAULT
+%token T_BREAK
+%token T_CONTINUE
+%token T_GOTO
+%token T_FUNCTION
+%token T_CONST
+%token T_RETURN
+%token T_TRY
+%token T_CATCH
+%token T_FINALLY
+%token T_THROW
+%token T_USE
+%token T_INSTEADOF
+%token T_GLOBAL
+%right T_STATIC T_ABSTRACT T_FINAL T_PRIVATE T_PROTECTED T_PUBLIC
+%token T_VAR
+%token T_UNSET
+%token T_ISSET
+%token T_EMPTY
+%token T_HALT_COMPILER
+%token T_CLASS
+%token T_TRAIT
+%token T_INTERFACE
+%token T_EXTENDS
+%token T_IMPLEMENTS
+%token T_OBJECT_OPERATOR
+%token T_DOUBLE_ARROW
+%token T_LIST
+%token T_ARRAY
+%token T_CALLABLE
+%token T_CLASS_C
+%token T_TRAIT_C
+%token T_METHOD_C
+%token T_FUNC_C
+%token T_LINE
+%token T_FILE
+%token T_COMMENT
+%token T_DOC_COMMENT
+%token T_OPEN_TAG
+%token T_OPEN_TAG_WITH_ECHO
+%token T_CLOSE_TAG
+%token T_WHITESPACE
+%token T_START_HEREDOC
+%token T_END_HEREDOC
+%token T_DOLLAR_OPEN_CURLY_BRACES
+%token T_CURLY_OPEN
+%token T_PAAMAYIM_NEKUDOTAYIM
+%token T_NAMESPACE
+%token T_NS_C
+%token T_DIR
+%token T_NS_SEPARATOR
+%token T_ELLIPSIS
+
+%{
+use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar;
+use PhpParser\Node\Stmt;
+%}
+
+%%
+
+start:
+    top_statement_list                                      { $$ = $this->handleNamespaces($1); }
+;
+
+top_statement_list:
+      top_statement_list top_statement                      { pushNormalizing($1, $2); }
+    | /* empty */                                           { init(); }
+;
+
+namespace_name_parts:
+      T_STRING                                              { init($1); }
+    | namespace_name_parts T_NS_SEPARATOR T_STRING          { push($1, $3); }
+;
+
+namespace_name:
+      namespace_name_parts                                  { $$ = Name[$1]; }
+;
+
+top_statement:
+      statement                                             { $$ = $1; }
+    | function_declaration_statement                        { $$ = $1; }
+    | class_declaration_statement                           { $$ = $1; }
+    | T_HALT_COMPILER
+          { $$ = Stmt\HaltCompiler[$this->lexer->handleHaltCompiler()]; }
+    | T_NAMESPACE namespace_name ';'                        { $$ = Stmt\Namespace_[$2, null]; }
+    | T_NAMESPACE namespace_name '{' top_statement_list '}' { $$ = Stmt\Namespace_[$2, $4]; }
+    | T_NAMESPACE '{' top_statement_list '}'                { $$ = Stmt\Namespace_[null,     $3]; }
+    | T_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:
+      use_declarations ',' use_declaration                  { push($1, $3); }
+    | use_declaration                                       { init($1); }
+;
+
+use_declaration:
+      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:
+      constant_declaration_list ',' constant_declaration    { push($1, $3); }
+    | constant_declaration                                  { init($1); }
+;
+
+constant_declaration:
+    T_STRING '=' static_scalar                              { $$ = Node\Const_[$1, $3]; }
+;
+
+inner_statement_list:
+      inner_statement_list inner_statement                  { pushNormalizing($1, $2); }
+    | /* empty */                                           { init(); }
+;
+
+inner_statement:
+      statement                                             { $$ = $1; }
+    | function_declaration_statement                        { $$ = $1; }
+    | class_declaration_statement                           { $$ = $1; }
+    | T_HALT_COMPILER
+          { throw new Error('__HALT_COMPILER() can only be used from the outermost scope', attributes()); }
+;
+
+statement:
+      '{' inner_statement_list '}'                          { $$ = $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 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 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 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]; }
+    | error                                                 { $$ = array(); /* means: no statement */ }
+;
+
+catches:
+      /* empty */                                           { init(); }
+    | catches catch                                         { push($1, $2); }
+;
+
+catch:
+    T_CATCH '(' name T_VARIABLE ')' '{' inner_statement_list '}'
+        { $$ = Stmt\Catch_[$3, parseVar($4), $7]; }
+;
+
+optional_finally:
+      /* empty */                                           { $$ = null; }
+    | T_FINALLY '{' inner_statement_list '}'                { $$ = $3; }
+;
+
+variables_list:
+      variable                                              { init($1); }
+    | variables_list ',' variable                           { push($1, $3); }
+;
+
+optional_ref:
+      /* empty */                                           { $$ = false; }
+    | '&'                                                   { $$ = true; }
+;
+
+optional_ellipsis:
+      /* empty */                                           { $$ = false; }
+    | T_ELLIPSIS                                            { $$ = true; }
+;
+
+function_declaration_statement:
+    T_FUNCTION optional_ref T_STRING '(' parameter_list ')' optional_return_type '{' inner_statement_list '}'
+        { $$ = Stmt\Function_[$3, [byRef: $2, params: $5, returnType: $7, stmts: $9]]; }
+;
+
+class_declaration_statement:
+      class_entry_type T_STRING extends_from implements_list '{' class_statement_list '}'
+          { $$ = 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]]; }
+    | T_TRAIT T_STRING '{' class_statement_list '}'
+          { $$ = 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; }
+;
+
+extends_from:
+      /* empty */                                           { $$ = null; }
+    | T_EXTENDS name                                        { $$ = $2; }
+;
+
+interface_extends_list:
+      /* empty */                                           { $$ = array(); }
+    | T_EXTENDS name_list                                   { $$ = $2; }
+;
+
+implements_list:
+      /* empty */                                           { $$ = array(); }
+    | T_IMPLEMENTS name_list                                { $$ = $2; }
+;
+
+name_list:
+      name                                                  { init($1); }
+    | name_list ',' name                                    { push($1, $3); }
+;
+
+for_statement:
+      statement                                             { $$ = toArray($1); }
+    | ':' inner_statement_list T_ENDFOR ';'                 { $$ = $2; }
+;
+
+foreach_statement:
+      statement                                             { $$ = toArray($1); }
+    | ':' inner_statement_list T_ENDFOREACH ';'             { $$ = $2; }
+;
+
+declare_statement:
+      statement                                             { $$ = toArray($1); }
+    | ':' inner_statement_list T_ENDDECLARE ';'             { $$ = $2; }
+;
+
+declare_list:
+      declare_list_element                                  { init($1); }
+    | declare_list ',' declare_list_element                 { push($1, $3); }
+;
+
+declare_list_element:
+      T_STRING '=' static_scalar                            { $$ = Stmt\DeclareDeclare[$1, $3]; }
+;
+
+switch_case_list:
+      '{' case_list '}'                                     { $$ = $2; }
+    | '{' ';' case_list '}'                                 { $$ = $3; }
+    | ':' case_list T_ENDSWITCH ';'                         { $$ = $2; }
+    | ':' ';' case_list T_ENDSWITCH ';'                     { $$ = $3; }
+;
+
+case_list:
+      /* empty */                                           { init(); }
+    | case_list case                                        { push($1, $2); }
+;
+
+case:
+      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:
+      ':'
+    | ';'
+;
+
+while_statement:
+      statement                                             { $$ = toArray($1); }
+    | ':' inner_statement_list T_ENDWHILE ';'               { $$ = $2; }
+;
+
+elseif_list:
+      /* empty */                                           { init(); }
+    | elseif_list elseif                                    { push($1, $2); }
+;
+
+elseif:
+      T_ELSEIF parentheses_expr statement                   { $$ = Stmt\ElseIf_[$2, toArray($3)]; }
+;
+
+new_elseif_list:
+      /* empty */                                           { init(); }
+    | new_elseif_list new_elseif                            { push($1, $2); }
+;
+
+new_elseif:
+     T_ELSEIF parentheses_expr ':' inner_statement_list     { $$ = Stmt\ElseIf_[$2, $4]; }
+;
+
+else_single:
+      /* empty */                                           { $$ = null; }
+    | T_ELSE statement                                      { $$ = Stmt\Else_[toArray($2)]; }
+;
+
+new_else_single:
+      /* empty */                                           { $$ = null; }
+    | 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:
+      non_empty_parameter_list                              { $$ = $1; }
+    | /* empty */                                           { $$ = array(); }
+;
+
+non_empty_parameter_list:
+      parameter                                             { init($1); }
+    | non_empty_parameter_list ',' parameter                { push($1, $3); }
+;
+
+parameter:
+      optional_param_type optional_ref optional_ellipsis T_VARIABLE
+          { $$ = Node\Param[parseVar($4), null, $1, $2, $3]; }
+    | optional_param_type optional_ref optional_ellipsis T_VARIABLE '=' static_scalar
+          { $$ = Node\Param[parseVar($4), $6, $1, $2, $3]; }
+;
+
+type:
+      name                                                  { $$ = $1; }
+    | T_ARRAY                                               { $$ = 'array'; }
+    | T_CALLABLE                                            { $$ = 'callable'; }
+;
+
+optional_param_type:
+      /* empty */                                           { $$ = null; }
+    | type                                                  { $$ = $1; }
+;
+
+optional_return_type:
+      /* empty */                                           { $$ = null; }
+    | ':' type                                              { $$ = $2; }
+;
+
+argument_list:
+      '(' ')'                                               { $$ = array(); }
+    | '(' non_empty_argument_list ')'                       { $$ = $2; }
+    | '(' yield_expr ')'                                    { $$ = array(Node\Arg[$2, false, false]); }
+;
+
+non_empty_argument_list:
+      argument                                              { init($1); }
+    | non_empty_argument_list ',' argument                  { push($1, $3); }
+;
+
+argument:
+      expr                                                  { $$ = Node\Arg[$1, false, false]; }
+    | '&' variable                                          { $$ = Node\Arg[$2, true, false]; }
+    | T_ELLIPSIS expr                                       { $$ = Node\Arg[$2, false, true]; }
+;
+
+global_var_list:
+      global_var_list ',' global_var                        { push($1, $3); }
+    | global_var                                            { init($1); }
+;
+
+global_var:
+      T_VARIABLE                                            { $$ = Expr\Variable[parseVar($1)]; }
+    | '$' variable                                          { $$ = Expr\Variable[$2]; }
+    | '$' '{' expr '}'                                      { $$ = Expr\Variable[$3]; }
+;
+
+static_var_list:
+      static_var_list ',' static_var                        { push($1, $3); }
+    | static_var                                            { init($1); }
+;
+
+static_var:
+      T_VARIABLE                                            { $$ = Stmt\StaticVar[parseVar($1), null]; }
+    | T_VARIABLE '=' static_scalar                          { $$ = Stmt\StaticVar[parseVar($1), $3]; }
+;
+
+class_statement_list:
+      class_statement_list class_statement                  { push($1, $2); }
+    | /* empty */                                           { init(); }
+;
+
+class_statement:
+      variable_modifiers property_declaration_list ';'      { $$ = Stmt\Property[$1, $2]; }
+    | T_CONST constant_declaration_list ';'                 { $$ = Stmt\ClassConst[$2]; }
+    | method_modifiers T_FUNCTION optional_ref T_STRING '(' parameter_list ')' optional_return_type method_body
+          { $$ = Stmt\ClassMethod[$4, [type: $1, byRef: $3, params: $6, returnType: $8, stmts: $9]]; }
+    | T_USE name_list trait_adaptations                     { $$ = Stmt\TraitUse[$2, $3]; }
+;
+
+trait_adaptations:
+      ';'                                                   { $$ = array(); }
+    | '{' trait_adaptation_list '}'                         { $$ = $2; }
+;
+
+trait_adaptation_list:
+      /* empty */                                           { init(); }
+    | trait_adaptation_list trait_adaptation                { push($1, $2); }
+;
+
+trait_adaptation:
+      trait_method_reference_fully_qualified T_INSTEADOF name_list ';'
+          { $$ = 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]; }
+    | trait_method_reference T_AS member_modifier ';'
+          { $$ = 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]; }
+;
+
+trait_method_reference_fully_qualified:
+      name T_PAAMAYIM_NEKUDOTAYIM T_STRING                  { $$ = array($1, $3); }
+;
+trait_method_reference:
+      trait_method_reference_fully_qualified                { $$ = $1; }
+    | T_STRING                                              { $$ = array(null, $1); }
+;
+
+method_body:
+      ';' /* abstract method */                             { $$ = null; }
+    | '{' inner_statement_list '}'                          { $$ = $2; }
+;
+
+variable_modifiers:
+      non_empty_member_modifiers                            { $$ = $1; }
+    | T_VAR                                                 { $$ = 0; }
+;
+
+method_modifiers:
+      /* empty */                                           { $$ = 0; }
+    | 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; }
+;
+
+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; }
+;
+
+property_declaration_list:
+      property_declaration                                  { init($1); }
+    | property_declaration_list ',' property_declaration    { push($1, $3); }
+;
+
+property_declaration:
+      T_VARIABLE                                            { $$ = Stmt\PropertyProperty[parseVar($1), null]; }
+    | T_VARIABLE '=' static_scalar                          { $$ = Stmt\PropertyProperty[parseVar($1), $3]; }
+;
+
+expr_list:
+      expr_list ',' expr                                    { push($1, $3); }
+    | expr                                                  { init($1); }
+;
+
+for_expr:
+      /* empty */                                           { $$ = array(); }
+    | expr_list                                             { $$ = $1; }
+;
+
+expr:
+      variable                                              { $$ = $1; }
+    | list_expr '=' expr                                    { $$ = Expr\Assign[$1, $3]; }
+    | variable '=' expr                                     { $$ = Expr\Assign[$1, $3]; }
+    | variable '=' '&' variable                             { $$ = Expr\AssignRef[$1, $4]; }
+    | variable '=' '&' new_expr                             { $$ = Expr\AssignRef[$1, $4]; }
+    | new_expr                                              { $$ = $1; }
+    | T_CLONE expr                                          { $$ = Expr\Clone_[$2]; }
+    | variable T_PLUS_EQUAL expr                            { $$ = Expr\AssignOp\Plus      [$1, $3]; }
+    | variable T_MINUS_EQUAL expr                           { $$ = Expr\AssignOp\Minus     [$1, $3]; }
+    | 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 T_SPACESHIP expr                                 { $$ = Expr\BinaryOp\Spaceship     [$1, $3]; }
+    | expr '<' expr                                         { $$ = Expr\BinaryOp\Smaller       [$1, $3]; }
+    | expr T_IS_SMALLER_OR_EQUAL expr                       { $$ = Expr\BinaryOp\SmallerOrEqual[$1, $3]; }
+    | expr '>' expr                                         { $$ = Expr\BinaryOp\Greater       [$1, $3]; }
+    | 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]; }
+    | expr T_COALESCE expr                                  { $$ = Expr\BinaryOp\Coalesce[$1, $3]; }
+    | T_ISSET '(' variables_list ')'                        { $$ = Expr\Isset_[$3]; }
+    | T_EMPTY '(' expr ')'                                  { $$ = Expr\Empty_[$3]; }
+    | T_INCLUDE expr                                        { $$ = Expr\Include_[$2, Expr\Include_::TYPE_INCLUDE]; }
+    | 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; }
+    | array_expr                                            { $$ = $1; }
+    | scalar_dereference                                    { $$ = $1; }
+    | '`' backticks_expr '`'                                { $$ = Expr\ShellExec[$2]; }
+    | T_PRINT expr                                          { $$ = Expr\Print_[$2]; }
+    | T_YIELD                                               { $$ = Expr\Yield_[null, null]; }
+    | T_YIELD_FROM expr                                     { $$ = Expr\YieldFrom[$2]; }
+    | T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type
+      '{' inner_statement_list '}'
+          { $$ = Expr\Closure[[static: false, byRef: $2, params: $4, uses: $6, returnType: $7, stmts: $9]]; }
+    | T_STATIC T_FUNCTION optional_ref '(' parameter_list ')' lexical_vars optional_return_type
+      '{' inner_statement_list '}'
+          { $$ = Expr\Closure[[static: true, byRef: $3, params: $5, uses: $7, returnType: $8, stmts: $10]]; }
+;
+
+parentheses_expr:
+      '(' 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 */
+;
+
+anonymous_class:
+      T_CLASS ctor_arguments extends_from implements_list '{' class_statement_list '}'
+          { $$ = array(Stmt\Class_[null, [type: 0, extends: $3, implements: $4, stmts: $6]], $2); }
+
+new_expr:
+      T_NEW class_name_reference ctor_arguments             { $$ = Expr\New_[$2, $3]; }
+    | T_NEW anonymous_class
+          { list($class, $ctorArgs) = $2; $$ = Expr\New_[$class, $ctorArgs]; }
+;
+
+lexical_vars:
+      /* empty */                                           { $$ = array(); }
+    | T_USE '(' lexical_var_list ')'                        { $$ = $3; }
+;
+
+lexical_var_list:
+      lexical_var                                           { init($1); }
+    | lexical_var_list ',' lexical_var                      { push($1, $3); }
+;
+
+lexical_var:
+      optional_ref T_VARIABLE                               { $$ = Expr\ClosureUse[parseVar($2), $1]; }
+;
+
+function_call:
+      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 Node\Expr\ArrayDimFetch) {
+                    $tmp = $tmp->var;
+                }
+
+                $$ = Expr\StaticCall[$tmp->var->class, $1, $2];
+                $tmp->var = Expr\Variable[$tmp->var->name];
+            } else {
+                throw new \Exception;
+            }
+          }
+    | 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[$1]; }
+    | name                                                  { $$ = $1; }
+;
+
+name:
+      namespace_name_parts                                  { $$ = Name[$1]; }
+    | T_NS_SEPARATOR namespace_name_parts                   { $$ = Name\FullyQualified[$2]; }
+    | T_NAMESPACE T_NS_SEPARATOR namespace_name_parts       { $$ = Name\Relative[$3]; }
+;
+
+class_name_reference:
+      class_name                                            { $$ = $1; }
+    | dynamic_class_name_reference                          { $$ = $1; }
+;
+
+dynamic_class_name_reference:
+      object_access_for_dcnr                                { $$ = $1; }
+    | base_variable                                         { $$ = $1; }
+;
+
+class_name_or_var:
+      class_name                                            { $$ = $1; }
+    | reference_variable                                    { $$ = $1; }
+;
+
+object_access_for_dcnr:
+      base_variable T_OBJECT_OPERATOR object_property
+          { $$ = 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]; }
+;
+
+exit_expr:
+      /* empty */                                           { $$ = null; }
+    | '(' ')'                                               { $$ = null; }
+    | parentheses_expr                                      { $$ = $1; }
+;
+
+backticks_expr:
+      /* empty */                                           { $$ = array(); }
+    | T_ENCAPSED_AND_WHITESPACE                             { $$ = array(Scalar\String_::parseEscapeSequences($1, '`')); }
+    | encaps_list                                           { parseEncapsed($1, '`'); $$ = $1; }
+;
+
+ctor_arguments:
+      /* empty */                                           { $$ = array(); }
+    | 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_[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)]; }
+    | T_START_HEREDOC T_END_HEREDOC
+          { $$ = Scalar\String_['']; }
+;
+
+static_scalar:
+      common_scalar                                         { $$ = $1; }
+    | 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; }
+    | constant                                              { $$ = $1; }
+    | '"' encaps_list '"'
+          { parseEncapsed($2, '"'); $$ = Scalar\Encapsed[$2]; }
+    | T_START_HEREDOC encaps_list T_END_HEREDOC
+          { parseEncapsedDoc($2); $$ = Scalar\Encapsed[$2]; }
+;
+
+class_const_name:
+      T_STRING                                              { $$ = $1; }
+    | T_CLASS                                               { $$ = 'class'; }
+;
+
+static_array_pair_list:
+      /* empty */                                           { $$ = array(); }
+    | non_empty_static_array_pair_list optional_comma       { $$ = $1; }
+;
+
+optional_comma:
+      /* empty */
+    | ','
+;
+
+non_empty_static_array_pair_list:
+      non_empty_static_array_pair_list ',' static_array_pair { push($1, $3); }
+    | static_array_pair                                      { init($1); }
+;
+
+static_array_pair:
+      static_scalar T_DOUBLE_ARROW static_scalar            { $$ = Expr\ArrayItem[$3, $1,   false]; }
+    | static_scalar                                         { $$ = Expr\ArrayItem[$1, null, false]; }
+;
+
+variable:
+      object_access                                         { $$ = $1; }
+    | base_variable                                         { $$ = $1; }
+    | function_call                                         { $$ = $1; }
+    | new_expr_array_deref                                  { $$ = $1; }
+;
+
+new_expr_array_deref:
+      '(' 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, $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:
+      variable                                              { $$ = $1; }
+    | '(' new_expr ')'                                      { $$ = $2; }
+;
+
+variable_without_objects:
+      reference_variable                                    { $$ = $1; }
+    | '$' variable_without_objects                          { $$ = Expr\Variable[$2]; }
+;
+
+base_variable:
+      variable_without_objects                              { $$ = $1; }
+    | static_property                                       { $$ = $1; }
+;
+
+static_property:
+      class_name_or_var T_PAAMAYIM_NEKUDOTAYIM '$' reference_variable
+          { $$ = 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)]; }
+    | 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]; }
+;
+
+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]; }
+;
+
+dim_offset:
+      /* empty */                                           { $$ = null; }
+    | expr                                                  { $$ = $1; }
+;
+
+object_property:
+      T_STRING                                              { $$ = $1; }
+    | '{' expr '}'                                          { $$ = $2; }
+    | variable_without_objects                              { $$ = $1; }
+;
+
+list_expr:
+      T_LIST '(' list_expr_elements ')'                     { $$ = Expr\List_[$3]; }
+;
+
+list_expr_elements:
+      list_expr_elements ',' list_expr_element              { push($1, $3); }
+    | list_expr_element                                     { init($1); }
+;
+
+list_expr_element:
+      variable                                              { $$ = $1; }
+    | list_expr                                             { $$ = $1; }
+    | /* empty */                                           { $$ = null; }
+;
+
+array_pair_list:
+      /* empty */                                           { $$ = array(); }
+    | non_empty_array_pair_list optional_comma              { $$ = $1; }
+;
+
+non_empty_array_pair_list:
+      non_empty_array_pair_list ',' array_pair              { push($1, $3); }
+    | array_pair                                            { init($1); }
+;
+
+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]; }
+;
+
+encaps_list:
+      encaps_list encaps_var                                { push($1, $2); }
+    | encaps_list T_ENCAPSED_AND_WHITESPACE                 { push($1, $2); }
+    | encaps_var                                            { init($1); }
+    | T_ENCAPSED_AND_WHITESPACE encaps_var                  { init($1, $2); }
+;
+
+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_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
+          { $$ = 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)]; }
+;
+
+%%

vendor/nikic/php-parser/lib/PhpParser/Autoloader.php

@@ -0,0 +1,275 @@
+<?php
+
+namespace PhpParser;
+
+/**
+ * @codeCoverageIgnore
+ */
+class Autoloader
+{
+    /** @var bool Whether the autoloader has been registered. */
+    private static $registered = false;
+
+    /** @var bool Whether we're running on PHP 7. */
+    private static $runningOnPhp7;
+
+    /**
+     * Registers PhpParser\Autoloader as an SPL autoloader.
+     *
+     * @param bool $prepend Whether to prepend the autoloader instead of appending
+     */
+    static public function register($prepend = false) {
+        if (self::$registered === true) {
+            return;
+        }
+
+        spl_autoload_register(array(__CLASS__, 'autoload'), true, $prepend);
+        self::$registered = true;
+        self::$runningOnPhp7 = version_compare(PHP_VERSION, '7.0-dev', '>=');
+    }
+
+    /**
+     * Handles autoloading of classes.
+     *
+     * @param string $class A class name.
+     */
+    static public function autoload($class) {
+        if (0 === strpos($class, 'PhpParser\\')) {
+            if (isset(self::$php7AliasesOldToNew[$class])) {
+                if (self::$runningOnPhp7) {
+                    return;
+                }
+
+                // Load the new class, alias will be registered afterwards
+                $class = self::$php7AliasesOldToNew[$class];
+            }
+
+            $fileName = dirname(__DIR__) . '/' . strtr($class, '\\', '/') . '.php';
+            if (file_exists($fileName)) {
+                require $fileName;
+            }
+
+            if (isset(self::$php7AliasesNewToOld[$class])) {
+                // New class name was used, register alias for old one, otherwise
+                // it won't be usable in "instanceof" and other non-autoloading places.
+                if (!self::$runningOnPhp7) {
+                    class_alias($class, self::$php7AliasesNewToOld[$class]);
+                }
+            }
+        } else if (0 === strpos($class, 'PHPParser_')) {
+            if (isset(self::$nonNamespacedAliases[$class])) {
+                // Register all aliases at once to avoid dependency issues
+                self::registerNonNamespacedAliases();
+            }
+        }
+    }
+
+    private static function registerNonNamespacedAliases() {
+        foreach (self::$nonNamespacedAliases as $old => $new) {
+            class_alias($new, $old);
+        }
+    }
+
+    private static $php7AliasesOldToNew = array(
+        'PhpParser\Node\Expr\Cast\Bool' => 'PhpParser\Node\Expr\Cast\Bool_',
+        'PhpParser\Node\Expr\Cast\Int' => 'PhpParser\Node\Expr\Cast\Int_',
+        'PhpParser\Node\Expr\Cast\Object' => 'PhpParser\Node\Expr\Cast\Object_',
+        'PhpParser\Node\Expr\Cast\String' => 'PhpParser\Node\Expr\Cast\String_',
+        'PhpParser\Node\Scalar\String' => 'PhpParser\Node\Scalar\String_',
+    );
+
+    private static $php7AliasesNewToOld = array(
+        'PhpParser\Node\Expr\Cast\Bool_' => 'PhpParser\Node\Expr\Cast\Bool',
+        'PhpParser\Node\Expr\Cast\Int_' => 'PhpParser\Node\Expr\Cast\Int',
+        'PhpParser\Node\Expr\Cast\Object_' => 'PhpParser\Node\Expr\Cast\Object',
+        'PhpParser\Node\Expr\Cast\String_' => 'PhpParser\Node\Expr\Cast\String',
+        'PhpParser\Node\Scalar\String_' => 'PhpParser\Node\Scalar\String',
+    );
+
+    private static $nonNamespacedAliases = array(
+        'PHPParser_Builder' => 'PhpParser\Builder',
+        'PHPParser_BuilderAbstract' => 'PhpParser\BuilderAbstract',
+        'PHPParser_BuilderFactory' => 'PhpParser\BuilderFactory',
+        'PHPParser_Comment' => 'PhpParser\Comment',
+        'PHPParser_Comment_Doc' => 'PhpParser\Comment\Doc',
+        'PHPParser_Error' => 'PhpParser\Error',
+        'PHPParser_Lexer' => 'PhpParser\Lexer',
+        'PHPParser_Lexer_Emulative' => 'PhpParser\Lexer\Emulative',
+        'PHPParser_Node' => 'PhpParser\Node',
+        'PHPParser_NodeAbstract' => 'PhpParser\NodeAbstract',
+        'PHPParser_NodeDumper' => 'PhpParser\NodeDumper',
+        'PHPParser_NodeTraverser' => 'PhpParser\NodeTraverser',
+        'PHPParser_NodeTraverserInterface' => 'PhpParser\NodeTraverserInterface',
+        'PHPParser_NodeVisitor' => 'PhpParser\NodeVisitor',
+        'PHPParser_NodeVisitor_NameResolver' => 'PhpParser\NodeVisitor\NameResolver',
+        'PHPParser_NodeVisitorAbstract' => 'PhpParser\NodeVisitorAbstract',
+        'PHPParser_Parser' => 'PhpParser\Parser',
+        'PHPParser_PrettyPrinterAbstract' => 'PhpParser\PrettyPrinterAbstract',
+        'PHPParser_PrettyPrinter_Default' => 'PhpParser\PrettyPrinter\Standard',
+        'PHPParser_PrettyPrinter_Zend' => 'PhpParser\PrettyPrinter\Standard',
+        'PHPParser_Serializer' => 'PhpParser\Serializer',
+        'PHPParser_Serializer_XML' => 'PhpParser\Serializer\XML',
+        'PHPParser_Unserializer' => 'PhpParser\Unserializer',
+        'PHPParser_Unserializer_XML' => 'PhpParser\Unserializer\XML',
+
+        'PHPParser_Builder_Class' => 'PhpParser\Builder\Class_',
+        'PHPParser_Builder_Function' => 'PhpParser\Builder\Function_',
+        'PHPParser_Builder_Interface' => 'PhpParser\Builder\Interface_',
+        'PHPParser_Builder_Method' => 'PhpParser\Builder\Method',
+        'PHPParser_Builder_Param' => 'PhpParser\Builder\Param',
+        'PHPParser_Builder_Property' => 'PhpParser\Builder\Property',
+
+        'PHPParser_Node_Arg' => 'PhpParser\Node\Arg',
+        'PHPParser_Node_Const' => 'PhpParser\Node\Const_',
+        'PHPParser_Node_Expr' => 'PhpParser\Node\Expr',
+        'PHPParser_Node_Name' => 'PhpParser\Node\Name',
+        'PHPParser_Node_Name_FullyQualified' => 'PhpParser\Node\Name\FullyQualified',
+        'PHPParser_Node_Name_Relative' => 'PhpParser\Node\Name\Relative',
+        'PHPParser_Node_Param' => 'PhpParser\Node\Param',
+        'PHPParser_Node_Scalar' => 'PhpParser\Node\Scalar',
+        'PHPParser_Node_Stmt' => 'PhpParser\Node\Stmt',
+
+        'PHPParser_Node_Stmt_Break' => 'PhpParser\Node\Stmt\Break_',
+        'PHPParser_Node_Stmt_Case' => 'PhpParser\Node\Stmt\Case_',
+        'PHPParser_Node_Stmt_Catch' => 'PhpParser\Node\Stmt\Catch_',
+        'PHPParser_Node_Stmt_Class' => 'PhpParser\Node\Stmt\Class_',
+        'PHPParser_Node_Stmt_ClassConst' => 'PhpParser\Node\Stmt\ClassConst',
+        'PHPParser_Node_Stmt_ClassMethod' => 'PhpParser\Node\Stmt\ClassMethod',
+        'PHPParser_Node_Stmt_Const' => 'PhpParser\Node\Stmt\Const_',
+        'PHPParser_Node_Stmt_Continue' => 'PhpParser\Node\Stmt\Continue_',
+        'PHPParser_Node_Stmt_Declare' => 'PhpParser\Node\Stmt\Declare_',
+        'PHPParser_Node_Stmt_DeclareDeclare' => 'PhpParser\Node\Stmt\DeclareDeclare',
+        'PHPParser_Node_Stmt_Do' => 'PhpParser\Node\Stmt\Do_',
+        'PHPParser_Node_Stmt_Echo' => 'PhpParser\Node\Stmt\Echo_',
+        'PHPParser_Node_Stmt_Else' => 'PhpParser\Node\Stmt\Else_',
+        'PHPParser_Node_Stmt_ElseIf' => 'PhpParser\Node\Stmt\ElseIf_',
+        'PHPParser_Node_Stmt_For' => 'PhpParser\Node\Stmt\For_',
+        'PHPParser_Node_Stmt_Foreach' => 'PhpParser\Node\Stmt\Foreach_',
+        'PHPParser_Node_Stmt_Function' => 'PhpParser\Node\Stmt\Function_',
+        'PHPParser_Node_Stmt_Global' => 'PhpParser\Node\Stmt\Global_',
+        'PHPParser_Node_Stmt_Goto' => 'PhpParser\Node\Stmt\Goto_',
+        'PHPParser_Node_Stmt_HaltCompiler' => 'PhpParser\Node\Stmt\HaltCompiler',
+        'PHPParser_Node_Stmt_If' => 'PhpParser\Node\Stmt\If_',
+        'PHPParser_Node_Stmt_InlineHTML' => 'PhpParser\Node\Stmt\InlineHTML',
+        'PHPParser_Node_Stmt_Interface' => 'PhpParser\Node\Stmt\Interface_',
+        'PHPParser_Node_Stmt_Label' => 'PhpParser\Node\Stmt\Label',
+        'PHPParser_Node_Stmt_Namespace' => 'PhpParser\Node\Stmt\Namespace_',
+        'PHPParser_Node_Stmt_Property' => 'PhpParser\Node\Stmt\Property',
+        'PHPParser_Node_Stmt_PropertyProperty' => 'PhpParser\Node\Stmt\PropertyProperty',
+        'PHPParser_Node_Stmt_Return' => 'PhpParser\Node\Stmt\Return_',
+        'PHPParser_Node_Stmt_Static' => 'PhpParser\Node\Stmt\Static_',
+        'PHPParser_Node_Stmt_StaticVar' => 'PhpParser\Node\Stmt\StaticVar',
+        'PHPParser_Node_Stmt_Switch' => 'PhpParser\Node\Stmt\Switch_',
+        'PHPParser_Node_Stmt_Throw' => 'PhpParser\Node\Stmt\Throw_',
+        'PHPParser_Node_Stmt_Trait' => 'PhpParser\Node\Stmt\Trait_',
+        'PHPParser_Node_Stmt_TraitUse' => 'PhpParser\Node\Stmt\TraitUse',
+        'PHPParser_Node_Stmt_TraitUseAdaptation' => 'PhpParser\Node\Stmt\TraitUseAdaptation',
+        'PHPParser_Node_Stmt_TraitUseAdaptation_Alias' => 'PhpParser\Node\Stmt\TraitUseAdaptation\Alias',
+        'PHPParser_Node_Stmt_TraitUseAdaptation_Precedence' => 'PhpParser\Node\Stmt\TraitUseAdaptation\Precedence',
+        'PHPParser_Node_Stmt_TryCatch' => 'PhpParser\Node\Stmt\TryCatch',
+        'PHPParser_Node_Stmt_Unset' => 'PhpParser\Node\Stmt\Unset_',
+        'PHPParser_Node_Stmt_UseUse' => 'PhpParser\Node\Stmt\UseUse',
+        'PHPParser_Node_Stmt_Use' => 'PhpParser\Node\Stmt\Use_',
+        'PHPParser_Node_Stmt_While' => 'PhpParser\Node\Stmt\While_',
+
+        'PHPParser_Node_Expr_AssignBitwiseAnd' => 'PhpParser\Node\Expr\AssignOp\BitwiseAnd',
+        'PHPParser_Node_Expr_AssignBitwiseOr' => 'PhpParser\Node\Expr\AssignOp\BitwiseOr',
+        'PHPParser_Node_Expr_AssignBitwiseXor' => 'PhpParser\Node\Expr\AssignOp\BitwiseXor',
+        'PHPParser_Node_Expr_AssignConcat' => 'PhpParser\Node\Expr\AssignOp\Concat',
+        'PHPParser_Node_Expr_AssignDiv' => 'PhpParser\Node\Expr\AssignOp\Div',
+        'PHPParser_Node_Expr_AssignMinus' => 'PhpParser\Node\Expr\AssignOp\Minus',
+        'PHPParser_Node_Expr_AssignMod' => 'PhpParser\Node\Expr\AssignOp\Mod',
+        'PHPParser_Node_Expr_AssignMul' => 'PhpParser\Node\Expr\AssignOp\Mul',
+        'PHPParser_Node_Expr_AssignPlus' => 'PhpParser\Node\Expr\AssignOp\Plus',
+        'PHPParser_Node_Expr_AssignShiftLeft' => 'PhpParser\Node\Expr\AssignOp\ShiftLeft',
+        'PHPParser_Node_Expr_AssignShiftRight' => 'PhpParser\Node\Expr\AssignOp\ShiftRight',
+
+        'PHPParser_Node_Expr_Cast' => 'PhpParser\Node\Expr\Cast',
+        'PHPParser_Node_Expr_Cast_Array' => 'PhpParser\Node\Expr\Cast\Array_',
+        'PHPParser_Node_Expr_Cast_Bool' => 'PhpParser\Node\Expr\Cast\Bool_',
+        'PHPParser_Node_Expr_Cast_Double' => 'PhpParser\Node\Expr\Cast\Double',
+        'PHPParser_Node_Expr_Cast_Int' => 'PhpParser\Node\Expr\Cast\Int_',
+        'PHPParser_Node_Expr_Cast_Object' => 'PhpParser\Node\Expr\Cast\Object_',
+        'PHPParser_Node_Expr_Cast_String' => 'PhpParser\Node\Expr\Cast\String_',
+        'PHPParser_Node_Expr_Cast_Unset' => 'PhpParser\Node\Expr\Cast\Unset_',
+
+        'PHPParser_Node_Expr_BitwiseAnd' => 'PhpParser\Node\Expr\BinaryOp\BitwiseAnd',
+        'PHPParser_Node_Expr_BitwiseOr' => 'PhpParser\Node\Expr\BinaryOp\BitwiseOr',
+        'PHPParser_Node_Expr_BitwiseXor' => 'PhpParser\Node\Expr\BinaryOp\BitwiseXor',
+        'PHPParser_Node_Expr_BooleanAnd' => 'PhpParser\Node\Expr\BinaryOp\BooleanAnd',
+        'PHPParser_Node_Expr_BooleanOr' => 'PhpParser\Node\Expr\BinaryOp\BooleanOr',
+        'PHPParser_Node_Expr_Concat' => 'PhpParser\Node\Expr\BinaryOp\Concat',
+        'PHPParser_Node_Expr_Div' => 'PhpParser\Node\Expr\BinaryOp\Div',
+        'PHPParser_Node_Expr_Equal' => 'PhpParser\Node\Expr\BinaryOp\Equal',
+        'PHPParser_Node_Expr_Greater' => 'PhpParser\Node\Expr\BinaryOp\Greater',
+        'PHPParser_Node_Expr_GreaterOrEqual' => 'PhpParser\Node\Expr\BinaryOp\GreaterOrEqual',
+        'PHPParser_Node_Expr_Identical' => 'PhpParser\Node\Expr\BinaryOp\Identical',
+        'PHPParser_Node_Expr_LogicalAnd' => 'PhpParser\Node\Expr\BinaryOp\LogicalAnd',
+        'PHPParser_Node_Expr_LogicalOr' => 'PhpParser\Node\Expr\BinaryOp\LogicalOr',
+        'PHPParser_Node_Expr_LogicalXor' => 'PhpParser\Node\Expr\BinaryOp\LogicalXor',
+        'PHPParser_Node_Expr_Minus' => 'PhpParser\Node\Expr\BinaryOp\Minus',
+        'PHPParser_Node_Expr_Mod' => 'PhpParser\Node\Expr\BinaryOp\Mod',
+        'PHPParser_Node_Expr_Mul' => 'PhpParser\Node\Expr\BinaryOp\Mul',
+        'PHPParser_Node_Expr_NotEqual' => 'PhpParser\Node\Expr\BinaryOp\NotEqual',
+        'PHPParser_Node_Expr_NotIdentical' => 'PhpParser\Node\Expr\BinaryOp\NotIdentical',
+        'PHPParser_Node_Expr_Plus' => 'PhpParser\Node\Expr\BinaryOp\Plus',
+        'PHPParser_Node_Expr_ShiftLeft' => 'PhpParser\Node\Expr\BinaryOp\ShiftLeft',
+        'PHPParser_Node_Expr_ShiftRight' => 'PhpParser\Node\Expr\BinaryOp\ShiftRight',
+        'PHPParser_Node_Expr_Smaller' => 'PhpParser\Node\Expr\BinaryOp\Smaller',
+        'PHPParser_Node_Expr_SmallerOrEqual' => 'PhpParser\Node\Expr\BinaryOp\SmallerOrEqual',
+
+        'PHPParser_Node_Expr_Array' => 'PhpParser\Node\Expr\Array_',
+        'PHPParser_Node_Expr_ArrayDimFetch' => 'PhpParser\Node\Expr\ArrayDimFetch',
+        'PHPParser_Node_Expr_ArrayItem' => 'PhpParser\Node\Expr\ArrayItem',
+        'PHPParser_Node_Expr_Assign' => 'PhpParser\Node\Expr\Assign',
+        'PHPParser_Node_Expr_AssignRef' => 'PhpParser\Node\Expr\AssignRef',
+        'PHPParser_Node_Expr_BitwiseNot' => 'PhpParser\Node\Expr\BitwiseNot',
+        'PHPParser_Node_Expr_BooleanNot' => 'PhpParser\Node\Expr\BooleanNot',
+        'PHPParser_Node_Expr_ClassConstFetch' => 'PhpParser\Node\Expr\ClassConstFetch',
+        'PHPParser_Node_Expr_Clone' => 'PhpParser\Node\Expr\Clone_',
+        'PHPParser_Node_Expr_Closure' => 'PhpParser\Node\Expr\Closure',
+        'PHPParser_Node_Expr_ClosureUse' => 'PhpParser\Node\Expr\ClosureUse',
+        'PHPParser_Node_Expr_ConstFetch' => 'PhpParser\Node\Expr\ConstFetch',
+        'PHPParser_Node_Expr_Empty' => 'PhpParser\Node\Expr\Empty_',
+        'PHPParser_Node_Expr_ErrorSuppress' => 'PhpParser\Node\Expr\ErrorSuppress',
+        'PHPParser_Node_Expr_Eval' => 'PhpParser\Node\Expr\Eval_',
+        'PHPParser_Node_Expr_Exit' => 'PhpParser\Node\Expr\Exit_',
+        'PHPParser_Node_Expr_FuncCall' => 'PhpParser\Node\Expr\FuncCall',
+        'PHPParser_Node_Expr_Include' => 'PhpParser\Node\Expr\Include_',
+        'PHPParser_Node_Expr_Instanceof' => 'PhpParser\Node\Expr\Instanceof_',
+        'PHPParser_Node_Expr_Isset' => 'PhpParser\Node\Expr\Isset_',
+        'PHPParser_Node_Expr_List' => 'PhpParser\Node\Expr\List_',
+        'PHPParser_Node_Expr_MethodCall' => 'PhpParser\Node\Expr\MethodCall',
+        'PHPParser_Node_Expr_New' => 'PhpParser\Node\Expr\New_',
+        'PHPParser_Node_Expr_PostDec' => 'PhpParser\Node\Expr\PostDec',
+        'PHPParser_Node_Expr_PostInc' => 'PhpParser\Node\Expr\PostInc',
+        'PHPParser_Node_Expr_PreDec' => 'PhpParser\Node\Expr\PreDec',
+        'PHPParser_Node_Expr_PreInc' => 'PhpParser\Node\Expr\PreInc',
+        'PHPParser_Node_Expr_Print' => 'PhpParser\Node\Expr\Print_',
+        'PHPParser_Node_Expr_PropertyFetch' => 'PhpParser\Node\Expr\PropertyFetch',
+        'PHPParser_Node_Expr_ShellExec' => 'PhpParser\Node\Expr\ShellExec',
+        'PHPParser_Node_Expr_StaticCall' => 'PhpParser\Node\Expr\StaticCall',
+        'PHPParser_Node_Expr_StaticPropertyFetch' => 'PhpParser\Node\Expr\StaticPropertyFetch',
+        'PHPParser_Node_Expr_Ternary' => 'PhpParser\Node\Expr\Ternary',
+        'PHPParser_Node_Expr_UnaryMinus' => 'PhpParser\Node\Expr\UnaryMinus',
+        'PHPParser_Node_Expr_UnaryPlus' => 'PhpParser\Node\Expr\UnaryPlus',
+        'PHPParser_Node_Expr_Variable' => 'PhpParser\Node\Expr\Variable',
+        'PHPParser_Node_Expr_Yield' => 'PhpParser\Node\Expr\Yield_',
+
+        'PHPParser_Node_Scalar_ClassConst' => 'PhpParser\Node\Scalar\MagicConst\Class_',
+        'PHPParser_Node_Scalar_DirConst' => 'PhpParser\Node\Scalar\MagicConst\Dir',
+        'PHPParser_Node_Scalar_FileConst' => 'PhpParser\Node\Scalar\MagicConst\File',
+        'PHPParser_Node_Scalar_FuncConst' => 'PhpParser\Node\Scalar\MagicConst\Function_',
+        'PHPParser_Node_Scalar_LineConst' => 'PhpParser\Node\Scalar\MagicConst\Line',
+        'PHPParser_Node_Scalar_MethodConst' => 'PhpParser\Node\Scalar\MagicConst\Method',
+        'PHPParser_Node_Scalar_NSConst' => 'PhpParser\Node\Scalar\MagicConst\Namespace_',
+        'PHPParser_Node_Scalar_TraitConst' => 'PhpParser\Node\Scalar\MagicConst\Trait_',
+
+        'PHPParser_Node_Scalar_DNumber' => 'PhpParser\Node\Scalar\DNumber',
+        'PHPParser_Node_Scalar_Encapsed' => 'PhpParser\Node\Scalar\Encapsed',
+        'PHPParser_Node_Scalar_LNumber' => 'PhpParser\Node\Scalar\LNumber',
+        'PHPParser_Node_Scalar_String' => 'PhpParser\Node\Scalar\String_',
+    );
+}
+
+class_alias('PhpParser\Autoloader', 'PHPParser_Autoloader');

vendor/nikic/php-parser/lib/PhpParser/Builder.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace PhpParser;
+
+interface Builder
+{
+    /**
+     * Returns the built node.
+     *
+     * @return Node The built node
+     */
+    public function getNode();
+}

vendor/nikic/php-parser/lib/PhpParser/Builder/Class_.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
+
+class Class_ extends Declaration
+{
+    protected $name;
+
+    protected $extends = null;
+    protected $implements = array();
+    protected $type = 0;
+
+    protected $uses = array();
+    protected $constants = array();
+    protected $properties = array();
+    protected $methods = array();
+
+    /**
+     * Creates a class builder.
+     *
+     * @param string $name Name of the class
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+
+    /**
+     * Extends a class.
+     *
+     * @param Name|string $class Name of class to extend
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function extend($class) {
+        $this->extends = $this->normalizeName($class);
+
+        return $this;
+    }
+
+    /**
+     * Implements one or more interfaces.
+     *
+     * @param Name|string $interface Name of interface to implement
+     * @param Name|string $...       More interfaces to implement
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function implement() {
+        foreach (func_get_args() as $interface) {
+            $this->implements[] = $this->normalizeName($interface);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Makes the class abstract.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeAbstract() {
+        $this->setModifier(Stmt\Class_::MODIFIER_ABSTRACT);
+
+        return $this;
+    }
+
+    /**
+     * Makes the class final.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeFinal() {
+        $this->setModifier(Stmt\Class_::MODIFIER_FINAL);
+
+        return $this;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param Stmt|PhpParser\Builder $stmt The statement to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addStmt($stmt) {
+        $stmt = $this->normalizeNode($stmt);
+
+        $targets = array(
+            'Stmt_TraitUse'    => &$this->uses,
+            'Stmt_ClassConst'  => &$this->constants,
+            'Stmt_Property'    => &$this->properties,
+            'Stmt_ClassMethod' => &$this->methods,
+        );
+
+        $type = $stmt->getType();
+        if (!isset($targets[$type])) {
+            throw new \LogicException(sprintf('Unexpected node of type "%s"', $type));
+        }
+
+        $targets[$type][] = $stmt;
+
+        return $this;
+    }
+
+    /**
+     * Returns the built class node.
+     *
+     * @return Stmt\Class_ The built class node
+     */
+    public function getNode() {
+        return new Stmt\Class_($this->name, array(
+            'type' => $this->type,
+            'extends' => $this->extends,
+            'implements' => $this->implements,
+            'stmts' => array_merge($this->uses, $this->constants, $this->properties, $this->methods),
+        ), $this->attributes);
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Builder/Declaration.php

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

vendor/nikic/php-parser/lib/PhpParser/Builder/FunctionLike.php

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

vendor/nikic/php-parser/lib/PhpParser/Builder/Function_.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+
+class Function_ extends FunctionLike
+{
+    protected $name;
+    protected $stmts = array();
+
+    /**
+     * Creates a function builder.
+     *
+     * @param string $name Name of the function
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param Node|PhpParser\Builder $stmt The statement to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addStmt($stmt) {
+        $this->stmts[] = $this->normalizeNode($stmt);
+
+        return $this;
+    }
+
+    /**
+     * Returns the built function node.
+     *
+     * @return Stmt\Function_ The built function node
+     */
+    public function getNode() {
+        return new Stmt\Function_($this->name, array(
+            'byRef'  => $this->returnByRef,
+            'params' => $this->params,
+            'stmts'  => $this->stmts,
+        ), $this->attributes);
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Builder/Interface_.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
+
+class Interface_ extends Declaration
+{
+    protected $name;
+    protected $extends = array();
+    protected $constants = array();
+    protected $methods = array();
+
+    /**
+     * Creates an interface builder.
+     *
+     * @param string $name Name of the interface
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+
+    /**
+     * Extends one or more interfaces.
+     *
+     * @param Name|string $interface Name of interface to extend
+     * @param Name|string $...       More interfaces to extend
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function extend() {
+        foreach (func_get_args() as $interface) {
+            $this->extends[] = $this->normalizeName($interface);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param Stmt|PhpParser\Builder $stmt The statement to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addStmt($stmt) {
+        $stmt = $this->normalizeNode($stmt);
+
+        $type = $stmt->getType();
+        switch ($type) {
+            case 'Stmt_ClassConst':
+                $this->constants[] = $stmt;
+                break;
+
+            case 'Stmt_ClassMethod':
+                // we erase all statements in the body of an interface method
+                $stmt->stmts = null;
+                $this->methods[] = $stmt;
+                break;
+
+            default:
+                throw new \LogicException(sprintf('Unexpected node of type "%s"', $type));
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns the built interface node.
+     *
+     * @return Stmt\Interface_ The built interface node
+     */
+    public function getNode() {
+        return new Stmt\Interface_($this->name, array(
+            'extends' => $this->extends,
+            'stmts' => array_merge($this->constants, $this->methods),
+        ), $this->attributes);
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Builder/Method.php

@@ -0,0 +1,125 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node;
+use PhpParser\Node\Stmt;
+
+class Method extends FunctionLike
+{
+    protected $name;
+    protected $type = 0;
+    protected $stmts = array();
+
+    /**
+     * Creates a method builder.
+     *
+     * @param string $name Name of the method
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+
+    /**
+     * Makes the method public.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makePublic() {
+        $this->setModifier(Stmt\Class_::MODIFIER_PUBLIC);
+
+        return $this;
+    }
+
+    /**
+     * Makes the method protected.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeProtected() {
+        $this->setModifier(Stmt\Class_::MODIFIER_PROTECTED);
+
+        return $this;
+    }
+
+    /**
+     * Makes the method private.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makePrivate() {
+        $this->setModifier(Stmt\Class_::MODIFIER_PRIVATE);
+
+        return $this;
+    }
+
+    /**
+     * Makes the method static.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeStatic() {
+        $this->setModifier(Stmt\Class_::MODIFIER_STATIC);
+
+        return $this;
+    }
+
+    /**
+     * Makes the method abstract.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeAbstract() {
+        if (!empty($this->stmts)) {
+            throw new \LogicException('Cannot make method with statements abstract');
+        }
+
+        $this->setModifier(Stmt\Class_::MODIFIER_ABSTRACT);
+        $this->stmts = null; // abstract methods don't have statements
+
+        return $this;
+    }
+
+    /**
+     * Makes the method final.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeFinal() {
+        $this->setModifier(Stmt\Class_::MODIFIER_FINAL);
+
+        return $this;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param Node|PhpParser\Builder $stmt The statement to add
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function addStmt($stmt) {
+        if (null === $this->stmts) {
+            throw new \LogicException('Cannot add statements to an abstract method');
+        }
+
+        $this->stmts[] = $this->normalizeNode($stmt);
+
+        return $this;
+    }
+
+    /**
+     * Returns the built method node.
+     *
+     * @return Stmt\ClassMethod The built method node
+     */
+    public function getNode() {
+        return new Stmt\ClassMethod($this->name, array(
+            'type'   => $this->type,
+            'byRef'  => $this->returnByRef,
+            'params' => $this->params,
+            'stmts'  => $this->stmts,
+        ), $this->attributes);
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Builder/Namespace_.php

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

vendor/nikic/php-parser/lib/PhpParser/Builder/Param.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node;
+
+class Param extends PhpParser\BuilderAbstract
+{
+    protected $name;
+
+    protected $default = null;
+    protected $type = null;
+    protected $byRef = false;
+
+    /**
+     * Creates a parameter builder.
+     *
+     * @param string $name Name of the parameter
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+
+    /**
+     * Sets default value for the parameter.
+     *
+     * @param mixed $value Default value to use
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function setDefault($value) {
+        $this->default = $this->normalizeValue($value);
+
+        return $this;
+    }
+
+    /**
+     * Sets type hint for the parameter.
+     *
+     * @param string|Node\Name $type Type hint to use
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function setTypeHint($type) {
+        if ($type === 'array' || $type === 'callable') {
+            $this->type = $type;
+        } else {
+            $this->type = $this->normalizeName($type);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Make the parameter accept the value by reference.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeByRef() {
+        $this->byRef = true;
+
+        return $this;
+    }
+
+    /**
+     * Returns the built parameter node.
+     *
+     * @return Node\Param The built parameter node
+     */
+    public function getNode() {
+        return new Node\Param(
+            $this->name, $this->default, $this->type, $this->byRef
+        );
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Builder/Property.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace PhpParser\Builder;
+
+use PhpParser;
+use PhpParser\Node\Stmt;
+
+class Property extends PhpParser\BuilderAbstract
+{
+    protected $name;
+
+    protected $type = 0;
+    protected $default = null;
+    protected $attributes = array();
+
+    /**
+     * Creates a property builder.
+     *
+     * @param string $name Name of the property
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+
+    /**
+     * Makes the property public.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makePublic() {
+        $this->setModifier(Stmt\Class_::MODIFIER_PUBLIC);
+
+        return $this;
+    }
+
+    /**
+     * Makes the property protected.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeProtected() {
+        $this->setModifier(Stmt\Class_::MODIFIER_PROTECTED);
+
+        return $this;
+    }
+
+    /**
+     * Makes the property private.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makePrivate() {
+        $this->setModifier(Stmt\Class_::MODIFIER_PRIVATE);
+
+        return $this;
+    }
+
+    /**
+     * Makes the property static.
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function makeStatic() {
+        $this->setModifier(Stmt\Class_::MODIFIER_STATIC);
+
+        return $this;
+    }
+
+    /**
+     * Sets default value for the property.
+     *
+     * @param mixed $value Default value to use
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function setDefault($value) {
+        $this->default = $this->normalizeValue($value);
+
+        return $this;
+    }
+
+    /**
+     * Sets doc comment for the property.
+     *
+     * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
+     *
+     * @return $this The builder instance (for fluid interface)
+     */
+    public function setDocComment($docComment) {
+        $this->attributes = array(
+            'comments' => array($this->normalizeDocComment($docComment))
+        );
+
+        return $this;
+    }
+
+    /**
+     * Returns the built class node.
+     *
+     * @return Stmt\Property The built property node
+     */
+    public function getNode() {
+        return new Stmt\Property(
+            $this->type !== 0 ? $this->type : Stmt\Class_::MODIFIER_PUBLIC,
+            array(
+                new Stmt\PropertyProperty($this->name, $this->default)
+            ),
+            $this->attributes
+        );
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Builder/Trait_.php

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

vendor/nikic/php-parser/lib/PhpParser/Builder/Use_.php

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

vendor/nikic/php-parser/lib/PhpParser/BuilderAbstract.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace PhpParser;
+
+use PhpParser\Node\Name;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Scalar;
+use PhpParser\Comment;
+
+abstract class BuilderAbstract implements Builder {
+    /**
+     * Normalizes a node: Converts builder objects to nodes.
+     *
+     * @param Node|Builder $node The node to normalize
+     *
+     * @return Node The normalized node
+     */
+    protected function normalizeNode($node) {
+        if ($node instanceof Builder) {
+            return $node->getNode();
+        } elseif ($node instanceof Node) {
+            return $node;
+        }
+
+        throw new \LogicException('Expected node or builder object');
+    }
+
+    /**
+     * Normalizes a name: Converts plain string names to PhpParser\Node\Name.
+     *
+     * @param Name|string $name The name to normalize
+     *
+     * @return Name The normalized name
+     */
+    protected function normalizeName($name) {
+        if ($name instanceof Name) {
+            return $name;
+        } elseif (is_string($name)) {
+            if (!$name) {
+                throw new \LogicException('Name cannot be empty');
+            }
+
+            if ($name[0] == '\\') {
+                return new Name\FullyQualified(substr($name, 1));
+            } elseif (0 === strpos($name, 'namespace\\')) {
+                return new Name\Relative(substr($name, strlen('namespace\\')));
+            } else {
+                return new Name($name);
+            }
+        }
+
+        throw new \LogicException('Name must be a string or an instance of PhpParser\Node\Name');
+    }
+
+    /**
+     * Normalizes a value: Converts nulls, booleans, integers,
+     * floats, strings and arrays into their respective nodes
+     *
+     * @param mixed $value The value to normalize
+     *
+     * @return Expr The normalized value
+     */
+    protected function normalizeValue($value) {
+        if ($value instanceof Node) {
+            return $value;
+        } elseif (is_null($value)) {
+            return new Expr\ConstFetch(
+                new Name('null')
+            );
+        } elseif (is_bool($value)) {
+            return new Expr\ConstFetch(
+                new Name($value ? 'true' : 'false')
+            );
+        } elseif (is_int($value)) {
+            return new Scalar\LNumber($value);
+        } elseif (is_float($value)) {
+            return new Scalar\DNumber($value);
+        } elseif (is_string($value)) {
+            return new Scalar\String_($value);
+        } elseif (is_array($value)) {
+            $items = array();
+            $lastKey = -1;
+            foreach ($value as $itemKey => $itemValue) {
+                // for consecutive, numeric keys don't generate keys
+                if (null !== $lastKey && ++$lastKey === $itemKey) {
+                    $items[] = new Expr\ArrayItem(
+                        $this->normalizeValue($itemValue)
+                    );
+                } else {
+                    $lastKey = null;
+                    $items[] = new Expr\ArrayItem(
+                        $this->normalizeValue($itemValue),
+                        $this->normalizeValue($itemKey)
+                    );
+                }
+            }
+
+            return new Expr\Array_($items);
+        } else {
+            throw new \LogicException('Invalid value');
+        }
+    }
+
+    /**
+     * Normalizes a doc comment: Converts plain strings to PhpParser\Comment\Doc.
+     *
+     * @param Comment\Doc|string $docComment The doc comment to normalize
+     *
+     * @return Comment\Doc The normalized doc comment
+     */
+    protected function normalizeDocComment($docComment) {
+        if ($docComment instanceof Comment\Doc) {
+            return $docComment;
+        } else if (is_string($docComment)) {
+            return new Comment\Doc($docComment);
+        } else {
+            throw new \LogicException('Doc comment must be a string or an instance of PhpParser\Comment\Doc');
+        }
+    }
+
+    /**
+     * Sets a modifier in the $this->type property.
+     *
+     * @param int $modifier Modifier to set
+     */
+    protected function setModifier($modifier) {
+        Stmt\Class_::verifyModifier($this->type, $modifier);
+        $this->type |= $modifier;
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php

@@ -0,0 +1,127 @@
+<?php
+
+namespace PhpParser;
+
+use PhpParser\Builder;
+use PhpParser\Node\Stmt\Use_;
+
+/**
+ * The following methods use reserved keywords, so their implementation is defined with an underscore and made available
+ * with the reserved name through __call() magic.
+ *
+ * @method Builder\Namespace_ namespace(string $name) Creates a namespace builder.
+ * @method Builder\Class_     class(string $name)     Creates a class builder.
+ * @method Builder\Interface_ interface(string $name) Creates an interface builder.
+ * @method Builder\Trait_     trait(string $name)     Creates a trait builder.
+ * @method Builder\Function_  function(string $name)  Creates a function builder.
+ * @method Builder\Use_       use(string $name)       Creates a namespace/class use builder.
+ */
+class BuilderFactory
+{
+    /**
+     * Creates a namespace builder.
+     * 
+     * @param null|string|Node\Name $name Name of the namespace
+     *
+     * @return Builder\Namespace_ The created namespace builder
+     */
+    protected function _namespace($name) {
+        return new Builder\Namespace_($name);
+    }
+
+    /**
+     * Creates a class builder.
+     *
+     * @param string $name Name of the class
+     *
+     * @return Builder\Class_ The created class builder
+     */
+    protected function _class($name) {
+        return new Builder\Class_($name);
+    }
+
+    /**
+     * Creates an interface builder.
+     *
+     * @param string $name Name of the interface
+     *
+     * @return Builder\Interface_ The created interface builder
+     */
+    protected function _interface($name) {
+        return new Builder\Interface_($name);
+    }
+
+    /**
+     * Creates a trait builder.
+     *
+     * @param string $name Name of the trait
+     *
+     * @return Builder\Trait_ The created trait builder
+     */
+    protected function _trait($name) {
+        return new Builder\Trait_($name);
+    }
+
+    /**
+     * Creates a method builder.
+     *
+     * @param string $name Name of the method
+     *
+     * @return Builder\Method The created method builder
+     */
+    public function method($name) {
+        return new Builder\Method($name);
+    }
+
+    /**
+     * Creates a parameter builder.
+     *
+     * @param string $name Name of the parameter
+     *
+     * @return Builder\Param The created parameter builder
+     */
+    public function param($name) {
+        return new Builder\Param($name);
+    }
+
+    /**
+     * Creates a property builder.
+     *
+     * @param string $name Name of the property
+     *
+     * @return Builder\Property The created property builder
+     */
+    public function property($name) {
+        return new Builder\Property($name);
+    }
+
+    /**
+     * Creates a function builder.
+     *
+     * @param string $name Name of the function
+     *
+     * @return Builder\Function_ The created function builder
+     */
+    protected function _function($name) {
+        return new Builder\Function_($name);
+    }
+
+    /**
+     * Creates a namespace/class use builder.
+     *
+     * @param string|Node\Name Name to alias
+     *
+     * @return Builder\Use_ The create use builder
+     */
+    protected function _use($name) {
+        return new Builder\Use_($name, Use_::TYPE_NORMAL);
+    }
+
+    public function __call($name, array $args) {
+        if (method_exists($this, '_' . $name)) {
+            return call_user_func_array(array($this, '_' . $name), $args);
+        }
+
+        throw new \LogicException(sprintf('Method "%s" does not exist', $name));
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Comment.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace PhpParser;
+
+class Comment
+{
+    protected $text;
+    protected $line;
+
+    /**
+     * Constructs a comment node.
+     *
+     * @param string $text Comment text (including comment delimiters like /*)
+     * @param int    $line Line number the comment started on
+     */
+    public function __construct($text, $line = -1) {
+        $this->text = $text;
+        $this->line = $line;
+    }
+
+    /**
+     * Gets the comment text.
+     *
+     * @return string The comment text (including comment delimiters like /*)
+     */
+    public function getText() {
+        return $this->text;
+    }
+
+    /**
+     * Sets the comment text.
+     *
+     * @param string $text The comment text (including comment delimiters like /*)
+     */
+    public function setText($text) {
+        $this->text = $text;
+    }
+
+    /**
+     * Gets the line number the comment started on.
+     *
+     * @return int Line number
+     */
+    public function getLine() {
+        return $this->line;
+    }
+
+    /**
+     * Sets the line number the comment started on.
+     *
+     * @param int $line Line number
+     */
+    public function setLine($line) {
+        $this->line = $line;
+    }
+
+    /**
+     * Gets the comment text.
+     *
+     * @return string The comment text (including comment delimiters like /*)
+     */
+    public function __toString() {
+        return $this->text;
+    }
+
+    /**
+     * Gets the reformatted comment text.
+     *
+     * "Reformatted" here means that we try to clean up the whitespace at the
+     * starts of the lines. This is necessary because we receive the comments
+     * without trailing whitespace on the first line, but with trailing whitespace
+     * on all subsequent lines.
+     *
+     * @return mixed|string
+     */
+    public function getReformattedText() {
+        $text = trim($this->text);
+        if (false === strpos($text, "\n")) {
+            // Single line comments don't need further processing
+            return $text;
+        } elseif (preg_match('((*BSR_ANYCRLF)(*ANYCRLF)^.*(?:\R\s+\*.*)+$)', $text)) {
+            // Multi line comment of the type
+            //
+            //     /*
+            //      * Some text.
+            //      * Some more text.
+            //      */
+            //
+            // is handled by replacing the whitespace sequences before the * by a single space
+            return preg_replace('(^\s+\*)m', ' *', $this->text);
+        } elseif (preg_match('(^/\*\*?\s*[\r\n])', $text) && preg_match('(\n(\s*)\*/$)', $text, $matches)) {
+            // Multi line comment of the type
+            //
+            //    /*
+            //        Some text.
+            //        Some more text.
+            //    */
+            //
+            // is handled by removing the whitespace sequence on the line before the closing
+            // */ on all lines. So if the last line is "    */", then "    " is removed at the
+            // start of all lines.
+            return preg_replace('(^' . preg_quote($matches[1]) . ')m', '', $text);
+        } elseif (preg_match('(^/\*\*?\s*(?!\s))', $text, $matches)) {
+            // Multi line comment of the type
+            //
+            //     /* Some text.
+            //        Some more text.
+            //        Even more text. */
+            //
+            // is handled by taking the length of the "/* " segment and leaving only that
+            // many space characters before the lines. Thus in the above example only three
+            // space characters are left at the start of every line.
+            return preg_replace('(^\s*(?= {' . strlen($matches[0]) . '}(?!\s)))m', '', $text);
+        }
+
+        // No idea how to format this comment, so simply return as is
+        return $text;
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Comment/Doc.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace PhpParser\Comment;
+
+class Doc extends \PhpParser\Comment
+{
+}

vendor/nikic/php-parser/lib/PhpParser/Error.php

@@ -0,0 +1,158 @@
+<?php
+
+namespace PhpParser;
+
+class Error extends \RuntimeException
+{
+    protected $rawMessage;
+    protected $attributes;
+
+    /**
+     * Creates an Exception signifying a parse error.
+     *
+     * @param string    $message    Error message
+     * @param array|int $attributes Attributes of node/token where error occurred
+     *                              (or start line of error -- deprecated)
+     */
+    public function __construct($message, $attributes = array()) {
+        $this->rawMessage = (string) $message;
+        if (is_array($attributes)) {
+            $this->attributes = $attributes;
+        } else {
+            $this->attributes = array('startLine' => $attributes);
+        }
+        $this->updateMessage();
+    }
+
+    /**
+     * Gets the error message
+     *
+     * @return string Error message
+     */
+    public function getRawMessage() {
+        return $this->rawMessage;
+    }
+
+    /**
+     * Gets the line the error starts in.
+     *
+     * @return int Error start line
+     */
+    public function getStartLine() {
+        return isset($this->attributes['startLine']) ? $this->attributes['startLine'] : -1;
+    }
+
+    /**
+     * Gets the line the error ends in.
+     *
+     * @return int Error end line
+     */
+    public function getEndLine() {
+        return isset($this->attributes['endLine']) ? $this->attributes['endLine'] : -1;
+    }
+
+
+    /**
+     * Gets the attributes of the node/token the error occurred at.
+     *
+     * @return array
+     */
+    public function getAttributes() {
+        return $this->attributes;
+    }
+
+    /**
+     * Sets the line of the PHP file the error occurred in.
+     *
+     * @param string $message Error message
+     */
+    public function setRawMessage($message) {
+        $this->rawMessage = (string) $message;
+        $this->updateMessage();
+    }
+
+    /**
+     * Sets the line the error starts in.
+     *
+     * @param int $line Error start line
+     */
+    public function setStartLine($line) {
+        $this->attributes['startLine'] = (int) $line;
+        $this->updateMessage();
+    }
+
+    /**
+     * Returns whether the error has start and end column information.
+     *
+     * For column information enable the startFilePos and endFilePos in the lexer options.
+     *
+     * @return bool
+     */
+    public function hasColumnInfo() {
+        return isset($this->attributes['startFilePos']) && isset($this->attributes['endFilePos']);
+    }
+
+    /**
+     * Gets the start column (1-based) into the line where the error started.
+     *
+     * @param string $code Source code of the file
+     * @return int
+     */
+    public function getStartColumn($code) {
+        if (!$this->hasColumnInfo()) {
+            throw new \RuntimeException('Error does not have column information');
+        }
+
+        return $this->toColumn($code, $this->attributes['startFilePos']);
+    }
+
+    /**
+     * Gets the end column (1-based) into the line where the error ended.
+     *
+     * @param string $code Source code of the file
+     * @return int
+     */
+    public function getEndColumn($code) {
+        if (!$this->hasColumnInfo()) {
+            throw new \RuntimeException('Error does not have column information');
+        }
+
+        return $this->toColumn($code, $this->attributes['endFilePos']);
+    }
+
+    private function toColumn($code, $pos) {
+        if ($pos > strlen($code)) {
+            throw new \RuntimeException('Invalid position information');
+        }
+
+        $lineStartPos = strrpos($code, "\n", $pos - strlen($code));
+        if (false === $lineStartPos) {
+            $lineStartPos = -1;
+        }
+
+        return $pos - $lineStartPos;
+    }
+
+    /**
+     * Updates the exception message after a change to rawMessage or rawLine.
+     */
+    protected function updateMessage() {
+        $this->message = $this->rawMessage;
+
+        if (-1 === $this->getStartLine()) {
+            $this->message .= ' on unknown line';
+        } else {
+            $this->message .= ' on line ' . $this->getStartLine();
+        }
+    }
+
+    /** @deprecated Use getStartLine() instead */
+    public function getRawLine() {
+        return $this->getStartLine();
+    }
+
+    /** @deprecated Use setStartLine() instead */
+    public function setRawLine($line) {
+        $this->setStartLine($line);
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Lexer.php

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

vendor/nikic/php-parser/lib/PhpParser/Lexer/Emulative.php

@@ -0,0 +1,231 @@
+<?php
+
+namespace PhpParser\Lexer;
+
+use PhpParser\Parser;
+
+/**
+ * ATTENTION: This code is WRITE-ONLY. Do not try to read it.
+ */
+class Emulative extends \PhpParser\Lexer
+{
+    protected $newKeywords;
+    protected $inObjectAccess;
+
+    const T_ELLIPSIS   = 1001;
+    const T_POW        = 1002;
+    const T_POW_EQUAL  = 1003;
+    const T_COALESCE   = 1004;
+    const T_SPACESHIP  = 1005;
+    const T_YIELD_FROM = 1006;
+
+    const PHP_7_0 = '7.0.0dev';
+    const PHP_5_6 = '5.6.0rc1';
+    const PHP_5_5 = '5.5.0beta1';
+    const PHP_5_4 = '5.4.0beta1';
+
+    public function __construct(array $options = array()) {
+        parent::__construct($options);
+
+        $newKeywordsPerVersion = array(
+            self::PHP_5_5 => array(
+                'finally'       => Parser::T_FINALLY,
+                'yield'         => Parser::T_YIELD,
+            ),
+            self::PHP_5_4 => array(
+                'callable'      => Parser::T_CALLABLE,
+                'insteadof'     => Parser::T_INSTEADOF,
+                'trait'         => Parser::T_TRAIT,
+                '__trait__'     => Parser::T_TRAIT_C,
+            ),
+        );
+
+        $this->newKeywords = array();
+        foreach ($newKeywordsPerVersion as $version => $newKeywords) {
+            if (version_compare(PHP_VERSION, $version, '>=')) {
+                break;
+            }
+
+            $this->newKeywords += $newKeywords;
+        }
+
+        if (version_compare(PHP_VERSION, self::PHP_7_0, '>=')) {
+            return;
+        }
+        $this->tokenMap[self::T_COALESCE] = Parser::T_COALESCE;
+        $this->tokenMap[self::T_SPACESHIP] = Parser::T_SPACESHIP;
+        $this->tokenMap[self::T_YIELD_FROM] = Parser::T_YIELD_FROM;
+
+        if (version_compare(PHP_VERSION, self::PHP_5_6, '>=')) {
+            return;
+        }
+        $this->tokenMap[self::T_ELLIPSIS]  = Parser::T_ELLIPSIS;
+        $this->tokenMap[self::T_POW]       = Parser::T_POW;
+        $this->tokenMap[self::T_POW_EQUAL] = Parser::T_POW_EQUAL;
+    }
+
+    public function startLexing($code) {
+        $this->inObjectAccess = false;
+
+        $preprocessedCode = $this->preprocessCode($code);
+        parent::startLexing($preprocessedCode);
+        if ($preprocessedCode !== $code) {
+            $this->postprocessTokens();
+        }
+
+        // Set code property back to the original code, so __halt_compiler()
+        // handling and (start|end)FilePos attributes use the correct offsets
+        $this->code = $code;
+    }
+
+    /*
+     * Replaces new features in the code by ~__EMU__{NAME}__{DATA}__~ sequences.
+     * ~LABEL~ is never valid PHP code, that's why we can (to some degree) safely
+     * use it here.
+     * Later when preprocessing the tokens these sequences will either be replaced
+     * by real tokens or replaced with their original content (e.g. if they occurred
+     * inside a string, i.e. a place where they don't have a special meaning).
+     */
+    protected function preprocessCode($code) {
+        if (version_compare(PHP_VERSION, self::PHP_7_0, '>=')) {
+            return $code;
+        }
+
+        $code = str_replace('??', '~__EMU__COALESCE__~', $code);
+        $code = str_replace('<=>', '~__EMU__SPACESHIP__~', $code);
+        $code = preg_replace_callback('(yield[ \n\r\t]+from)', function($matches) {
+            // Encoding $0 in order to preserve exact whitespace
+            return '~__EMU__YIELDFROM__' . bin2hex($matches[0]) . '__~';
+        }, $code);
+
+        if (version_compare(PHP_VERSION, self::PHP_5_6, '>=')) {
+            return $code;
+        }
+
+        $code = str_replace('...', '~__EMU__ELLIPSIS__~', $code);
+        $code = preg_replace('((?<!/)\*\*=)', '~__EMU__POWEQUAL__~', $code);
+        $code = preg_replace('((?<!/)\*\*(?!/))', '~__EMU__POW__~', $code);
+
+        if (version_compare(PHP_VERSION, self::PHP_5_4, '>=')) {
+            return $code;
+        }
+
+        // binary notation (0b010101101001...)
+        return preg_replace('(\b0b[01]+\b)', '~__EMU__BINARY__$0__~', $code);
+    }
+
+    /*
+     * 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 of form ~LABEL~,
+            // then match the __EMU__... sequence.
+            if ('~' === $this->tokens[$i]
+                && isset($this->tokens[$i + 2])
+                && '~' === $this->tokens[$i + 2]
+                && T_STRING === $this->tokens[$i + 1][0]
+                && preg_match('(^__EMU__([A-Z]++)__(?:([A-Za-z0-9]++)__)?$)', $this->tokens[$i + 1][1], $matches)
+            ) {
+                if ('BINARY' === $matches[1]) {
+                    // the binary number can either be an integer or a double, so return a LNUMBER
+                    // or DNUMBER respectively
+                    $isInt = is_int(bindec($matches[2]));
+                    $replace = array(
+                        array($isInt ? T_LNUMBER : T_DNUMBER, $matches[2], $this->tokens[$i + 1][2])
+                    );
+                } else if ('ELLIPSIS' === $matches[1]) {
+                    $replace = array(
+                        array(self::T_ELLIPSIS, '...', $this->tokens[$i + 1][2])
+                    );
+                } else if ('POW' === $matches[1]) {
+                    $replace = array(
+                        array(self::T_POW, '**', $this->tokens[$i + 1][2])
+                    );
+                } else if ('POWEQUAL' === $matches[1]) {
+                    $replace = array(
+                        array(self::T_POW_EQUAL, '**=', $this->tokens[$i + 1][2])
+                    );
+                } else if ('COALESCE' === $matches[1]) {
+                    $replace = array(
+                        array(self::T_COALESCE, '??', $this->tokens[$i + 1][2])
+                    );
+                } else if ('SPACESHIP' === $matches[1]) {
+                    $replace = array(
+                        array(self::T_SPACESHIP, '<=>', $this->tokens[$i + 1][2]),
+                    );
+                } else if ('YIELDFROM' === $matches[1]) {
+                    $content = $this->hex2bin($matches[2]);
+                    $replace = array(
+                        array(self::T_YIELD_FROM, $content, $this->tokens[$i + 1][2] - substr_count($content, "\n"))
+                    );
+                } else {
+                    throw new \RuntimeException('Invalid __EMU__ sequence');
+                }
+
+                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];
+        } else if ('ELLIPSIS' === $matches[1]) {
+            return '...';
+        } else if ('POW' === $matches[1]) {
+            return '**';
+        } else if ('POWEQUAL' === $matches[1]) {
+            return '**=';
+        } else if ('COALESCE' === $matches[1]) {
+            return '??';
+        } else if ('SPACESHIP' === $matches[1]) {
+            return '<=>';
+        } else if ('YIELDFROM' === $matches[1]) {
+            return $this->hex2bin($matches[2]);
+        } else {
+            return $matches[0];
+        }
+    }
+
+    private function hex2bin($str) {
+        // TODO Drop when removing support for PHP 5.3
+        return pack('H*', $str);
+    }
+
+    public function getNextToken(&$value = null, &$startAttributes = null, &$endAttributes = null) {
+        $token = parent::getNextToken($value, $startAttributes, $endAttributes);
+
+        // 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 (Parser::T_STRING === $token && !$this->inObjectAccess) {
+            if (isset($this->newKeywords[strtolower($value)])) {
+                return $this->newKeywords[strtolower($value)];
+            }
+        } else {
+            // keep track of whether we currently are in an object access (after ->)
+            $this->inObjectAccess = Parser::T_OBJECT_OPERATOR === $token;
+        }
+
+        return $token;
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Node.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace PhpParser;
+
+interface Node
+{
+    /**
+     * Gets the type of the node.
+     *
+     * @return string Type of the node
+     */
+    public function getType();
+
+    /**
+     * Gets the names of the sub nodes.
+     *
+     * @return array Names of sub nodes
+     */
+    public function getSubNodeNames();
+
+    /**
+     * Gets line the node started in.
+     *
+     * @return int Line
+     */
+    public function getLine();
+
+    /**
+     * Sets line the node started in.
+     *
+     * @param int $line Line
+     */
+    public function setLine($line);
+
+    /**
+     * Gets the doc comment of the node.
+     *
+     * The doc comment has to be the last comment associated with the node.
+     *
+     * @return null|Comment\Doc Doc comment object or null
+     */
+    public function getDocComment();
+
+    /**
+     * Sets an attribute on a node.
+     *
+     * @param string $key
+     * @param mixed  $value
+     */
+    public function setAttribute($key, $value);
+
+    /**
+     * Returns whether an attribute exists.
+     *
+     * @param string $key
+     *
+     * @return bool
+     */
+    public function hasAttribute($key);
+
+    /**
+     * Returns the value of an attribute.
+     *
+     * @param string $key
+     * @param mixed  $default
+     *
+     * @return mixed
+     */
+    public function &getAttribute($key, $default = null);
+
+    /**
+     * Returns all attributes for the given node.
+     *
+     * @return array
+     */
+    public function getAttributes();
+}

vendor/nikic/php-parser/lib/PhpParser/Node/Arg.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Const_.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayDimFetch.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayItem.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Array_.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node\Expr;
+
+class Array_ extends Expr
+{
+    /** @var ArrayItem[] Items */
+    public $items;
+
+    /**
+     * Constructs an array node.
+     *
+     * @param ArrayItem[] $items      Items of the array
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct(array $items = array(), array $attributes = array()) {
+        parent::__construct(null, $attributes);
+        $this->items = $items;
+    }
+
+    public function getSubNodeNames() {
+        return array('items');
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Assign.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node\Expr;
+
+/**
+ * @property Expr $var  Variable
+ * @property Expr $expr Expression
+ */
+abstract class AssignOp extends Expr
+{
+    /** @var Expr Variable */
+    public $var;
+    /** @var Expr Expression */
+    public $expr;
+
+    /**
+     * Constructs a compound assignment operation node.
+     *
+     * @param Expr  $var        Variable
+     * @param Expr  $expr       Expression
+     * @param array $attributes Additional attributes
+     */
+    public function __construct(Expr $var, Expr $expr, array $attributes = array()) {
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('var', 'expr');
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseAnd.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseOr.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseXor.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Concat.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Div.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Minus.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Mod.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Mul.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Plus.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Pow.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/ShiftLeft.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/ShiftRight.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignRef.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace PhpParser\Node\Expr;
+
+use PhpParser\Node\Expr;
+
+/**
+ * @property Expr $var  Variable reference is assigned to
+ * @property Expr $expr Variable which is referenced
+ */
+class AssignRef extends Expr
+{
+    /** @var Expr Variable reference is assigned to */
+    public $var;
+    /** @var Expr Variable which is referenced */
+    public $expr;
+
+    /**
+     * Constructs an assignment node.
+     *
+     * @param Expr  $var        Variable
+     * @param Expr  $expr       Expression
+     * @param array $attributes Additional attributes
+     */
+    public function __construct(Expr $var, Expr $expr, array $attributes = array()) {
+        parent::__construct(null, $attributes);
+        $this->var = $var;
+        $this->expr = $expr;
+    }
+
+    public function getSubNodeNames() {
+        return array('var', 'expr');
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseAnd.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseOr.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseXor.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BooleanAnd.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BooleanOr.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Coalesce.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Concat.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Div.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Equal.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Greater.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/GreaterOrEqual.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Identical.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/LogicalAnd.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/LogicalOr.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/LogicalXor.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Minus.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Mod.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Mul.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/NotEqual.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/NotIdentical.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Plus.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Pow.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/ShiftLeft.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/ShiftRight.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Smaller.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/SmallerOrEqual.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Spaceship.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BitwiseNot.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BooleanNot.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Array_.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Bool_.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Double.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Int_.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Object_.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/String_.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Unset_.php

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

vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ClassConstFetch.php

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