Uzly stromu
***********

.[perex]
Referenční přehled všech tříd uzlů: popis a sloty s typem. Slot je pojmenovaný rolí, ne textem (`ifKeyword`, `openParen`, `body`), párové oddělovače jsou vždy `open*` a `close*`, seznamy jsou v množném čísle; `?` značí slot, který může být prázdný.

Všechny třídy leží v `PhpSyntax\Nodes`. Slot typu `Token` drží jeden token, `NodeList<T>` seznam uzlů bez oddělovačů, `SeparatedNodeList<T>` seznam s oddělovači (čárky, středníky) mezi položkami. Jak strom číst a měnit, říkají stránky [Strom |tree] a [Úpravy |mutation].


Společné uzly
=============

Kořen souboru, jména, seznamy, parametry, argumenty, atributy a části řídicích struktur.


NameNode
--------

Name of a class, function, constant or namespace: one token of any kind, including keywords the grammar accepts as names (static, array, readonly). Rozšiřuje `Node`. Implementuje `Stringable`.

- `token`: `Token`


IdentifierNode
--------------

Identifier of a member, label, hook or alias: one token of any kind, including reserved words. Rozšiřuje `Node`. Implementuje `Stringable`.

- `token`: `Token`


ArgumentListNode
----------------

Parenthesized arguments of a call, instantiation, attribute or exit. Rozšiřuje `Node`. Implementuje `Stringable`.

- `openParen`: `Token`
- `args`: `SeparatedNodeList<ArgumentNode|VariadicPlaceholderNode|ArgumentPlaceholderNode>`
- `closeParen`: `Token`


ArgumentNode
------------

Argument of a call: optionally named, by reference or unpacked. Rozšiřuje `Node`. Implementuje `Stringable`.

- `name`: `?IdentifierNode`
- `colon`: `?Token`
- `byRef`: `?Token`
- `ellipsis`: `?Token`
- `expr`: `ExpressionNode`


VariadicPlaceholderNode
-----------------------

The ... placeholder of a first-class callable: f(...). Rozšiřuje `Node`. Implementuje `Stringable`.

- `ellipsis`: `Token`


ArgumentPlaceholderNode
-----------------------

The ? placeholder of a partial function application, optionally named: f(?), f(name: ?). Rozšiřuje `Node`. Implementuje `Stringable`.

- `name`: `?IdentifierNode`
- `colon`: `?Token`
- `question`: `Token`


ParameterNode
-------------

Parameter of a function, method, closure or hook; with modifiers it promotes a property. Rozšiřuje `Node`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `modifiers`: `ModifiersNode`
- `type`: `?TypeNode`
- `byRef`: `?Token`
- `ellipsis`: `?Token`
- `var`: `Expression\VariableNode`
- `equals`: `?Token`
- `default`: `?ExpressionNode`
- `openBrace`: `?Token`
- `hooks`: `?NodeList<Member\PropertyHookNode>`
- `closeBrace`: `?Token`


AttributeGroupNode
------------------

One `#[...]` group of attributes. Rozšiřuje `Node`. Implementuje `Stringable`.

- `openAttribute`: `Token`
- `attributes`: `SeparatedNodeList<AttributeNode>`
- `closeBracket`: `Token`


AttributeNode
-------------

Attribute with optional arguments. Rozšiřuje `Node`. Implementuje `Stringable`.

- `name`: `NameNode`
- `args`: `?ArgumentListNode`


ModifiersNode
-------------

Modifier keywords in source order (public, static, readonly, abstract, final, var, public(set)...); may be empty. Rozšiřuje `Node`. Implementuje `Stringable`.

- `tokens`: `list<Token>`


NodeList
--------

Sequence of nodes without separators: statements, members, attribute groups. Rozšiřuje `Node`. Implementuje `Stringable`, `Countable`.

- `items`: `list<Node>`


SeparatedNodeList
-----------------

Sequence of nodes with separator tokens between them and an optional trailing separator: parameters, arguments, array items, imports. An item may be an empty node standing for nothing between two separators `([, $b]` = $x). Rozšiřuje `Node`. Implementuje `Stringable`, `Countable`.

- `items`: `list<Node>`
- `separators`: `list<Token>`


