Přehled uzlů – PhpSyntax

Referenční přehled všech tříd uzlů: popis, sloty i s typem a veřejné vlastnosti a metody. Slot je pojmenovaný podle role, ne podle textu (ifKeyword, openParen, body), párové oddělovače jsou vždy open* a close*, seznam uzlů má jméno v množném čísle (statements, members) a ? značí slot, který může být prázdný.

Třídy leží v PhpSyntax\Nodes a jeho podprostorech Statement, Expression, Member, Scalar a Type; jména v typech jsou psaná relativně k PhpSyntax\Nodes (Expression\VariableNode), třídy mimo něj relativně k PhpSyntax (Token). Slot typu Token drží jeden token, NodeList<T> seznam uzlů bez oddělovačů a SeparatedNodeList<T> seznam s oddělovači mezi položkami: čárkami, svislítky ve sjednocení typů a v catch a ampersandy v průniku typů. U každé třídy jsou nejdřív sloty a pak konstanty, vlastnosti a metody, které třída sama přidává; co umí každý uzel, je u Node, co každý výraz, u ExpressionNode. Popisy jsou převzaté z dokumentačních komentářů v kódu, proto jsou anglicky. Jak strom číst a měnit, říkají stránky Uzly a sloty a Úpravy stromu.

Bázové třídy a rozhraní

Předci a rozhraní, podle kterých se uzly hledají a filtrují ($file->find(ExpressionNode::class)). Node leží v PhpSyntax, TraitAdaptationNode v PhpSyntax\Nodes\Member a ostatní v PhpSyntax\Nodes.

Node

Node of the concrete syntax tree; every token of the source is reachable through the children.

$parent: ?Node – The node this one belongs to; only the tree writes it, through attachTo().
$text: string – The node as it is written, without the trivia on its outer edges, which printing it writes too.
$leadingTrivia: list<Trivia> – The trivia before the node, which are the leading trivia of its first token; setEdgeTrivia() writes them.
$trailingTrivia: list<Trivia> – The trivia after the node, which are the trailing trivia of its last token; setEdgeTrivia() writes them.
getChildren(): list<Node|Token> – Children in source order, without empty slots.
replaceChild(Node|Token $old, Node|Token $new): void – Replaces a direct child; the new one must fit the type of the slot.
findSlotOf(Node|Token $child): ?string – The slot the direct child stands in; null when it is not a child.
setSlot(string $slot, Node|Token|null $value): static – Writes a slot given by its name, the way an assignment to the property does: the value takes the place of the current one, which leaves the tree; the typed property refuses a value that does not fit the slot.
getFile(): ?FileNode
getTokens(): list<Token> – The tokens of the whole subtree in source order; empty for a node without tokens, such as an empty list.
getTokenTexts(): list<string> – The texts of the tokens of the subtree in source order, the trivia left out: what matches() compares two nodes by, and what a tool keys a map by where the layout of the code must not count. The size of the code is measured on $text, which keeps the layout.
getFirstToken(): ?Token – Null only for a node without tokens, such as an empty list.
getLastToken(): ?Token
getStartLine(): ?int – Current line of the first token; null for a detached subtree or a node without tokens.
getEndLine(): ?int – Current line where the last token ends; null as for getStartLine().
getDocComment(): ?Trivia – Doc comment before the node: the last one in the leading trivia of the first token, or in the trailing trivia of the previous token, where a doc comment stands between two declarations on one line.
replaceTrivia(Trivia $old, Trivia $new): void – Replaces one trivia of the node, wherever among its tokens it stands, with another in place.
removeTrivia(Trivia $trivia): void – Removes one trivia of the node, wherever among its tokens it stands, tidying the whitespace around it the way Token::removeTrivia() does.
replaceDocComment(Trivia $docComment): void – Replaces the doc comment of the node (see getDocComment()) with the trivia given.
removeDocComment(): void – Removes the doc comment of the node (see getDocComment()) together with the line it stands on.
findAncestor(class-string<T> $class): (T&Node)|null
findFirst(class-string<T> $class, ?callable $predicate = null): (T&Node)|null – The first descendant of the class the predicate accepts, in pre-order; null when there is none.
find(class-string<T> $class, ?callable $predicate = null): list<T&Node> – Descendant nodes of the class the predicate accepts, in pre-order, as a snapshot safe to iterate while mutating the tree.
matches(Node $other): bool – Whether the tokens of both nodes carry the same texts, whatever the whitespace between them.
hasComment(): bool – Whether a comment sits anywhere between the first and the last token of the node; the trivia on its outer edges do not count.
getComments(): list<Trivia> – The comments inside the node, in source order; those on its outer edges are not among them, the same way hasComment() does not count them.
setEdgeTrivia(?list<Trivia> $leading = null, ?list<Trivia> $trailing = null): static – Writes the trivia on the outer edges of the node: before its first token and after its last one. A null leaves that edge alone, [] clears it, and a node without tokens takes neither.
withoutEdgeTrivia(): static – A deep copy without a parent and without the trivia on its outer edges, which belong to the place it was copied from.
replaceWith(Node $node): void – Replaces this node in its parent; the trivia around the old node stay in place around the new one, and where the new one then stands right against a token it would be read together with, . against 1 or return against FOO, a space keeps the two apart.
remove(CommentPolicy $comments = CommentPolicy::MoveToNextToken): void – Removes this node from its list, together with the separator that goes with it. A node alone on its lines takes the lines with it (indentation and line ending), otherwise the whitespace around stays; its comments, those on its edges included, go where the policy says, each with its indentation and the line ending after it.
__toString(): string – The node printed back to source, the trivia on its outer edges included; $text leaves them out.

