├── README.md
├── TestProject
    ├── ASTmainForTest.php
    ├── CrossParseTest.php
    ├── README.md
    ├── VulnerabilityTest
    │   ├── branch_test
    │   │   ├── if-else.php
    │   │   ├── if-no_else.php
    │   │   ├── readme.md
    │   │   ├── switch-default.php
    │   │   ├── switch-no_default.php
    │   │   └── try-catch.php
    │   ├── crossfile_test
    │   │   ├── 1.php
    │   │   ├── 2.php
    │   │   ├── 3.php
    │   │   └── main.php
    │   ├── rce
    │   │   └── rce.php
    │   ├── sanitizer_test
    │   │   └── sanitizer_test.php
    │   ├── sql注入
    │   │   ├── 1.php
    │   │   ├── 2.php
    │   │   └── 3.php
    │   ├── think
    │   └── transfer_test
    │   │   └── transfer_test.php
    └── test.php
├── analyze.php
├── analyze_func.php
├── assets
    ├── css
    │   └── bootstrap.min.css
    └── js
    │   ├── bootstrap.min.js
    │   ├── jquery-3.4.1.js
    │   └── jquery-3.4.1.min.js
├── composer.json
├── composer.lock
├── config
    ├── AstToIrConverter.php
    ├── TaintFlowAnalysisCore.php
    ├── analysis
    │   ├── Sanitizer.php
    │   ├── Sink.php
    │   ├── Source.php
    │   └── TaintAnalyzer.php
    ├── control_flow
    │   ├── BasicBlockHandler.php
    │   └── CFGBuilder.php
    └── utils
    │   ├── FuncTable.php
    │   └── Visitor.php
├── favicon.ico
├── global.php
├── index.php
└── vendor
    ├── autoload.php
    ├── bin
        ├── php-parse
        └── php-parse.bat
    ├── composer
        ├── ClassLoader.php
        ├── InstalledVersions.php
        ├── LICENSE
        ├── autoload_classmap.php
        ├── autoload_namespaces.php
        ├── autoload_psr4.php
        ├── autoload_real.php
        ├── autoload_static.php
        ├── installed.json
        ├── installed.php
        └── platform_check.php
    └── nikic
        └── php-parser
            ├── LICENSE
            ├── README.md
            ├── bin
                └── php-parse
            ├── composer.json
            └── lib
                └── PhpParser
                    ├── Builder.php
                    ├── Builder
                        ├── ClassConst.php
                        ├── Class_.php
                        ├── Declaration.php
                        ├── EnumCase.php
                        ├── Enum_.php
                        ├── FunctionLike.php
                        ├── Function_.php
                        ├── Interface_.php
                        ├── Method.php
                        ├── Namespace_.php
                        ├── Param.php
                        ├── Property.php
                        ├── TraitUse.php
                        ├── TraitUseAdaptation.php
                        ├── Trait_.php
                        └── Use_.php
                    ├── BuilderFactory.php
                    ├── BuilderHelpers.php
                    ├── Comment.php
                    ├── Comment
                        └── Doc.php
                    ├── ConstExprEvaluationException.php
                    ├── ConstExprEvaluator.php
                    ├── Error.php
                    ├── ErrorHandler.php
                    ├── ErrorHandler
                        ├── Collecting.php
                        └── Throwing.php
                    ├── Internal
                        ├── DiffElem.php
                        ├── Differ.php
                        ├── PrintableNewAnonClassNode.php
                        └── TokenStream.php
                    ├── JsonDecoder.php
                    ├── Lexer.php
                    ├── Lexer
                        ├── Emulative.php
                        └── TokenEmulator
                        │   ├── AttributeEmulator.php
                        │   ├── CoaleseEqualTokenEmulator.php
                        │   ├── EnumTokenEmulator.php
                        │   ├── ExplicitOctalEmulator.php
                        │   ├── FlexibleDocStringEmulator.php
                        │   ├── FnTokenEmulator.php
                        │   ├── KeywordEmulator.php
                        │   ├── MatchTokenEmulator.php
                        │   ├── NullsafeTokenEmulator.php
                        │   ├── NumericLiteralSeparatorEmulator.php
                        │   ├── ReadonlyFunctionTokenEmulator.php
                        │   ├── ReadonlyTokenEmulator.php
                        │   ├── ReverseEmulator.php
                        │   └── TokenEmulator.php
                    ├── NameContext.php
                    ├── Node.php
                    ├── Node
                        ├── Arg.php
                        ├── Attribute.php
                        ├── AttributeGroup.php
                        ├── ComplexType.php
                        ├── Const_.php
                        ├── Expr.php
                        ├── Expr
                        │   ├── ArrayDimFetch.php
                        │   ├── ArrayItem.php
                        │   ├── Array_.php
                        │   ├── ArrowFunction.php
                        │   ├── Assign.php
                        │   ├── AssignOp.php
                        │   ├── AssignOp
                        │   │   ├── BitwiseAnd.php
                        │   │   ├── BitwiseOr.php
                        │   │   ├── BitwiseXor.php
                        │   │   ├── Coalesce.php
                        │   │   ├── Concat.php
                        │   │   ├── Div.php
                        │   │   ├── Minus.php
                        │   │   ├── Mod.php
                        │   │   ├── Mul.php
                        │   │   ├── Plus.php
                        │   │   ├── Pow.php
                        │   │   ├── ShiftLeft.php
                        │   │   └── ShiftRight.php
                        │   ├── AssignRef.php
                        │   ├── BinaryOp.php
                        │   ├── BinaryOp
                        │   │   ├── BitwiseAnd.php
                        │   │   ├── BitwiseOr.php
                        │   │   ├── BitwiseXor.php
                        │   │   ├── BooleanAnd.php
                        │   │   ├── BooleanOr.php
                        │   │   ├── Coalesce.php
                        │   │   ├── Concat.php
                        │   │   ├── Div.php
                        │   │   ├── Equal.php
                        │   │   ├── Greater.php
                        │   │   ├── GreaterOrEqual.php
                        │   │   ├── Identical.php
                        │   │   ├── LogicalAnd.php
                        │   │   ├── LogicalOr.php
                        │   │   ├── LogicalXor.php
                        │   │   ├── Minus.php
                        │   │   ├── Mod.php
                        │   │   ├── Mul.php
                        │   │   ├── NotEqual.php
                        │   │   ├── NotIdentical.php
                        │   │   ├── Plus.php
                        │   │   ├── Pow.php
                        │   │   ├── ShiftLeft.php
                        │   │   ├── ShiftRight.php
                        │   │   ├── Smaller.php
                        │   │   ├── SmallerOrEqual.php
                        │   │   └── Spaceship.php
                        │   ├── BitwiseNot.php
                        │   ├── BooleanNot.php
                        │   ├── CallLike.php
                        │   ├── Cast.php
                        │   ├── Cast
                        │   │   ├── Array_.php
                        │   │   ├── Bool_.php
                        │   │   ├── Double.php
                        │   │   ├── Int_.php
                        │   │   ├── Object_.php
                        │   │   ├── String_.php
                        │   │   └── Unset_.php
                        │   ├── ClassConstFetch.php
                        │   ├── Clone_.php
                        │   ├── Closure.php
                        │   ├── ClosureUse.php
                        │   ├── ConstFetch.php
                        │   ├── Empty_.php
                        │   ├── Error.php
                        │   ├── ErrorSuppress.php
                        │   ├── Eval_.php
                        │   ├── Exit_.php
                        │   ├── FuncCall.php
                        │   ├── Include_.php
                        │   ├── Instanceof_.php
                        │   ├── Isset_.php
                        │   ├── List_.php
                        │   ├── Match_.php
                        │   ├── MethodCall.php
                        │   ├── New_.php
                        │   ├── NullsafeMethodCall.php
                        │   ├── NullsafePropertyFetch.php
                        │   ├── PostDec.php
                        │   ├── PostInc.php
                        │   ├── PreDec.php
                        │   ├── PreInc.php
                        │   ├── Print_.php
                        │   ├── PropertyFetch.php
                        │   ├── ShellExec.php
                        │   ├── StaticCall.php
                        │   ├── StaticPropertyFetch.php
                        │   ├── Ternary.php
                        │   ├── Throw_.php
                        │   ├── UnaryMinus.php
                        │   ├── UnaryPlus.php
                        │   ├── Variable.php
                        │   ├── YieldFrom.php
                        │   └── Yield_.php
                        ├── FunctionLike.php
                        ├── Identifier.php
                        ├── IntersectionType.php
                        ├── MatchArm.php
                        ├── Name.php
                        ├── Name
                        │   ├── FullyQualified.php
                        │   └── Relative.php
                        ├── NullableType.php
                        ├── Param.php
                        ├── Scalar.php
                        ├── Scalar
                        │   ├── DNumber.php
                        │   ├── Encapsed.php
                        │   ├── EncapsedStringPart.php
                        │   ├── LNumber.php
                        │   ├── MagicConst.php
                        │   ├── MagicConst
                        │   │   ├── Class_.php
                        │   │   ├── Dir.php
                        │   │   ├── File.php
                        │   │   ├── Function_.php
                        │   │   ├── Line.php
                        │   │   ├── Method.php
                        │   │   ├── Namespace_.php
                        │   │   └── Trait_.php
                        │   └── String_.php
                        ├── Stmt.php
                        ├── Stmt
                        │   ├── Break_.php
                        │   ├── Case_.php
                        │   ├── Catch_.php
                        │   ├── ClassConst.php
                        │   ├── ClassLike.php
                        │   ├── ClassMethod.php
                        │   ├── Class_.php
                        │   ├── Const_.php
                        │   ├── Continue_.php
                        │   ├── DeclareDeclare.php
                        │   ├── Declare_.php
                        │   ├── Do_.php
                        │   ├── Echo_.php
                        │   ├── ElseIf_.php
                        │   ├── Else_.php
                        │   ├── EnumCase.php
                        │   ├── Enum_.php
                        │   ├── Expression.php
                        │   ├── Finally_.php
                        │   ├── For_.php
                        │   ├── Foreach_.php
                        │   ├── Function_.php
                        │   ├── Global_.php
                        │   ├── Goto_.php
                        │   ├── GroupUse.php
                        │   ├── HaltCompiler.php
                        │   ├── If_.php
                        │   ├── InlineHTML.php
                        │   ├── Interface_.php
                        │   ├── Label.php
                        │   ├── Namespace_.php
                        │   ├── Nop.php
                        │   ├── Property.php
                        │   ├── PropertyProperty.php
                        │   ├── Return_.php
                        │   ├── StaticVar.php
                        │   ├── Static_.php
                        │   ├── Switch_.php
                        │   ├── Throw_.php
                        │   ├── TraitUse.php
                        │   ├── TraitUseAdaptation.php
                        │   ├── TraitUseAdaptation
                        │   │   ├── Alias.php
                        │   │   └── Precedence.php
                        │   ├── Trait_.php
                        │   ├── TryCatch.php
                        │   ├── Unset_.php
                        │   ├── UseUse.php
                        │   ├── Use_.php
                        │   └── While_.php
                        ├── UnionType.php
                        ├── VarLikeIdentifier.php
                        └── VariadicPlaceholder.php
                    ├── NodeAbstract.php
                    ├── NodeDumper.php
                    ├── NodeFinder.php
                    ├── NodeTraverser.php
                    ├── NodeTraverserInterface.php
                    ├── NodeVisitor.php
                    ├── NodeVisitor
                        ├── CloningVisitor.php
                        ├── FindingVisitor.php
                        ├── FirstFindingVisitor.php
                        ├── NameResolver.php
                        ├── NodeConnectingVisitor.php
                        └── ParentConnectingVisitor.php
                    ├── NodeVisitorAbstract.php
                    ├── Parser.php
                    ├── Parser
                        ├── Multiple.php
                        ├── Php5.php
                        ├── Php7.php
                        └── Tokens.php
                    ├── ParserAbstract.php
                    ├── ParserFactory.php
                    ├── PrettyPrinter
                        └── Standard.php
                    └── PrettyPrinterAbstract.php


/TestProject/ASTmainForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PhpParser\Error;
 4 | use PhpParser\ParserFactory;
 5 | use PhpParser\NodeDumper;
 6 | use PhpParser\Node;
 7 | use PhpParser\Node\Stmt\Function_;
 8 | use PhpParser\NodeTraverser;
 9 | use PhpParser\NodeVisitorAbstract;
10 | use PhpParser\PrettyPrinter;
11 | 
12 | require '../global.php';
13 | 
14 | // Start time tracking
15 | $startTime = microtime(true);
16 | 
17 | try {
18 |     $parser = new PhpParser\Parser\Php7(new PhpParser\Lexer\Emulative());
19 |     $filePath = './test.php';
20 |     $code = file_get_contents($filePath);
21 | 
22 |     // 自动将所有的 'else if' 转换成 'elseif'
23 |     $code = preg_replace('/\belse\s+if\b/', 'elseif', $code);
24 | 
25 |     $parseResult = $parser->parse($code);
26 |     $NodeInitVisitor = new NodeInitVisitor();
27 |     $traverser = new PhpParser\NodeTraverser();
28 |     $traverser->addVisitor($NodeInitVisitor);
29 |     $traverser->traverse($parseResult);
30 | 
31 |     $nodes = $NodeInitVisitor->getNodes();
32 |     $AstToIrConverter = new AstToIrConverter();
33 |     $quads = $AstToIrConverter->AstParse($nodes); //返回四元组
34 |     $quad_id = count($quads); //quad总数
35 |     $a = 0;
36 |     //遍历每一个quad
37 |     for ($i = 1; $i < $quad_id; $i++) {
38 | 
39 |         //分支语句整体的开始
40 |         if ($quads[$i]->opcode == "Stmt_Branch_Start") {
41 |             $a++;
42 |         }
43 |     }
44 |     var_dump($a);
45 |     $flow_graph = new ControlFlowGraph();
46 |     $flow_graph->process($quads);
47 | 
48 |     // var_dump($parseResult); //AST
49 |     // var_dump($AstToIrConverter->funcs); //方法表
50 |     // var_dump($quads); //Q_IR
51 |     // //var_dump($flow_graph->BasicBlockHandler->BasicBlock); //基本块
52 |     // var_dump($flow_graph->CFGBuilder->CFG); //CFG
53 |     // var_dump($flow_graph->TaintAnalyzer->varMap); //变量
54 |     var_dump($flow_graph->sinks); //污点
55 | } catch (Error $e) {
56 |     echo 'Parse Error: ', $e->getMessage(), "\n";
57 | }
58 | 
59 | $endTime = microtime(true);
60 | 
61 | //计算耗时
62 | $executionTime = $endTime - $startTime;
63 | echo "Execution Time: " . round($executionTime, 4) . " seconds\n";
64 | 


--------------------------------------------------------------------------------
/TestProject/README.md:
--------------------------------------------------------------------------------
 1 | VulnerabilityTest目录是一些测试漏洞的代码
 2 | 
 3 | ASTmainForTest.php(用于单文件)和CrossParseTest.php(用于跨文件的函数解析)都是开发过程中使用的测试代码，可以看到他读取了test.php进行处理，核心逻辑是
 4 | 
 5 | ```
 6 | var_dump($parseResult); //AST
 7 | var_dump($quads); //Q_IR
 8 | var_dump($flow_graph->BasicBlockHandler->BasicBlock); //基本块
 9 | var_dump($flow_graph->CFGBuilder->CFG); //CFG
10 | var_dump($flow_graph->TaintAnalyzer->varMap); //变量
11 | var_dump($flow_graph->sinks); //污点
12 | ```
13 | 
14 | 可以输出代码运行过程中产生的AST、IR、基本块、CFG、变量表和污点，便于调试


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/branch_test/if-else.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | $age = $_POST[1];
 3 | if ($age < 18) {
 4 |     system($age);
 5 | } elseif ($age == 18) {
 6 |     $age = 1;
 7 |     echo $age;
 8 | } elseif ($age == 19) {
 9 |     eval($age);
10 | } else {
11 |     echo $age;
12 | }
13 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/branch_test/if-no_else.php:
--------------------------------------------------------------------------------
1 | <?php
2 | $age = $_POST[1];
3 | if ($age < 18) {
4 |     $age = $age . "1";
5 | } elseif ($age == 18) {
6 |     $age = 1;
7 | }
8 | system($age);
9 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/branch_test/readme.md:
--------------------------------------------------------------------------------
 1 | ## 分支语句的测试用例
 2 | 
 3 | 对于分支语句，每一种分支视作一条不同的控制流，目前支持if try switch
 4 | 
 5 | ## try
 6 | 
 7 | ```
 8 | <?php
 9 | $a = $_POST[1];
10 | try {
11 |     $b = $a;
12 |     $a = 1;
13 |     $c = $a . $b;
14 |     $d = $a;
15 |     echo $c;
16 | } catch (Exception $e) {
17 |     $d = $a;
18 |     echo $d;
19 | }
20 | ```
21 | 
22 | try-catch语句，try是一条控制流，catch是另一条控制流
23 | 
24 | ## if
25 | 
26 | 大致分为两种情况，没有else和有else的情况。
27 | 
28 | 有else的情况下，if elseif else语句都是一条流
29 | 
30 | ```
31 | <?php
32 | $age = 18;
33 | 
34 | if ($age < 18) {
35 |     echo "未成年";
36 | } elseif ($age == 18) {
37 |     echo "刚满18岁";
38 | } else {
39 |     echo "成年人";
40 | }
41 | ?>
42 | ```
43 | 
44 | 没有else的情况下，if elseif是一条流，由于不存在else，因此还应当存在一条不经过if语句的流
45 | 
46 | ```
47 | <?php
48 | $age = 18;
49 | 
50 | if ($age < 18) {
51 |     echo "未成年";
52 | } elseif ($age == 18) {
53 |     echo "刚满18岁";
54 | }
55 | ?>
56 | ```
57 | 
58 | ## switch
59 | 
60 | 分为两种情况，有default和没有default
61 | 
62 | 注意 case和default本质没有不同，只是default没有条件
63 | 
64 | 有default时，case和default分别是一条流
65 | 
66 | ```
67 | <?php
68 | $day = 3;
69 | 
70 | switch ($day) {
71 |     case 1:
72 |         echo "星期一";
73 |         break;
74 |     default:
75 |         echo "无效的日期";
76 | }
77 | ?>
78 | ```
79 | 
80 | 没有default时，注意还存在一条不经过switch的流
81 | 
82 | ```
83 | <?php
84 | $day = 3;
85 | 
86 | switch ($day) {
87 |     case 1:
88 |         echo "星期一";
89 |         break;
90 | }
91 | ?>
92 | ```
93 | 
94 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/branch_test/switch-default.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | $a = $_POST[1];
 3 | 
 4 | switch ($day) {
 5 |     case 1:
 6 |         echo $a;
 7 |     case 2:
 8 |         system($a);
 9 |     default:;
10 |         $a = 1;
11 |         echo $a;
12 | }
13 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/branch_test/switch-no_default.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | $a = $_POST[1];
 3 | 
 4 | switch ($day) {
 5 |     case 1:
 6 |         $a = $a . "1";
 7 |     case 2:
 8 |         $a = 1;
 9 | }
