Node Overview for PHP-Parser 5.6 (2025)

Here you can find overview of commonly used nodes and how to build PHP code from them. For all nodes, check php-parser code.

`PhpParser\Node\ArrayItem`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ArrayItem;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\String_;

$value = new Variable('Tom');
$key = new String_('name');

return new ArrayItem($value, $key);

↓

'name' => $Tom

Public Properties

$key - /** @var null|Expr Key */
$value - /** @var Expr Value */
$byRef - /** @var bool Whether to assign by reference */
$unpack - /** @var bool Whether to unpack the argument */

`PhpParser\Node\ClosureUse`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ClosureUse;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');

return new ClosureUse($variable);

↓

$variableName

Public Properties

$var - /** @var Expr\Variable Variable to use */
$byRef - /** @var bool Whether to use by reference */

`PhpParser\Node\Const_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Const_;
use PhpParser\Node\Scalar\String_;

return new Const_('CONSTANT_NAME', new String_('default'));

↓

CONSTANT_NAME = 'default'

Public Properties

$name - /** @var Identifier Name */
$value - /** @var Expr Value */
$namespacedName - /** @var Name|null Namespaced name (if using NameResolver) */

`PhpParser\Node\Expr\ArrayDimFetch`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ArrayDimFetch;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\Int_;

$variable = new Variable('variableName');
$dimension = new Int_(0);

return new ArrayDimFetch($variable, $dimension);

↓

$variableName[0]

Public Properties

$var - /** @var Expr Variable */
$dim - /** @var null|Expr Array index / dim */

`PhpParser\Node\Expr\Array_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Array_;
use PhpParser\Node\Expr\ArrayItem;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\String_;

$value = new Variable('Tom');
$key = new String_('name');

$arrayItem = new ArrayItem($value, $key);

return new Array_([$arrayItem]);

↓

['name' => $Tom]

Public Properties

$items - /** @var ArrayItem[] Items */

`PhpParser\Node\Expr\ArrowFunction`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ArrowFunction;
use PhpParser\Node\Scalar\Int_;

$subNodes['expr'] = new Int_(1);

return new ArrowFunction($subNodes);

↓

fn() => 1

Public Properties

$static - /** @var bool Whether the closure is static */
$byRef - /** @var bool Whether to return by reference */
$params - /** @var Node\Param[] */
$returnType - /** @var null|Node\Identifier|Node\Name|Node\ComplexType */
$expr - /** @var Expr Expression body */
$attrGroups - /** @var Node\AttributeGroup[] */

`PhpParser\Node\Expr\Assign`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\String_;

$variable = new Variable('variableName');
$value = new String_('some value');

return new Assign($variable, $value);

↓

$variableName = 'some value'

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\String_;

$propertyFetch = new PropertyFetch(new Variable('someObject'), 'someProperty');
$value = new String_('some value');

return new Assign($propertyFetch, $value);

↓

$someObject->someProperty = 'some value'

Public Properties

$var - /** @var Expr Variable */
$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\AssignOp\Coalesce`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\AssignOp\Coalesce;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new Coalesce($left, $right);

↓

5 ??= 10

Public Properties

$var - /** @var Expr Variable */
$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\AssignOp\Concat`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\AssignOp\Concat;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new Concat($left, $right);

↓

5 .= 10

Public Properties

$var - /** @var Expr Variable */
$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\BinaryOp\BooleanAnd`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new BooleanAnd($left, $right);

↓

5 && 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BinaryOp\Coalesce`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\Coalesce;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new Coalesce($left, $right);

↓

5 ?? 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BinaryOp\Concat`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\Concat;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new Concat($left, $right);

↓

5 . 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BinaryOp\Equal`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\Equal;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new Equal($left, $right);

↓

5 == 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BinaryOp\Identical`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\Identical;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new Identical($left, $right);

↓

5 === 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BinaryOp\Minus`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\Minus;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new Minus($left, $right);

↓

5 - 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BinaryOp\NotEqual`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\NotEqual;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new NotEqual($left, $right);

↓

5 != 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BinaryOp\NotIdentical`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\NotIdentical;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new NotIdentical($left, $right);

↓

