Uzly stromu

Referenční přehled všech tříd uzlů PhpSyntax: 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 a Úpravy.

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).

• token: Token

IdentifierNode

Identifier of a member, label, hook or alias: one token of any kind, including reserved words.

• token: Token

ArgumentListNode

Parenthesized arguments of a call, instantiation, attribute or exit.

• openParen: Token
• args: SeparatedNodeList<ArgumentNode|VariadicPlaceholderNode>
• closeParen: Token

ArgumentNode

Argument of a call: optionally named, by reference or unpacked.

• name: ?IdentifierNode
• colon: ?Token
• byRef: ?Token
• ellipsis: ?Token
• expr: ExpressionNode

VariadicPlaceholderNode

The … placeholder of a first-class callable: f(…).

• ellipsis: Token

ParameterNode

Parameter of a function, method, closure or hook; with modifiers it promotes a property.

• 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.

• openAttribute: Token
• attributes: SeparatedNodeList<AttributeNode>
• closeBracket: Token

AttributeNode

Attribute with optional arguments.

• name: NameNode
• args: ?ArgumentListNode

ModifiersNode

Modifier keywords in source order; may be empty.

• tokens: list<Token>

FileNode

Root of the tree.

• stmts: NodeList<StatementNode>
• eof: Token

AnonymousClassNode

Anonymous class in a new expression: new class(…) extends A implements B { … }. Implementuje 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.

• key: ?ExpressionNode
• doubleArrow: ?Token
• byRef: ?Token
• ellipsis: ?Token
• value: ExpressionNode

EmptyArrayItemNode

Skipped item of a destructuring list ([, $b] = $x); has no tokens.

MatchArmNode

Arm of a match expression: conditions or default, and the result.

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

ClosureUsesNode

The use (…) clause of a closure.

• useKeyword: Token
• openParen: Token
• vars: SeparatedNodeList<ClosureUseNode>
• closeParen: Token

ClosureUseNode

Variable captured by a closure, optionally by reference.

• byRef: ?Token
• var: Expression\VariableNode

ElseIfNode

elseif branch, in either syntax.

• 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.

• elseKeyword: Token
• body: ?StatementNode
• colon: ?Token
• stmts: ?NodeList<StatementNode>

CaseNode

case or default of a switch; the separator is a colon or a semicolon.

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

CatchNode

catch clause with one or more types and an optional variable.

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

FinallyNode

finally clause.

• finallyKeyword: Token
• body: Statement\BlockNode

DeclareItemNode

Directive of a declare statement: strict_types=1.

• name: IdentifierNode
• equals: Token
• value: ExpressionNode

StaticVarNode

Variable of a static statement with an optional initializer.

• var: Expression\VariableNode
• equals: ?Token
• default: ?ExpressionNode

UseItemNode

Imported name with an optional alias; the type (function, const) appears only inside a group use.

• type: ?Token
• name: NameNode
• asKeyword: ?Token
• alias: ?IdentifierNode

ConstItemNode

Constant of a const statement or a class constant declaration.

• 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.

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

UseNode

use import of classes, functions or constants.

• useKeyword: Token
• type: ?Token
• items: SeparatedNodeList<UseItemNode>
• semicolon: Token

GroupUseNode

Group use import: use A\{B, C};.

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

ConstNode

const statement outside a class.

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

HaltCompilerNode

__halt_compiler(); the rest of the file is the data token.

• haltKeyword: Token
• openParen: Token
• closeParen: Token
• semicolon: Token
• data: ?Token

InlineHtmlNode

Text outside PHP tags, including a BOM or a hashbang line.

• html: Token

EmptyStatementNode

Bare semicolon, or a close tag after a terminated statement.

• semicolon: Token

ExpressionStatementNode

Expression as a statement.

• expr: ExpressionNode
• semicolon: Token

BlockNode

Statements in braces.

• openBrace: Token
• stmts: NodeList<StatementNode>
• closeBrace: Token

IfNode

if statement in either syntax; the body is a statement, the alternative syntax fills stmts.

• 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.

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

DoWhileNode

do-while loop.

• doKeyword: Token
• body: StatementNode
• whileKeyword: Token
• openParen: Token
• cond: ExpressionNode
• closeParen: Token
• semicolon: Token

ForNode

for loop in either syntax.

• 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.

• 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.

• 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.

• breakKeyword: Token
• expr: ?ExpressionNode
• semicolon: Token

ContinueNode

continue with an optional level.

• continueKeyword: Token
• expr: ?ExpressionNode
• semicolon: Token

ReturnNode

return with an optional value.

• returnKeyword: Token
• expr: ?ExpressionNode
• semicolon: Token

GlobalNode

global statement.

• globalKeyword: Token
• vars: SeparatedNodeList<ExpressionNode>
• semicolon: Token

StaticNode

static variable declaration.

• staticKeyword: Token
• vars: SeparatedNodeList<StaticVarNode>
• semicolon: Token

EchoNode

echo statement; the keyword may be the <?= open tag and the semicolon a close tag.

• echoKeyword: Token
• exprs: SeparatedNodeList<ExpressionNode>
• semicolon: Token

UnsetNode

unset statement.

• 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.

• 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.

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

GotoNode

goto statement.

• gotoKeyword: Token
• label: IdentifierNode
• semicolon: Token

LabelNode

Label for goto.

• name: IdentifierNode
• colon: Token

FunctionNode

Function declaration.

• 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. Implementuje 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. Implementuje ClassLikeNode.

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

TraitNode

Trait declaration. Implementuje ClassLikeNode.

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

EnumNode