ClassLikeNode

Declaration with members: class, interface, trait, enum, anonymous class; an interface, because an anonymous class stands inside a new expression and the rest are statements.

$name: ?IdentifierNode
$members: NodeList<MemberNode>

ExpressionNode

Expression, which stands for a value; a destructuring stands where a target is written and is a ListNode, not one of these. Rozšiřuje Node.

getAccessKind(): ?AccessKind – How the parent reaches into this expression, null where it does not: $this->x and $this[0] read a member, $this() calls it, $this::y() takes it for the name of a class.
isDereferenced(): bool – Whether the parent reads a member, an element or a static member of this expression, or calls it: $this->x, $this[0], $this::y(), $this(). Such an expression needs parentheses unless the grammar makes it a primary one.
isDereferenceable(AccessKind $by = AccessKind::Member): bool – Whether what is written after the expression may reach into it with no parentheses around it. A call takes a name or a member written before it for its own, which calls another thing entirely, and :: takes the name of a class, which a name written there would become.
canNameClass(): bool – Whether the expression may stand where a class is named: a variable, a static property of a named class and what is read out of either all the way down, a property or an element, and an expression in parentheses; new f()->b instantiates f and new A::B[0] is no code.
isWritable(): bool – Whether the expression may stand where a place is assigned to: a variable, an element, a property, reached through a chain PHP writes through. A ?-> anywhere along it rules the write out, a call in the chain included, and so does a chain starting at a value of its own, a literal, a constant, new or clone, which has no place to write to. It says nothing about reading; that is isRepeatableRead(), and the two answer for the two sides of =.
isRepeatableRead(): bool – Whether reading the expression again gives the same value with no side effects: variables, property, constant and offset fetches, literals, arrays of such items and what parentheses or a unary operator make of them, nothing that runs code of its own; an unpacked item may run a generator and one by reference creates the variable, so neither is repeatable. The answer is syntactic, so what the language runs behind such a read is out of sight and does not count: a magic getter or a property hook behind a fetch, an ArrayAccess behind an offset, a __toString() behind a string that interpolates. Whoever cannot assume that much has to know the types, which a syntax tree does not.
toValue(): mixed – The value the expression is written as: a scalar, null, true, false, or an array of them. A name standing for a constant is not one, its value being a matter of what the code around it defines. Throws LogicException where the expression is written as no value; hasValue() tells beforehand.
hasValue(): bool – Whether the expression is written as a value, which is what toValue() gives.
replaceWithExpression(ExpressionNode $expression): void – Replaces this node by the expression the way replaceWith() does, in parentheses where the expression binds looser than the place asks or is reached into there: what ParenthesizedNode::isRedundant() does not call needless stays.

FunctionLikeNode

Declaration with parameters and a body: function, method, closure, arrow function, property hook; an interface, because a closure and an arrow function are expressions and the rest are not.

$parameters: ?SeparatedNodeList<ParameterNode> – Null for a property hook written without parentheses.
$returnType: ?TypeNode – The return type declared; null where none is, a property hook having none to declare.

