sqllens 1.3.0 → 1.4.0

package/dist/completion/complete.js

@@ -130,20 +130,29 @@ function collect(doc, offset, schema) {
 function templateCompletions(slot, schema) {
     if (!(schema instanceof DefaultTemplateProvider))
         return [];
-    return schema.templateCandidates(slot.callee, slot.argIndex, slot.packageName).map((c) => ({
+    return schema.templateCandidates(slot.call, slot.argIndex).map((c) => ({
         label: c.label,
         kind: "template",
         ...(c.detail !== undefined ? { detail: c.detail } : {}),
     }));
 }
-/** The walk's caret token index: the first default-channel token whose `.start >= offset`; for an
- *  end-of-input caret that is the EOF sentinel's index (last entry). Mirrors Task 10's tests' caret
- *  helper. `toks` is the document's own token stream (doc coordinates) with the EOF sentinel appended. */
+/** The walk's caret token index. Two rules, in order (anvil 2026-07-15; antlr4-c3's own caret
+ *  convention):
+ *   1. the token being TYPED — a word-like token whose span CONTAINS the caret (start < offset <=
+ *      end). A caret at the end of `ifn` completes `ifn`; it does not mean the slot is filled.
+ *      Word-like only: punctuation is never partially typed, so `abs(|` keeps rule 2.
+ *   2. between tokens — the first default-channel token whose `.start >= offset`; for an
+ *      end-of-input caret that is the EOF sentinel's index (last entry).
+ *  `toks` is the document's own token stream (doc coordinates) with the EOF sentinel appended.
+ *  Source order makes one pass sufficient: a containing token starts before any `.start >= offset`
+ *  token, so rule 1 fires first whenever it applies. */
 function caretTokenIndex(toks, offset) {
     for (let i = 0; i < toks.length; i++) {
         const t = toks[i];
         if (!t || t.channel !== Token.DEFAULT_CHANNEL)
             continue;
+        if (/^\w/.test(t.text) && t.start < offset && offset <= t.start + t.text.length)
+            return i;
         if (t.start >= offset)
             return i;
     }

package/dist/completion/jinja-slot.d.ts

@@ -1,3 +1,4 @@
+import type { TemplateCall } from "../qualify/template-provider.js";
 import type { TagNode } from "../minijinja/tag-ast.js";
 /** Where the caret sits inside a jinja call tag. NEUTRAL, the callee is a bare string; the dbt
  *  meaning of the slot (ref arg0 = a model) is the consumer's to apply. */
@@ -6,6 +7,11 @@ export interface JinjaSlot {
     callee: string;
     /** Dotted package before the callee (`dbt_utils` in `dbt_utils.star(...)`). */
     packageName?: string;
+    /** The WHOLE parsed call (issue #37): name, packageParts and every sibling arg's literal value
+     *  (null where computed) — the same TemplateCall shape every provider method receives. A slot's
+     *  candidates can depend on the other args (source('raw', '|')'s candidates are the tables OF
+     *  raw), so the provider callback gets the call, not just the callee name. */
+    call: TemplateCall;
     /** 0-based index of the positional arg the caret is in. The callee-name slot (caret still in the
      *  callee identifier, `{{ my_mac|`) is `-1`. */
     argIndex: number;

package/dist/completion/jinja-slot.js

@@ -18,6 +18,7 @@
 // Reuses the parse: it reads the tags the document already produced, never re-parses.
 // Total: returns undefined off any jinja completion slot; never throws.
 // ---------------------------------------------------------------------------
+import { callOf } from "../minijinja/apply-tags.js";
 /**
  * The jinja completion slot at `offset`, or undefined when the caret is not in a completable jinja
  * position. `tags` is `parseTemplated(...).tags` (or `doc.templated.tags`); `text` is the document
@@ -82,7 +83,10 @@ function macroHit(c) {
 }
 /** The slot for a caret inside a resolved call: the callee name, or the positional argument. */
 function slotFromCall(c, text, offset) {
-    const base = { callee: c.name, ...(c.packageName !== undefined ? { packageName: c.packageName } : {}) };
+    // The whole call rides the slot (#37): callOf reads name + literal args off the source text,
+    // the same extraction apply-tags feeds the provider everywhere else.
+    const call = callOf({ name: c.name, nameSpan: c.nameSpan, args: c.args, ...(c.packageName !== undefined ? { packageName: c.packageName } : {}) }, text);
+    const base = { callee: c.name, call, ...(c.packageName !== undefined ? { packageName: c.packageName } : {}) };
     // Callee-name slot: the caret is still within (or right at the end of) the callee identifier,
     // before the open paren, the user is typing the macro name itself.
     if (offset <= c.nameSpan.end) {
@@ -122,7 +126,8 @@ function bareCalleeSlot(tags, text, offset) {
     const m = /^\s*([A-Za-z_]\w*)$/.exec(before);
     if (!m)
         return undefined;
-    return { callee: m[1], argIndex: -1, prefix: m[1], incomplete: true };
+    // No parsed call exists yet (`{{ re`) — the slot's call is the bare callee with no args.
+    return { callee: m[1], call: { name: m[1], args: [] }, argIndex: -1, prefix: m[1], incomplete: true };
 }
 /** Drop a single leading quote from a partial string arg (`'cu` -> `cu`) so the prefix is the value
  *  the consumer filters by. Leaves a non-string arg untouched. */

package/dist/minijinja/apply-tags.js

@@ -17,8 +17,9 @@
 // TemplateProvider for a call's relation (`provider.relationOf`) and carries no ref/source vocabulary
 // itself. The NEUTRAL provider answers nothing, so a bare parse leaves calls opaque; a
 // DbtTemplateProvider names ref/source. Naming is never-wrong: a resolved name comes from the call's
-// literal args, and a call whose relation the provider does not resolve keeps its placeholder name and
-// stays opaque. We NEVER fabricate a name.
+// literal args, and a call whose relation the provider does not resolve takes the RAW TAG TEXT as its
+// name ({{ ref('m') }} verbatim) and stays opaque. We NEVER fabricate a name — in particular the
+// placeholder fill (scaffolding this library invented) never escapes as one (issue #35).
 //
 // The IR is frozen after lower(); this transform REBUILDS with STRUCTURAL SHARING (new objects only on
 // changed paths, an unchanged subtree keeps its original already-frozen reference) and re-freezes the
@@ -152,7 +153,10 @@ function markTemplateExprs(node, ctx) {
 // never wrong.
 // ---------------------------------------------------------------------------
 /** Match a direct string-literal argument's raw text (no escapes, one token). */
-const LITERAL_ARG = /^(['"])([^'"\\]*)\1$/;
+/** A literal argument's value: a quoted string (quote-stripped) or a bare numeric literal —
+ *  both are the user's own text, never computed. Everything else stays `null` (computed). */
+const LITERAL_ARG = /^(?:(['"])([^'"\\]*)\1|(-?\d+(?:\.\d+)?))$/;
+const literalValueOf = (m) => m[2] ?? m[3];
 /** The raw text of a span. */
 function sliceSpan(text, span) {
     return text.slice(span.start, span.end);
@@ -172,11 +176,11 @@ export function callOf(mc, text) {
         const kw = KWARG_RE.exec(raw);
         if (kw) {
             const m = LITERAL_ARG.exec(kw[2].trim());
-            kwargs.push({ name: kw[1], value: m ? m[2] : null });
+            kwargs.push({ name: kw[1], value: m ? literalValueOf(m) : null });
         }
         else {
             const m = LITERAL_ARG.exec(raw);
-            args.push(m ? m[2] : null);
+            args.push(m ? literalValueOf(m) : null);
         }
     }
     return {
@@ -398,6 +402,11 @@ function transformTableSource(src, ctx) {
     // where `jjj…` was a fabrication.
     const aliasTok = src.aliasCst?.start;
     const base = aliasTok != null && inSpan(aliasTok.start, tag.tagSpan) ? withoutAlias(src) : src;
+    // An unresolved source's name is the RAW TAG TEXT — the bytes the user actually wrote. The
+    // placeholder fill is scaffolding this library invented so the grammar parses; letting it
+    // escape as a relation name (scope sources, lineage dependencies, go-to-def) is fabrication
+    // under the never-wrong rule (issue #35, reported by anvil).
+    const rawTagName = [ctx.text.slice(tag.tagSpan.start, tag.tagSpan.end)];
     // NOTE: `template.span` intentionally aliases `tag.tagSpan` BY REFERENCE. freezeIR
     // therefore also freezes the TagNode.tagSpan object returned in `.tags`, benign
     // since spans are read-only. Every call marker carries its `call`, the provider key
@@ -406,24 +415,24 @@ function transformTableSource(src, ctx) {
         const call = callOf(tag, ctx.text);
         const rel = ctx.provider.relationOf(call);
         // A call in a FROM slot (ref/source/a TVF-like macro). When the provider resolves its
-        // relation, carry the resolved name; otherwise keep the placeholder name (never fabricated).
+        // relation, carry the resolved name; otherwise the raw tag text (never the fill).
         // Either way the `call` keeps it consultable, so an unresolved call is not a dead end: a
         // provider added later resolves it. ref vs source is not stored here, it is call.name.
-        const named = rel ? { ...base, name: [...rel.nameParts] } : base;
+        const named = { ...base, name: rel ? [...rel.nameParts] : rawTagName };
         const template = { kind: "call", span: tag.tagSpan, call };
         return attach(ctx, { ...named, template }, tag);
     }
     // Non-call expression tag (var / env_var / other) in a FROM slot. A bare `{{ t }}` resolving
     // through a `{% set t = … %}` single-call RHS carries the resolved relation name (when the
     // provider resolved it) or the call identity alone; every other case gets the opaque "expr"
-    // marker, so the placeholder name stops posing as a real table.
+    // marker. In every unresolved case the name is the raw tag text, never the fill.
     const ident = tag.kind === "other" ? bareIdentOf(tag, ctx.text) : undefined;
     const resolved = ident !== undefined ? ctx.sets.get(ident) : undefined;
     if (resolved) {
-        const named = resolved.name ? { ...base, name: [...resolved.name] } : base;
+        const named = { ...base, name: resolved.name ? [...resolved.name] : rawTagName };
         const template = { kind: "call", span: tag.tagSpan, indirect: true, call: resolved.call };
         return attach(ctx, { ...named, template }, tag);
     }
     const template = { kind: "expr", span: tag.tagSpan, opaque: true };
-    return attach(ctx, { ...base, template }, tag);
+    return attach(ctx, { ...base, name: rawTagName, template }, tag);
 }

package/dist/qualify/template-provider.d.ts

@@ -110,8 +110,11 @@ export declare class DefaultTemplateProvider implements SchemaProvider {
      *  the table names). `argIndex` is -1 when the caret is still in the callee name itself, so a host
      *  can answer the macro/callee names it knows. `packageName` is the dotted package (`dbt_utils` in
      *  `dbt_utils.star(...)`). The NEUTRAL provider knows no vocabulary and offers none; a host answers
-     *  from its catalog. `completeAt` reads this when the caret is inside a jinja tag. */
-    templateCandidates(_callee: string, _argIndex: number, _packageName?: string): TemplateCandidate[];
+     *  from its catalog. `completeAt` reads this when the caret is inside a jinja tag. The WHOLE
+     *  parsed call comes along (issue #37) — a slot's candidates can depend on the sibling args:
+     *  `source('raw', '|')`'s candidates are the tables OF the source named in `call.args[0]`.
+     *  `argIndex` is the positional arg the caret is in (`-1` = the callee-name slot). */
+    templateCandidates(_call: TemplateCall, _argIndex: number): TemplateCandidate[];
     /**
      * Everything known about `call`, composed from the granular methods. Field precedence for the
      * shape (channel-agreed): an EXPLICIT `shapeOf` answer always wins; absent, derived

package/dist/qualify/template-provider.js

@@ -137,8 +137,11 @@ export class DefaultTemplateProvider {
      *  the table names). `argIndex` is -1 when the caret is still in the callee name itself, so a host
      *  can answer the macro/callee names it knows. `packageName` is the dotted package (`dbt_utils` in
      *  `dbt_utils.star(...)`). The NEUTRAL provider knows no vocabulary and offers none; a host answers
-     *  from its catalog. `completeAt` reads this when the caret is inside a jinja tag. */
-    templateCandidates(_callee, _argIndex, _packageName) {
+     *  from its catalog. `completeAt` reads this when the caret is inside a jinja tag. The WHOLE
+     *  parsed call comes along (issue #37) — a slot's candidates can depend on the sibling args:
+     *  `source('raw', '|')`'s candidates are the tables OF the source named in `call.args[0]`.
+     *  `argIndex` is the positional arg the caret is in (`-1` = the callee-name slot). */
+    templateCandidates(_call, _argIndex) {
         return [];
     }
     // --- The composed entry the ENGINE consults (rarely overridden wholesale). ---

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sqllens",
-	"version": "1.3.0",
+	"version": "1.4.0",
 	"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",