sqllens 1.1.0 → 1.2.0

package/dist/snowflake/behavior.d.ts

@@ -0,0 +1,2 @@
+import type { DialectBehavior } from "../dialect-behavior/behavior.js";
+export declare const snowflakeBehavior: DialectBehavior;

package/dist/snowflake/behavior.js

@@ -0,0 +1,22 @@
+import { acceptsFor } from "../dialect-behavior/coerce-rules.js";
+import { likePatternToRegExp } from "../scope/like-pattern.js";
+import { SIGNATURES } from "../signature/signatures.js";
+import { displayName, fold, foldTableName, matchesSourceKey } from "./fold.js";
+import { snowflakeLiteral, snowflakeParseType, SNOWFLAKE_FUNCTION_RETURNS, snowflakeSpecial } from "./infer.js";
+// Snowflake implicit coercion: VARCHAR containing a number coerces to NUMBER (str->num), no bool<->num.
+const STR_TO_NUM = true;
+const BOOL_NUM = false;
+export const snowflakeBehavior = {
+    fold,
+    displayName,
+    foldTableName,
+    matchesSourceKey,
+    likeMatch: (pattern, value) => likePatternToRegExp(pattern).test(value),
+    literal: snowflakeLiteral,
+    parseType: snowflakeParseType,
+    functions: SNOWFLAKE_FUNCTION_RETURNS,
+    division: "decimal", // Snowflake: 10/3 -> 3.333333, a scaled NUMBER unless a float is involved
+    special: snowflakeSpecial,
+    signatures: SIGNATURES.snowflake,
+    accepts: (argType, paramText) => acceptsFor(snowflakeParseType, STR_TO_NUM, BOOL_NUM, argType, paramText),
+};

package/dist/snowflake/fold.d.ts

@@ -0,0 +1,8 @@
+import { type FoldRule, type IdentKind } from "../ident/fold.js";
+export declare const SNOWFLAKE_FOLD_RULE: FoldRule;
+/** Fold an identifier to its Snowflake identity key. */
+export declare function fold(raw: string, kind?: IdentKind): string;
+/** Presentation twin: strip delimiters, no case change. */
+export declare function displayName(raw: string): string;
+export declare function foldTableName(parts: string[]): string[];
+export declare function matchesSourceKey(key: string, rawPart: string): boolean;

package/dist/snowflake/fold.js