MemberNode

Member of a class-like declaration: property, constant, method, trait use, enum case. Rozšiřuje Node.

OperatorNode

Expression written with an operator, which is what decides whether parentheses around it are needed. Those whose right operand reaches as far as the code lets it, an arrow function among them, are a RightExtendingNode.

const LeftAssociative = -1 – Which side the operator leans to, where an operand of the same precedence may stand.
const NonAssociative = 0
const RightAssociative = 1
getPrecedence(): array{int, OperatorNode::LeftAssociative|OperatorNode::NonAssociative|OperatorNode::RightAssociative} – How tightly the operator binds and which side it leans to; the higher the number the tighter, in the order the precedence declarations of the grammar put the operators.

RightExtendingNode

Operator written with no left operand, whose right one reaches as far as the code lets it: fn() => …, throw, print, yield, yield from and include. It can capture nothing before itself, so it stands bare however loosely it binds, unless an operator follows it, which its operand would take in; before one it needs parentheses. Rozšiřuje OperatorNode.

ScalarNode

Literal written in the source: a number, a string in any of its delimiters, an interpolated string, a boolean, null and a magic constant. What it stands for is hasValue() and toValue(), which an interpolating string and a magic constant answer no to, standing for what the code around them says. Rozšiřuje ExpressionNode.

StatementNode

Statement: what a file, a block and the body of a control structure consist of. Rozšiřuje Node.

TraitAdaptationNode

What a trait use says about a method it takes from a trait: an alias or a precedence. The trait slot is left to the two subclasses, an alias being able to leave it out where a precedence has to name it. Rozšiřuje Node.

$method: IdentifierNode
$semicolon: Token

TypeNode

Type written in a declaration: a name, a nullable, a union or an intersection. Rozšiřuje Node.

allowsNull(): bool – Whether the type accepts null: ?T, a union with null, and mixed.

Společné uzly

Kořen souboru, jména, seznamy, parametry, argumenty, atributy a části řídicích struktur; leží přímo v PhpSyntax\Nodes.

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
$text: string – The name as it is written, the leading backslash and the namespace prefix included. Writing it replaces the token with the one the name is written as, so that a qualified name does not stay an identifier; the trivia around it and its place in the original file stay with it.
$kind: NameKind
$parts: list<string> – Segments of the name without the leading backslash or the namespace prefix.
$shortName: string – The last segment, which is what an import of the name brings in.
$role: SymbolKind – Which table of names the name belongs to: functions when called, constants when fetched, what a use item imports, otherwise classes, a namespace among them. It follows the place in the tree, so moving the node changes it, and it says nothing about whether the name refers to a symbol or declares one, which is isReference(): whoever resolves names asks that first.
static fromText(string $text): NameNode – A name written as the text, in the token the name is written as (Foo, A\B, \A\B, namespace\B).
isKeyword(): bool – Whether the name is a keyword the grammar accepts in place of a name (static, array, readonly, exit…).
isFullyQualified(): bool
isUnqualified(): bool
isSpecialClass(): bool – Whether the name is self, static or parent, which stand for a class only where they are written.
isDeclaration(): bool – Whether the name declares or imports a symbol instead of referring to one: a namespace statement or a use.
isReference(): bool – Whether the name refers to a symbol of its table, one the resolver looks up: not the name a use or a namespace statement introduces, not self, static or parent where a class is named, which stand for one only where they are written, and not a builtin type where a type is written. A keyword read as a name refers where it stands for a symbol, as readonly(...) calls a function of that name, and so does self() or the constant parent.
equals(string $name): bool – Whether the name is written the same, letter case aside where PHP ignores it: a constant is compared exactly, its namespace too, although PHP ignores the case there; a class, a function and a namespace are not. The leading backslash is part of the writing and so part of the comparison; whether two names mean the same class is what NameResolver answers.

IdentifierNode

Identifier of a declaration, member, label, hook, alias or named argument: one token of any kind, including keywords. Rozšiřuje Node.

token: Token
$text: string – The identifier as it is written. Whether its letter case matters is up to what it names, so comparing it is left to the caller: a member and a label are case-sensitive, a magic method is not. Writing it takes an identifier and nothing else, so that no whitespace ends up in the text of a token.
static fromText(string $text): IdentifierNode – An identifier written as the text, which takes an identifier and nothing else.

ArgumentListNode

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

openParen: Token
items: SeparatedNodeList<ArgumentNode|VariadicPlaceholderNode|ArgumentPlaceholderNode>
closeParen: Token
static of(ExpressionNode ...$values): ArgumentListNode – A one-line list of positional arguments with the values, which lose the trivia on their edges.
isPartialApplication(): bool – Whether the list leaves parameters unbound with ? or ..., which makes a closure of the call instead of calling it.
findArgument(?string $name, ?int $position): ?ArgumentNode – The argument the parameter of the name and the position gets: the one written with the name, else the one standing at the position, so that get_class(object: $o) reads as the call get_class($o) is. Null where the parameter gets none, and where the call does not say which it gets: a ? placeholder holds a place without being an argument, and an unpacked array stands for as many arguments as it holds, so it takes the answer from a position after it, never from a name, which stands for itself. Whoever knows only one of the two asks with null for the other: the position alone finds no argument written with a name, the name alone none that is not.

ArgumentNode

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

name: ?IdentifierNode
colon: ?Token
ampersand: ?Token
ellipsis: ?Token
value: ExpressionNode

VariadicPlaceholderNode

The ... placeholder of a first-class callable or a partial application: f(...), f($a, ...). 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, arrow function or hook; with modifiers it promotes a property. Rozšiřuje Node.

attributes: NodeList<AttributeGroupNode>
modifiers: ModifiersNode
type: ?TypeNode
ampersand: ?Token
ellipsis: ?Token
variable: Expression\VariableNode
equals: ?Token
default: ?ExpressionNode
openBrace: ?Token
hooks: ?NodeList<Member\PropertyHookNode>
closeBrace: ?Token
isPromoted(): bool – Whether the parameter declares a property of the class, which its modifiers make it do.

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
arguments: ?ArgumentListNode

ModifiersNode

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

$visibility: ?Visibility – The visibility the modifiers declare, null when they declare none, which leaves a member public, a promoted parameter too.
$writeVisibility: ?Visibility – The visibility for writing, which asymmetric visibility declares apart: public(set) and its kin.
$tokens: list<Token>
isPublic(): bool – Whether the member is public, which it also is without a visibility of its own.
isProtected(): bool
isPrivate(): bool
isStatic(): bool
isAbstract(): bool
isFinal(): bool
isReadonly(): bool
findToken(int $kind): ?Token – The modifier token of the kind, null when the modifiers do not have it.
isEmpty(): bool
has(int $kind): bool
append(Token $token): void – Appends a modifier. The first one opens the declaration, so it takes over the leading trivia of the token it now stands before, the open tag and the doc comment among them; one without trailing trivia is kept apart from what follows by a space.
removeToken(Token $token): void – Removes a modifier. Its leading trivia go to the token after it, which may now open the declaration, and a comment after it stays: after the modifier before it, or on a line of its own above the token after it.
count(): int
getIterator(): ArrayIterator<int, Token> – The modifier tokens, as a snapshot safe to iterate while mutating them.

NodeList

Sequence of nodes without separators: statements, members, attribute groups. Rozšiřuje Node. Implementuje Countable, IteratorAggregate. Typ položek T je podtyp Node.

$items: list<T> – The items; only the list writes them, through its own methods.
getItems(): list<T>
isEmpty(): bool
append(T $item): void – Appends an item, which takes the place in the lines of the list its neighbor has.
insert(int $index, T $item): void – Inserts an item at the index. In a list standing in a file, an item that carries no trivia of its own takes the indentation of its neighbor and ends its line the same way.
removeItem(Node $item): void – Takes the item out with its trivia and tidies nothing; Node::remove() takes the lines with it.
indexOf(Node $item): int
count(): int
getIterator(): ArrayIterator<int, T> – The items, as a snapshot safe to iterate while mutating the list.

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 Countable, IteratorAggregate. Typ položek T je podtyp Node.