FileNode
--------

Root of the tree: the statements of a file and the end-of-file token carrying the trailing trivia. Rozšiřuje `Node`. Implementuje `Stringable`.

- `stmts`: `NodeList<StatementNode>`
- `eof`: `Token`


AnonymousClassNode
------------------

Anonymous class in a new expression: new class(...) extends A implements B { ... }. Rozšiřuje `Node`. Implementuje `Stringable`, `ClassLikeNode`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `modifiers`: `ModifiersNode`
- `classKeyword`: `Token`
- `args`: `?ArgumentListNode`
- `extendsKeyword`: `?Token`
- `extends`: `?NameNode`
- `implementsKeyword`: `?Token`
- `implements`: `?SeparatedNodeList<NameNode>`
- `openBrace`: `Token`
- `members`: `NodeList<MemberNode>`
- `closeBrace`: `Token`


ArrayItemNode
-------------

Item of an array literal or a destructuring list: value with optional key, by reference or unpacked. Rozšiřuje `Node`. Implementuje `Stringable`.

- `key`: `?ExpressionNode`
- `doubleArrow`: `?Token`
- `byRef`: `?Token`
- `ellipsis`: `?Token`
- `value`: `ExpressionNode`


EmptyArrayItemNode
------------------

Skipped item of a destructuring list `([, $b]` = $x); has no tokens. Rozšiřuje `Node`. Implementuje `Stringable`.


MatchArmNode
------------

Arm of a match expression: conditions or default, and the result. Rozšiřuje `Node`. Implementuje `Stringable`.

- `conds`: `?SeparatedNodeList<ExpressionNode>`
- `defaultKeyword`: `?Token`
- `defaultComma`: `?Token`
- `doubleArrow`: `Token`
- `body`: `ExpressionNode`


ClosureUsesNode
---------------

The use (...) clause of a closure. Rozšiřuje `Node`. Implementuje `Stringable`.

- `useKeyword`: `Token`
- `openParen`: `Token`
- `vars`: `SeparatedNodeList<ClosureUseNode>`
- `closeParen`: `Token`


ClosureUseNode
--------------

Variable captured by a closure, optionally by reference. Rozšiřuje `Node`. Implementuje `Stringable`.

- `byRef`: `?Token`
- `var`: `Expression\VariableNode`


ElseIfNode
----------

elseif branch, in either syntax. Rozšiřuje `Node`. Implementuje `Stringable`.

- `elseifKeyword`: `Token`
- `openParen`: `Token`
- `cond`: `ExpressionNode`
- `closeParen`: `Token`
- `body`: `?StatementNode`
- `colon`: `?Token`
- `stmts`: `?NodeList<StatementNode>`


ElseNode
--------

else branch, in either syntax; else if is an else with an if statement as the body. Rozšiřuje `Node`. Implementuje `Stringable`.

- `elseKeyword`: `Token`
- `body`: `?StatementNode`
- `colon`: `?Token`
- `stmts`: `?NodeList<StatementNode>`


CaseNode
--------

case or default of a switch; the separator is a colon or a semicolon. Rozšiřuje `Node`. Implementuje `Stringable`.

- `caseKeyword`: `Token`
- `cond`: `?ExpressionNode`
- `separator`: `Token`
- `stmts`: `NodeList<StatementNode>`


CatchNode
---------

catch clause with one or more types and an optional variable. Rozšiřuje `Node`. Implementuje `Stringable`.

- `catchKeyword`: `Token`
- `openParen`: `Token`
- `types`: `SeparatedNodeList<NameNode>`
- `var`: `?Expression\VariableNode`
- `closeParen`: `Token`
- `body`: `Statement\BlockNode`


FinallyNode
-----------

finally clause. Rozšiřuje `Node`. Implementuje `Stringable`.

- `finallyKeyword`: `Token`
- `body`: `Statement\BlockNode`


DeclareItemNode
---------------

Directive of a declare statement: strict_types=1. Rozšiřuje `Node`. Implementuje `Stringable`.

- `name`: `IdentifierNode`
- `equals`: `Token`
- `value`: `ExpressionNode`


StaticVarNode
-------------

Variable of a static statement with an optional initializer. Rozšiřuje `Node`. Implementuje `Stringable`.

