Function getContextualTypeForBinaryOperand

test/fixtures/snapshot/typescript.js:72607–72632

(node, contextFlags)

            return undefined;
        }
        function getContextualTypeForBinaryOperand(node, contextFlags) {
            var binaryExpression = node.parent;
            var left = binaryExpression.left, operatorToken = binaryExpression.operatorToken, right = binaryExpression.right;
            switch (operatorToken.kind) {
                case 63 /* SyntaxKind.EqualsToken */:
                case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
                case 75 /* SyntaxKind.BarBarEqualsToken */:
                case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
                    return node === right ? getContextualTypeForAssignmentDeclaration(binaryExpression) : undefined;
                case 56 /* SyntaxKind.BarBarToken */:
                case 60 /* SyntaxKind.QuestionQuestionToken */:
                    // When an || expression has a contextual type, the operands are contextually typed by that type, except
                    // when that type originates in a binding pattern, the right operand is contextually typed by the type of
                    // the left operand. When an || expression has no contextual type, the right operand is contextually typed
                    // by the type of the left operand, except for the special case of Javascript declarations of the form
                    // `namespace.prop = namespace.prop || {}`.
                    var type = getContextualType(binaryExpression, contextFlags);
                    return node === right && (type && type.pattern || !type && !ts.isDefaultedExpandoInitializer(binaryExpression)) ?
                        getTypeOfExpression(left) : type;
                case 55 /* SyntaxKind.AmpersandAmpersandToken */:
                case 27 /* SyntaxKind.CommaToken */:
                    return node === right ? getContextualType(binaryExpression, contextFlags) : undefined;
                default:
                    return undefined;
            }
        }
        /**
         * Try to find a resolved symbol for an expression without also resolving its type, as
         * getSymbolAtLocation would (as that could be reentrant into contextual typing)