5 !== 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BinaryOp\Spaceship`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BinaryOp\Spaceship;
use PhpParser\Node\Scalar\Int_;

$left = new Int_(5);
$right = new Int_(10);

return new Spaceship($left, $right);

↓

5 <=> 10

Public Properties

$left - /** @var Expr The left hand side expression */
$right - /** @var Expr The right hand side expression */

`PhpParser\Node\Expr\BooleanNot`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\BooleanNot;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('isEligible');

return new BooleanNot($variable);

↓

!$isEligible

Public Properties

$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\Cast\Array_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Cast\Array_;
use PhpParser\Node\Expr\Variable;

$expr = new Variable('variableName');

return new Array_($expr);

↓

(array) $variableName

Public Properties

$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\Cast\Bool_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Cast\Bool_;
use PhpParser\Node\Expr\Variable;

$expr = new Variable('variableName');

return new Bool_($expr);

↓

(bool) $variableName

Public Properties

$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\Cast\Int_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Cast\Int_;
use PhpParser\Node\Expr\Variable;

$expr = new Variable('variableName');

return new Int_($expr);

↓

(int) $variableName

Public Properties

$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\Cast\String_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Cast\String_;
use PhpParser\Node\Expr\Variable;

$expr = new Variable('variableName');

return new String_($expr);

↓

(string) $variableName

Public Properties

$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\ClassConstFetch`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Name\FullyQualified;

$class = new FullyQualified('SomeClassName');

return new ClassConstFetch($class, 'SOME_CONSTANT');

↓

\SomeClassName::SOME_CONSTANT

Public Properties

$class - /** @var Name|Expr Class name */
$name - /** @var Identifier|Expr|Error Constant name */

`PhpParser\Node\Expr\ConstFetch`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Name;

$name = new Name('true');

return new ConstFetch($name);

↓

true

Public Properties

$name - /** @var Name Constant name */

`PhpParser\Node\Expr\Empty_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Empty_;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');

return new Empty_($variable);

↓

empty($variableName)

Public Properties

$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\Eval_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Eval_;
use PhpParser\Node\Scalar\String_;

$string = new String_('Some php code');

return new Eval_(new String_('Some php code'));

↓

eval('Some php code')

Public Properties

$expr - /** @var Expr Expression */

`PhpParser\Node\Expr\FuncCall`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Arg;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Name;

$args = [new Arg(new Variable('someVariable'))];

return new FuncCall(new Name('func_call'), $args);

↓

func_call($someVariable)

Public Properties

$name - /** @var Node\Name|Expr Function name */
$args - /** @var array<Node\Arg|Node\VariadicPlaceholder> Arguments */

`PhpParser\Node\Expr\Include_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Include_;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');

return new Include_($variable, Include_::TYPE_INCLUDE);

↓

include $variableName

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Include_;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');

return new Include_($variable, Include_::TYPE_REQUIRE_ONCE);

↓

require_once $variableName

Public Properties

$expr - /** @var Expr Expression */
$type - /** @var int Type of include */

`PhpParser\Node\Expr\Instanceof_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Instanceof_;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Name\FullyQualified;

$variable = new Variable('variableName');
$class = new FullyQualified('SomeClassName');

return new Instanceof_($variable, $class);

↓

$variableName instanceof \SomeClassName

Public Properties

$expr - /** @var Expr Expression */
$class - /** @var Name|Expr Class name */

`PhpParser\Node\Expr\Isset_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Isset_;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');

return new Isset_([$variable]);

↓

isset($variableName)

Public Properties

$vars - /** @var Expr[] Variables */

`PhpParser\Node\Expr\List_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ArrayItem;
use PhpParser\Node\Expr\List_;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');
$anotherVariable = new Variable('anotherVariableName');

$arrayItems = [new ArrayItem($variable), new ArrayItem($anotherVariable)];

return new List_($arrayItems);

↓

[$variableName, $anotherVariableName]

Public Properties

$items - /** @var (ArrayItem|null)[] List of items to assign to */

`PhpParser\Node\Expr\Match_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Match_;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\MatchArm;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Scalar\String_;

$variable = new Variable('variableName');

$body = new String_('yes');
$cond = new Int_(1);
$matchArm = new MatchArm([$cond], $body);

return new Match_($variable, [$matchArm]);

↓

match ($variableName) {
    1 => 'yes',
}

Public Properties

$cond - /** @var Node\Expr Condition */
$arms - /** @var MatchArm[] */

`PhpParser\Node\Expr\MethodCall`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('someObject');

return new MethodCall($variable, 'methodName');

↓

$someObject->methodName()

<?php

declare(strict_types=1);

use PhpParser\Node\Arg;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\String_;

$variable = new Variable('someObject');

$args = [];
$args[] = new Arg(new String_('yes'));