- `var`: `Expression\VariableNode`
- `equals`: `?Token`
- `default`: `?ExpressionNode`


UseItemNode
-----------

Imported name with an optional alias; the type (function, const) appears only inside a group use. Rozšiřuje `Node`. Implementuje `Stringable`.

- `type`: `?Token`
- `name`: `NameNode`
- `asKeyword`: `?Token`
- `alias`: `?IdentifierNode`


ConstItemNode
-------------

Constant of a const statement or a class constant declaration. Rozšiřuje `Node`. Implementuje `Stringable`.

- `name`: `IdentifierNode`
- `equals`: `Token`
- `value`: `ExpressionNode`


Příkazy
=======

Deklarace a příkazy: `Statement\*` jsou položky seznamu `stmts` souboru, bloku nebo jmenného prostoru.


NamespaceNode
-------------

namespace declaration; after "namespace A;" the following statements are nested in it. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `namespaceKeyword`: `Token`
- `name`: `?NameNode`
- `semicolon`: `?Token`
- `openBrace`: `?Token`
- `stmts`: `NodeList<StatementNode>`
- `closeBrace`: `?Token`


UseNode
-------

use import of classes, functions or constants. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `useKeyword`: `Token`
- `type`: `?Token`
- `items`: `SeparatedNodeList<UseItemNode>`
- `semicolon`: `Token`


GroupUseNode
------------

Group use import: use A\{B, C};. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `useKeyword`: `Token`
- `type`: `?Token`
- `prefix`: `NameNode`
- `namespaceSeparator`: `Token`
- `openBrace`: `Token`
- `items`: `SeparatedNodeList<UseItemNode>`
- `closeBrace`: `Token`
- `semicolon`: `Token`


ConstNode
---------

const statement outside a class. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `constKeyword`: `Token`
- `items`: `SeparatedNodeList<ConstItemNode>`
- `semicolon`: `Token`


HaltCompilerNode
----------------

__halt_compiler(); the rest of the file is the data token. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `haltKeyword`: `Token`
- `openParen`: `Token`
- `closeParen`: `Token`
- `semicolon`: `Token`
- `data`: `?Token`


InlineHtmlNode
--------------

Text outside PHP tags, including a BOM or a hashbang line. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `html`: `Token`


EmptyStatementNode
------------------

Bare semicolon, or a close tag after a terminated statement. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `semicolon`: `Token`


ExpressionStatementNode
-----------------------

Expression as a statement. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `expr`: `ExpressionNode`
- `semicolon`: `Token`


BlockNode
---------

Statements in braces. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `openBrace`: `Token`
- `stmts`: `NodeList<StatementNode>`
- `closeBrace`: `Token`


IfNode
------

if statement in either syntax; the body is a statement, the alternative syntax fills stmts. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `ifKeyword`: `Token`
- `openParen`: `Token`
- `cond`: `ExpressionNode`
- `closeParen`: `Token`
- `body`: `?StatementNode`
- `colon`: `?Token`
- `stmts`: `?NodeList<StatementNode>`
- `elseifs`: `NodeList<ElseIfNode>`
- `else`: `?ElseNode`
- `endKeyword`: `?Token`
- `semicolon`: `?Token`


WhileNode
---------

while loop in either syntax. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `whileKeyword`: `Token`
- `openParen`: `Token`
- `cond`: `ExpressionNode`
- `closeParen`: `Token`
- `body`: `?StatementNode`
- `colon`: `?Token`
- `stmts`: `?NodeList<StatementNode>`
- `endKeyword`: `?Token`
- `semicolon`: `?Token`


DoWhileNode
-----------

do-while loop. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `doKeyword`: `Token`
- `body`: `StatementNode`
- `whileKeyword`: `Token`
- `openParen`: `Token`
- `cond`: `ExpressionNode`
- `closeParen`: `Token`
- `semicolon`: `Token`


ForNode
-------