$items: list<T> – The items; only the list writes them, through its own methods.
$separators: list<Token> – One before each item but the first, plus an optional trailing one.
getItems(): list<T>
getSeparators(): list<Token>
isEmpty(): bool
hasTrailingSeparator(): bool
append(T $item, ?Token $separator = null): void – Appends an item; the separator before it is derived from the existing ones unless given.
insert(int $index, T $item, ?Token $separator = null): void – Inserts an item at the index. A missing separator is modeled on the existing ones, or on , ` in a one-line list, and then the item also takes the indentation and the line ending of its neighbor in a multi-line list; a separator given is inserted as it is. The separator is the one that goes with the item (see `findSeparatorOf()): the one after it, and for the last item the one before it, so what the separators already there carry stays with the items they follow.
setTrailingSeparator(?Token $separator): static
removeItem(Node $item): void – Takes the item out with its trivia, together with the separator that goes with it (see findSeparatorOf()), and tidies nothing; Node::remove() takes the lines with it.
findSeparatorOf(Node $item): ?Token – The separator that goes when the item goes: the one after it, and for the last item the one before it.
indexOf(Node $item): int
count(): int
getIterator(): ArrayIterator<int, T> – The items without the separators between them, as a snapshot safe to iterate while mutating the list.

FileNode

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

statements: NodeList<StatementNode>
endOfFile: Token
$revision: int – Version of the tree: every write to a slot, a list, or the text or trivia of a token increments it.
getIndex(): TokenIndex

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
arguments: ?ArgumentListNode
extendsKeyword: ?Token
extends: ?NameNode
implementsKeyword: ?Token
implements: ?SeparatedNodeList<NameNode>
openBrace: Token
members: NodeList<MemberNode>
closeBrace: Token
$name: ?IdentifierNode

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
ampersand: ?Token
ellipsis: ?Token
value: ExpressionNode|Expression\ListNode

EmptyArrayItemNode

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

MatchArmNode

Arm of a match expression: the values compared with the subject, or default, and the result. Rozšiřuje Node.

values: ?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
variables: SeparatedNodeList<ClosureUseNode>
closeParen: Token

ClosureUseNode

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

ampersand: ?Token
variable: Expression\VariableNode

ElseIfNode

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

elseifKeyword: Token
openParen: Token
condition: ExpressionNode
closeParen: Token
body: ?StatementNode
colon: ?Token
statements: ?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
statements: ?NodeList<StatementNode>

CaseNode

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

caseKeyword: Token
value: ?ExpressionNode
separator: Token
statements: 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>
variable: ?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

StaticVariableNode

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

variable: Expression\VariableNode
equals: ?Token
default: ?ExpressionNode

UseItemNode

Imported name with an optional alias; the type (function, const) appears only inside a group use. What the item imports is said by the statement it stands in, the prefix of a group included, so an item is not moved from one statement to another but written anew by UseNode::addImport(). Rozšiřuje Node.

type: ?Token
name: NameNode
asKeyword: ?Token
alias: ?IdentifierNode
$kind: SymbolKind – What the item imports: its own type where a group use writes one per item, else what the statement imports.
$fullName: string – The name the item imports, without a leading backslash: what is written here, and in a group use the prefix of the statement before it.
getStatement(): ?Statement\UseNode – The import the item belongs to; null for an item that is not in one.

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 v PhpSyntax\Nodes\Statement: položky seznamu statements souboru, bloku, jmenného prostoru, větve case a alternativní syntaxe, a také tělo řídicí struktury (body).

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
statements: 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
$kind: SymbolKind – What the statement imports, which every item without a type of its own imports too.
isGroup(): bool – Whether the items are written as a group under a prefix, which every one of them imports.
addImport(string $name, ?string $alias = null, ?int $index = null): UseItemNode – Adds an import of the fully qualified name, written the way the statement writes its items: whole in a plain import, under the prefix in a group, which refuses a name standing outside it. The item imports what the statement imports and goes last unless an index says where.

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
isPreamble(): bool – Whether the text is only what may precede the code of a pure PHP file: a byte order mark, a hashbang line, or both.

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.

expression: ExpressionNode
semicolon: Token

BlockNode

Statements in braces. Rozšiřuje StatementNode.

openBrace: Token
statements: NodeList<StatementNode>
closeBrace: Token

IfNode

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

ifKeyword: Token
openParen: Token
condition: ExpressionNode
closeParen: Token
body: ?StatementNode
colon: ?Token
statements: ?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
condition: ExpressionNode
closeParen: Token
body: ?StatementNode
colon: ?Token
statements: ?NodeList<StatementNode>
endKeyword: ?Token
semicolon: ?Token

DoWhileNode

