the whole shebang

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

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

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

@@ -0,0 +1,11 @@
+<?php
+
+interface PHPParser_Builder
+{
+    /**
+     * Returns the built node.
+     *
+     * @return PHPParser_Node The built node
+     */
+    public function getNode();
+}

vendor/nikic/php-parser/lib/PHPParser/Builder/Class.php

@@ -0,0 +1,137 @@
+<?php
+
+class PHPParser_Builder_Class extends PHPParser_BuilderAbstract
+{
+    protected $name;
+
+    protected $extends;
+    protected $implements;
+    protected $type;
+
+    protected $uses;
+    protected $constants;
+    protected $properties;
+    protected $methods;
+
+    /**
+     * Creates a class builder.
+     *
+     * @param string $name Name of the class
+     */
+    public function __construct($name) {
+        $this->name = $name;
+
+        $this->type = 0;
+        $this->extends = null;
+        $this->implements = array();
+
+        $this->uses = $this->constants = $this->properties = $this->methods = array();
+    }
+
+    /**
+     * Extends a class.
+     *
+     * @param PHPParser_Node_Name|string $class Name of class to extend
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function extend($class) {
+        $this->extends = $this->normalizeName($class);
+
+        return $this;
+    }
+
+    /**
+     * Implements one or more interfaces.
+     *
+     * @param PHPParser_Node_Name|string $interface Name of interface to implement
+     * @param PHPParser_Node_Name|string $...       More interfaces to implement
+     *
+     * @return PHPParser_Builder_Class 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 PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function makeAbstract() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT);
+
+        return $this;
+    }
+
+    /**
+     * Makes the class final.
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function makeFinal() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_FINAL);
+
+        return $this;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param PHPParser_Node_Stmt|PHPParser_Builder $stmt The statement to add
+     *
+     * @return PHPParser_Builder_Class 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;
+    }
+
+    /**
+     * Adds multiple statements.
+     *
+     * @param array $stmts The statements to add
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function addStmts(array $stmts) {
+        foreach ($stmts as $stmt) {
+            $this->addStmt($stmt);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns the built class node.
+     *
+     * @return PHPParser_Node_Stmt_Class The built class node
+     */
+    public function getNode() {
+        return new PHPParser_Node_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),
+        ));
+    }
+}

vendor/nikic/php-parser/lib/PHPParser/Builder/Function.php

@@ -0,0 +1,109 @@
+<?php
+
+class PHPParser_Builder_Function extends PHPParser_BuilderAbstract
+{
+    protected $name;
+
+    protected $returnByRef;
+    protected $params;
+    protected $stmts;
+
+    /**
+     * Creates a function builder.
+     *
+     * @param string $name Name of the function
+     */
+    public function __construct($name) {
+        $this->name = $name;
+
+        $this->returnByRef = false;
+        $this->params = array();
+        $this->stmts = array();
+    }
+
+    /**
+     * Make the function return by reference.
+     *
+     * @return PHPParser_Builder_Function The builder instance (for fluid interface)
+     */
+    public function makeReturnByRef() {
+        $this->returnByRef = true;
+
+        return $this;
+    }
+
+    /**
+     * Adds a parameter.
+     *
+     * @param PHPParser_Node_Param|PHPParser_Builder_Param $param The parameter to add
+     *
+     * @return PHPParser_Builder_Function The builder instance (for fluid interface)
+     */
+    public function addParam($param) {
+        $param = $this->normalizeNode($param);
+
+        if (!$param instanceof PHPParser_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 PHPParser_Builder_Function The builder instance (for fluid interface)
+     */
+    public function addParams(array $params) {
+        foreach ($params as $param) {
+            $this->addParam($param);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param PHPParser_Node|PHPParser_Builder $stmt The statement to add
+     *
+     * @return PHPParser_Builder_Function 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 PHPParser_Builder_Function The builder instance (for fluid interface)
+     */
+    public function addStmts(array $stmts) {
+        foreach ($stmts as $stmt) {
+            $this->addStmt($stmt);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns the built function node.
+     *
+     * @return PHPParser_Node_Stmt_Function The built function node
+     */
+    public function getNode() {
+        return new PHPParser_Node_Stmt_Function($this->name, array(
+            'byRef'  => $this->returnByRef,
+            'params' => $this->params,
+            'stmts'  => $this->stmts,
+        ));
+    }
+}

vendor/nikic/php-parser/lib/PHPParser/Builder/Interface.php

@@ -0,0 +1,92 @@
+<?php
+
+class PHPParser_Builder_Interface extends PHPParser_BuilderAbstract
+{
+    protected $name;
+    protected $extends;
+    protected $constants;
+    protected $methods;
+
+    /**
+     * Creates an interface builder.
+     *
+     * @param string $name Name of the interface
+     */
+    public function __construct($name) {
+        $this->name = $name;
+        $this->extends = array();
+        $this->constants = $this->methods = array();
+    }
+
+    /**
+     * Extends one or more interfaces.
+     *
+     * @param PHPParser_Node_Name|string $interface Name of interface to extend
+     * @param PHPParser_Node_Name|string $...       More interfaces to extend
+     *
+     * @return PHPParser_Builder_Interface 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 PHPParser_Node_Stmt|PHPParser_Builder $stmt The statement to add
+     *
+     * @return PHPParser_Builder_Interface 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;
+    }
+
+    /**
+     * Adds multiple statements.
+     *
+     * @param array $stmts The statements to add
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function addStmts(array $stmts) {
+        foreach ($stmts as $stmt) {
+            $this->addStmt($stmt);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns the built class node.
+     *
+     * @return PHPParser_Node_Stmt_Interface The built interface node
+     */
+    public function getNode() {
+        return new PHPParser_Node_Stmt_Interface($this->name, array(
+            'extends' => $this->extends,
+            'stmts' => array_merge($this->constants, $this->methods),
+        ));
+    }
+}

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

@@ -0,0 +1,187 @@
+<?php
+
+class PHPParser_Builder_Method extends PHPParser_BuilderAbstract
+{
+    protected $name;
+
+    protected $type;
+    protected $returnByRef;
+    protected $params;
+    protected $stmts;
+
+    /**
+     * Creates a method builder.
+     *
+     * @param string $name Name of the method
+     */
+    public function __construct($name) {
+        $this->name = $name;
+
+        $this->type = 0;
+        $this->returnByRef = false;
+        $this->params = array();
+        $this->stmts = array();
+    }
+
+    /**
+     * Makes the method public.
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function makePublic() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC);
+
+        return $this;
+    }
+
+    /**
+     * Makes the method protected.
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function makeProtected() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED);
+
+        return $this;
+    }
+
+    /**
+     * Makes the method private.
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function makePrivate() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_PRIVATE);
+
+        return $this;
+    }
+
+    /**
+     * Makes the method static.
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function makeStatic() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_STATIC);
+
+        return $this;
+    }
+
+    /**
+     * Makes the method abstract.
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function makeAbstract() {
+        if (!empty($this->stmts)) {
+            throw new LogicException('Cannot make method with statements abstract');
+        }
+
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT);
+        $this->stmts = null; // abstract methods don't have statements
+
+        return $this;
+    }
+
+    /**
+     * Makes the method final.
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function makeFinal() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_FINAL);
+
+        return $this;
+    }
+
+    /**
+     * Make the method return by reference.
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function makeReturnByRef() {
+        $this->returnByRef = true;
+
+        return $this;
+    }
+
+    /**
+     * Adds a parameter.
+     *
+     * @param PHPParser_Node_Param|PHPParser_Builder_Param $param The parameter to add
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function addParam($param) {
+        $param = $this->normalizeNode($param);
+
+        if (!$param instanceof PHPParser_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 PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function addParams(array $params) {
+        foreach ($params as $param) {
+            $this->addParam($param);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param PHPParser_Node|PHPParser_Builder $stmt The statement to add
+     *
+     * @return PHPParser_Builder_Method 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;
+    }
+
+    /**
+     * Adds multiple statements.
+     *
+     * @param array $stmts The statements to add
+     *
+     * @return PHPParser_Builder_Method The builder instance (for fluid interface)
+     */
+    public function addStmts(array $stmts) {
+        foreach ($stmts as $stmt) {
+            $this->addStmt($stmt);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns the built method node.
+     *
+     * @return PHPParser_Node_Stmt_ClassMethod The built method node
+     */
+    public function getNode() {
+        return new PHPParser_Node_Stmt_ClassMethod($this->name, array(
+            'type'   => $this->type !== 0 ? $this->type : PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC,
+            'byRef'  => $this->returnByRef,
+            'params' => $this->params,
+            'stmts'  => $this->stmts,
+        ));
+    }
+}

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

@@ -0,0 +1,75 @@
+<?php
+
+class PHPParser_Builder_Param extends PHPParser_BuilderAbstract
+{
+    protected $name;
+
+    protected $default;
+    protected $type;
+    protected $byRef;
+
+    /**
+     * Creates a parameter builder.
+     *
+     * @param string $name Name of the parameter
+     */
+    public function __construct($name) {
+        $this->name = $name;
+
+        $this->default = null;
+        $this->type = null;
+        $this->byRef = false;
+    }
+
+    /**
+     * Sets default value for the parameter.
+     *
+     * @param mixed $value Default value to use
+     *
+     * @return PHPParser_Builder_Param 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|PHPParser_Node_Name $type Type hint to use
+     *
+     * @return PHPParser_Builder_Param 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 PHPParser_Builder_Param The builder instance (for fluid interface)
+     */
+    public function makeByRef() {
+        $this->byRef = true;
+
+        return $this;
+    }
+
+    /**
+     * Returns the built parameter node.
+     *
+     * @return PHPParser_Node_Param The built parameter node
+     */
+    public function getNode() {
+        return new PHPParser_Node_Param(
+            $this->name, $this->default, $this->type, $this->byRef
+        );
+    }
+}

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

@@ -0,0 +1,92 @@
+<?php
+
+class PHPParser_Builder_Property extends PHPParser_BuilderAbstract
+{
+    protected $name;
+
+    protected $type;
+    protected $default;
+
+    /**
+     * Creates a property builder.
+     *
+     * @param string $name Name of the property
+     */
+    public function __construct($name) {
+        $this->name = $name;
+
+        $this->type = 0;
+        $this->default = null;
+    }
+
+    /**
+     * Makes the property public.
+     *
+     * @return PHPParser_Builder_Property The builder instance (for fluid interface)
+     */
+    public function makePublic() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC);
+
+        return $this;
+    }
+
+    /**
+     * Makes the property protected.
+     *
+     * @return PHPParser_Builder_Property The builder instance (for fluid interface)
+     */
+    public function makeProtected() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED);
+
+        return $this;
+    }
+
+    /**
+     * Makes the property private.
+     *
+     * @return PHPParser_Builder_Property The builder instance (for fluid interface)
+     */
+    public function makePrivate() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_PRIVATE);
+
+        return $this;
+    }
+
+    /**
+     * Makes the property static.
+     *
+     * @return PHPParser_Builder_Property The builder instance (for fluid interface)
+     */
+    public function makeStatic() {
+        $this->setModifier(PHPParser_Node_Stmt_Class::MODIFIER_STATIC);
+
+        return $this;
+    }
+
+    /**
+     * Sets default value for the property.
+     *
+     * @param mixed $value Default value to use
+     *
+     * @return PHPParser_Builder_Property The builder instance (for fluid interface)
+     */
+    public function setDefault($value) {
+        $this->default = $this->normalizeValue($value);
+
+        return $this;
+    }
+
+    /**
+     * Returns the built class node.
+     *
+     * @return PHPParser_Node_Stmt_Property The built property node
+     */
+    public function getNode() {
+        return new PHPParser_Node_Stmt_Property(
+            $this->type !== 0 ? $this->type : PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC,
+            array(
+                new PHPParser_Node_Stmt_PropertyProperty($this->name, $this->default)
+            )
+        );
+    }
+}

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

@@ -0,0 +1,94 @@
+<?php
+
+abstract class PHPParser_BuilderAbstract implements PHPParser_Builder {
+    /**
+     * Normalizes a node: Converts builder objects to nodes.
+     *
+     * @param PHPParser_Node|PHPParser_Builder $node The node to normalize
+     *
+     * @return PHPParser_Node The normalized node
+     */
+    protected function normalizeNode($node) {
+        if ($node instanceof PHPParser_Builder) {
+            return $node->getNode();
+        } elseif ($node instanceof PHPParser_Node) {
+            return $node;
+        }
+
+        throw new LogicException('Expected node or builder object');
+    }
+
+    /**
+     * Normalizes a name: Converts plain string names to PHPParser_Node_Name.
+     *
+     * @param PHPParser_Node_Name|string $name The name to normalize
+     *
+     * @return PHPParser_Node_Name The normalized name
+     */
+    protected function normalizeName($name) {
+        if ($name instanceof PHPParser_Node_Name) {
+            return $name;
+        } else {
+            return new PHPParser_Node_Name($name);
+        }
+    }
+
+    /**
+     * Normalizes a value: Converts nulls, booleans, integers,
+     * floats, strings and arrays into their respective nodes
+     *
+     * @param mixed $value The value to normalize
+     *
+     * @return PHPParser_Node_Expr The normalized value
+     */
+    protected function normalizeValue($value) {
+        if ($value instanceof PHPParser_Node) {
+            return $value;
+        } elseif (is_null($value)) {
+            return new PHPParser_Node_Expr_ConstFetch(
+                new PHPParser_Node_Name('null')
+            );
+        } elseif (is_bool($value)) {
+            return new PHPParser_Node_Expr_ConstFetch(
+                new PHPParser_Node_Name($value ? 'true' : 'false')
+            );
+        } elseif (is_int($value)) {
+            return new PHPParser_Node_Scalar_LNumber($value);
+        } elseif (is_float($value)) {
+            return new PHPParser_Node_Scalar_DNumber($value);
+        } elseif (is_string($value)) {
+            return new PHPParser_Node_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 PHPParser_Node_Expr_ArrayItem(
+                        $this->normalizeValue($itemValue)
+                    );
+                } else {
+                    $lastKey = null;
+                    $items[] = new PHPParser_Node_Expr_ArrayItem(
+                        $this->normalizeValue($itemValue),
+                        $this->normalizeValue($itemKey)
+                    );
+                }
+            }
+
+            return new PHPParser_Node_Expr_Array($items);
+        } else {
+            throw new LogicException('Invalid value');
+        }
+    }
+
+    /**
+     * Sets a modifier in the $this->type property.
+     *
+     * @param int $modifier Modifier to set
+     */
+    protected function setModifier($modifier) {
+        PHPParser_Node_Stmt_Class::verifyModifier($this->type, $modifier);
+        $this->type |= $modifier;
+    }
+}

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