for loop in either syntax. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `forKeyword`: `Token`
- `openParen`: `Token`
- `init`: `SeparatedNodeList<ExpressionNode>`
- `initSemicolon`: `Token`
- `cond`: `SeparatedNodeList<ExpressionNode>`
- `condSemicolon`: `Token`
- `loop`: `SeparatedNodeList<ExpressionNode>`
- `closeParen`: `Token`
- `body`: `?StatementNode`
- `colon`: `?Token`
- `stmts`: `?NodeList<StatementNode>`
- `endKeyword`: `?Token`
- `semicolon`: `?Token`


ForeachNode
-----------

foreach loop in either syntax; the value may be a variable, a list or an array pattern. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `foreachKeyword`: `Token`
- `openParen`: `Token`
- `expr`: `ExpressionNode`
- `asKeyword`: `Token`
- `keyVar`: `?ExpressionNode`
- `doubleArrow`: `?Token`
- `byRef`: `?Token`
- `valueVar`: `ExpressionNode`
- `closeParen`: `Token`
- `body`: `?StatementNode`
- `colon`: `?Token`
- `stmts`: `?NodeList<StatementNode>`
- `endKeyword`: `?Token`
- `semicolon`: `?Token`


SwitchNode
----------

switch statement in either syntax; a semicolon may precede the first case. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `switchKeyword`: `Token`
- `openParen`: `Token`
- `cond`: `ExpressionNode`
- `closeParen`: `Token`
- `openBrace`: `?Token`
- `colon`: `?Token`
- `leadingSemicolon`: `?Token`
- `cases`: `NodeList<CaseNode>`
- `closeBrace`: `?Token`
- `endKeyword`: `?Token`
- `semicolon`: `?Token`


BreakNode
---------

break with an optional level. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `breakKeyword`: `Token`
- `expr`: `?ExpressionNode`
- `semicolon`: `Token`


ContinueNode
------------

continue with an optional level. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `continueKeyword`: `Token`
- `expr`: `?ExpressionNode`
- `semicolon`: `Token`


ReturnNode
----------

return with an optional value. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `returnKeyword`: `Token`
- `expr`: `?ExpressionNode`
- `semicolon`: `Token`


GlobalNode
----------

global statement. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `globalKeyword`: `Token`
- `vars`: `SeparatedNodeList<ExpressionNode>`
- `semicolon`: `Token`


StaticNode
----------

static variable declaration. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `staticKeyword`: `Token`
- `vars`: `SeparatedNodeList<StaticVarNode>`
- `semicolon`: `Token`


EchoNode
--------

echo statement; the keyword may be the <?= open tag and the semicolon a close tag. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `echoKeyword`: `Token`
- `exprs`: `SeparatedNodeList<ExpressionNode>`
- `semicolon`: `Token`


UnsetNode
---------

unset statement. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `unsetKeyword`: `Token`
- `openParen`: `Token`
- `vars`: `SeparatedNodeList<ExpressionNode>`
- `closeParen`: `Token`
- `semicolon`: `Token`


DeclareNode
-----------

declare statement in its three forms: with a body, with a bare semicolon, or with the alternative syntax. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `declareKeyword`: `Token`
- `openParen`: `Token`
- `items`: `SeparatedNodeList<DeclareItemNode>`
- `closeParen`: `Token`
- `body`: `?StatementNode`
- `colon`: `?Token`
- `stmts`: `?NodeList<StatementNode>`
- `endKeyword`: `?Token`
- `semicolon`: `?Token`


TryNode
-------

try statement with catches and an optional finally. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `tryKeyword`: `Token`
- `body`: `Statement\BlockNode`
- `catches`: `NodeList<CatchNode>`
- `finally`: `?FinallyNode`


GotoNode
--------

goto statement. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `gotoKeyword`: `Token`
- `label`: `IdentifierNode`
- `semicolon`: `Token`


LabelNode
---------

Label for goto. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `name`: `IdentifierNode`
- `colon`: `Token`


FunctionNode
------------

Function declaration. Rozšiřuje `StatementNode`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `functionKeyword`: `Token`
- `byRef`: `?Token`
- `name`: `IdentifierNode`
- `openParen`: `Token`
- `params`: `SeparatedNodeList<ParameterNode>`
- `closeParen`: `Token`
- `colon`: `?Token`
- `returnType`: `?TypeNode`
- `body`: `Statement\BlockNode`


ClassNode
---------

