@lzehrung/codegraph 3.0.1 → 3.1.1

package/dist/sql/navigation.js

@@ -1,14 +1,14 @@
 import fsp from "node:fs/promises";
-import path from "node:path";
 import { createNavigationProvenance, okGoToResult } from "../indexer/navigation-provenance.js";
 import { buildIndexedCandidateCoverage } from "../indexer/navigation-references.js";
+import { SymbolKind } from "../indexer/types.js";
 import { fileIdentityKey, normalizePath } from "../util/paths.js";
+import { isSqlFilePath } from "./classify-sql-file.js";
 import { extractSqlFactsFromSource } from "./extract-facts.js";
-import { pushSqlLookupValue } from "./lookup.js";
-import { maskSqlStringsAndComments, normalizeSqlObjectName, SQL_IDENTIFIER_PART_PATTERN, splitTopLevelCommaSeparated, sqlObjectBaseNameLookupKey, sqlObjectLookupKey, sqlParenDepthAt, } from "./lex.js";
-function isSqlFile(filePath) {
-    return path.extname(filePath).toLowerCase() === ".sql";
-}
+import { addSqlDefinition, createSqlDefinitionIndex, sqlRoutineNameCandidates, } from "./lookup.js";
+import { maskSqlQuotedIdentifiers, maskSqlStringsAndComments, normalizeSqlObjectName, SQL_IDENTIFIER_PART_PATTERN, splitTopLevelCommaSeparated, sqlObjectBaseNameLookupKey, sqlObjectLookupKey, sqlQueryScopes, sqlSourceClauses, } from "./lex.js";
+import { sqlDefinedNameSpan, sqlObjectMentionCovers, sqlRelationReadSpans, sqlSpanCovers, sqlSyntacticObjectSpans, } from "./object-mentions.js";
+import { findSqlRoutineMentions, findSqlRoutineSources, sqlRoutineDefinitionNamespace, sqlStatementDropsRoutine, } from "./routine-mentions.js";
 function rangeForToken(line, column, length) {
     return {
         start: { line, column },
@@ -18,7 +18,7 @@ function rangeForToken(line, column, length) {
 function sqlFiles(index) {
     return Array.from(index.byFile.values())
         .map((module) => normalizePath(module.file))
-        .filter(isSqlFile)
+        .filter((file) => isSqlFilePath(file, index.languageExtensions))
         .sort((left, right) => left.localeCompare(right));
 }
 function getSqlNavigationCache(index) {
@@ -28,23 +28,23 @@ function getSqlNavigationCache(index) {
     };
     return index.sqlNavigation;
 }
+/** Table, view, and index definitions. Routines resolve through `getSqlRoutineLookups`. */
 function getSqlDefinitionLookup(index) {
     const cache = getSqlNavigationCache(index);
     if (cache.definitionLookup)
         return cache.definitionLookup;
-    const exact = new Map();
-    const basename = new Map();
+    const lookup = createSqlDefinitionIndex();
     for (const file of sqlFiles(index)) {
         const module = index.byFile.get(fileIdentityKey(file));
         if (!module)
             continue;
         for (const local of module.locals) {
-            pushSqlLookupValue(exact, sqlObjectLookupKey(local.localName), local);
-            pushSqlLookupValue(basename, sqlObjectBaseNameLookupKey(local.localName), local);
+            if (local.kind !== SymbolKind.Routine)
+                addSqlDefinition(lookup, local.localName, local);
         }
     }
-    cache.definitionLookup = { exact, basename };
-    return cache.definitionLookup;
+    cache.definitionLookup = lookup;
+    return lookup;
 }
 function sqlDefinitionsFromLookup(lookup, objectName) {
     const normalizedName = sqlObjectLookupKey(objectName);
@@ -75,6 +75,7 @@ function sqlDefinitionMatches(lookup, objectName) {
 const SQL_IDENTIFIER = SQL_IDENTIFIER_PART_PATTERN;
 const SQL_DOTTED_TOKEN = String.raw `${SQL_IDENTIFIER}(?:\s*\.\s*${SQL_IDENTIFIER})*`;
 const SQL_DOTTED_TOKEN_RE = new RegExp(SQL_DOTTED_TOKEN, "g");
+const SQL_IDENTIFIER_PART_RE = new RegExp(SQL_IDENTIFIER, "g");
 const SQL_SOURCE_KEYWORDS = new Set([
     "as",
     "on",
@@ -93,9 +94,8 @@ const SQL_SOURCE_KEYWORDS = new Set([
     "returning",
 ]);
 const SQL_SOURCE_MODIFIERS = new Set(["only", "lateral"]);
-const SQL_SOURCE_BOUNDARY_RE = /\b(?:where|group\s+by|order\s+by|having|limit|offset|returning|union|intersect|except|on|inner\s+join|left\s+join|right\s+join|full\s+join|cross\s+join|join)\b/i;
 function wordAtPosition(source, line, column) {
-    const lineText = maskSqlStringsAndComments(source).split(/\r?\n/)[line - 1];
+    const lineText = maskSqlStringsAndComments(source, { escapeStrings: true }).split(/\r?\n/)[line - 1];
     if (!lineText)
         return null;
     const zeroBasedColumn = Math.max(0, column - 1);
@@ -113,14 +113,20 @@ function sqlObjectNameParts(name) {
         .map((part) => part.trim())
         .filter(Boolean);
 }
+const slicesByFacts = new WeakMap();
+/** The statements of one file's facts in source order. A file's facts are fixed, so the result is cached. */
 function sqlStatementSlices(facts) {
+    const cached = slicesByFacts.get(facts);
+    if (cached)
+        return cached;
     const slices = [];
     const seen = new Set();
     for (const fact of facts) {
-        const key = `${fact.startLine}:${fact.endLine}:${fact.statementText}`;
-        if (seen.has(key))
+        // One statement yields several facts. Its start offset tells it apart from an identical statement
+        // on the same line, which its lines and text cannot.
+        if (seen.has(fact.startIndex))
             continue;
-        seen.add(key);
+        seen.add(fact.startIndex);
         slices.push({
             text: fact.statementText,
             startLine: fact.startLine,
@@ -128,15 +134,13 @@ function sqlStatementSlices(facts) {
             endLine: fact.endLine,
         });
     }
-    return slices.sort((left, right) => left.startLine - right.startLine || left.endLine - right.endLine);
+    slices.sort((left, right) => left.startLine - right.startLine || left.endLine - right.endLine);
+    slicesByFacts.set(facts, slices);
+    return slices;
 }
 function sqlStatementAtLine(facts, line) {
     return (sqlStatementSlices(facts).find((statement) => line >= statement.startLine && line <= statement.endLine) ?? null);
 }
-function sourceClauseEndIndex(text, start) {
-    const boundary = text.slice(start).search(SQL_SOURCE_BOUNDARY_RE);
-    return boundary < 0 ? text.length : start + boundary;
-}
 function cteNamesForStatement(text) {
     const cteNames = new Set();
     const cteRe = new RegExp(String.raw `(?:\bwith\s+(?:recursive\s+)?|,\s*)(${SQL_IDENTIFIER})(?:\s*\([^)]*\))?\s+as\s*\(`, "gi");
@@ -150,12 +154,14 @@ function cteNamesForStatement(text) {
     return cteNames;
 }
 function parseSqlSourceEntry(entry) {
+    const leading = entry.length - entry.trimStart().length;
     const trimmed = entry.trim();
     if (!trimmed || trimmed.startsWith("("))
         return null;
     const tokenRe = new RegExp(SQL_DOTTED_TOKEN, "gy");
     let cursor = 0;
     let objectName = null;
+    let objectOffset = -1;
     while (cursor < trimmed.length) {
         tokenRe.lastIndex = cursor;
         const match = tokenRe.exec(trimmed);
@@ -167,12 +173,13 @@ function parseSqlSourceEntry(entry) {
         cursor = match.index + match[0].length;
         if (!SQL_SOURCE_MODIFIERS.has(normalized.toLowerCase())) {
             objectName = normalized;
+            objectOffset = leading + match.index;
             break;
         }
         while (cursor < trimmed.length && /\s/.test(trimmed[cursor] ?? ""))
             cursor += 1;
     }
-    if (!objectName)
+    if (!objectName || objectOffset < 0)
         return null;
     let rest = trimmed.slice(cursor).trimStart();
     if (rest.startsWith("."))
@@ -182,31 +189,9 @@ function parseSqlSourceEntry(entry) {
     const aliasMatch = new RegExp(String.raw `^(${SQL_IDENTIFIER})`, "i").exec(rest);
     const aliasName = normalizeSqlObjectName(aliasMatch?.[1]) ?? null;
     if (!aliasName || SQL_SOURCE_KEYWORDS.has(aliasName.toLowerCase())) {
-        return { objectName, aliasName: null };
-    }
-    return { objectName, aliasName };
-}
-function sqlAliasMapForStatement(statementText) {
-    const aliases = new Map();
-    const cteNames = cteNamesForStatement(statementText);
-    const clauseRe = /\b(?:from|using|join|inner\s+join|left\s+join|right\s+join|full\s+join|cross\s+join)\s+/gi;
-    for (const match of statementText.matchAll(clauseRe)) {
-        if (sqlParenDepthAt(statementText, match.index ?? 0) > 0)
-            continue;
-        const start = (match.index ?? 0) + match[0].length;
-        const clause = statementText.slice(start, sourceClauseEndIndex(statementText, start));
-        for (const part of splitTopLevelCommaSeparated(clause)) {
-            const parsed = parseSqlSourceEntry(part);
-            if (!parsed?.aliasName)
-                continue;
-            const objectKey = sqlObjectLookupKey(parsed.objectName);
-            const objectBaseKey = sqlObjectBaseNameLookupKey(parsed.objectName);
-            if (cteNames.has(objectKey) || cteNames.has(objectBaseKey))
-                continue;
-            aliases.set(sqlObjectLookupKey(parsed.aliasName), parsed.objectName);
-        }
+        return { objectName, aliasName: null, objectOffset };
     }
-    return aliases;
+    return { objectName, aliasName, objectOffset };
 }
 function unambiguousSqlPrefixDefinitionName(lookup, objectName) {
     const matches = sqlDefinitionMatches(lookup, objectName);
@@ -218,23 +203,116 @@ function unambiguousSqlPrefixDefinitionName(lookup, objectName) {
         return matches.basename[0]?.localName ?? null;
     return null;
 }
-function resolveQualifiedSqlName(lookup, name, statementText) {
-    if (sqlDefinitionsFromLookup(lookup, name).length)
-        return name;
+/** Resolve a qualifier against the nearest query's relation aliases and indexed routine sources. */
+function sqlSourceBindings(lookups, statementText) {
+    const masked = maskSqlStringsAndComments(statementText, { escapeStrings: true });
+    const scan = maskSqlQuotedIdentifiers(masked);
+    const scopes = sqlQueryScopes(scan);
+    const bindings = new Map();
+    const addBinding = (offset, key, binding) => {
+        const scope = scopes.at(offset);
+        let inScope = bindings.get(scope);
+        if (!inScope) {
+            inScope = new Map();
+            bindings.set(scope, inScope);
+        }
+        const previous = inScope.get(key);
+        if (!previous) {
+            inScope.set(key, binding);
+        }
+        else if (previous.kind !== binding.kind ||
+            (previous.kind === "relation" && binding.kind === "relation" && previous.objectName !== binding.objectName)) {
+            inScope.set(key, { kind: "ambiguous" });
+        }
+    };
+    const cteNames = cteNamesForStatement(masked);
+    const routineSources = lookups.namespaceByDefinition.size
+        ? findSqlRoutineSources(statementText).filter(({ mention }) => routineCandidates(lookups, mention).length > 0)
+        : [];
+    for (const source of sqlSourceClauses(scan)) {
+        const clause = masked.slice(source.end, source.clauseEnd);
+        let nextPartStart = source.end;
+        for (const part of splitTopLevelCommaSeparated(clause)) {
+            const partStart = masked.indexOf(part, nextPartStart);
+            if (partStart < 0)
+                continue;
+            const partEnd = partStart + part.length;
+            nextPartStart = partEnd + 1;
+            const parsed = parseSqlSourceEntry(part);
+            if (!parsed)
+                continue;
+            // A routine source owns only its own source item. A later call that merely falls inside this
+            // slice, such as the next statement of a procedure body, must not drop the relation binding.
+            if (routineSources.some(({ mention }) => mention.start === partStart + parsed.objectOffset))
+                continue;
+            const objectKey = sqlObjectLookupKey(parsed.objectName);
+            const objectBaseKey = sqlObjectBaseNameLookupKey(parsed.objectName);
+            if (cteNames.has(objectKey) || cteNames.has(objectBaseKey))
+                continue;
+            const relation = { kind: "relation", objectName: parsed.objectName };
+            if (parsed.aliasName) {
+                addBinding(source.start, sqlObjectLookupKey(parsed.aliasName), relation);
+            }
+            else {
+                addBinding(source.start, objectKey, relation);
+                if (objectBaseKey !== objectKey)
+                    addBinding(source.start, objectBaseKey, relation);
+            }
+        }
+    }
+    for (const { mention, alias } of routineSources) {
+        if (alias) {
+            addBinding(mention.start, sqlObjectLookupKey(alias), { kind: "routine" });
+        }
+        else {
+            addBinding(mention.start, sqlObjectLookupKey(mention.name), { kind: "routine" });
+            addBinding(mention.start, sqlObjectBaseNameLookupKey(mention.name), { kind: "routine" });
+        }
+    }
+    return {
+        at(offset, parts) {
+            for (let scope = scopes.at(offset);; scope = scopes.parent.get(scope) ?? 0) {
+                const inScope = bindings.get(scope);
+                let binding = inScope?.get(sqlObjectLookupKey(parts[0] ?? ""));
+                for (let count = 2; count < parts.length; count += 1) {
+                    const candidate = inScope?.get(sqlObjectLookupKey(parts.slice(0, count).join(".")));
+                    if (candidate && binding && candidate !== binding)
+                        return { kind: "ambiguous" };
+                    binding ??= candidate;
+                }
+                if (binding)
+                    return binding;
+                if (!scope)
+                    break;
+            }
+            return null;
+        },
+    };
+}
+function resolveQualifiedSqlName(lookup, routineLookups, name, statementText, offset) {
     const parts = sqlObjectNameParts(name);
     if (parts.length < 2)
         return name;
     const firstPart = parts[0];
     if (!firstPart)
         return null;
-    if (statementText) {
-        const maskedStatementText = maskSqlStringsAndComments(statementText);
+    if (statementText && offset !== undefined) {
+        const maskedStatementText = maskSqlStringsAndComments(statementText, { escapeStrings: true });
         if (cteNamesForStatement(maskedStatementText).has(sqlObjectLookupKey(firstPart)))
             return null;
-        const aliasTarget = sqlAliasMapForStatement(maskedStatementText).get(sqlObjectLookupKey(firstPart));
-        if (aliasTarget && sqlDefinitionsFromLookup(lookup, aliasTarget).length)
-            return aliasTarget;
+        if (sqlObjectMentionCovers(statementText, offset)) {
+            const direct = sqlDefinitionMatches(lookup, name);
+            return direct.exact.length || direct.basename.length === 1 ? name : null;
+        }
+        const binding = sqlSourceBindings(routineLookups, statementText).at(offset, parts);
+        if (binding) {
+            if (binding.kind !== "relation")
+                return null;
+            return sqlDefinitionsFromLookup(lookup, binding.objectName).length ? binding.objectName : null;
+        }
     }
+    if (sqlDefinitionsFromLookup(lookup, name).length)
+        return name;
     for (let partCount = parts.length - 1; partCount >= 1; partCount -= 1) {
         const candidate = parts.slice(0, partCount).join(".");
         const resolvedName = unambiguousSqlPrefixDefinitionName(lookup, candidate);
@@ -261,7 +339,15 @@ function sqlNameResolvesToDefinition(lookup, name, definition) {
         return matches.exact.includes(definition);
     return matches.basename.length === 1 && matches.basename[0] === definition;
 }
-function factReferenceRanges(fact, objectName) {
+/**
+ * Where the last `partCount` parts of a dotted name begin. Rename edits the definition's own name and
+ * keeps the qualifier in front of it: a rename of `f` edits the `f` in `public.f`.
+ */
+function trailingPartsOffset(dottedName, partCount) {
+    const parts = [...dottedName.matchAll(SQL_IDENTIFIER_PART_RE)];
+    return parts[parts.length - partCount]?.index ?? 0;
+}
+function factReferenceRanges(fact, objectName, claimedStarts, keepParts = 0) {
     const statement = {
         text: fact.statementText,
         startLine: fact.startLine,
@@ -270,22 +356,35 @@ function factReferenceRanges(fact, objectName) {
     };
     const objectKey = sqlObjectLookupKey(objectName);
     const ranges = [];
-    const maskedStatementText = maskSqlStringsAndComments(statement.text);
+    const sourceSpans = fact.kind === "reads_from" || fact.kind === "joins" ? sqlRelationReadSpans(statement.text) : null;
+    const maskedStatementText = maskSqlStringsAndComments(statement.text, { escapeStrings: true });
     for (const match of maskedStatementText.matchAll(SQL_DOTTED_TOKEN_RE)) {
         const token = normalizeSqlObjectName(match[0]);
         if (!token || sqlObjectLookupKey(token) !== objectKey)
             continue;
         const offset = match.index ?? 0;
-        ranges.push(rangeForToken(statementLineForOffset(statement, offset), statementColumnForOffset(statement, offset), match[0].length));
+        if (claimedStarts?.has(offset))
+            continue;
+        if (sourceSpans &&
+            !sourceSpans.some((span) => span.start === offset && sqlObjectLookupKey(span.name) === objectKey))
+            continue;
+        const nameOffset = keepParts ? trailingPartsOffset(match[0], keepParts) : 0;
+        ranges.push(rangeForToken(statementLineForOffset(statement, offset + nameOffset), statementColumnForOffset(statement, offset + nameOffset), match[0].length - nameOffset));
     }
     return ranges;
 }
-function qualifiedReferenceRanges(lookup, statement, definition) {
+function qualifiedReferenceRanges(lookup, routineLookups, statement, definition, claimedStarts, keepParts = 0) {
     const ranges = [];
-    const maskedStatementText = maskSqlStringsAndComments(statement.text);
-    const aliases = sqlAliasMapForStatement(maskedStatementText);
+    let ambiguous = false;
+    const maskedStatementText = maskSqlStringsAndComments(statement.text, { escapeStrings: true });
+    const bindings = sqlSourceBindings(routineLookups, statement.text);
     const cteNames = cteNamesForStatement(maskedStatementText);
+    // One scan for the statement. A fresh scan for every qualified name is quadratic.
+    const objectSpans = sqlSyntacticObjectSpans(statement.text);
     for (const match of maskedStatementText.matchAll(SQL_DOTTED_TOKEN_RE)) {
+        const offset = match.index ?? 0;
+        if (claimedStarts?.has(offset))
+            continue;
         const token = normalizeSqlObjectName(match[0]);
         if (!token)
             continue;
@@ -297,19 +396,38 @@ function qualifiedReferenceRanges(lookup, statement, definition) {
             continue;
         if (cteNames.has(sqlObjectLookupKey(firstPart)))
             continue;
-        const aliasTarget = aliases.get(sqlObjectLookupKey(firstPart));
-        const matchesAlias = aliasTarget ? sqlNameResolvesToDefinition(lookup, aliasTarget, definition) : false;
-        let matchesPrefix = false;
-        for (let partCount = parts.length - 1; partCount >= 1 && !matchesPrefix; partCount -= 1) {
-            const candidate = parts.slice(0, partCount).join(".");
-            matchesPrefix = sqlNameResolvesToDefinition(lookup, candidate, definition);
+        if (sqlSpanCovers(objectSpans, offset)) {
+            const direct = sqlDefinitionMatches(lookup, token);
+            if (!direct.exact.length && direct.basename.length > 1 && direct.basename.includes(definition))
+                ambiguous = true;
+            if (sqlNameResolvesToDefinition(lookup, token, definition)) {
+                const nameOffset = keepParts ? trailingPartsOffset(match[0], keepParts) : 0;
+                ranges.push(rangeForToken(statementLineForOffset(statement, offset + nameOffset), statementColumnForOffset(statement, offset + nameOffset), match[0].length - nameOffset));
+            }
+            continue;
         }
-        if (!matchesAlias && !matchesPrefix)
+        const binding = bindings.at(offset, parts);
+        if (binding?.kind === "ambiguous") {
+            ambiguous = true;
+            continue;
+        }
+        if (binding?.kind === "routine")
+            continue;
+        let matches = false;
+        if (binding) {
+            matches = sqlNameResolvesToDefinition(lookup, binding.objectName, definition);
+        }
+        else {
+            for (let partCount = parts.length - 1; partCount >= 1 && !matches; partCount -= 1) {
+                const candidate = parts.slice(0, partCount).join(".");
+                matches = sqlNameResolvesToDefinition(lookup, candidate, definition);
+            }
+        }
+        if (!matches)
             continue;
-        const offset = match.index ?? 0;
         ranges.push(rangeForToken(statementLineForOffset(statement, offset), statementColumnForOffset(statement, offset), match[0].length));
     }
-    return ranges;
+    return { ranges, ambiguous };
 }
 async function sourceForFile(filePath, index) {
     const cache = getSqlNavigationCache(index);
@@ -332,17 +450,185 @@ async function sqlFactsForFile(index, filePath) {
     cache.factsByFile.set(key, facts);
     return facts;
 }
+const routineLookupsByIndex = new WeakMap();
+const mentionsByFacts = new WeakMap();
+function siteKey(file, line, column) {
+    return `${fileIdentityKey(file)}:${line}:${column}`;
+}
+/** The name space of each routine one file defines, by the position where its statement starts. */
+async function routineNamespacesByStart(index, file) {
+    const namespaces = new Map();
+    for (const fact of await sqlFactsForFile(index, file)) {
+        if (fact.kind !== "defines_routine")
+            continue;
+        namespaces.set(`${fact.startLine}:${fact.startColumn}`, sqlRoutineDefinitionNamespace(fact.statementText));
+    }
+    return namespaces;
+}
+async function buildSqlRoutineLookups(index) {
+    const lookups = {
+        callable: createSqlDefinitionIndex(),
+        trigger: createSqlDefinitionIndex(),
+        namespaceByDefinition: new Map(),
+        definitionByStart: new Map(),
+    };
+    for (const file of sqlFiles(index)) {
+        const locals = index.byFile.get(fileIdentityKey(file))?.locals ?? [];
+        const routines = locals.filter((local) => local.kind === SymbolKind.Routine);
+        if (!routines.length)
+            continue;
+        const namespaces = await routineNamespacesByStart(index, file);
+        for (const routine of routines) {
+            const { line, column } = routine.range.start;
+            const namespace = namespaces.get(`${line}:${column}`) ?? "callable";
+            addSqlDefinition(lookups[namespace], routine.localName, routine);
+            lookups.namespaceByDefinition.set(routine, namespace);
+            lookups.definitionByStart.set(siteKey(file, line, column), routine);
+        }
+    }
+    return lookups;
+}
+function getSqlRoutineLookups(index) {
+    const cached = routineLookupsByIndex.get(index);
+    if (cached)
+        return cached;
+    const lookups = buildSqlRoutineLookups(index);
+    routineLookupsByIndex.set(index, lookups);
+    // A failed build must not stay cached; the next lookup tries again.
+    lookups.catch(() => routineLookupsByIndex.delete(index));
+    return lookups;
+}
+/**
+ * The mentions in each statement that name a routine. A keyword mention always does. A bare `name(`
+ * does only when an indexed routine has that name, because `INSERT INTO users (id)` has the same shape.
+ */
+function statementMentions(lookups, facts) {
+    const cached = mentionsByFacts.get(facts);
+    if (cached)
+        return cached;
+    const statements = [];
+    for (const statement of sqlStatementSlices(facts)) {
+        const mentions = findSqlRoutineMentions(statement.text).filter((mention) => !mention.speculative || routineCandidates(lookups, mention).length);
+        if (mentions.length)
+            statements.push({ statement, mentions });
+    }
+    mentionsByFacts.set(facts, statements);
+    return statements;
+}
+function routineCandidates(lookups, mention) {
+    return sqlRoutineNameCandidates(lookups[mention.namespace], mention.name, (definition) => definition.localName)
+        .candidates;
+}
+/**
+ * Start offsets of the tokens in each statement that name a routine, by statement start. A table or
+ * view reference skips these tokens: a name in a routine position is not a relation.
+ */
+function claimedMentionStarts(lookups, facts) {
+    const claimed = new Map();
+    for (const { statement, mentions } of statementMentions(lookups, facts)) {
+        claimed.set(`${statement.startLine}:${statement.startColumn}`, new Set(mentions.map((mention) => mention.start)));
+    }
+    return claimed;
+}
+function mentionRange(statement, mention, keepParts = 0) {
+    const start = mention.start + (keepParts ? trailingPartsOffset(statement.text.slice(mention.start, mention.end), keepParts) : 0);
+    return {
+        start: {
+            line: statementLineForOffset(statement, start),
+            column: statementColumnForOffset(statement, start),
+        },
+        end: {
+            line: statementLineForOffset(statement, mention.end),
+            column: statementColumnForOffset(statement, mention.end),
+        },
+    };
+}
+function statementOffsetAtPosition(statement, line, column) {
+    if (line < statement.startLine || line > statement.endLine)
+        return undefined;
+    let lineStart = 0;
+    for (let current = statement.startLine; current < line; current += 1) {
+        const newline = statement.text.indexOf("\n", lineStart);
+        if (newline < 0)
+            return undefined;
+        lineStart = newline + 1;
+    }
+    return lineStart + column - (line === statement.startLine ? statement.startColumn : 1);
+}
+function goToRoutineMention(index, lookups, file, facts, position) {
+    for (const statement of sqlStatementSlices(facts)) {
+        const offset = statementOffsetAtPosition(statement, position.line, position.column);
+        // Several statements can share one line, so only the statement that holds the position counts.
+        if (offset === undefined || offset < 0 || offset >= statement.text.length)
+            continue;
+        const mention = findSqlRoutineMentions(statement.text).find((entry) => offset >= entry.start && offset < entry.end);
+        if (!mention)
+            return null;
+        if (mention.kind === "definition") {
+            const definition = lookups.definitionByStart.get(siteKey(file, statement.startLine, statement.startColumn));
+            return definition ? okGoToResult(index, definition, { resolution: "exact", confidence: "high" }) : null;
+        }
+        const candidates = routineCandidates(lookups, mention);
+        const [only] = candidates;
+        if (only && candidates.length === 1)
+            return okGoToResult(index, only, { resolution: "exact", confidence: "high" });
+        if (candidates.length)
+            return { status: "not_found", reason: "Several SQL routines share this name" };
+        // A bare `name(` can name a table or an index; a keyword such as `CALL` or `DROP FUNCTION` names a routine.
+        return mention.speculative ? null : { status: "not_found", reason: "No matching SQL routine definition" };
+    }
+    return null;
+}
+function routineMentionIsProven(lookups, statementText, offset) {
+    const mention = findSqlRoutineMentions(statementText).find((entry) => offset >= entry.start && offset < entry.end);
+    if (!mention)
+        return false;
+    // A bare `name(` is a routine only when an indexed routine has that name. Otherwise it may be a table.
+    if (!mention.speculative)
+        return true;
+    return routineCandidates(lookups, mention).length > 0;
+}
+/**
+ * True when the position names an object or a routine by SQL syntax: a `FROM`/`JOIN`/`CALL`/`ON`
+ * target, not a column that happens to share a table's name. The name that a `CREATE` statement
+ * defines is no mention: it names the definition itself.
+ */
+export async function sqlPositionIsProvenObjectOrRoutineMention(index, req) {
+    if (!isSqlFilePath(req.file, index.languageExtensions))
+        return false;
+    const facts = await sqlFactsForFile(index, req.file);
+    const routineLookups = await getSqlRoutineLookups(index);
+    for (const statement of sqlStatementSlices(facts)) {
+        const offset = statementOffsetAtPosition(statement, req.line, req.column);
+        if (offset === undefined || offset < 0 || offset >= statement.text.length)
+            continue;
+        const defined = sqlDefinedNameSpan(statement.text);
+        if (defined && offset >= defined.start && offset < defined.end)
+            return false;
+        if (routineMentionIsProven(routineLookups, statement.text, offset))
+            return true;
+        return sqlObjectMentionCovers(statement.text, offset);
+    }
+    return false;
+}
 export async function goToSqlDefinition(index, req) {
-    if (!isSqlFile(req.file))
+    if (!isSqlFilePath(req.file, index.languageExtensions))
         return null;
     const source = await sourceForFile(req.file, index);
-    const name = wordAtPosition(source, req.line, req.column);
-    if (!name)
-        return { status: "not_found", reason: "No SQL object at position" };
     const lookup = getSqlDefinitionLookup(index);
+    const routineLookups = await getSqlRoutineLookups(index);
     const facts = await sqlFactsForFile(index, req.file);
+    // `DROP FUNCTION f`, `CALL f`, and the like name a routine even when the project defines none, so they
+    // never fall through to a table of the same name.
+    const routineResult = goToRoutineMention(index, routineLookups, req.file, facts, req);
+    if (routineResult)
+        return routineResult;
     const statement = sqlStatementAtLine(facts, req.line);
-    const resolvedName = resolveQualifiedSqlName(lookup, name, statement?.text ?? null);
+    const name = wordAtPosition(source, req.line, req.column);
+    if (!name)
+        return { status: "not_found", reason: "No SQL object at position" };
+    const offset = statement ? statementOffsetAtPosition(statement, req.line, req.column) : undefined;
+    const resolvedName = resolveQualifiedSqlName(lookup, routineLookups, name, statement?.text ?? null, offset);
     if (!resolvedName)
         return { status: "not_found", reason: "No matching SQL object definition" };
     const definitions = sqlDefinitionsFromLookup(lookup, resolvedName);
@@ -354,24 +640,65 @@ export async function goToSqlDefinition(index, req) {
         confidence: "high",
     });
 }
-export async function findSqlReferences(index, definition, options) {
-    if (!isSqlFile(definition.file))
+/**
+ * The site of the name `definition` declares, as in `users` in `CREATE TABLE users`. A definition spans
+ * its whole statement, so its range does not say where its name is.
+ */
+async function declarationSiteKey(index, definition) {
+    const { line, column } = definition.range.start;
+    const facts = await sqlFactsForFile(index, definition.file);
+    const statement = sqlStatementSlices(facts).find((slice) => slice.startLine === line && slice.startColumn === column);
+    const name = statement ? sqlDefinedNameSpan(statement.text) : null;
+    if (!statement || !name)
+        return null;
+    const nameLine = statementLineForOffset(statement, name.start);
+    return siteKey(definition.file, nameLine, statementColumnForOffset(statement, name.start));
+}
+/**
+ * The indexed definition declared at the site `definition` names. Impact analysis passes a copy of a
+ * definition, and a lookup by object identity cannot match a copy.
+ */
+function indexedSqlDefinition(index, definition) {
+    const { line, column } = definition.range.start;
+    const locals = index.byFile.get(fileIdentityKey(definition.file))?.locals ?? [];
+    return (locals.find((local) => local.range.start.line === line &&
+        local.range.start.column === column &&
+        local.kind === definition.kind &&
+        local.localName === definition.localName) ?? null);
+}
+export async function findSqlReferences(index, requested, options) {
+    if (!isSqlFilePath(requested.file, index.languageExtensions))
         return null;
+    const definition = indexedSqlDefinition(index, requested);
+    // Without the indexed definition no lookup can match, and an empty list would claim a complete scan.
+    if (!definition)
+        return { status: "not_found", reason: "SQL definition is not in the index" };
     const references = [];
     const seen = new Set();
     const lookup = getSqlDefinitionLookup(index);
+    const routineLookups = await getSqlRoutineLookups(index);
+    const routineNamespace = routineLookups.namespaceByDefinition.get(definition);
+    const hasRoutines = !!routineLookups.namespaceByDefinition.size;
     const candidateFiles = sqlFiles(index);
     const scannedFiles = [];
+    // Files with a mention that several routine definitions could own, so no one definition owns it.
+    const ambiguousFiles = [];
     const includeDefinition = options?.includeDefinition ?? true;
+    const keepParts = options?.renameRanges ? sqlObjectNameParts(definition.localName).length : 0;
     const maxReferences = typeof options?.maxReferences === "number" && options.maxReferences > 0 ? options.maxReferences : undefined;
     const collectionLimit = maxReferences === undefined ? undefined : maxReferences + 1;
-    const definitionKey = `${fileIdentityKey(definition.file)}:${definition.range.start.line}:${definition.range.start.column}`;
+    const definitionKey = siteKey(definition.file, definition.range.start.line, definition.range.start.column);
+    // A usage lookup leaves out the declaration. A routine's declaration is a mention, skipped below.
+    // A relation's is not, so find the site of its name here.
+    let declarationKey = null;
+    if (!includeDefinition && !routineNamespace)
+        declarationKey = await declarationSiteKey(index, definition);
     const hasReachedCollectionLimit = () => collectionLimit !== undefined && references.length >= collectionLimit;
     const addReference = (file, range) => {
         if (hasReachedCollectionLimit())
             return;
-        const key = `${fileIdentityKey(file)}:${range.start.line}:${range.start.column}`;
-        if (!includeDefinition && key === definitionKey)
+        const key = siteKey(file, range.start.line, range.start.column);
+        if (key === declarationKey)
             return;
         if (seen.has(key))
             return;
@@ -383,13 +710,44 @@ export async function findSqlReferences(index, definition, options) {
             break;
         scannedFiles.push(file);
         const facts = await sqlFactsForFile(index, file);
+        if (routineNamespace) {
+            for (const { statement, mentions } of statementMentions(routineLookups, facts)) {
+                for (const mention of mentions) {
+                    if (hasReachedCollectionLimit())
+                        break;
+                    if (mention.namespace !== routineNamespace)
+                        continue;
+                    if (mention.kind === "definition") {
+                        // A definition always names itself, even when several definitions share the name. Only a
+                        // lookup that includes the declaration reports it.
+                        const namesDefinition = siteKey(file, statement.startLine, statement.startColumn) === definitionKey;
+                        if (includeDefinition && namesDefinition)
+                            addReference(file, mentionRange(statement, mention, keepParts));
+                        continue;
+                    }
+                    const candidates = routineCandidates(routineLookups, mention);
+                    if (!candidates.includes(definition))
+                        continue;
+                    if (candidates.length === 1)
+                        addReference(file, mentionRange(statement, mention, keepParts));
+                    else if (!ambiguousFiles.includes(file))
+                        ambiguousFiles.push(file);
+                }
+            }
+            continue;
+        }
+        const claimedStarts = hasRoutines ? claimedMentionStarts(routineLookups, facts) : undefined;
         for (const fact of facts) {
             if (hasReachedCollectionLimit())
                 break;
+            // The name in `DROP FUNCTION name` is a routine mention, never a table of the same name.
+            if (fact.kind === "drops_object" && sqlStatementDropsRoutine(fact.statementText))
+                continue;
+            const claimed = claimedStarts?.get(`${fact.startLine}:${fact.startColumn}`);
             for (const name of [fact.objectName, fact.relatedObjectName]) {
                 if (!name || !sqlNameResolvesToDefinition(lookup, name, definition))
                     continue;
-                for (const range of factReferenceRanges(fact, name)) {
+                for (const range of factReferenceRanges(fact, name, claimed, keepParts)) {
                     addReference(file, range);
                 }
             }
@@ -399,9 +757,14 @@ export async function findSqlReferences(index, definition, options) {
         for (const statement of sqlStatementSlices(facts)) {
             if (hasReachedCollectionLimit())
                 break;
-            for (const range of qualifiedReferenceRanges(lookup, statement, definition)) {
+            if (sqlStatementDropsRoutine(statement.text))
+                continue;
+            const claimed = claimedStarts?.get(`${statement.startLine}:${statement.startColumn}`);
+            const { ranges, ambiguous } = qualifiedReferenceRanges(lookup, routineLookups, statement, definition, claimed, keepParts);
+            for (const range of ranges)
                 addReference(file, range);
-            }
+            if (ambiguous && !ambiguousFiles.includes(file))
+                ambiguousFiles.push(file);
         }
     }
     references.sort((left, right) => {
@@ -426,7 +789,34 @@ export async function findSqlReferences(index, definition, options) {
             candidateFiles,
             scannedFiles,
             truncated,
+            strategyUnavailableFiles: ambiguousFiles,
         }),
     };
 }
+/**
+ * What each changed SQL symbol is called in graph edges: a table, view, or index by its name, a
+ * routine by its name and name space. The index stores no name space, and an index restored from a
+ * cache never read the statement, so the name space comes from the facts of the changed file.
+ */
+export async function sqlChangedSymbolTargets(index, symbols) {
+    const targets = new Map();
+    const namespacesByFile = new Map();
+    for (const symbol of symbols) {
+        if (symbol.kind === SymbolKind.Table || symbol.kind === SymbolKind.View || symbol.kind === SymbolKind.Index) {
+            targets.set(symbol, { name: symbol.name, namespace: "relation" });
+            continue;
+        }
+        if (symbol.kind !== SymbolKind.Routine)
+            continue;
+        const fileKey = fileIdentityKey(symbol.file);
+        let namespaces = namespacesByFile.get(fileKey);
+        if (!namespaces) {
+            namespaces = await routineNamespacesByStart(index, symbol.file);
+            namespacesByFile.set(fileKey, namespaces);
+        }
+        const { line, column } = symbol.range.start;
+        targets.set(symbol, { name: symbol.name, namespace: namespaces.get(`${line}:${column}`) ?? "callable" });
+    }
+    return targets;
+}
 //# sourceMappingURL=navigation.js.map