sqllens 1.9.0 → 1.9.1

package/dist/fragment-grammar.d.ts

@@ -35,8 +35,10 @@ export interface FragmentGrammarSpec<P extends Parser> {
     lex?: (text: string) => FragmentLex;
     newLexer: (input: CharStream) => Lexer;
     newParser: (tokens: CommonTokenStream) => P;
+    /** One entry per kind, or several tried in order (tsql's `expression` is its scalar `expression`
+     *  then `search_condition`: the grammar keeps comparisons out of the scalar rule). */
     entries: {
-        readonly [K in FragmentKind]: FragmentEntry<P>;
+        readonly [K in FragmentKind]: FragmentEntry<P> | readonly FragmentEntry<P>[];
     };
     /** The list separator token type (COMMA). A list body (`cteList`/`selectList`) may end with
      *  one: a macro's CTE list often ends `),` because the caller appends more CTEs. */

package/dist/fragment-grammar.js

@@ -51,9 +51,13 @@ function trailingInput(parser) {
 /** Bind a dialect's lexer, parser and fragment entry rules into a `FragmentGrammar`. */
 export function defineFragmentGrammar(spec) {
     const { newLexer, newParser, entries, separator, postParse } = spec;
+    const alternatives = (kind) => {
+        const e = entries[kind];
+        return Array.isArray(e) ? e : [e];
+    };
     /** The entry, then a trailing separator on a list body is consumed rather than left over. */
-    const run = (parser, kind) => {
-        const tree = entries[kind](parser);
+    const run = (parser, entry, kind) => {
+        const tree = entry(parser);
         const input = parser.inputStream;
         if (LIST_KINDS.has(kind) && input.LA(1) === separator && input.LA(2) === AntlrToken.EOF)
             input.consume();
@@ -68,36 +72,53 @@ export function defineFragmentGrammar(spec) {
     return {
         lex,
         parse(slice, kind, bail) {
-            const tokens = new CommonTokenStream(new ListTokenSource([...slice]));
-            const parser = newParser(tokens);
-            const collector = makeErrorCollector();
-            parser.removeErrorListeners();
-            parser.addErrorListener(collector.listener);
-            const sim = parser.interpreter;
-            if (bail) {
-                parser.errorHandler = new BailErrorStrategy();
-                sim.predictionMode = PredictionMode.SLL;
-                let tree;
-                try {
-                    tree = run(parser, kind);
+            // Each alternative gets a fresh parser over the same slice; bail mode returns the first
+            // clean one, LL mode the alternative that got furthest before its first error.
+            let best;
+            let bestAt = -1;
+            for (const entry of alternatives(kind)) {
+                const tokens = new CommonTokenStream(new ListTokenSource([...slice]));
+                const parser = newParser(tokens);
+                const collector = makeErrorCollector();
+                parser.removeErrorListeners();
+                parser.addErrorListener(collector.listener);
+                const sim = parser.interpreter;
+                if (bail) {
+                    parser.errorHandler = new BailErrorStrategy();
+                    sim.predictionMode = PredictionMode.SLL;
+                    let tree;
+                    try {
+                        tree = run(parser, entry, kind);
+                    }
+                    catch {
+                        continue;
+                    }
+                    // A grammar action can report through the listener without throwing (bigquery's
+                    // join-balance check); that is not a clean parse either. Nor is leftover input.
+                    if (collector.diagnostics.length > 0 || trailingInput(parser))
+                        continue;
+                    const post = postParse?.(tree) ?? [];
+                    if (post.length === 0)
+                        return { tree, diagnostics: [] };
+                    continue;
                 }
-                catch {
-                    return undefined;
+                sim.predictionMode = PredictionMode.LL;
+                const tree = run(parser, entry, kind);
+                const trailing = trailingInput(parser);
+                const diagnostics = [
+                    ...collector.diagnostics,
+                    ...(trailing ? [trailing] : []),
+                    ...(postParse?.(tree) ?? []),
+                ];
+                if (diagnostics.length === 0)
+                    return { tree, diagnostics };
+                const at = diagnostics[0].offset ?? Number.MAX_SAFE_INTEGER;
+                if (at > bestAt) {
+                    bestAt = at;
+                    best = { tree, diagnostics };
                 }
-                // A grammar action can report through the listener without throwing (bigquery's
-                // join-balance check); that is not a clean parse either. Nor is leftover input.
-                if (collector.diagnostics.length > 0 || trailingInput(parser))
-                    return undefined;
-                const post = postParse?.(tree) ?? [];
-                return post.length === 0 ? { tree, diagnostics: [] } : undefined;
             }
-            sim.predictionMode = PredictionMode.LL;
-            const tree = run(parser, kind);
-            const trailing = trailingInput(parser);
-            return {
-                tree,
-                diagnostics: [...collector.diagnostics, ...(trailing ? [trailing] : []), ...(postParse?.(tree) ?? [])],
-            };
+            return best;
         },
     };
 }

package/dist/minijinja/parse.js

@@ -275,7 +275,7 @@ function scrubPlaceholderDiagnostics(diags, tagRanges, text, placeholder) {
  * will), so "matches no known shape" is not evidence of invalid SQL (never-wrong). Mutates
  * the regions' `body` field only. Files without a macro region are untouched.
  */
-function reparseMacroBodies(regions, diagnostics, placeholder, dialect) {
+function reparseMacroBodies(regions, diagnostics, placeholder, fragments) {
     const macros = [];
     // Macros can sit under an if/for (a guarded definition); a macro inside a macro body is
     // covered by the outer body's read and not visited on its own.
@@ -291,7 +291,6 @@ function reparseMacroBodies(regions, diagnostics, placeholder, dialect) {
     visit(regions);
     if (macros.length === 0)
         return diagnostics;
-    const fragments = openFragments(placeholder, dialect);
     const bodies = [];
     for (const region of macros) {
         const arm = region.arms[0];
@@ -304,7 +303,7 @@ function reparseMacroBodies(regions, diagnostics, placeholder, dialect) {
         if (body.end <= body.start)
             continue;
         bodies.push(body);
-        const verdict = fragments.verdict([body]);
+        const verdict = fragments().verdict([body]);
         if (verdict)
             region.body = verdict;
     }
@@ -318,7 +317,7 @@ function reparseMacroBodies(regions, diagnostics, placeholder, dialect) {
     }
     if (at < placeholder.length)
         remainder.push({ start: at, end: placeholder.length });
-    const rest = fragments.parse(remainder, ["statement"]);
+    const rest = fragments().parse(remainder, ["statement"]);
     return [...diagnostics.filter((d) => d.offset === undefined), ...(rest?.diagnostics ?? [])];
 }
 /** Insert a hidden WS-shaped token over every gap in the source-ordered stream whose original text
@@ -380,7 +379,7 @@ const DEFAULT_KEYWORD_SHAPE = {
  *      `else` arm, the macro can render to nothing → `nothing`, last.
  * Anything else stays out (never-wrong): a hole with no visible default, a return-only body.
  */
-function macroShapesOf(regions, tags, text, placeholder) {
+function macroShapesOf(regions, tags, text, placeholder, fragments) {
     const out = [];
     const visit = (list) => {
         for (const region of list) {
@@ -399,19 +398,28 @@ function macroShapesOf(regions, tags, text, placeholder) {
                 shapes.push(VERDICT_SHAPE[region.body]);
             else {
                 // A body opening with a hole: `{{ name }}` / `{{ name|default('kw') }}`, `name` one of
-                // the macro's declared parameters (the signature's args are bare identifiers).
+                // the macro's declared parameters. The signature's args are `name` or `name=default`
+                // (the jinja-standard default spelling); the filter default wins over the signature's.
                 const lead = leadingHole(arm.bodySpan, tags, placeholder);
                 const holeText = lead ? text.slice(lead.tagSpan.start, lead.tagSpan.end) : "";
                 const bound = /^\{\{-?\s*([A-Za-z_]\w*)\s*(?:\||-?\}\})/.exec(holeText)?.[1];
-                const params = (open.calls[0]?.args ?? []).map((a) => text.slice(a.span.start, a.span.end).trim());
-                const index = bound === undefined ? -1 : params.indexOf(bound);
-                const fallback = /\|\s*default\(\s*['"](\w+)['"]\s*\)/.exec(holeText)?.[1];
+                const params = (open.calls[0]?.args ?? []).map((a) => signatureParam(text.slice(a.span.start, a.span.end)));
+                const index = bound === undefined ? -1 : params.findIndex((p) => p?.name === bound);
+                const fallback = /\|\s*default\(\s*['"](\w+)['"]\s*\)/.exec(holeText)?.[1] ?? params[index]?.default;
                 if (bound !== undefined && index >= 0) {
                     keywordParam = { name: bound, index, ...(fallback !== undefined ? { default: fallback } : {}) };
                 }
                 const clause = fallback ? DEFAULT_KEYWORD_SHAPE[fallback.toLowerCase()] : undefined;
                 if (clause)
                     shapes.push(clause);
+                // A body that literally opens with the clause keyword (`and {{ c }} = 0`): the shape the
+                // same word resolves to through a hole, provided the rest reads as an expression.
+                if (!lead) {
+                    const led = leadingKeyword(arm.bodySpan, placeholder);
+                    if (led && fragments().verdict([{ start: led.end, end: arm.bodySpan.end }], ["expression"])) {
+                        shapes.push(DEFAULT_KEYWORD_SHAPE[led.word]);
+                    }
+                }
             }
             if ((shapes.length > 0 || keywordParam) && rendersToNothing(arm, placeholder))
                 shapes.push("nothing");
@@ -445,6 +453,22 @@ export function shapesForCall(macro, call) {
     const rest = macro.shapes.filter((s) => s !== "where-clause" && s !== "conjunct");
     return clause ? [clause, ...rest] : rest;
 }
+/** One signature argument, `name` or `name=default` (a quoted string default is unquoted). */
+function signatureParam(argText) {
+    const m = /^\s*([A-Za-z_]\w*)\s*(?:=\s*(.+?))?\s*$/s.exec(argText);
+    if (!m)
+        return undefined;
+    const raw = m[2];
+    const literal = raw === undefined ? undefined : /^(['\"])(.*)\1$/s.exec(raw)?.[2];
+    return { name: m[1], ...(literal !== undefined ? { default: literal } : {}) };
+}
+/** A clause keyword (`and`/`or`/`where`) opening the body, past whitespace and `--` comment lines:
+ *  the word (lowercased) and the offset just past it. */
+function leadingKeyword(body, placeholder) {
+    const slice = placeholder.slice(body.start, body.end);
+    const m = /^(?:\s|--[^\n]*\n)*(and|or|where)\b/i.exec(slice);
+    return m ? { word: m[1].toLowerCase(), end: body.start + m[0].length } : undefined;
+}
 /** The expression tag at the very start of a body (only whitespace, comments and control tags
  *  before it in the placeholder), or undefined when the body opens with SQL. */
 function leadingHole(body, tags, placeholder) {
@@ -555,8 +579,11 @@ function build(text, dialect, provider) {
     // source, CTE list, select list; src/fragment.ts) and its own diagnostics replace whatever
     // the statement parse reported inside that body. The IR and tokens stay the whole-file
     // parse's: the fragment verdict rides the region as `body`.
-    const sqlDiagnostics = reparseMacroBodies(regions, sqlResult.diagnostics, placeholder, dialect);
-    const macros = macroShapesOf(regions, tags, text, placeholder);
+    // One lex of the placeholder, opened on first use, shared by both macro passes.
+    let session;
+    const fragments = () => (session ??= openFragments(placeholder, dialect));
+    const sqlDiagnostics = reparseMacroBodies(regions, sqlResult.diagnostics, placeholder, fragments);
+    const macros = macroShapesOf(regions, tags, text, placeholder, fragments);
     const { diagnostics: scrubbed, bySegment } = scrubPlaceholderDiagnostics(sqlDiagnostics, tagRanges, text, placeholder);
     // Fold the scrubbed SQL diagnostics into the same per-tag map as the jinja ones
     // (Task 10) — a tag's diagnostics are its own jinja parse errors PLUS whatever

package/dist/tsql/parse.js

@@ -83,7 +83,9 @@ export const fragmentGrammar = defineFragmentGrammar({
     separator: TSqlLexer.COMMA,
     entries: {
         statement: (p) => p.tsql_file(),
-        expression: (p) => p.expression(),
+        // T-SQL keeps comparisons out of the scalar `expression` rule (they are `search_condition`
+        // predicates), so an expression body is either.
+        expression: [(p) => p.expression(), (p) => p.search_condition()],
         tableSource: (p) => p.table_source(),
         cteList: separatedList((p) => p.common_table_expression(), TSqlLexer.COMMA),
         selectList: (p) => p.select_list(),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sqllens",
-	"version": "1.9.0",
+	"version": "1.9.1",
 	"description": "A TypeScript SQL parser and static analyzer: parse, resolve names, infer types, and trace column lineage across many SQL dialects (Databricks, T-SQL, Snowflake, BigQuery, Redshift, PostgreSQL, DuckDB, Trino, SQLite, MySQL).",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",