rector-src/src/PhpParser/Node/AssignAndBinaryMap.php at 5de759f9d4a536df9b3756d4e2cfdbd10eb3a246 · rectorphp/rector-src · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
<?php

declare(strict_types=1);

namespace Rector\PhpParser\Node;

use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\AssignOp;
use PhpParser\Node\Expr\AssignOp\BitwiseAnd as AssignBitwiseAnd;
use PhpParser\Node\Expr\AssignOp\BitwiseOr as AssignBitwiseOr;
use PhpParser\Node\Expr\AssignOp\BitwiseXor as AssignBitwiseXor;
use PhpParser\Node\Expr\AssignOp\Concat as AssignConcat;
use PhpParser\Node\Expr\AssignOp\Div as AssignDiv;
use PhpParser\Node\Expr\AssignOp\Minus as AssignMinus;
use PhpParser\Node\Expr\AssignOp\Mod as AssignMod;
use PhpParser\Node\Expr\AssignOp\Mul as AssignMul;
use PhpParser\Node\Expr\AssignOp\Plus as AssignPlus;
use PhpParser\Node\Expr\AssignOp\Pow as AssignPow;
use PhpParser\Node\Expr\AssignOp\ShiftLeft as AssignShiftLeft;
use PhpParser\Node\Expr\AssignOp\ShiftRight as AssignShiftRight;
use PhpParser\Node\Expr\BinaryOp;
use PhpParser\Node\Expr\BinaryOp\BitwiseAnd;
use PhpParser\Node\Expr\BinaryOp\BitwiseOr;
use PhpParser\Node\Expr\BinaryOp\BitwiseXor;
use PhpParser\Node\Expr\BinaryOp\Concat;
use PhpParser\Node\Expr\BinaryOp\Div;
use PhpParser\Node\Expr\BinaryOp\Equal;
use PhpParser\Node\Expr\BinaryOp\Greater;
use PhpParser\Node\Expr\BinaryOp\GreaterOrEqual;
use PhpParser\Node\Expr\BinaryOp\Identical;
use PhpParser\Node\Expr\BinaryOp\Minus;
use PhpParser\Node\Expr\BinaryOp\Mod;
use PhpParser\Node\Expr\BinaryOp\Mul;
use PhpParser\Node\Expr\BinaryOp\NotEqual;
use PhpParser\Node\Expr\BinaryOp\NotIdentical;
use PhpParser\Node\Expr\BinaryOp\Plus;
use PhpParser\Node\Expr\BinaryOp\Pow;
use PhpParser\Node\Expr\BinaryOp\ShiftLeft;
use PhpParser\Node\Expr\BinaryOp\ShiftRight;
use PhpParser\Node\Expr\BinaryOp\Smaller;
use PhpParser\Node\Expr\BinaryOp\SmallerOrEqual;
use PhpParser\Node\Expr\BooleanNot;
use PhpParser\Node\Expr\Cast\Bool_;
use Rector\NodeTypeResolver\NodeTypeResolver;

final class AssignAndBinaryMap
{
    /**
     * @var array<class-string<BinaryOp>, class-string<BinaryOp>>
     */
    private const array BINARY_OP_TO_INVERSE_CLASSES = [
        Identical::class => NotIdentical::class,
        NotIdentical::class => Identical::class,
        Equal::class => NotEqual::class,
        NotEqual::class => Equal::class,
        Greater::class => SmallerOrEqual::class,
        Smaller::class => GreaterOrEqual::class,
        GreaterOrEqual::class => Smaller::class,
        SmallerOrEqual::class => Greater::class,
    ];

    /**
     * @var array<class-string<AssignOp>, class-string<BinaryOp>>
     */
    private const array ASSIGN_OP_TO_BINARY_OP_CLASSES = [
        AssignBitwiseOr::class => BitwiseOr::class,
        AssignBitwiseAnd::class => BitwiseAnd::class,
        AssignBitwiseXor::class => BitwiseXor::class,
        AssignPlus::class => Plus::class,
        AssignDiv::class => Div::class,
        AssignMul::class => Mul::class,
        AssignMinus::class => Minus::class,
        AssignConcat::class => Concat::class,
        AssignPow::class => Pow::class,
        AssignMod::class => Mod::class,
        AssignShiftLeft::class => ShiftLeft::class,
        AssignShiftRight::class => ShiftRight::class,
    ];

    /**
     * @var array<class-string<BinaryOp>, class-string<AssignOp>>
     */
    private array $binaryOpToAssignClasses;

    public function __construct(
        private readonly NodeTypeResolver $nodeTypeResolver
    ) {
        /** @var array<class-string<BinaryOp>, class-string<AssignOp>> $binaryClassesToAssignOp */
        $binaryClassesToAssignOp = array_flip(self::ASSIGN_OP_TO_BINARY_OP_CLASSES);
        $this->binaryOpToAssignClasses = $binaryClassesToAssignOp;
    }

    /**
     * @return class-string<BinaryOp|AssignOp>|null
     */
    public function getAlternative(Node $node): ?string
    {
        $nodeClass = $node::class;

        if ($node instanceof AssignOp) {
            return self::ASSIGN_OP_TO_BINARY_OP_CLASSES[$nodeClass] ?? null;
        }

        if ($node instanceof BinaryOp) {
            return $this->binaryOpToAssignClasses[$nodeClass] ?? null;
        }

        return null;
    }

    /**
     * @return class-string<BinaryOp>|null
     */
    public function getInversed(BinaryOp $binaryOp): ?string
    {
        $nodeClass = $binaryOp::class;
        return self::BINARY_OP_TO_INVERSE_CLASSES[$nodeClass] ?? null;
    }

    public function getTruthyExpr(Expr $expr): Expr
    {
        if ($expr instanceof Bool_) {
            return $expr;
        }

        if ($expr instanceof BooleanNot) {
            return $expr;
        }

        $exprType = $this->nodeTypeResolver->getType($expr);
        // $type = $scope->getType($expr);
        if ($exprType->isBoolean()->yes()) {
            return $expr;
        }

        return new Bool_($expr);
    }
}