Class declaration. Rozšiřuje `StatementNode`. Implementuje `Stringable`, `ClassLikeNode`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `modifiers`: `ModifiersNode`
- `classKeyword`: `Token`
- `name`: `IdentifierNode`
- `extendsKeyword`: `?Token`
- `extends`: `?NameNode`
- `implementsKeyword`: `?Token`
- `implements`: `?SeparatedNodeList<NameNode>`
- `openBrace`: `Token`
- `members`: `NodeList<MemberNode>`
- `closeBrace`: `Token`


InterfaceNode
-------------

Interface declaration. Rozšiřuje `StatementNode`. Implementuje `Stringable`, `ClassLikeNode`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `interfaceKeyword`: `Token`
- `name`: `IdentifierNode`
- `extendsKeyword`: `?Token`
- `extends`: `?SeparatedNodeList<NameNode>`
- `openBrace`: `Token`
- `members`: `NodeList<MemberNode>`
- `closeBrace`: `Token`


TraitNode
---------

Trait declaration. Rozšiřuje `StatementNode`. Implementuje `Stringable`, `ClassLikeNode`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `traitKeyword`: `Token`
- `name`: `IdentifierNode`
- `openBrace`: `Token`
- `members`: `NodeList<MemberNode>`
- `closeBrace`: `Token`


EnumNode
--------

Enum declaration, optionally backed by a scalar type. Rozšiřuje `StatementNode`. Implementuje `Stringable`, `ClassLikeNode`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `enumKeyword`: `Token`
- `name`: `IdentifierNode`
- `colon`: `?Token`
- `scalarType`: `?TypeNode`
- `implementsKeyword`: `?Token`
- `implements`: `?SeparatedNodeList<NameNode>`
- `openBrace`: `Token`
- `members`: `NodeList<MemberNode>`
- `closeBrace`: `Token`


Výrazy
======

Vše, co má hodnotu: operátory, volání, přístupy, přiřazení, closures.


VariableNode
------------

Variable: $a, $$a, ${expr}; inside a string also a bare name in ${name}. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `dollar`: `?Token`
- `openBrace`: `?Token`
- `name`: `Token|ExpressionNode`
- `closeBrace`: `?Token`


ArrayDimFetchNode
-----------------

Array or string offset access: `$a[$i],` `$a[]`. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `var`: `ExpressionNode`
- `openBracket`: `Token`
- `dim`: `?ExpressionNode`
- `closeBracket`: `Token`


PropertyFetchNode
-----------------

Property access with -> or ?->; the name may be an identifier, a variable or a braced expression. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `object`: `ExpressionNode`
- `operator`: `Token`
- `openBrace`: `?Token`
- `name`: `IdentifierNode|ExpressionNode`
- `closeBrace`: `?Token`


StaticPropertyFetchNode
-----------------------

Static property access: A::$b. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `class`: `NameNode|ExpressionNode`
- `doubleColon`: `Token`
- `name`: `Expression\VariableNode`


ClassConstantFetchNode
----------------------

Class constant access: A::B, A::class, A::{expr}. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `class`: `NameNode|ExpressionNode`
- `doubleColon`: `Token`
- `openBrace`: `?Token`
- `name`: `IdentifierNode|ExpressionNode`
- `closeBrace`: `?Token`


ConstantFetchNode
-----------------

Constant access by name: FOO, \Foo\BAR, true. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `name`: `NameNode`


FunctionCallNode
----------------

Function call by name or on an expression. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `name`: `NameNode|ExpressionNode`
- `args`: `ArgumentListNode`


MethodCallNode
--------------

Method call with -> or ?->. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `object`: `ExpressionNode`
- `operator`: `Token`
- `openBrace`: `?Token`
- `name`: `IdentifierNode|ExpressionNode`
- `closeBrace`: `?Token`
- `args`: `ArgumentListNode`


StaticCallNode
--------------

Static method call: A::b(), $a::b(), A::{expr}(). Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `class`: `NameNode|ExpressionNode`
- `doubleColon`: `Token`
- `openBrace`: `?Token`
- `name`: `IdentifierNode|ExpressionNode`
- `closeBrace`: `?Token`
- `args`: `ArgumentListNode`


NewNode
-------

