Class PhpParser\PrettyPrinterAbstract

`abstract`
`implements`	`PrettyPrinter`

PhpParser\PrettyPrinterAbstract implements PrettyPrinter
- PhpParser\PrettyPrinter\Standard
  - PHPStan\Node\Printer\Printer

Located at vendor/nikic/php-parser/lib/PhpParser/PrettyPrinterAbstract.php

Methods


					
	public

__construct(array{phpVersion?:PhpVersion, newline?:string, indent?:string, shortArraySyntax?:bool} $options = [])

Creates a pretty printer instance using the given options.

Supported options:

PhpVersion $phpVersion: The PHP version to target (default to PHP 7.4). This option controls compatibility of the generated code with older PHP versions in cases where a simple stylistic choice exists (e.g. array() vs []). It is safe to pretty-print an AST for a newer PHP version while specifying an older target (but the result will of course not be compatible with the older version in that case).
string $newline: The newline style to use. Should be "\n" (default) or "\r\n".
string $indent: The indentation to use. Should either be all spaces or a single tab. Defaults to four spaces (" ").
bool $shortArraySyntax: Whether to use [] instead of array() as the default array syntax, if the node does not specify a format. Defaults to whether the phpVersion support short array syntax.

Parameters

$options

Dictionary of formatting options


					
	protected

resetState(): void

Reset pretty printing state.


					
	protected

setIndentLevel(int $level): void

Set indentation level

Parameters

$level

Level in number of spaces


					
	protected

indent(): void

Increase indentation level.


					
	protected

outdent(): void

Decrease indentation level.


					
	public

prettyPrint(Node[] $stmts): string

Pretty prints an array of statements.

Parameters

$stmts

Array of statements

Returns

Pretty printed statements

Implements

PhpParser\PrettyPrinter::prettyPrint()


					
	public

prettyPrintExpr(Expr $node): string

Pretty prints an expression.

Parameters

$node

Expression node

Returns

Pretty printed node

Implements

PhpParser\PrettyPrinter::prettyPrintExpr()


					
	public

prettyPrintFile(Node[] $stmts): string

Pretty prints a file of statements (includes the opening <?php tag if it is required).

Parameters

$stmts

Array of statements

Returns

Pretty printed statements

Implements

PhpParser\PrettyPrinter::prettyPrintFile()


					
	protected

preprocessNodes(Node[] $nodes): void

Preprocesses the top-level nodes to initialize pretty printer state.

Parameters

$nodes

Array of nodes


					
	protected

handleMagicTokens(string $str): string

Handles (and removes) doc-string-end tokens.


					
	protected

pStmts(Node[] $nodes, bool $indent = true): string

Pretty prints an array of nodes (statements) and indents them optionally.

Parameters

`$nodes`	Array of nodes
`$indent`	Whether to indent the printed nodes

Returns

Pretty printed statements


					
	protected

pInfixOp(
	string $class,
	Node $leftNode,
	string $operatorString,
	Node $rightNode,
	int $precedence,
	int $lhsPrecedence,
): string

Pretty-print an infix operation while taking precedence into account.

Parameters

`$class`	Node class of operator
`$leftNode`	Left-hand side node
`$operatorString`	String representation of the operator
`$rightNode`	Right-hand side node
`$precedence`	Precedence of parent operator
`$lhsPrecedence`	Precedence for unary operator on LHS of binary operator

Returns

Pretty printed infix operation


					
	protected

pPrefixOp(string $class, string $operatorString, Node $node, int $precedence, int $lhsPrecedence): string

Pretty-print a prefix operation while taking precedence into account.

Parameters

`$class`	Node class of operator
`$operatorString`	String representation of the operator
`$node`	Node
`$precedence`	Precedence of parent operator
`$lhsPrecedence`	Precedence for unary operator on LHS of binary operator

Returns

Pretty printed prefix operation


					
	protected

pPostfixOp(string $class, Node $node, string $operatorString, int $precedence, int $lhsPrecedence): string

Pretty-print a postfix operation while taking precedence into account.

Parameters

`$class`	Node class of operator
`$node`	Node
`$operatorString`	String representation of the operator
`$precedence`	Precedence of parent operator
`$lhsPrecedence`	Precedence for unary operator on LHS of binary operator

Returns

Pretty printed postfix operation


					
	protected

