Function matchReference

src/resolution/name-matcher.ts:9392–9432

(
  ref: UnresolvedRef,
  context: ResolutionContext
)

}

export function matchReference(
  ref: UnresolvedRef,
  context: ResolutionContext
): ResolvedRef | null {
  const result = gateLanguageMatch(matchReferenceInner(ref, context), ref, context);
  // `this.container.classList.toggle()` inside `toggle()`, `window.$events
  // .listen()` inside `listen()`, Scala's `requestToArmeria(request).execute()`
  // inside `execute()`: a member of what the receiver is, which is the calling
  // method only through a TS/JS field of the caller's own type.
  if (result && result.targetNodeId === ref.fromNodeId && isCollapsedNonRecursion(ref, context)) return null;
  // A name the calling JS/TS function binds itself shadows the file's own:
  // lodash's `mixin(object, …)` calling `object(this.__wrapped__)` is its
  // parameter, whichever strategy (fuzzy included) found a `function object`.
  if (result && JS_LOCAL_REF_KINDS.has(ref.referenceKind)) {
    const target = context.getNodeById?.(result.targetNodeId);
    // (A target of another name is what the local was followed to: `const
    // selected = useStore(s => s.reset); selected()` is the store's `reset`.)
    if (target && target.name === ref.referenceName && isOutsideJsLocal(target, ref, context)) return null;
  }
  // R looks a call's name up among FUNCTIONS only, skipping other bindings:
  // ggplot2's tests' `c <- data_frame(b = 3)` is never what `c(1, 2)` calls —
  // base R's `c` is. (A project binding made by a function factory, ggplot2's
  // `geom_point <- make_constructor(…)`, is a function, and stays.)
  if (result && ref.language === 'r' && ref.referenceKind === 'calls' && R_BASE_FUNCTIONS.has(ref.referenceName)) {
    const target = context.getNodeById?.(result.targetNodeId);
    if (target && (target.kind === 'variable' || target.kind === 'constant') && !isRFunctionValue(target, context)) return null;
  }
  // C has no methods, and C code cannot call a C++ one: hiredis' function
  // pointer `c->funcs->read(c, buf, …)` is no Qt adapter's `read`.
  if (result && ref.language === 'c' && ref.referenceKind === 'calls' &&
      context.getNodeById?.(result.targetNodeId)?.kind === 'method') return null;
  // A type never inherits from itself: cats' `trait BigDecimalInstances extends
  // cats.kernel.instances.BigDecimalInstances` and `trait AllOps … with
  // Bifoldable.AllOps` name another type of their own name.
  if (result && result.targetNodeId === ref.fromNodeId && isInheritanceRef(ref)) return otherSupertypeNamed(ref, context);
  // Nor does a value's initializer call the value: sttp's `val response =
  // basicRequest.get(…).response(asStringAlways)` is a request's `response`.
  if (result && result.targetNodeId === ref.fromNodeId && ref.referenceKind === 'calls' &&
      VALUE_KINDS.has(context.getNodeById?.(ref.fromNodeId)?.kind ?? '')) return null;
  return result ? retargetSelfOverload(result, ref, context) : result;
}

/**
 * The supertype an inheritance ref names when the name is the declaring