Instantiation of a named, dynamic or anonymous class. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `newKeyword`: `Token`
- `class`: `NameNode|ExpressionNode|AnonymousClassNode`
- `args`: `?ArgumentListNode`


ArrayNode
---------

Array literal in either syntax: `[...]` or array(...); on the left of an assignment it destructures. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `arrayKeyword`: `?Token`
- `openDelimiter`: `Token`
- `items`: `SeparatedNodeList<ArrayItemNode|EmptyArrayItemNode>`
- `closeDelimiter`: `Token`


ListNode
--------

Destructuring with list(...). Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `listKeyword`: `Token`
- `openParen`: `Token`
- `items`: `SeparatedNodeList<ArrayItemNode|EmptyArrayItemNode>`
- `closeParen`: `Token`


AssignNode
----------

Assignment, plain or compound (+=, ??=); the operator token tells which. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `var`: `ExpressionNode`
- `operator`: `Token`
- `expr`: `ExpressionNode`


AssignRefNode
-------------

Assignment by reference: $a = &$b. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `var`: `ExpressionNode`
- `equals`: `Token`
- `ampersand`: `Token`
- `expr`: `ExpressionNode`


BinaryNode
----------

Binary operation; the operator token tells which (arithmetic, comparison, logical, bitwise, concatenation, coalesce, pipe). Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `left`: `ExpressionNode`
- `operator`: `Token`
- `right`: `ExpressionNode`


UnaryNode
---------

Prefix operation: +, -, !, ~, @, ++, --. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `operator`: `Token`
- `expr`: `ExpressionNode`


PostfixNode
-----------

Postfix increment or decrement. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `expr`: `ExpressionNode`
- `operator`: `Token`


CastNode
--------

Type cast; the cast token keeps its spelling including inner whitespace: ( int ). Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `cast`: `Token`
- `expr`: `ExpressionNode`


TernaryNode
-----------

Ternary conditional ($cond ? $if : $else) or the elvis form ($cond ?: $else). Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `cond`: `ExpressionNode`
- `question`: `Token`
- `if`: `?ExpressionNode`
- `colon`: `Token`
- `else`: `ExpressionNode`


InstanceofNode
--------------

instanceof check against a name or a dynamic class. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `expr`: `ExpressionNode`
- `instanceofKeyword`: `Token`
- `class`: `NameNode|ExpressionNode`


ParenthesizedNode
-----------------

Expression in parentheses. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `openParen`: `Token`
- `expr`: `ExpressionNode`
- `closeParen`: `Token`


IssetNode
---------

isset(...) with one or more variables. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `issetKeyword`: `Token`
- `openParen`: `Token`
- `vars`: `SeparatedNodeList<ExpressionNode>`
- `closeParen`: `Token`


EmptyNode
---------

empty(...). Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `emptyKeyword`: `Token`
- `openParen`: `Token`
- `expr`: `ExpressionNode`
- `closeParen`: `Token`


EvalNode
--------

eval(...). Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `evalKeyword`: `Token`
- `openParen`: `Token`
- `expr`: `ExpressionNode`
- `closeParen`: `Token`


IncludeNode
-----------

include, include_once, require or require_once; the keyword token tells which. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `includeKeyword`: `Token`
- `expr`: `ExpressionNode`


ExitNode
--------

exit or die with optional arguments. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `exitKeyword`: `Token`
- `args`: `?ArgumentListNode`


PrintNode
---------

print expression. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `printKeyword`: `Token`
- `expr`: `ExpressionNode`


YieldNode
---------

yield, yield $value or yield $key => $value. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `yieldKeyword`: `Token`
- `key`: `?ExpressionNode`
- `doubleArrow`: `?Token`
- `value`: `?ExpressionNode`


YieldFromNode
-------------

yield from expression. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `yieldFromKeyword`: `Token`
- `expr`: `ExpressionNode`


ThrowNode
---------

throw expression. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `throwKeyword`: `Token`
- `expr`: `ExpressionNode`


CloneNode
---------

clone expression; clone(...) with arguments is a function call. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `cloneKeyword`: `Token`
- `expr`: `ExpressionNode`


MatchNode
---------