do-while loop. Rozšiřuje StatementNode.

doKeyword: Token
body: StatementNode
whileKeyword: Token
openParen: Token
condition: ExpressionNode
closeParen: Token
semicolon: Token

ForNode

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

forKeyword: Token
openParen: Token
initializers: SeparatedNodeList<ExpressionNode>
firstSemicolon: Token
conditions: SeparatedNodeList<ExpressionNode>
secondSemicolon: Token
updates: SeparatedNodeList<ExpressionNode>
closeParen: Token
body: ?StatementNode
colon: ?Token
statements: ?NodeList<StatementNode>
endKeyword: ?Token
semicolon: ?Token

ForeachNode

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

foreachKeyword: Token
openParen: Token
expression: ExpressionNode
asKeyword: Token
key: ?ExpressionNode
doubleArrow: ?Token
ampersand: ?Token
value: ExpressionNode|Expression\ListNode
closeParen: Token
body: ?StatementNode
colon: ?Token
statements: ?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
subject: 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
expression: ?ExpressionNode
semicolon: Token

ContinueNode

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

continueKeyword: Token
expression: ?ExpressionNode
semicolon: Token

ReturnNode

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

returnKeyword: Token
expression: ?ExpressionNode
semicolon: Token

GlobalNode

global statement. Rozšiřuje StatementNode.

globalKeyword: Token
variables: SeparatedNodeList<ExpressionNode>
semicolon: Token

StaticNode

static variable declaration. Rozšiřuje StatementNode.

staticKeyword: Token
variables: SeparatedNodeList<StaticVariableNode>
semicolon: Token

EchoNode

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

echoKeyword: Token
expressions: SeparatedNodeList<ExpressionNode>
semicolon: Token

UnsetNode

unset statement. Rozšiřuje StatementNode.

unsetKeyword: Token
openParen: Token
variables: 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
statements: ?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
ampersand: ?Token
name: IdentifierNode
openParen: Token
parameters: 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ýrazy v PhpSyntax\Nodes\Expression: operátory, volání, přístupy, přiřazení, closure a arrow funkce. Literály mají vlastní sekci Skaláry; destrukturace ListNode leží tady, ale výrazem není, protože stojí jen tam, kam se přiřazuje, a hodnotu nemá.

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
$plainName: ?string – The name without the dollar sign; null where the name is an expression ($$a, ${expr}).
isThis(): bool – Whether the variable is $this, the object a method runs on.

ArrayAccessNode

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

expression: ExpressionNode
openBracket: Token
index: ?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
$plainName: ?string – The name of the property; null where the name is a variable or an expression ($a->$b, $a->{expr}).
isNullsafe(): bool – Whether the fetch is written with ?->, which skips it when the object is null.
isOfThis(): bool – Whether the property is one of $this, with either operator.

StaticPropertyFetchNode

Static property access: A::$b, A::$$b, A::${expr}. The name is written the way a variable is, dollar and braces included, but it names a property. Rozšiřuje ExpressionNode.

class: NameNode|ExpressionNode
doubleColon: Token
dollar: ?Token
openBrace: ?Token
name: Token|ExpressionNode
closeBrace: ?Token
$plainName: ?string – The name of the property without the dollar sign; null where the name is an expression ($$b, ${expr}).

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

name: NameNode

FunctionCallNode

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

name: NameNode|ExpressionNode
arguments: ArgumentListNode
static of(NameNode|ExpressionNode $name, ?ArgumentListNode $arguments = null): Expression\FunctionCallNode – A call of the name, or of the expression, in parentheses where the call would take it for something else.

MethodCallNode

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

object: ExpressionNode
operator: Token
openBrace: ?Token
name: IdentifierNode|ExpressionNode
closeBrace: ?Token
arguments: ArgumentListNode
static of(ExpressionNode $object, string $name, ?ArgumentListNode $arguments = null, bool $nullsafe = false): Expression\MethodCallNode – A call of the method on the object, in parentheses where it could not be reached into bare.
isNullsafe(): bool – Whether the call is written with ?->, which skips it when the object is null.

StaticMethodCallNode

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
arguments: ArgumentListNode
static of(NameNode|ExpressionNode $class, string $name, ?ArgumentListNode $arguments = null): Expression\StaticMethodCallNode – A call of the static method of the class, an expression in parentheses where :: could not follow it bare.

NewNode

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

newKeyword: Token
class: NameNode|ExpressionNode|AnonymousClassNode
arguments: ?ArgumentListNode
static of(NameNode|ExpressionNode $class, ?ArgumentListNode $arguments = null): Expression\NewNode – An instantiation of the class, an expression in parentheses where it could not name one bare; no list is written where none is given.

ArrayNode

Array literal in either syntax: [...] or array(...). A short array standing where a place is assigned to destructures instead, and is a ListNode. Rozšiřuje ExpressionNode.

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

ListNode

Destructuring, written list(...) or [...]; the keyword is null for the short form. A short array is a literal until it stands where a place is assigned to, which is where it becomes one of these. It is no expression: it never carries a value. Rozšiřuje Node.

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

AssignmentNode

Assignment $a = $b, whose operator is always =. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

target: ExpressionNode|Expression\ListNode
operator: Token
expression: ExpressionNode

CombinedAssignmentNode

Combined assignment $a += $b, whose operator token tells which operation is baked into it. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

target: ExpressionNode
operator: Token
expression: ExpressionNode
static of(ExpressionNode $target, string $operator, ExpressionNode $expression): Expression\CombinedAssignmentNode – The combined assignment of the expression to the target, the expression in parentheses where it binds looser than the assignment takes. Throws InvalidArgumentException for what is no combined assignment operator, and for a target nothing can be assigned to.

AssignmentByReferenceNode

Assignment by reference $a = &$b; the grammar takes a variable or a new expression on the right. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

target: ExpressionNode
equals: Token
ampersand: Token
expression: ExpressionNode

BinaryOpNode

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
static of(ExpressionNode $left, string $operator, ExpressionNode $right): Expression\BinaryOpNode – The operation on the two operands, each in parentheses where it binds looser than its side of the operator takes. Throws InvalidArgumentException for what is no binary operator.

UnaryOpNode

Unary operation written before its operand: +, -, !, ~, @; ++ and -- are a PrefixOpNode, the way the grammar tells them apart. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

operator: Token
expression: ExpressionNode

PrefixOpNode

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

operator: Token
target: ExpressionNode

PostfixOpNode

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

target: ExpressionNode
operator: Token

CastNode

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

cast: Token
expression: ExpressionNode
$type: string – The type the cast converts to, in the name PHP knows it by: (integer) is int, (double) and (real) are float.

TernaryNode

Ternary conditional $a ? $b : $c, or the elvis form $a ?: $c leaving then empty. Rozšiřuje ExpressionNode. Implementuje OperatorNode.

condition: ExpressionNode
question: Token
then: ?ExpressionNode
colon: Token
else: ExpressionNode

InstanceofNode

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

expression: ExpressionNode
instanceofKeyword: Token
class: NameNode|ExpressionNode

ParenthesizedNode

Expression in parentheses. Rozšiřuje ExpressionNode.

openParen: Token
expression: ExpressionNode
closeParen: Token
static of(ExpressionNode $expression): Expression\ParenthesizedNode – The expression in parentheses, without the trivia on its edges.
isRedundant(): bool – Whether the parentheses may go without the code coming to mean anything else: what stands in them binds at least as tightly as the place they stand in asks, and what reaches into them could reach into it bare. Where the answer is not certain it is no.

IssetNode

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

issetKeyword: Token
openParen: Token
variables: SeparatedNodeList<ExpressionNode>
closeParen: Token

EmptyNode

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

emptyKeyword: Token
openParen: Token
expression: ExpressionNode
closeParen: Token

EvalNode

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

evalKeyword: Token
openParen: Token
expression: ExpressionNode
closeParen: Token

IncludeNode

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

includeKeyword: Token
expression: ExpressionNode

ExitNode

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

exitKeyword: Token
arguments: ?ArgumentListNode

PrintNode

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

printKeyword: Token
expression: ExpressionNode

YieldNode

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

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

YieldFromNode

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

yieldFromKeyword: Token
expression: ExpressionNode

ThrowNode

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

throwKeyword: Token
expression: ExpressionNode

CloneNode

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

cloneKeyword: Token
expression: ExpressionNode

MatchNode

match expression. Rozšiřuje ExpressionNode.

matchKeyword: Token
openParen: Token
subject: 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
ampersand: ?Token
openParen: Token
parameters: 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, RightExtendingNode, OperatorNode.