pImplode(Node[] $nodes, string $glue = ''): string

Pretty prints an array of nodes and implodes the printed values.

Parameters

`$nodes`	Array of Nodes to be printed
`$glue`	Character to implode with

Returns

Imploded pretty printed nodes> $pre


					
	protected

pCommaSeparated(Node[] $nodes): string

Pretty prints an array of nodes and implodes the printed values with commas.

Parameters

$nodes

Array of Nodes to be printed

Returns

Comma separated pretty printed nodes


					
	protected

pCommaSeparatedMultiline(Node[] $nodes, bool $trailingComma): string

Pretty prints a comma-separated list of nodes in multiline style, including comments.

The result includes a leading newline and one level of indentation (same as pStmts).

Parameters

`$nodes`	Array of Nodes to be printed
`$trailingComma`	Whether to use a trailing comma

Returns

Comma separated pretty printed nodes in multiline style


					
	protected

pComments(Comment[] $comments): string

Prints reformatted text of the passed comments.

Parameters

$comments

List of comments

Returns

Reformatted text of comments


					
	public

printFormatPreserving(Node[] $stmts, Node[] $origStmts, Token[] $origTokens): string

Perform a format-preserving pretty print of an AST.

The format preservation is best effort. For some changes to the AST the formatting will not be preserved (at least not locally).

In order to use this method a number of prerequisites must be satisfied:

The startTokenPos and endTokenPos attributes in the lexer must be enabled.
The CloningVisitor must be run on the AST prior to modification.
The original tokens must be provided, using the getTokens() method on the lexer.

Parameters

`$stmts`	Modified AST with links to original AST
`$origStmts`	Original AST with token offset information
`$origTokens`	Tokens of the original code

Implements

PhpParser\PrettyPrinter::printFormatPreserving()


					
	protected

pFallback(Node $node, int $precedence, int $lhsPrecedence): string


					
	protected

p(
	Node $node,
	int $precedence = self::MAX_PRECEDENCE,
	int $lhsPrecedence = self::MAX_PRECEDENCE,
	bool $parentFormatPreserved = false,
): string

Pretty prints a node.

This method also handles formatting preservation for nodes.

Parameters

`$node`	Node to be pretty printed
`$precedence`	Precedence of parent operator
`$lhsPrecedence`	Precedence for unary operator on LHS of binary operator
`$parentFormatPreserved`	Whether parent node has preserved formatting

Returns

Pretty printed node


					
	protected

pArray(
	Node[] $nodes,
	Node[] $origNodes,
	int &$pos,
	int $indentAdjustment,
	string $parentNodeClass,
	string $subNodeName,
	null|int $fixup,
): null|string

Perform a format-preserving pretty print of an array.

Parameters

`$nodes`	New nodes
`$origNodes`	Original nodes
`$pos`	Current token position (updated by reference)
`$indentAdjustment`	Adjustment for indentation
`$parentNodeClass`	Class of the containing node.
`$subNodeName`	Name of array subnode.
`$fixup`	Fixup information for array item nodes

Returns

Result of pretty print or null if cannot preserve formatting


					
	protected

pFixup(int $fixup, Node $subNode, string|null $parentClass, int $subStartPos, int $subEndPos): string

Print node with fixups.

Fixups here refer to the addition of extra parentheses, braces or other characters, that are required to preserve program semantics in a certain context (e.g. to maintain precedence or because only certain expressions are allowed in certain places).

Parameters

`$fixup`	Fixup type
`$subNode`	Subnode to print
`$parentClass`	Class of parent node
`$subStartPos`	Original start pos of subnode
`$subEndPos`	Original end pos of subnode

Returns

Result of fixed-up print of subnode


					
	protected

safeAppend(string &$str, string $append): void

Appends to a string, ensuring whitespace between label characters.

Example: "echo" and "$x" result in "echo$x", but "echo" and "x" result in "echo x". Without safeAppend the result would be "echox", which does not preserve semantics.


					
	protected

callLhsRequiresParens(Node $node): bool

Determines whether the LHS of a call must be wrapped in parenthesis.

Parameters

$node

LHS of a call

Returns

Whether parentheses are required


					
	protected

dereferenceLhsRequiresParens(Node $node): bool

Determines whether the LHS of an array/object operation must be wrapped in parentheses.

Parameters

$node

LHS of dereferencing operation

