@boyingliu01/xp-gate 0.31.3 → 0.32.0

package/principles/adapters/typescript.ts

@@ -102,6 +102,56 @@ function findBlockEnd(masked: string, open: number): number {
   return masked.length;
 }
 
+/** Keywords that begin a new top-level declaration. */
+const DECLARATION_KEYWORDS = /^(?:export|import|interface|class|const|let|var|function|type|declare|@)/;
+
+/**
+ * True when a newline at `index` ends a declaration that has no body: the next
+ * line starts another declaration (or a decorator). Without this the scan runs
+ * into the following declaration and reports ITS brace as this one's body.
+ */
+function startsNewDeclaration(masked: string, index: number): boolean {
+  const rest = masked.substring(index + 1).replace(/^[ \t]*/, '');
+  return DECLARATION_KEYWORDS.test(rest);
+}
+
+/** What the declaration scan should do with the character it just read. */
+type ScanAction =
+  | { kind: 'advance' }
+  | { kind: 'jump'; to: number }
+  | { kind: 'depth'; delta: 1 | -1 }
+  | { kind: 'body'; at: number }
+  | { kind: 'no-body' };
+
+/** Characters that open a generic/bracket group in a declaration header. */
+const HEADER_OPENERS = new Set(['<', '[']);
+/** Characters that close one. */
+const HEADER_CLOSERS = new Set(['>', ']']);
+
+/**
+ * Decide what the declaration scan does at `i`.
+ *
+ * Table-driven rather than an `if` ladder (#620): the interesting cases are
+ * "this character means something", and a per-character decision keeps that list
+ * readable and each rule independently testable.
+ */
+function declarationScanAction(masked: string, i: number, depth: number): ScanAction {
+  const c = masked[i];
+
+  // A parenthesised group is skipped whole: parens only ever appear inside a
+  // header (`class X extends Y<() => void>`), never as body structure.
+  if (c === '(') return { kind: 'jump', to: readParenGroup(masked, i).end - 1 };
+  if (HEADER_OPENERS.has(c)) return { kind: 'depth', delta: 1 };
+  if (HEADER_CLOSERS.has(c)) return { kind: 'depth', delta: -1 };
+
+  if (c === '{') return depth === 0 ? { kind: 'body', at: i } : { kind: 'depth', delta: 1 };
+  if (c === '}') return { kind: 'depth', delta: -1 };
+
+  if (c === ';' && depth === 0) return { kind: 'no-body' };
+  if (c === '\n' && depth === 0 && startsNewDeclaration(masked, i)) return { kind: 'no-body' };
+  return { kind: 'advance' };
+}
+
 /**
  * Body brace for declarations that have no parameter list (`class`, `interface`).
  * Scans forward from the end of the declaration header; the first `{` at generic
@@ -110,27 +160,17 @@ function findBlockEnd(masked: string, open: number): number {
 function findDeclarationBrace(masked: string, from: number): number {
   let depth = 0;
   for (let i = from; i < masked.length; i++) {
-    const c = masked[i];
-    if (c === '<' || c === '[' || c === '(') {
-      if (c === '(') { const g = readParenGroup(masked, i); i = g.end - 1; continue; }
-      depth++;
-      continue;
-    }
-    if (c === '>' || c === ']') { if (depth > 0) depth--; continue; }
-    if (c === '{') {
-      if (depth === 0) return i;
-      depth++;
-      continue;
-    }
-    if (c === '}') { if (depth > 0) depth--; continue; }
-    if (c === ';' && depth === 0) return -1;
-    // Stop at a blank line / a new top-level keyword so we do not run into the
-    // next declaration when this one has no body.
-    if (c === '\n') {
-      const rest = masked.substring(i + 1).replace(/^[ \t]*/, '');
-      if (/^(?:export|import|interface|class|const|let|var|function|type|declare|@)/.test(rest) && depth === 0) {
-        return -1;
-      }
+    const action = declarationScanAction(masked, i, depth);
+    switch (action.kind) {
+      case 'body': return action.at;
+      case 'no-body': return -1;
+      case 'jump': i = action.to; break;
+      case 'depth':
+        // Depth never goes negative: a stray closing bracket in a header must
+        // not look like the start of a new group.
+        depth = Math.max(0, depth + action.delta);
+        break;
+      case 'advance': break;
     }
   }
   return -1;
@@ -140,80 +180,292 @@ function lineOf(src: string, index: number): number {
   return src.substring(0, index).split('\n').length;
 }
 