attributes: NodeList<AttributeGroupNode>
staticKeyword: ?Token
fnKeyword: Token
ampersand: ?Token
openParen: Token
parameters: SeparatedNodeList<ParameterNode>
closeParen: Token
colon: ?Token
returnType: ?TypeNode
doubleArrow: Token
expression: 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ů v PhpSyntax\Nodes\Member.

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
$plainName: string – The name of the property without the dollar sign.

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
ampersand: ?Token
name: IdentifierNode
openParen: ?Token
parameters: ?SeparatedNodeList<ParameterNode>
closeParen: ?Token
body: ?Statement\BlockNode
doubleArrow: ?Token
expression: ?ExpressionNode
semicolon: ?Token
$returnType: ?TypeNode

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
ampersand: ?Token
name: IdentifierNode
openParen: Token
parameters: SeparatedNodeList<ParameterNode>
closeParen: Token
colon: ?Token
returnType: ?TypeNode
body: ?Statement\BlockNode
semicolon: ?Token
isConstructor(): bool – Whether the method is the constructor, whose name PHP compares without regard to letter case.

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\TraitAdaptationNode>
closeBrace: ?Token

TraitPrecedenceNode

Trait adaptation A::m insteadof B. Rozšiřuje Member\TraitAdaptationNode.

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

TraitAliasNode

Trait adaptation m as [modifier] [alias]. Rozšiřuje Member\TraitAdaptationNode.

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, true, false, null a magické konstanty v PhpSyntax\Nodes\Scalar; text zůstává tak, jak byl zapsán.

IntegerNode

Integer literal in any base, kept as written. Rozšiřuje ScalarNode.

token: Token
$base: int – The base the literal is written in: 2, 8, 10 or 16; a leading zero alone is the old octal notation.
$value: int – The value of the literal; a literal beyond the integer range is a float to PHP, so it is a FloatNode.

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

token: Token
$value: float – The value of the literal, which is also how an integer literal beyond the integer range reaches PHP.

BooleanNode

Boolean literal, kept in the letter case and with the leading backslash it is written with: true, FALSE, \True. Rozšiřuje ScalarNode.

token: Token
$value: bool

NullNode

Null literal, kept in the letter case and with the leading backslash it is written with: null, NULL, \Null. Rozšiřuje ScalarNode.

token: Token

StringNode

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

token: Token
$quote: string – The delimiter the literal is written with: ' or ", a b or B prefix left out.
$value: string – The value of the literal with its escape sequences resolved.
static fromValue(string $value, string $quote = "'"): Scalar\StringNode – A literal standing for the value, escaped as the delimiter needs it.
setValue(string $value, ?string $quote = null): static – Writes the literal: the value escaped as the delimiter needs it, in the delimiter given or in the one it has. The two go together, because the delimiter decides how the value is written.

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

token: Token
$value: string – The value of the offset, which is the text as it stands.

MagicConstantNode

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

token: Token

InterpolatedStringNode

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

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

openDelimiter: Token
parts: NodeList<Scalar\InterpolatedStringPartNode|Scalar\InterpolationNode|ExpressionNode>
closeDelimiter: Token
$label: string – The label between <<< and the body, without quotes.
$indentation: string – The indentation of the closing delimiter, which the body shares.
$value: string – The text of the body with its escape sequences resolved and the common indentation removed. Throws LogicException when the heredoc interpolates; hasInterpolation() tells beforehand.
isNowdoc(): bool – Whether the label is in single quotes, which makes a nowdoc that resolves no escape sequences.
hasInterpolation(): bool – Whether any part of the body is an interpolation, which leaves the heredoc without a value of its own.

InterpolatedStringPartNode

Literal text between interpolations, whitespace included. What its escape sequences mean depends on the string it stands in, so the part keeps them as written and whoever reads it resolves them for that string, as HeredocNode::$value does for a heredoc. Rozšiřuje Node.

token: Token

InterpolationNode

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

openBrace: Token
expression: ExpressionNode
closeBrace: Token

Typy

Typové deklarace parametrů, vlastností, konstant třídy a návratových hodnot a typ hodnot výčtu (enum Suit: string) v PhpSyntax\Nodes\Type.

NamedTypeNode

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

name: NameNode
isBuiltin(): bool – Whether the type is one PHP knows itself, self, static and parent among them.

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