Function visitBinaryExpression

test/fixtures/snapshot/typescript.js:94792–94861

(node, valueIsDiscarded)

            }
        }
        function visitBinaryExpression(node, valueIsDiscarded) {
            if (ts.isDestructuringAssignment(node)) {
                var savedPendingExpressions = pendingExpressions;
                pendingExpressions = undefined;
                node = factory.updateBinaryExpression(node, ts.visitNode(node.left, visitorDestructuringTarget), node.operatorToken, ts.visitNode(node.right, visitor));
                var expr = ts.some(pendingExpressions) ?
                    factory.inlineExpressions(ts.compact(__spreadArray(__spreadArray([], pendingExpressions, true), [node], false))) :
                    node;
                pendingExpressions = savedPendingExpressions;
                return expr;
            }
            if (ts.isAssignmentExpression(node)) {
                if (shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifierPropertyAccessExpression(node.left)) {
                    var info = accessPrivateIdentifier(node.left.name);
                    if (info) {
                        return ts.setTextRange(ts.setOriginalNode(createPrivateIdentifierAssignment(info, node.left.expression, node.right, node.operatorToken.kind), node), node);
                    }
                }
                else if (shouldTransformSuperInStaticInitializers &&
                    ts.isSuperProperty(node.left) &&
                    currentStaticPropertyDeclarationOrStaticBlock &&
                    currentClassLexicalEnvironment) {
                    var classConstructor = currentClassLexicalEnvironment.classConstructor, superClassReference = currentClassLexicalEnvironment.superClassReference, facts = currentClassLexicalEnvironment.facts;
                    if (facts & 1 /* ClassFacts.ClassWasDecorated */) {
                        return factory.updateBinaryExpression(node, visitInvalidSuperProperty(node.left), node.operatorToken, ts.visitNode(node.right, visitor, ts.isExpression));
                    }
                    if (classConstructor && superClassReference) {
                        var setterName = ts.isElementAccessExpression(node.left) ? ts.visitNode(node.left.argumentExpression, visitor, ts.isExpression) :
                            ts.isIdentifier(node.left.name) ? factory.createStringLiteralFromNode(node.left.name) :
                                undefined;
                        if (setterName) {
                            // converts `super.x = 1` into `(Reflect.set(_baseTemp, "x", _a = 1, _classTemp), _a)`
                            // converts `super[f()] = 1` into `(Reflect.set(_baseTemp, f(), _a = 1, _classTemp), _a)`
                            // converts `super.x += 1` into `(Reflect.set(_baseTemp, "x", _a = Reflect.get(_baseTemp, "x", _classtemp) + 1, _classTemp), _a)`
                            // converts `super[f()] += 1` into `(Reflect.set(_baseTemp, _a = f(), _b = Reflect.get(_baseTemp, _a, _classtemp) + 1, _classTemp), _b)`
                            var expression = ts.visitNode(node.right, visitor, ts.isExpression);
                            if (ts.isCompoundAssignment(node.operatorToken.kind)) {
                                var getterName = setterName;
                                if (!ts.isSimpleInlineableExpression(setterName)) {
                                    getterName = factory.createTempVariable(hoistVariableDeclaration);
                                    setterName = factory.createAssignment(getterName, setterName);
                                }
                                var superPropertyGet = factory.createReflectGetCall(superClassReference, getterName, classConstructor);
                                ts.setOriginalNode(superPropertyGet, node.left);
                                ts.setTextRange(superPropertyGet, node.left);
                                expression = factory.createBinaryExpression(superPropertyGet, ts.getNonAssignmentOperatorForCompoundAssignment(node.operatorToken.kind), expression);
                                ts.setTextRange(expression, node);
                            }
                            var temp = valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration);
                            if (temp) {
                                expression = factory.createAssignment(temp, expression);
                                ts.setTextRange(temp, node);
                            }
                            expression = factory.createReflectSetCall(superClassReference, setterName, expression, classConstructor);
                            ts.setOriginalNode(expression, node);
                            ts.setTextRange(expression, node);
                            if (temp) {
                                expression = factory.createComma(expression, temp);