10 | echo $a;
11 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/branch_test/try-catch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | $a = $_POST[1];
 3 | try {
 4 |     $b = $a;
 5 |     $e = 1;
 6 |     $c = $b . $e;
 7 |     echo $c;
 8 | } catch (Exception $e) {
 9 |     $d = $a;
10 |     echo $d;
11 | }
12 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/crossfile_test/1.php:
--------------------------------------------------------------------------------
1 | <?php
2 | //1.php
3 | function a($c)
4 | {
5 |     b($c);
6 | }
7 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/crossfile_test/2.php:
--------------------------------------------------------------------------------
1 | <?php
2 | function b($c)
3 | {
4 |     c($c, null, null);
5 | }
6 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/crossfile_test/3.php:
--------------------------------------------------------------------------------
1 | <?php
2 | function c($c, $d, $e)
3 | {
4 |     system($c);
5 | }
6 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/crossfile_test/main.php:
--------------------------------------------------------------------------------
1 | <?php
2 | include '1.php';
3 | include '2.php';
4 | include '3.php';
5 | 
6 | 
7 | $a = $_POST[1];
8 | a($a);
9 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/sanitizer_test/sanitizer_test.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //该函数事先已在Sanitizer.php被处理成sanitizer
 3 | function sanitizer_test($a)
 4 | {
 5 |     return $a;
 6 | }
 7 | 
 8 | function demo($b)
 9 | {
10 |     return $b;
11 | }
12 | 
13 | $a_taint = $_GET['a'];
14 | $d = sanitizer_test($a_taint);
15 | $e = demo($a_taint);
16 | system($d);
17 | system($e);
18 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/sql注入/1.php:
--------------------------------------------------------------------------------
1 | <?php
2 | class danmu
3 | {
4 |     public function 编辑弹幕($cid)
5 |     {
6 |         sql::编辑_弹幕($cid);
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/sql注入/2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | class sql
 3 | {
 4 |     public static function 编辑_弹幕($cid)
 5 |     {
 6 |         try {
 7 |             global $_config;
 8 |             $text = $_POST['text'];
 9 |             $color = $_POST['color'];
10 |             $conn = @new mysqli($_config['数据库']['地址'], $_config['数据库']['用户名'], $_config['数据库']['密码'], $_config['数据库']['名称'], $_config['数据库']['端口']);
11 | 
12 |             $sql = "UPDATE sea_danmaku_list SET text='$text',color='$color' WHERE cid=$cid";
13 |             $result = "UPDATE sea_danmaku_report SET text='$text',color='$color' WHERE cid=$cid";
14 |             $conn->query($sql);
15 |             $conn->query($result);
16 |         } catch (PDOException $e) {
17 |             showmessage(-1, '数据库错误:' . $e->getMessage());
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/sql注入/3.php:
--------------------------------------------------------------------------------
1 | <?php
2 | $cid = $_POST['cid'] ?: showmessage(-1, null);
3 | $data = $d->编辑弹幕($cid) ?:  succeedmsg(0, '完成');
4 | 


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/think:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Fushuling/TaintScaner/5eb01f8affbcbe0a5edb8ee2ba91bda3100619da/TestProject/VulnerabilityTest/think


--------------------------------------------------------------------------------
/TestProject/VulnerabilityTest/transfer_test/transfer_test.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $a = $_POST[1];
 4 | //trim是transfer
 5 | $processed_a = trim($a);
 6 | //addslashes不是transfer，是sanitizer，截断污点传播
 7 | $processed_b = addslashes($a);
 8 | 
 9 | system($processed_a);
10 | system($processed_b);
11 | 


--------------------------------------------------------------------------------
/TestProject/test.php:
--------------------------------------------------------------------------------
1 | <?php
2 | $cid = $_POST['cid'];
3 | $data = $d->query($cid);
4 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
1 | {
2 |     "require": {
3 |         "nikic/php-parser": "^4.2"
4 |     }
5 | }
6 | 


--------------------------------------------------------------------------------
/config/analysis/Sanitizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | //Sanitizer集合
 4 | 
 5 | /*
 6 | 默认情况下，所有内置函数和用户函数都视作可以传播污点流。若函数名在Sanitizer中，则无法传播
 7 | */
 8 | 
 9 | $SanitizerAll = array(
10 |     'sanitizer_test',
11 |     'htmlspecialchars',
12 |     'filter_var',
13 |     'strip_tags',
14 |     'mysqli_real_escape_string',
15 |     'addslashes',
16 |     'str_ireplace',
17 |     'intval',
18 |     'md5',
19 | );
20 | 


--------------------------------------------------------------------------------
/config/analysis/Source.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //source点 用户输入
 3 | class Sources
 4 | {
 5 | 	/**
 6 | 	 * 获取用户的输入sources
 7 | 	 * @return array
 8 | 	 */
 9 | 	public static function GetUserInput()
10 | 	{
11 | 		// 增加递归深度限制标志
12 | 		static $callDepth = 0;
13 | 		$maxDepth = 50; // 设置最大递归深度
14 | 
15 | 		// 检查递归深度是否超出限制
16 | 		if ($callDepth >= $maxDepth) {
17 | 			trigger_error("Maximum recursion depth ($maxDepth) reached in GetUserInput", E_USER_WARNING);
18 | 			return [];
19 | 		}
20 | 
21 | 		$callDepth++; // 递归深度加1
22 | 
23 | 		try {
24 | 			$result = self::$userInput;
25 | 		} catch (Exception $e) {
26 | 			// 捕获可能的异常，防止程序崩溃
27 | 			trigger_error("Error in GetUserInput: " . $e->getMessage(), E_USER_WARNING);
28 | 			$result = [];
29 | 		}
30 | 
31 | 		$callDepth--; // 递归深度减1
32 | 		return $result;
33 | 	}
34 | 
35 | 	//用户输入参数
36 | 	public static $userInput = array(
37 | 		'_GET',
38 | 		'_POST',
39 | 		'_COOKIE',
40 | 		'_REQUEST',
41 | 		'_SERVER',
42 | 		'_ENV',
43 | 		'_SESSION'
44 | 	);
45 | }
46 | 


--------------------------------------------------------------------------------
/config/utils/FuncTable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //处理用户自定义函数
 3 | 
 4 | class func_table
 5 | {
 6 |     public $func_name; //方法名
 7 |     public $func_param; //方法的参数
 8 |     public $func_stmt; // 方法内部的声明啥的
 9 |     public $file_path; // 保存文件路径
10 |     //一共有四种flag： true false in null 
11 |     //true表示是sink false表示不是sink in表示正在搜索中，不知道具体信息(为了防止成环的) null就是还没遍历过
12 |     public $flag;
13 |     public $sink; //保存污点路径
14 | 
15 |     public function __construct($func_name = null, $func_param = null, $func_stmt = null, $file_path = null, $flag = null)
16 |     {
17 |         $this->func_name = $func_name;
18 |         $this->func_param = $func_param;
19 |         $this->func_stmt = $func_stmt;
20 |         $this->file_path = $file_path; // 将文件路径赋值给类属性
21 |         $this->flag = $flag;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/config/utils/Visitor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 | NodeInitVisitor继承PhpParser\NodeVisitorAbstract，实现对AST节点遍历的自定义逻辑。
 4 | */
 5 | class NodeInitVisitor extends PhpParser\NodeVisitorAbstract{
 6 |     private $nodes = array();
 7 |     //在遍历前将所有节点存储到 $nodes 数组中
 8 |     public function beforeTraverse(array $nodes){
 9 |         $this->nodes = $nodes ;
10 |     }
11 |     //提供获取这些节点的接口
12 |     public function getNodes(){
13 |         return $this->nodes ;
14 |     }
15 | }
16 | 
17 | 


--------------------------------------------------------------------------------
/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Fushuling/TaintScaner/5eb01f8affbcbe0a5edb8ee2ba91bda3100619da/favicon.ico


--------------------------------------------------------------------------------
/global.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //包含必要的配置文件
 3 | include 'vendor/autoload.php';
 4 | 
 5 | require 'config/AstToIrConverter.php';  //AST->Q_IR
 6 | require 'config/TaintFlowAnalysisCore.php'; //污点分析核心逻辑
 7 | 
 8 | require 'config/analysis/Sink.php';
 9 | require 'config/analysis/Source.php';
10 | require 'config/analysis/TaintAnalyzer.php';
11 | require 'config/analysis/Sanitizer.php';
12 | 
13 | require 'config/control_flow/BasicBlockHandler.php';
14 | require 'config/control_flow/CFGBuilder.php';
15 | 
16 | 
17 | require 'config/utils/Visitor.php';
18 | require 'config/utils/FuncTable.php';
19 | 


--------------------------------------------------------------------------------
/vendor/autoload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload.php @generated by Composer
 4 | 
 5 | if (PHP_VERSION_ID < 50600) {
 6 |     if (!headers_sent()) {
 7 |         header('HTTP/1.1 500 Internal Server Error');
 8 |     }
 9 |     $err = 'Composer 2.3.0 dropped support for autoloading on PHP <5.6 and you are running '.PHP_VERSION.', please upgrade PHP or use Composer 2.2 LTS via "composer self-update --2.2". Aborting.'.PHP_EOL;
10 |     if (!ini_get('display_errors')) {
11 |         if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
12 |             fwrite(STDERR, $err);
13 |         } elseif (!headers_sent()) {
14 |             echo $err;
15 |         }
16 |     }
17 |     trigger_error(
18 |         $err,
19 |         E_USER_ERROR
20 |     );
21 | }
22 | 
23 | require_once __DIR__ . '/composer/autoload_real.php';
24 | 
25 | return ComposerAutoloaderInit2e49afaa0b65ddf0f5750ceeba7b0334::getLoader();
26 | 


--------------------------------------------------------------------------------
/vendor/bin/php-parse.bat:
--------------------------------------------------------------------------------
1 | @ECHO OFF
2 | setlocal DISABLEDELAYEDEXPANSION
3 | SET BIN_TARGET=%~dp0/php-parse
4 | SET COMPOSER_RUNTIME_BIN_DIR=%~dp0
5 | php "%BIN_TARGET%" %*
6 | 


--------------------------------------------------------------------------------
/vendor/composer/LICENSE:
--------------------------------------------------------------------------------
 1 | 
 2 | Copyright (c) Nils Adermann, Jordi Boggiano
 3 | 
 4 | Permission is hereby granted, free of charge, to any person obtaining a copy
 5 | of this software and associated documentation files (the "Software"), to deal
 6 | in the Software without restriction, including without limitation the rights
 7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the Software is furnished
 9 | to do so, subject to the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be included in all
12 | copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 | THE SOFTWARE.
21 | 
22 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_classmap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_classmap.php @generated by Composer
 4 | 
 5 | $vendorDir = dirname(__DIR__);
 6 | $baseDir = dirname($vendorDir);
 7 | 
 8 | return array(
 9 |     'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
10 | );
11 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_namespaces.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_namespaces.php @generated by Composer
 4 | 
 5 | $vendorDir = dirname(__DIR__);
 6 | $baseDir = dirname($vendorDir);
 7 | 
 8 | return array(
 9 | );
10 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_psr4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_psr4.php @generated by Composer
 4 | 
 5 | $vendorDir = dirname(__DIR__);
 6 | $baseDir = dirname($vendorDir);
 7 | 
 8 | return array(
 9 |     'PhpParser\\' => array($vendorDir . '/nikic/php-parser/lib/PhpParser'),
10 | );
11 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_real.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_real.php @generated by Composer
 4 | 
 5 | class ComposerAutoloaderInit2e49afaa0b65ddf0f5750ceeba7b0334
 6 | {
 7 |     private static $loader;
 8 | 
 9 |     public static function loadClassLoader($class)
10 |     {
11 |         if ('Composer\Autoload\ClassLoader' === $class) {
12 |             require __DIR__ . '/ClassLoader.php';
13 |         }
14 |     }
15 | 
16 |     /**
17 |      * @return \Composer\Autoload\ClassLoader
18 |      */
19 |     public static function getLoader()
20 |     {
21 |         if (null !== self::$loader) {
22 |             return self::$loader;
23 |         }
24 | 
25 |         require __DIR__ . '/platform_check.php';
26 | 
27 |         spl_autoload_register(array('ComposerAutoloaderInit2e49afaa0b65ddf0f5750ceeba7b0334', 'loadClassLoader'), true, true);
28 |         self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(__DIR__));
29 |         spl_autoload_unregister(array('ComposerAutoloaderInit2e49afaa0b65ddf0f5750ceeba7b0334', 'loadClassLoader'));
30 | 
31 |         require __DIR__ . '/autoload_static.php';
32 |         call_user_func(\Composer\Autoload\ComposerStaticInit2e49afaa0b65ddf0f5750ceeba7b0334::getInitializer($loader));
33 | 
34 |         $loader->register(true);
35 | 
36 |         return $loader;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/vendor/composer/autoload_static.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // autoload_static.php @generated by Composer
 4 | 
 5 | namespace Composer\Autoload;
 6 | 
 7 | class ComposerStaticInit2e49afaa0b65ddf0f5750ceeba7b0334
 8 | {
 9 |     public static $prefixLengthsPsr4 = array (
10 |         'P' => 
11 |         array (
12 |             'PhpParser\\' => 10,
13 |         ),
14 |     );
15 | 
16 |     public static $prefixDirsPsr4 = array (
17 |         'PhpParser\\' => 
18 |         array (
19 |             0 => __DIR__ . '/..' . '/nikic/php-parser/lib/PhpParser',
20 |         ),
21 |     );
22 | 
23 |     public static $classMap = array (
24 |         'Composer\\InstalledVersions' => __DIR__ . '/..' . '/composer/InstalledVersions.php',
25 |     );
26 | 
27 |     public static function getInitializer(ClassLoader $loader)
28 |     {
29 |         return \Closure::bind(function () use ($loader) {
30 |             $loader->prefixLengthsPsr4 = ComposerStaticInit2e49afaa0b65ddf0f5750ceeba7b0334::$prefixLengthsPsr4;
31 |             $loader->prefixDirsPsr4 = ComposerStaticInit2e49afaa0b65ddf0f5750ceeba7b0334::$prefixDirsPsr4;
32 |             $loader->classMap = ComposerStaticInit2e49afaa0b65ddf0f5750ceeba7b0334::$classMap;
33 | 
34 |         }, null, ClassLoader::class);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/vendor/composer/installed.php:
--------------------------------------------------------------------------------
 1 | <?php return array(
 2 |     'root' => array(
 3 |         'name' => '__root__',
 4 |         'pretty_version' => '1.0.0+no-version-set',
 5 |         'version' => '1.0.0.0',
 6 |         'reference' => null,
 7 |         'type' => 'library',
 8 |         'install_path' => __DIR__ . '/../../',
 9 |         'aliases' => array(),
10 |         'dev' => true,
11 |     ),
12 |     'versions' => array(
13 |         '__root__' => array(
14 |             'pretty_version' => '1.0.0+no-version-set',
15 |             'version' => '1.0.0.0',
16 |             'reference' => null,
17 |             'type' => 'library',
18 |             'install_path' => __DIR__ . '/../../',
19 |             'aliases' => array(),
20 |             'dev_requirement' => false,
21 |         ),
22 |         'nikic/php-parser' => array(
23 |             'pretty_version' => 'v4.19.4',
24 |             'version' => '4.19.4.0',
25 |             'reference' => '715f4d25e225bc47b293a8b997fe6ce99bf987d2',
26 |             'type' => 'library',
27 |             'install_path' => __DIR__ . '/../nikic/php-parser',
28 |             'aliases' => array(),
29 |             'dev_requirement' => false,
30 |         ),
31 |     ),
32 | );
33 | 


--------------------------------------------------------------------------------
/vendor/composer/platform_check.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // platform_check.php @generated by Composer
 4 | 
 5 | $issues = array();
 6 | 
 7 | if (!(PHP_VERSION_ID >= 70100)) {
 8 |     $issues[] = 'Your Composer dependencies require a PHP version ">= 7.1.0". You are running ' . PHP_VERSION . '.';
 9 | }
10 | 
11 | if ($issues) {
12 |     if (!headers_sent()) {
13 |         header('HTTP/1.1 500 Internal Server Error');
14 |     }
15 |     if (!ini_get('display_errors')) {
16 |         if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
17 |             fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL);
18 |         } elseif (!headers_sent()) {
19 |             echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL;
20 |         }
21 |     }
22 |     trigger_error(
23 |         'Composer detected issues in your platform: ' . implode(' ', $issues),
24 |         E_USER_ERROR
25 |     );
26 | }
27 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 3-Clause License
 2 | 
 3 | Copyright (c) 2011, Nikita Popov
 4 | All rights reserved.
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, are permitted provided that the following conditions are met:
 8 | 
 9 | 1. Redistributions of source code must retain the above copyright notice, this
10 |    list of conditions and the following disclaimer.
11 | 
12 | 2. Redistributions in binary form must reproduce the above copyright notice,
13 |    this list of conditions and the following disclaimer in the documentation
14 |    and/or other materials provided with the distribution.
15 | 
16 | 3. Neither the name of the copyright holder nor the names of its
17 |    contributors may be used to endorse or promote products derived from
18 |    this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "nikic/php-parser",
 3 |     "type": "library",
 4 |     "description": "A PHP parser written in PHP",
 5 |     "keywords": [
 6 |         "php",
 7 |         "parser"
 8 |     ],
 9 |     "license": "BSD-3-Clause",
10 |     "authors": [
11 |         {
12 |             "name": "Nikita Popov"
13 |         }
14 |     ],
15 |     "require": {
16 |         "php": ">=7.1",
17 |         "ext-tokenizer": "*"
18 |     },
19 |     "require-dev": {
20 |         "phpunit/phpunit": "^7.0 || ^8.0 || ^9.0",
21 |         "ircmaxell/php-yacc": "^0.0.7"
22 |     },
23 |     "extra": {
24 |         "branch-alias": {
25 |             "dev-master": "4.9-dev"
26 |         }
27 |     },
28 |     "autoload": {
29 |         "psr-4": {
30 |             "PhpParser\\": "lib/PhpParser"
31 |         }
32 |     },
33 |     "autoload-dev": {
34 |         "psr-4": {
35 |             "PhpParser\\": "test/PhpParser/"
36 |         }
37 |     },
38 |     "bin": [
39 |         "bin/php-parse"
40 |     ]
41 | }
42 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Builder.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser;
 4 | 
 5 | interface Builder
 6 | {
 7 |     /**
 8 |      * Returns the built node.
 9 |      *
10 |      * @return Node The built node
11 |      */
12 |     public function getNode() : Node;
13 | }
14 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Builder/Declaration.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Builder;
 4 | 
 5 | use PhpParser;
 6 | use PhpParser\BuilderHelpers;
 7 | 
 8 | abstract class Declaration implements PhpParser\Builder
 9 | {
10 |     protected $attributes = [];
11 | 
12 |     abstract public function addStmt($stmt);
13 | 
14 |     /**
15 |      * Adds multiple statements.
16 |      *
17 |      * @param array $stmts The statements to add
18 |      *
19 |      * @return $this The builder instance (for fluid interface)
20 |      */
21 |     public function addStmts(array $stmts) {
22 |         foreach ($stmts as $stmt) {
23 |             $this->addStmt($stmt);
24 |         }
25 | 
26 |         return $this;
27 |     }
28 | 
29 |     /**
30 |      * Sets doc comment for the declaration.
31 |      *
32 |      * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
33 |      *
34 |      * @return $this The builder instance (for fluid interface)
35 |      */
36 |     public function setDocComment($docComment) {
37 |         $this->attributes['comments'] = [
38 |             BuilderHelpers::normalizeDocComment($docComment)
39 |         ];
40 | 
41 |         return $this;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Builder/EnumCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpParser\Builder;
 6 | 
 7 | use PhpParser;
 8 | use PhpParser\BuilderHelpers;
 9 | use PhpParser\Node;
10 | use PhpParser\Node\Identifier;
11 | use PhpParser\Node\Stmt;
12 | 
13 | class EnumCase implements PhpParser\Builder
14 | {
15 |     protected $name;
16 |     protected $value = null;
17 |     protected $attributes = [];
18 | 
19 |     /** @var Node\AttributeGroup[] */
20 |     protected $attributeGroups = [];
21 | 
22 |     /**
23 |      * Creates an enum case builder.
24 |      *
25 |      * @param string|Identifier $name  Name
26 |      */
27 |     public function __construct($name) {
28 |         $this->name = $name;
29 |     }
30 | 
31 |     /**
32 |      * Sets the value.
33 |      *
34 |      * @param Node\Expr|string|int $value
35 |      *
36 |      * @return $this
37 |      */
38 |     public function setValue($value) {
39 |         $this->value = BuilderHelpers::normalizeValue($value);
40 | 
41 |         return $this;
42 |     }
43 | 
44 |     /**
45 |      * Sets doc comment for the constant.
46 |      *
47 |      * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
48 |      *
49 |      * @return $this The builder instance (for fluid interface)
50 |      */
51 |     public function setDocComment($docComment) {
52 |         $this->attributes = [
53 |             'comments' => [BuilderHelpers::normalizeDocComment($docComment)]
54 |         ];
55 | 
56 |         return $this;
57 |     }
58 | 
59 |     /**
60 |      * Adds an attribute group.
61 |      *
62 |      * @param Node\Attribute|Node\AttributeGroup $attribute
63 |      *
64 |      * @return $this The builder instance (for fluid interface)
65 |      */
66 |     public function addAttribute($attribute) {
67 |         $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
68 | 
69 |         return $this;
70 |     }
71 | 
72 |     /**
73 |      * Returns the built enum case node.
74 |      *
75 |      * @return Stmt\EnumCase The built constant node
76 |      */
77 |     public function getNode(): PhpParser\Node {
78 |         return new Stmt\EnumCase(
79 |             $this->name,
80 |             $this->value,
81 |             $this->attributeGroups,
82 |             $this->attributes
83 |         );
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Builder/FunctionLike.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Builder;
 4 | 
 5 | use PhpParser\BuilderHelpers;
 6 | use PhpParser\Node;
 7 | 
 8 | abstract class FunctionLike extends Declaration
 9 | {
10 |     protected $returnByRef = false;
11 |     protected $params = [];
12 | 
13 |     /** @var string|Node\Name|Node\NullableType|null */
14 |     protected $returnType = null;
15 | 
16 |     /**
17 |      * Make the function return by reference.
18 |      *
19 |      * @return $this The builder instance (for fluid interface)
20 |      */
21 |     public function makeReturnByRef() {
22 |         $this->returnByRef = true;
23 | 
24 |         return $this;
25 |     }
26 | 
27 |     /**
28 |      * Adds a parameter.
29 |      *
30 |      * @param Node\Param|Param $param The parameter to add
31 |      *
32 |      * @return $this The builder instance (for fluid interface)
33 |      */
34 |     public function addParam($param) {
35 |         $param = BuilderHelpers::normalizeNode($param);
36 | 
37 |         if (!$param instanceof Node\Param) {
38 |             throw new \LogicException(sprintf('Expected parameter node, got "%s"', $param->getType()));
39 |         }
40 | 
41 |         $this->params[] = $param;
42 | 
43 |         return $this;
44 |     }
45 | 
46 |     /**
47 |      * Adds multiple parameters.
48 |      *
49 |      * @param array $params The parameters to add
50 |      *
51 |      * @return $this The builder instance (for fluid interface)
52 |      */
53 |     public function addParams(array $params) {
54 |         foreach ($params as $param) {
55 |             $this->addParam($param);
56 |         }
57 | 
58 |         return $this;
59 |     }
60 | 
61 |     /**
62 |      * Sets the return type for PHP 7.
63 |      *
64 |      * @param string|Node\Name|Node\Identifier|Node\ComplexType $type
65 |      *
66 |      * @return $this The builder instance (for fluid interface)
67 |      */
68 |     public function setReturnType($type) {
69 |         $this->returnType = BuilderHelpers::normalizeType($type);
70 | 
71 |         return $this;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Builder/Function_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Builder;
 4 | 
 5 | use PhpParser;
 6 | use PhpParser\BuilderHelpers;
 7 | use PhpParser\Node;
 8 | use PhpParser\Node\Stmt;
 9 | 
10 | class Function_ extends FunctionLike
11 | {
12 |     protected $name;
13 |     protected $stmts = [];
14 | 
15 |     /** @var Node\AttributeGroup[] */
16 |     protected $attributeGroups = [];
17 | 
18 |     /**
19 |      * Creates a function builder.
20 |      *
21 |      * @param string $name Name of the function
22 |      */
23 |     public function __construct(string $name) {
24 |         $this->name = $name;
25 |     }
26 | 
27 |     /**
28 |      * Adds a statement.
29 |      *
30 |      * @param Node|PhpParser\Builder $stmt The statement to add
31 |      *
32 |      * @return $this The builder instance (for fluid interface)
33 |      */
34 |     public function addStmt($stmt) {
35 |         $this->stmts[] = BuilderHelpers::normalizeStmt($stmt);
36 | 
37 |         return $this;
38 |     }
39 | 
40 |     /**
41 |      * Adds an attribute group.
42 |      *
43 |      * @param Node\Attribute|Node\AttributeGroup $attribute
44 |      *
45 |      * @return $this The builder instance (for fluid interface)
46 |      */
47 |     public function addAttribute($attribute) {
48 |         $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
49 | 
50 |         return $this;
51 |     }
52 | 
53 |     /**
54 |      * Returns the built function node.
55 |      *
56 |      * @return Stmt\Function_ The built function node
57 |      */
58 |     public function getNode() : Node {
59 |         return new Stmt\Function_($this->name, [
60 |             'byRef'      => $this->returnByRef,
61 |             'params'     => $this->params,
62 |             'returnType' => $this->returnType,
63 |             'stmts'      => $this->stmts,
64 |             'attrGroups' => $this->attributeGroups,
65 |         ], $this->attributes);
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Builder/Namespace_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Builder;
 4 | 
 5 | use PhpParser;
 6 | use PhpParser\BuilderHelpers;
 7 | use PhpParser\Node;
 8 | use PhpParser\Node\Stmt;
 9 | 
10 | class Namespace_ extends Declaration
11 | {
12 |     private $name;
13 |     private $stmts = [];
14 | 
15 |     /**
16 |      * Creates a namespace builder.
17 |      *
18 |      * @param Node\Name|string|null $name Name of the namespace
19 |      */
20 |     public function __construct($name) {
21 |         $this->name = null !== $name ? BuilderHelpers::normalizeName($name) : null;
22 |     }
23 | 
24 |     /**
25 |      * Adds a statement.
26 |      *
27 |      * @param Node|PhpParser\Builder $stmt The statement to add
28 |      *
29 |      * @return $this The builder instance (for fluid interface)
30 |      */
31 |     public function addStmt($stmt) {
32 |         $this->stmts[] = BuilderHelpers::normalizeStmt($stmt);
33 | 
34 |         return $this;
35 |     }
36 | 
37 |     /**
38 |      * Returns the built node.
39 |      *
40 |      * @return Stmt\Namespace_ The built node
41 |      */
42 |     public function getNode() : Node {
43 |         return new Stmt\Namespace_($this->name, $this->stmts, $this->attributes);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Builder/TraitUse.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Builder;
 4 | 
 5 | use PhpParser\Builder;
 6 | use PhpParser\BuilderHelpers;
 7 | use PhpParser\Node;
 8 | use PhpParser\Node\Stmt;
 9 | 
10 | class TraitUse implements Builder
11 | {
12 |     protected $traits = [];
13 |     protected $adaptations = [];
14 | 
15 |     /**
16 |      * Creates a trait use builder.
17 |      *
18 |      * @param Node\Name|string ...$traits Names of used traits
19 |      */
20 |     public function __construct(...$traits) {
21 |         foreach ($traits as $trait) {
22 |             $this->and($trait);
23 |         }
24 |     }
25 | 
26 |     /**
27 |      * Adds used trait.
28 |      *
29 |      * @param Node\Name|string $trait Trait name
30 |      *
31 |      * @return $this The builder instance (for fluid interface)
32 |      */
33 |     public function and($trait) {
34 |         $this->traits[] = BuilderHelpers::normalizeName($trait);
35 |         return $this;
36 |     }
37 | 
38 |     /**
39 |      * Adds trait adaptation.
40 |      *
41 |      * @param Stmt\TraitUseAdaptation|Builder\TraitUseAdaptation $adaptation Trait adaptation
42 |      *
43 |      * @return $this The builder instance (for fluid interface)
44 |      */
45 |     public function with($adaptation) {
46 |         $adaptation = BuilderHelpers::normalizeNode($adaptation);
47 | 
48 |         if (!$adaptation instanceof Stmt\TraitUseAdaptation) {
49 |             throw new \LogicException('Adaptation must have type TraitUseAdaptation');
50 |         }
51 | 
52 |         $this->adaptations[] = $adaptation;
53 |         return $this;
54 |     }
55 | 
56 |     /**
57 |      * Returns the built node.
58 |      *
59 |      * @return Node The built node
60 |      */
61 |     public function getNode() : Node {
62 |         return new Stmt\TraitUse($this->traits, $this->adaptations);
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Builder/Use_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Builder;
 4 | 
 5 | use PhpParser\Builder;
 6 | use PhpParser\BuilderHelpers;
 7 | use PhpParser\Node;
 8 | use PhpParser\Node\Stmt;
 9 | 
10 | class Use_ implements Builder
11 | {
12 |     protected $name;
13 |     protected $type;
14 |     protected $alias = null;
15 | 
16 |     /**
17 |      * Creates a name use (alias) builder.
18 |      *
19 |      * @param Node\Name|string $name Name of the entity (namespace, class, function, constant) to alias
20 |      * @param int              $type One of the Stmt\Use_::TYPE_* constants
21 |      */
22 |     public function __construct($name, int $type) {
23 |         $this->name = BuilderHelpers::normalizeName($name);
24 |         $this->type = $type;
25 |     }
26 | 
27 |     /**
28 |      * Sets alias for used name.
29 |      *
30 |      * @param string $alias Alias to use (last component of full name by default)
31 |      *
32 |      * @return $this The builder instance (for fluid interface)
33 |      */
34 |     public function as(string $alias) {
35 |         $this->alias = $alias;
36 |         return $this;
37 |     }
38 | 
39 |     /**
40 |      * Returns the built node.
41 |      *
42 |      * @return Stmt\Use_ The built node
43 |      */
44 |     public function getNode() : Node {
45 |         return new Stmt\Use_([
46 |             new Stmt\UseUse($this->name, $this->alias)
47 |         ], $this->type);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Comment/Doc.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace PhpParser\Comment;
4 | 
5 | class Doc extends \PhpParser\Comment
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/ConstExprEvaluationException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace PhpParser;
4 | 
5 | class ConstExprEvaluationException extends \Exception
6 | {}
7 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser;
 4 | 
 5 | interface ErrorHandler
 6 | {
 7 |     /**
 8 |      * Handle an error generated during lexing, parsing or some other operation.
 9 |      *
10 |      * @param Error $error The error that needs to be handled
11 |      */
12 |     public function handleError(Error $error);
13 | }
14 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler/Collecting.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\ErrorHandler;
 4 | 
 5 | use PhpParser\Error;
 6 | use PhpParser\ErrorHandler;
 7 | 
 8 | /**
 9 |  * Error handler that collects all errors into an array.
10 |  *
11 |  * This allows graceful handling of errors.
12 |  */
13 | class Collecting implements ErrorHandler
14 | {
15 |     /** @var Error[] Collected errors */
16 |     private $errors = [];
17 | 
18 |     public function handleError(Error $error) {
19 |         $this->errors[] = $error;
20 |     }
21 | 
22 |     /**
23 |      * Get collected errors.
24 |      *
25 |      * @return Error[]
26 |      */
27 |     public function getErrors() : array {
28 |         return $this->errors;
29 |     }
30 | 
31 |     /**
32 |      * Check whether there are any errors.
33 |      *
34 |      * @return bool
35 |      */
36 |     public function hasErrors() : bool {
37 |         return !empty($this->errors);
38 |     }
39 | 
40 |     /**
41 |      * Reset/clear collected errors.
42 |      */
43 |     public function clearErrors() {
44 |         $this->errors = [];
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler/Throwing.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\ErrorHandler;
 4 | 
 5 | use PhpParser\Error;
 6 | use PhpParser\ErrorHandler;
 7 | 
 8 | /**
 9 |  * Error handler that handles all errors by throwing them.
10 |  *
11 |  * This is the default strategy used by all components.
12 |  */
13 | class Throwing implements ErrorHandler
14 | {
15 |     public function handleError(Error $error) {
16 |         throw $error;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Internal/DiffElem.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Internal;
 4 | 
 5 | /**
 6 |  * @internal
 7 |  */
 8 | class DiffElem
 9 | {
10 |     const TYPE_KEEP = 0;
11 |     const TYPE_REMOVE = 1;
12 |     const TYPE_ADD = 2;
13 |     const TYPE_REPLACE = 3;
14 | 
15 |     /** @var int One of the TYPE_* constants */
16 |     public $type;
17 |     /** @var mixed Is null for add operations */
18 |     public $old;
19 |     /** @var mixed Is null for remove operations */
20 |     public $new;
21 | 
22 |     public function __construct(int $type, $old, $new) {
23 |         $this->type = $type;
24 |         $this->old = $old;
25 |         $this->new = $new;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AttributeEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | use PhpParser\Lexer\Emulative;
 6 | 
 7 | final class AttributeEmulator extends TokenEmulator
 8 | {
 9 |     public function getPhpVersion(): string
10 |     {
11 |         return Emulative::PHP_8_0;
12 |     }
13 | 
14 |     public function isEmulationNeeded(string $code) : bool
15 |     {
16 |         return strpos($code, '#[') !== false;
17 |     }
18 | 
19 |     public function emulate(string $code, array $tokens): array
20 |     {
21 |         // We need to manually iterate and manage a count because we'll change
22 |         // the tokens array on the way.
23 |         $line = 1;
24 |         for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
25 |             if ($tokens[$i] === '#' && isset($tokens[$i + 1]) && $tokens[$i + 1] === '[') {
26 |                 array_splice($tokens, $i, 2, [
27 |                     [\T_ATTRIBUTE, '#[', $line]
28 |                 ]);
29 |                 $c--;
30 |                 continue;
31 |             }
32 |             if (\is_array($tokens[$i])) {
33 |                 $line += substr_count($tokens[$i][1], "\n");
34 |             }
35 |         }
36 | 
37 |         return $tokens;
38 |     }
39 | 
40 |     public function reverseEmulate(string $code, array $tokens): array
41 |     {
42 |         // TODO
43 |         return $tokens;
44 |     }
45 | 
46 |     public function preprocessCode(string $code, array &$patches): string {
47 |         $pos = 0;
48 |         while (false !== $pos = strpos($code, '#[', $pos)) {
49 |             // Replace #[ with %[
50 |             $code[$pos] = '%';
51 |             $patches[] = [$pos, 'replace', '#'];
52 |             $pos += 2;
53 |         }
54 |         return $code;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/CoaleseEqualTokenEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | use PhpParser\Lexer\Emulative;
 6 | 
 7 | final class CoaleseEqualTokenEmulator extends TokenEmulator
 8 | {
 9 |     public function getPhpVersion(): string
10 |     {
11 |         return Emulative::PHP_7_4;
12 |     }
13 | 
14 |     public function isEmulationNeeded(string $code): bool
15 |     {
16 |         return strpos($code, '??=') !== false;
17 |     }
18 | 
19 |     public function emulate(string $code, array $tokens): array
20 |     {
21 |         // We need to manually iterate and manage a count because we'll change
22 |         // the tokens array on the way
23 |         $line = 1;
24 |         for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
25 |             if (isset($tokens[$i + 1])) {
26 |                 if ($tokens[$i][0] === T_COALESCE && $tokens[$i + 1] === '=') {
27 |                     array_splice($tokens, $i, 2, [
28 |                         [\T_COALESCE_EQUAL, '??=', $line]
29 |                     ]);
30 |                     $c--;
31 |                     continue;
32 |                 }
33 |             }
34 |             if (\is_array($tokens[$i])) {
35 |                 $line += substr_count($tokens[$i][1], "\n");
36 |             }
37 |         }
38 | 
39 |         return $tokens;
40 |     }
41 | 
42 |     public function reverseEmulate(string $code, array $tokens): array
43 |     {
44 |         // ??= was not valid code previously, don't bother.
45 |         return $tokens;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/EnumTokenEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | use PhpParser\Lexer\Emulative;
 6 | 
 7 | final class EnumTokenEmulator extends KeywordEmulator
 8 | {
 9 |     public function getPhpVersion(): string
10 |     {
11 |         return Emulative::PHP_8_1;
12 |     }
13 | 
14 |     public function getKeywordString(): string
15 |     {
16 |         return 'enum';
17 |     }
18 | 
19 |     public function getKeywordToken(): int
20 |     {
21 |         return \T_ENUM;
22 |     }
23 | 
24 |     protected function isKeywordContext(array $tokens, int $pos): bool
25 |     {
26 |         return parent::isKeywordContext($tokens, $pos)
27 |             && isset($tokens[$pos + 2])
28 |             && $tokens[$pos + 1][0] === \T_WHITESPACE
29 |             && $tokens[$pos + 2][0] === \T_STRING;
30 |     }
31 | }


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ExplicitOctalEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | use PhpParser\Lexer\Emulative;
 6 | 
 7 | class ExplicitOctalEmulator extends TokenEmulator {
 8 |     public function getPhpVersion(): string {
 9 |         return Emulative::PHP_8_1;
10 |     }
11 | 
12 |     public function isEmulationNeeded(string $code): bool {
13 |         return strpos($code, '0o') !== false || strpos($code, '0O') !== false;
14 |     }
15 | 
16 |     public function emulate(string $code, array $tokens): array {
17 |         for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
18 |             if ($tokens[$i][0] == \T_LNUMBER && $tokens[$i][1] === '0' &&
19 |                 isset($tokens[$i + 1]) && $tokens[$i + 1][0] == \T_STRING &&
20 |                 preg_match('/[oO][0-7]+(?:_[0-7]+)*/', $tokens[$i + 1][1])
21 |             ) {
22 |                 $tokenKind = $this->resolveIntegerOrFloatToken($tokens[$i + 1][1]);
23 |                 array_splice($tokens, $i, 2, [
24 |                     [$tokenKind, '0' . $tokens[$i + 1][1], $tokens[$i][2]],
25 |                 ]);
26 |                 $c--;
27 |             }
28 |         }
29 |         return $tokens;
30 |     }
31 | 
32 |     private function resolveIntegerOrFloatToken(string $str): int
33 |     {
34 |         $str = substr($str, 1);
35 |         $str = str_replace('_', '', $str);
36 |         $num = octdec($str);
37 |         return is_float($num) ? \T_DNUMBER : \T_LNUMBER;
38 |     }
39 | 
40 |     public function reverseEmulate(string $code, array $tokens): array {
41 |         // Explicit octals were not legal code previously, don't bother.
42 |         return $tokens;
43 |     }
44 | }


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/FnTokenEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | use PhpParser\Lexer\Emulative;
 6 | 
 7 | final class FnTokenEmulator extends KeywordEmulator
 8 | {
 9 |     public function getPhpVersion(): string
10 |     {
11 |         return Emulative::PHP_7_4;
12 |     }
13 | 
14 |     public function getKeywordString(): string
15 |     {
16 |         return 'fn';
17 |     }
18 | 
19 |     public function getKeywordToken(): int
20 |     {
21 |         return \T_FN;
22 |     }
23 | }


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | abstract class KeywordEmulator extends TokenEmulator
 6 | {
 7 |     abstract function getKeywordString(): string;
 8 |     abstract function getKeywordToken(): int;
 9 | 
10 |     public function isEmulationNeeded(string $code): bool
11 |     {
12 |         return strpos(strtolower($code), $this->getKeywordString()) !== false;
13 |     }
14 | 
15 |     protected function isKeywordContext(array $tokens, int $pos): bool
16 |     {
17 |         $previousNonSpaceToken = $this->getPreviousNonSpaceToken($tokens, $pos);
18 |         return $previousNonSpaceToken === null || $previousNonSpaceToken[0] !== \T_OBJECT_OPERATOR;
19 |     }
20 | 
21 |     public function emulate(string $code, array $tokens): array
22 |     {
23 |         $keywordString = $this->getKeywordString();
24 |         foreach ($tokens as $i => $token) {
25 |             if ($token[0] === T_STRING && strtolower($token[1]) === $keywordString
26 |                     && $this->isKeywordContext($tokens, $i)) {
27 |                 $tokens[$i][0] = $this->getKeywordToken();
28 |             }
29 |         }
30 | 
31 |         return $tokens;
32 |     }
33 | 
34 |     /**
35 |      * @param mixed[] $tokens
36 |      * @return array|string|null
37 |      */
38 |     private function getPreviousNonSpaceToken(array $tokens, int $start)
39 |     {
40 |         for ($i = $start - 1; $i >= 0; --$i) {
41 |             if ($tokens[$i][0] === T_WHITESPACE) {
42 |                 continue;
43 |             }
44 | 
45 |             return $tokens[$i];
46 |         }
47 | 
48 |         return null;
49 |     }
50 | 
51 |     public function reverseEmulate(string $code, array $tokens): array
52 |     {
53 |         $keywordToken = $this->getKeywordToken();
54 |         foreach ($tokens as $i => $token) {
55 |             if ($token[0] === $keywordToken) {
56 |                 $tokens[$i][0] = \T_STRING;
57 |             }
58 |         }
59 | 
60 |         return $tokens;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | use PhpParser\Lexer\Emulative;
 6 | 
 7 | final class MatchTokenEmulator extends KeywordEmulator
 8 | {
 9 |     public function getPhpVersion(): string
10 |     {
11 |         return Emulative::PHP_8_0;
12 |     }
13 | 
14 |     public function getKeywordString(): string
15 |     {
16 |         return 'match';
17 |     }
18 | 
19 |     public function getKeywordToken(): int
20 |     {
21 |         return \T_MATCH;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReadonlyFunctionTokenEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | use PhpParser\Lexer\Emulative;
 6 | 
 7 | /*
 8 |  * In PHP 8.1, "readonly(" was special cased in the lexer in order to support functions with
 9 |  * name readonly. In PHP 8.2, this may conflict with readonly properties having a DNF type. For
10 |  * this reason, PHP 8.2 instead treats this as T_READONLY and then handles it specially in the
11 |  * parser. This emulator only exists to handle this special case, which is skipped by the
12 |  * PHP 8.1 ReadonlyTokenEmulator.
13 |  */
14 | class ReadonlyFunctionTokenEmulator extends KeywordEmulator {
15 |     public function getKeywordString(): string {
16 |         return 'readonly';
17 |     }
18 | 
19 |     public function getKeywordToken(): int {
20 |         return \T_READONLY;
21 |     }
22 | 
23 |     public function getPhpVersion(): string {
24 |         return Emulative::PHP_8_2;
25 |     }
26 | 
27 |     public function reverseEmulate(string $code, array $tokens): array {
28 |         // Don't bother
29 |         return $tokens;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReadonlyTokenEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | use PhpParser\Lexer\Emulative;
 6 | 
 7 | final class ReadonlyTokenEmulator extends KeywordEmulator
 8 | {
 9 |     public function getPhpVersion(): string
10 |     {
11 |         return Emulative::PHP_8_1;
12 |     }
13 | 
14 |     public function getKeywordString(): string
15 |     {
16 |         return 'readonly';
17 |     }
18 | 
19 |     public function getKeywordToken(): int
20 |     {
21 |         return \T_READONLY;
22 |     }
23 | 
24 |     protected function isKeywordContext(array $tokens, int $pos): bool
25 |     {
26 |         if (!parent::isKeywordContext($tokens, $pos)) {
27 |             return false;
28 |         }
29 |         // Support "function readonly("
30 |         return !(isset($tokens[$pos + 1]) &&
31 |                  ($tokens[$pos + 1][0] === '(' ||
32 |                   ($tokens[$pos + 1][0] === \T_WHITESPACE &&
33 |                    isset($tokens[$pos + 2]) &&
34 |                    $tokens[$pos + 2][0] === '(')));
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReverseEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | /**
 6 |  * Reverses emulation direction of the inner emulator.
 7 |  */
 8 | final class ReverseEmulator extends TokenEmulator
 9 | {
10 |     /** @var TokenEmulator Inner emulator */
11 |     private $emulator;
12 | 
13 |     public function __construct(TokenEmulator $emulator) {
14 |         $this->emulator = $emulator;
15 |     }
16 | 
17 |     public function getPhpVersion(): string {
18 |         return $this->emulator->getPhpVersion();
19 |     }
20 | 
21 |     public function isEmulationNeeded(string $code): bool {
22 |         return $this->emulator->isEmulationNeeded($code);
23 |     }
24 | 
25 |     public function emulate(string $code, array $tokens): array {
26 |         return $this->emulator->reverseEmulate($code, $tokens);
27 |     }
28 | 
29 |     public function reverseEmulate(string $code, array $tokens): array {
30 |         return $this->emulator->emulate($code, $tokens);
31 |     }
32 | 
33 |     public function preprocessCode(string $code, array &$patches): string {
34 |         return $code;
35 |     }
36 | }


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/TokenEmulator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Lexer\TokenEmulator;
 4 | 
 5 | /** @internal */
 6 | abstract class TokenEmulator
 7 | {
 8 |     abstract public function getPhpVersion(): string;
 9 | 
10 |     abstract public function isEmulationNeeded(string $code): bool;
11 | 
12 |     /**
13 |      * @return array Modified Tokens
14 |      */
15 |     abstract public function emulate(string $code, array $tokens): array;
16 | 
17 |     /**
18 |      * @return array Modified Tokens
19 |      */
20 |     abstract public function reverseEmulate(string $code, array $tokens): array;
21 | 
22 |     public function preprocessCode(string $code, array &$patches): string {
23 |         return $code;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Arg.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\Node\VariadicPlaceholder;
 6 | use PhpParser\NodeAbstract;
 7 | 
 8 | class Arg extends NodeAbstract
 9 | {
10 |     /** @var Identifier|null Parameter name (for named parameters) */
11 |     public $name;
12 |     /** @var Expr Value to pass */
13 |     public $value;
14 |     /** @var bool Whether to pass by ref */
15 |     public $byRef;
16 |     /** @var bool Whether to unpack the argument */
17 |     public $unpack;
18 | 
19 |     /**
20 |      * Constructs a function call argument node.
21 |      *
22 |      * @param Expr  $value      Value to pass
23 |      * @param bool  $byRef      Whether to pass by ref
24 |      * @param bool  $unpack     Whether to unpack the argument
25 |      * @param array $attributes Additional attributes
26 |      * @param Identifier|null $name Parameter name (for named parameters)
27 |      */
28 |     public function __construct(
29 |         Expr $value, bool $byRef = false, bool $unpack = false, array $attributes = [],
30 |         ?Identifier $name = null
31 |     ) {
32 |         $this->attributes = $attributes;
33 |         $this->name = $name;
34 |         $this->value = $value;
35 |         $this->byRef = $byRef;
36 |         $this->unpack = $unpack;
37 |     }
38 | 
39 |     public function getSubNodeNames() : array {
40 |         return ['name', 'value', 'byRef', 'unpack'];
41 |     }
42 |     
43 |     public function getType() : string {
44 |         return 'Arg';
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Attribute.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\NodeAbstract;
 7 | 
 8 | class Attribute extends NodeAbstract
 9 | {
10 |     /** @var Name Attribute name */
11 |     public $name;
12 | 
13 |     /** @var Arg[] Attribute arguments */
14 |     public $args;
15 | 
16 |     /**
17 |      * @param Node\Name $name       Attribute name
18 |      * @param Arg[]     $args       Attribute arguments
19 |      * @param array     $attributes Additional node attributes
20 |      */
21 |     public function __construct(Name $name, array $args = [], array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->name = $name;
24 |         $this->args = $args;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['name', 'args'];
29 |     }
30 | 
31 |     public function getType() : string {
32 |         return 'Attribute';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/AttributeGroup.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\NodeAbstract;
 7 | 
 8 | class AttributeGroup extends NodeAbstract
 9 | {
10 |     /** @var Attribute[] Attributes */
11 |     public $attrs;
12 | 
13 |     /**
14 |      * @param Attribute[] $attrs PHP attributes
15 |      * @param array $attributes Additional node attributes
16 |      */
17 |     public function __construct(array $attrs, array $attributes = []) {
18 |         $this->attributes = $attributes;
19 |         $this->attrs = $attrs;
20 |     }
21 | 
22 |     public function getSubNodeNames() : array {
23 |         return ['attrs'];
24 |     }
25 | 
26 |     public function getType() : string {
27 |         return 'AttributeGroup';
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/ComplexType.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\NodeAbstract;
 6 | 
 7 | /**
 8 |  * This is a base class for complex types, including nullable types and union types.
 9 |  *
10 |  * It does not provide any shared behavior and exists only for type-checking purposes.
11 |  */
12 | abstract class ComplexType extends NodeAbstract
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Const_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\NodeAbstract;
 6 | 
 7 | class Const_ extends NodeAbstract
 8 | {
 9 |     /** @var Identifier Name */
10 |     public $name;
11 |     /** @var Expr Value */
12 |     public $value;
13 | 
14 |     /** @var Name|null Namespaced name (if using NameResolver) */
15 |     public $namespacedName;
16 | 
17 |     /**
18 |      * Constructs a const node for use in class const and const statements.
19 |      *
20 |      * @param string|Identifier $name       Name
21 |      * @param Expr              $value      Value
22 |      * @param array             $attributes Additional attributes
23 |      */
24 |     public function __construct($name, Expr $value, array $attributes = []) {
25 |         $this->attributes = $attributes;
26 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
27 |         $this->value = $value;
28 |     }
29 | 
30 |     public function getSubNodeNames() : array {
31 |         return ['name', 'value'];
32 |     }
33 | 
34 |     public function getType() : string {
35 |         return 'Const';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\NodeAbstract;
 6 | 
 7 | abstract class Expr extends NodeAbstract
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayDimFetch.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class ArrayDimFetch extends Expr
 8 | {
 9 |     /** @var Expr Variable */
10 |     public $var;
11 |     /** @var null|Expr Array index / dim */
12 |     public $dim;
13 | 
14 |     /**
15 |      * Constructs an array index fetch node.
16 |      *
17 |      * @param Expr      $var        Variable
18 |      * @param null|Expr $dim        Array index / dim
19 |      * @param array     $attributes Additional attributes
20 |      */
21 |     public function __construct(Expr $var, ?Expr $dim = null, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->var = $var;
24 |         $this->dim = $dim;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['var', 'dim'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Expr_ArrayDimFetch';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayItem.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class ArrayItem extends Expr
 8 | {
 9 |     /** @var null|Expr Key */
10 |     public $key;
11 |     /** @var Expr Value */
12 |     public $value;
13 |     /** @var bool Whether to assign by reference */
14 |     public $byRef;
15 |     /** @var bool Whether to unpack the argument */
16 |     public $unpack;
17 | 
18 |     /**
19 |      * Constructs an array item node.
20 |      *
21 |      * @param Expr      $value      Value
22 |      * @param null|Expr $key        Key
23 |      * @param bool      $byRef      Whether to assign by reference
24 |      * @param array     $attributes Additional attributes
25 |      */
26 |     public function __construct(Expr $value, ?Expr $key = null, bool $byRef = false, array $attributes = [], bool $unpack = false) {
27 |         $this->attributes = $attributes;
28 |         $this->key = $key;
29 |         $this->value = $value;
30 |         $this->byRef = $byRef;
31 |         $this->unpack = $unpack;
32 |     }
33 | 
34 |     public function getSubNodeNames() : array {
35 |         return ['key', 'value', 'byRef', 'unpack'];
36 |     }
37 | 
38 |     public function getType() : string {
39 |         return 'Expr_ArrayItem';
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Array_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Array_ extends Expr
 8 | {
 9 |     // For use in "kind" attribute
10 |     const KIND_LONG = 1;  // array() syntax
11 |     const KIND_SHORT = 2; // [] syntax
12 | 
13 |     /** @var (ArrayItem|null)[] Items */
14 |     public $items;
15 | 
16 |     /**
17 |      * Constructs an array node.
18 |      *
19 |      * @param (ArrayItem|null)[] $items      Items of the array
20 |      * @param array       $attributes Additional attributes
21 |      */
22 |     public function __construct(array $items = [], array $attributes = []) {
23 |         $this->attributes = $attributes;
24 |         $this->items = $items;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['items'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Expr_Array';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Assign.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Assign extends Expr
 8 | {
 9 |     /** @var Expr Variable */
10 |     public $var;
11 |     /** @var Expr Expression */
12 |     public $expr;
13 | 
14 |     /**
15 |      * Constructs an assignment node.
16 |      *
17 |      * @param Expr  $var        Variable
18 |      * @param Expr  $expr       Expression
19 |      * @param array $attributes Additional attributes
20 |      */
21 |     public function __construct(Expr $var, Expr $expr, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->var = $var;
24 |         $this->expr = $expr;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['var', 'expr'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Expr_Assign';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | abstract class AssignOp extends Expr
 8 | {
 9 |     /** @var Expr Variable */
10 |     public $var;
11 |     /** @var Expr Expression */
12 |     public $expr;
13 | 
14 |     /**
15 |      * Constructs a compound assignment operation node.
16 |      *
17 |      * @param Expr  $var        Variable
18 |      * @param Expr  $expr       Expression
19 |      * @param array $attributes Additional attributes
20 |      */
21 |     public function __construct(Expr $var, Expr $expr, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->var = $var;
24 |         $this->expr = $expr;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['var', 'expr'];
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseAnd.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class BitwiseAnd extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_BitwiseAnd';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseOr.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class BitwiseOr extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_BitwiseOr';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseXor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class BitwiseXor extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_BitwiseXor';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Coalesce.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class Coalesce extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_Coalesce';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Concat.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class Concat extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_Concat';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Div.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class Div extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_Div';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Minus.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class Minus extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_Minus';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Mod.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class Mod extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_Mod';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Mul.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class Mul extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_Mul';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Plus.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class Plus extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_Plus';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/Pow.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class Pow extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_Pow';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/ShiftLeft.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class ShiftLeft extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_ShiftLeft';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/ShiftRight.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\AssignOp;
 4 | 
 5 | use PhpParser\Node\Expr\AssignOp;
 6 | 
 7 | class ShiftRight extends AssignOp
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_AssignOp_ShiftRight';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignRef.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class AssignRef extends Expr
 8 | {
 9 |     /** @var Expr Variable reference is assigned to */
10 |     public $var;
11 |     /** @var Expr Variable which is referenced */
12 |     public $expr;
13 | 
14 |     /**
15 |      * Constructs an assignment node.
16 |      *
17 |      * @param Expr  $var        Variable
18 |      * @param Expr  $expr       Expression
19 |      * @param array $attributes Additional attributes
20 |      */
21 |     public function __construct(Expr $var, Expr $expr, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->var = $var;
24 |         $this->expr = $expr;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['var', 'expr'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Expr_AssignRef';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | abstract class BinaryOp extends Expr
 8 | {
 9 |     /** @var Expr The left hand side expression */
10 |     public $left;
11 |     /** @var Expr The right hand side expression */
12 |     public $right;
13 | 
14 |     /**
15 |      * Constructs a binary operator node.
16 |      *
17 |      * @param Expr  $left       The left hand side expression
18 |      * @param Expr  $right      The right hand side expression
19 |      * @param array $attributes Additional attributes
20 |      */
21 |     public function __construct(Expr $left, Expr $right, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->left = $left;
24 |         $this->right = $right;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['left', 'right'];
29 |     }
30 | 
31 |     /**
32 |      * Get the operator sigil for this binary operation.
33 |      *
34 |      * In the case there are multiple possible sigils for an operator, this method does not
35 |      * necessarily return the one used in the parsed code.
36 |      *
37 |      * @return string
38 |      */
39 |     abstract public function getOperatorSigil() : string;
40 | }
41 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseAnd.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class BitwiseAnd extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '&';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_BitwiseAnd';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseOr.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class BitwiseOr extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '|';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_BitwiseOr';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseXor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class BitwiseXor extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '^';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_BitwiseXor';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BooleanAnd.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class BooleanAnd extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '&&';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_BooleanAnd';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BooleanOr.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class BooleanOr extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '||';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_BooleanOr';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Coalesce.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Coalesce extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '??';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Coalesce';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Concat.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Concat extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '.';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Concat';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Div.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Div extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '/';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Div';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Equal.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Equal extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '==';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Equal';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Greater.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Greater extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '>';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Greater';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/GreaterOrEqual.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class GreaterOrEqual extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '>=';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_GreaterOrEqual';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Identical.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Identical extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '===';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Identical';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/LogicalAnd.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class LogicalAnd extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return 'and';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_LogicalAnd';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/LogicalOr.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class LogicalOr extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return 'or';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_LogicalOr';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/LogicalXor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class LogicalXor extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return 'xor';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_LogicalXor';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Minus.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Minus extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '-';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Minus';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Mod.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Mod extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '%';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Mod';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Mul.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Mul extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '*';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Mul';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/NotEqual.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class NotEqual extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '!=';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_NotEqual';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/NotIdentical.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class NotIdentical extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '!==';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_NotIdentical';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Plus.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Plus extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '+';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Plus';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Pow.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Pow extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '**';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Pow';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/ShiftLeft.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class ShiftLeft extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '<<';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_ShiftLeft';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/ShiftRight.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class ShiftRight extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '>>';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_ShiftRight';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Smaller.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Smaller extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '<';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Smaller';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/SmallerOrEqual.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class SmallerOrEqual extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '<=';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_SmallerOrEqual';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Spaceship.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\BinaryOp;
 4 | 
 5 | use PhpParser\Node\Expr\BinaryOp;
 6 | 
 7 | class Spaceship extends BinaryOp
 8 | {
 9 |     public function getOperatorSigil() : string {
10 |         return '<=>';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Expr_BinaryOp_Spaceship';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BitwiseNot.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class BitwiseNot extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a bitwise not node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_BitwiseNot';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BooleanNot.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class BooleanNot extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a boolean not node.
14 |      *
15 |      * @param Expr $expr       Expression
16 |      * @param array               $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_BooleanNot';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/CallLike.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Arg;
 6 | use PhpParser\Node\Expr;
 7 | use PhpParser\Node\VariadicPlaceholder;
 8 | 
 9 | abstract class CallLike extends Expr {
10 |     /**
11 |      * Return raw arguments, which may be actual Args, or VariadicPlaceholders for first-class
12 |      * callables.
13 |      *
14 |      * @return array<Arg|VariadicPlaceholder>
15 |      */
16 |     abstract public function getRawArgs(): array;
17 | 
18 |     /**
19 |      * Returns whether this call expression is actually a first class callable.
20 |      */
21 |     public function isFirstClassCallable(): bool {
22 |         foreach ($this->getRawArgs() as $arg) {
23 |             if ($arg instanceof VariadicPlaceholder) {
24 |                 return true;
25 |             }
26 |         }
27 |         return false;
28 |     }
29 | 
30 |     /**
31 |      * Assert that this is not a first-class callable and return only ordinary Args.
32 |      *
33 |      * @return Arg[]
34 |      */
35 |     public function getArgs(): array {
36 |         assert(!$this->isFirstClassCallable());
37 |         return $this->getRawArgs();
38 |     }
39 | }


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | abstract class Cast extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a cast node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Array_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\Cast;
 4 | 
 5 | use PhpParser\Node\Expr\Cast;
 6 | 
 7 | class Array_ extends Cast
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_Cast_Array';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Bool_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\Cast;
 4 | 
 5 | use PhpParser\Node\Expr\Cast;
 6 | 
 7 | class Bool_ extends Cast
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_Cast_Bool';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Double.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\Cast;
 4 | 
 5 | use PhpParser\Node\Expr\Cast;
 6 | 
 7 | class Double extends Cast
 8 | {
 9 |     // For use in "kind" attribute
10 |     const KIND_DOUBLE = 1; // "double" syntax
11 |     const KIND_FLOAT = 2;  // "float" syntax
12 |     const KIND_REAL = 3; // "real" syntax
13 | 
14 |     public function getType() : string {
15 |         return 'Expr_Cast_Double';
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Int_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\Cast;
 4 | 
 5 | use PhpParser\Node\Expr\Cast;
 6 | 
 7 | class Int_ extends Cast
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_Cast_Int';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Object_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\Cast;
 4 | 
 5 | use PhpParser\Node\Expr\Cast;
 6 | 
 7 | class Object_ extends Cast
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_Cast_Object';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/String_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\Cast;
 4 | 
 5 | use PhpParser\Node\Expr\Cast;
 6 | 
 7 | class String_ extends Cast
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_Cast_String';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Unset_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr\Cast;
 4 | 
 5 | use PhpParser\Node\Expr\Cast;
 6 | 
 7 | class Unset_ extends Cast
 8 | {
 9 |     public function getType() : string {
10 |         return 'Expr_Cast_Unset';
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ClassConstFetch.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | use PhpParser\Node\Identifier;
 7 | use PhpParser\Node\Name;
 8 | 
 9 | class ClassConstFetch extends Expr
10 | {
11 |     /** @var Name|Expr Class name */
12 |     public $class;
13 |     /** @var Identifier|Expr|Error Constant name */
14 |     public $name;
15 | 
16 |     /**
17 |      * Constructs a class const fetch node.
18 |      *
19 |      * @param Name|Expr                    $class      Class name
20 |      * @param string|Identifier|Expr|Error $name       Constant name
21 |      * @param array                        $attributes Additional attributes
22 |      */
23 |     public function __construct($class, $name, array $attributes = []) {
24 |         $this->attributes = $attributes;
25 |         $this->class = $class;
26 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
27 |     }
28 | 
29 |     public function getSubNodeNames() : array {
30 |         return ['class', 'name'];
31 |     }
32 | 
33 |     public function getType() : string {
34 |         return 'Expr_ClassConstFetch';
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Clone_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Clone_ extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a clone node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_Clone';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ClosureUse.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class ClosureUse extends Expr
 8 | {
 9 |     /** @var Expr\Variable Variable to use */
10 |     public $var;
11 |     /** @var bool Whether to use by reference */
12 |     public $byRef;
13 | 
14 |     /**
15 |      * Constructs a closure use node.
16 |      *
17 |      * @param Expr\Variable $var        Variable to use
18 |      * @param bool          $byRef      Whether to use by reference
19 |      * @param array         $attributes Additional attributes
20 |      */
21 |     public function __construct(Expr\Variable $var, bool $byRef = false, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->var = $var;
24 |         $this->byRef = $byRef;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['var', 'byRef'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Expr_ClosureUse';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ConstFetch.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | use PhpParser\Node\Name;
 7 | 
 8 | class ConstFetch extends Expr
 9 | {
10 |     /** @var Name Constant name */
11 |     public $name;
12 | 
13 |     /**
14 |      * Constructs a const fetch node.
15 |      *
16 |      * @param Name  $name       Constant name
17 |      * @param array $attributes Additional attributes
18 |      */
19 |     public function __construct(Name $name, array $attributes = []) {
20 |         $this->attributes = $attributes;
21 |         $this->name = $name;
22 |     }
23 | 
24 |     public function getSubNodeNames() : array {
25 |         return ['name'];
26 |     }
27 |     
28 |     public function getType() : string {
29 |         return 'Expr_ConstFetch';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Empty_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Empty_ extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs an empty() node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_Empty';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Error.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | /**
 8 |  * Error node used during parsing with error recovery.
 9 |  *
10 |  * An error node may be placed at a position where an expression is required, but an error occurred.
11 |  * Error nodes will not be present if the parser is run in throwOnError mode (the default).
12 |  */
13 | class Error extends Expr
14 | {
15 |     /**
16 |      * Constructs an error node.
17 |      *
18 |      * @param array $attributes Additional attributes
19 |      */
20 |     public function __construct(array $attributes = []) {
21 |         $this->attributes = $attributes;
22 |     }
23 | 
24 |     public function getSubNodeNames() : array {
25 |         return [];
26 |     }
27 |     
28 |     public function getType() : string {
29 |         return 'Expr_Error';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ErrorSuppress.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class ErrorSuppress extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs an error suppress node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_ErrorSuppress';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Eval_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Eval_ extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs an eval() node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_Eval';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Exit_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Exit_ extends Expr
 8 | {
 9 |     /* For use in "kind" attribute */
10 |     const KIND_EXIT = 1;
11 |     const KIND_DIE = 2;
12 | 
13 |     /** @var null|Expr Expression */
14 |     public $expr;
15 | 
16 |     /**
17 |      * Constructs an exit() node.
18 |      *
19 |      * @param null|Expr $expr       Expression
20 |      * @param array                    $attributes Additional attributes
21 |      */
22 |     public function __construct(?Expr $expr = null, array $attributes = []) {
23 |         $this->attributes = $attributes;
24 |         $this->expr = $expr;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['expr'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Expr_Exit';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/FuncCall.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\Expr;
 7 | 
 8 | class FuncCall extends CallLike
 9 | {
10 |     /** @var Node\Name|Expr Function name */
11 |     public $name;
12 |     /** @var array<Node\Arg|Node\VariadicPlaceholder> Arguments */
13 |     public $args;
14 | 
15 |     /**
16 |      * Constructs a function call node.
17 |      *
18 |      * @param Node\Name|Expr                           $name       Function name
19 |      * @param array<Node\Arg|Node\VariadicPlaceholder> $args       Arguments
20 |      * @param array                                    $attributes Additional attributes
21 |      */
22 |     public function __construct($name, array $args = [], array $attributes = []) {
23 |         $this->attributes = $attributes;
24 |         $this->name = $name;
25 |         $this->args = $args;
26 |     }
27 | 
28 |     public function getSubNodeNames() : array {
29 |         return ['name', 'args'];
30 |     }
31 |     
32 |     public function getType() : string {
33 |         return 'Expr_FuncCall';
34 |     }
35 | 
36 |     public function getRawArgs(): array {
37 |         return $this->args;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Include_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Include_ extends Expr
 8 | {
 9 |     const TYPE_INCLUDE      = 1;
10 |     const TYPE_INCLUDE_ONCE = 2;
11 |     const TYPE_REQUIRE      = 3;
12 |     const TYPE_REQUIRE_ONCE = 4;
13 | 
14 |     /** @var Expr Expression */
15 |     public $expr;
16 |     /** @var int Type of include */
17 |     public $type;
18 | 
19 |     /**
20 |      * Constructs an include node.
21 |      *
22 |      * @param Expr  $expr       Expression
23 |      * @param int   $type       Type of include
24 |      * @param array $attributes Additional attributes
25 |      */
26 |     public function __construct(Expr $expr, int $type, array $attributes = []) {
27 |         $this->attributes = $attributes;
28 |         $this->expr = $expr;
29 |         $this->type = $type;
30 |     }
31 | 
32 |     public function getSubNodeNames() : array {
33 |         return ['expr', 'type'];
34 |     }
35 |     
36 |     public function getType() : string {
37 |         return 'Expr_Include';
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Instanceof_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | use PhpParser\Node\Name;
 7 | 
 8 | class Instanceof_ extends Expr
 9 | {
10 |     /** @var Expr Expression */
11 |     public $expr;
12 |     /** @var Name|Expr Class name */
13 |     public $class;
14 | 
15 |     /**
16 |      * Constructs an instanceof check node.
17 |      *
18 |      * @param Expr      $expr       Expression
19 |      * @param Name|Expr $class      Class name
20 |      * @param array     $attributes Additional attributes
21 |      */
22 |     public function __construct(Expr $expr, $class, array $attributes = []) {
23 |         $this->attributes = $attributes;
24 |         $this->expr = $expr;
25 |         $this->class = $class;
26 |     }
27 | 
28 |     public function getSubNodeNames() : array {
29 |         return ['expr', 'class'];
30 |     }
31 |     
32 |     public function getType() : string {
33 |         return 'Expr_Instanceof';
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Isset_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Isset_ extends Expr
 8 | {
 9 |     /** @var Expr[] Variables */
10 |     public $vars;
11 | 
12 |     /**
13 |      * Constructs an array node.
14 |      *
15 |      * @param Expr[] $vars       Variables
16 |      * @param array  $attributes Additional attributes
17 |      */
18 |     public function __construct(array $vars, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->vars = $vars;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['vars'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_Isset';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/List_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class List_ extends Expr
 8 | {
 9 |     /** @var (ArrayItem|null)[] List of items to assign to */
10 |     public $items;
11 | 
12 |     /**
13 |      * Constructs a list() destructuring node.
14 |      *
15 |      * @param (ArrayItem|null)[] $items      List of items to assign to
16 |      * @param array              $attributes Additional attributes
17 |      */
18 |     public function __construct(array $items, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->items = $items;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['items'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_List';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Match_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\MatchArm;
 7 | 
 8 | class Match_ extends Node\Expr
 9 | {
10 |     /** @var Node\Expr */
11 |     public $cond;
12 |     /** @var MatchArm[] */
13 |     public $arms;
14 | 
15 |     /**
16 |      * @param MatchArm[] $arms
17 |      */
18 |     public function __construct(Node\Expr $cond, array $arms = [], array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->cond = $cond;
21 |         $this->arms = $arms;
22 |     }
23 | 
24 |     public function getSubNodeNames() : array {
25 |         return ['cond', 'arms'];
26 |     }
27 | 
28 |     public function getType() : string {
29 |         return 'Expr_Match';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/MethodCall.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Arg;
 6 | use PhpParser\Node\Expr;
 7 | use PhpParser\Node\Identifier;
 8 | use PhpParser\Node\VariadicPlaceholder;
 9 | 
10 | class MethodCall extends CallLike
11 | {
12 |     /** @var Expr Variable holding object */
13 |     public $var;
14 |     /** @var Identifier|Expr Method name */
15 |     public $name;
16 |     /** @var array<Arg|VariadicPlaceholder> Arguments */
17 |     public $args;
18 | 
19 |     /**
20 |      * Constructs a function call node.
21 |      *
22 |      * @param Expr                           $var        Variable holding object
23 |      * @param string|Identifier|Expr         $name       Method name
24 |      * @param array<Arg|VariadicPlaceholder> $args       Arguments
25 |      * @param array                          $attributes Additional attributes
26 |      */
27 |     public function __construct(Expr $var, $name, array $args = [], array $attributes = []) {
28 |         $this->attributes = $attributes;
29 |         $this->var = $var;
30 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
31 |         $this->args = $args;
32 |     }
33 | 
34 |     public function getSubNodeNames() : array {
35 |         return ['var', 'name', 'args'];
36 |     }
37 |     
38 |     public function getType() : string {
39 |         return 'Expr_MethodCall';
40 |     }
41 | 
42 |     public function getRawArgs(): array {
43 |         return $this->args;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/New_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\Arg;
 7 | use PhpParser\Node\Expr;
 8 | use PhpParser\Node\VariadicPlaceholder;
 9 | 
10 | class New_ extends CallLike
11 | {
12 |     /** @var Node\Name|Expr|Node\Stmt\Class_ Class name */
13 |     public $class;
14 |     /** @var array<Arg|VariadicPlaceholder> Arguments */
15 |     public $args;
16 | 
17 |     /**
18 |      * Constructs a function call node.
19 |      *
20 |      * @param Node\Name|Expr|Node\Stmt\Class_ $class      Class name (or class node for anonymous classes)
21 |      * @param array<Arg|VariadicPlaceholder>  $args       Arguments
22 |      * @param array                           $attributes Additional attributes
23 |      */
24 |     public function __construct($class, array $args = [], array $attributes = []) {
25 |         $this->attributes = $attributes;
26 |         $this->class = $class;
27 |         $this->args = $args;
28 |     }
29 | 
30 |     public function getSubNodeNames() : array {
31 |         return ['class', 'args'];
32 |     }
33 |     
34 |     public function getType() : string {
35 |         return 'Expr_New';
36 |     }
37 | 
38 |     public function getRawArgs(): array {
39 |         return $this->args;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafeMethodCall.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Arg;
 6 | use PhpParser\Node\Expr;
 7 | use PhpParser\Node\Identifier;
 8 | use PhpParser\Node\VariadicPlaceholder;
 9 | 
10 | class NullsafeMethodCall extends CallLike
11 | {
12 |     /** @var Expr Variable holding object */
13 |     public $var;
14 |     /** @var Identifier|Expr Method name */
15 |     public $name;
16 |     /** @var array<Arg|VariadicPlaceholder> Arguments */
17 |     public $args;
18 | 
19 |     /**
20 |      * Constructs a nullsafe method call node.
21 |      *
22 |      * @param Expr                           $var        Variable holding object
23 |      * @param string|Identifier|Expr         $name       Method name
24 |      * @param array<Arg|VariadicPlaceholder> $args       Arguments
25 |      * @param array                          $attributes Additional attributes
26 |      */
27 |     public function __construct(Expr $var, $name, array $args = [], array $attributes = []) {
28 |         $this->attributes = $attributes;
29 |         $this->var = $var;
30 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
31 |         $this->args = $args;
32 |     }
33 | 
34 |     public function getSubNodeNames() : array {
35 |         return ['var', 'name', 'args'];
36 |     }
37 |     
38 |     public function getType() : string {
39 |         return 'Expr_NullsafeMethodCall';
40 |     }
41 | 
42 |     public function getRawArgs(): array {
43 |         return $this->args;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafePropertyFetch.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | use PhpParser\Node\Identifier;
 7 | 
 8 | class NullsafePropertyFetch extends Expr
 9 | {
10 |     /** @var Expr Variable holding object */
11 |     public $var;
12 |     /** @var Identifier|Expr Property name */
13 |     public $name;
14 | 
15 |     /**
16 |      * Constructs a nullsafe property fetch node.
17 |      *
18 |      * @param Expr                   $var        Variable holding object
19 |      * @param string|Identifier|Expr $name       Property name
20 |      * @param array                  $attributes Additional attributes
21 |      */
22 |     public function __construct(Expr $var, $name, array $attributes = []) {
23 |         $this->attributes = $attributes;
24 |         $this->var = $var;
25 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
26 |     }
27 | 
28 |     public function getSubNodeNames() : array {
29 |         return ['var', 'name'];
30 |     }
31 |     
32 |     public function getType() : string {
33 |         return 'Expr_NullsafePropertyFetch';
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PostDec.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class PostDec extends Expr
 8 | {
 9 |     /** @var Expr Variable */
10 |     public $var;
11 | 
12 |     /**
13 |      * Constructs a post decrement node.
14 |      *
15 |      * @param Expr  $var        Variable
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $var, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->var = $var;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['var'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_PostDec';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PostInc.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class PostInc extends Expr
 8 | {
 9 |     /** @var Expr Variable */
10 |     public $var;
11 | 
12 |     /**
13 |      * Constructs a post increment node.
14 |      *
15 |      * @param Expr  $var        Variable
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $var, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->var = $var;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['var'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_PostInc';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PreDec.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class PreDec extends Expr
 8 | {
 9 |     /** @var Expr Variable */
10 |     public $var;
11 | 
12 |     /**
13 |      * Constructs a pre decrement node.
14 |      *
15 |      * @param Expr  $var        Variable
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $var, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->var = $var;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['var'];
25 |     }
26 | 
27 |     public function getType() : string {
28 |         return 'Expr_PreDec';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PreInc.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class PreInc extends Expr
 8 | {
 9 |     /** @var Expr Variable */
10 |     public $var;
11 | 
12 |     /**
13 |      * Constructs a pre increment node.
14 |      *
15 |      * @param Expr  $var        Variable
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $var, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->var = $var;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['var'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_PreInc';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Print_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Print_ extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs an print() node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_Print';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PropertyFetch.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | use PhpParser\Node\Identifier;
 7 | 
 8 | class PropertyFetch extends Expr
 9 | {
10 |     /** @var Expr Variable holding object */
11 |     public $var;
12 |     /** @var Identifier|Expr Property name */
13 |     public $name;
14 | 
15 |     /**
16 |      * Constructs a function call node.
17 |      *
18 |      * @param Expr                   $var        Variable holding object
19 |      * @param string|Identifier|Expr $name       Property name
20 |      * @param array                  $attributes Additional attributes
21 |      */
22 |     public function __construct(Expr $var, $name, array $attributes = []) {
23 |         $this->attributes = $attributes;
24 |         $this->var = $var;
25 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
26 |     }
27 | 
28 |     public function getSubNodeNames() : array {
29 |         return ['var', 'name'];
30 |     }
31 |     
32 |     public function getType() : string {
33 |         return 'Expr_PropertyFetch';
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ShellExec.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class ShellExec extends Expr
 8 | {
 9 |     /** @var array Encapsed string array */
10 |     public $parts;
11 | 
12 |     /**
13 |      * Constructs a shell exec (backtick) node.
14 |      *
15 |      * @param array $parts      Encapsed string array
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(array $parts, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->parts = $parts;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['parts'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_ShellExec';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/StaticCall.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\Arg;
 7 | use PhpParser\Node\Expr;
 8 | use PhpParser\Node\Identifier;
 9 | use PhpParser\Node\VariadicPlaceholder;
10 | 
11 | class StaticCall extends CallLike
12 | {
13 |     /** @var Node\Name|Expr Class name */
14 |     public $class;
15 |     /** @var Identifier|Expr Method name */
16 |     public $name;
17 |     /** @var array<Arg|VariadicPlaceholder> Arguments */
18 |     public $args;
19 | 
20 |     /**
21 |      * Constructs a static method call node.
22 |      *
23 |      * @param Node\Name|Expr                 $class      Class name
24 |      * @param string|Identifier|Expr         $name       Method name
25 |      * @param array<Arg|VariadicPlaceholder> $args       Arguments
26 |      * @param array                          $attributes Additional attributes
27 |      */
28 |     public function __construct($class, $name, array $args = [], array $attributes = []) {
29 |         $this->attributes = $attributes;
30 |         $this->class = $class;
31 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
32 |         $this->args = $args;
33 |     }
34 | 
35 |     public function getSubNodeNames() : array {
36 |         return ['class', 'name', 'args'];
37 |     }
38 |     
39 |     public function getType() : string {
40 |         return 'Expr_StaticCall';
41 |     }
42 | 
43 |     public function getRawArgs(): array {
44 |         return $this->args;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/StaticPropertyFetch.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | use PhpParser\Node\Name;
 7 | use PhpParser\Node\VarLikeIdentifier;
 8 | 
 9 | class StaticPropertyFetch extends Expr
10 | {
11 |     /** @var Name|Expr Class name */
12 |     public $class;
13 |     /** @var VarLikeIdentifier|Expr Property name */
14 |     public $name;
15 | 
16 |     /**
17 |      * Constructs a static property fetch node.
18 |      *
19 |      * @param Name|Expr                     $class      Class name
20 |      * @param string|VarLikeIdentifier|Expr $name       Property name
21 |      * @param array                         $attributes Additional attributes
22 |      */
23 |     public function __construct($class, $name, array $attributes = []) {
24 |         $this->attributes = $attributes;
25 |         $this->class = $class;
26 |         $this->name = \is_string($name) ? new VarLikeIdentifier($name) : $name;
27 |     }
28 | 
29 |     public function getSubNodeNames() : array {
30 |         return ['class', 'name'];
31 |     }
32 |     
33 |     public function getType() : string {
34 |         return 'Expr_StaticPropertyFetch';
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Ternary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Ternary extends Expr
 8 | {
 9 |     /** @var Expr Condition */
10 |     public $cond;
11 |     /** @var null|Expr Expression for true */
12 |     public $if;
13 |     /** @var Expr Expression for false */
14 |     public $else;
15 | 
16 |     /**
17 |      * Constructs a ternary operator node.
18 |      *
19 |      * @param Expr      $cond       Condition
20 |      * @param null|Expr $if         Expression for true
21 |      * @param Expr      $else       Expression for false
22 |      * @param array                    $attributes Additional attributes
23 |      */
24 |     public function __construct(Expr $cond, $if, Expr $else, array $attributes = []) {
25 |         $this->attributes = $attributes;
26 |         $this->cond = $cond;
27 |         $this->if = $if;
28 |         $this->else = $else;
29 |     }
30 | 
31 |     public function getSubNodeNames() : array {
32 |         return ['cond', 'if', 'else'];
33 |     }
34 |     
35 |     public function getType() : string {
36 |         return 'Expr_Ternary';
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Throw_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Throw_ extends Node\Expr
 8 | {
 9 |     /** @var Node\Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a throw expression node.
14 |      *
15 |      * @param Node\Expr $expr       Expression
16 |      * @param array     $attributes Additional attributes
17 |      */
18 |     public function __construct(Node\Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 | 
27 |     public function getType() : string {
28 |         return 'Expr_Throw';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/UnaryMinus.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class UnaryMinus extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a unary minus node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_UnaryMinus';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/UnaryPlus.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class UnaryPlus extends Expr
 8 | {
 9 |     /** @var Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a unary plus node.
14 |      *
15 |      * @param Expr $expr       Expression
16 |      * @param array               $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_UnaryPlus';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Variable.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Variable extends Expr
 8 | {
 9 |     /** @var string|Expr Name */
10 |     public $name;
11 | 
12 |     /**
13 |      * Constructs a variable node.
14 |      *
15 |      * @param string|Expr $name       Name
16 |      * @param array       $attributes Additional attributes
17 |      */
18 |     public function __construct($name, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->name = $name;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['name'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_Variable';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/YieldFrom.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class YieldFrom extends Expr
 8 | {
 9 |     /** @var Expr Expression to yield from */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs an "yield from" node.
14 |      *
15 |      * @param Expr  $expr       Expression
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Expr_YieldFrom';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Yield_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Expr;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | 
 7 | class Yield_ extends Expr
 8 | {
 9 |     /** @var null|Expr Key expression */
10 |     public $key;
11 |     /** @var null|Expr Value expression */
12 |     public $value;
13 | 
14 |     /**
15 |      * Constructs a yield expression node.
16 |      *
17 |      * @param null|Expr $value      Value expression
18 |      * @param null|Expr $key        Key expression
19 |      * @param array     $attributes Additional attributes
20 |      */
21 |     public function __construct(?Expr $value = null, ?Expr $key = null, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->key = $key;
24 |         $this->value = $value;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['key', 'value'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Expr_Yield';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/FunctionLike.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | interface FunctionLike extends Node
 8 | {
 9 |     /**
10 |      * Whether to return by reference
11 |      *
12 |      * @return bool
13 |      */
14 |     public function returnsByRef() : bool;
15 | 
16 |     /**
17 |      * List of parameters
18 |      *
19 |      * @return Param[]
20 |      */
21 |     public function getParams() : array;
22 | 
23 |     /**
24 |      * Get the declared return type or null
25 |      *
26 |      * @return null|Identifier|Name|ComplexType
27 |      */
28 |     public function getReturnType();
29 | 
30 |     /**
31 |      * The function body
32 |      *
33 |      * @return Stmt[]|null
34 |      */
35 |     public function getStmts();
36 | 
37 |     /**
38 |      * Get PHP attribute groups.
39 |      *
40 |      * @return AttributeGroup[]
41 |      */
42 |     public function getAttrGroups() : array;
43 | }
44 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Identifier.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\NodeAbstract;
 6 | 
 7 | /**
 8 |  * Represents a non-namespaced name. Namespaced names are represented using Name nodes.
 9 |  */
10 | class Identifier extends NodeAbstract
11 | {
12 |     /** @var string Identifier as string */
13 |     public $name;
14 | 
15 |     private static $specialClassNames = [
16 |         'self'   => true,
17 |         'parent' => true,
18 |         'static' => true,
19 |     ];
20 | 
21 |     /**
22 |      * Constructs an identifier node.
23 |      *
24 |      * @param string $name       Identifier as string
25 |      * @param array  $attributes Additional attributes
26 |      */
27 |     public function __construct(string $name, array $attributes = []) {
28 |         $this->attributes = $attributes;
29 |         $this->name = $name;
30 |     }
31 | 
32 |     public function getSubNodeNames() : array {
33 |         return ['name'];
34 |     }
35 | 
36 |     /**
37 |      * Get identifier as string.
38 |      *
39 |      * @return string Identifier as string.
40 |      */
41 |     public function toString() : string {
42 |         return $this->name;
43 |     }
44 | 
45 |     /**
46 |      * Get lowercased identifier as string.
47 |      *
48 |      * @return string Lowercased identifier as string
49 |      */
50 |     public function toLowerString() : string {
51 |         return strtolower($this->name);
52 |     }
53 | 
54 |     /**
55 |      * Checks whether the identifier is a special class name (self, parent or static).
56 |      *
57 |      * @return bool Whether identifier is a special class name
58 |      */
59 |     public function isSpecialClassName() : bool {
60 |         return isset(self::$specialClassNames[strtolower($this->name)]);
61 |     }
62 | 
63 |     /**
64 |      * Get identifier as string.
65 |      *
66 |      * @return string Identifier as string
67 |      */
68 |     public function __toString() : string {
69 |         return $this->name;
70 |     }
71 |     
72 |     public function getType() : string {
73 |         return 'Identifier';
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/IntersectionType.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\NodeAbstract;
 6 | 
 7 | class IntersectionType extends ComplexType
 8 | {
 9 |     /** @var (Identifier|Name)[] Types */
10 |     public $types;
11 | 
12 |     /**
13 |      * Constructs an intersection type.
14 |      *
15 |      * @param (Identifier|Name)[] $types      Types
16 |      * @param array               $attributes Additional attributes
17 |      */
18 |     public function __construct(array $types, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->types = $types;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['types'];
25 |     }
26 | 
27 |     public function getType() : string {
28 |         return 'IntersectionType';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/MatchArm.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\NodeAbstract;
 7 | 
 8 | class MatchArm extends NodeAbstract
 9 | {
10 |     /** @var null|Node\Expr[] */
11 |     public $conds;
12 |     /** @var Node\Expr */
13 |     public $body;
14 | 
15 |     /**
16 |      * @param null|Node\Expr[] $conds
17 |      */
18 |     public function __construct($conds, Node\Expr $body, array $attributes = []) {
19 |         $this->conds = $conds;
20 |         $this->body = $body;
21 |         $this->attributes = $attributes;
22 |     }
23 | 
24 |     public function getSubNodeNames() : array {
25 |         return ['conds', 'body'];
26 |     }
27 | 
28 |     public function getType() : string {
29 |         return 'MatchArm';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Name/FullyQualified.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Name;
 4 | 
 5 | class FullyQualified extends \PhpParser\Node\Name
 6 | {
 7 |     /**
 8 |      * Checks whether the name is unqualified. (E.g. Name)
 9 |      *
10 |      * @return bool Whether the name is unqualified
11 |      */
12 |     public function isUnqualified() : bool {
13 |         return false;
14 |     }
15 | 
16 |     /**
17 |      * Checks whether the name is qualified. (E.g. Name\Name)
18 |      *
19 |      * @return bool Whether the name is qualified
20 |      */
21 |     public function isQualified() : bool {
22 |         return false;
23 |     }
24 | 
25 |     /**
26 |      * Checks whether the name is fully qualified. (E.g. \Name)
27 |      *
28 |      * @return bool Whether the name is fully qualified
29 |      */
30 |     public function isFullyQualified() : bool {
31 |         return true;
32 |     }
33 | 
34 |     /**
35 |      * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
36 |      *
37 |      * @return bool Whether the name is relative
38 |      */
39 |     public function isRelative() : bool {
40 |         return false;
41 |     }
42 | 
43 |     public function toCodeString() : string {
44 |         return '\\' . $this->toString();
45 |     }
46 |     
47 |     public function getType() : string {
48 |         return 'Name_FullyQualified';
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Name/Relative.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Name;
 4 | 
 5 | class Relative extends \PhpParser\Node\Name
 6 | {
 7 |     /**
 8 |      * Checks whether the name is unqualified. (E.g. Name)
 9 |      *
10 |      * @return bool Whether the name is unqualified
11 |      */
12 |     public function isUnqualified() : bool {
13 |         return false;
14 |     }
15 | 
16 |     /**
17 |      * Checks whether the name is qualified. (E.g. Name\Name)
18 |      *
19 |      * @return bool Whether the name is qualified
20 |      */
21 |     public function isQualified() : bool {
22 |         return false;
23 |     }
24 | 
25 |     /**
26 |      * Checks whether the name is fully qualified. (E.g. \Name)
27 |      *
28 |      * @return bool Whether the name is fully qualified
29 |      */
30 |     public function isFullyQualified() : bool {
31 |         return false;
32 |     }
33 | 
34 |     /**
35 |      * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
36 |      *
37 |      * @return bool Whether the name is relative
38 |      */
39 |     public function isRelative() : bool {
40 |         return true;
41 |     }
42 | 
43 |     public function toCodeString() : string {
44 |         return 'namespace\\' . $this->toString();
45 |     }
46 |     
47 |     public function getType() : string {
48 |         return 'Name_Relative';
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/NullableType.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | class NullableType extends ComplexType
 6 | {
 7 |     /** @var Identifier|Name Type */
 8 |     public $type;
 9 | 
10 |     /**
11 |      * Constructs a nullable type (wrapping another type).
12 |      *
13 |      * @param string|Identifier|Name $type       Type
14 |      * @param array                  $attributes Additional attributes
15 |      */
16 |     public function __construct($type, array $attributes = []) {
17 |         $this->attributes = $attributes;
18 |         $this->type = \is_string($type) ? new Identifier($type) : $type;
19 |     }
20 | 
21 |     public function getSubNodeNames() : array {
22 |         return ['type'];
23 |     }
24 |     
25 |     public function getType() : string {
26 |         return 'NullableType';
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace PhpParser\Node;
4 | 
5 | abstract class Scalar extends Expr
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/DNumber.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar;
 4 | 
 5 | use PhpParser\Node\Scalar;
 6 | 
 7 | class DNumber extends Scalar
 8 | {
 9 |     /** @var float Number value */
10 |     public $value;
11 | 
12 |     /**
13 |      * Constructs a float number scalar node.
14 |      *
15 |      * @param float $value      Value of the number
16 |      * @param array $attributes Additional attributes
17 |      */
18 |     public function __construct(float $value, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->value = $value;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['value'];
25 |     }
26 | 
27 |     /**
28 |      * @param mixed[] $attributes
29 |      */
30 |     public static function fromString(string $str, array $attributes = []): DNumber
31 |     {
32 |         $attributes['rawValue'] = $str;
33 |         $float = self::parse($str);
34 | 
35 |         return new DNumber($float, $attributes);
36 |     }
37 | 
38 |     /**
39 |      * @internal
40 |      *
41 |      * Parses a DNUMBER token like PHP would.
42 |      *
43 |      * @param string $str A string number
44 |      *
45 |      * @return float The parsed number
46 |      */
47 |     public static function parse(string $str) : float {
48 |         $str = str_replace('_', '', $str);
49 | 
50 |         // Check whether this is one of the special integer notations.
51 |         if ('0' === $str[0]) {
52 |             // hex
53 |             if ('x' === $str[1] || 'X' === $str[1]) {
54 |                 return hexdec($str);
55 |             }
56 | 
57 |             // bin
58 |             if ('b' === $str[1] || 'B' === $str[1]) {
59 |                 return bindec($str);
60 |             }
61 | 
62 |             // oct, but only if the string does not contain any of '.eE'.
63 |             if (false === strpbrk($str, '.eE')) {
64 |                 // substr($str, 0, strcspn($str, '89')) cuts the string at the first invalid digit
65 |                 // (8 or 9) so that only the digits before that are used.
66 |                 return octdec(substr($str, 0, strcspn($str, '89')));
67 |             }
68 |         }
69 | 
70 |         // dec
71 |         return (float) $str;
72 |     }
73 | 
74 |     public function getType() : string {
75 |         return 'Scalar_DNumber';
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/Encapsed.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar;
 4 | 
 5 | use PhpParser\Node\Expr;
 6 | use PhpParser\Node\Scalar;
 7 | 
 8 | class Encapsed extends Scalar
 9 | {
10 |     /** @var Expr[] list of string parts */
11 |     public $parts;
12 | 
13 |     /**
14 |      * Constructs an encapsed string node.
15 |      *
16 |      * @param Expr[] $parts      Encaps list
17 |      * @param array  $attributes Additional attributes
18 |      */
19 |     public function __construct(array $parts, array $attributes = []) {
20 |         $this->attributes = $attributes;
21 |         $this->parts = $parts;
22 |     }
23 | 
24 |     public function getSubNodeNames() : array {
25 |         return ['parts'];
26 |     }
27 |     
28 |     public function getType() : string {
29 |         return 'Scalar_Encapsed';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/EncapsedStringPart.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar;
 4 | 
 5 | use PhpParser\Node\Scalar;
 6 | 
 7 | class EncapsedStringPart extends Scalar
 8 | {
 9 |     /** @var string String value */
10 |     public $value;
11 | 
12 |     /**
13 |      * Constructs a node representing a string part of an encapsed string.
14 |      *
15 |      * @param string $value      String value
16 |      * @param array  $attributes Additional attributes
17 |      */
18 |     public function __construct(string $value, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->value = $value;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['value'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Scalar_EncapsedStringPart';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar;
 4 | 
 5 | use PhpParser\Node\Scalar;
 6 | 
 7 | abstract class MagicConst extends Scalar
 8 | {
 9 |     /**
10 |      * Constructs a magic constant node.
11 |      *
12 |      * @param array $attributes Additional attributes
13 |      */
14 |     public function __construct(array $attributes = []) {
15 |         $this->attributes = $attributes;
16 |     }
17 | 
18 |     public function getSubNodeNames() : array {
19 |         return [];
20 |     }
21 | 
22 |     /**
23 |      * Get name of magic constant.
24 |      *
25 |      * @return string Name of magic constant
26 |      */
27 |     abstract public function getName() : string;
28 | }
29 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Class_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar\MagicConst;
 4 | 
 5 | use PhpParser\Node\Scalar\MagicConst;
 6 | 
 7 | class Class_ extends MagicConst
 8 | {
 9 |     public function getName() : string {
10 |         return '__CLASS__';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Scalar_MagicConst_Class';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Dir.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar\MagicConst;
 4 | 
 5 | use PhpParser\Node\Scalar\MagicConst;
 6 | 
 7 | class Dir extends MagicConst
 8 | {
 9 |     public function getName() : string {
10 |         return '__DIR__';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Scalar_MagicConst_Dir';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/File.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar\MagicConst;
 4 | 
 5 | use PhpParser\Node\Scalar\MagicConst;
 6 | 
 7 | class File extends MagicConst
 8 | {
 9 |     public function getName() : string {
10 |         return '__FILE__';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Scalar_MagicConst_File';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Function_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar\MagicConst;
 4 | 
 5 | use PhpParser\Node\Scalar\MagicConst;
 6 | 
 7 | class Function_ extends MagicConst
 8 | {
 9 |     public function getName() : string {
10 |         return '__FUNCTION__';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Scalar_MagicConst_Function';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Line.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar\MagicConst;
 4 | 
 5 | use PhpParser\Node\Scalar\MagicConst;
 6 | 
 7 | class Line extends MagicConst
 8 | {
 9 |     public function getName() : string {
10 |         return '__LINE__';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Scalar_MagicConst_Line';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Method.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar\MagicConst;
 4 | 
 5 | use PhpParser\Node\Scalar\MagicConst;
 6 | 
 7 | class Method extends MagicConst
 8 | {
 9 |     public function getName() : string {
10 |         return '__METHOD__';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Scalar_MagicConst_Method';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Namespace_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar\MagicConst;
 4 | 
 5 | use PhpParser\Node\Scalar\MagicConst;
 6 | 
 7 | class Namespace_ extends MagicConst
 8 | {
 9 |     public function getName() : string {
10 |         return '__NAMESPACE__';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Scalar_MagicConst_Namespace';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Trait_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Scalar\MagicConst;
 4 | 
 5 | use PhpParser\Node\Scalar\MagicConst;
 6 | 
 7 | class Trait_ extends MagicConst
 8 | {
 9 |     public function getName() : string {
10 |         return '__TRAIT__';
11 |     }
12 |     
13 |     public function getType() : string {
14 |         return 'Scalar_MagicConst_Trait';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\NodeAbstract;
 6 | 
 7 | abstract class Stmt extends NodeAbstract
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Break_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Break_ extends Node\Stmt
 8 | {
 9 |     /** @var null|Node\Expr Number of loops to break */
10 |     public $num;
11 | 
12 |     /**
13 |      * Constructs a break node.
14 |      *
15 |      * @param null|Node\Expr $num        Number of loops to break
16 |      * @param array          $attributes Additional attributes
17 |      */
18 |     public function __construct(?Node\Expr $num = null, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->num = $num;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['num'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Break';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Case_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Case_ extends Node\Stmt
 8 | {
 9 |     /** @var null|Node\Expr Condition (null for default) */
10 |     public $cond;
11 |     /** @var Node\Stmt[] Statements */
12 |     public $stmts;
13 | 
14 |     /**
15 |      * Constructs a case node.
16 |      *
17 |      * @param null|Node\Expr $cond       Condition (null for default)
18 |      * @param Node\Stmt[]    $stmts      Statements
19 |      * @param array          $attributes Additional attributes
20 |      */
21 |     public function __construct($cond, array $stmts = [], array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->cond = $cond;
24 |         $this->stmts = $stmts;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['cond', 'stmts'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_Case';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Catch_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\Expr;
 7 | 
 8 | class Catch_ extends Node\Stmt
 9 | {
10 |     /** @var Node\Name[] Types of exceptions to catch */
11 |     public $types;
12 |     /** @var Expr\Variable|null Variable for exception */
13 |     public $var;
14 |     /** @var Node\Stmt[] Statements */
15 |     public $stmts;
16 | 
17 |     /**
18 |      * Constructs a catch node.
19 |      *
20 |      * @param Node\Name[]           $types      Types of exceptions to catch
21 |      * @param Expr\Variable|null    $var        Variable for exception
22 |      * @param Node\Stmt[]           $stmts      Statements
23 |      * @param array                 $attributes Additional attributes
24 |      */
25 |     public function __construct(
26 |         array $types, ?Expr\Variable $var = null, array $stmts = [], array $attributes = []
27 |     ) {
28 |         $this->attributes = $attributes;
29 |         $this->types = $types;
30 |         $this->var = $var;
31 |         $this->stmts = $stmts;
32 |     }
33 | 
34 |     public function getSubNodeNames() : array {
35 |         return ['types', 'var', 'stmts'];
36 |     }
37 | 
38 |     public function getType() : string {
39 |         return 'Stmt_Catch';
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Const_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Const_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Const_[] Constant declarations */
10 |     public $consts;
11 | 
12 |     /**
13 |      * Constructs a const list node.
14 |      *
15 |      * @param Node\Const_[] $consts     Constant declarations
16 |      * @param array         $attributes Additional attributes
17 |      */
18 |     public function __construct(array $consts, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->consts = $consts;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['consts'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Const';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Continue_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Continue_ extends Node\Stmt
 8 | {
 9 |     /** @var null|Node\Expr Number of loops to continue */
10 |     public $num;
11 | 
12 |     /**
13 |      * Constructs a continue node.
14 |      *
15 |      * @param null|Node\Expr $num        Number of loops to continue
16 |      * @param array          $attributes Additional attributes
17 |      */
18 |     public function __construct(?Node\Expr $num = null, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->num = $num;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['num'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Continue';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/DeclareDeclare.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class DeclareDeclare extends Node\Stmt
 8 | {
 9 |     /** @var Node\Identifier Key */
10 |     public $key;
11 |     /** @var Node\Expr Value */
12 |     public $value;
13 | 
14 |     /**
15 |      * Constructs a declare key=>value pair node.
16 |      *
17 |      * @param string|Node\Identifier $key        Key
18 |      * @param Node\Expr              $value      Value
19 |      * @param array                  $attributes Additional attributes
20 |      */
21 |     public function __construct($key, Node\Expr $value, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->key = \is_string($key) ? new Node\Identifier($key) : $key;
24 |         $this->value = $value;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['key', 'value'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_DeclareDeclare';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Declare_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Declare_ extends Node\Stmt
 8 | {
 9 |     /** @var DeclareDeclare[] List of declares */
10 |     public $declares;
11 |     /** @var Node\Stmt[]|null Statements */
12 |     public $stmts;
13 | 
14 |     /**
15 |      * Constructs a declare node.
16 |      *
17 |      * @param DeclareDeclare[] $declares   List of declares
18 |      * @param Node\Stmt[]|null $stmts      Statements
19 |      * @param array            $attributes Additional attributes
20 |      */
21 |     public function __construct(array $declares, ?array $stmts = null, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->declares = $declares;
24 |         $this->stmts = $stmts;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['declares', 'stmts'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_Declare';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Do_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Do_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Stmt[] Statements */
10 |     public $stmts;
11 |     /** @var Node\Expr Condition */
12 |     public $cond;
13 | 
14 |     /**
15 |      * Constructs a do while node.
16 |      *
17 |      * @param Node\Expr   $cond       Condition
18 |      * @param Node\Stmt[] $stmts      Statements
19 |      * @param array       $attributes Additional attributes
20 |      */
21 |     public function __construct(Node\Expr $cond, array $stmts = [], array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->cond = $cond;
24 |         $this->stmts = $stmts;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['stmts', 'cond'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_Do';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Echo_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Echo_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr[] Expressions */
10 |     public $exprs;
11 | 
12 |     /**
13 |      * Constructs an echo node.
14 |      *
15 |      * @param Node\Expr[] $exprs      Expressions
16 |      * @param array       $attributes Additional attributes
17 |      */
18 |     public function __construct(array $exprs, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->exprs = $exprs;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['exprs'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Echo';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ElseIf_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class ElseIf_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr Condition */
10 |     public $cond;
11 |     /** @var Node\Stmt[] Statements */
12 |     public $stmts;
13 | 
14 |     /**
15 |      * Constructs an elseif node.
16 |      *
17 |      * @param Node\Expr   $cond       Condition
18 |      * @param Node\Stmt[] $stmts      Statements
19 |      * @param array       $attributes Additional attributes
20 |      */
21 |     public function __construct(Node\Expr $cond, array $stmts = [], array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->cond = $cond;
24 |         $this->stmts = $stmts;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['cond', 'stmts'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_ElseIf';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Else_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Else_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Stmt[] Statements */
10 |     public $stmts;
11 | 
12 |     /**
13 |      * Constructs an else node.
14 |      *
15 |      * @param Node\Stmt[] $stmts      Statements
16 |      * @param array       $attributes Additional attributes
17 |      */
18 |     public function __construct(array $stmts = [], array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->stmts = $stmts;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['stmts'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Else';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/EnumCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\AttributeGroup;
 7 | 
 8 | class EnumCase extends Node\Stmt
 9 | {
10 |     /** @var Node\Identifier Enum case name */
11 |     public $name;
12 |     /** @var Node\Expr|null Enum case expression */
13 |     public $expr;
14 |     /** @var Node\AttributeGroup[] PHP attribute groups */
15 |     public $attrGroups;
16 | 
17 |     /**
18 |      * @param string|Node\Identifier    $name       Enum case name
19 |      * @param Node\Expr|null            $expr       Enum case expression
20 |      * @param AttributeGroup[]          $attrGroups PHP attribute groups
21 |      * @param array                     $attributes Additional attributes
22 |      */
23 |     public function __construct($name, ?Node\Expr $expr = null, array $attrGroups = [], array $attributes = []) {
24 |         parent::__construct($attributes);
25 |         $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
26 |         $this->expr = $expr;
27 |         $this->attrGroups = $attrGroups;
28 |     }
29 | 
30 |     public function getSubNodeNames() : array {
31 |         return ['attrGroups', 'name', 'expr'];
32 |     }
33 | 
34 |     public function getType() : string {
35 |         return 'Stmt_EnumCase';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Enum_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Enum_ extends ClassLike
 8 | {
 9 |     /** @var null|Node\Identifier Scalar Type */
10 |     public $scalarType;
11 |     /** @var Node\Name[] Names of implemented interfaces */
12 |     public $implements;
13 | 
14 |     /**
15 |      * @param string|Node\Identifier|null $name       Name
16 |      * @param array                       $subNodes   Array of the following optional subnodes:
17 |      *                                                'scalarType'  => null    : Scalar type
18 |      *                                                'implements'  => array() : Names of implemented interfaces
19 |      *                                                'stmts'       => array() : Statements
20 |      *                                                'attrGroups'  => array() : PHP attribute groups
21 |      * @param array                       $attributes Additional attributes
22 |      */
23 |     public function __construct($name, array $subNodes = [], array $attributes = []) {
24 |         $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
25 |         $this->scalarType = $subNodes['scalarType'] ?? null;
26 |         $this->implements = $subNodes['implements'] ?? [];
27 |         $this->stmts = $subNodes['stmts'] ?? [];
28 |         $this->attrGroups = $subNodes['attrGroups'] ?? [];
29 | 
30 |         parent::__construct($attributes);
31 |     }
32 | 
33 |     public function getSubNodeNames() : array {
34 |         return ['attrGroups', 'name', 'scalarType', 'implements', 'stmts'];
35 |     }
36 | 
37 |     public function getType() : string {
38 |         return 'Stmt_Enum';
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Expression.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | /**
 8 |  * Represents statements of type "expr;"
 9 |  */
10 | class Expression extends Node\Stmt
11 | {
12 |     /** @var Node\Expr Expression */
13 |     public $expr;
14 | 
15 |     /**
16 |      * Constructs an expression statement.
17 |      *
18 |      * @param Node\Expr $expr       Expression
19 |      * @param array     $attributes Additional attributes
20 |      */
21 |     public function __construct(Node\Expr $expr, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->expr = $expr;
24 |     }
25 | 
26 |     public function getSubNodeNames() : array {
27 |         return ['expr'];
28 |     }
29 |     
30 |     public function getType() : string {
31 |         return 'Stmt_Expression';
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Finally_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Finally_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Stmt[] Statements */
10 |     public $stmts;
11 | 
12 |     /**
13 |      * Constructs a finally node.
14 |      *
15 |      * @param Node\Stmt[] $stmts      Statements
16 |      * @param array       $attributes Additional attributes
17 |      */
18 |     public function __construct(array $stmts = [], array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->stmts = $stmts;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['stmts'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Finally';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/For_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class For_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr[] Init expressions */
10 |     public $init;
11 |     /** @var Node\Expr[] Loop conditions */
12 |     public $cond;
13 |     /** @var Node\Expr[] Loop expressions */
14 |     public $loop;
15 |     /** @var Node\Stmt[] Statements */
16 |     public $stmts;
17 | 
18 |     /**
19 |      * Constructs a for loop node.
20 |      *
21 |      * @param array $subNodes   Array of the following optional subnodes:
22 |      *                          'init'  => array(): Init expressions
23 |      *                          'cond'  => array(): Loop conditions
24 |      *                          'loop'  => array(): Loop expressions
25 |      *                          'stmts' => array(): Statements
26 |      * @param array $attributes Additional attributes
27 |      */
28 |     public function __construct(array $subNodes = [], array $attributes = []) {
29 |         $this->attributes = $attributes;
30 |         $this->init = $subNodes['init'] ?? [];
31 |         $this->cond = $subNodes['cond'] ?? [];
32 |         $this->loop = $subNodes['loop'] ?? [];
33 |         $this->stmts = $subNodes['stmts'] ?? [];
34 |     }
35 | 
36 |     public function getSubNodeNames() : array {
37 |         return ['init', 'cond', 'loop', 'stmts'];
38 |     }
39 |     
40 |     public function getType() : string {
41 |         return 'Stmt_For';
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Foreach_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Foreach_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr Expression to iterate */
10 |     public $expr;
11 |     /** @var null|Node\Expr Variable to assign key to */
12 |     public $keyVar;
13 |     /** @var bool Whether to assign value by reference */
14 |     public $byRef;
15 |     /** @var Node\Expr Variable to assign value to */
16 |     public $valueVar;
17 |     /** @var Node\Stmt[] Statements */
18 |     public $stmts;
19 | 
20 |     /**
21 |      * Constructs a foreach node.
22 |      *
23 |      * @param Node\Expr $expr       Expression to iterate
24 |      * @param Node\Expr $valueVar   Variable to assign value to
25 |      * @param array     $subNodes   Array of the following optional subnodes:
26 |      *                              'keyVar' => null   : Variable to assign key to
27 |      *                              'byRef'  => false  : Whether to assign value by reference
28 |      *                              'stmts'  => array(): Statements
29 |      * @param array     $attributes Additional attributes
30 |      */
31 |     public function __construct(Node\Expr $expr, Node\Expr $valueVar, array $subNodes = [], array $attributes = []) {
32 |         $this->attributes = $attributes;
33 |         $this->expr = $expr;
34 |         $this->keyVar = $subNodes['keyVar'] ?? null;
35 |         $this->byRef = $subNodes['byRef'] ?? false;
36 |         $this->valueVar = $valueVar;
37 |         $this->stmts = $subNodes['stmts'] ?? [];
38 |     }
39 | 
40 |     public function getSubNodeNames() : array {
41 |         return ['expr', 'keyVar', 'byRef', 'valueVar', 'stmts'];
42 |     }
43 |     
44 |     public function getType() : string {
45 |         return 'Stmt_Foreach';
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Global_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Global_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr[] Variables */
10 |     public $vars;
11 | 
12 |     /**
13 |      * Constructs a global variables list node.
14 |      *
15 |      * @param Node\Expr[] $vars       Variables to unset
16 |      * @param array       $attributes Additional attributes
17 |      */
18 |     public function __construct(array $vars, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->vars = $vars;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['vars'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Global';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Goto_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node\Identifier;
 6 | use PhpParser\Node\Stmt;
 7 | 
 8 | class Goto_ extends Stmt
 9 | {
10 |     /** @var Identifier Name of label to jump to */
11 |     public $name;
12 | 
13 |     /**
14 |      * Constructs a goto node.
15 |      *
16 |      * @param string|Identifier $name       Name of label to jump to
17 |      * @param array             $attributes Additional attributes
18 |      */
19 |     public function __construct($name, array $attributes = []) {
20 |         $this->attributes = $attributes;
21 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
22 |     }
23 | 
24 |     public function getSubNodeNames() : array {
25 |         return ['name'];
26 |     }
27 |     
28 |     public function getType() : string {
29 |         return 'Stmt_Goto';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/GroupUse.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node\Name;
 6 | use PhpParser\Node\Stmt;
 7 | 
 8 | class GroupUse extends Stmt
 9 | {
10 |     /** @var int Type of group use */
11 |     public $type;
12 |     /** @var Name Prefix for uses */
13 |     public $prefix;
14 |     /** @var UseUse[] Uses */
15 |     public $uses;
16 | 
17 |     /**
18 |      * Constructs a group use node.
19 |      *
20 |      * @param Name     $prefix     Prefix for uses
21 |      * @param UseUse[] $uses       Uses
22 |      * @param int      $type       Type of group use
23 |      * @param array    $attributes Additional attributes
24 |      */
25 |     public function __construct(Name $prefix, array $uses, int $type = Use_::TYPE_NORMAL, array $attributes = []) {
26 |         $this->attributes = $attributes;
27 |         $this->type = $type;
28 |         $this->prefix = $prefix;
29 |         $this->uses = $uses;
30 |     }
31 | 
32 |     public function getSubNodeNames() : array {
33 |         return ['type', 'prefix', 'uses'];
34 |     }
35 |     
36 |     public function getType() : string {
37 |         return 'Stmt_GroupUse';
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/HaltCompiler.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node\Stmt;
 6 | 
 7 | class HaltCompiler extends Stmt
 8 | {
 9 |     /** @var string Remaining text after halt compiler statement. */
10 |     public $remaining;
11 | 
12 |     /**
13 |      * Constructs a __halt_compiler node.
14 |      *
15 |      * @param string $remaining  Remaining text after halt compiler statement.
16 |      * @param array  $attributes Additional attributes
17 |      */
18 |     public function __construct(string $remaining, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->remaining = $remaining;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['remaining'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_HaltCompiler';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/If_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class If_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr Condition expression */
10 |     public $cond;
11 |     /** @var Node\Stmt[] Statements */
12 |     public $stmts;
13 |     /** @var ElseIf_[] Elseif clauses */
14 |     public $elseifs;
15 |     /** @var null|Else_ Else clause */
16 |     public $else;
17 | 
18 |     /**
19 |      * Constructs an if node.
20 |      *
21 |      * @param Node\Expr $cond       Condition
22 |      * @param array     $subNodes   Array of the following optional subnodes:
23 |      *                              'stmts'   => array(): Statements
24 |      *                              'elseifs' => array(): Elseif clauses
25 |      *                              'else'    => null   : Else clause
26 |      * @param array     $attributes Additional attributes
27 |      */
28 |     public function __construct(Node\Expr $cond, array $subNodes = [], array $attributes = []) {
29 |         $this->attributes = $attributes;
30 |         $this->cond = $cond;
31 |         $this->stmts = $subNodes['stmts'] ?? [];
32 |         $this->elseifs = $subNodes['elseifs'] ?? [];
33 |         $this->else = $subNodes['else'] ?? null;
34 |     }
35 | 
36 |     public function getSubNodeNames() : array {
37 |         return ['cond', 'stmts', 'elseifs', 'else'];
38 |     }
39 |     
40 |     public function getType() : string {
41 |         return 'Stmt_If';
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/InlineHTML.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node\Stmt;
 6 | 
 7 | class InlineHTML extends Stmt
 8 | {
 9 |     /** @var string String */
10 |     public $value;
11 | 
12 |     /**
13 |      * Constructs an inline HTML node.
14 |      *
15 |      * @param string $value      String
16 |      * @param array  $attributes Additional attributes
17 |      */
18 |     public function __construct(string $value, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->value = $value;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['value'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_InlineHTML';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Interface_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Interface_ extends ClassLike
 8 | {
 9 |     /** @var Node\Name[] Extended interfaces */
10 |     public $extends;
11 | 
12 |     /**
13 |      * Constructs a class node.
14 |      *
15 |      * @param string|Node\Identifier $name Name
16 |      * @param array  $subNodes   Array of the following optional subnodes:
17 |      *                           'extends'    => array(): Name of extended interfaces
18 |      *                           'stmts'      => array(): Statements
19 |      *                           'attrGroups' => array(): PHP attribute groups
20 |      * @param array  $attributes Additional attributes
21 |      */
22 |     public function __construct($name, array $subNodes = [], array $attributes = []) {
23 |         $this->attributes = $attributes;
24 |         $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
25 |         $this->extends = $subNodes['extends'] ?? [];
26 |         $this->stmts = $subNodes['stmts'] ?? [];
27 |         $this->attrGroups = $subNodes['attrGroups'] ?? [];
28 |     }
29 | 
30 |     public function getSubNodeNames() : array {
31 |         return ['attrGroups', 'name', 'extends', 'stmts'];
32 |     }
33 | 
34 |     public function getType() : string {
35 |         return 'Stmt_Interface';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Label.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node\Identifier;
 6 | use PhpParser\Node\Stmt;
 7 | 
 8 | class Label extends Stmt
 9 | {
10 |     /** @var Identifier Name */
11 |     public $name;
12 | 
13 |     /**
14 |      * Constructs a label node.
15 |      *
16 |      * @param string|Identifier $name       Name
17 |      * @param array             $attributes Additional attributes
18 |      */
19 |     public function __construct($name, array $attributes = []) {
20 |         $this->attributes = $attributes;
21 |         $this->name = \is_string($name) ? new Identifier($name) : $name;
22 |     }
23 | 
24 |     public function getSubNodeNames() : array {
25 |         return ['name'];
26 |     }
27 |     
28 |     public function getType() : string {
29 |         return 'Stmt_Label';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Namespace_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Namespace_ extends Node\Stmt
 8 | {
 9 |     /* For use in the "kind" attribute */
10 |     const KIND_SEMICOLON = 1;
11 |     const KIND_BRACED = 2;
12 | 
13 |     /** @var null|Node\Name Name */
14 |     public $name;
15 |     /** @var Node\Stmt[] Statements */
16 |     public $stmts;
17 | 
18 |     /**
19 |      * Constructs a namespace node.
20 |      *
21 |      * @param null|Node\Name   $name       Name
22 |      * @param null|Node\Stmt[] $stmts      Statements
23 |      * @param array            $attributes Additional attributes
24 |      */
25 |     public function __construct(?Node\Name $name = null, $stmts = [], array $attributes = []) {
26 |         $this->attributes = $attributes;
27 |         $this->name = $name;
28 |         $this->stmts = $stmts;
29 |     }
30 | 
31 |     public function getSubNodeNames() : array {
32 |         return ['name', 'stmts'];
33 |     }
34 |     
35 |     public function getType() : string {
36 |         return 'Stmt_Namespace';
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Nop.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | /** Nop/empty statement (;). */
 8 | class Nop extends Node\Stmt
 9 | {
10 |     public function getSubNodeNames() : array {
11 |         return [];
12 |     }
13 |     
14 |     public function getType() : string {
15 |         return 'Stmt_Nop';
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/PropertyProperty.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class PropertyProperty extends Node\Stmt
 8 | {
 9 |     /** @var Node\VarLikeIdentifier Name */
10 |     public $name;
11 |     /** @var null|Node\Expr Default */
12 |     public $default;
13 | 
14 |     /**
15 |      * Constructs a class property node.
16 |      *
17 |      * @param string|Node\VarLikeIdentifier $name       Name
18 |      * @param null|Node\Expr                $default    Default value
19 |      * @param array                         $attributes Additional attributes
20 |      */
21 |     public function __construct($name, ?Node\Expr $default = null, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->name = \is_string($name) ? new Node\VarLikeIdentifier($name) : $name;
24 |         $this->default = $default;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['name', 'default'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_PropertyProperty';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Return_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Return_ extends Node\Stmt
 8 | {
 9 |     /** @var null|Node\Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a return node.
14 |      *
15 |      * @param null|Node\Expr $expr       Expression
16 |      * @param array          $attributes Additional attributes
17 |      */
18 |     public function __construct(?Node\Expr $expr = null, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Return';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/StaticVar.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\Expr;
 7 | 
 8 | class StaticVar extends Node\Stmt
 9 | {
10 |     /** @var Expr\Variable Variable */
11 |     public $var;
12 |     /** @var null|Node\Expr Default value */
13 |     public $default;
14 | 
15 |     /**
16 |      * Constructs a static variable node.
17 |      *
18 |      * @param Expr\Variable  $var         Name
19 |      * @param null|Node\Expr $default    Default value
20 |      * @param array          $attributes Additional attributes
21 |      */
22 |     public function __construct(
23 |         Expr\Variable $var, ?Node\Expr $default = null, array $attributes = []
24 |     ) {
25 |         $this->attributes = $attributes;
26 |         $this->var = $var;
27 |         $this->default = $default;
28 |     }
29 | 
30 |     public function getSubNodeNames() : array {
31 |         return ['var', 'default'];
32 |     }
33 |     
34 |     public function getType() : string {
35 |         return 'Stmt_StaticVar';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Static_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node\Stmt;
 6 | 
 7 | class Static_ extends Stmt
 8 | {
 9 |     /** @var StaticVar[] Variable definitions */
10 |     public $vars;
11 | 
12 |     /**
13 |      * Constructs a static variables list node.
14 |      *
15 |      * @param StaticVar[] $vars       Variable definitions
16 |      * @param array       $attributes Additional attributes
17 |      */
18 |     public function __construct(array $vars, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->vars = $vars;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['vars'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Static';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Switch_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Switch_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr Condition */
10 |     public $cond;
11 |     /** @var Case_[] Case list */
12 |     public $cases;
13 | 
14 |     /**
15 |      * Constructs a case node.
16 |      *
17 |      * @param Node\Expr $cond       Condition
18 |      * @param Case_[]   $cases      Case list
19 |      * @param array     $attributes Additional attributes
20 |      */
21 |     public function __construct(Node\Expr $cond, array $cases, array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->cond = $cond;
24 |         $this->cases = $cases;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['cond', 'cases'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_Switch';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Throw_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Throw_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr Expression */
10 |     public $expr;
11 | 
12 |     /**
13 |      * Constructs a legacy throw statement node.
14 |      *
15 |      * @param Node\Expr $expr       Expression
16 |      * @param array     $attributes Additional attributes
17 |      */
18 |     public function __construct(Node\Expr $expr, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->expr = $expr;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['expr'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Throw';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUse.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class TraitUse extends Node\Stmt
 8 | {
 9 |     /** @var Node\Name[] Traits */
10 |     public $traits;
11 |     /** @var TraitUseAdaptation[] Adaptations */
12 |     public $adaptations;
13 | 
14 |     /**
15 |      * Constructs a trait use node.
16 |      *
17 |      * @param Node\Name[]          $traits      Traits
18 |      * @param TraitUseAdaptation[] $adaptations Adaptations
19 |      * @param array                $attributes  Additional attributes
20 |      */
21 |     public function __construct(array $traits, array $adaptations = [], array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->traits = $traits;
24 |         $this->adaptations = $adaptations;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['traits', 'adaptations'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_TraitUse';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | abstract class TraitUseAdaptation extends Node\Stmt
 8 | {
 9 |     /** @var Node\Name|null Trait name */
10 |     public $trait;
11 |     /** @var Node\Identifier Method name */
12 |     public $method;
13 | }
14 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation/Alias.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt\TraitUseAdaptation;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Alias extends Node\Stmt\TraitUseAdaptation
 8 | {
 9 |     /** @var null|int New modifier */
10 |     public $newModifier;
11 |     /** @var null|Node\Identifier New name */
12 |     public $newName;
13 | 
14 |     /**
15 |      * Constructs a trait use precedence adaptation node.
16 |      *
17 |      * @param null|Node\Name              $trait       Trait name
18 |      * @param string|Node\Identifier      $method      Method name
19 |      * @param null|int                    $newModifier New modifier
20 |      * @param null|string|Node\Identifier $newName     New name
21 |      * @param array                       $attributes  Additional attributes
22 |      */
23 |     public function __construct($trait, $method, $newModifier, $newName, array $attributes = []) {
24 |         $this->attributes = $attributes;
25 |         $this->trait = $trait;
26 |         $this->method = \is_string($method) ? new Node\Identifier($method) : $method;
27 |         $this->newModifier = $newModifier;
28 |         $this->newName = \is_string($newName) ? new Node\Identifier($newName) : $newName;
29 |     }
30 | 
31 |     public function getSubNodeNames() : array {
32 |         return ['trait', 'method', 'newModifier', 'newName'];
33 |     }
34 |     
35 |     public function getType() : string {
36 |         return 'Stmt_TraitUseAdaptation_Alias';
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation/Precedence.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt\TraitUseAdaptation;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Precedence extends Node\Stmt\TraitUseAdaptation
 8 | {
 9 |     /** @var Node\Name[] Overwritten traits */
10 |     public $insteadof;
11 | 
12 |     /**
13 |      * Constructs a trait use precedence adaptation node.
14 |      *
15 |      * @param Node\Name              $trait       Trait name
16 |      * @param string|Node\Identifier $method      Method name
17 |      * @param Node\Name[]            $insteadof   Overwritten traits
18 |      * @param array                  $attributes  Additional attributes
19 |      */
20 |     public function __construct(Node\Name $trait, $method, array $insteadof, array $attributes = []) {
21 |         $this->attributes = $attributes;
22 |         $this->trait = $trait;
23 |         $this->method = \is_string($method) ? new Node\Identifier($method) : $method;
24 |         $this->insteadof = $insteadof;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['trait', 'method', 'insteadof'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_TraitUseAdaptation_Precedence';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Trait_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Trait_ extends ClassLike
 8 | {
 9 |     /**
10 |      * Constructs a trait node.
11 |      *
12 |      * @param string|Node\Identifier $name Name
13 |      * @param array  $subNodes   Array of the following optional subnodes:
14 |      *                           'stmts'      => array(): Statements
15 |      *                           'attrGroups' => array(): PHP attribute groups
16 |      * @param array  $attributes Additional attributes
17 |      */
18 |     public function __construct($name, array $subNodes = [], array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
21 |         $this->stmts = $subNodes['stmts'] ?? [];
22 |         $this->attrGroups = $subNodes['attrGroups'] ?? [];
23 |     }
24 | 
25 |     public function getSubNodeNames() : array {
26 |         return ['attrGroups', 'name', 'stmts'];
27 |     }
28 | 
29 |     public function getType() : string {
30 |         return 'Stmt_Trait';
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TryCatch.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class TryCatch extends Node\Stmt
 8 | {
 9 |     /** @var Node\Stmt[] Statements */
10 |     public $stmts;
11 |     /** @var Catch_[] Catches */
12 |     public $catches;
13 |     /** @var null|Finally_ Optional finally node */
14 |     public $finally;
15 | 
16 |     /**
17 |      * Constructs a try catch node.
18 |      *
19 |      * @param Node\Stmt[]   $stmts      Statements
20 |      * @param Catch_[]      $catches    Catches
21 |      * @param null|Finally_ $finally    Optional finally node
22 |      * @param array         $attributes Additional attributes
23 |      */
24 |     public function __construct(array $stmts, array $catches, ?Finally_ $finally = null, array $attributes = []) {
25 |         $this->attributes = $attributes;
26 |         $this->stmts = $stmts;
27 |         $this->catches = $catches;
28 |         $this->finally = $finally;
29 |     }
30 | 
31 |     public function getSubNodeNames() : array {
32 |         return ['stmts', 'catches', 'finally'];
33 |     }
34 | 
35 |     public function getType() : string {
36 |         return 'Stmt_TryCatch';
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Unset_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class Unset_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr[] Variables to unset */
10 |     public $vars;
11 | 
12 |     /**
13 |      * Constructs an unset node.
14 |      *
15 |      * @param Node\Expr[] $vars       Variables to unset
16 |      * @param array       $attributes Additional attributes
17 |      */
18 |     public function __construct(array $vars, array $attributes = []) {
19 |         $this->attributes = $attributes;
20 |         $this->vars = $vars;
21 |     }
22 | 
23 |     public function getSubNodeNames() : array {
24 |         return ['vars'];
25 |     }
26 |     
27 |     public function getType() : string {
28 |         return 'Stmt_Unset';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/UseUse.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\Node\Identifier;
 7 | 
 8 | class UseUse extends Node\Stmt
 9 | {
10 |     /** @var int One of the Stmt\Use_::TYPE_* constants. Will only differ from TYPE_UNKNOWN for mixed group uses */
11 |     public $type;
12 |     /** @var Node\Name Namespace, class, function or constant to alias */
13 |     public $name;
14 |     /** @var Identifier|null Alias */
15 |     public $alias;
16 | 
17 |     /**
18 |      * Constructs an alias (use) node.
19 |      *
20 |      * @param Node\Name              $name       Namespace/Class to alias
21 |      * @param null|string|Identifier $alias      Alias
22 |      * @param int                    $type       Type of the use element (for mixed group use only)
23 |      * @param array                  $attributes Additional attributes
24 |      */
25 |     public function __construct(Node\Name $name, $alias = null, int $type = Use_::TYPE_UNKNOWN, array $attributes = []) {
26 |         $this->attributes = $attributes;
27 |         $this->type = $type;
28 |         $this->name = $name;
29 |         $this->alias = \is_string($alias) ? new Identifier($alias) : $alias;
30 |     }
31 | 
32 |     public function getSubNodeNames() : array {
33 |         return ['type', 'name', 'alias'];
34 |     }
35 | 
36 |     /**
37 |      * Get alias. If not explicitly given this is the last component of the used name.
38 |      *
39 |      * @return Identifier
40 |      */
41 |     public function getAlias() : Identifier {
42 |         if (null !== $this->alias) {
43 |             return $this->alias;
44 |         }
45 | 
46 |         return new Identifier($this->name->getLast());
47 |     }
48 |     
49 |     public function getType() : string {
50 |         return 'Stmt_UseUse';
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Use_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node\Stmt;
 6 | 
 7 | class Use_ extends Stmt
 8 | {
 9 |     /**
10 |      * Unknown type. Both Stmt\Use_ / Stmt\GroupUse and Stmt\UseUse have a $type property, one of them will always be
11 |      * TYPE_UNKNOWN while the other has one of the three other possible types. For normal use statements the type on the
12 |      * Stmt\UseUse is unknown. It's only the other way around for mixed group use declarations.
13 |      */
14 |     const TYPE_UNKNOWN = 0;
15 |     /** Class or namespace import */
16 |     const TYPE_NORMAL = 1;
17 |     /** Function import */
18 |     const TYPE_FUNCTION = 2;
19 |     /** Constant import */
20 |     const TYPE_CONSTANT = 3;
21 | 
22 |     /** @var int Type of alias */
23 |     public $type;
24 |     /** @var UseUse[] Aliases */
25 |     public $uses;
26 | 
27 |     /**
28 |      * Constructs an alias (use) list node.
29 |      *
30 |      * @param UseUse[] $uses       Aliases
31 |      * @param int      $type       Type of alias
32 |      * @param array    $attributes Additional attributes
33 |      */
34 |     public function __construct(array $uses, int $type = self::TYPE_NORMAL, array $attributes = []) {
35 |         $this->attributes = $attributes;
36 |         $this->type = $type;
37 |         $this->uses = $uses;
38 |     }
39 | 
40 |     public function getSubNodeNames() : array {
41 |         return ['type', 'uses'];
42 |     }
43 |     
44 |     public function getType() : string {
45 |         return 'Stmt_Use';
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/While_.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node\Stmt;
 4 | 
 5 | use PhpParser\Node;
 6 | 
 7 | class While_ extends Node\Stmt
 8 | {
 9 |     /** @var Node\Expr Condition */
10 |     public $cond;
11 |     /** @var Node\Stmt[] Statements */
12 |     public $stmts;
13 | 
14 |     /**
15 |      * Constructs a while node.
16 |      *
17 |      * @param Node\Expr   $cond       Condition
18 |      * @param Node\Stmt[] $stmts      Statements
19 |      * @param array       $attributes Additional attributes
20 |      */
21 |     public function __construct(Node\Expr $cond, array $stmts = [], array $attributes = []) {
22 |         $this->attributes = $attributes;
23 |         $this->cond = $cond;
24 |         $this->stmts = $stmts;
25 |     }
26 | 
27 |     public function getSubNodeNames() : array {
28 |         return ['cond', 'stmts'];
29 |     }
30 |     
31 |     public function getType() : string {
32 |         return 'Stmt_While';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/UnionType.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | class UnionType extends ComplexType
 6 | {
 7 |     /** @var (Identifier|Name|IntersectionType)[] Types */
 8 |     public $types;
 9 | 
10 |     /**
11 |      * Constructs a union type.
12 |      *
13 |      * @param (Identifier|Name|IntersectionType)[] $types      Types
14 |      * @param array               $attributes Additional attributes
15 |      */
16 |     public function __construct(array $types, array $attributes = []) {
17 |         $this->attributes = $attributes;
18 |         $this->types = $types;
19 |     }
20 | 
21 |     public function getSubNodeNames() : array {
22 |         return ['types'];
23 |     }
24 |     
25 |     public function getType() : string {
26 |         return 'UnionType';
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/VarLikeIdentifier.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | /**
 6 |  * Represents a name that is written in source code with a leading dollar,
 7 |  * but is not a proper variable. The leading dollar is not stored as part of the name.
 8 |  *
 9 |  * Examples: Names in property declarations are formatted as variables. Names in static property
10 |  * lookups are also formatted as variables.
11 |  */
12 | class VarLikeIdentifier extends Identifier
13 | {
14 |     public function getType() : string {
15 |         return 'VarLikeIdentifier';
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Node/VariadicPlaceholder.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Node;
 4 | 
 5 | use PhpParser\NodeAbstract;
 6 | 
 7 | /**
 8 |  * Represents the "..." in "foo(...)" of the first-class callable syntax.
 9 |  */
10 | class VariadicPlaceholder extends NodeAbstract {
11 |     /**
12 |      * Create a variadic argument placeholder (first-class callable syntax).
13 |      *
14 |      * @param array $attributes Additional attributes
15 |      */
16 |     public function __construct(array $attributes = []) {
17 |         $this->attributes = $attributes;
18 |     }
19 | 
20 |     public function getType(): string {
21 |         return 'VariadicPlaceholder';
22 |     }
23 | 
24 |     public function getSubNodeNames(): array {
25 |         return [];
26 |     }
27 | }


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/NodeTraverserInterface.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser;
 4 | 
 5 | interface NodeTraverserInterface
 6 | {
 7 |     /**
 8 |      * Adds a visitor.
 9 |      *
10 |      * @param NodeVisitor $visitor Visitor to add
11 |      */
12 |     public function addVisitor(NodeVisitor $visitor);
13 | 
14 |     /**
15 |      * Removes an added visitor.
16 |      *
17 |      * @param NodeVisitor $visitor
18 |      */
19 |     public function removeVisitor(NodeVisitor $visitor);
20 | 
21 |     /**
22 |      * Traverses an array of nodes using the registered visitors.
23 |      *
24 |      * @param Node[] $nodes Array of nodes
25 |      *
26 |      * @return Node[] Traversed array of nodes
27 |      */
28 |     public function traverse(array $nodes) : array;
29 | }
30 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser;
 4 | 
 5 | interface NodeVisitor
 6 | {
 7 |     /**
 8 |      * Called once before traversal.
 9 |      *
10 |      * Return value semantics:
11 |      *  * null:      $nodes stays as-is
12 |      *  * otherwise: $nodes is set to the return value
13 |      *
14 |      * @param Node[] $nodes Array of nodes
15 |      *
16 |      * @return null|Node[] Array of nodes
17 |      */
18 |     public function beforeTraverse(array $nodes);
19 | 
20 |     /**
21 |      * Called when entering a node.
22 |      *
23 |      * Return value semantics:
24 |      *  * null
25 |      *        => $node stays as-is
26 |      *  * NodeTraverser::DONT_TRAVERSE_CHILDREN
27 |      *        => Children of $node are not traversed. $node stays as-is
28 |      *  * NodeTraverser::STOP_TRAVERSAL
29 |      *        => Traversal is aborted. $node stays as-is
30 |      *  * otherwise
31 |      *        => $node is set to the return value
32 |      *
33 |      * @param Node $node Node
34 |      *
35 |      * @return null|int|Node Replacement node (or special return value)
36 |      */
37 |     public function enterNode(Node $node);
38 | 
39 |     /**
40 |      * Called when leaving a node.
41 |      *
42 |      * Return value semantics:
43 |      *  * null
44 |      *        => $node stays as-is
45 |      *  * NodeTraverser::REMOVE_NODE
46 |      *        => $node is removed from the parent array
47 |      *  * NodeTraverser::STOP_TRAVERSAL
48 |      *        => Traversal is aborted. $node stays as-is
49 |      *  * array (of Nodes)
50 |      *        => The return value is merged into the parent array (at the position of the $node)
51 |      *  * otherwise
52 |      *        => $node is set to the return value
53 |      *
54 |      * @param Node $node Node
55 |      *
56 |      * @return null|int|Node|Node[] Replacement node (or special return value)
57 |      */
58 |     public function leaveNode(Node $node);
59 | 
60 |     /**
61 |      * Called once after traversal.
62 |      *
63 |      * Return value semantics:
64 |      *  * null:      $nodes stays as-is
65 |      *  * otherwise: $nodes is set to the return value
66 |      *
67 |      * @param Node[] $nodes Array of nodes
68 |      *
69 |      * @return null|Node[] Array of nodes
70 |      */
71 |     public function afterTraverse(array $nodes);
72 | }
73 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CloningVisitor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\NodeVisitor;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\NodeVisitorAbstract;
 7 | 
 8 | /**
 9 |  * Visitor cloning all nodes and linking to the original nodes using an attribute.
10 |  *
11 |  * This visitor is required to perform format-preserving pretty prints.
12 |  */
13 | class CloningVisitor extends NodeVisitorAbstract
14 | {
15 |     public function enterNode(Node $origNode) {
16 |         $node = clone $origNode;
17 |         $node->setAttribute('origNode', $origNode);
18 |         return $node;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FindingVisitor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\NodeVisitor;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\NodeVisitorAbstract;
 7 | 
 8 | /**
 9 |  * This visitor can be used to find and collect all nodes satisfying some criterion determined by
10 |  * a filter callback.
11 |  */
12 | class FindingVisitor extends NodeVisitorAbstract
13 | {
14 |     /** @var callable Filter callback */
15 |     protected $filterCallback;
16 |     /** @var Node[] Found nodes */
17 |     protected $foundNodes;
18 | 
19 |     public function __construct(callable $filterCallback) {
20 |         $this->filterCallback = $filterCallback;
21 |     }
22 | 
23 |     /**
24 |      * Get found nodes satisfying the filter callback.
25 |      *
26 |      * Nodes are returned in pre-order.
27 |      *
28 |      * @return Node[] Found nodes
29 |      */
30 |     public function getFoundNodes() : array {
31 |         return $this->foundNodes;
32 |     }
33 | 
34 |     public function beforeTraverse(array $nodes) {
35 |         $this->foundNodes = [];
36 | 
37 |         return null;
38 |     }
39 | 
40 |     public function enterNode(Node $node) {
41 |         $filterCallback = $this->filterCallback;
42 |         if ($filterCallback($node)) {
43 |             $this->foundNodes[] = $node;
44 |         }
45 | 
46 |         return null;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FirstFindingVisitor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\NodeVisitor;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\NodeTraverser;
 7 | use PhpParser\NodeVisitorAbstract;
 8 | 
 9 | /**
10 |  * This visitor can be used to find the first node satisfying some criterion determined by
11 |  * a filter callback.
12 |  */
13 | class FirstFindingVisitor extends NodeVisitorAbstract
14 | {
15 |     /** @var callable Filter callback */
16 |     protected $filterCallback;
17 |     /** @var null|Node Found node */
18 |     protected $foundNode;
19 | 
20 |     public function __construct(callable $filterCallback) {
21 |         $this->filterCallback = $filterCallback;
22 |     }
23 | 
24 |     /**
25 |      * Get found node satisfying the filter callback.
26 |      *
27 |      * Returns null if no node satisfies the filter callback.
28 |      *
29 |      * @return null|Node Found node (or null if not found)
30 |      */
31 |     public function getFoundNode() {
32 |         return $this->foundNode;
33 |     }
34 | 
35 |     public function beforeTraverse(array $nodes) {
36 |         $this->foundNode = null;
37 | 
38 |         return null;
39 |     }
40 | 
41 |     public function enterNode(Node $node) {
42 |         $filterCallback = $this->filterCallback;
43 |         if ($filterCallback($node)) {
44 |             $this->foundNode = $node;
45 |             return NodeTraverser::STOP_TRAVERSAL;
46 |         }
47 | 
48 |         return null;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NodeConnectingVisitor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\NodeVisitor;
 4 | 
 5 | use PhpParser\Node;
 6 | use PhpParser\NodeVisitorAbstract;
 7 | 
 8 | /**
 9 |  * Visitor that connects a child node to its parent node
10 |  * as well as its sibling nodes.
11 |  *
12 |  * On the child node, the parent node can be accessed through
13 |  * <code>$node->getAttribute('parent')</code>, the previous
14 |  * node can be accessed through <code>$node->getAttribute('previous')</code>,
15 |  * and the next node can be accessed through <code>$node->getAttribute('next')</code>.
16 |  */
17 | final class NodeConnectingVisitor extends NodeVisitorAbstract
18 | {
19 |     /**
20 |      * @var Node[]
21 |      */
22 |     private $stack = [];
23 | 
24 |     /**
25 |      * @var ?Node
26 |      */
27 |     private $previous;
28 | 
29 |     public function beforeTraverse(array $nodes) {
30 |         $this->stack    = [];
31 |         $this->previous = null;
32 |     }
33 | 
34 |     public function enterNode(Node $node) {
35 |         if (!empty($this->stack)) {
36 |             $node->setAttribute('parent', $this->stack[count($this->stack) - 1]);
37 |         }
38 | 
39 |         if ($this->previous !== null && $this->previous->getAttribute('parent') === $node->getAttribute('parent')) {
40 |             $node->setAttribute('previous', $this->previous);
41 |             $this->previous->setAttribute('next', $node);
42 |         }
43 | 
44 |         $this->stack[] = $node;
45 |     }
46 | 
47 |     public function leaveNode(Node $node) {
48 |         $this->previous = $node;
49 | 
50 |         array_pop($this->stack);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/ParentConnectingVisitor.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\NodeVisitor;
 4 | 
 5 | use function array_pop;
 6 | use function count;
 7 | use PhpParser\Node;
 8 | use PhpParser\NodeVisitorAbstract;
 9 | 
10 | /**
11 |  * Visitor that connects a child node to its parent node.
12 |  *
13 |  * On the child node, the parent node can be accessed through
14 |  * <code>$node->getAttribute('parent')</code>.
15 |  */
16 | final class ParentConnectingVisitor extends NodeVisitorAbstract
17 | {
18 |     /**
19 |      * @var Node[]
20 |      */
21 |     private $stack = [];
22 | 
23 |     public function beforeTraverse(array $nodes)
24 |     {
25 |         $this->stack = [];
26 |     }
27 | 
28 |     public function enterNode(Node $node)
29 |     {
30 |         if (!empty($this->stack)) {
31 |             $node->setAttribute('parent', $this->stack[count($this->stack) - 1]);
32 |         }
33 | 
34 |         $this->stack[] = $node;
35 |     }
36 | 
37 |     public function leaveNode(Node $node)
38 |     {
39 |         array_pop($this->stack);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/NodeVisitorAbstract.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser;
 4 | 
 5 | /**
 6 |  * @codeCoverageIgnore
 7 |  */
 8 | class NodeVisitorAbstract implements NodeVisitor
 9 | {
10 |     public function beforeTraverse(array $nodes) {
11 |         return null;
12 |     }
13 | 
14 |     public function enterNode(Node $node) {
15 |         return null;
16 |     }
17 | 
18 |     public function leaveNode(Node $node) {
19 |         return null;
20 |     }
21 | 
22 |     public function afterTraverse(array $nodes) {
23 |         return null;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Parser.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser;
 4 | 
 5 | interface Parser
 6 | {
 7 |     /**
 8 |      * Parses PHP code into a node tree.
 9 |      *
10 |      * @param string $code The source code to parse
11 |      * @param ErrorHandler|null $errorHandler Error handler to use for lexer/parser errors, defaults
12 |      *                                        to ErrorHandler\Throwing.
13 |      *
14 |      * @return Node\Stmt[]|null Array of statements (or null non-throwing error handler is used and
15 |      *                          the parser was unable to recover from an error).
16 |      */
17 |     public function parse(string $code, ?ErrorHandler $errorHandler = null);
18 | }
19 | 


--------------------------------------------------------------------------------
/vendor/nikic/php-parser/lib/PhpParser/Parser/Multiple.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace PhpParser\Parser;
 4 | 
 5 | use PhpParser\Error;
 6 | use PhpParser\ErrorHandler;
 7 | use PhpParser\Parser;
 8 | 
 9 | class Multiple implements Parser
10 | {
11 |     /** @var Parser[] List of parsers to try, in order of preference */
12 |     private $parsers;
13 | 
14 |     /**
15 |      * Create a parser which will try multiple parsers in an order of preference.
16 |      *
17 |      * Parsers will be invoked in the order they're provided to the constructor. If one of the
18 |      * parsers runs without throwing, it's output is returned. Otherwise the exception that the
19 |      * first parser generated is thrown.
20 |      *
21 |      * @param Parser[] $parsers
22 |      */
23 |     public function __construct(array $parsers) {
24 |         $this->parsers = $parsers;
25 |     }
26 | 
27 |     public function parse(string $code, ?ErrorHandler $errorHandler = null) {
28 |         if (null === $errorHandler) {
29 |             $errorHandler = new ErrorHandler\Throwing;
30 |         }
31 | 
32 |         list($firstStmts, $firstError) = $this->tryParse($this->parsers[0], $errorHandler, $code);
33 |         if ($firstError === null) {
34 |             return $firstStmts;
35 |         }
36 | 
37 |         for ($i = 1, $c = count($this->parsers); $i < $c; ++$i) {
38 |             list($stmts, $error) = $this->tryParse($this->parsers[$i], $errorHandler, $code);
39 |             if ($error === null) {
40 |                 return $stmts;
41 |             }
42 |         }
43 | 
44 |         throw $firstError;
45 |     }
46 | 
47 |     private function tryParse(Parser $parser, ErrorHandler $errorHandler, $code) {
48 |         $stmts = null;
49 |         $error = null;
50 |         try {
51 |             $stmts = $parser->parse($code, $errorHandler);
52 |         } catch (Error $error) {}
53 |         return [$stmts, $error];
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------