Function hasUnmatchedOpenParen

packages/queryLanguage/src/tokens.ts:345–419

* Checks if we're currently inside a ParenExpr by looking backwards in the input * to count unmatched opening parens that likely started a ParenExpr. * * We only consider a '(' as a ParenExpr start if it's preceded by whitespace or * start-of-input, since "test()" has a '(' that's part of a word

(input: InputStream)

 * Handles escaped characters (backslash followed by any character).
 */
function hasUnmatchedOpenParen(input: InputStream): boolean {
    // Count parens backwards from current position
    let depth = 0;
    let offset = -1;

    // Look backwards up to 1000 characters (reasonable limit)
    while (offset >= -1000) {
        const ch = input.peek(offset);
        if (ch === EOF) {
            // Reached start of input - if we have negative depth, there's an unmatched '('
            return depth < 0;
        }

        // Check if this character is escaped (preceded by backslash)
        // Note: we need to be careful about escaped backslashes (\\)
        // For simplicity, if we see a backslash immediately before, skip this char
        const prevCh = input.peek(offset - 1);
        if (prevCh === 92 /* backslash */) {
            // Check if the backslash itself is escaped
            const prevPrevCh = input.peek(offset - 2);
            if (prevPrevCh !== 92) {
                // Single backslash - this char is escaped, skip it
                offset--;
                continue;
            }
            // Double backslash - the backslash is escaped, so current char is not
        }

        if (ch === CLOSE_PAREN) {
            depth++;
        } else if (ch === OPEN_PAREN) {
            // Check what's before this '('
            const beforeParen = input.peek(offset - 1);

            // A '(' starts a ParenExpr if it's preceded by:
            // - EOF or whitespace (e.g., "(hello)" or "test (hello)")
            // - '-' for negation (e.g., "-(hello)")
            // - ':' for prefix values (e.g., "repo:(foo or bar)")
            const isDefinitelyParenExprStart =
                beforeParen === EOF ||
                isWhitespace(beforeParen) ||
                beforeParen === DASH ||
                beforeParen === COLON;

            // Special case: '(' preceded by '(' could be nested ParenExprs like "((hello))"
            // BUT it could also be part of a word like "test((nested))"
            // To distinguish: if prev is '(', check what's before THAT '('
            let isParenExprStart = isDefinitelyParenExprStart;
            if (!isParenExprStart && beforeParen === OPEN_PAREN) {
                // Check what's before the previous '('
                const prevPrevCh = input.peek(offset - 2);
                // Only count as ParenExpr if the preceding '(' is also at a token boundary
                isParenExprStart =
                    prevPrevCh === EOF ||
                    isWhitespace(prevPrevCh) ||
                    prevPrevCh === DASH ||
                    prevPrevCh === COLON;
            }