First commit

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,94 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+use PhpParser\Node\FunctionLike;
+
+class ClassMethod extends Node\Stmt implements FunctionLike
+{
+    /** @var int Flags */
+    public $flags;
+    /** @var bool Whether to return by reference */
+    public $byRef;
+    /** @var string Name */
+    public $name;
+    /** @var Node\Param[] Parameters */
+    public $params;
+    /** @var null|string|Node\Name|Node\NullableType Return type */
+    public $returnType;
+    /** @var Node[]|null Statements */
+    public $stmts;
+
+    /** @deprecated Use $flags instead */
+    public $type;
+
+    /**
+     * Constructs a class method node.
+     *
+     * @param string      $name       Name
+     * @param array       $subNodes   Array of the following optional subnodes:
+     *                                'flags       => MODIFIER_PUBLIC: Flags
+     *                                'byRef'      => false          : Whether to return by reference
+     *                                'params'     => array()        : Parameters
+     *                                'returnType' => null           : Return type
+     *                                'stmts'      => array()        : Statements
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct($name, array $subNodes = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->flags = isset($subNodes['flags']) ? $subNodes['flags']
+            : (isset($subNodes['type']) ? $subNodes['type'] : 0);
+        $this->type = $this->flags;
+        $this->byRef = isset($subNodes['byRef'])  ? $subNodes['byRef']  : false;
+        $this->name = $name;
+        $this->params = isset($subNodes['params']) ? $subNodes['params'] : array();
+        $this->returnType = isset($subNodes['returnType']) ? $subNodes['returnType'] : null;
+        $this->stmts = array_key_exists('stmts', $subNodes) ? $subNodes['stmts'] : array();
+    }
+
+    public function getSubNodeNames() {
+        return array('flags', 'byRef', 'name', 'params', 'returnType', 'stmts');
+    }
+
+    public function returnsByRef() {
+        return $this->byRef;
+    }
+
+    public function getParams() {
+        return $this->params;
+    }
+
+    public function getReturnType() {
+        return $this->returnType;
+    }
+
+    public function getStmts() {
+        return $this->stmts;
+    }
+
+    public function isPublic() {
+        return ($this->flags & Class_::MODIFIER_PUBLIC) !== 0
+            || ($this->flags & Class_::VISIBILITY_MODIFIER_MASK) === 0;
+    }
+
+    public function isProtected() {
+        return (bool) ($this->flags & Class_::MODIFIER_PROTECTED);
+    }
+
+    public function isPrivate() {
+        return (bool) ($this->flags & Class_::MODIFIER_PRIVATE);
+    }
+
+    public function isAbstract() {
+        return (bool) ($this->flags & Class_::MODIFIER_ABSTRACT);
+    }
+
+    public function isFinal() {
+        return (bool) ($this->flags & Class_::MODIFIER_FINAL);
+    }
+
+    public function isStatic() {
+        return (bool) ($this->flags & Class_::MODIFIER_STATIC);
+    }
+}

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

@@ -0,0 +1,99 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Error;
+use PhpParser\Node;
+
+class Class_ extends ClassLike
+{
+    const MODIFIER_PUBLIC    =  1;
+    const MODIFIER_PROTECTED =  2;
+    const MODIFIER_PRIVATE   =  4;
+    const MODIFIER_STATIC    =  8;
+    const MODIFIER_ABSTRACT  = 16;
+    const MODIFIER_FINAL     = 32;
+
+    const VISIBILITY_MODIFIER_MASK = 7; // 1 | 2 | 4
+    /** @deprecated */
+    const VISIBILITY_MODIFER_MASK = self::VISIBILITY_MODIFIER_MASK;
+
+    /** @var int Type */
+    public $flags;
+    /** @var null|Node\Name Name of extended class */
+    public $extends;
+    /** @var Node\Name[] Names of implemented interfaces */
+    public $implements;
+
+    /** @deprecated Use $flags instead */
+    public $type;
+
+    protected static $specialNames = array(
+        'self'   => true,
+        'parent' => true,
+        'static' => true,
+    );
+
+    /**
+     * Constructs a class node.
+     *
+     * @param string|null $name       Name
+     * @param array       $subNodes   Array of the following optional subnodes:
+     *                                'flags'      => 0      : Flags
+     *                                'extends'    => null   : Name of extended class
+     *                                'implements' => array(): Names of implemented interfaces
+     *                                'stmts'      => array(): Statements
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct($name, array $subNodes = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->flags = isset($subNodes['flags']) ? $subNodes['flags']
+            : (isset($subNodes['type']) ? $subNodes['type'] : 0);
+        $this->type = $this->flags;
+        $this->name = $name;
+        $this->extends = isset($subNodes['extends']) ? $subNodes['extends'] : null;
+        $this->implements = isset($subNodes['implements']) ? $subNodes['implements'] : array();
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
+    }
+
+    public function getSubNodeNames() {
+        return array('flags', 'name', 'extends', 'implements', 'stmts');
+    }
+
+    public function isAbstract() {
+        return (bool) ($this->flags & self::MODIFIER_ABSTRACT);
+    }
+
+    public function isFinal() {
+        return (bool) ($this->flags & self::MODIFIER_FINAL);
+    }
+
+    public function isAnonymous() {
+        return null === $this->name;
+    }
+
+    /**
+     * @internal
+     */
+    public static function verifyModifier($a, $b) {
+        if ($a & self::VISIBILITY_MODIFIER_MASK && $b & self::VISIBILITY_MODIFIER_MASK) {
+            throw new Error('Multiple access type modifiers are not allowed');
+        }
+
+        if ($a & self::MODIFIER_ABSTRACT && $b & self::MODIFIER_ABSTRACT) {
+            throw new Error('Multiple abstract modifiers are not allowed');
+        }
+
+        if ($a & self::MODIFIER_STATIC && $b & self::MODIFIER_STATIC) {
+            throw new Error('Multiple static modifiers are not allowed');
+        }
+
+        if ($a & self::MODIFIER_FINAL && $b & self::MODIFIER_FINAL) {
+            throw new Error('Multiple final modifiers are not allowed');
+        }
+
+        if ($a & 48 && $b & 48) {
+            throw new Error('Cannot use the final modifier on an abstract class member');
+        }
+    }
+}

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

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

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

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

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