match expression. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `matchKeyword`: `Token`
- `openParen`: `Token`
- `cond`: `ExpressionNode`
- `closeParen`: `Token`
- `openBrace`: `Token`
- `arms`: `SeparatedNodeList<MatchArmNode>`
- `closeBrace`: `Token`


ClosureNode
-----------

Anonymous function, optionally static, with captured variables. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `staticKeyword`: `?Token`
- `functionKeyword`: `Token`
- `byRef`: `?Token`
- `openParen`: `Token`
- `params`: `SeparatedNodeList<ParameterNode>`
- `closeParen`: `Token`
- `uses`: `?ClosureUsesNode`
- `colon`: `?Token`
- `returnType`: `?TypeNode`
- `body`: `Statement\BlockNode`


ArrowFunctionNode
-----------------

Arrow function fn(...) => expr, optionally static. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `staticKeyword`: `?Token`
- `fnKeyword`: `Token`
- `byRef`: `?Token`
- `openParen`: `Token`
- `params`: `SeparatedNodeList<ParameterNode>`
- `closeParen`: `Token`
- `colon`: `?Token`
- `returnType`: `?TypeNode`
- `doubleArrow`: `Token`
- `expr`: `ExpressionNode`


ShellExecNode
-------------

Command in backticks with interpolation. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `openBacktick`: `Token`
- `parts`: `NodeList<Scalar\InterpolatedStringPartNode|Scalar\InterpolationNode|ExpressionNode>`
- `closeBacktick`: `Token`


Členy tříd
==========

Vlastnosti, konstanty, metody, případy výčtu, hooky a použití traitů.


PropertyNode
------------

Property declaration; one or more properties, optionally with hooks. Rozšiřuje `MemberNode`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `modifiers`: `ModifiersNode`
- `type`: `?TypeNode`
- `items`: `SeparatedNodeList<Member\PropertyItemNode>`
- `semicolon`: `?Token`
- `openBrace`: `?Token`
- `hooks`: `?NodeList<Member\PropertyHookNode>`
- `closeBrace`: `?Token`


PropertyItemNode
----------------

One property of a declaration with an optional default. Rozšiřuje `Node`. Implementuje `Stringable`.

- `name`: `Token`
- `equals`: `?Token`
- `default`: `?ExpressionNode`


PropertyHookNode
----------------

Property hook (get, set) with a block body, an arrow body or none. Rozšiřuje `Node`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `modifiers`: `ModifiersNode`
- `byRef`: `?Token`
- `name`: `IdentifierNode`
- `openParen`: `?Token`
- `params`: `?SeparatedNodeList<ParameterNode>`
- `closeParen`: `?Token`
- `body`: `?Statement\BlockNode`
- `doubleArrow`: `?Token`
- `expr`: `?ExpressionNode`
- `semicolon`: `?Token`


ClassConstNode
--------------

Class constant declaration, optionally typed. Rozšiřuje `MemberNode`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `modifiers`: `ModifiersNode`
- `constKeyword`: `Token`
- `type`: `?TypeNode`
- `items`: `SeparatedNodeList<ConstItemNode>`
- `semicolon`: `Token`


MethodNode
----------

Method declaration; abstract and interface methods end with a semicolon instead of a body. Rozšiřuje `MemberNode`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `modifiers`: `ModifiersNode`
- `functionKeyword`: `Token`
- `byRef`: `?Token`
- `name`: `IdentifierNode`
- `openParen`: `Token`
- `params`: `SeparatedNodeList<ParameterNode>`
- `closeParen`: `Token`
- `colon`: `?Token`
- `returnType`: `?TypeNode`
- `body`: `?Statement\BlockNode`
- `semicolon`: `?Token`


TraitUseNode
------------

use of traits with optional adaptations in braces. Rozšiřuje `MemberNode`. Implementuje `Stringable`.

- `useKeyword`: `Token`
- `traits`: `SeparatedNodeList<NameNode>`
- `semicolon`: `?Token`
- `openBrace`: `?Token`
- `adaptations`: `?NodeList<Member\TraitPrecedenceNode|Member\TraitAliasNode>`
- `closeBrace`: `?Token`


TraitPrecedenceNode
-------------------

Trait adaptation A::m insteadof B;. Rozšiřuje `Node`. Implementuje `Stringable`.

