Method isBuiltInOrExternal

src/resolution/index.ts:2318–2446

* Check if reference is to a built-in or external symbol

(ref: UnresolvedRef)

   * Check if reference is to a built-in or external symbol
   */
  private isBuiltInOrExternal(ref: UnresolvedRef): boolean {
    const name = ref.referenceName;
    const isJsTs = ref.language === 'typescript' || ref.language === 'javascript'
      || ref.language === 'tsx' || ref.language === 'jsx' || ref.language === 'arkts';

    // JavaScript/TypeScript built-ins
    if (isJsTs && JS_BUILT_INS.has(name)) {
      return true;
    }

    // ArkTS resource-reference intrinsics — `$r('app.string.x')` /
    // `$rawfile('x.png')` are framework-provided and appear dozens of times
    // per UI file; without this they can resolve to a stray same-named
    // symbol (e.g. a checked-in hvigor wrapper's `$r`).
    if (ref.language === 'arkts' && (name === '$r' || name === '$rawfile')) {
      return true;
    }

    // Common JS/TS library calls (console.log, Math.floor, JSON.parse)
    if (isJsTs && (name.startsWith('console.') || name.startsWith('Math.') || name.startsWith('JSON.'))) {
      return true;
    }

    // React hooks from React itself
    if (isJsTs && REACT_HOOKS.has(name)) {
      return true;
    }

    // Python built-ins (bare calls only — dotted calls like console.print are method calls)
    if (ref.language === 'python' && PYTHON_BUILT_INS.has(name)) {
      return true;
    }

    // Python built-in method calls (e.g., list.extend, dict.update)
    if (ref.language === 'python') {
      const dotIdx = name.indexOf('.');
      if (dotIdx > 0) {
        const receiver = name.substring(0, dotIdx);
        const method = name.substring(dotIdx + 1);
        // Filter calls on built-in types (list.append, dict.update, etc.)
        if (PYTHON_BUILT_IN_TYPES.has(receiver)) {
          return true;
        }
        // Filter built-in methods on non-class receivers
        // (e.g., items.append where items is a local list variable)
        // But allow if the capitalized receiver matches a known codebase class,
        // OR the receiver is itself an imported project module — a module can
        // export a top-level function sharing a common collection-method name
        // (`ledger.append`, `from . import ledger`), and that call is a real
        // project dependency, not `list.append` (#1681). Without this, the
        // qualified ref never reaches resolveViaImport / resolvePythonModuleMember.
        if (PYTHON_BUILT_IN_METHODS.has(method)) {
          // A module-scope collection binding is stronger evidence than a
          // coincidentally matching class name (#1652). Only use this file's
          // binding: an unrelated module may reuse the receiver for a collection.
          const isCollection = this.context.getNodesByName(receiver).some((node) =>
            node.language === 'python' && node.filePath === ref.filePath &&
            (node.kind === 'variable' || node.kind === 'constant') &&