Documentation

PrettyPrinterAbstract
in package

Application

FIXUP_BRACED_NAME = 4
FIXUP_CALL_LHS = 2
FIXUP_DEREF_LHS = 3
FIXUP_ENCAPSED = 6
FIXUP_PREC_LEFT = 0
FIXUP_PREC_RIGHT = 1
FIXUP_VAR_BRACED_NAME = 5
$canUseSemicolonNamespaces : bool
$docStringEndToken : string
$emptyListInsertionMap : mixed
$fixupMap : array<string|int, array<string|int, int>>
$indentLevel : int
$insertionMap : array<string|int, mixed>
$labelCharMap : array<string|int, bool>
$listInsertionMap : array<string|int, string>
$modifierChangeMap : array<string|int, int>
$nl : string
$nodeListDiffer : Differ
$options : array<string|int, mixed>
$origTokens : TokenStream
$precedenceMap : mixed
$removalMap : array<string|int, array<string|int, int>>
__construct() : mixed: Creates a pretty printer instance using the given options.
prettyPrint() : string: Pretty prints an array of statements.
prettyPrintExpr() : string: Pretty prints an expression.
prettyPrintFile() : string: Pretty prints a file of statements (includes the opening <?php tag if it is required).
printFormatPreserving() : string: Perform a format-preserving pretty print of an AST.
callLhsRequiresParens() : bool: Determines whether the LHS of a call must be wrapped in parenthesis.
dereferenceLhsRequiresParens() : bool: Determines whether the LHS of a dereferencing operation must be wrapped in parenthesis.
handleMagicTokens() : string: Handles (and removes) no-indent and doc-string-end tokens.
indent() : mixed: Increase indentation level.
initializeEmptyListInsertionMap() : mixed
initializeFixupMap() : mixed: Lazily initializes fixup map.
initializeInsertionMap() : mixed
initializeLabelCharMap() : mixed: Lazily initializes label char map.
initializeListInsertionMap() : mixed
initializeModifierChangeMap() : mixed
initializeNodeListDiffer() : mixed: Lazily initializes node list differ.
initializeRemovalMap() : mixed: Lazily initializes the removal map.
isMultiline() : bool: Determine whether a list of nodes uses multiline formatting.
outdent() : mixed: Decrease indentation level.
p() : string: Pretty prints a node.
pArray() : null|string: Perform a format-preserving pretty print of an array.
pCommaSeparated() : string: Pretty prints an array of nodes and implodes the printed values with commas.
pCommaSeparatedMultiline() : string: Pretty prints a comma-separated list of nodes in multiline style, including comments.
pComments() : string: Prints reformatted text of the passed comments.
pFallback() : mixed
pFixup() : string: Print node with fixups.
pImplode() : string: Pretty prints an array of nodes and implodes the printed values.
pInfixOp() : string: Pretty-print an infix operation while taking precedence into account.
pModifiers() : string: Print modifiers, including trailing whitespace.
pPostfixOp() : string: Pretty-print a postfix operation while taking precedence into account.
pPrec() : string: Prints an expression node with the least amount of parentheses necessary to preserve the meaning.
pPrefixOp() : string: Pretty-print a prefix operation while taking precedence into account.
preprocessNodes() : mixed: Preprocesses the top-level nodes to initialize pretty printer state.
pStmts() : string: Pretty prints an array of nodes (statements) and indents them optionally.
resetState() : mixed: Reset pretty printing state.
safeAppend() : mixed: Appends to a string, ensuring whitespace between label characters.
setIndentLevel() : mixed: Set indentation level

FIXUP_BRACED_NAME


    public
        mixed
    FIXUP_BRACED_NAME
    = 4

FIXUP_CALL_LHS


    public
        mixed
    FIXUP_CALL_LHS
    = 2

FIXUP_DEREF_LHS


    public
        mixed
    FIXUP_DEREF_LHS
    = 3

FIXUP_ENCAPSED


    public
        mixed
    FIXUP_ENCAPSED
    = 6

FIXUP_PREC_LEFT


    public
        mixed
    FIXUP_PREC_LEFT
    = 0

FIXUP_PREC_RIGHT


    public
        mixed
    FIXUP_PREC_RIGHT
    = 1