Returns

Whether parentheses are required


					
	protected

staticDereferenceLhsRequiresParens(Node $node): bool

Determines whether the LHS of a static operation must be wrapped in parentheses.

Parameters

$node

LHS of dereferencing operation

Returns

Whether parentheses are required


					
	protected

newOperandRequiresParens(Node $node): bool

Determines whether an expression used in "new" or "instanceof" requires parentheses.

Parameters

$node

New or instanceof operand

Returns

Whether parentheses are required


					
	protected

pModifiers(int $modifiers): string

Print modifiers, including trailing whitespace.

Parameters

$modifiers

Modifier mask to print

Returns

Printed modifiers


					
	protected

pStatic(bool $static): string


					
	protected

isMultiline((Node|null)[] $nodes): bool

Determine whether a list of nodes uses multiline formatting.

Parameters

$nodes

Node list

Returns

Whether multiline formatting is used


					
	protected

initializeLabelCharMap(): void

Lazily initializes label char map.

The label char map determines whether a certain character may occur in a label.


					
	protected

initializeNodeListDiffer(): void

Lazily initializes node list differ.

The node list differ is used to determine differences between two array subnodes.


					
	protected

initializeFixupMap(): void

Lazily initializes fixup map.

The fixup map is used to determine whether a certain subnode of a certain node may require some kind of "fixup" operation, e.g. the addition of parenthesis or braces.


					
	protected

initializeRemovalMap(): void

Lazily initializes the removal map.

The removal map is used to determine which additional tokens should be removed when a certain node is replaced by null.


					
	protected

initializeInsertionMap(): void


					
	protected

initializeListInsertionMap(): void


					
	protected

initializeEmptyListInsertionMap(): void


					
	protected

initializeModifierChangeMap(): void

Constants
`protected`	`FIXUP_PREC_LEFT = 0`	#
`protected`	`FIXUP_PREC_RIGHT = 1`	#
`protected`	`FIXUP_PREC_UNARY = 2`	#
`protected`	`FIXUP_CALL_LHS = 3`	#
`protected`	`FIXUP_DEREF_LHS = 4`	#
`protected`	`FIXUP_STATIC_DEREF_LHS = 5`	#
`protected`	`FIXUP_BRACED_NAME = 6`	#
`protected`	`FIXUP_VAR_BRACED_NAME = 7`	#
`protected`	`FIXUP_ENCAPSED = 8`	#
`protected`	`FIXUP_NEW = 9`	#
`protected`	`MAX_PRECEDENCE = 1000`	#

