Přehled uzlů

Referenční přehled všech tříd uzlů: popis a sloty i s typem. Slot je pojmenovaný podle role, ne podle textu (ifKeyword, openParen, body), párové oddělovače jsou vždy open* a close*, seznamy jsou v množném čísle a ? 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čů a SeparatedNodeList<T> seznam s oddělovači (čárkami, středníky) mezi položkami. Jak strom číst a měnit, říkají stránky Uzly a sloty a Úpravy stromu.

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.

• token: Token

IdentifierNode

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

• token: Token

ArgumentListNode

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

• openParen: Token
• items: SeparatedNodeList<ArgumentNode|VariadicPlaceholderNode|ArgumentPlaceholderNode>
• closeParen: Token

ArgumentNode

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

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

VariadicPlaceholderNode

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

• ellipsis: Token

ArgumentPlaceholderNode

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

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

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

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

AttributeNode

Attribute with optional arguments. Rozšiřuje Node.

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

• tokens: list<Token>

NodeList

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

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

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

• stmts: NodeList<StatementNode>
• eof: Token

AnonymousClassNode

Anonymous class in a new expression: new class(…) extends A implements B { … }. Rozšiřuje Node. 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. Rozšiřuje Node.

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

MatchArmNode

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

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

ClosureUsesNode

The use (…) clause of a closure. Rozšiřuje Node.

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

ClosureUseNode

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

• byRef: ?Token
• var: Expression\VariableNode

ElseIfNode

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

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

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

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

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

FinallyNode

finally clause. Rozšiřuje Node.

• finallyKeyword: Token
• body: Statement\BlockNode

DeclareItemNode

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

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

StaticVarNode

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

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

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

ConstItemNode

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

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

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

UseNode

use import of classes, functions or constants, written item by item or as a group under a prefix (use A\{B, C};), which fills the slots the other form leaves empty. Rozšiřuje StatementNode.

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

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

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

• html: Token

EmptyStatementNode

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

• semicolon: Token

ExpressionStatementNode

Expression as a statement. Rozšiřuje StatementNode.

• expr: ExpressionNode
• semicolon: Token

BlockNode

Statements in braces. Rozšiřuje StatementNode.

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

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

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

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

ForNode

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

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

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

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

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

ContinueNode

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

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

ReturnNode

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

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

GlobalNode

global statement. Rozšiřuje StatementNode.

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

StaticNode

static variable declaration. Rozšiřuje StatementNode.

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

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

UnsetNode

unset statement. Rozšiřuje StatementNode.

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

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

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

GotoNode

goto statement. Rozšiřuje StatementNode.

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

LabelNode

Label for goto. Rozšiřuje StatementNode.

• name: IdentifierNode
• colon: Token

FunctionNode

Function declaration. Rozšiřuje StatementNode. Implementuje FunctionLikeNode.

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

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

ArrayDimFetchNode

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

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

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

StaticPropertyFetchNode

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

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

ClassConstantFetchNode

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

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

• name: NameNode

FunctionCallNode

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

• name: NameNode|ExpressionNode
• args: ArgumentListNode

MethodCallNode

Method call with → or ?->. Rozšiřuje ExpressionNode.

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

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

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

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

ListNode

Destructuring with list(…). Rozšiřuje ExpressionNode.

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

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

AssignRefNode

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

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

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

UnaryNode

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

• operator: Token
• expr: ExpressionNode

PostfixNode

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

• expr: ExpressionNode
• operator: Token

CastNode

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

• cast: Token
• expr: ExpressionNode

TernaryNode

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

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

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

ParenthesizedNode

Expression in parentheses. Rozšiřuje ExpressionNode.

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

IssetNode

isset(…) with one or more variables. Rozšiřuje ExpressionNode.

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

EmptyNode

empty(…). Rozšiřuje ExpressionNode.

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

EvalNode

eval(…). Rozšiřuje ExpressionNode.

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

• includeKeyword: Token
• expr: ExpressionNode

ExitNode

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

• exitKeyword: Token
• args: ?ArgumentListNode

PrintNode

print expression. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

• printKeyword: Token
• expr: ExpressionNode

YieldNode

yield, yield $value or yield $key ⇒ $value. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

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

YieldFromNode

yield from expression. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

• yieldFromKeyword: Token
• expr: ExpressionNode

ThrowNode

throw expression. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

• throwKeyword: Token
• expr: ExpressionNode

CloneNode

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

• cloneKeyword: Token
• expr: ExpressionNode

MatchNode

match expression. Rozšiřuje ExpressionNode.

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

• 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 FunctionLikeNode, OperatorNode.

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

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

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

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

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

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

• 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. Rozšiřuje MemberNode.

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

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

• token: Token

StringNode

String literal without interpolation, quotes included. Rozšiřuje ExpressionNode.

• token: Token

UnquotedStringNode

Name of an offset written without quotes inside an interpolated string ("$row[label]"), which PHP reads as a string; having no delimiter, it stands for itself and holds no escape sequence. Rozšiřuje ExpressionNode.

• token: Token

MagicConstantNode

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

• token: Token

InterpolatedStringNode

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

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

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

• token: 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. Rozšiřuje TypeNode.

• name: NameNode

NullableTypeNode

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

• question: Token
• type: TypeNode

UnionTypeNode

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

• types: SeparatedNodeList<TypeNode>

IntersectionTypeNode

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

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