FIXUP_VAR_BRACED_NAME


    public
        mixed
    FIXUP_VAR_BRACED_NAME
    = 5

$canUseSemicolonNamespaces


    protected
        bool
    $canUseSemicolonNamespaces

Whether semicolon namespaces can be used (i.e. no global namespace is used)

$docStringEndToken


    protected
        string
    $docStringEndToken

Token placed at end of doc string to ensure it is followed by a newline.

$emptyListInsertionMap


    protected
        mixed
    $emptyListInsertionMap

$fixupMap


    protected
        array<string|int, array<string|int, int>>
    $fixupMap

Map from token classes and subnode names to FIXUP_* constants. This is used during format-preserving prints to place additional parens/braces if necessary.

$indentLevel


    protected
        int
    $indentLevel

Current indentation level.

$insertionMap


    protected
        array<string|int, mixed>
    $insertionMap

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.

$labelCharMap


    protected
        array<string|int, bool>
    $labelCharMap

Map determining whether a certain character is a label character

$listInsertionMap


    protected
        array<string|int, string>
    $listInsertionMap

Map From "{$node->getType()}->{$subNode}" to string that should be inserted between elements of this list subnode.

$modifierChangeMap


    protected
        array<string|int, int>
    $modifierChangeMap

Map from "{$node->getType()}->{$subNode}" to token before which the modifiers should be reprinted.

$nl


    protected
        string
    $nl

Newline including current indentation.

$nodeListDiffer


    protected
        Differ
    $nodeListDiffer

Differ for node lists

$options


    protected
        array<string|int, mixed>
    $options

Pretty printer options

$origTokens


    protected
        TokenStream
    $origTokens

Original tokens for use in format-preserving pretty print

$precedenceMap


    protected
        mixed
    $precedenceMap
     = [
    // [precedence, associativity]
    // where for precedence -1 is %left, 0 is %nonassoc and 1 is %right
    \PhpParser\Node\Expr\BinaryOp\Pow::class => [0, 1],
    \PhpParser\Node\Expr\BitwiseNot::class => [10, 1],
    \PhpParser\Node\Expr\PreInc::class => [10, 1],
    \PhpParser\Node\Expr\PreDec::class => [10, 1],
    \PhpParser\Node\Expr\PostInc::class => [10, -1],
    \PhpParser\Node\Expr\PostDec::class => [10, -1],
    \PhpParser\Node\Expr\UnaryPlus::class => [10, 1],
    \PhpParser\Node\Expr\UnaryMinus::class => [10, 1],
    \PhpParser\Node\Expr\Cast\Int_::class => [10, 1],
    \PhpParser\Node\Expr\Cast\Double::class => [10, 1],
    \PhpParser\Node\Expr\Cast\String_::class => [10, 1],
    \PhpParser\Node\Expr\Cast\Array_::class => [10, 1],
    \PhpParser\Node\Expr\Cast\Object_::class => [10, 1],
    \PhpParser\Node\Expr\Cast\Bool_::class => [10, 1],
    \PhpParser\Node\Expr\Cast\Unset_::class => [10, 1],
    \PhpParser\Node\Expr\ErrorSuppress::class => [10, 1],
    \PhpParser\Node\Expr\Instanceof_::class => [20, 0],
    \PhpParser\Node\Expr\BooleanNot::class => [30, 1],
    \PhpParser\Node\Expr\BinaryOp\Mul::class => [40, -1],
    \PhpParser\Node\Expr\BinaryOp\Div::class => [40, -1],
    \PhpParser\Node\Expr\BinaryOp\Mod::class => [40, -1],
    \PhpParser\Node\Expr\BinaryOp\Plus::class => [50, -1],
    \PhpParser\Node\Expr\BinaryOp\Minus::class => [50, -1],
    \PhpParser\Node\Expr\BinaryOp\Concat::class => [50, -1],
    \PhpParser\Node\Expr\BinaryOp\ShiftLeft::class => [60, -1],
    \PhpParser\Node\Expr\BinaryOp\ShiftRight::class => [60, -1],
    \PhpParser\Node\Expr\BinaryOp\Smaller::class => [70, 0],
    \PhpParser\Node\Expr\BinaryOp\SmallerOrEqual::class => [70, 0],
    \PhpParser\Node\Expr\BinaryOp\Greater::class => [70, 0],
    \PhpParser\Node\Expr\BinaryOp\GreaterOrEqual::class => [70, 0],
    \PhpParser\Node\Expr\BinaryOp\Equal::class => [80, 0],
    \PhpParser\Node\Expr\BinaryOp\NotEqual::class => [80, 0],
    \PhpParser\Node\Expr\BinaryOp\Identical::class => [80, 0],
    \PhpParser\Node\Expr\BinaryOp\NotIdentical::class => [80, 0],
    \PhpParser\Node\Expr\BinaryOp\Spaceship::class => [80, 0],
    \PhpParser\Node\Expr\BinaryOp\BitwiseAnd::class => [90, -1],
    \PhpParser\Node\Expr\BinaryOp\BitwiseXor::class => [100, -1],
    \PhpParser\Node\Expr\BinaryOp\BitwiseOr::class => [110, -1],
    \PhpParser\Node\Expr\BinaryOp\BooleanAnd::class => [120, -1],
    \PhpParser\Node\Expr\BinaryOp\BooleanOr::class => [130, -1],
    \PhpParser\Node\Expr\BinaryOp\Coalesce::class => [140, 1],
    \PhpParser\Node\Expr\Ternary::class => [150, 0],
    // parser uses %left for assignments, but they really behave as %right
    \PhpParser\Node\Expr\Assign::class => [160, 1],
    \PhpParser\Node\Expr\AssignRef::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\Plus::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\Minus::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\Mul::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\Div::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\Concat::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\Mod::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\BitwiseAnd::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\BitwiseOr::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\BitwiseXor::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\ShiftLeft::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\ShiftRight::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\Pow::class => [160, 1],
    \PhpParser\Node\Expr\AssignOp\Coalesce::class => [160, 1],
    \PhpParser\Node\Expr\YieldFrom::class => [165, 1],
    \PhpParser\Node\Expr\Print_::class => [168, 1],
    \PhpParser\Node\Expr\BinaryOp\LogicalAnd::class => [170, -1],
    \PhpParser\Node\Expr\BinaryOp\LogicalXor::class => [180, -1],
    \PhpParser\Node\Expr\BinaryOp\LogicalOr::class => [190, -1],
    \PhpParser\Node\Expr\Include_::class => [200, -1],
]

$removalMap


    protected
        array<string|int, array<string|int, int>>
    $removalMap

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.

__construct()

Creates a pretty printer instance using the given options.


    public
                    __construct([array<string|int, mixed> $options = [] ]) : mixed

Supported options:

bool $shortArraySyntax = false: Whether to use [] instead of array() as the default array syntax, if the node does not specify a format.

Parameters

$options : array<string|int, mixed> = []: Dictionary of formatting options

Return values

mixed —

prettyPrint()

Pretty prints an array of statements.


    public
                    prettyPrint(array<string|int, Node> $stmts) : string

Parameters

$stmts : array<string|int, Node>: Array of statements

Return values

string —

Pretty printed statements

prettyPrintExpr()

Pretty prints an expression.


    public
                    prettyPrintExpr(Expr $node) : string

Parameters

$node : Expr: Expression node

Return values

string —

Pretty printed node

prettyPrintFile()

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


    public
                    prettyPrintFile(array<string|int, Node> $stmts) : string

Parameters

$stmts : array<string|int, Node>: Array of statements

Return values

string —

Pretty printed statements

printFormatPreserving()

Perform a format-preserving pretty print of an AST.


    public
                    printFormatPreserving(array<string|int, Node> $stmts, array<string|int, Node> $origStmts, array<string|int, mixed> $origTokens) : string

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 : array<string|int, Node>: Modified AST with links to original AST
$origStmts : array<string|int, Node>: Original AST with token offset information
$origTokens : array<string|int, mixed>: Tokens of the original code

Return values

string —

callLhsRequiresParens()

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


    protected
                    callLhsRequiresParens(Node $node) : bool

Parameters

$node : Node: LHS of a call

Return values

bool —

Whether parentheses are required

dereferenceLhsRequiresParens()

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


    protected
                    dereferenceLhsRequiresParens(Node $node) : bool

Parameters

$node : Node: LHS of dereferencing operation

