rip-lang 3.14.0 → 3.14.2

package/src/typecheck.js

@@ -15,7 +15,6 @@ import { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, ARIA_TYPE_DECLS, SIGNAL_INTERF
 import { hasSchemas } from './schema.js';
 import { createRequire } from 'module';
 import { readFileSync, existsSync, readdirSync } from 'fs';
-import { mapToSourcePos, offsetToLine, getLineText, findNearestWord, lineColToOffset, offsetToLineCol, adjustSwitchDiagnostic, isInjectedOverload, srcToOffset } from './sourcemap-utils.js';
 import { resolve, relative, dirname } from 'path';
 import { buildLineMap } from './sourcemaps.js';
 
@@ -1299,9 +1298,539 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
   return { tsContent, headerLines, hasTypes, srcToGen, genToSrc, srcColToGen, source, dts };
 }
 
-// ── Source mapping helpers (delegated to sourcemap-utils.js) ───────
+// ── Source-position mapping helpers ────────────────────────────────
+//
+// These utilities turn a TypeScript-virtual-file offset (the TS language
+// service hands us one per diagnostic) back into a Rip `{line, col}`
+// position the user can navigate to. The virtual file has a compiler-
+// injected header (declarations, intrinsics) plus the compiled body;
+// each entry carries its own `genToSrc` / `srcToGen` / `srcColToGen`
+// maps (built by buildLineMap in sourcemaps.js) plus the raw tsContent
+// and original Rip source.
+//
+// Most of the complexity below is Rip-specific heuristics for cases
+// where a single generated line maps to multiple source lines, or
+// where the compiler injects code that has no direct source (hoisted
+// `let` aggregates, overload signatures, switch-IIFE wrappers, etc.).
+
+// When a switch expression is the implicit return of a function, the compiler
+// wraps it in an IIFE: `return (() => { switch ... })()`.  Non-exhaustive
+// switches produce TS2322 on the IIFE return, which source-maps to the `switch`
+// line.  This helper detects that pattern and remaps the diagnostic to the
+// function's return-type annotation (matching TS behaviour on the raw .ts).
+// Returns { line, col, len } if remapped, or null if no adjustment needed.
+export function adjustSwitchDiagnostic(source, pos, code) {
+  if (code !== 2322) return null;
+  const srcLines = source.split('\n');
+  const line = srcLines[pos.line] || '';
+  if (!/^\s*switch\b/.test(line)) return null;
+
+  const switchIndent = line.match(/^(\s*)/)[1].length;
+  for (let i = pos.line - 1; i >= 0; i--) {
+    const defLine = srcLines[i];
+    const defMatch = defLine.match(/^(\s*)def\b/);
+    if (defMatch && defMatch[1].length < switchIndent) {
+      // Found enclosing function — look for return-type annotation "):: Type"
+      const retMatch = defLine.match(/\)\s*::\s*(\w+)\s*$/);
+      if (retMatch) {
+        const typeStart = defLine.lastIndexOf(retMatch[1]);
+        return { line: i, col: typeStart, len: retMatch[1].length };
+      }
+      return { line: i, col: defMatch[1].length, len: 3 }; // fallback: highlight `def`
+    }
+    // Stop if we leave the indentation context
+    if (/\S/.test(defLine) && !defLine.match(/^(\s*)/)[1].length && !/^\s*#/.test(defLine)) break;
+  }
+  return null;
+}
+
+export function getLineText(text, lineNum) {
+  let start = 0, line = 0;
+  for (let i = 0; i <= text.length; i++) {
+    if (i === text.length || text[i] === '\n') {
+      if (line === lineNum) return text.slice(start, i);
+      start = i + 1;
+      line++;
+    }
+  }
+  return '';
+}
+
+export function findNearestWord(text, word, approx) {
+  let bestIdx = -1, bestDist = Infinity, idx = 0;
+  while ((idx = text.indexOf(word, idx)) >= 0) {
+    const before = idx === 0 || /\W/.test(text[idx - 1]);
+    const after = idx + word.length >= text.length || /\W/.test(text[idx + word.length]);
+    if (before && after) {
+      const dist = Math.abs(idx - approx);
+      if (dist < bestDist) { bestDist = dist; bestIdx = idx; }
+    }
+    idx++;
+  }
+  return bestIdx;
+}
+
+// Check whether an offset falls on an injected function overload signature line
+// (generated by compileForCheck, not from user code).  These are body lines that
+// match `function NAME(...): TYPE;` and have no genToSrc entry.
+export function isInjectedOverload(entry, offset) {
+  const tsLine = offsetToLine(entry.tsContent, offset);
+  if (tsLine < entry.headerLines) return false;
+  if (entry.genToSrc.get(tsLine) !== undefined) return false;
+  const lineText = getLineText(entry.tsContent, tsLine);
+  return /^(?:async\s+)?function\s+\w+\s*\(/.test(lineText) && lineText.trimEnd().endsWith(';');
+}
+
+export function offsetToLine(text, offset) {
+  let line = 0;
+  for (let i = 0; i < offset && i < text.length; i++) {
+    if (text[i] === '\n') line++;
+  }
+  return line;
+}
+
+export function lineColToOffset(text, line, col) {
+  let r = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (r === line) return i + col;
+    if (text[i] === '\n') r++;
+  }
+  return text.length;
+}
+
+export function offsetToLineCol(text, offset) {
+  let line = 0, ls = 0;
+  for (let i = 0; i < offset && i < text.length; i++) {
+    if (text[i] === '\n') { line++; ls = i + 1; }
+  }
+  return { line, col: offset - ls };
+}
+
+// Map a TypeScript offset back to a Rip source { line, col } (0-based).
+// Returns null if the offset falls in the DTS header (and no match is found).
+//
+// `entry` must have: tsContent, headerLines, genToSrc, source, srcColToGen (optional)
+export function mapToSourcePos(entry, offset) {
+  const tsLine = offsetToLine(entry.tsContent, offset);
+  if (tsLine < entry.headerLines) {
+    // DTS preamble — find the identifier at the offset and locate it in the source
+    const genLineText = getLineText(entry.tsContent, tsLine);
+
+    // Skip compiler-injected stdlib declarations (declare function warn, etc.)
+    // — diagnostics on these lines are never user-authored and would incorrectly
+    // match string literals or identifiers in the source.
+    if (/^declare\s+function\s/.test(genLineText)) return null;
+
+    // If genToSrc has a mapping for this header line (e.g. imports, declarations),
+    // use it to target the correct source line for word matching.
+    const mappedSrcLine = entry.genToSrc.get(tsLine);
+
+    let lineStart = 0, curLine = 0;
+    for (let i = 0; i < entry.tsContent.length; i++) {
+      if (curLine === tsLine) { lineStart = i; break; }
+      if (entry.tsContent[i] === '\n') curLine++;
+    }
+    const genCol = offset - lineStart;
+    const wordMatch = genLineText.slice(genCol).match(/^\w+/);
+    if (wordMatch && entry.source) {
+      const word = wordMatch[0];
+      const srcLines = entry.source.split('\n');
+      const re = new RegExp('\\b' + word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
+
+      // If we have a direct line mapping, try that source line first
+      if (mappedSrcLine !== undefined) {
+        const m = re.exec(srcLines[mappedSrcLine]);
+        if (m) return { line: mappedSrcLine, col: m.index };
+        return { line: mappedSrcLine, col: genCol };
+      }
+
+      // For let/var declarations, the error word may appear on many source lines
+      // (e.g. `Status` referenced in multiple variable annotations). Narrow the
+      // search to the source line that declares the same variable.
+      const letMatch = genLineText.match(/^(?:export\s+)?(?:declare\s+)?(?:let|var)\s+(\w+)/);
+      if (letMatch) {
+        const varName = letMatch[1];
+        const varRe = new RegExp('\\b' + varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s*::');
+        for (let s = 0; s < srcLines.length; s++) {
+          if (varRe.test(srcLines[s])) {
+            const m = re.exec(srcLines[s]);
+            if (m) return { line: s, col: m.index };
+            return { line: s, col: 0 };
+          }
+        }
+      }
+
+      // Find enclosing type/interface from DTS context to narrow search —
+      // without this, duplicate member names (e.g. "host" in two types) always
+      // resolve to the first occurrence in the source.
+      let searchStart = 0;
+      for (let t = tsLine; t >= 0; t--) {
+        const tl = getLineText(entry.tsContent, t);
+        const tm = tl.match(/^(?:type|interface)\s+(\w+)/);
+        if (tm) {
+          const typeRe = new RegExp('(?:type|interface)\\s+' + tm[1].replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
+          for (let s = 0; s < srcLines.length; s++) {
+            if (typeRe.test(srcLines[s])) { searchStart = s; break; }
+          }
+          break;
+        }
+        if (/^\}/.test(tl.trim())) break; // exited a type block — not inside one
+      }
+
+      for (let s = searchStart; s < srcLines.length; s++) {
+        const m = re.exec(srcLines[s]);
+        if (m) return { line: s, col: m.index };
+      }
+    }
+    return null;
+  }
+
+  // Hoisted multi-variable `let` declaration (e.g. `let a, b, items, ...;`) —
+  // the compiler aggregates variable declarations into one line with no useful
+  // per-variable source mapping.  Detect the pattern (both top-level and inside
+  // functions), extract the word at the offset, and find its assignment in
+  // the Rip source.  Use the genToSrc mapping of the preceding TS line (the
+  // function declaration) to scope the search and avoid matching a same-named
+  // variable in a different function.
+  const hoistLine = getLineText(entry.tsContent, tsLine);
+  if (/^\s*let\s+[$\w]+\s*,/.test(hoistLine) && entry.source) {
+    let hl = 0;
+    for (let i = 0; i < entry.tsContent.length; i++) {
+      if (hl === tsLine) { hl = i; break; }
+      if (entry.tsContent[i] === '\n') hl++;
+    }
+    const hCol = offset - hl;
+    const hWord = hoistLine.slice(hCol).match(/^[$\w]+/);
+    if (hWord) {
+      const word = hWord[0];
+      const srcLines = entry.source.split('\n');
+      const assignRe = new RegExp('^' + word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s*(?:::|=!|:=|~=|=)');
+
+      // Scope the search: find the source line of the enclosing function by
+      // checking genToSrc for the TS line just before the hoisted let.
+      let searchStart = 0;
+      if (entry.genToSrc) {
+        for (let g = tsLine - 1; g >= 0; g--) {
+          const s = entry.genToSrc.get(g);
+          if (s !== undefined) { searchStart = s; break; }
+        }
+      }
+
+      for (let s = searchStart; s < srcLines.length; s++) {
+        if (assignRe.test(srcLines[s].trimStart())) {
+          const col = srcLines[s].indexOf(word);
+          if (col >= 0) return { line: s, col };
+        }
+      }
+      // Variable is on a hoisted let but has no recognisable assignment in
+      // the source (e.g. for-loop iterators, destructured names).  Return
+      // null so callers skip it rather than producing a garbage mapping.
+      return null;
+    }
+  }
+
+  // Injected function overload signatures (e.g. `function fetchUser(id: number): Promise<User>;`)
+  // have no genToSrc entry.  The backward-walk approximation below can map them to
+  // wildly wrong source lines.  Extract the function name and find its `def` in the source.
+  const bodyLine = getLineText(entry.tsContent, tsLine);
+  if (entry.genToSrc.get(tsLine) === undefined && entry.source) {
+    const overloadMatch = bodyLine.match(/^(?:async\s+)?function\s+(\w+)\s*\(/);
+    if (overloadMatch && bodyLine.trimEnd().endsWith(';')) {
+      const fnName = overloadMatch[1];
+      const srcLines = entry.source.split('\n');
+      const defRe = new RegExp('\\bdef\\s+' + fnName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
+      for (let s = 0; s < srcLines.length; s++) {
+        if (defRe.test(srcLines[s])) {
+          const col = srcLines[s].indexOf(fnName);
+          return { line: s, col: col >= 0 ? col : 0 };
+        }
+      }
+    }
+  }
+
+  // Resolve source line from genToSrc
+  let srcLine = entry.genToSrc.get(tsLine);
+  if (srcLine === undefined) {
+    // Walk backward to find nearest mapped gen line
+    let best = -1;
+    for (const [g] of entry.genToSrc) if (g <= tsLine && g > best) best = g;
+    if (best >= 0) {
+      srcLine = entry.genToSrc.get(best) + (tsLine - best);
+    } else {
+      srcLine = tsLine - entry.headerLines;
+    }
+  }
+
+  // Compute generated column
+  let lineStart = 0, curLine = 0;
+  for (let i = 0; i < entry.tsContent.length; i++) {
+    if (curLine === tsLine) { lineStart = i; break; }
+    if (entry.tsContent[i] === '\n') curLine++;
+  }
+  const genCol = offset - lineStart;
+
+  // Remap column via text matching
+  const genText = getLineText(entry.tsContent, tsLine);
+  let srcCol = genCol;
+  let approx = genCol;  // default: assume same column
+  // Scan ALL source lines for mappings to this gen line — a multi-line Rip
+  // expression (e.g. object literal) may compile to a single gen line, so
+  // multiple source lines can share one gen line.  Pick the closest genCol.
+  // On ties, prefer the source line that genToSrc already identified (e.g.
+  // from an @rip-src annotation) so that stub render-block expressions land
+  // on their correct source lines instead of a sibling attribute line.
+  if (entry.srcColToGen) {
+    const origSrcLine = srcLine;
+    let bestDist = Infinity;
+    for (const [sl, entries] of entry.srcColToGen) {
+      for (const e of entries) {
+        if (e.genLine === tsLine) {
+          const dist = Math.abs(e.genCol - genCol);
+          if (dist < bestDist || (dist === bestDist && sl === origSrcLine)) {
+            bestDist = dist;
+            srcLine = sl;
+            approx = e.srcCol + (genCol - e.genCol);
+          }
+        }
+      }
+    }
+  }
+  const srcText = entry.source ? getLineText(entry.source, srcLine) : '';
+  // Text-match: find the word at genCol in the gen line, then locate it in the source line
+  if (srcText) {
+    let wordAt = genText.slice(genCol).match(/^\w+/);
+    // Quoted string literal (e.g. __ripEl('tag')) — peek inside the quotes
+    if (!wordAt && (genText[genCol] === "'" || genText[genCol] === '"')) {
+      wordAt = genText.slice(genCol + 1).match(/^\w+/);
+    }
+    if (wordAt) {
+      let word = wordAt[0];
+      let idx = findNearestWord(srcText, word, approx);
+      // __bind_xxx__ → xxx: two-way binding props use mangled names in gen
+      if (idx < 0 && word.startsWith('__bind_') && word.endsWith('__')) {
+        word = word.slice(7, -2);
+        idx = findNearestWord(srcText, word, approx);
+      }
+      if (idx >= 0) return { line: srcLine, col: idx };
+    }
+    if (genCol > 0 && (!wordAt || genCol >= genText.length)) {
+      let wordBefore = genText.slice(0, genCol).match(/(\w+)$/);
+      // Closing quote — peek inside to find the word (e.g. end of __ripEl('tag'))
+      if (!wordBefore && (genText[genCol - 1] === "'" || genText[genCol - 1] === '"')) {
+        wordBefore = genText.slice(0, genCol - 1).match(/(\w+)$/);
+      }
+      if (wordBefore) {
+        let word = wordBefore[0];
+        let idx = findNearestWord(srcText, word, approx - word.length);
+        // __bind_xxx__ → xxx: two-way binding props use mangled names in gen
+        if (idx < 0 && word.startsWith('__bind_') && word.endsWith('__')) {
+          word = word.slice(7, -2);
+          idx = findNearestWord(srcText, word, approx - word.length);
+        }
+        if (idx >= 0) return { line: srcLine, col: idx + word.length };
+        // Injected property access (e.g. clicks.value from clicks :=) — map to end of object identifier
+        const dotMatch = genText.slice(0, genCol - wordBefore[0].length).match(/(\w+)\.$/);
+        if (dotMatch) {
+          const objIdx = findNearestWord(srcText, dotMatch[1], approx - wordBefore[0].length - dotMatch[1].length - 1);
+          if (objIdx >= 0) return { line: srcLine, col: objIdx + dotMatch[1].length };
+        }
+      }
+    }
+    srcCol = Math.max(0, approx);
+  }
+
+  // Word not found on mapped line (or line was empty) — search nearby lines
+  // (handles cases where multiple source lines compress to one generated line,
+  // e.g. constructor params, or srcLine is blank)
+  {
+    let wordFallback = genText.slice(genCol).match(/^\w+/);
+    // Quoted string literal — peek inside the quotes (e.g. __RipProps<'inputz'>)
+    if (!wordFallback && (genText[genCol] === "'" || genText[genCol] === '"')) {
+      wordFallback = genText.slice(genCol + 1).match(/^\w+/);
+    }
+    if (wordFallback) {
+      let word = wordFallback[0];
+      if (word.startsWith('__bind_') && word.endsWith('__')) word = word.slice(7, -2);
+      const srcLines = entry.source.split('\n');
+      const re = new RegExp('\\b' + word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
+      for (let delta = 0; delta <= 10; delta++) {
+        for (const d of delta === 0 ? [srcLine] : [srcLine + delta, srcLine - delta]) {
+          if (d >= 0 && d < srcLines.length) {
+            const m = re.exec(srcLines[d]);
+            if (m) return { line: d, col: m.index };
+          }
+        }
+      }
+    }
+  }
+
+  // When text matching failed entirely (generated identifier like _2 doesn't
+  // exist in source), srcCol may land on whitespace or past EOL.  Fall back to
+  // the first word on the source line so the diagnostic highlights something
+  // meaningful (e.g. the component name on a `Button` line).
+  if (srcText) {
+    if (srcCol >= srcText.length || /^\s*$/.test(srcText.slice(srcCol, srcCol + 1))) {
+      const firstWord = srcText.match(/^\s*(\w+)/);
+      if (firstWord) return { line: srcLine, col: firstWord.index + firstWord[0].length - firstWord[1].length };
+    }
+  }
+  return { line: srcLine, col: srcCol };
+}
+
+// Map a Rip source (line, col) to a TypeScript virtual file byte offset.
+// This is the forward direction: source → generated (used for hover, definition, etc.)
+//
+// `entry` must have: tsContent, source, srcToGen, srcColToGen (optional)
+// Returns undefined if no mapping can be established.
+export function srcToOffset(entry, line, col) {
+  if (!entry) return undefined;
+  let genLine = entry.srcToGen.get(line);
+  let genColHint = -1;
+  let bestSrcCol = -1;
+
+  // Column-aware lookup
+  if (entry.srcColToGen) {
+    const colEntries = entry.srcColToGen.get(line);
+    if (colEntries && colEntries.length > 0) {
+      let best = colEntries[0];
+      for (const e of colEntries) {
+        if (e.srcCol <= col && (best.srcCol > col || e.srcCol > best.srcCol)) best = e;
+      }
+      if (best.srcCol > col) {
+        for (const e of colEntries) {
+          if (Math.abs(e.srcCol - col) < Math.abs(best.srcCol - col)) best = e;
+        }
+      }
+      genLine = best.genLine;
+      genColHint = best.genCol;
+      bestSrcCol = best.srcCol;
+    }
+  }
+
+  if (genLine === undefined) {
+    let best = -1;
+    for (const [s] of entry.srcToGen) if (s <= line && s > best) best = s;
+    if (best < 0) return undefined;
+    genLine = entry.srcToGen.get(best);
+  }
+
+  const srcLines = entry.source.split('\n');
+  const genLines = entry.tsContent.split('\n');
+  const KEYWORDS = new Set(['interface', 'type', 'enum', 'class', 'export', 'declare', 'extends', 'implements', 'import', 'from', 'def', 'const', 'let', 'var']);
+
+  if (srcLines[line] != null && genLines[genLine] != null) {
+    const srcText = srcLines[line];
+    const genText = genLines[genLine];
+    const leftPart = srcText.substring(0, col).match(/\w*$/)?.[0] || '';
+    const rightPart = srcText.substring(col).match(/^\w*/)?.[0] || '';
+    let wordMatch = (leftPart + rightPart) ? [leftPart + rightPart] : null;
+    if (wordMatch && KEYWORDS.has(wordMatch[0])) {
+      const after = srcText.substring(col + wordMatch[0].length).match(/\s+(\w+)/);
+      if (after) wordMatch = [after[1]];
+    }
+    if (wordMatch) {
+      const word = wordMatch[0];
+      const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const wordStart = col - leftPart.length;
+      const useHint = genColHint >= 0 && bestSrcCol >= wordStart && bestSrcCol < wordStart + word.length;
+
+      // Prefer the overload signature line (genLine-1) when it exists and
+      // contains the same identifier — overloads carry typed parameters.
+      let targetLine = genLine;
+      let targetText = genText;
+      if (genLine > 0) {
+        const prevText = genLines[genLine - 1] || '';
+        if (/^(?:export\s+)?function\s+\w+\(.*\).*;\s*$/.test(prevText)) {
+          const re0 = new RegExp('\\b' + escaped + '\\b');
+          if (re0.test(prevText)) { targetLine = genLine - 1; targetText = prevText; }
+        }
+      }
+
+      const re = new RegExp('\\b' + escaped + '\\b', 'g');
+      let m, bestCol = -1, bestDist = Infinity;
+      // When the word doesn't fall exactly on a mapped srcCol, extrapolate
+      // the expected gen column from the nearest mapping entry.  This avoids
+      // picking a same-named word inside a string literal that happens to be
+      // closer to the raw source column.
+      const expectedGenCol = useHint ? genColHint
+        : genColHint >= 0 ? genColHint + (col - bestSrcCol) : col;
+      while ((m = re.exec(targetText)) !== null) {
+        const dist = Math.abs(m.index - expectedGenCol);
+        if (dist < bestDist) { bestDist = dist; bestCol = m.index; }
+      }
+      if (bestCol >= 0) return lineColToOffset(entry.tsContent, targetLine, bestCol);
+
+      // Fall back to original genLine if overload didn't match
+      if (targetLine !== genLine) {
+        const re1b = new RegExp('\\b' + escaped + '\\b', 'g');
+        let m1b, bestCol1b = -1, bestDist1b = Infinity;
+        while ((m1b = re1b.exec(genText)) !== null) {
+          const dist = Math.abs(m1b.index - expectedGenCol);
+          if (dist < bestDist1b) { bestDist1b = dist; bestCol1b = m1b.index; }
+        }
+        if (bestCol1b >= 0) return lineColToOffset(entry.tsContent, genLine, bestCol1b);
+      }
 
-export { mapToSourcePos, offsetToLine, getLineText, findNearestWord, lineColToOffset, offsetToLineCol, adjustSwitchDiagnostic, isInjectedOverload, srcToOffset } from './sourcemap-utils.js';
+      // Word not on mapped line — search nearby generated lines
+      for (let delta = 1; delta <= 5; delta++) {
+        for (const tryLine of [genLine + delta, genLine - delta]) {
+          if (tryLine < 0 || tryLine >= genLines.length) continue;
+          const tryText = genLines[tryLine];
+          const re2 = new RegExp('\\b' + escaped + '\\b', 'g');
+          let m2, best2 = -1, bestDist2 = Infinity;
+          while ((m2 = re2.exec(tryText)) !== null) {
+            const dist2 = Math.abs(m2.index - col);
+            if (dist2 < bestDist2) { bestDist2 = dist2; best2 = m2.index; }
+          }
+          if (best2 >= 0) return lineColToOffset(entry.tsContent, tryLine, best2);
+        }
+      }
+
+      // Neighbor-line fallback: when the word isn't on the mapped gen line or
+      // nearby ±5 lines, check neighboring source lines for srcColToGen entries
+      // that point to gen lines containing the word.  Handles multi-line
+      // expressions collapsed to one gen line, bodiless overload signatures
+      // mapped to wrong gen lines, etc.
+      if (entry.srcColToGen) {
+        const candidateGenLines = new Set();
+        for (let d = 0; d <= 10; d++) {
+          for (const sl of d === 0 ? [line] : [line - d, line + d]) {
+            if (sl < 0) continue;
+            const ce = entry.srcColToGen.get(sl);
+            if (ce) {
+              for (const e of ce) candidateGenLines.add(e.genLine);
+            }
+          }
+        }
+        // Also try gen lines near those candidates (overload signatures are
+        // typically on the line just before the function body)
+        const expanded = new Set(candidateGenLines);
+        for (const gl of candidateGenLines) {
+          for (let d = 1; d <= 3; d++) {
+            expanded.add(gl - d);
+            expanded.add(gl + d);
+          }
+        }
+        let bestAlt = -1, bestAltCol = -1, bestAltDist = Infinity;
+        for (const gl of expanded) {
+          if (gl < 0 || gl >= genLines.length) continue;
+          const altText = genLines[gl] || '';
+          const re3 = new RegExp('\\b' + escaped + '\\b', 'g');
+          let m3;
+          while ((m3 = re3.exec(altText)) !== null) {
+            const dist3 = Math.abs(m3.index - expectedGenCol);
+            if (dist3 < bestAltDist) { bestAltDist = dist3; bestAltCol = m3.index; bestAlt = gl; }
+          }
+        }
+        if (bestAltCol >= 0) return lineColToOffset(entry.tsContent, bestAlt, bestAltCol);
+      }
+    }
+  }
+
+  const genText = entry.tsContent.split('\n')[genLine] || '';
+  if (col < genText.length) return lineColToOffset(entry.tsContent, genLine, col);
+  return lineColToOffset(entry.tsContent, genLine, 0);
+}
 
 // Map a TypeScript diagnostic offset back to a Rip source line number.
 // Returns -1 if the offset falls in the DTS header.