Properties
`protected`	`array<class-string, array{int, int, int}>`	$precedenceMap = [ Clone_::class => [-10, 0, 1], Pow::class => [0, 0, 1], BitwiseNot::class => [10, -1, -1], UnaryPlus::class => [10, -1, -1], UnaryMinus::class => [10, -1, -1], Int_::class => [10, -1, -1], Double::class => [10, -1, -1], String_::class => [10, -1, -1], Array_::class => [10, -1, -1], Object_::class => [10, -1, -1], Bool_::class => [10, -1, -1], Unset_::class => [10, -1, -1], ErrorSuppress::class => [10, -1, -1], Instanceof_::class => [20, -1, -1], BooleanNot::class => [30, -1, -1], Mul::class => [40, 41, 40], Div::class => [40, 41, 40], Mod::class => [40, 41, 40], Plus::class => [50, 51, 50], Minus::class => [50, 51, 50], Concat::class => [50, 51, 50], ShiftLeft::class => [60, 61, 60], ShiftRight::class => [60, 61, 60], Smaller::class => [70, 70, 70], SmallerOrEqual::class => [70, 70, 70], Greater::class => [70, 70, 70], GreaterOrEqual::class => [70, 70, 70], Equal::class => [80, 80, 80], NotEqual::class => [80, 80, 80], Identical::class => [80, 80, 80], NotIdentical::class => [80, 80, 80], Spaceship::class => [80, 80, 80], BitwiseAnd::class => [90, 91, 90], BitwiseXor::class => [100, 101, 100], BitwiseOr::class => [110, 111, 110], BooleanAnd::class => [120, 121, 120], BooleanOr::class => [130, 131, 130], Coalesce::class => [140, 140, 141], Ternary::class => [150, 150, 150], Assign::class => [160, -1, -1], AssignRef::class => [160, -1, -1], Plus::class => [160, -1, -1], Minus::class => [160, -1, -1], Mul::class => [160, -1, -1], Div::class => [160, -1, -1], Concat::class => [160, -1, -1], Mod::class => [160, -1, -1], BitwiseAnd::class => [160, -1, -1], BitwiseOr::class => [160, -1, -1], BitwiseXor::class => [160, -1, -1], ShiftLeft::class => [160, -1, -1], ShiftRight::class => [160, -1, -1], Pow::class => [160, -1, -1], Coalesce::class => [160, -1, -1], YieldFrom::class => [170, -1, -1], Yield_::class => [175, -1, -1], Print_::class => [180, -1, -1], LogicalAnd::class => [190, 191, 190], LogicalXor::class => [200, 201, 200], LogicalOr::class => [210, 211, 210], Include_::class => [220, -1, -1], ArrowFunction::class => [230, -1, -1], Throw_::class => [240, -1, -1], ]	#
`protected`	`int`	`$indentLevel` Current indentation level. Current indentation level.	#
`protected`	`string`	`$newline` Newline style. Does not include current indentation. Newline style. Does not include current indentation.	#
`protected`	`string`	`$nl` Newline including current indentation. Newline including current indentation.	#
`protected`	`string\|null`	`$docStringEndToken` Token placed at end of doc string to ensure it is followed by a newline. Null if flexible doc strings… Token placed at end of doc string to ensure it is followed by a newline. Null if flexible doc strings are used.	#
`protected`	`bool`	`$canUseSemicolonNamespaces` Whether semicolon namespaces can be used (i.e. no global namespace is used) Whether semicolon namespaces can be used (i.e. no global namespace is used)	#
`protected`	`bool`	`$shortArraySyntax` Whether to use short array syntax if the node specifies no preference Whether to use short array syntax if the node specifies no preference	#
`protected`	`PhpVersion`	`$phpVersion` PHP version to target PHP version to target	#
`protected`	`TokenStream\|null`	`$origTokens` Original tokens for use in format-preserving pretty print Original tokens for use in format-preserving pretty print	#
`protected`	`Differ<Node>`	`$nodeListDiffer` Differ for node lists Differ for node lists	#
`protected`	`array<string, bool>`	`$labelCharMap` Map determining whether a certain character is a label character Map determining whether a certain character is a label character	#
`protected`	`array<string, array<string, int>>`	`$fixupMap` Map from token classes and subnode names to FIXUP_* constants. This is used… Map from token classes and subnode names to FIXUP_* constants. This is used during format-preserving prints to place additional parens/braces if necessary.	#
`protected`	`array<string, array{left?:(int\|string), right?:(int\|string)}>`	`$removalMap` Map from "{$node->getType()}->{$subNode}" to ['left' =… Map from "{$node->getType()}->{$subNode}" to ['left' => $l, 'right' => $r], where $l and $r specify the token type that needs to be stripped when removing this node.	#
`protected`	`array<string, array{(int\|string\|null), bool, (string\|null), (string\|null)}>`	`$insertionMap` Map from "{$node->getType()}->{$subNode}" to… Map from "{$node->getType()}->{$subNode}" to [$find, $beforeToken, $extraLeft, $extraRight]. $find is an optional token after which the insertion occurs. $extraLeft/Right are optionally added before/after the main insertions.	#
`protected`	`array<string, string>`	`$listInsertionMap` Map From "{$class}->{$subNode}" to string that should be inserted between elements of this… Map From "{$class}->{$subNode}" to string that should be inserted between elements of this list subnode.	#
`protected`	`array<string, array{(int\|string\|null), string, string}>`	`$emptyListInsertionMap`	#
`protected`	`array<string, array{string, int}>`	`$modifierChangeMap` Map from "{$class}->{$subNode}" to [$printFn, $token] where $printFn is the function to print the modifiers and … Map from "{$class}->{$subNode}" to [$printFn, $token] where $printFn is the function to print the modifiers and $token is the token before which the modifiers should be reprinted.	#

Namespaces

Classes

Interfaces

Exceptions

Class PhpParser\PrettyPrinterAbstract

Parameters

Parameters

Parameters

Returns

Implements

Parameters

Returns

Implements

Parameters

Returns

Implements

Parameters

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Implements

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns