PrettyPrinterAbstract::$precedenceMap

@var array<class-string, array{int, int, int}>

Type: precedenceMap

File

vendor/nikic/php-parser/lib/PhpParser/PrettyPrinterAbstract.php, line 37

Class

PrettyPrinterAbstract

Namespace

PhpParser

Code

protected array $precedenceMap = [
    // [precedence, precedenceLHS, precedenceRHS]
    // Where the latter two are the precedences to use for the LHS and RHS of a binary operator,
    // where 1 is added to one of the sides depending on associativity. This information is not
    // used for unary operators and set to -1.
Expr\Clone_::class => [
        -10,
        0,
        1,
    ],
    BinaryOp\Pow::class => [
        0,
        0,
        1,
    ],
    Expr\BitwiseNot::class => [
        10,
        -1,
        -1,
    ],
    Expr\UnaryPlus::class => [
        10,
        -1,
        -1,
    ],
    Expr\UnaryMinus::class => [
        10,
        -1,
        -1,
    ],
    Cast\Int_::class => [
        10,
        -1,
        -1,
    ],
    Cast\Double::class => [
        10,
        -1,
        -1,
    ],
    Cast\String_::class => [
        10,
        -1,
        -1,
    ],
    Cast\Array_::class => [
        10,
        -1,
        -1,
    ],
    Cast\Object_::class => [
        10,
        -1,
        -1,
    ],
    Cast\Bool_::class => [
        10,
        -1,
        -1,
    ],
    Cast\Unset_::class => [
        10,
        -1,
        -1,
    ],
    Expr\ErrorSuppress::class => [
        10,
        -1,
        -1,
    ],
    Expr\Instanceof_::class => [
        20,
        -1,
        -1,
    ],
    Expr\BooleanNot::class => [
        30,
        -1,
        -1,
    ],
    BinaryOp\Mul::class => [
        40,
        41,
        40,
    ],
    BinaryOp\Div::class => [
        40,
        41,
        40,
    ],
    BinaryOp\Mod::class => [
        40,
        41,
        40,
    ],
    BinaryOp\Plus::class => [
        50,
        51,
        50,
    ],
    BinaryOp\Minus::class => [
        50,
        51,
        50,
    ],
    BinaryOp\Concat::class => [
        50,
        51,
        50,
    ],
    BinaryOp\ShiftLeft::class => [
        60,
        61,
        60,
    ],
    BinaryOp\ShiftRight::class => [
        60,
        61,
        60,
    ],
    BinaryOp\Smaller::class => [
        70,
        70,
        70,
    ],
    BinaryOp\SmallerOrEqual::class => [
        70,
        70,
        70,
    ],
    BinaryOp\Greater::class => [
        70,
        70,
        70,
    ],
    BinaryOp\GreaterOrEqual::class => [
        70,
        70,
        70,
    ],
    BinaryOp\Equal::class => [
        80,
        80,
        80,
    ],
    BinaryOp\NotEqual::class => [
        80,
        80,
        80,
    ],
    BinaryOp\Identical::class => [
        80,
        80,
        80,
    ],
    BinaryOp\NotIdentical::class => [
        80,
        80,
        80,
    ],
    BinaryOp\Spaceship::class => [
        80,
        80,
        80,
    ],
    BinaryOp\BitwiseAnd::class => [
        90,
        91,
        90,
    ],
    BinaryOp\BitwiseXor::class => [
        100,
        101,
        100,
    ],
    BinaryOp\BitwiseOr::class => [
        110,
        111,
        110,
    ],
    BinaryOp\BooleanAnd::class => [
        120,
        121,
        120,
    ],
    BinaryOp\BooleanOr::class => [
        130,
        131,
        130,
    ],
    BinaryOp\Coalesce::class => [
        140,
        140,
        141,
    ],
    Expr\Ternary::class => [
        150,
        150,
        150,
    ],
    Expr\Assign::class => [
        160,
        -1,
        -1,
    ],
    Expr\AssignRef::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\Plus::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\Minus::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\Mul::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\Div::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\Concat::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\Mod::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\BitwiseAnd::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\BitwiseOr::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\BitwiseXor::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\ShiftLeft::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\ShiftRight::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\Pow::class => [
        160,
        -1,
        -1,
    ],
    AssignOp\Coalesce::class => [
        160,
        -1,
        -1,
    ],
    Expr\YieldFrom::class => [
        170,
        -1,
        -1,
    ],
    Expr\Yield_::class => [
        175,
        -1,
        -1,
    ],
    Expr\Print_::class => [
        180,
        -1,
        -1,
    ],
    BinaryOp\LogicalAnd::class => [
        190,
        191,
        190,
    ],
    BinaryOp\LogicalXor::class => [
        200,
        201,
        200,
    ],
    BinaryOp\LogicalOr::class => [
        210,
        211,
        210,
    ],
    Expr\Include_::class => [
        220,
        -1,
        -1,
    ],
    Expr\ArrowFunction::class => [
        230,
        -1,
        -1,
    ],
    Expr\Throw_::class => [
        240,
        -1,
        -1,
    ],
];