Function isInExpressionContext

test/fixtures/snapshot/typescript.js:16246–16296

(node)

    }
    ts.isExpressionNode = isExpressionNode;
    function isInExpressionContext(node) {
        var parent = node.parent;
        switch (parent.kind) {
            case 254 /* SyntaxKind.VariableDeclaration */:
            case 164 /* SyntaxKind.Parameter */:
            case 167 /* SyntaxKind.PropertyDeclaration */:
            case 166 /* SyntaxKind.PropertySignature */:
            case 299 /* SyntaxKind.EnumMember */:
            case 296 /* SyntaxKind.PropertyAssignment */:
            case 203 /* SyntaxKind.BindingElement */:
                return parent.initializer === node;
            case 238 /* SyntaxKind.ExpressionStatement */:
            case 239 /* SyntaxKind.IfStatement */:
            case 240 /* SyntaxKind.DoStatement */:
            case 241 /* SyntaxKind.WhileStatement */:
            case 247 /* SyntaxKind.ReturnStatement */:
            case 248 /* SyntaxKind.WithStatement */:
            case 249 /* SyntaxKind.SwitchStatement */:
            case 289 /* SyntaxKind.CaseClause */:
            case 251 /* SyntaxKind.ThrowStatement */:
                return parent.expression === node;
            case 242 /* SyntaxKind.ForStatement */:
                var forStatement = parent;
                return (forStatement.initializer === node && forStatement.initializer.kind !== 255 /* SyntaxKind.VariableDeclarationList */) ||
                    forStatement.condition === node ||
                    forStatement.incrementor === node;
            case 243 /* SyntaxKind.ForInStatement */:
            case 244 /* SyntaxKind.ForOfStatement */:
                var forInStatement = parent;
                return (forInStatement.initializer === node && forInStatement.initializer.kind !== 255 /* SyntaxKind.VariableDeclarationList */) ||
                    forInStatement.expression === node;
            case 211 /* SyntaxKind.TypeAssertionExpression */:
            case 229 /* SyntaxKind.AsExpression */:
                return node === parent.expression;
            case 233 /* SyntaxKind.TemplateSpan */:
                return node === parent.expression;
            case 162 /* SyntaxKind.ComputedPropertyName */:
                return node === parent.expression;
            case 165 /* SyntaxKind.Decorator */:
            case 288 /* SyntaxKind.JsxExpression */:
            case 287 /* SyntaxKind.JsxSpreadAttribute */:
            case 298 /* SyntaxKind.SpreadAssignment */:
                return true;
            case 228 /* SyntaxKind.ExpressionWithTypeArguments */:
                return parent.expression === node && !isPartOfTypeNode(parent);
            case 297 /* SyntaxKind.ShorthandPropertyAssignment */:
                return parent.objectAssignmentInitializer === node;
            default:
                return isExpressionNode(parent);
        }
    }
    ts.isInExpressionContext = isInExpressionContext;
    function isPartOfTypeQuery(node) {
        while (node.kind === 161 /* SyntaxKind.QualifiedName */ || node.kind === 79 /* SyntaxKind.Identifier */) {