hullproof 0.0.0-stage → 0.5.0

package/src/map/lex-more.ts

@@ -0,0 +1,152 @@
+// Masking for the languages added after JavaScript and Python: Go, Ruby and PHP (second wave), Java and C# (which have light profiles),
+// and Kotlin, Swift and Rust (masking only). Same contract as mask() in lex.ts: a copy of the text with the same length in which
+// comments and the insides of string literals are spaces, quote characters and newlines kept, so a position in the copy is the same
+// position in the original.
+export type MoreLang = 'go' | 'rb' | 'php' | 'java' | 'cs';       // languages with a body profile (light-profiles.ts)
+export type MaskLang = MoreLang | 'kt' | 'swift' | 'rs';
+
+// Java, C#, Kotlin, Swift and Rust: line and block comments, "strings" with escapes, text blocks and raw strings, character literals.
+function maskC(text: string, lang: 'java' | 'cs' | 'kt' | 'swift' | 'rs'): string {
+  const n = text.length;
+  const out: string[] = [];
+  let i = 0;
+  const put = (from: number, to: number): void => { out.push(blank(text.slice(from, to))); };
+  const keep = (from: number, to: number): void => { out.push(text.slice(from, to)); };
+  const closed = (open: number, close: string, escapes: boolean, doubled = false): number => {
+    // index of the closing delimiter at or after open, or -1
+    let j = open;
+    while (j < n) {
+      if (escapes && text[j] === '\\') { j += 2; continue; }
+      if (text.startsWith(close, j)) { if (doubled && text.startsWith(close + close, j)) { j += close.length * 2; continue; } return j; }
+      j++;
+    }
+    return -1;
+  };
+  while (i < n) {
+    const c = text[i];
+    const c2 = text[i + 1];
+    if (c === '/' && c2 === '/') { const e = text.indexOf('\n', i); const end = e < 0 ? n : e; put(i, end); i = end; continue; }
+    if (c === '/' && c2 === '*') { const e = text.indexOf('*/', i + 2); const end = e < 0 ? n : e + 2; put(i, end); i = end; continue; }
+    // C#: $"...", @"...", $@"..." ; raw strings in every language: """..."""
+    let pre = 0;
+    if (lang === 'cs') { while (text[i + pre] === '$' || text[i + pre] === '@') pre++; }
+    if (lang === 'rs' && (c === 'r' || (c === 'b' && c2 === 'r')) && /^b?r#*"/.test(text.slice(i, i + 12))) {
+      const m = /^b?r(#*)"/.exec(text.slice(i, i + 12))!;
+      const start = i + m[0].length;
+      const e = text.indexOf('"' + m[1], start);
+      const end = e < 0 ? n : e;
+      keep(i, start); put(start, end); if (e >= 0) keep(e, e + 1 + m[1].length); i = e < 0 ? n : e + 1 + m[1].length; continue;
+    }
+    const q = i + pre;
+    if (text[q] === '"') {
+      if (text.startsWith('"""', q)) {
+        const e = text.indexOf('"""', q + 3);
+        const end = e < 0 ? n : e;
+        keep(i, q + 3); put(q + 3, end); if (e >= 0) keep(e, e + 3); i = e < 0 ? n : e + 3; continue;
+      }
+      const verbatim = lang === 'cs' && text.slice(i, q).includes('@');
+      const e = closed(q + 1, '"', !verbatim, verbatim);
+      const end = e < 0 ? n : e;
+      keep(i, q + 1); put(q + 1, end); if (e >= 0) keep(e, e + 1); i = e < 0 ? n : e + 1; continue;
+    }
+    if (c === '\'' && lang !== 'rs' || (c === '\'' && lang === 'rs' && /^'(?:\\.[^']*|[^\\'])'/.test(text.slice(i, i + 12)))) {
+      const e = closed(i + 1, '\'', true);
+      if (e >= 0 && e - i <= 12) { keep(i, i + 1); put(i + 1, e); keep(e, e + 1); i = e + 1; continue; }
+    }
+    keep(i, i + 1);
+    i++;
+  }
+  return out.join('');
+}
+
+const blank = (s: string): string => s.replace(/[^\n]/g, ' ');
+
+export function maskMore(text: string, lang: MaskLang): string {
+  if (lang === 'java' || lang === 'cs' || lang === 'kt' || lang === 'swift' || lang === 'rs') return maskC(text, lang);
+  const n = text.length;
+  const out: string[] = [];
+  const put = (from: number, to: number): void => { out.push(blank(text.slice(from, to))); };
+  const keep = (from: number, to: number): void => { out.push(text.slice(from, to)); };
+  let i = 0;
+  let prevSig = '';
+  let prevWord = '';
+  // Heredoc terminators waiting for the end of the current line (Ruby and PHP).
+  let pending: { id: string; squiggly: boolean }[] = [];
+
+  const quoted = (q: string, escapes: boolean): void => {
+    let j = i + 1;
+    while (j < n && text[j] !== q && (text[j] !== '\n' || lang !== 'go')) { if (escapes && text[j] === '\\') j++; j++; }
+    const close = j < n && text[j] === q ? j : -1;
+    keep(i, i + 1);
+    put(i + 1, close < 0 ? Math.min(j, n) : close);
+    if (close >= 0) keep(close, close + 1);
+    i = close < 0 ? Math.min(j, n) : close + 1;
+    prevSig = q;
+    prevWord = '';
+  };
+
+  const flushHeredocs = (): void => {
+    // i is just after a newline. Blank lines until each pending terminator line.
+    for (const h of pending) {
+      for (;;) {
+        if (i >= n) break;
+        const e = text.indexOf('\n', i);
+        const end = e < 0 ? n : e;
+        const row = text.slice(i, end);
+        const isEnd = (lang === 'rb' ? row.trim() : row.replace(/^\s+/, '').replace(/[;,)\s]+$/, '')) === h.id;
+        if (isEnd) { keep(i, end); i = end; break; }
+        put(i, end);
+        i = end;
+        if (i < n) { out.push('\n'); i++; }
+      }
+    }
+    pending = [];
+  };
+
+  while (i < n) {
+    const c = text[i];
+    const c2 = text[i + 1];
+    if (c === '\n') {
+      keep(i, i + 1); i++;
+      if (pending.length) flushHeredocs();
+      // Ruby block comments
+      if (lang === 'rb' && text.startsWith('=begin', i)) { const e = text.indexOf('\n=end', i); const end = e < 0 ? n : text.indexOf('\n', e + 1) < 0 ? n : text.indexOf('\n', e + 1); put(i, end); i = end; }
+      continue;
+    }
+    if (lang === 'go') {
+      if (c === '/' && c2 === '/') { const e = text.indexOf('\n', i); const end = e < 0 ? n : e; put(i, end); i = end; continue; }
+      if (c === '/' && c2 === '*') { const e = text.indexOf('*/', i + 2); const end = e < 0 ? n : e + 2; put(i, end); i = end; continue; }
+      if (c === '"') { quoted('"', true); continue; }
+      if (c === '\'') { quoted('\'', true); continue; }
+      if (c === '`') { const e = text.indexOf('`', i + 1); const end = e < 0 ? n : e; keep(i, i + 1); put(i + 1, end); if (e >= 0) keep(e, e + 1); i = e < 0 ? n : e + 1; prevSig = '`'; continue; }
+    } else if (lang === 'rb') {
+      if (i === 0 && text.startsWith('=begin')) { const e = text.indexOf('\n=end'); const end = e < 0 ? n : e + 5; put(0, end); i = end; continue; }
+      if (c === '#') { const e = text.indexOf('\n', i); const end = e < 0 ? n : e; put(i, end); i = end; continue; }
+      const hd = c === '<' && c2 === '<' ? /^<<([~-]?)(['"`]?)([A-Za-z_]\w*)\2/.exec(text.slice(i, i + 60)) : null;
+      if (hd && !/[\w)\]]\s*$/.test(text.slice(Math.max(0, i - 2), i).replace(/ $/, '')) || (hd && /[=(,]\s*$/.test(text.slice(Math.max(0, i - 12), i)))) {
+        pending.push({ id: hd![3], squiggly: hd![1] === '~' });
+        keep(i, i + hd![0].length); i += hd![0].length; continue;
+      }
+      if (c === '"' || c === '\'' || c === '`') { quoted(c, true); continue; }
+      if (c === '/' && /^[(,=~{|&!;]$/.test(prevSig) || (c === '/' && /^(?:when|if|unless|and|or|not|return|split|match|scan|gsub|sub)$/.test(prevWord))) {
+        let j = i + 1; let cls = false;
+        while (j < n && text[j] !== '\n') { if (text[j] === '\\') { j += 2; continue; } if (text[j] === '[') cls = true; else if (text[j] === ']') cls = false; else if (text[j] === '/' && !cls) break; j++; }
+        if (j < n && text[j] === '/') { keep(i, i + 1); put(i + 1, j); keep(j, j + 1); i = j + 1; prevSig = '/'; prevWord = ''; continue; }
+      }
+    } else {
+      if ((c === '/' && c2 === '/') || (c === '#' && c2 !== '[')) { const e = text.indexOf('\n', i); const end = e < 0 ? n : e; put(i, end); i = end; continue; }
+      if (c === '/' && c2 === '*') { const e = text.indexOf('*/', i + 2); const end = e < 0 ? n : e + 2; put(i, end); i = end; continue; }
+      const hd = c === '<' && c2 === '<' && text[i + 2] === '<' ? /^<<<\s*(['"]?)([A-Za-z_]\w*)\1/.exec(text.slice(i, i + 60)) : null;
+      if (hd) { pending.push({ id: hd[2], squiggly: true }); keep(i, i + hd[0].length); i += hd[0].length; continue; }
+      if (c === '"' || c === '\'') { quoted(c, true); continue; }
+    }
+    keep(i, i + 1);
+    if (!/\s/.test(c)) {
+      prevSig = c;
+      if (/[A-Za-z_]/.test(c)) { const m = /^[A-Za-z_]\w*/.exec(text.slice(i, i + 20)); if (m) { prevWord = m[0]; out.pop(); keep(i, i + m[0].length); i += m[0].length; prevSig = 'w'; continue; } }
+      else prevWord = '';
+    }
+    i++;
+  }
+  return out.join('');
+}

package/src/map/lex.ts

@@ -0,0 +1,274 @@
+// Text helpers for the extractors (approach (b) in docs/PHASE-2-DESIGN.md): blank out comments and string contents while
+// keeping every position, match brackets, and cut function bodies. No parser, no dependency.
+
+import { maskMore } from './lex-more.ts';
+
+export type Lang = 'js' | 'py' | 'go' | 'rb' | 'php' | 'java' | 'cs' | 'kt' | 'swift' | 'rs';
+
+const blank = (s: string): string => s.replace(/[^\n]/g, ' ');
+
+
+// Whether a "/" at `i` starts a regular expression literal (and is not a division or a JSX closing tag), judged from the
+// text before it.
+function regexAllowed(text: string, i: number): boolean {
+  let k = i - 1;
+  while (k >= 0 && /\s/.test(text[k])) k--;
+  if (k < 0) return true;
+  if ('(,=:[!&|?{;+-*%~^'.includes(text[k])) return true;
+  const m = /([A-Za-z_$][\w$]*)$/.exec(text.slice(Math.max(0, k - 12), k + 1));
+  return !!m && /^(return|typeof|case|in|of|delete|void|throw|new|else|do|yield|await)$/.test(m[1]);
+}
+
+// A copy of `text` with the same length in which comments and the insides of string literals are spaces. Quote characters
+// and newlines stay, so a regular expression run on the copy never matches inside a comment or a string, and a position in
+// the copy is the same position in the original.
+export function mask(text: string, lang: Lang): string {
+  if (lang !== 'js' && lang !== 'py') return maskMore(text, lang);
+  const n = text.length;
+  const out: string[] = [];
+  let i = 0;
+  let prevSig = '';
+  const put = (from: number, to: number): void => { out.push(blank(text.slice(from, to))); };
+  const keep = (from: number, to: number): void => { out.push(text.slice(from, to)); };
+
+  const skipTemplate = (start: number): number => { // start is the index of the opening backtick; returns the index after the closing one
+    let j = start + 1;
+    while (j < n) {
+      const c = text[j];
+      if (c === '\\') { j += 2; continue; }
+      if (c === '`') return j + 1;
+      if (c === '$' && text[j + 1] === '{') {
+        let depth = 1;
+        j += 2;
+        while (j < n && depth > 0) {
+          const d = text[j];
+          if (d === '`') { j = skipTemplate(j); continue; }
+          if (d === '"' || d === "'") { j++; while (j < n && text[j] !== d && text[j] !== '\n') { if (text[j] === '\\') j++; j++; } j++; continue; }
+          if (d === '{') depth++;
+          else if (d === '}') depth--;
+          j++;
+        }
+        continue;
+      }
+      j++;
+    }
+    return n;
+  };
+
+  while (i < n) {
+    const c = text[i];
+    const c2 = text[i + 1];
+    if (lang === 'js') {
+      if (c === '/' && c2 === '/') { const e = text.indexOf('\n', i); const end = e < 0 ? n : e; put(i, end); i = end; continue; }
+      if (c === '/' && c2 === '*') { const e = text.indexOf('*/', i + 2); const end = e < 0 ? n : e + 2; put(i, end); i = end; continue; }
+      if (c === '`') { const end = skipTemplate(i); keep(i, i + 1); put(i + 1, Math.max(i + 1, end - 1)); if (end - 1 > i) keep(end - 1, end); i = end; prevSig = '`'; continue; }
+      if (c === '"' || c === "'") {
+        let j = i + 1;
+        while (j < n && text[j] !== c && text[j] !== '\n') { if (text[j] === '\\') j++; j++; }
+        const close = j < n && text[j] === c ? j : -1;
+        keep(i, i + 1);
+        put(i + 1, close < 0 ? Math.min(j, n) : close);
+        if (close >= 0) keep(close, close + 1);
+        i = close < 0 ? Math.min(j, n) : close + 1;
+        prevSig = c;
+        continue;
+      }
+      if (c === '/' && regexAllowed(text, i)) {
+        // regular expression literal
+        let j = i + 1;
+        let inClass = false;
+        while (j < n && text[j] !== '\n') {
+          if (text[j] === '\\') { j += 2; continue; }
+          if (text[j] === '[') inClass = true;
+          else if (text[j] === ']') inClass = false;
+          else if (text[j] === '/' && !inClass) break;
+          j++;
+        }
+        if (j < n && text[j] === '/') { keep(i, i + 1); put(i + 1, j); keep(j, j + 1); i = j + 1; prevSig = '/'; continue; }
+      }
+    } else {
+      if (c === '#') { const e = text.indexOf('\n', i); const end = e < 0 ? n : e; put(i, end); i = end; continue; }
+      if (c === '"' || c === "'") {
+        const triple = text[i + 1] === c && text[i + 2] === c;
+        if (triple) {
+          const e = text.indexOf(c.repeat(3), i + 3);
+          const end = e < 0 ? n : e + 3;
+          keep(i, i + 3); put(i + 3, Math.max(i + 3, end - 3)); if (e >= 0) keep(end - 3, end);
+          i = end; prevSig = c; continue;
+        }
+        let j = i + 1;
+        while (j < n && text[j] !== c && text[j] !== '\n') { if (text[j] === '\\') j++; j++; }
+        const close = j < n && text[j] === c ? j : -1;
+        keep(i, i + 1);
+        put(i + 1, close < 0 ? Math.min(j, n) : close);
+        if (close >= 0) keep(close, close + 1);
+        i = close < 0 ? Math.min(j, n) : close + 1;
+        prevSig = c;
+        continue;
+      }
+    }
+    keep(i, i + 1);
+    if (!/\s/.test(c)) prevSig = c;
+    i++;
+  }
+  return out.join('');
+}
+
+// Line numbers from character positions, by binary search over the line starts. Built once per file.
+export class Lines {
+  private starts: number[] = [0];
+  constructor(text: string) { for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) this.starts.push(i + 1); }
+  at(index: number): number {
+    let lo = 0;
+    let hi = this.starts.length - 1;
+    while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (this.starts[mid] <= index) lo = mid; else hi = mid - 1; }
+    return lo + 1;
+  }
+  start(line: number): number { return this.starts[Math.max(0, Math.min(this.starts.length - 1, line - 1))]; }
+  get count(): number { return this.starts.length; }
+}
+
+const PAIR: Record<string, string> = { '(': ')', '{': '}', '[': ']' };
+
+// The index just past the bracket that closes the one at `open`, in masked text, or -1.
+export function closeOf(masked: string, open: number): number {
+  const stack: string[] = [];
+  for (let i = open; i < masked.length; i++) {
+    const c = masked[i];
+    if (PAIR[c]) stack.push(PAIR[c]);
+    else if (c === ')' || c === '}' || c === ']') {
+      if (c !== stack[stack.length - 1]) return -1;
+      stack.pop();
+      if (stack.length === 0) return i + 1;
+    }
+  }
+  return -1;
+}
+
+// Top level argument ranges of the call whose "(" is at `open`: [{start, end}] with end exclusive, trimmed.
+export function splitArgs(masked: string, open: number): { start: number; end: number }[] {
+  const close = closeOf(masked, open);
+  if (close < 0) return [];
+  const args: { start: number; end: number }[] = [];
+  let depth = 0;
+  let from = open + 1;
+  const push = (end: number): void => {
+    let s = from;
+    let e = end;
+    while (s < e && /\s/.test(masked[s])) s++;
+    while (e > s && /\s/.test(masked[e - 1])) e--;
+    if (e > s) args.push({ start: s, end: e });
+  };
+  for (let i = open + 1; i < close - 1; i++) {
+    const c = masked[i];
+    if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') depth--;
+    else if (c === ',' && depth === 0) { push(i); from = i + 1; }
+    else if (c === '=' && masked[i + 1] === '>' ) { /* arrow: the body follows; handled by depth of braces */ }
+  }
+  push(close - 1);
+  return args;
+}
+
+// The end (exclusive) of the statement that starts at `from`: the first ";" at depth 0, or a newline at depth 0 after which
+// the next code character does not continue the expression (a ".", "?", ":", operator or closing bracket).
+export function statementEnd(masked: string, from: number): number {
+  let depth = 0;
+  for (let i = from; i < masked.length; i++) {
+    const c = masked[i];
+    if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') { if (depth === 0) return i; depth--; }
+    else if (c === ';' && depth === 0) return i;
+    else if (c === '\n' && depth === 0) {
+      const rest = masked.slice(i + 1, i + 200);
+      const next = /\S/.exec(rest);
+      const prev = masked.slice(from, i).trimEnd().slice(-1);
+      if (!next) return i;
+      const nc = rest[next.index];
+      if (nc === '.' || nc === '?' || nc === ':' || nc === '+' || nc === '|' || nc === '&' || nc === ',' || nc === ')' || nc === ']') continue;
+      if (prev === ',' || prev === '+' || prev === '=' || prev === '?' || prev === ':' || prev === '|' || prev === '&' || prev === '(') continue;
+      return i;
+    }
+  }
+  return masked.length;
+}
+
+export interface Extent { start: number; end: number; bodyStart: number }
+
+// The extent of the JavaScript or TypeScript function that begins at `from` (the index of "async", "function", "(" or a
+// single parameter name before "=>"). bodyStart is the first index of the body text (the "{" or the first token of an
+// expression body). Returns null when the text there is not a function.
+// `method`: the text is a class method, so a "{" after the return type at bracket depth 0 is the body and never an object type.
+export function jsFunction(masked: string, from: number, method = false): Extent | null {
+  let i = from;
+  const ws = (): void => { while (i < masked.length && /\s/.test(masked[i])) i++; };
+  ws();
+  if (masked.startsWith('async', i) && /\W/.test(masked[i + 5] ?? ' ')) { i += 5; ws(); }
+  let isFunctionKeyword = false;
+  if (masked.startsWith('function', i) && /\W/.test(masked[i + 8] ?? ' ')) { isFunctionKeyword = true; i += 8; ws(); if (masked[i] === '*') { i++; ws(); } while (/[\w$]/.test(masked[i] ?? '')) i++; ws(); if (masked[i] === '<') { let d = 0; for (; i < masked.length; i++) { if (masked[i] === '<') d++; else if (masked[i] === '>') { d--; if (d === 0) { i++; break; } } } ws(); } }
+  if (masked[i] === '(') {
+    const pc = closeOf(masked, i);
+    if (pc < 0) return null;
+    i = pc;
+  } else if (!isFunctionKeyword && /[\w$]/.test(masked[i] ?? '')) {
+    while (/[\w$]/.test(masked[i] ?? '')) i++;
+    ws();
+    if (!(masked[i] === '=' && masked[i + 1] === '>')) return null;
+  } else return null;
+  ws();
+  // Optional return type annotation: scan to the "{" (function) or "=>" (arrow) at bracket depth 0.
+  if (masked[i] === ':') {
+    let depth = 0;
+    for (i = i + 1; i < masked.length; i++) {
+      const c = masked[i];
+      if (c === '(' || c === '[') depth++;
+      else if (c === ')' || c === ']') depth--;
+      else if (c === '<') depth++;
+      else if (c === '>' && masked[i - 1] !== '=') depth--;
+      else if (c === '{' && depth <= 0 && !isFunctionKeyword && !method) { depth++; }
+      else if (c === '}' && depth > 0 && !isFunctionKeyword && !method) { depth--; }
+      else if (c === '=' && masked[i + 1] === '>' && depth <= 0) break;
+      else if (c === '{' && depth <= 0 && (isFunctionKeyword || method)) break;
+    }
+  }
+  ws();
+  if (masked[i] === '=' && masked[i + 1] === '>') {
+    i += 2;
+    ws();
+    if (masked[i] === '{') { const e = closeOf(masked, i); return e < 0 ? null : { start: from, end: e, bodyStart: i }; }
+    const e = statementEnd(masked, i);
+    return { start: from, end: e, bodyStart: i };
+  }
+  if (masked[i] === '{') { const e = closeOf(masked, i); return e < 0 ? null : { start: from, end: e, bodyStart: i }; }
+  return null;
+}
+
+// The Python block that belongs to the "def" or "class" line starting at `lineStart` (an index at the start of the line):
+// the header (which may span several lines until the colon that ends it) and every following line indented deeper.
+export function pyBlock(masked: string, lines: Lines, lineStart: number): Extent {
+  const indentOf = (ls: number): number => { let k = ls; let w = 0; while (masked[k] === ' ' || masked[k] === '\t') { w += masked[k] === '\t' ? 8 : 1; k++; } return w; };
+  const base = indentOf(lineStart);
+  // header ends at the first ":" at bracket depth 0 followed by end of line
+  let depth = 0;
+  let i = lineStart;
+  for (; i < masked.length; i++) {
+    const c = masked[i];
+    if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') depth--;
+    else if (c === ':' && depth === 0 && /^[ \t]*(\n|$)/.test(masked.slice(i + 1, i + 40))) break;
+    else if (c === ':' && depth === 0 && /^[ \t]*\S/.test(masked.slice(i + 1, i + 40)) && /^\s*(def|class|async\s+def)\b/.test(masked.slice(lineStart, lineStart + 12))) { /* annotation colon, keep scanning */ }
+  }
+  const bodyStart = Math.min(masked.length, i + 1);
+  let end = bodyStart;
+  const total = lines.count;
+  let ln = lines.at(bodyStart) + 1;
+  for (; ln <= total; ln++) {
+    const ls = lines.start(ln);
+    const le = masked.indexOf('\n', ls);
+    const row = masked.slice(ls, le < 0 ? masked.length : le);
+    if (row.trim() === '') { continue; }
+    if (indentOf(ls) <= base) break;
+    end = le < 0 ? masked.length : le;
+  }
+  return { start: lineStart, end, bodyStart };
+}

package/src/map/light-index.ts

@@ -0,0 +1,134 @@
+// An index of the repository's own functions by name for Go, Ruby and PHP: where a function starts and ends, so a handler
+// can be followed to its definition and one hop into the helpers it calls. Built once per language and repository.
+import { cmp } from '../util.ts';
+import type { HelperRef } from './analyze.ts';
+import { closeOf, statementEnd } from './lex.ts';
+import type { MoreLang } from './lex-more.ts';
+import type { Repo } from './repo.ts';
+
+// The extent of a Go function whose "func" keyword is at `at`: [start, end) with the body inside braces.
+export function goFunc(masked: string, at: number): { start: number; end: number; bodyStart: number; params: string } | null {
+  let i = at + 4;
+  while (/\s/.test(masked[i] ?? '')) i++;
+  if (masked[i] === '(' && /^\(\s*\w*\s*\*?\s*[\w.[\]]+\s*\)\s*\w/.test(masked.slice(i, i + 120))) { const c = closeOf(masked, i); if (c < 0) return null; i = c; while (/\s/.test(masked[i] ?? '')) i++; }
+  while (/[\w]/.test(masked[i] ?? '')) i++;
+  while (/\s/.test(masked[i] ?? '')) i++;
+  if (masked[i] === '[') { const c = closeOf(masked, i); if (c < 0) return null; i = c; }
+  if (masked[i] !== '(') return null;
+  const pc = closeOf(masked, i);
+  if (pc < 0) return null;
+  const params = masked.slice(i + 1, pc - 1);
+  for (i = pc; i < masked.length; i++) {
+    const c = masked[i];
+    if (c === '{') {
+      const before = masked.slice(Math.max(0, i - 12), i).trimEnd();
+      if (/(?:interface|struct)$/.test(before)) { const e = closeOf(masked, i); if (e < 0) return null; i = e - 1; continue; }
+      const e = closeOf(masked, i);
+      return e < 0 ? null : { start: at, end: e, bodyStart: i, params };
+    }
+    if (c === ';' ) return null;
+  }
+  return null;
+}
+
+// A Ruby method: from "def" to the "end" at the same indentation.
+export function rubyDef(masked: string, defAt: number): { start: number; end: number } {
+  const ls = masked.lastIndexOf('\n', defAt) + 1;
+  const indent = /^[ \t]*/.exec(masked.slice(ls))![0].length;
+  const oneLine = /^[^\n]*\bdef\b[^\n]*=\s*\S/.exec(masked.slice(defAt, defAt + 200));
+  const firstEnd = masked.indexOf('\n', defAt);
+  if (oneLine && !/\bend\b/.test(masked.slice(defAt, firstEnd < 0 ? masked.length : firstEnd))) return { start: defAt, end: firstEnd < 0 ? masked.length : firstEnd };
+  let pos = firstEnd < 0 ? masked.length : firstEnd + 1;
+  while (pos < masked.length) {
+    const e = masked.indexOf('\n', pos);
+    const row = masked.slice(pos, e < 0 ? masked.length : e);
+    const ind = /^[ \t]*/.exec(row)![0].length;
+    if (row.trim() !== '' && ind <= indent && /^\s*end\b/.test(row)) return { start: defAt, end: pos + row.length };
+    if (row.trim() !== '' && ind < indent) return { start: defAt, end: pos };
+    if (e < 0) break;
+    pos = e + 1;
+  }
+  return { start: defAt, end: masked.length };
+}
+
+// A PHP function or method: from "function" to the closing brace of its body.
+export function phpFunc(masked: string, at: number): { start: number; end: number; bodyStart: number; params: string } | null {
+  const open = masked.indexOf('(', at);
+  if (open < 0) return null;
+  const pc = closeOf(masked, open);
+  if (pc < 0) return null;
+  const params = masked.slice(open + 1, pc - 1);
+  const m = /^[^{;]*\{/.exec(masked.slice(pc, pc + 300));
+  if (!m) return null;
+  const bodyStart = pc + m[0].length - 1;
+  const e = closeOf(masked, bodyStart);
+  return e < 0 ? null : { start: at, end: e, bodyStart, params };
+}
+
+// A Java or C# method whose name starts at `at`: the parameters, then a block body, or in C# an expression body after "=>". An abstract or
+// interface method (ending in ";") has no body and gives null.
+export function cMethod(masked: string, at: number): { start: number; end: number; bodyStart: number; params: string } | null {
+  let i = at;
+  while (/[\w$]/.test(masked[i] ?? '')) i++;
+  while (/\s/.test(masked[i] ?? '')) i++;
+  if (masked[i] === '<') { let d = 0; for (; i < masked.length; i++) { if (masked[i] === '<') d++; else if (masked[i] === '>' && --d === 0) { i++; break; } else if (masked[i] === '\n' && d > 4) return null; } while (/\s/.test(masked[i] ?? '')) i++; }
+  if (masked[i] !== '(') return null;
+  const pc = closeOf(masked, i);
+  if (pc < 0) return null;
+  const params = masked.slice(i + 1, pc - 1);
+  for (let j = pc; j < masked.length; j++) {
+    const c = masked[j];
+    if (c === '{') { const e = closeOf(masked, j); return e < 0 ? null : { start: at, end: e, bodyStart: j, params }; }
+    if (c === ';') return null;
+    if (c === '=' && masked[j + 1] === '>') return { start: at, end: statementEnd(masked, j + 2), bodyStart: j + 2, params };
+  }
+  return null;
+}
+
+// Method declarations: at least one modifier, a type, a name and "(".
+export const C_METHOD = /^[ \t]*(?:@\w+(?:\([^)\n]*\))?[ \t]*)*(?:(?:public|protected|private|internal|static|final|abstract|synchronized|async|override|virtual|sealed|partial|new|extern|unsafe|default)\s+)+[^;{}()=\n]*?\s(\w+)\s*(?:<[^>\n]*>)?\s*\(/gm;
+
+export class FnIndex {
+  private idx = new Map<string, HelperRef[]>();
+  readonly repo: Repo;
+  readonly lang: MoreLang;
+  constructor(repo: Repo, lang: MoreLang) {
+    this.repo = repo;
+    this.lang = lang;
+    const put = (name: string, ref: HelperRef): void => { const l = this.idx.get(name); if (l) l.push(ref); else this.idx.set(name, [ref]); };
+    for (const file of repo.filesOf(lang)) {
+      const v = repo.view(file);
+      if (!v) continue;
+      const m = v.masked;
+      if (lang === 'go') {
+        for (const x of m.matchAll(/^func\s+(?:\(\s*\w*\s*\*?\s*[\w.[\]]+\s*\)\s*)?(\w+)\s*[([]/gm)) {
+          const f = goFunc(m, x.index!);
+          if (f) put(x[1], { view: v, start: f.start, end: f.end });
+        }
+      } else if (lang === 'rb') {
+        for (const x of m.matchAll(/^[ \t]*def\s+(?:self\.)?(\w+[?!=]?)/gm)) {
+          const d = rubyDef(m, x.index! + x[0].indexOf('def'));
+          put(x[1], { view: v, start: d.start, end: d.end });
+        }
+      } else if (lang === 'java' || lang === 'cs') {
+        for (const x of m.matchAll(C_METHOD)) {
+          const f = cMethod(m, x.index! + x[0].lastIndexOf(x[1]));
+          if (f) put(x[1], { view: v, start: f.start, end: f.end });
+        }
+      } else {
+        for (const x of m.matchAll(/\bfunction\s+&?\s*(\w+)\s*\(/g)) {
+          const f = phpFunc(m, x.index!);
+          if (f) put(x[1], { view: v, start: f.start, end: f.end });
+        }
+      }
+    }
+  }
+  defs(name: string): HelperRef[] { return (this.idx.get(name) ?? []).slice().sort((a, b) => cmp(a.view.file, b.view.file) || a.start - b.start); }
+  find = (name: string, fromFile: string): HelperRef | null => {
+    const refs = this.idx.get(name);
+    if (!refs) return null;
+    if (refs.length === 1) return refs[0];
+    const same = refs.filter((r) => r.view.file === fromFile);
+    return same.length === 1 ? same[0] : null;
+  };
+}