Return values

bool —

Whether parentheses are required

handleMagicTokens()

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


    protected
                    handleMagicTokens(string $str) : string

Parameters

$str : string

Return values

string —

indent()

Increase indentation level.


    protected
                    indent() : mixed

Return values

mixed —

initializeEmptyListInsertionMap()


    protected
                    initializeEmptyListInsertionMap() : mixed

Return values

mixed —

initializeFixupMap()

Lazily initializes fixup map.


    protected
                    initializeFixupMap() : mixed

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.

Return values

mixed —

initializeInsertionMap()


    protected
                    initializeInsertionMap() : mixed

Return values

mixed —

initializeLabelCharMap()

Lazily initializes label char map.


    protected
                    initializeLabelCharMap() : mixed

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

Return values

mixed —

initializeListInsertionMap()


    protected
                    initializeListInsertionMap() : mixed

Return values

mixed —

initializeModifierChangeMap()


    protected
                    initializeModifierChangeMap() : mixed

Return values

mixed —

initializeNodeListDiffer()

Lazily initializes node list differ.


    protected
                    initializeNodeListDiffer() : mixed

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

Return values

mixed —

initializeRemovalMap()

Lazily initializes the removal map.


    protected
                    initializeRemovalMap() : mixed

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

Return values

mixed —

isMultiline()

Determine whether a list of nodes uses multiline formatting.


    protected
                    isMultiline(array<string|int, \PhpParser\Node|null> $nodes) : bool

Parameters

$nodes : array<string|int, \PhpParser\Node|null>: Node list

Return values

bool —

Whether multiline formatting is used

outdent()

Decrease indentation level.


    protected
                    outdent() : mixed

Return values

mixed —

p()

Pretty prints a node.


    protected
                    p(Node $node[, bool $parentFormatPreserved = false ]) : string

This method also handles formatting preservation for nodes.

Parameters

$node : Node: Node to be pretty printed
$parentFormatPreserved : bool = false: Whether parent node has preserved formatting

Return values

string —

Pretty printed node

pArray()

Perform a format-preserving pretty print of an array.


    protected
                    pArray(array<string|int, mixed> $nodes, array<string|int, mixed> $origNodes, int &$pos, int $indentAdjustment, string $parentNodeType, string $subNodeName, null|int $fixup) : null|string

Parameters

$nodes : array<string|int, mixed>: New nodes
$origNodes : array<string|int, mixed>: Original nodes
$pos : int: Current token position (updated by reference)
$indentAdjustment : int: Adjustment for indentation
$parentNodeType : string: Type of the containing node.
$subNodeName : string: Name of array subnode.
$fixup : null|int: Fixup information for array item nodes

Return values

null|string —

Result of pretty print or null if cannot preserve formatting

pCommaSeparated()

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


    protected
                    pCommaSeparated(array<string|int, Node> $nodes) : string

Parameters

$nodes : array<string|int, Node>: Array of Nodes to be printed

Return values

string —

Comma separated pretty printed nodes

pCommaSeparatedMultiline()

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


    protected
                    pCommaSeparatedMultiline(array<string|int, Node> $nodes, bool $trailingComma) : string

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

Parameters

$nodes : array<string|int, Node>: Array of Nodes to be printed
$trailingComma : bool: Whether to use a trailing comma

Return values

string —

Comma separated pretty printed nodes in multiline style

pComments()

Prints reformatted text of the passed comments.


    protected
                    pComments(array<string|int, Comment> $comments) : string

Parameters

$comments : array<string|int, Comment>: List of comments

Return values

string —

Reformatted text of comments

pFallback()


    protected
                    pFallback(Node $node) : mixed

Parameters

$node : Node

Return values

mixed —

pFixup()

Print node with fixups.


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

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 : int: Fixup type
$subNode : Node: Subnode to print
$parentClass : string|null: Class of parent node
$subStartPos : int: Original start pos of subnode
$subEndPos : int: Original end pos of subnode

Return values

string —

Result of fixed-up print of subnode

pImplode()

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


    protected
                    pImplode(array<string|int, Node> $nodes[, string $glue = '' ]) : string

Parameters

$nodes : array<string|int, Node>: Array of Nodes to be printed
$glue : string = '': Character to implode with

Return values

string —

Imploded pretty printed nodes

pInfixOp()

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


    protected
                    pInfixOp(string $class, Node $leftNode, string $operatorString, Node $rightNode) : string

Parameters

$class : string: Node class of operator
$leftNode : Node: Left-hand side node
$operatorString : string: String representation of the operator
$rightNode : Node: Right-hand side node

Return values

string —

Pretty printed infix operation

pModifiers()

Print modifiers, including trailing whitespace.


    protected
                    pModifiers(int $modifiers) : string

Parameters

$modifiers : int: Modifier mask to print

Return values

string —

Printed modifiers

pPostfixOp()

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


    protected
                    pPostfixOp(string $class, Node $node, string $operatorString) : string

Parameters

$class : string: Node class of operator
$node : Node: Node
$operatorString : string: String representation of the operator

Return values

string —

Pretty printed postfix operation

pPrec()

Prints an expression node with the least amount of parentheses necessary to preserve the meaning.


    protected
                    pPrec(Node $node, int $parentPrecedence, int $parentAssociativity, int $childPosition) : string

Parameters

$node : Node: Node to pretty print
$parentPrecedence : int: Precedence of the parent operator
$parentAssociativity : int: Associativity of parent operator (-1 is left, 0 is nonassoc, 1 is right)
$childPosition : int: Position of the node relative to the operator (-1 is left, 1 is right)

Return values

string —

The pretty printed node

pPrefixOp()

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


    protected
                    pPrefixOp(string $class, string $operatorString, Node $node) : string

Parameters

$class : string: Node class of operator
$operatorString : string: String representation of the operator
$node : Node: Node

Return values

string —

Pretty printed prefix operation

preprocessNodes()

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


    protected
                    preprocessNodes(array<string|int, Node> $nodes) : mixed

Parameters

$nodes : array<string|int, Node>: Array of nodes

Return values

mixed —

pStmts()

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


    protected
                    pStmts(array<string|int, Node> $nodes[, bool $indent = true ]) : string

Parameters

$nodes : array<string|int, Node>: Array of nodes
$indent : bool = true: Whether to indent the printed nodes

Return values

string —

Pretty printed statements

resetState()

Reset pretty printing state.


    protected
                    resetState() : mixed

Return values

mixed —

safeAppend()

Appends to a string, ensuring whitespace between label characters.


    protected
                    safeAppend(string &$str, string $append) : mixed

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.

Parameters

$str : string
$append : string

Return values

mixed —

setIndentLevel()

Set indentation level


    protected
                    setIndentLevel(int $level) : mixed

Parameters

$level : int: Level in number of spaces

Return values

mixed —

PrettyPrinterAbstract in package Application

Table of Contents

Constants

FIXUP_BRACED_NAME

FIXUP_CALL_LHS

FIXUP_DEREF_LHS

FIXUP_ENCAPSED

FIXUP_PREC_LEFT

FIXUP_PREC_RIGHT

FIXUP_VAR_BRACED_NAME

Properties

$canUseSemicolonNamespaces

$docStringEndToken

$emptyListInsertionMap

$fixupMap

$indentLevel

$insertionMap

$labelCharMap

$listInsertionMap

$modifierChangeMap

$nl

$nodeListDiffer

$options

$origTokens

$precedenceMap

$removalMap

Methods

__construct()

Parameters

Return values

prettyPrint()

Parameters

Return values

prettyPrintExpr()

Parameters

Return values

prettyPrintFile()

Parameters

Return values

printFormatPreserving()

Parameters

Return values

callLhsRequiresParens()

Parameters

Return values

dereferenceLhsRequiresParens()

Parameters

Return values

handleMagicTokens()

Parameters

Return values

indent()

Return values

initializeEmptyListInsertionMap()

Return values

initializeFixupMap()

Return values

initializeInsertionMap()

Return values

initializeLabelCharMap()

Return values

initializeListInsertionMap()

Return values

initializeModifierChangeMap()

Return values

initializeNodeListDiffer()

Return values

initializeRemovalMap()

Return values

isMultiline()

Parameters

Return values

outdent()

Return values

p()

Parameters

Return values

pArray()

Parameters

Return values

PrettyPrinterAbstract
in package

Application