$methodCall = new MethodCall($variable, 'methodName', $args);

$nestedMethodCall = new MethodCall($methodCall, 'nextMethodName');

return $nestedMethodCall;

↓

$someObject->methodName('yes')->nextMethodName()

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Expr\Variable;

$thisVariable = new Variable('this');
$propertyFetch = new PropertyFetch($thisVariable, 'someProperty');

return new MethodCall($propertyFetch, 'methodName');

↓

$this->someProperty->methodName()

<?php

declare(strict_types=1);

use PhpParser\Node\Arg;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\String_;

$variable = new Variable('someObject');

$args = [];
$args[] = new Arg(new String_('yes'));
$args[] = new Arg(new String_('maybe'));

return new MethodCall($variable, 'methodName', $args);

↓

$someObject->methodName('yes', 'maybe')

Public Properties

$var - /** @var Expr Variable holding object */
$name - /** @var Identifier|Expr Method name */
$args - /** @var array<Arg|VariadicPlaceholder> Arguments */

`PhpParser\Node\Expr\New_`

Example PHP Code

<?php

declare(strict_types=1);

// anonymous class

use PhpParser\Node\Expr\New_;
use PhpParser\Node\Stmt\Class_;

$class = new Class_(null);

return new New_($class);

↓

new class
{
}

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\New_;
use PhpParser\Node\Name;

$class = new Name('SomeClass');

return new New_($class);

↓

new SomeClass()

Public Properties

$class - /** @var Node\Name|Expr|Node\Stmt\Class_ Class name */
$args - /** @var array<Arg|VariadicPlaceholder> Arguments */

`PhpParser\Node\Expr\NullsafeMethodCall`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\NullsafeMethodCall;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');

return new NullsafeMethodCall($variable, 'methodName');

↓

$variableName?->methodName()

Public Properties

$var - /** @var Expr Variable holding object */
$name - /** @var Identifier|Expr Method name */
$args - /** @var array<Arg|VariadicPlaceholder> Arguments */

`PhpParser\Node\Expr\NullsafePropertyFetch`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\NullsafePropertyFetch;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');

return new NullsafePropertyFetch($variable, 'someProperty');

↓

$variableName?->someProperty

Public Properties

$var - /** @var Expr Variable holding object */
$name - /** @var Identifier|Expr Property name */

`PhpParser\Node\Expr\PropertyFetch`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Expr\Variable;

$variable = new Variable('variableName');

return new PropertyFetch($variable, 'propertyName');

↓

$variableName->propertyName

Public Properties

$var - /** @var Expr Variable holding object */
$name - /** @var Identifier|Expr Property name */

`PhpParser\Node\Expr\StaticCall`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;

$fullyQualified = new FullyQualified('ClassName');

return new StaticCall($fullyQualified, 'methodName');

↓

\ClassName::methodName()

Public Properties

$class - /** @var Node\Name|Expr Class name */
$name - /** @var Identifier|Expr Method name */
$args - /** @var array<Arg|VariadicPlaceholder> Arguments */

`PhpParser\Node\Expr\StaticPropertyFetch`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\StaticPropertyFetch;
use PhpParser\Node\Name\FullyQualified;

$class = new FullyQualified('StaticClassName');

return new StaticPropertyFetch($class, 'someProperty');

↓

\StaticClassName::$someProperty

Public Properties

$class - /** @var Name|Expr Class name */
$name - /** @var VarLikeIdentifier|Expr Property name */

`PhpParser\Node\Expr\Ternary`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Expr\Ternary;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Name;

$variable = new Variable('variableName');

$trueConstFetch = new ConstFetch(new Name('true'));
$falseConstFetch = new ConstFetch(new Name('false'));

return new Ternary($variable, $trueConstFetch, $falseConstFetch);

↓

$variableName ? true : false

Public Properties

$cond - /** @var Expr Condition */
$if - /** @var null|Expr Expression for true */
$else - /** @var Expr Expression for false */

`PhpParser\Node\Expr\Throw_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Throw_;
use PhpParser\Node\Scalar\String_;

$string = new String_('some string');

return new Throw_($string);

↓

throw 'some string'

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Throw_;
use PhpParser\Node\Scalar\String_;

$string = new String_('some string');

return new Throw_($string);

↓

throw 'some string'

Public Properties

$expr - /** @var Node\Expr Expression */

`PhpParser\Node\Expr\Variable`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;

return new Variable('variableName');

↓

$variableName

Public Properties

$name - /** @var string|Expr Name */

`PhpParser\Node\MatchArm`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\MatchArm;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Scalar\String_;

$conds = [new Int_(1)];
$body = new String_('yes');

return new MatchArm($conds, $body);

↓

1 => 'yes'

Public Properties

$conds - /** @var null|list<Node\Expr> */
$body - ``

`PhpParser\Node\Name`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Name;

return new Name('shortName');

↓

shortName

Public Properties

$name - `/**
- @psalm-var non-empty-string
- @var string Name as string */`
$specialClassNames - /** @var array<string, bool> */

`PhpParser\Node\Name\FullyQualified`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Name\FullyQualified;

return new FullyQualified('SomeNamespace\ShortName');

↓

\SomeNamespace\ShortName

Public Properties

$name - `/**
- @psalm-var non-empty-string
- @var string Name as string */`

`PhpParser\Node\NullableType`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Name;
use PhpParser\Node\NullableType;

return new NullableType(new Name('SomeType'));

↓

?SomeType

Public Properties

$type - /** @var Identifier|Name Type */

`PhpParser\Node\Param`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Param;

$variable = new Variable('variableName');

return new Param($variable);

↓

$variableName

Public Properties

$type - /** @var null|Identifier|Name|ComplexType Type declaration */
$byRef - /** @var bool Whether parameter is passed by reference */
$variadic - /** @var bool Whether this is a variadic argument */
$var - /** @var Expr\Variable|Expr\Error Parameter variable */
$default - /** @var null|Expr Default value */
$flags - /** @var int Optional visibility flags */
$attrGroups - /** @var AttributeGroup[] PHP attribute groups */
$hooks - /** @var PropertyHook[] Property hooks for promoted properties */

`PhpParser\Node\Scalar\Float_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Scalar\Float_;

return new Float_(100.5);

↓

100.5

Public Properties

$value - /** @var float Number value */

`PhpParser\Node\Scalar\Int_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Scalar\Int_;

return new Int_(100);

↓

Public Properties

$value - /** @var int Number value */

`PhpParser\Node\Scalar\InterpolatedString`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\Encapsed;

return new Encapsed([new Variable('variableName')]);

↓

"{$variableName}"

Public Properties

$parts - /** @var (Expr|InterpolatedStringPart)[] list of string parts */

`PhpParser\Node\Scalar\MagicConst\Property`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Scalar\MagicConst\Property;

return new Property();

↓

__PROPERTY__

`PhpParser\Node\Scalar\String_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Scalar\String_;

return new String_('some string');

↓

'some string'

Public Properties

$value - /** @var string String value */
$replacements - /** @var array<string, string> Escaped character to its decoded value */

`PhpParser\Node\StaticVar`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt\StaticVar;

$variable = new Variable('variableName');

return new StaticVar($variable);

↓

$variableName

Public Properties

$var - /** @var Expr\Variable Variable */
$default - /** @var null|Node\Expr Default value */

`PhpParser\Node\Stmt\Block`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Stmt\Block;
use PhpParser\Node\Stmt\Expression;

$assign = new Assign(new Variable('someValue'), new Int_(10000));

return new Block([new Expression($assign)]);

↓

{
    $someValue = 10000;
}

Public Properties

$stmts - /** @var Stmt[] Statements */

`PhpParser\Node\Stmt\ClassConst`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Const_;
use PhpParser\Node\Scalar\String_;
use PhpParser\Node\Stmt\ClassConst;

$defaultValue = new String_('default value');
$const = new Const_('SOME_CLASS_CONSTANT', $defaultValue);

return new ClassConst([$const], Modifiers::PUBLIC);

↓

public const SOME_CLASS_CONSTANT = 'default value';

Public Properties

$flags - /** @var int Modifiers */
$consts - /** @var Node\Const_[] Constant declarations */
$attrGroups - /** @var Node\AttributeGroup[] PHP attribute groups */
$type - /** @var Node\Identifier|Node\Name|Node\ComplexType|null Type declaration */

`PhpParser\Node\Stmt\ClassMethod`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Stmt\ClassMethod;

$classMethod = new ClassMethod('methodName');
$classMethod->flags = Modifiers::PUBLIC;

return $classMethod;

↓

public function methodName()
{
}

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Identifier;
use PhpParser\Node\Param;
use PhpParser\Node\Stmt\ClassMethod;

$classMethod = new ClassMethod('methodName');
$classMethod->flags = Modifiers::PRIVATE;