@@ -0,0 +1,87 @@
+<?php
+
+/**
+ * "class", "interface" and "function" are reserved keywords, so the methods are defined as _class(),
+ * _interface() and _function() in the class and are made available as class(), interface() and function()
+ * through __call() magic.
+ *
+ * @method PHPParser_Builder_Class     class(string $name)     Creates a class builder.
+ * @method PHPParser_Builder_Function  function(string $name)  Creates a function builder
+ * @method PHPParser_Builder_Interface interface(string $name) Creates an interface builder.
+ */
+class PHPParser_BuilderFactory
+{
+    /**
+     * Creates a class builder.
+     *
+     * @param string $name Name of the class
+     *
+     * @return PHPParser_Builder_Class The created class builder
+     */
+    protected function _class($name) {
+        return new PHPParser_Builder_Class($name);
+    }
+
+    /**
+     * Creates a interface builder.
+     *
+     * @param string $name Name of the interface
+     *
+     * @return PHPParser_Builder_Class The created interface builder
+     */
+    protected function _interface($name) {
+        return new PHPParser_Builder_Interface($name);
+    }
+
+    /**
+     * Creates a method builder.
+     *
+     * @param string $name Name of the method
+     *
+     * @return PHPParser_Builder_Method The created method builder
+     */
+    public function method($name) {
+        return new PHPParser_Builder_Method($name);
+    }
+
+    /**
+     * Creates a parameter builder.
+     *
+     * @param string $name Name of the parameter
+     *
+     * @return PHPParser_Builder_Param The created parameter builder
+     */
+    public function param($name) {
+        return new PHPParser_Builder_Param($name);
+    }
+
+    /**
+     * Creates a property builder.
+     *
+     * @param string $name Name of the property
+     *
+     * @return PHPParser_Builder_Property The created property builder
+     */
+    public function property($name) {
+        return new PHPParser_Builder_Property($name);
+    }
+
+    /**
+     * Creates a function builder.
+     *
+     * @param string $name Name of the function
+     *
+     * @return PHPParser_Builder_Property The created function builder
+     */
+    protected function _function($name) {
+        return new PHPParser_Builder_Function($name);
+    }
+
+    public function __call($name, array $args) {
+        if (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,117 @@
+<?php
+
+class PHPParser_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,5 @@
+<?php
+
+class PHPParser_Comment_Doc extends PHPParser_Comment
+{
+}

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

@@ -0,0 +1,70 @@
+<?php
+
+class PHPParser_Error extends RuntimeException
+{
+    protected $rawMessage;
+    protected $rawLine;
+
+    /**
+     * Creates an Exception signifying a parse error.
+     *
+     * @param string $message Error message
+     * @param int    $line    Error line in PHP file
+     */
+    public function __construct($message, $line = -1) {
+        $this->rawMessage = (string) $message;
+        $this->rawLine    = (int) $line;
+        $this->updateMessage();
+    }
+
+    /**
+     * Gets the error message
+     *
+     * @return string Error message
+     */
+    public function getRawMessage() {
+        return $this->rawMessage;
+    }
+
+    /**
+     * 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();
+    }
+
+    /**
+     * Gets the error line in the PHP file.
+     *
+     * @return int Error line in the PHP file
+     */
+    public function getRawLine() {
+        return $this->rawLine;
+    }
+
+    /**
+     * Sets the line of the PHP file the error occurred in.
+     *
+     * @param int $line Error line in the PHP file
+     */
+    public function setRawLine($line) {
+        $this->rawLine = (int) $line;
+        $this->updateMessage();
+    }
+
+    /**
+     * Updates the exception message after a change to rawMessage or rawLine.
+     */
+    protected function updateMessage() {
+        $this->message = $this->rawMessage;
+
+        if (-1 === $this->rawLine) {
+            $this->message .= ' on unknown line';
+        } else {
+            $this->message .= ' on line ' . $this->rawLine;
+        }
+    }
+}

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

@@ -0,0 +1,191 @@
+<?php
+
+class PHPParser_Lexer
+{
+    protected $code;
+    protected $tokens;
+    protected $pos;
+    protected $line;
+
+    protected $tokenMap;
+    protected $dropTokens;
+
+    /**
+     * Creates a Lexer.
+     */
+    public function __construct() {
+        // 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);
+    }
+
+    /**
+     * Initializes the lexer for lexing the provided source code.
+     *
+     * @param string $code The source code to lex
+     *
+     * @throws PHPParser_Error on lexing errors (unterminated comment or unexpected character)
+     */
+    public function startLexing($code) {
+        $this->resetErrors();
+        $this->tokens = @token_get_all($code);
+        $this->handleErrors();
+
+        $this->code = $code; // keep the code around for __halt_compiler() handling
+        $this->pos  = -1;
+        $this->line =  1;
+    }
+
+    protected function resetErrors() {
+        // clear error_get_last() by forcing an undefined variable error
+        @$undefinedVariable;
+    }
+
+    protected function handleErrors() {
+        $error = error_get_last();
+
+        if (preg_match(
+            '~^Unterminated comment starting line ([0-9]+)$~',
+            $error['message'], $matches
+        )) {
+            throw new PHPParser_Error('Unterminated comment', $matches[1]);
+        }
+
+        if (preg_match(
+            '~^Unexpected character in input:  \'(.)\' \(ASCII=([0-9]+)\)~s',
+            $error['message'], $matches
+        )) {
+            throw new PHPParser_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 PHPParser_Error('Unexpected null byte');
+        }
+    }
+
+    /**
+     * Fetches the next token.
+     *
+     * @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 (isset($this->tokens[++$this->pos])) {
+            $token = $this->tokens[$this->pos];
+
+            if (is_string($token)) {
+                $startAttributes['startLine'] = $this->line;
+                $endAttributes['endLine']     = $this->line;
+
+                // bug in token_get_all
+                if ('b"' === $token) {
+                    $value = 'b"';
+                    return ord('"');
+                } else {
+                    $value = $token;
+                    return ord($token);
+                }
+            } else {
+                $this->line += substr_count($token[1], "\n");
+
+                if (T_COMMENT === $token[0]) {
+                    $startAttributes['comments'][] = new PHPParser_Comment($token[1], $token[2]);
+                } elseif (T_DOC_COMMENT === $token[0]) {
+                    $startAttributes['comments'][] = new PHPParser_Comment_Doc($token[1], $token[2]);
+                } elseif (!isset($this->dropTokens[$token[0]])) {
+                    $value = $token[1];
+                    $startAttributes['startLine'] = $token[2];
+                    $endAttributes['endLine']     = $this->line;
+
+                    return $this->tokenMap[$token[0]];
+                }
+            }
+        }
+
+        $startAttributes['startLine'] = $this->line;
+
+        // 0 is the EOF token
+        return 0;
+    }
+
+    /**
+     * Handles __halt_compiler() by returning the text after it.
+     *
+     * @return string Remaining text
+     */
+    public function handleHaltCompiler() {
+        // get the length of the text before the T_HALT_COMPILER token
+        $textBefore = '';
+        for ($i = 0; $i <= $this->pos; ++$i) {
+            if (is_string($this->tokens[$i])) {
+                $textBefore .= $this->tokens[$i];
+            } else {
+                $textBefore .= $this->tokens[$i][1];
+            }
+        }
+
+        // text after T_HALT_COMPILER, still including ();
+        $textAfter = substr($this->code, strlen($textBefore));
+
+        // 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 PHPParser_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) {
+            // T_DOUBLE_COLON is equivalent to T_PAAMAYIM_NEKUDOTAYIM
+            if (T_DOUBLE_COLON === $i) {
+                $tokenMap[$i] = PHPParser_Parser::T_PAAMAYIM_NEKUDOTAYIM;
+            // T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
+            } elseif(T_OPEN_TAG_WITH_ECHO === $i) {
+                $tokenMap[$i] = PHPParser_Parser::T_ECHO;
+            // T_CLOSE_TAG is equivalent to ';'
+            } elseif(T_CLOSE_TAG === $i) {
+                $tokenMap[$i] = ord(';');
+            // and the others can be mapped directly
+            } elseif ('UNKNOWN' !== ($name = token_name($i))
+                      && defined($name = 'PHPParser_Parser::' . $name)
+            ) {
+                $tokenMap[$i] = constant($name);
+            }
+        }
+
+        return $tokenMap;
+    }
+}

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

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Const.php

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Array.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * @property PHPParser_Node_Expr_ArrayItem[] $items Items
+ */
+class PHPParser_Node_Expr_Array extends PHPParser_Node_Expr
+{
+    /**
+     * Constructs an array node.
+     *
+     * @param PHPParser_Node_Expr_ArrayItem[] $items      Items of the array
+     * @param array                           $attributes Additional attributes
+     */
+    public function __construct(array $items = array(), array $attributes = array()) {
+        parent::__construct(
+            array(
+                'items' => $items
+            ),
+            $attributes
+        );
+    }
+}

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

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

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

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignBitwiseAnd.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignBitwiseOr.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignBitwiseXor.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignConcat.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignDiv.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignMinus.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignMod.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignMul.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignPlus.php

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignShiftLeft.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/AssignShiftRight.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/BitwiseAnd.php

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/BitwiseOr.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/BitwiseXor.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/BooleanAnd.php

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/BooleanOr.php

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Cast/Array.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Cast/Bool.php

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Cast/Int.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Cast/Object.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Cast/String.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Cast/Unset.php

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

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

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Clone.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Closure.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/ClosureUse.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * @property string $var   Name of variable
+ * @property bool   $byRef Whether to use by reference
+ */
+class PHPParser_Node_Expr_ClosureUse extends PHPParser_Node_Expr
+{
+    /**
+     * Constructs a closure use node.
+     *
+     * @param string      $var        Name of variable
+     * @param bool        $byRef      Whether to use by reference
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct($var, $byRef = false, array $attributes = array()) {
+        parent::__construct(
+            array(
+                'var'   => $var,
+                'byRef' => $byRef
+            ),
+            $attributes
+        );
+    }
+}

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Concat.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/ConstFetch.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Div.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Empty.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Equal.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/ErrorSuppress.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Eval.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Exit.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/FuncCall.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * @property PHPParser_Node_Name|PHPParser_Node_Expr $name Function name
+ * @property PHPParser_Node_Arg[]                    $args Arguments
+ */
+class PHPParser_Node_Expr_FuncCall extends PHPParser_Node_Expr
+{
+    /**
+     * Constructs a function call node.
+     *
+     * @param PHPParser_Node_Name|PHPParser_Node_Expr $name       Function name
+     * @param PHPParser_Node_Arg[]                    $args       Arguments
+     * @param array                                   $attributes Additional attributes
+     */
+    public function __construct($name, array $args = array(), array $attributes = array()) {
+        parent::__construct(
+            array(
+                'name' => $name,
+                'args' => $args
+            ),
+            $attributes
+        );
+    }
+}

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Greater.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/GreaterOrEqual.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Identical.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Include.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Instanceof.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Isset.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/List.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/LogicalAnd.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/LogicalOr.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/LogicalXor.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/MethodCall.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Minus.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Mod.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Mul.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/New.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * @property PHPParser_Node_Name|PHPParser_Node_Expr $class Class name
+ * @property PHPParser_Node_Arg[]                    $args  Arguments
+ */
+class PHPParser_Node_Expr_New extends PHPParser_Node_Expr
+{
+    /**
+     * Constructs a function call node.
+     *
+     * @param PHPParser_Node_Name|PHPParser_Node_Expr $class      Class name
+     * @param PHPParser_Node_Arg[]                    $args       Arguments
+     * @param array                                   $attributes Additional attributes
+     */
+    public function __construct($class, array $args = array(), array $attributes = array()) {
+        parent::__construct(
+            array(
+                'class' => $class,
+                'args'  => $args
+            ),
+            $attributes
+        );
+    }
+}

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/NotEqual.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/NotIdentical.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Plus.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/PostDec.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/PostInc.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/PreDec.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/PreInc.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Print.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/PropertyFetch.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/ShellExec.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * @property array $parts Encapsed string array
+ */
+class PHPParser_Node_Expr_ShellExec extends PHPParser_Node_Expr
+{
+    /**
+     * Constructs a shell exec (backtick) node.
+     *
+     * @param array       $parts      Encapsed string array
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct($parts, array $attributes = array()) {
+        parent::__construct(
+            array(
+                'parts' => $parts
+            ),
+            $attributes
+        );
+    }
+}

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/ShiftLeft.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/ShiftRight.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Smaller.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/SmallerOrEqual.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/StaticCall.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/StaticPropertyFetch.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Ternary.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/UnaryMinus.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/UnaryPlus.php

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

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Variable.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * @property string|PHPParser_Node_Expr $name Name
+ */
+class PHPParser_Node_Expr_Variable extends PHPParser_Node_Expr
+{
+    /**
+     * Constructs a variable node.
+     *
+     * @param string|PHPParser_Node_Expr $name       Name
+     * @param array                      $attributes Additional attributes
+     */
+    public function __construct($name, array $attributes = array()) {
+        parent::__construct(
+            array(
+                 'name' => $name
+            ),
+            $attributes
+        );
+    }
+}

vendor/nikic/php-parser/lib/PHPParser/Node/Expr/Yield.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * @property null|PHPParser_Node_Expr $value Value expression
+ * @property null|PHPParser_Node_Expr $key   Key expression
+ */
+class PHPParser_Node_Expr_Yield extends PHPParser_Node_Expr
+{
+    /**
+     * Constructs a yield expression node.
+     *
+     * @param null|PHPParser_Node_Expr $value ´    Value expression
+     * @param null|PHPParser_Node_Expr $key        Key expression
+     * @param array                    $attributes Additional attributes
+     */
+    public function __construct(PHPParser_Node_Expr $value = null, PHPParser_Node_Expr $key = null, array $attributes = array()) {
+        parent::__construct(
+            array(
+                'key'   => $key,
+                'value' => $value,
+            ),
+            $attributes
+        );
+    }
+}

vendor/nikic/php-parser/lib/PHPParser/Node/Name.php

@@ -0,0 +1,168 @@
+<?php
+
+/**
+ * @property array $parts Parts of the name
+ */
+class PHPParser_Node_Name extends PHPParser_NodeAbstract
+{
+    /**
+     * Constructs a name node.
+     *
+     * @param string|array $parts      Parts of the name (or name as string)
+     * @param array        $attributes Additional attributes
+     */
+    public function __construct($parts, array $attributes = array()) {
+        if (!is_array($parts)) {
+            $parts = explode('\\', $parts);
+        }
+
+        parent::__construct(
+            array(
+                'parts' => $parts,
+            ),
+            $attributes
+        );
+    }
+
+    /**
+     * Gets the first part of the name, i.e. everything before the first namespace separator.
+     *
+     * @return string First part of the name
+     */
+    public function getFirst() {
+        return $this->parts[0];
+    }
+
+    /**
+     * Gets the last part of the name, i.e. everything after the last namespace separator.
+     *
+     * @return string Last part of the name
+     */
+    public function getLast() {
+        return $this->parts[count($this->parts) - 1];
+    }
+
+    /**
+     * Checks whether the name is unqualified. (E.g. Name)
+     *
+     * @return bool Whether the name is unqualified
+     */
+    public function isUnqualified() {
+        return 1 == count($this->parts);
+    }
+
+    /**
+     * Checks whether the name is qualified. (E.g. Name\Name)
+     *
+     * @return bool Whether the name is qualified
+     */
+    public function isQualified() {
+        return 1 < count($this->parts);
+    }
+
+    /**
+     * Checks whether the name is fully qualified. (E.g. \Name)
+     *
+     * @return bool Whether the name is fully qualified
+     */
+    public function isFullyQualified() {
+        return false;
+    }
+
+    /**
+     * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
+     *
+     * @return bool Whether the name is relative
+     */
+    public function isRelative() {
+        return false;
+    }
+
+    /**
+     * Returns a string representation of the name by imploding the namespace parts with a separator.
+     *
+     * @param string $separator The separator to use (defaults to the namespace separator \)
+     *
+     * @return string String representation
+     */
+    public function toString($separator = '\\') {
+        return implode($separator, $this->parts);
+    }
+
+    /**
+     * Returns a string representation of the name by imploding the namespace parts with the
+     * namespace separator.
+     *
+     * @return string String representation
+     */
+    public function __toString() {
+        return implode('\\', $this->parts);
+    }
+
+    /**
+     * Sets the whole name.
+     *
+     * @param string|array|self $name The name to set the whole name to
+     */
+    public function set($name) {
+        $this->parts = $this->prepareName($name);
+    }
+
+    /**
+     * Prepends a name to this name.
+     *
+     * @param string|array|self $name Name to prepend
+     */
+    public function prepend($name) {
+        $this->parts = array_merge($this->prepareName($name), $this->parts);
+    }
+
+    /**
+     * Appends a name to this name.
+     *
+     * @param string|array|self $name Name to append
+     */
+    public function append($name) {
+        $this->parts = array_merge($this->parts, $this->prepareName($name));
+    }
+
+    /**
+     * Sets the first part of the name.
+     *
+     * @param string|array|self $name The name to set the first part to
+     */
+    public function setFirst($name) {
+        array_splice($this->parts, 0, 1, $this->prepareName($name));
+    }
+
+    /**
+     * Sets the last part of the name.
+     *
+     * @param string|array|self $name The name to set the last part to
+     */
+    public function setLast($name) {
+        array_splice($this->parts, -1, 1, $this->prepareName($name));
+    }
+
+    /**
+     * Prepares a (string, array or Name node) name for use in name changing methods by converting
+     * it to an array.
+     *
+     * @param string|array|self $name Name to prepare
+     *
+     * @return array Prepared name
+     */
+    protected function prepareName($name) {
+        if (is_string($name)) {
+            return explode('\\', $name);
+        } elseif (is_array($name)) {
+            return $name;
+        } elseif ($name instanceof self) {
+            return $name->parts;
+        }
+
+        throw new InvalidArgumentException(
+            'When changing a name you need to pass either a string, an array or a Name node'
+        );
+    }
+}