@@ -0,0 +1,30 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class DeclareDeclare extends Node\Stmt
+{
+    /** @var string Key */
+    public $key;
+    /** @var Node\Expr Value */
+    public $value;
+
+    /**
+     * Constructs a declare key=>value pair node.
+     *
+     * @param string    $key        Key
+     * @param Node\Expr $value      Value
+     * @param array     $attributes Additional attributes
+     */
+    public function __construct($key, Node\Expr $value, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->key = $key;
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames() {
+        return array('key', 'value');
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class For_ extends Node\Stmt
+{
+    /** @var Node\Expr[] Init expressions */
+    public $init;
+    /** @var Node\Expr[] Loop conditions */
+    public $cond;
+    /** @var Node\Expr[] Loop expressions */
+    public $loop;
+    /** @var Node[] Statements */
+    public $stmts;
+
+    /**
+     * Constructs a for loop node.
+     *
+     * @param array $subNodes   Array of the following optional subnodes:
+     *                          'init'  => array(): Init expressions
+     *                          'cond'  => array(): Loop conditions
+     *                          'loop'  => array(): Loop expressions
+     *                          'stmts' => array(): Statements
+     * @param array $attributes Additional attributes
+     */
+    public function __construct(array $subNodes = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->init = isset($subNodes['init']) ? $subNodes['init'] : array();
+        $this->cond = isset($subNodes['cond']) ? $subNodes['cond'] : array();
+        $this->loop = isset($subNodes['loop']) ? $subNodes['loop'] : array();
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
+    }
+
+    public function getSubNodeNames() {
+        return array('init', 'cond', 'loop', 'stmts');
+    }
+}

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

@@ -0,0 +1,43 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Foreach_ extends Node\Stmt
+{
+    /** @var Node\Expr Expression to iterate */
+    public $expr;
+    /** @var null|Node\Expr Variable to assign key to */
+    public $keyVar;
+    /** @var bool Whether to assign value by reference */
+    public $byRef;
+    /** @var Node\Expr Variable to assign value to */
+    public $valueVar;
+    /** @var Node[] Statements */
+    public $stmts;
+
+    /**
+     * Constructs a foreach node.
+     *
+     * @param Node\Expr $expr       Expression to iterate
+     * @param Node\Expr $valueVar   Variable to assign value to
+     * @param array     $subNodes   Array of the following optional subnodes:
+     *                              'keyVar' => null   : Variable to assign key to
+     *                              'byRef'  => false  : Whether to assign value by reference
+     *                              'stmts'  => array(): Statements
+     * @param array     $attributes Additional attributes
+     */
+    public function __construct(Node\Expr $expr, Node\Expr $valueVar, array $subNodes = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->expr = $expr;
+        $this->keyVar = isset($subNodes['keyVar']) ? $subNodes['keyVar'] : null;
+        $this->byRef = isset($subNodes['byRef']) ? $subNodes['byRef'] : false;
+        $this->valueVar = $valueVar;
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
+    }
+
+    public function getSubNodeNames() {
+        return array('expr', 'keyVar', 'byRef', 'valueVar', 'stmts');
+    }
+}

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

@@ -0,0 +1,60 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+use PhpParser\Node\FunctionLike;
+
+class Function_ extends Node\Stmt implements FunctionLike
+{
+    /** @var bool Whether function returns by reference */
+    public $byRef;
+    /** @var string Name */
+    public $name;
+    /** @var Node\Param[] Parameters */
+    public $params;
+    /** @var null|string|Node\Name|Node\NullableType Return type */
+    public $returnType;
+    /** @var Node[] Statements */
+    public $stmts;
+
+    /**
+     * Constructs a function node.
+     *
+     * @param string $name       Name
+     * @param array  $subNodes   Array of the following optional subnodes:
+     *                           'byRef'      => false  : Whether to return by reference
+     *                           'params'     => array(): Parameters
+     *                           'returnType' => null   : Return type
+     *                           'stmts'      => array(): Statements
+     * @param array  $attributes Additional attributes
+     */
+    public function __construct($name, array $subNodes = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->byRef = isset($subNodes['byRef']) ? $subNodes['byRef'] : false;
+        $this->name = $name;
+        $this->params = isset($subNodes['params']) ? $subNodes['params'] : array();
+        $this->returnType = isset($subNodes['returnType']) ? $subNodes['returnType'] : null;
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
+    }
+
+    public function getSubNodeNames() {
+        return array('byRef', 'name', 'params', 'returnType', 'stmts');
+    }
+
+    public function returnsByRef() {
+        return $this->byRef;
+    }
+
+    public function getParams() {
+        return $this->params;
+    }
+
+    public function getReturnType() {
+        return $this->returnType;
+    }
+
+    public function getStmts() {
+        return $this->stmts;
+    }
+}

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

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Global_ extends Node\Stmt
+{
+    /** @var Node\Expr[] Variables */
+    public $vars;
+
+    /**
+     * Constructs a global variables list node.
+     *
+     * @param Node\Expr[] $vars       Variables to unset
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct(array $vars, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->vars = $vars;
+    }
+
+    public function getSubNodeNames() {
+        return array('vars');
+    }
+}

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

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\Stmt;
+
+class Goto_ extends Stmt
+{
+    /** @var string Name of label to jump to */
+    public $name;
+
+    /**
+     * Constructs a goto node.
+     *
+     * @param string $name       Name of label to jump to
+     * @param array  $attributes Additional attributes
+     */
+    public function __construct($name, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->name = $name;
+    }
+
+    public function getSubNodeNames() {
+        return array('name');
+    }
+}

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

@@ -0,0 +1,35 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
+
+class GroupUse extends Stmt
+{
+    /** @var int Type of group use */
+    public $type;
+    /** @var Name Prefix for uses */
+    public $prefix;
+    /** @var UseUse[] Uses */
+    public $uses;
+
+    /**
+     * Constructs a group use node.
+     *
+     * @param Name     $prefix     Prefix for uses
+     * @param UseUse[] $uses       Uses
+     * @param int      $type       Type of group use
+     * @param array    $attributes Additional attributes
+     */
+    public function __construct(Name $prefix, array $uses, $type = Use_::TYPE_NORMAL, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->type = $type;
+        $this->prefix = $prefix;
+        $this->uses = $uses;
+    }
+
+    public function getSubNodeNames() {
+        return array('type', 'prefix', 'uses');
+    }
+}

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

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\Stmt;
+
+class HaltCompiler extends Stmt
+{
+    /** @var string Remaining text after halt compiler statement. */
+    public $remaining;
+
+    /**
+     * Constructs a __halt_compiler node.
+     *
+     * @param string $remaining  Remaining text after halt compiler statement.
+     * @param array  $attributes Additional attributes
+     */
+    public function __construct($remaining, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->remaining = $remaining;
+    }
+
+    public function getSubNodeNames() {
+        return array('remaining');
+    }
+}

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

@@ -0,0 +1,39 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class If_ extends Node\Stmt
+{
+    /** @var Node\Expr Condition expression */
+    public $cond;
+    /** @var Node[] Statements */
+    public $stmts;
+    /** @var ElseIf_[] Elseif clauses */
+    public $elseifs;
+    /** @var null|Else_ Else clause */
+    public $else;
+
+    /**
+     * Constructs an if node.
+     *
+     * @param Node\Expr $cond       Condition
+     * @param array     $subNodes   Array of the following optional subnodes:
+     *                              'stmts'   => array(): Statements
+     *                              'elseifs' => array(): Elseif clauses
+     *                              'else'    => null   : Else clause
+     * @param array     $attributes Additional attributes
+     */
+    public function __construct(Node\Expr $cond, array $subNodes = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->cond = $cond;
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
+        $this->elseifs = isset($subNodes['elseifs']) ? $subNodes['elseifs'] : array();
+        $this->else = isset($subNodes['else']) ? $subNodes['else'] : null;
+    }
+
+    public function getSubNodeNames() {
+        return array('cond', 'stmts', 'elseifs', 'else');
+    }
+}

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

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\Stmt;
+
+class InlineHTML extends Stmt
+{
+    /** @var string String */
+    public $value;
+
+    /**
+     * Constructs an inline HTML node.
+     *
+     * @param string $value      String
+     * @param array  $attributes Additional attributes
+     */
+    public function __construct($value, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->value = $value;
+    }
+
+    public function getSubNodeNames() {
+        return array('value');
+    }
+}

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

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Interface_ extends ClassLike
+{
+    /** @var Node\Name[] Extended interfaces */
+    public $extends;
+
+    /**
+     * Constructs a class node.
+     *
+     * @param string $name       Name
+     * @param array  $subNodes   Array of the following optional subnodes:
+     *                           'extends' => array(): Name of extended interfaces
+     *                           'stmts'   => array(): Statements
+     * @param array  $attributes Additional attributes
+     */
+    public function __construct($name, array $subNodes = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->name = $name;
+        $this->extends = isset($subNodes['extends']) ? $subNodes['extends'] : array();
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
+    }
+
+    public function getSubNodeNames() {
+        return array('name', 'extends', 'stmts');
+    }
+}

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

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

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

@@ -0,0 +1,34 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Namespace_ extends Node\Stmt
+{
+    /* For use in the "kind" attribute */
+    const KIND_SEMICOLON = 1;
+    const KIND_BRACED = 2;
+
+    /** @var null|Node\Name Name */
+    public $name;
+    /** @var Node[] Statements */
+    public $stmts;
+
+    /**
+     * Constructs a namespace node.
+     *
+     * @param null|Node\Name $name       Name
+     * @param null|Node[]    $stmts      Statements
+     * @param array          $attributes Additional attributes
+     */
+    public function __construct(Node\Name $name = null, $stmts = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->name = $name;
+        $this->stmts = $stmts;
+    }
+
+    public function getSubNodeNames() {
+        return array('name', 'stmts');
+    }
+}

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

@@ -0,0 +1,13 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+/** Nop/empty statement (;). */
+class Nop extends Node\Stmt
+{
+    public function getSubNodeNames() {
+        return array();
+    }
+}

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

@@ -0,0 +1,51 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Property extends Node\Stmt
+{
+    /** @var int Modifiers */
+    public $flags;
+    /** @var PropertyProperty[] Properties */
+    public $props;
+
+    /** @deprecated Use $flags instead */
+    public $type;
+
+    /**
+     * Constructs a class property list node.
+     *
+     * @param int                $flags      Modifiers
+     * @param PropertyProperty[] $props      Properties
+     * @param array              $attributes Additional attributes
+     */
+    public function __construct($flags, array $props, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->flags = $flags;
+        $this->type = $flags;
+        $this->props = $props;
+    }
+
+    public function getSubNodeNames() {
+        return array('flags', 'props');
+    }
+
+    public function isPublic() {
+        return ($this->flags & Class_::MODIFIER_PUBLIC) !== 0
+            || ($this->flags & Class_::VISIBILITY_MODIFIER_MASK) === 0;
+    }
+
+    public function isProtected() {
+        return (bool) ($this->flags & Class_::MODIFIER_PROTECTED);
+    }
+
+    public function isPrivate() {
+        return (bool) ($this->flags & Class_::MODIFIER_PRIVATE);
+    }
+
+    public function isStatic() {
+        return (bool) ($this->flags & Class_::MODIFIER_STATIC);
+    }
+}

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

@@ -0,0 +1,30 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class PropertyProperty extends Node\Stmt
+{
+    /** @var string Name */
+    public $name;
+    /** @var null|Node\Expr Default */
+    public $default;
+
+    /**
+     * Constructs a class property node.
+     *
+     * @param string         $name       Name
+     * @param null|Node\Expr $default    Default value
+     * @param array          $attributes Additional attributes
+     */
+    public function __construct($name, Node\Expr $default = null, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->name = $name;
+        $this->default = $default;
+    }
+
+    public function getSubNodeNames() {
+        return array('name', 'default');
+    }
+}

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

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

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

@@ -0,0 +1,30 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class StaticVar extends Node\Stmt
+{
+    /** @var string Name */
+    public $name;
+    /** @var null|Node\Expr Default value */
+    public $default;
+
+    /**
+     * Constructs a static variable node.
+     *
+     * @param string         $name       Name
+     * @param null|Node\Expr $default    Default value
+     * @param array          $attributes Additional attributes
+     */
+    public function __construct($name, Node\Expr $default = null, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->name = $name;
+        $this->default = $default;
+    }
+
+    public function getSubNodeNames() {
+        return array('name', 'default');
+    }
+}

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

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

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

@@ -0,0 +1,30 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Switch_ extends Node\Stmt
+{
+    /** @var Node\Expr Condition */
+    public $cond;
+    /** @var Case_[] Case list */
+    public $cases;
+
+    /**
+     * Constructs a case node.
+     *
+     * @param Node\Expr $cond       Condition
+     * @param Case_[]   $cases      Case list
+     * @param array     $attributes Additional attributes
+     */
+    public function __construct(Node\Expr $cond, array $cases, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->cond = $cond;
+        $this->cases = $cases;
+    }
+
+    public function getSubNodeNames() {
+        return array('cond', 'cases');
+    }
+}

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

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

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

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+
+class TraitUse extends Node\Stmt
+{
+    /** @var Node\Name[] Traits */
+    public $traits;
+    /** @var TraitUseAdaptation[] Adaptations */
+    public $adaptations;
+
+    /**
+     * Constructs a trait use node.
+     *
+     * @param Node\Name[]          $traits      Traits
+     * @param TraitUseAdaptation[] $adaptations Adaptations
+     * @param array                $attributes  Additional attributes
+     */
+    public function __construct(array $traits, array $adaptations = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->traits = $traits;
+        $this->adaptations = $adaptations;
+    }
+
+    public function getSubNodeNames() {
+        return array('traits', 'adaptations');
+    }
+}

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

@@ -0,0 +1,13 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+abstract class TraitUseAdaptation extends Node\Stmt
+{
+    /** @var Node\Name Trait name */
+    public $trait;
+    /** @var string Method name */
+    public $method;
+}

vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation/Alias.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace PhpParser\Node\Stmt\TraitUseAdaptation;
+
+use PhpParser\Node;
+
+class Alias extends Node\Stmt\TraitUseAdaptation
+{
+    /** @var null|int New modifier */
+    public $newModifier;
+    /** @var null|string New name */
+    public $newName;
+
+    /**
+     * Constructs a trait use precedence adaptation node.
+     *
+     * @param null|Node\Name $trait       Trait name
+     * @param string         $method      Method name
+     * @param null|int       $newModifier New modifier
+     * @param null|string    $newName     New name
+     * @param array          $attributes  Additional attributes
+     */
+    public function __construct($trait, $method, $newModifier, $newName, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->trait = $trait;
+        $this->method = $method;
+        $this->newModifier = $newModifier;
+        $this->newName = $newName;
+    }
+
+    public function getSubNodeNames() {
+        return array('trait', 'method', 'newModifier', 'newName');
+    }
+}

vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation/Precedence.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace PhpParser\Node\Stmt\TraitUseAdaptation;
+
+use PhpParser\Node;
+
+class Precedence extends Node\Stmt\TraitUseAdaptation
+{
+    /** @var Node\Name[] Overwritten traits */
+    public $insteadof;
+
+    /**
+     * Constructs a trait use precedence adaptation node.
+     *
+     * @param Node\Name   $trait       Trait name
+     * @param string      $method      Method name
+     * @param Node\Name[] $insteadof   Overwritten traits
+     * @param array       $attributes  Additional attributes
+     */
+    public function __construct(Node\Name $trait, $method, array $insteadof, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->trait = $trait;
+        $this->method = $method;
+        $this->insteadof = $insteadof;
+    }
+
+    public function getSubNodeNames() {
+        return array('trait', 'method', 'insteadof');
+    }
+}

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

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Trait_ extends ClassLike
+{
+    /**
+     * Constructs a trait node.
+     *
+     * @param string $name       Name
+     * @param array  $subNodes   Array of the following optional subnodes:
+     *                           'stmts' => array(): Statements
+     * @param array  $attributes Additional attributes
+     */
+    public function __construct($name, array $subNodes = array(), array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->name = $name;
+        $this->stmts = isset($subNodes['stmts']) ? $subNodes['stmts'] : array();
+    }
+
+    public function getSubNodeNames() {
+        return array('name', 'stmts');
+    }
+}

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

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

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

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class Unset_ extends Node\Stmt
+{
+    /** @var Node\Expr[] Variables to unset */
+    public $vars;
+
+    /**
+     * Constructs an unset node.
+     *
+     * @param Node\Expr[] $vars       Variables to unset
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct(array $vars, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->vars = $vars;
+    }
+
+    public function getSubNodeNames() {
+        return array('vars');
+    }
+}

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

@@ -0,0 +1,38 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node;
+
+class UseUse extends Node\Stmt
+{
+    /** @var int One of the Stmt\Use_::TYPE_* constants. Will only differ from TYPE_UNKNOWN for mixed group uses */
+    public $type;
+    /** @var Node\Name Namespace, class, function or constant to alias */
+    public $name;
+    /** @var string Alias */
+    public $alias;
+
+    /**
+     * Constructs an alias (use) node.
+     *
+     * @param Node\Name   $name       Namespace/Class to alias
+     * @param null|string $alias      Alias
+     * @param int         $type       Type of the use element (for mixed group use declarations only)
+     * @param array       $attributes Additional attributes
+     */
+    public function __construct(Node\Name $name, $alias = null, $type = Use_::TYPE_UNKNOWN, array $attributes = array()) {
+        if (null === $alias) {
+            $alias = $name->getLast();
+        }
+
+        parent::__construct($attributes);
+        $this->type = $type;
+        $this->name = $name;
+        $this->alias = $alias;
+    }
+
+    public function getSubNodeNames() {
+        return array('type', 'name', 'alias');
+    }
+}

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

@@ -0,0 +1,43 @@
+<?php
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\Stmt;
+
+class Use_ extends Stmt
+{
+    /**
+     * Unknown type. Both Stmt\Use_ / Stmt\GroupUse and Stmt\UseUse have a $type property, one of them will always be
+     * TYPE_UNKNOWN while the other has one of the three other possible types. For normal use statements the type on the
+     * Stmt\UseUse is unknown. It's only the other way around for mixed group use declarations.
+     */
+    const TYPE_UNKNOWN = 0;
+    /** Class or namespace import */
+    const TYPE_NORMAL = 1;
+    /** Function import */
+    const TYPE_FUNCTION = 2;
+    /** Constant import */
+    const TYPE_CONSTANT = 3;
+
+    /** @var int Type of alias */
+    public $type;
+    /** @var UseUse[] Aliases */
+    public $uses;
+
+    /**
+     * Constructs an alias (use) list node.
+     *
+     * @param UseUse[] $uses       Aliases
+     * @param int      $type       Type of alias
+     * @param array    $attributes Additional attributes
+     */
+    public function __construct(array $uses, $type = self::TYPE_NORMAL, array $attributes = array()) {
+        parent::__construct($attributes);
+        $this->type = $type;
+        $this->uses = $uses;
+    }
+
+    public function getSubNodeNames() {
+        return array('type', 'uses');
+    }
+}

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

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