Enum declaration, optionally backed by a scalar type. Implementuje 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}.

• dollar: ?Token
• openBrace: ?Token
• name: Token|ExpressionNode
• closeBrace: ?Token

ArrayDimFetchNode

Array or string offset access: $a[$i], $a[].

• 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.

• object: ExpressionNode
• operator: Token
• openBrace: ?Token
• name: IdentifierNode|ExpressionNode
• closeBrace: ?Token

StaticPropertyFetchNode

Static property access: A::$b.

• class: NameNode|ExpressionNode
• doubleColon: Token
• name: Expression\VariableNode

ClassConstantFetchNode

Class constant access: A::B, A::class, A::{expr}.

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

ConstantFetchNode

Constant access by name: FOO, \Foo\BAR, true.

• name: NameNode

FunctionCallNode

Function call by name or on an expression.

• name: NameNode|ExpressionNode
• args: ArgumentListNode

MethodCallNode

Method call with → or ?->.

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

StaticCallNode

Static method call: A::b(), $a::b(), A::{expr}().

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

NewNode

Instantiation of a named, dynamic or anonymous class.

• newKeyword: Token
• class: NameNode|ExpressionNode|AnonymousClassNode
• args: ?ArgumentListNode

ArrayNode

Array literal in either syntax: [...] or array(…); on the left of an assignment it destructures.

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

ListNode

Destructuring with list(…).

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

AssignNode

Assignment, plain or compound (+=, ??=); the operator token tells which.

• var: ExpressionNode
• operator: Token
• expr: ExpressionNode

AssignRefNode

Assignment by reference: $a = &$b.

• var: ExpressionNode
• equals: Token
• ampersand: Token
• expr: ExpressionNode

BinaryNode

Binary operation; the operator token tells which (arithmetic, comparison, logical, bitwise, concatenation, coalesce, pipe).

• left: ExpressionNode
• operator: Token
• right: ExpressionNode

UnaryNode

Prefix operation: +, -, !, ~, @, ++, –.

• operator: Token
• expr: ExpressionNode

PostfixNode

Postfix increment or decrement.

• expr: ExpressionNode
• operator: Token

CastNode

Type cast; the cast token keeps its spelling including inner whitespace: ( int ).

• cast: Token
• expr: ExpressionNode

TernaryNode

Ternary conditional ($cond ? $if : $else) or the elvis form ($cond ?: $else).

• cond: ExpressionNode
• question: Token
• if: ?ExpressionNode
• colon: Token
• else: ExpressionNode

InstanceofNode

instanceof check against a name or a dynamic class.

• expr: ExpressionNode
• instanceofKeyword: Token
• class: NameNode|ExpressionNode

ParenthesizedNode

Expression in parentheses.

• openParen: Token
• expr: ExpressionNode
• closeParen: Token

IssetNode

isset(…) with one or more variables.

• issetKeyword: Token
• openParen: Token
• vars: SeparatedNodeList<ExpressionNode>
• closeParen: Token

EmptyNode

empty(…).

• emptyKeyword: Token
• openParen: Token
• expr: ExpressionNode
• closeParen: Token

EvalNode

eval(…).

• evalKeyword: Token
• openParen: Token
• expr: ExpressionNode
• closeParen: Token

IncludeNode

include, include_once, require or require_once; the keyword token tells which.

• includeKeyword: Token
• expr: ExpressionNode

ExitNode

exit or die with optional arguments.

• exitKeyword: Token
• args: ?ArgumentListNode

PrintNode

print expression.

• printKeyword: Token
• expr: ExpressionNode

YieldNode

yield, yield $value or yield $key ⇒ $value.

• yieldKeyword: Token
• key: ?ExpressionNode
• doubleArrow: ?Token
• value: ?ExpressionNode

YieldFromNode

yield from expression.

• yieldFromKeyword: Token
• expr: ExpressionNode

ThrowNode

throw expression.

• throwKeyword: Token
• expr: ExpressionNode

CloneNode

clone expression; clone(…) with arguments is a function call.

• cloneKeyword: Token
• expr: ExpressionNode

MatchNode

match expression.

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

ClosureNode

Anonymous function, optionally static, with captured variables.

• 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.

• 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.

• 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.

• 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.

• name: Token
• equals: ?Token
• default: ?ExpressionNode

PropertyHookNode

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

• 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.

• 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.

• 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.

• 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.

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

TraitAliasNode

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

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

EnumCaseNode

Enum case with an optional backing value.

• 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.

• token: Token

FloatNode

Floating-point literal, kept as written.

• token: Token

StringNode

String literal without interpolation, quotes included; inside an interpolated string also a bare offset name ($a[key]).

• token: Token

MagicConstantNode

Magic constant: __LINE__, __FILE__, __DIR__, __CLASS__, __TRAIT__, __METHOD__, __FUNCTION__, __PROPERTY__, __NAMESPACE__.

• token: Token

InterpolatedStringNode

Double-quoted string with interpolated variables or expressions.

• 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.

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

InterpolatedStringPartNode

Literal text between interpolations, whitespace included. Rozšiřuje Node.

• text: Token

InterpolationNode

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

• 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.

• name: NameNode

NullableTypeNode

Nullable type: ?T.

• question: Token
• type: TypeNode

UnionTypeNode

Union type A|B; a member may be a parenthesized intersection (DNF).

• types: SeparatedNodeList<TypeNode>

IntersectionTypeNode

Intersection type A&B, parenthesized inside a union.

• openParen: ?Token
• types: SeparatedNodeList<TypeNode>
• closeParen: ?Token