$param = new Param(new Variable('paramName'));
$classMethod->params = [$param];
$classMethod->returnType = new Identifier('string');

return $classMethod;

↓

private function methodName($paramName): string
{
}

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Expression;

$classMethod = new ClassMethod('methodName');
$classMethod->flags = Modifiers::PUBLIC;

$variable = new Variable('some');
$number = new Int_(10000);
$assign = new Assign($variable, $number);

$classMethod->stmts[] = new Expression($assign);

return $classMethod;

↓

public function methodName()
{
    $some = 10000;
}

Public Properties

$flags - /** @var int Flags */
$byRef - /** @var bool Whether to return by reference */
$name - /** @var Node\Identifier Name */
$params - /** @var Node\Param[] Parameters */
$returnType - /** @var null|Node\Identifier|Node\Name|Node\ComplexType Return type */
$stmts - /** @var Node\Stmt[]|null Statements */
$attrGroups - /** @var Node\AttributeGroup[] PHP attribute groups */
$magicNames - /** @var array<string, bool> */

`PhpParser\Node\Stmt\Class_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Stmt\Class_;

return new Class_('ClassName');

↓

class ClassName
{
}

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Stmt\Class_;

$class = new Class_('ClassName');
$class->flags |= Modifiers::FINAL;

return $class;

↓

final class ClassName
{
}

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Identifier;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\PropertyProperty;

$class = new Class_(new Identifier('ClassName'));

$propertyProperty = new PropertyProperty('someProperty');
$property = new Property(Modifiers::PRIVATE, [$propertyProperty]);

$class->stmts[] = $property;

return $class;

↓

class ClassName
{
    private $someProperty;
}

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Stmt\Class_;

$class = new Class_('ClassName');

$class->flags = Modifiers::FINAL;
$class->extends = new FullyQualified('ParentClass');

return $class;

↓

final class ClassName extends \ParentClass
{
}

Public Properties

$flags - /** @var int Modifiers */
$extends - /** @var null|Node\Name Name of extended class */
$implements - /** @var Node\Name[] Names of implemented interfaces */
$name - /** @var Node\Identifier|null Name */
$stmts - /** @var Node\Stmt[] Statements */
$attrGroups - /** @var Node\AttributeGroup[] PHP attribute groups */
$namespacedName - /** @var Node\Name|null Namespaced name (if using NameResolver) */

`PhpParser\Node\Stmt\Const_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Const_;
use PhpParser\Node\Scalar\String_;
use PhpParser\Node\Stmt\Const_ as ConstStmt;

$consts = [new Const_('CONSTANT_IN_CLASS', new String_('default value'))];

return new ConstStmt($consts);

↓

const CONSTANT_IN_CLASS = 'default value';

Public Properties

$consts - /** @var Node\Const_[] Constant declarations */
$attrGroups - /** @var Node\AttributeGroup[] PHP attribute groups */

`PhpParser\Node\Stmt\Declare_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Stmt\Declare_;
use PhpParser\Node\Stmt\DeclareDeclare;

$declareDeclare = new DeclareDeclare('strict_types', new Int_(1));

return new Declare_([$declareDeclare]);

↓

declare (strict_types=1);

Public Properties

$declares - /** @var DeclareItem[] List of declares */
$stmts - /** @var Node\Stmt[]|null Statements */

`PhpParser\Node\Stmt\Do_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt\Do_;

$variable = new Variable('variableName');

return new Do_($variable);

↓

do {
} while ($variableName);

Public Properties

$stmts - /** @var Node\Stmt[] Statements */
$cond - /** @var Node\Expr Condition */

`PhpParser\Node\Stmt\Echo_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Scalar\String_;
use PhpParser\Node\Stmt\Echo_;

$string = new String_('hello');

return new Echo_([$string]);

↓

echo 'hello';

Public Properties

$exprs - /** @var Node\Expr[] Expressions */

`PhpParser\Node\Stmt\ElseIf_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Name;
use PhpParser\Node\Stmt\ElseIf_;
use PhpParser\Node\Stmt\Return_;

$name = new Name('true');
$constFetch = new ConstFetch($name);
$stmt = new Return_();

return new ElseIf_($constFetch, [$stmt]);

↓

elseif (true) {
    return;
}

Public Properties

$cond - /** @var Node\Expr Condition */
$stmts - /** @var Node\Stmt[] Statements */

`PhpParser\Node\Stmt\Foreach_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt\Foreach_;

$foreachedVariable = new Variable('foreachedVariableName');
$asVariable = new Variable('asVariable');

return new Foreach_($foreachedVariable, $asVariable);

↓

foreach ($foreachedVariableName as $asVariable) {
}

Public Properties

$expr - /** @var Node\Expr Expression to iterate */
$keyVar - /** @var null|Node\Expr Variable to assign key to */
$byRef - /** @var bool Whether to assign value by reference */
$valueVar - /** @var Node\Expr Variable to assign value to */
$stmts - /** @var Node\Stmt[] Statements */

`PhpParser\Node\Stmt\Function_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Stmt\Function_;

return new Function_('some_function');

↓

function some_function()
{
}

Public Properties

$byRef - /** @var bool Whether function returns by reference */
$name - /** @var Node\Identifier Name */
$params - /** @var Node\Param[] Parameters */
$returnType - /** @var null|Node\Identifier|Node\Name|Node\ComplexType Return type */
$stmts - /** @var Node\Stmt[] Statements */
$attrGroups - /** @var Node\AttributeGroup[] PHP attribute groups */
$namespacedName - /** @var Node\Name|null Namespaced name (if using NameResolver) */

`PhpParser\Node\Stmt\If_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Name;
use PhpParser\Node\Stmt\If_;

$cond = new ConstFetch(new Name('true'));

return new If_($cond);

↓

if (true) {
}

Public Properties

$cond - /** @var Node\Expr Condition expression */
$stmts - /** @var Node\Stmt[] Statements */
$elseifs - /** @var ElseIf_[] Elseif clauses */
$else - /** @var null|Else_ Else clause */

`PhpParser\Node\Stmt\InlineHTML`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Stmt\InlineHTML;

return new InlineHTML('<strong>feel</strong>');

↓

?>
<strong>feel</strong><?php

Public Properties

$value - /** @var string String */

`PhpParser\Node\Stmt\Interface_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Identifier;
use PhpParser\Node\Stmt\Interface_;

return new Interface_(new Identifier('InterfaceName'));

↓

interface InterfaceName
{
}

Public Properties

$extends - /** @var Node\Name[] Extended interfaces */
$name - /** @var Node\Identifier|null Name */
$stmts - /** @var Node\Stmt[] Statements */
$attrGroups - /** @var Node\AttributeGroup[] PHP attribute groups */
$namespacedName - /** @var Node\Name|null Namespaced name (if using NameResolver) */

`PhpParser\Node\Stmt\Label`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Stmt\Label;

return new Label('labelName');

↓

labelName:

Public Properties

$name - /** @var Identifier Name */

`PhpParser\Node\Stmt\Property`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Identifier;
use PhpParser\Modifiers;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\PropertyProperty;
use PhpParser\Node\VarLikeIdentifier;

$propertyProperty = new PropertyProperty(new VarLikeIdentifier('propertyName'));

return new Property(Modifiers::PUBLIC, [$propertyProperty], [], new Identifier('string'));

↓

public string $propertyName;

<?php

declare(strict_types=1);

use PhpParser\Node\PropertyItem;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Expr\BinaryOp\Plus;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\PropertyHook;
use PhpParser\Modifiers;

$propertyItem = new PropertyItem('someProperty');
$property = new Property(Modifiers::PUBLIC, [$propertyItem]);

$plus = new Plus(
    new Variable('variable'),
    new Int_(100)
);

$getPropertyHook = new PropertyHook('getProperty', $plus);

$property->hooks[] = $getPropertyHook;

return $property;

↓

public $someProperty {
    getProperty => $variable + 100;
}

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\PropertyProperty;
use PhpParser\Node\VarLikeIdentifier;

$propertyProperty = new PropertyProperty(new VarLikeIdentifier('propertyName'));

return new Property(Modifiers::PUBLIC, [$propertyProperty]);

↓

public $propertyName;

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\PropertyProperty;

$propertyProperties = [new PropertyProperty('firstProperty'), new PropertyProperty('secondProperty')];

return new Property(Modifiers::STATIC | Modifiers::PUBLIC, $propertyProperties);

↓

public static $firstProperty, $secondProperty;

Public Properties

$flags - /** @var int Modifiers */
$props - /** @var PropertyItem[] Properties */
$type - /** @var null|Identifier|Name|ComplexType Type declaration */
$attrGroups - /** @var Node\AttributeGroup[] PHP attribute groups */
$hooks - /** @var Node\PropertyHook[] Property hooks */

`PhpParser\Node\Stmt\Static_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt\Static_;
use PhpParser\Node\Stmt\StaticVar;

$staticVars = [new StaticVar(new Variable('static'))];

return new Static_($staticVars);

↓

static $static;

Public Properties

$vars - /** @var StaticVar[] Variable definitions */

`PhpParser\Node\Stmt\Switch_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Stmt\Case_;
use PhpParser\Node\Stmt\Switch_;

$cond = new Variable('variableName');
$cases = [new Case_(new Int_(1))];

return new Switch_($cond, $cases);

↓

switch ($variableName) {
    case 1:
}

Public Properties

$cond - /** @var Node\Expr Condition */
$cases - /** @var Case_[] Case list */

`PhpParser\Node\Stmt\TraitUse`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Stmt\TraitUse;

return new TraitUse([new FullyQualified('TraitName')]);

↓

use \TraitName;

Public Properties

$traits - /** @var Node\Name[] Traits */
$adaptations - /** @var TraitUseAdaptation[] Adaptations */

`PhpParser\Node\Stmt\TraitUseAdaptation\Alias`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Modifiers;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Stmt\TraitUseAdaptation\Alias;

$traitFullyQualified = new FullyQualified('TraitName');

return new Alias($traitFullyQualified, 'method', Modifiers::PUBLIC, 'aliasedMethod');

↓

\TraitName::method as public aliasedMethod;

Public Properties

$newModifier - /** @var null|int New modifier */
$newName - /** @var null|Node\Identifier New name */
$trait - /** @var Node\Name|null Trait name */
$method - /** @var Node\Identifier Method name */

`PhpParser\Node\Stmt\Trait_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Stmt\Trait_;

return new Trait_('TraitName');

↓

trait TraitName
{
}

Public Properties

$name - /** @var Node\Identifier|null Name */
$stmts - /** @var Node\Stmt[] Statements */
$attrGroups - /** @var Node\AttributeGroup[] PHP attribute groups */
$namespacedName - /** @var Node\Name|null Namespaced name (if using NameResolver) */

`PhpParser\Node\Stmt\TryCatch`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Scalar\String_;
use PhpParser\Node\Stmt\Catch_;
use PhpParser\Node\Stmt\Echo_;
use PhpParser\Node\Stmt\Finally_;
use PhpParser\Node\Stmt\TryCatch;

$echo = new Echo_([new String_('one')]);
$tryStmts = [$echo];

$echo2 = new Echo_([new String_('two')]);
$catch = new Catch_([new FullyQualified('SomeType')], null, [$echo2]);

$echo3 = new Echo_([new String_('three')]);
$finally = new Finally_([$echo3]);

return new TryCatch($tryStmts, [$catch]);

↓

try {
    echo 'one';
} catch (\SomeType) {
    echo 'two';
}

Public Properties

$stmts - /** @var Node\Stmt[] Statements */
$catches - /** @var Catch_[] Catches */
$finally - /** @var null|Finally_ Optional finally node */

`PhpParser\Node\Stmt\Unset_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt\Unset_;

$variable = new Variable('variableName');

return new Unset_([$variable]);

↓

unset($variableName);

Public Properties

$vars - /** @var Node\Expr[] Variables to unset */