@@ -0,0 +1,25 @@
+// Snowflake identifier folding. The FoldRule plus its bound engine, colocated here because BOTH the
+// upstream lower() and the downstream DialectBehavior need it (the fold rule is the one dialect concern
+// used at two stages). Snowflake unquoted identifiers fold to UPPER; quoted identifiers preserve case
+// (docs.snowflake.com/en/sql-reference/identifiers-syntax); double-quote is the delimiter, doubled to escape.
+import { displayWith, foldWith } from "../ident/fold.js";
+const DOUBLE_QUOTE = ['"', '"'];
+export const SNOWFLAKE_FOLD_RULE = {
+    delimiters: [DOUBLE_QUOTE],
+    unquoted: "upper",
+    quoted: "preserve",
+};
+/** Fold an identifier to its Snowflake identity key. */
+export function fold(raw, kind = "other") {
+    return foldWith(SNOWFLAKE_FOLD_RULE, raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. */
+export function displayName(raw) {
+    return displayWith(SNOWFLAKE_FOLD_RULE, raw);
+}
+export function foldTableName(parts) {
+    return parts.map((p) => fold(p, "table"));
+}
+export function matchesSourceKey(key, rawPart) {
+    return key === fold(rawPart) || key === fold(rawPart, "table");
+}

package/dist/snowflake/index.d.ts

@@ -0,0 +1,7 @@
+import { lower } from "./lower.js";
+import { parseSnowflake } from "./parse.js";
+export declare const snowflake: {
+    parse: typeof parseSnowflake;
+    lower: typeof lower;
+    behavior: import("../dialect-behavior/behavior.js").DialectBehavior;
+};

package/dist/snowflake/index.js

@@ -0,0 +1,10 @@
+// The complete snowflake dialect module: parse + lower (front end) and behavior (semantic knowledge).
+// The registry wires this; to understand everything sqllens does for snowflake, read this folder.
+import { snowflakeBehavior } from "./behavior.js";
+import { lower } from "./lower.js";
+import { parseSnowflake } from "./parse.js";
+export const snowflake = {
+    parse: parseSnowflake,
+    lower,
+    behavior: snowflakeBehavior,
+};

package/dist/{infer/snowflake.d.ts → snowflake/infer.d.ts}

@@ -1,6 +1,6 @@
 import type { Expr } from "../ir/ir.js";
-import type { FnRule } from "./functions.js";
-import { type Type } from "./types.js";
+import type { FnRule } from "../infer/functions.js";
+import { type Type } from "../infer/types.js";
 export declare const SNOWFLAKE_FUNCTION_RETURNS: Record<string, FnRule>;
 /** Snowflake literal forms: '…' / $$…$$ → string; integers are NUMBER(38,0) (int
  *  canonically); non-integers are NUMBER (decimal); 1e3 is approximate (double). */

package/dist/{infer/snowflake.js → snowflake/infer.js}

@@ -1,5 +1,6 @@
-import { commonType, widenSum } from "./coerce.js";
-import { parseType, scalar, UNKNOWN } from "./types.js";
+import { commonType, widenSum } from "../infer/coerce.js";
+import { parseType, scalar, UNKNOWN } from "../infer/types.js";
+import { fold } from "./fold.js";
 // Snowflake inference knowledge — function return types, literal forms, and scalar-type
 // aliases — from the SQL function reference (docs.snowflake.com/en/sql-reference/functions).
 // Same contract as the other dialects: a rule is absent (→ unknown) only when the documented
@@ -557,7 +558,7 @@ export const SNOWFLAKE_ALIASES = {
     bool: "boolean",
 };
 export function snowflakeParseType(text) {
-    return parseType(text, SNOWFLAKE_ALIASES, "snowflake");
+    return parseType(text, SNOWFLAKE_ALIASES, fold);
 }
 /** Pre-registry hook for calls a plain FnRule can't key. `<seq>.NEXTVAL` carries the sequence as a
  *  (variable) qualifier, so no registry key can enumerate it; NEXTVAL always returns NUMBER(38,0)

package/dist/snowflake/lower.js

@@ -3,7 +3,7 @@ import { SnowflakeParser as P } from "../generated/snowflake/SnowflakeParser.js"
 import { keywordCategory, swallowedCategories, swallowedStatements } from "../ir/statement.js";
 import { partSpansOf } from "../ir/part-span.js";
 import { freezeIR } from "../ir/freeze.js";
-import { displayName } from "../ident/fold.js";
+import { displayName } from "./fold.js";
 // ---------------------------------------------------------------------------
 // Lowering — Snowflake (grammars-v4 sql/snowflake fork) CST -> the shared,
 // dialect-neutral IR (src/ir/ir.ts). The semantic layer runs on the IR
@@ -958,15 +958,16 @@ function lowerExpr(node) {
     // expr ! method ( args ) — class-instance method call
     if (hasDirectToken(node, P.BANG)) {
         const method = directChildrenOfRule(node, P.RULE_id_)[0];
-        const args = [
-            ...exprListExprs(node).map(lowerExpr),
-            ...directChildrenOfRule(node, P.RULE_param_assoc_list).flatMap(paramAssocValues),
-        ];
+        const positional = exprListExprs(node).map(lowerExpr);
+        const paramAssoc = directChildrenOfRule(node, P.RULE_param_assoc_list).flatMap(paramAssocValues);
         const base = exprs[0] ? lowerExpr(exprs[0]) : otherExpr(node);
+        const args = [base, ...positional, ...paramAssoc.map((v) => v.arg)];
+        const argNames = [undefined, ...positional.map(() => undefined), ...paramAssoc.map((v) => v.name)];
         return {
             kind: "function",
             name: method ? method.getText() : "",
-            args: [base, ...args],
+            args,
+            ...(argNames.some((n) => n !== undefined) ? { argNames } : {}),
             aggregate: false,
             distinct: false,
             cst: node,
@@ -1236,7 +1237,7 @@ function lowerFunctionCall(node) {
     const agg = directChildrenOfRule(node, P.RULE_aggregate_function)[0];
     if (agg) {
         const id = directChildrenOfRule(agg, P.RULE_id_)[0];
-        const name = (id ? displayName(id.getText(), "snowflake") : (leftmostToken(agg) ?? "")).toLowerCase();
+        const name = (id ? displayName(id.getText()) : (leftmostToken(agg) ?? "")).toLowerCase();
         const args = [
             ...exprListExprs(agg).map(lowerExpr),
             ...directChildrenOfRule(agg, P.RULE_expr).map(lowerExpr),
@@ -1252,40 +1253,79 @@ function lowerFunctionCall(node) {
             cst: node,
         };
     }
+    // EXTRACT LR_BRACKET (id_ | string) (FROM | COMMA) expr RR_BRACKET: the date-part operand is an
+    // id_/string child, not an expr, so the generic collection below drops it and every
+    // EXTRACT(part FROM ts) call under-counts to one argument (a wrong-arity false positive on valid
+    // SQL once the arity checker trusts the generated signatures). Lowered as a literal, never a
+    // column ref: a date part must not join name resolution.
+    if (hasTokenShallow(node, P.EXTRACT)) {
+        const part = directChildrenOfRule(node, P.RULE_id_)[0] ?? directChildrenOfRule(node, P.RULE_string)[0];
+        const partArgs = part ? [{ kind: "literal", text: part.getText(), cst: part }] : [];
+        return {
+            kind: "function",
+            name: "extract",
+            args: [...partArgs, ...directChildrenOfRule(node, P.RULE_expr).map(lowerExpr)],
+            aggregate: false,
+            distinct: false,
+            cst: node,
+        };
+    }
     const name = functionName(node);
-    const args = [
+    const positional = [
         ...exprListExprs(node).map(lowerExpr),
         ...directChildrenOfRule(node, P.RULE_expr).map(lowerExpr),
-        ...directChildrenOfRule(node, P.RULE_param_assoc_list).flatMap(paramAssocValues),
-        // the object_name(func_arg_list) alternative — positional exprs and named-arg values
-        // (STAR / stage / spread / TYPE args carry no expr payload and add nothing here).
-        // Also the SLL-surgery wave's home for plain f(args) calls (2026-07-03).
-        ...directChildrenOfRule(node, P.RULE_func_arg_list).flatMap(funcArgValues),
+    ];
+    const paramAssoc = directChildrenOfRule(node, P.RULE_param_assoc_list).flatMap(paramAssocValues);
+    // the object_name(func_arg_list) alternative — positional exprs and named-arg values
+    // (STAR / stage / spread / TYPE args carry no expr payload and add nothing here).
+    // Also the SLL-surgery wave's home for plain f(args) calls (2026-07-03).
+    const funcArg = directChildrenOfRule(node, P.RULE_func_arg_list).flatMap(funcArgValues);
+    const args = [...positional, ...paramAssoc.map((v) => v.arg), ...funcArg.map((v) => v.arg)];
+    const argNames = [
+        ...positional.map(() => undefined),
+        ...paramAssoc.map((v) => v.name),
+        ...funcArg.map((v) => v.name),
     ];
     return {
         kind: "function",
         name: name.toLowerCase(),
         args,
+        // Named-argument invocation `fn(name => value)`: the per-arg names make the call
+        // conservation-visible and let the arity checker's named-arg bypass fire (a named call's
+        // positional count says nothing about the documented positional signature).
+        ...(argNames.some((n) => n !== undefined) ? { argNames } : {}),
         aggregate: AGGREGATES.has(name.toLowerCase()),
         distinct: hasTokenShallow(node, P.DISTINCT),
         cst: node,
     };
 }
+/** One func_arg's lowered value plus its `name =>` parameter name (undefined for a plain positional
+ *  expr). STAR / stage / spread / TYPE / TABLE(...) args carry no expr payload and are skipped. */
 function funcArgValues(list) {
     return directChildrenOfRule(list, P.RULE_func_arg).flatMap((fa) => {
         const e = directChildrenOfRule(fa, P.RULE_expr)[0];
         if (e)
-            return [lowerExpr(e)];
+            return [{ arg: lowerExpr(e), name: undefined }];
         const pa = directChildrenOfRule(fa, P.RULE_param_assoc)[0];
-        const pe = pa ? directChildrenOfRule(pa, P.RULE_expr)[0] : undefined;
-        return pe ? [lowerExpr(pe)] : [];
+        const one = pa ? oneParamAssoc(pa) : undefined;
+        return one ? [one] : [];
     });
 }
+/** param_assoc_list: every param_assoc child, each lowered via oneParamAssoc. */
 function paramAssocValues(list) {
     return directChildrenOfRule(list, P.RULE_param_assoc)
-        .map((pa) => directChildrenOfRule(pa, P.RULE_expr)[0])
-        .filter((e) => e !== undefined)
-        .map(lowerExpr);
+        .map(oneParamAssoc)
+        .filter((v) => v !== undefined);
+}
+/** param_assoc: `(id_ | FILE_FORMAT | PATTERN | LIMIT) ASSOC expr`; the name is the id_ rule when
+ *  present, else the leading keyword token itself. */
+function oneParamAssoc(pa) {
+    const e = directChildrenOfRule(pa, P.RULE_expr)[0];
+    if (!e)
+        return undefined;
+    const id = directChildrenOfRule(pa, P.RULE_id_)[0];
+    const name = id ? id.getText() : leftmostToken(pa);
+    return { arg: lowerExpr(e), name };
 }
 function functionName(node) {
     const obj = directChildrenOfRule(node, P.RULE_object_name)[0];

package/dist/snowflake/signatures.generated.d.ts

@@ -0,0 +1,6 @@
+import type { FnSignature } from "../signature/signatures.js";
+/** The merged function-signature table for snowflake: curated overrides folded over the harvested
+ *  doc-derived long tail (overrides win by key, replacing the whole overload set), keyed by
+ *  lowercased name. Each name maps to an ORDERED overload set - a name with one documented shape
+ *  is a one-element array. `origin` says which layer produced the set. */
+export declare const SNOWFLAKE_SIGNATURES: Record<string, FnSignature[]>;