+/** The three quoted states shared by the parameter/paren scanners. */
+interface QuoteState {
+  inSingle: boolean;
+  inDouble: boolean;
+  inTemplate: boolean;
+}
+
+function newQuoteState(): QuoteState {
+  return { inSingle: false, inDouble: false, inTemplate: false };
+}
+
+function inQuotedState(state: QuoteState): boolean {
+  return state.inSingle || state.inDouble || state.inTemplate;
+}
+
+/** The three quote kinds tracked by QuoteState, with the flag that marks each. */
+const QUOTE_KINDS: ReadonlyArray<{ quote: string; flag: 'inSingle' | 'inDouble' | 'inTemplate' }> = [
+  { quote: "'", flag: 'inSingle' },
+  { quote: '"', flag: 'inDouble' },
+  { quote: '`', flag: 'inTemplate' },
+];
+
+/**
+ * Advance one character of quote tracking.
+ *
+ * Extracted because `countParams` and `readParenGroup` carried the same
+ * six-branch block verbatim (#602): both must ignore delimiters that appear
+ * inside a string, and neither may treat an escape as a closing quote.
+ *
+ * Table-driven (#620): all three quote kinds behave identically -- an escape
+ * skips two characters, the matching quote closes the literal -- so they are one
+ * rule applied to a list rather than three copies of it.
+ *
+ * @returns the number of characters consumed (2 when the next char is escaped).
+ */
+function advanceQuoteState(src: string, i: number, state: QuoteState): number {
+  const c = src[i];
+
+  for (const kind of QUOTE_KINDS) {
+    if (!state[kind.flag]) continue;
+    if (c === '\\') return 2;
+    if (c === kind.quote) state[kind.flag] = false;
+    return 1;
+  }
+
+  // Not inside any literal: open the one this character starts, if any.
+  const opener = QUOTE_KINDS.find(kind => kind.quote === c);
+  if (opener) state[opener.flag] = true;
+  return 1;
+}
+
+/** Opening delimiters that raise the generic/bracket depth in a param list. */
+const DEPTH_OPENERS = new Set(['(', '[', '{', '<']);
+/** Closing delimiters that lower it. */
+const DEPTH_CLOSERS = new Set([')', ']', '}', '>']);
+
+/**
+ * Adjust `depth` for one delimiter.
+ * @returns true when the character was a delimiter (so it cannot also be a
+ *          separator), false otherwise.
+ */
+function applyDelimiter(c: string, depth: { value: number }): boolean {
+  if (DEPTH_OPENERS.has(c)) { depth.value++; return true; }
+  if (DEPTH_CLOSERS.has(c)) { depth.value--; return true; }
+  return false;
+}
+
+/** True when the character opens a quote/template the scanners must skip. */
+function isQuote(c: string): boolean {
+  return c === "'" || c === '"' || c === '`';
+}
+
 /** Count top-level, comma-separated parameters in a raw parameter list. */
 function countParams(rawList: string): number {
   const trimmed = rawList.trim();
   if (trimmed === '') return 0;
-  let depth = 0;
+
+  const depth = { value: 0 };
   let count = 1;
-  let inSingle = false;
-  let inDouble = false;
-  let inTemplate = false;
-  for (let i = 0; i < trimmed.length; i++) {
+  const state = newQuoteState();
+
+  for (let i = 0; i < trimmed.length;) {
+    if (inQuotedState(state)) {
+      i += advanceQuoteState(trimmed, i, state);
+      continue;
+    }
     const c = trimmed[i];
-    if (inSingle) { if (c === '\\') i++; else if (c === "'") inSingle = false; continue; }
-    if (inDouble) { if (c === '\\') i++; else if (c === '"') inDouble = false; continue; }
-    if (inTemplate) { if (c === '\\') i++; else if (c === '`') inTemplate = false; continue; }
-    if (c === "'") { inSingle = true; continue; }
-    if (c === '"') { inDouble = true; continue; }
-    if (c === '`') { inTemplate = true; continue; }
-    if (c === '(' || c === '[' || c === '{' || c === '<') depth++;
-    else if (c === ')' || c === ']' || c === '}' || c === '>') depth--;
-    else if (c === ',' && depth === 0) count++;
+    if (isQuote(c)) {
+      advanceQuoteState(trimmed, i, state);
+    } else if (!applyDelimiter(c, depth) && c === ',' && depth.value === 0) {
+      count++;
+    }
+    i++;
   }
   return count;
 }
 
+/** What one step of the paren-group scan did, so the caller can react. */
+type ParenStep =
+  | { kind: 'consumed'; next: number }
+  | { kind: 'closed'; end: number };
+
+/**
+ * Advance one step through a paren group.
+ *
+ * Extracted from `readParenGroup` (#620) so the three-way decision -- inside a
+ * literal, opening a literal, or structural bracket -- reads as one rule instead
+ * of being folded into the loop that also owns depth and substring slicing.
+ *
+ * A literal is entered through `advanceQuoteState` at the SAME index rather than
+ * consumed: that call flips the state on the opening quote and reports one
+ * character consumed, so re-scans resume one past the quote with the state set.
+ *
+ * @param depth running paren depth, updated in place for structural brackets
+ * @returns the next index to read, or the offset just past the closing paren
+ */
+function stepParenGroup(
+  src: string,
+  i: number,
+  state: QuoteState,
+  depth: { value: number },
+): ParenStep {
+  if (inQuotedState(state)) {
+    return { kind: 'consumed', next: i + advanceQuoteState(src, i, state) };
+  }
+
+  const c = src[i];
+  if (isQuote(c)) {
+    // Entering a literal: flip state here, resume at the next character.
+    advanceQuoteState(src, i, state);
+    return { kind: 'consumed', next: i + 1 };
+  }
+  if (c === '(') {
+    depth.value++;
+    return { kind: 'consumed', next: i + 1 };
+  }
+  if (c === ')') {
+    depth.value--;
+    if (depth.value === 0) return { kind: 'closed', end: i + 1 };
+  }
+  return { kind: 'consumed', next: i + 1 };
+}
+
 /**
  * Extract the balanced `( ... )` group that starts at `open`.
  * Returns the inner text and the index just past the closing paren.
  */
 function readParenGroup(src: string, open: number): { inner: string; end: number } {
-  let depth = 0;
-  let inSingle = false;
-  let inDouble = false;
-  let inTemplate = false;
-  for (let i = open; i < src.length; i++) {
-    const c = src[i];
-    if (inSingle) { if (c === '\\') i++; else if (c === "'") inSingle = false; continue; }
-    if (inDouble) { if (c === '\\') i++; else if (c === '"') inDouble = false; continue; }
-    if (inTemplate) { if (c === '\\') i++; else if (c === '`') inTemplate = false; continue; }
-    if (c === "'") { inSingle = true; continue; }
-    if (c === '"') { inDouble = true; continue; }
-    if (c === '`') { inTemplate = true; continue; }
-    if (c === '(') depth++;
-    else if (c === ')') {
-      depth--;
-      if (depth === 0) return { inner: src.substring(open + 1, i), end: i + 1 };
+  const state = newQuoteState();
+  const depth = { value: 0 };
+
+  for (let i = open; i < src.length;) {
+    const step = stepParenGroup(src, i, state, depth);
+    if (step.kind === 'closed') {
+      return { inner: src.substring(open + 1, step.end - 1), end: step.end };
     }
+    i = step.next;
   }
   return { inner: src.substring(open + 1), end: src.length };
 }
 
+/**
+ * The lexical states `maxNesting` tracks while counting braces. Braces inside
+ * any of these are data, not structure, so they must not change the count.
+ */
+interface NestingScanState {
+  inSingle: boolean;
+  inDouble: boolean;
+  inTemplate: boolean;
+  inLineComment: boolean;
+  inBlockComment: boolean;
+}
+
+/**
+ * One handler per lexical state. Each returns how many characters were
+ * consumed, and mutates `state` only when the construct actually ends.
+ *
+ * Split out of a single 22-CCN dispatcher (#602): every state's exit condition
+ * is independent, so keeping them in one body bought nothing but branch count.
+ */
+type StateAdvance = (body: string, i: number, state: NestingScanState) => number;
+
+const advanceLineComment: StateAdvance = (body, i, state) => {
+  if (body[i] === '\n') state.inLineComment = false;
+  return 1;
+};
+
+const advanceBlockComment: StateAdvance = (body, i, state) => {
+  if (body[i] === '*' && body[i + 1] === '/') {
+    state.inBlockComment = false;
+    return 2;
+  }
+  return 1;
+};
+
+/** Shared shape of the three quoted states: honour `\`, close on the delimiter. */
+const advanceSingleQuote: StateAdvance = (body, i, state) => {
+  if (body[i] === '\\') return 2;
+  if (body[i] === "'") state.inSingle = false;
+  return 1;
+};
+
+const advanceDoubleQuote: StateAdvance = (body, i, state) => {
+  if (body[i] === '\\') return 2;
+  if (body[i] === '"') state.inDouble = false;
+  return 1;
+};
+
+const advanceTemplate: StateAdvance = (body, i, state) => {
+  if (body[i] === '\\') return 2;
+  if (body[i] === '`') state.inTemplate = false;
+  return 1;
+};
+
+/**
+ * Enter a construct when the current character opens one.
+ * @returns characters consumed, or 0 when nothing was opened.
+ */
+function openConstruct(body: string, i: number, state: NestingScanState): number {
+  const c = body[i];
+  const next = body[i + 1];
+  if (c === '/' && next === '/') { state.inLineComment = true; return 2; }
+  if (c === '/' && next === '*') { state.inBlockComment = true; return 2; }
+  if (c === "'") { state.inSingle = true; return 1; }
+  if (c === '"') { state.inDouble = true; return 1; }
+  if (c === '`') { state.inTemplate = true; return 1; }
+  return 0;
+}
+
+/**
+ * Advance the quoting/commenting state machine by one character.
+ *
+ * Pure with respect to depth: it only updates `state` and reports how many
+ * characters were consumed. Extracted from `maxNesting` (#602) so the brace
+ * counting and the lexing can be reasoned about separately -- the combined body
+ * carried every branch of both.
+ *
+ * @returns the number of characters consumed (1, or 2 for the escape/close
+ *          pairs that swallow the next character).
+ */
+function advanceNestingState(
+  body: string,
+  i: number,
+  state: NestingScanState,
+): number {
+  if (state.inLineComment) return advanceLineComment(body, i, state);
+  if (state.inBlockComment) return advanceBlockComment(body, i, state);
+  if (state.inSingle) return advanceSingleQuote(body, i, state);
+  if (state.inDouble) return advanceDoubleQuote(body, i, state);
+  if (state.inTemplate) return advanceTemplate(body, i, state);
+  const opened = openConstruct(body, i, state);
+  return opened === 0 ? 1 : opened;
+}
+
+/** True when the character at `i` is structural (not inside a literal/comment). */
+function isStructuralAt(state: NestingScanState): boolean {
+  return !state.inSingle && !state.inDouble && !state.inTemplate &&
+    !state.inLineComment && !state.inBlockComment;
+}
+
 /** Max brace nesting depth inside a function body (1 = body itself). */
 function maxNesting(body: string): number {
   let depth = 0;
   let max = 0;
-  let inSingle = false;
-  let inDouble = false;
-  let inTemplate = false;
-  let inLineComment = false;
-  let inBlockComment = false;
-  for (let i = 0; i < body.length; i++) {
-    const c = body[i];
-    const next = body[i + 1];
-    if (inLineComment) { if (c === '\n') inLineComment = false; continue; }
-    if (inBlockComment) { if (c === '*' && next === '/') { inBlockComment = false; i++; } continue; }
-    if (inSingle) { if (c === '\\') i++; else if (c === "'") inSingle = false; continue; }
-    if (inDouble) { if (c === '\\') i++; else if (c === '"') inDouble = false; continue; }
-    if (inTemplate) { if (c === '\\') i++; else if (c === '`') inTemplate = false; continue; }
-    if (c === '/' && next === '/') { inLineComment = true; i++; continue; }
-    if (c === '/' && next === '*') { inBlockComment = true; i++; continue; }
-    if (c === "'") { inSingle = true; continue; }
-    if (c === '"') { inDouble = true; continue; }
-    if (c === '`') { inTemplate = true; continue; }
-    if (c === '{') { depth++; if (depth > max) max = depth; }
-    else if (c === '}') depth--;
+  const state: NestingScanState = {
+    inSingle: false,
+    inDouble: false,
+    inTemplate: false,
+    inLineComment: false,
+    inBlockComment: false,
+  };
+
+  for (let i = 0; i < body.length;) {
+    const consumed = advanceNestingState(body, i, state);
+    if (consumed === 2) {
+      // The pair (escape, comment close, comment open) is consumed whole. A
+      // comment opener must not also be read as a brace-less character below.
+      i += 2;
+      continue;
+    }
+    if (isStructuralAt(state)) {
+      const c = body[i];
+      if (c === '{') { depth++; if (depth > max) max = depth; }
+      else if (c === '}') depth--;
+    }
+    i += 1;
   }
   return max;
 }
@@ -232,12 +484,121 @@ function ioOperationsIn(body: string): string[] {
   return [...found];
 }
 
+/**
+ * Blank a `//` line comment starting at `start`.
+ * Stops AT the newline so line numbering survives (the newline is the caller's
+ * to consume as an ordinary character).
+ * @returns the index to resume scanning from.
+ */
+function maskLineComment(src: string, out: string[], start: number): number {
+  let i = start;
+  while (i < src.length && src[i] !== '\n') { out[i] = ' '; i++; }
+  return i;
+}
+
+/**
+ * Blank a block comment starting at `start` (which holds `/`).
+ *
+ * #602: newlines inside the comment must survive. Blanking them shifts every
+ * subsequent line number, so `lineOf()` and every line-numbered violation after
+ * a multi-line comment would point at the wrong line -- exactly the defect the
+ * line-comment branch never had, because it stops AT the newline.
+ *
+ * @returns the index to resume scanning from.
+ */
+function maskBlockComment(src: string, out: string[], start: number): number {
+  let i = start;
+  out[i] = ' '; out[i + 1] = ' '; i += 2;
+  while (i < src.length && !(src[i] === '*' && src[i + 1] === '/')) {
+    if (src[i] !== '\n') out[i] = ' ';
+    i++;
+  }
+  if (i < src.length) { out[i] = ' '; out[i + 1] = ' '; i += 2; }
+  return i;
+}
+
+/**
+ * Decide whether the `/` at `index` opens a regex literal rather than being
+ * division. A regex may only start where an expression may start: at the very
+ * beginning, after an operator/punctuation, or after a keyword that expects an
+ * expression (`return /re/`, `typeof /re/`, ...).
+ */
+function opensRegexLiteral(src: string, index: number): boolean {
+  const before = src.substring(0, index).replace(/\s+$/, '');
+  const prev = before[before.length - 1];
+  if (prev === undefined) return true;
+  if (/[=(,:[!&|?{};+\-*%^~<>]/.test(prev)) return true;
+  return /(?:^|[^\w$])(return|typeof|case|in|of|new|delete|void|instanceof)$/.test(before);
+}
+
+/**
+ * Find where a regex literal starting at `start` closes, honouring `\` escapes
+ * and character classes (`[/]` must not close the literal).
+ * @returns the index of the closing `/`, or -1 when the line ends first (so the
+ *          slash really was division).
+ */
+function findRegexClose(src: string, start: number): number {
+  let inClass = false;
+  for (let j = start + 1; j < src.length; j++) {
+    const d = src[j];
+    if (d === '\\') { j++; continue; }
+    if (d === '\n') return -1;
+    if (d === '[') { inClass = true; continue; }
+    if (d === ']') { inClass = false; continue; }
+    if (d === '/' && !inClass) return j;
+  }
+  return -1;
+}
+
+/**
+ * Blank a regex literal (and its trailing flags) starting at `start`.
+ * @returns the index to resume scanning from.
+ */
+function maskRegexLiteral(src: string, out: string[], start: number): number {
+  const close = findRegexClose(src, start);
+  if (close < 0) return start;
+  for (let k = start; k <= close; k++) out[k] = ' ';
+  let i = close + 1;
+  while (i < src.length && /[a-z]/i.test(src[i])) { out[i] = ' '; i++; }
+  return i;
+}
+
+/**
+ * Blank a quoted or template literal starting at `start`.
+ * A backtick runs to its closing backtick (interpolations included); a single
+ * or double quote stops at an unescaped newline, matching a syntax error.
+ * @returns the index to resume scanning from.
+ */
+function maskStringLiteral(src: string, out: string[], start: number): number {
+  const quote = src[start];
+  out[start] = ' ';
+  let i = start + 1;
+  while (i < src.length) {
+    const d = src[i];
+    if (d === '\\') {
+      out[i] = ' ';
+      if (i + 1 < src.length) out[i + 1] = ' ';
+      i += 2;
+      continue;
+    }
+    if (d === quote) { out[i] = ' '; i++; break; }
+    if (d === '\n' && quote !== '`') break;
+    out[i] = ' ';
+    i++;
+  }
+  return i;
+}
+
 /**
  * Blank out comments and string/template literals, preserving offsets.
  * A single left-to-right scan is used rather than chained `.replace()` calls:
  * sequential regex replacement re-scans text that earlier passes produced and
  * can pair a quote inside a regex literal with a quote in a later comment,
  * swallowing hundreds of lines (observed as a 302-line phantom function).
+ *
+ * The scan dispatches to one masking routine per construct and otherwise copies
+ * the character through, so the loop's own branching stays flat (#602: split
+ * from a single 36-CCN body into five routines the tests can pin separately).
  */
 function maskLiterals(src: string): string {
   const out = src.split('');
@@ -247,56 +608,20 @@ function maskLiterals(src: string): string {
     const next = src[i + 1];
 
     if (c === '/' && next === '/') {
-      while (i < src.length && src[i] !== '\n') { out[i] = ' '; i++; }
+      i = maskLineComment(src, out, i);
       continue;
     }
     if (c === '/' && next === '*') {
-      out[i] = ' '; out[i + 1] = ' '; i += 2;
-      while (i < src.length && !(src[i] === '*' && src[i + 1] === '/')) { out[i] = ' '; i++; }
-      if (i < src.length) { out[i] = ' '; out[i + 1] = ' '; i += 2; }
+      i = maskBlockComment(src, out, i);
       continue;
     }
-
-    // Regex literals: `/.../flags`. Only treat `/` as a regex start when the
-    // previous significant character cannot end an expression.
-    if (c === '/') {
-      const before = src.substring(0, i).replace(/\s+$/, '');
-      const prev = before[before.length - 1];
-      const prevWord = /(?:^|[^\w$])(return|typeof|case|in|of|new|delete|void|instanceof)$/.test(before);
-      if (prev === undefined || /[=(,:[!&|?{};+\-*%^~<>]/.test(prev) || prevWord) {
-        let j = i + 1;
-        let inClass = false;
-        let closed = false;
-        while (j < src.length) {
-          const d = src[j];
-          if (d === '\\') { j += 2; continue; }
-          if (d === '\n') break;
-          if (d === '[') inClass = true;
-          else if (d === ']') inClass = false;
-          else if (d === '/' && !inClass) { closed = true; break; }
-          j++;
-        }
-        if (closed) {
-          for (let k = i; k <= j; k++) out[k] = ' ';
-          i = j + 1;
-          while (i < src.length && /[a-z]/i.test(src[i])) { out[i] = ' '; i++; }
-          continue;
-        }
-      }
+    if (c === '/' && opensRegexLiteral(src, i)) {
+      const resumed = maskRegexLiteral(src, out, i);
+      // -1/findRegexClose failure keeps start, so `i` only advances on a match.
+      if (resumed !== i) { i = resumed; continue; }
     }
-
     if (c === "'" || c === '"' || c === '`') {
-      const quote = c;
-      out[i] = ' ';
-      i++;
-      while (i < src.length) {
-        const d = src[i];
-        if (d === '\\') { out[i] = ' '; if (i + 1 < src.length) out[i + 1] = ' '; i += 2; continue; }
-        if (d === quote) { out[i] = ' '; i++; break; }
-        if (d === '\n' && quote !== '`') break;
-        out[i] = ' ';
-        i++;
-      }
+      i = maskStringLiteral(src, out, i);
       continue;
     }
 
@@ -513,15 +838,31 @@ export class TypeScriptAdapter extends BaseAdapter implements Adapter {
   }
 
   extractFunctions(): unknown[] {
-    const src = this.fileContent;
     // Match declarations against the masked source so identifiers that appear
     // only in comments or strings are never mistaken for functions, while
     // bodies/positions still come from the original text (same offsets).
-    const masked = this.maskedSource;
-    const found: FunctionMetrics[] = [];
     const seen = new Set<string>();
+    const found: FunctionMetrics[] = [];
+    // Three independent syntactic shapes, one collector each. Splitting them out
+    // of the single CCN-20 body also keeps each shape's quirks (see the comments
+    // on the collectors) next to the code they explain.
+    this.collectFunctionDecls(seen, found);
+    this.collectClassMethods(seen, found);
+    this.collectArrowFunctions(seen, found);
+    return found;
+  }
 
-    // 1. `function name(...)` declarations (incl. export / async / generators).
+  /** Claim a `name@offset` key once, so overlapping shapes cannot double-count. */
+  private claim(seen: Set<string>, name: string, nameIndex: number): boolean {
+    const key = `${name}@${nameIndex}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }
+
+  /** `function name(...)` declarations, including export / async / generators. */
+  private collectFunctionDecls(seen: Set<string>, found: FunctionMetrics[]): void {
+    const masked = this.maskedSource;
     const declRe = /(?:^|[^\w$.])(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*(\w+)\s*/g;
     let m: RegExpExecArray | null;
     while ((m = declRe.exec(masked)) !== null) {
@@ -530,16 +871,20 @@ export class TypeScriptAdapter extends BaseAdapter implements Adapter {
       if (parenIndex === -1) continue;
       const bodyOpen = findBodyBrace(masked, parenIndex);
       if (bodyOpen === -1) continue;
-      const key = `${m[1]}@${nameIndex}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
+      if (!this.claim(seen, m[1], nameIndex)) continue;
       found.push(this.buildFunction(m[1], 'function', nameIndex, parenIndex, bodyOpen));
     }
+  }
 
-    // 2. Class methods: `name(...) {`. Not anchored to line start so minified
-    //    single-line bodies count too. Control-flow keywords are excluded -- a
-    //    bare `if (a > 0) {` matches the shape but is not a method.
+  /**
+   * Class methods: `name(...) {`. Not anchored to line start so minified
+   * single-line bodies count too. Control-flow keywords are excluded -- a bare
+   * `if (a > 0) {` matches the shape but is not a method.
+   */
+  private collectClassMethods(seen: Set<string>, found: FunctionMetrics[]): void {
+    const masked = this.maskedSource;
     const memberRe = /(?<![\w$.])(?:public\s+|private\s+|protected\s+|static\s+|async\s+|readonly\s+|get\s+|set\s+|\*\s*)*(\w+)\s*\(/g;
+    let m: RegExpExecArray | null;
     while ((m = memberRe.exec(masked)) !== null) {
       if (CONTROL_KEYWORDS.has(m[1])) continue;
       // The pattern ends with `\(`, so the match's last character IS the opening
@@ -550,73 +895,98 @@ export class TypeScriptAdapter extends BaseAdapter implements Adapter {
       // Only treat as a method when a body brace follows the parameter list.
       const bodyOpen = findBodyBrace(masked, parenIndex);
       if (bodyOpen === -1) continue;
-      const key = `${m[1]}@${nameIndex}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
+      if (!this.claim(seen, m[1], nameIndex)) continue;
       found.push(this.buildFunction(m[1], 'method', nameIndex, parenIndex, bodyOpen));
     }
+  }
 
-    // 3. Arrow consts / assignments: `const name = (...) =>` / `name = x =>`.
+  /** Arrow consts / assignments: `const name = (...) =>` / `name = x =>`. */
+  private collectArrowFunctions(seen: Set<string>, found: FunctionMetrics[]): void {
+    const masked = this.maskedSource;
     const arrowRe = /(?:const|let|var)\s+(\w+)\s*(?::[^=]+)?=\s*(?:async\s*)?/g;
+    let m: RegExpExecArray | null;
     while ((m = arrowRe.exec(masked)) !== null) {
-      const rest = masked.substring(arrowRe.lastIndex);
-      const parenOffset = /^\s*\(/.test(rest) ? rest.indexOf('(') : -1;
-      let parenIndex: number;
-      if (parenOffset !== -1) {
-        parenIndex = arrowRe.lastIndex + parenOffset;
-      } else {
-        // Single-identifier param: `x => ...`
-        const simple = /^\s*(\w+)\s*=>/.exec(rest);
-        if (!simple) continue;
-        parenIndex = -1;
-      }
-      const afterParams = parenIndex === -1
-        ? arrowRe.lastIndex + (/^\s*(\w+)/.exec(rest) as RegExpExecArray)[0].length
-        : readParenGroup(src, parenIndex).end;
-      if (!/^\s*(?::[^=]+)?=>/.test(masked.substring(afterParams))) continue;
-
+      const arrow = this.parseArrowAt(m, arrowRe.lastIndex);
+      if (!arrow) continue;
       const nameIndex = m.index + m[0].length - m[1].length;
-      const braceAfter = masked.indexOf('{', afterParams);
-      const arrowBodyStart = braceAfter !== -1 && /^\s*(?::[^=]+)?=>\s*\{/.test(masked.substring(afterParams, braceAfter + 1))
-        ? braceAfter
-        : -1;
-
-      let length = 1;
-      let nestingDepth = 0;
-      let hasTryCatch = false;
-      let ioOperations: string[] = [];
-      let code = '';
-      if (arrowBodyStart !== -1) {
-        const bodyEnd = findBlockEnd(masked, arrowBodyStart);
-        code = src.substring(arrowBodyStart, bodyEnd);
-        const startLine = lineOf(src, nameIndex);
-        const endLine = lineOf(src, bodyEnd);
-        length = Math.max(1, endLine - startLine + 1);
-        nestingDepth = maxNesting(code);
-        hasTryCatch = /\btry\s*\{/.test(code);
-        ioOperations = ioOperationsIn(code);
-      }
+      if (!this.claim(seen, m[1], nameIndex)) continue;
+      found.push(this.buildArrowMetrics(m[1], nameIndex, arrow));
+    }
+  }
 
-      const startLine = lineOf(src, nameIndex);
-      const key = `${m[1]}@${nameIndex}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      found.push({
-        name: m[1],
+  /**
+   * Resolve an arrow assignment's parameter list and body brace.
+   * @returns null when the text after the assignment is not an arrow function.
+   */
+  private parseArrowAt(
+    m: RegExpExecArray,
+    scanFrom: number,
+  ): { parenIndex: number; afterParams: number; bodyOpen: number } | null {
+    const masked = this.maskedSource;
+    const rest = masked.substring(scanFrom);
+    const parenOffset = /^\s*\(/.test(rest) ? rest.indexOf('(') : -1;
+    let parenIndex: number;
+    if (parenOffset !== -1) {
+      parenIndex = scanFrom + parenOffset;
+    } else {
+      // Single-identifier param: `x => ...`
+      if (!/^\s*(\w+)\s*=>/.test(rest)) return null;
+      parenIndex = -1;
+    }
+    const afterParams = parenIndex === -1
+      ? scanFrom + (/^\s*(\w+)/.exec(rest) as RegExpExecArray)[0].length
+      : readParenGroup(this.fileContent, parenIndex).end;
+    if (!/^\s*(?::[^=]+)?=>/.test(masked.substring(afterParams))) return null;
+
+    const braceAfter = masked.indexOf('{', afterParams);
+    const isBlockBody = braceAfter !== -1 &&
+      /^\s*(?::[^=]+)?=>\s*\{/.test(masked.substring(afterParams, braceAfter + 1));
+    return { parenIndex, afterParams, bodyOpen: isBlockBody ? braceAfter : -1 };
+  }
+
+  /** Derive the metrics for one arrow function, whether or not it has a block body. */
+  private buildArrowMetrics(
+    name: string,
+    nameIndex: number,
+    arrow: { parenIndex: number; afterParams: number; bodyOpen: number },
+  ): FunctionMetrics {
+    const src = this.fileContent;
+    const startLine = lineOf(src, nameIndex);
+
+    // A concise body (`() => x + 1`) has no block, so it carries no measurable
+    // span: length 1, no nesting, no io. Only a block body is inspected.
+    if (arrow.bodyOpen === -1) {
+      return {
+        name,
         type: 'arrow',
         line: startLine,
         startLine,
         endLine: startLine,
-        length,
-        paramCount: parenIndex === -1 ? 1 : countParams(readParenGroup(src, parenIndex).inner),
-        nestingDepth,
-        hasTryCatch,
-        ioOperations,
-        code,
-      });
+        length: 1,
+        paramCount: arrow.parenIndex === -1 ? 1 : countParams(readParenGroup(src, arrow.parenIndex).inner),
+        nestingDepth: 0,
+        hasTryCatch: false,
+        ioOperations: [],
+        code: '',
+      };
     }
 
-    return found;
+    const bodyEnd = findBlockEnd(this.maskedSource, arrow.bodyOpen);
+    const code = src.substring(arrow.bodyOpen, bodyEnd);
+    const endLine = lineOf(src, bodyEnd);
+    return {
+      name,
+      type: 'arrow',
+      line: startLine,
+      startLine,
+      endLine: startLine,
+      length: Math.max(1, endLine - startLine + 1),
+      paramCount: arrow.parenIndex === -1 ? 1 : countParams(readParenGroup(src, arrow.parenIndex).inner),
+      nestingDepth: maxNesting(code),
+      hasTryCatch: /\btry\s*\{/.test(code),
+      ioOperations: ioOperationsIn(code),
+      code,
+    };
   }
 
   extractClasses(): unknown[] {