`PhpParser\Node\Stmt\Use_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Name;
use PhpParser\Node\Stmt\Use_;
use PhpParser\Node\Stmt\UseUse;

$useUse = new UseUse(new Name('UsedNamespace'));

return new Use_([$useUse]);

↓

use UsedNamespace;

Public Properties

$type - /** @var self::TYPE_* Type of alias */
$uses - /** @var UseItem[] Aliases */

`PhpParser\Node\Stmt\While_`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt\While_;

return new While_(new Variable('variableName'));

↓

while ($variableName) {
}

Public Properties

$cond - /** @var Node\Expr Condition */
$stmts - /** @var Node\Stmt[] Statements */

`PhpParser\Node\UnionType`

Example PHP Code

<?php

declare(strict_types=1);

use PhpParser\Node\Identifier;
use PhpParser\Node\UnionType;

$unionedTypes = [new Identifier('string'), new Identifier('int')];

return new UnionType($unionedTypes);

↓

string|int

Public Properties

$types - /** @var (Identifier|Name|IntersectionType)[] Types */

Name		Name	Last commit message	Last commit date
Latest commit History 35 Commits
.github/workflows		.github/workflows
bin		bin
snippet		snippet
src		src
tests		tests
.gitignore		.gitignore
README.md		README.md
composer.json		composer.json
ecs.php		ecs.php
phpstan.neon		phpstan.neon
phpunit.xml		phpunit.xml
rector.php		rector.php

rectorphp/php-parser-nodes-docs

Folders and files

Latest commit

History

Repository files navigation

Node Overview for PHP-Parser 5.6 (2025)

PhpParser\Node\ArrayItem

Example PHP Code

Public Properties

PhpParser\Node\ClosureUse

Example PHP Code

Public Properties

PhpParser\Node\Const_

Example PHP Code

Public Properties

PhpParser\Node\Expr\ArrayDimFetch

Example PHP Code

Public Properties

PhpParser\Node\Expr\Array_

Example PHP Code

Public Properties

PhpParser\Node\Expr\ArrowFunction

Example PHP Code

Public Properties

PhpParser\Node\Expr\Assign

Example PHP Code

Public Properties

PhpParser\Node\Expr\AssignOp\Coalesce

Example PHP Code

Public Properties

PhpParser\Node\Expr\AssignOp\Concat

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\BooleanAnd

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\Coalesce

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\Concat

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\Equal

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\Identical

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\Minus

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\NotEqual

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\NotIdentical

Example PHP Code

Public Properties

PhpParser\Node\Expr\BinaryOp\Spaceship

Example PHP Code

Public Properties

PhpParser\Node\Expr\BooleanNot

Example PHP Code

Public Properties

PhpParser\Node\Expr\Cast\Array_

Example PHP Code

Public Properties

PhpParser\Node\Expr\Cast\Bool_

Example PHP Code

Public Properties

PhpParser\Node\Expr\Cast\Int_

Example PHP Code

Public Properties

PhpParser\Node\Expr\Cast\String_

Example PHP Code

Public Properties

PhpParser\Node\Expr\ClassConstFetch

Example PHP Code

Public Properties

PhpParser\Node\Expr\ConstFetch

Example PHP Code

`PhpParser\Node\ArrayItem`

`PhpParser\Node\ClosureUse`

`PhpParser\Node\Const_`

`PhpParser\Node\Expr\ArrayDimFetch`

`PhpParser\Node\Expr\Array_`

`PhpParser\Node\Expr\ArrowFunction`

`PhpParser\Node\Expr\Assign`

`PhpParser\Node\Expr\AssignOp\Coalesce`

`PhpParser\Node\Expr\AssignOp\Concat`

`PhpParser\Node\Expr\BinaryOp\BooleanAnd`

`PhpParser\Node\Expr\BinaryOp\Coalesce`

`PhpParser\Node\Expr\BinaryOp\Concat`

`PhpParser\Node\Expr\BinaryOp\Equal`

`PhpParser\Node\Expr\BinaryOp\Identical`

`PhpParser\Node\Expr\BinaryOp\Minus`

`PhpParser\Node\Expr\BinaryOp\NotEqual`

`PhpParser\Node\Expr\BinaryOp\NotIdentical`

`PhpParser\Node\Expr\BinaryOp\Spaceship`

`PhpParser\Node\Expr\BooleanNot`

`PhpParser\Node\Expr\Cast\Array_`

`PhpParser\Node\Expr\Cast\Bool_`

`PhpParser\Node\Expr\Cast\Int_`

`PhpParser\Node\Expr\Cast\String_`

`PhpParser\Node\Expr\ClassConstFetch`

`PhpParser\Node\Expr\ConstFetch`

`PhpParser\Node\Expr\Empty_`

`PhpParser\Node\Expr\Eval_`

`PhpParser\Node\Expr\FuncCall`

`PhpParser\Node\Expr\Include_`

`PhpParser\Node\Expr\Instanceof_`

`PhpParser\Node\Expr\Isset_`

`PhpParser\Node\Expr\List_`

`PhpParser\Node\Expr\Match_`

`PhpParser\Node\Expr\MethodCall`

`PhpParser\Node\Expr\New_`

`PhpParser\Node\Expr\NullsafeMethodCall`

`PhpParser\Node\Expr\NullsafePropertyFetch`

`PhpParser\Node\Expr\PropertyFetch`

`PhpParser\Node\Expr\StaticCall`

`PhpParser\Node\Expr\StaticPropertyFetch`

`PhpParser\Node\Expr\Ternary`

`PhpParser\Node\Expr\Throw_`

`PhpParser\Node\Expr\Variable`

`PhpParser\Node\MatchArm`

`PhpParser\Node\Name`

`PhpParser\Node\Name\FullyQualified`