- `trait`: `NameNode`
- `doubleColon`: `Token`
- `method`: `IdentifierNode`
- `insteadofKeyword`: `Token`
- `traits`: `SeparatedNodeList<NameNode>`
- `semicolon`: `Token`


TraitAliasNode
--------------

Trait adaptation m as `[modifier]` `[alias];`. Rozšiřuje `Node`. Implementuje `Stringable`.

- `trait`: `?NameNode`
- `doubleColon`: `?Token`
- `method`: `IdentifierNode`
- `asKeyword`: `Token`
- `modifier`: `?Token`
- `alias`: `?IdentifierNode`
- `semicolon`: `Token`


EnumCaseNode
------------

Enum case with an optional backing value. Rozšiřuje `MemberNode`. Implementuje `Stringable`.

- `attributes`: `NodeList<AttributeGroupNode>`
- `caseKeyword`: `Token`
- `name`: `IdentifierNode`
- `equals`: `?Token`
- `value`: `?ExpressionNode`
- `semicolon`: `Token`


Skaláry
=======

Čísla, řetězce a jejich interpolace, magické konstanty; text zůstává tak, jak byl zapsán.


IntegerNode
-----------

Integer literal in any base, kept as written. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `token`: `Token`


FloatNode
---------

Literal PHP reads as a float, kept as written. That is not the same as float syntax: an integer literal beyond the integer range is a float to PHP whatever its base (0xFFFFFFFFFFFFFFFF as much as 9223372036854775808), and the lexer hands it over as one, so such a literal is a node of this class. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `token`: `Token`


StringNode
----------

String literal without interpolation, quotes included; inside an interpolated string also a bare offset name `($a[key])`. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `token`: `Token`


MagicConstantNode
-----------------

Magic constant: __LINE__, __FILE__, __DIR__, __CLASS__, __TRAIT__, __METHOD__, __FUNCTION__, __PROPERTY__, __NAMESPACE__. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `token`: `Token`


InterpolatedStringNode
----------------------

Double-quoted string with interpolated variables or expressions. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `openQuote`: `Token`
- `parts`: `NodeList<Scalar\InterpolatedStringPartNode|Scalar\InterpolationNode|ExpressionNode>`
- `closeQuote`: `Token`


HeredocNode
-----------

Heredoc or nowdoc; the closing delimiter keeps its indentation, the parts keep theirs. Rozšiřuje `ExpressionNode`. Implementuje `Stringable`.

- `openDelimiter`: `Token`
- `parts`: `NodeList<Scalar\InterpolatedStringPartNode|Scalar\InterpolationNode|ExpressionNode>`
- `closeDelimiter`: `Token`


InterpolatedStringPartNode
--------------------------

Literal text between interpolations, whitespace included. What its escape sequences mean depends on the string it stands in, so the string is what resolves them, with PhpSyntax\Escaping. Rozšiřuje `Node`. Implementuje `Stringable`.

- `text`: `Token`


InterpolationNode
-----------------

Braced interpolation inside a string: {$expr} or ${name}. Rozšiřuje `Node`. Implementuje `Stringable`.

- `openBrace`: `Token`
- `expr`: `ExpressionNode`
- `closeBrace`: `Token`


Typy
====

Typové deklarace parametrů, vlastností a návratových hodnot.


NamedTypeNode
-------------

Type given by a name: builtin (int, static, array, callable) or a class. Rozšiřuje `TypeNode`. Implementuje `Stringable`.

- `name`: `NameNode`


NullableTypeNode
----------------

Nullable type: ?T. Rozšiřuje `TypeNode`. Implementuje `Stringable`.

- `question`: `Token`
- `type`: `TypeNode`


UnionTypeNode
-------------

Union type A|B; a member may be a parenthesized intersection (DNF). Rozšiřuje `TypeNode`. Implementuje `Stringable`.

- `types`: `SeparatedNodeList<TypeNode>`


IntersectionTypeNode
--------------------

Intersection type A&B, parenthesized inside a union. Rozšiřuje `TypeNode`. Implementuje `Stringable`.

- `openParen`: `?Token`
- `types`: `SeparatedNodeList<TypeNode>`
- `closeParen`: `?Token`