Function normalizeValue

src/extraction/function-ref.ts:531–603

* Normalize one value expression to zero or more function names. Recursion is * bounded (wrapper layers only); anything that isn't a recognized * function-value shape yields [].

(
  node: SyntaxNode,
  spec: FnRefSpec,
  source: string,
  depth: number
)

 * function-value shape yields [].
 */
function normalizeValue(
  node: SyntaxNode,
  spec: FnRefSpec,
  source: string,
  depth: number
): NormalizedRef[] {
  if (depth > 4) return [];
  const type = node.type;

  // Bare identifier
  if (spec.idTypes.has(type)) {
    return [{ name: getNodeText(node, source), node }];
  }

  // Transparent layers (argument, value_argument, literal_element,
  // expression_list, block_argument). expression_list fans out (Go `a, b = f, g`).
  const layerField = spec.layers?.get(type);
  if (spec.layers?.has(type)) {
    // Labeled-argument param-forward skip (Swift/Kotlin): `value: value` /
    // `delay: delay` — when the label EQUALS the value identifier, the value
    // is a forwarded local/parameter, not a function reference (Alamofire
    // A/B finding; same rationale as the `this.x = x` assignment skip).
    if (type === 'value_argument') {
      const label = getChildByField(node, 'name');
      const value = getChildByField(node, 'value') ?? node.namedChild(node.namedChildCount - 1);
      if (
        label &&
        value &&
        getNodeText(label, source).trim() === getNodeText(value, source).trim()
      ) {
        return [];
      }
    }
    if (layerField) {
      const inner = getChildByField(node, layerField);
      return inner ? normalizeValue(inner, spec, source, depth + 1) : [];
    }
    const results: NormalizedRef[] = [];
    for (let i = 0; i < node.namedChildCount; i++) {
      const child = node.namedChild(i);
      if (child) results.push(...normalizeValue(child, spec, source, depth + 1));
    }
    return results;
  }

  // Unary wrappers: &fn / @Fn / `fn _`
  const unwrapField = spec.unwrap?.get(type);
  if (spec.unwrap?.has(type)) {
    // C-family `pointer_expression` covers BOTH `&x` (address-of — a function
    // value) and `*x` (dereference — a data read, never a function value).
    // Only `&` qualifies; without this, fmt's `*begin` reads resolved to its
    // free `begin()` functions.
    if (type === 'pointer_expression' && node.child(0)?.type !== '&') return [];
    const inner = unwrapField ? getChildByField(node, unwrapField) : node.namedChild(0);
    if (!inner) return [];
    // C++ `&Widget::on_click` — keep the QUALIFIED name. Resolution scopes the
    // method to that class (more precise than a bare-name match, and exempt
    // from the cpp bare-ids-are-free-functions rule since `&Cls::m` is an