Uzly stromu

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