Function pythonExternalWrites

src/resolution/name-matcher.ts:773–813

* Writes to module global `global` from OTHER files. A production write * ` . = Cls(...)` adds a type; any other production write * (another value, a tuple target, `setattr`) makes the type unknown. Test * files install doubles (`settings.conn = MagicMock()`, `monkeypatch.setattr`)

(global: Node, context: ResolutionContext)

 * a ref inside a writer resolves nothing through the global.
 */
function pythonExternalWrites(global: Node, context: ResolutionContext): { writes: Array<{ type: string; file: string }>; unknown: boolean; writers: Set<string> } {
  return pythonNameScan(context, `external\0${global.id}`, () => {
    const out = { writes: [] as Array<{ type: string; file: string }>, unknown: false, writers: new Set<string>() };
    const name = global.name;
    const escape = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    for (const file of context.getAllFiles()) {
      if (file === global.filePath || !/\.pyi?$/.test(file) || !context.readFile(file)?.includes(name)) continue;
      const test = isPythonTestFile(file);
      const { aliases, ambiguous } = pythonModuleAliases(file, global.filePath, context);
      if (!test && !aliases.length && !ambiguous.length) continue;
      const spell = (names: string[]) => `(?:${names.map(escape).join('|')})`;
      // Test files: any receiver (the double may sit on any spelling of the module).
      const receiver = test ? '[\\w.]+' : spell([...aliases, ...ambiguous]);
      const target = new RegExp(`(?<![\\w.])${receiver}\\.${name}\\b(?!\\s*[.\\[(])`);
      const exact = new RegExp(`^${test ? receiver : spell(aliases.length ? aliases : ['\\0'])}\\.${name}(?:\\s*:[^=]*)?$`);
      const dynamic = new RegExp(`\\b(?:setattr|patch\\.object)\\s*\\(\\s*${receiver}\\s*,\\s*['"]${name}['"]` +
        `|(?<![\\w.])${receiver}\\.__dict__\\s*(?:\\[|\\.\\s*update\\s*\\()`);
      const lines = pythonMemberLines(file, context);
      const statements = pythonStatementStarts(file, context);
      const script = pythonMainBlockLines(file, context);
      for (let i = 0; i < lines.length; i++) {
        if (!statements[i] || script.has(i)) continue;
        let statement = lines[i]!;
        for (let j = i + 1; j < lines.length && !statements[j]; j++) statement += '\n' + lines[j];
        if (!statement.includes(name)) continue;
        const assignment = pythonAssignment(statement);
        const assigned = assignment?.targets.some(t => target.test(t.trim())) ?? false;
        if (!assigned && !dynamic.test(statement)) continue;
        if (test) { out.writers.add(file); continue; }
        // A write through an ambiguous spelling may land on another module: unknown.
        const single = assignment && assignment.targets.length === 1 && !assignment.augmented && exact.test(assignment.targets[0]!.trim());
        const value = single ? assignment!.value.trim() : '';
        if (value === 'None') continue;
        const constructor = value ? pythonConstructorCall(value) : null;
        if (!constructor) { out.unknown = true; return out; }
        out.writes.push({ type: constructor, file });
      }
    }
    return out;
  });
}

/**
 * Whether the global's own module can write it through its namespace dict: