flowfig 0.7.0 → 0.8.0

package/dist/guide.js

@@ -66,7 +66,8 @@ If the code does not show a fact, leave the fact out. Do not guess a part, a nam
 
 Each fact becomes a box, an edge, a beat, a \`data\` card or a \`show\` row. Use the real names from the code as labels, and
 real example data from the code or its tests. Keep each fact that you leave out, with the reason, for the reply.
-Give each box and edge that draws code a \`source\`, from the fact list: \`"src/auth/login.ts#verifyPassword"\`. A store or an outside part may have none.
+Give each box and edge that draws code a \`source\`, from the fact list: \`"src/auth/login.ts#verifyPassword"\`. A method uses \`Owner.name\`: \`"src/auth/session.ts#Session.refresh"\`. An edge \`source\` names the function that makes the call. An edge needs no \`source\` when the code of its \`from\` box makes the call. An edge across a process (HTTP, a queue, a topic, a table) gets \`via\`: the route, queue, topic or table name that both sides use in the code, for example \`"via": "order-paid"\`. A store box may have no \`source\`, but an edge to it still needs \`via\`.
+For an HTTP edge, \`via\` is the path that both sides use: \`"via": "/internal/users"\`. An edge to a store box (a table, a file, a folder, a cache key) uses \`via\` with the name that the caller code uses: \`"via": "sales_facts"\`. A route handler with no name keeps a file \`source\`, and an edge into it uses \`via\` with the route path. An edge out of it in the same process uses no \`via\`.
 A box that draws a step from a document links to that document: \`"docs/sop/refunds.md#step-3-approve-the-refund"\`, the heading as a GitHub anchor. \`verify\` checks it the same way.
 
 Mermaid mapping:
@@ -112,7 +113,7 @@ command writes no SVG and lists the faults. Fix each fault and render again.
 Run \`npx flowfig --spec out.svg\`. Compare the spec with the fact list. Check that each edge goes from the caller to the callee
 that its fact names. Add each fact that is missing, fix each wrong edge, and render again.
 
-Run \`npx flowfig verify out.svg\` from the repo root. Fix each \`missing-file\` or \`missing-symbol\`.
+Run \`npx flowfig verify out.svg\` from the repo root. Fix each \`missing-file\` and \`missing-symbol\`. For each \`edge-not-found\`, the code does not make that call: remove the edge, or point its \`source\` at the function that makes the call. An \`unsure\` edge is allowed, but if a function with a typed receiver makes the call, point the edge \`source\` at it. A \`not checked\` edge has no code to check: give it a \`source\` or a \`via\` if one exists. Do not invent an edge to make verify pass.
 
 ### 6. Look at the SVG
 
@@ -132,7 +133,8 @@ The reply has these parts, in this order:
 4. what the figure leaves out, and why;
 5. the two check lines that the render printed, \`0 errors, 0 warnings\` and \`figure: ...\`, copied as printed, and whether
    you looked at the SVG;
-6. one line \`npx flowfig open <path>\` for each SVG, at the end of the reply. Do not run that command yourself.
+6. the \`verify\` edge counts from its count line, for example "edges: 5 found, 0 not found, 1 unsure, 0 not checked";
+7. one line \`npx flowfig open <path>\` for each SVG, at the end of the reply. Do not run that command yourself.
 
 To change an SVG later, print its spec with \`--spec\`, change the spec, and render again.
 
@@ -174,7 +176,7 @@ Every other item is a box.
 | \`from\`    | In a \`timeline\` figure: the start of the item, or the date of a milestone, as YYYY-MM-DD. |
 | \`to\`      | In a \`timeline\` figure: the last day of the item, as YYYY-MM-DD. Without it the box is a milestone. |
 | \`width\`   | Width in px. This overrides the width that the layout picks.                                              |
-| \`source\`  | The code this draws: \`path\` or \`path#symbol\`, relative to the repo root. \`flowfig verify\` checks it.  |
+| \`source\`  | The code this draws: \`path\` or \`path#Owner.name\`, relative to the repo root. \`flowfig verify\` checks it.  |
 | \`lines\`   | The least number of text lines that a content card keeps. The card still grows to fit its content.        |
 | \`tone\`    | The state color of the box: a 1 px border and a light tint. Use \`blue\`, \`purple\`, \`green\`, \`orange\`, \`red\` or \`gray\`.                  |
 | \`mark\`    | \`"start"\` or \`"end"\` | A lifecycle mark: a filled dot before a start state, a ringed dot after an end state. |
@@ -188,7 +190,8 @@ An edge has these fields.
 - \`label\`: text on the edge, drawn as a small pill.
 - \`around\`: \`"above"\` or \`"below"\`. This routes the edge over or under the boxes in between (loops, skip-ahead edges).
 - \`quiet\`: if \`true\`, the SVG draws the edge only while a step uses it.
-- \`source\`: the code this edge draws, as \`path\` or \`path#symbol\`. \`flowfig verify\` checks it.
+- \`source\`: the code this edge draws, as \`path\` or \`path#Owner.name\`. \`flowfig verify\` checks it.
+- \`via\`: the route, queue, topic or table name that both sides of a cross-process edge use in the code.
 
 ### steps
 
@@ -203,7 +206,7 @@ boxes to highlight for the whole step).
 
 The beat fields:
 
-- \`edges\`: an edge id, a hop object, or an array of these. A hop object is \`{ edge, back?, data?, tone?, async?, source? }\`.
+- \`edges\`: an edge id, a hop object, or an array of these. A hop object is \`{ edge, back?, data?, tone?, async?, source?, via? }\`.
   - \`back: true\` runs the packet from the \`to\` box to the \`from\` box.
   - \`data\` is a small card that moves with the packet.
   - \`async: true\` marks a message that does not wait for an answer. The rail draws it dashed, with an \`async\` tag.
@@ -275,7 +278,7 @@ npx flowfig - out.svg < spec.json      # render a spec from stdin
 npx flowfig spec.json out.svg          # render a spec file
 npx flowfig figure.ts out.svg          # render a module whose default export is a spec
 npx flowfig check <input> [--json]     # list the faults. The input can also be an SVG that flowfig wrote.
-npx flowfig verify <input>...          # check that the code each source names still exists
+npx flowfig verify <input>...          # check each source and each edge against the code
 npx flowfig diff <old> <new>           # list what changed in the spec between two figures
 npx flowfig --spec out.svg             # print the spec that an SVG carries
 npx flowfig open out.svg               # show the figure in the default browser

package/dist/imports.d.ts

@@ -0,0 +1,11 @@
+import { type CodeFile, type Read } from './code.ts';
+export type Import = {
+    name: string;
+    local: string;
+    path: string | null;
+};
+export declare const OUTSIDE = "#outside";
+export declare function resolveTs(root: string, from: string, spec: string, read: Read): string | null;
+export declare function resolvePy(root: string, from: string, mod: string, read: Read, top?: string): string | null;
+export declare function importsOf(root: string, file: CodeFile, read: Read): Import[];
+export declare function leadsTo(root: string, fromPath: string, toPath: string, name: string, read?: Read, cache?: Map<string, CodeFile | null>, depth?: number): string | null;

package/dist/imports.js

@@ -0,0 +1,235 @@
+import { builtinModules } from 'node:module';
+import { posix, resolve } from 'node:path';
+import { codeFile, esc, langOf, outside, readFile } from './code.js';
+export const OUTSIDE = '#outside';
+const TS_EXT = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '/index.ts', '/index.tsx', '/index.js'];
+const readIn = (root, path, read) => (outside(root, path) ? null : read(resolve(root, path)));
+const has = (root, path, read) => readIn(root, path, read) != null;
+function tsConfig(root, read) {
+    const paths = [];
+    let baseUrl;
+    let cfg = 'tsconfig.json';
+    for (let k = 0; k < 4 && cfg; k++) {
+        const raw = readIn(root, cfg, read);
+        if (raw == null)
+            break;
+        const dir = posix.dirname(cfg);
+        const own = /"baseUrl"\s*:\s*"([^"]*)"/.exec(raw)?.[1];
+        if (own != null)
+            baseUrl ??= posix.join(dir, own);
+        const block = /"paths"\s*:\s*\{([^}]*)\}/.exec(raw)?.[1] ?? '';
+        for (const m of block.matchAll(/"([^"]+)"\s*:\s*\[\s*"([^"]+)"/g))
+            paths.push({ base: own != null ? posix.join(dir, own) : dir, key: m[1], target: m[2] });
+        const ext = /"extends"\s*:\s*"(\.[^"]+)"/.exec(raw)?.[1];
+        cfg = ext ? posix.join(dir, ext.endsWith('.json') ? ext : `${ext}.json`) : '';
+    }
+    return { paths, baseUrl };
+}
+export function resolveTs(root, from, spec, read) {
+    const bases = [];
+    if (spec.startsWith('.'))
+        bases.push(posix.join(posix.dirname(from), spec));
+    else {
+        const cfg = tsConfig(root, read);
+        for (const { base, key, target } of cfg.paths) {
+            const star = key.indexOf('*');
+            const pre = star < 0 ? key : key.slice(0, star);
+            const post = star < 0 ? '' : key.slice(star + 1);
+            if (star < 0 ? spec !== key : !(spec.startsWith(pre) && spec.endsWith(post) && spec.length >= key.length - 1))
+                continue;
+            bases.push(posix.join(base, star < 0 ? target : target.replace('*', spec.slice(pre.length, spec.length - post.length))));
+        }
+        if (cfg.baseUrl != null)
+            bases.push(posix.join(cfg.baseUrl, spec));
+    }
+    for (const b of bases) {
+        const base = b.replace(/\.(js|mjs|cjs|jsx)$/, '');
+        const hit = TS_EXT.map((e) => base + e).find((p) => has(root, p, read));
+        if (hit)
+            return hit;
+    }
+    return spec.startsWith('node:') || builtinModules.includes(spec.split('/')[0]) ? OUTSIDE : null;
+}
+function pyTop(root, from, read) {
+    let d = posix.dirname(from);
+    while (d !== '.' && has(root, `${d}/__init__.py`, read))
+        d = posix.dirname(d);
+    return d;
+}
+export function resolvePy(root, from, mod, read, top) {
+    const hit = (b) => [`${b}.py`, `${b}/__init__.py`].find((p) => has(root, p, read)) ?? null;
+    if (mod.startsWith('.')) {
+        const dots = /^\.+/.exec(mod)[0].length;
+        let d = posix.dirname(from);
+        for (let k = 1; k < dots; k++) {
+            if (d === '.')
+                return null;
+            d = posix.dirname(d);
+        }
+        return hit(posix.join(d, mod.slice(dots).replace(/\./g, '/')));
+    }
+    const rel = mod.replace(/\./g, '/');
+    const d = top ?? pyTop(root, from, read);
+    return hit(rel) ?? (d === '.' ? null : hit(posix.join(d, rel)));
+}
+function goModule(root, from, read) {
+    let dir = posix.dirname(from);
+    for (;;) {
+        const text = readIn(root, posix.join(dir, 'go.mod'), read);
+        if (text != null)
+            return { mod: /module\s+(\S+)/.exec(text)?.[1], dir, text };
+        if (dir === '.')
+            return { dir, text: '' };
+        dir = posix.dirname(dir);
+    }
+}
+function goWork(root, from, read) {
+    for (let d = posix.dirname(from);; d = posix.dirname(d)) {
+        const text = readIn(root, posix.join(d, 'go.work'), read);
+        if (text != null)
+            return [...text.matchAll(/^\s*(?:use\s+)?"?(\.[^\s")]*)"?\s*$/gm)].flatMap((m) => {
+                const dir = posix.join(d, m[1]);
+                const mod = /module\s+(\S+)/.exec(readIn(root, posix.join(dir, 'go.mod'), read) ?? '')?.[1];
+                return mod ? [{ mod, dir }] : [];
+            });
+        if (d === '.')
+            return [];
+    }
+}
+const goRequired = (text, p) => [...text.matchAll(/^\s*(?:require\s+)?([\w.~-]+\/[\w.~/-]+)\s+v\S+/gm)].some((m) => (p === m[1] || p.startsWith(`${m[1]}/`)) && !new RegExp(`^\\s*(?:replace\\s+)?${esc(m[1])}\\b[^\\n]*=>`, 'm').test(text));
+export function importsOf(root, file, read) {
+    const { keep, lang, path } = file;
+    const out = [];
+    const add = (name, local, to) => out.push({ name, local, path: to });
+    if (lang === 'ts') {
+        for (const m of keep.matchAll(/\bimport\s+(type\s+)?([\s\S]*?)\s+from\s+(["'])([^"']+)\3/g)) {
+            const to = resolveTs(root, path, m[4], read);
+            const clause = m[2];
+            const def = /^([A-Za-z_$][\w$]*)\s*(,|$)/.exec(clause);
+            if (def)
+                add('default', def[1], to);
+            const ns = /\*\s+as\s+([A-Za-z_$][\w$]*)/.exec(clause);
+            if (ns)
+                add('*', ns[1], to);
+            const named = /\{([\s\S]*)\}/.exec(clause);
+            if (named)
+                for (const part of named[1].split(',')) {
+                    const p = part.trim().replace(/^type\s+/, '');
+                    if (!p)
+                        continue;
+                    const [a, b] = p.split(/\s+as\s+/);
+                    add(a.trim(), (b ?? a).trim(), to);
+                }
+        }
+        for (const m of keep.matchAll(/\b(?:const|let|var)\s+(\{[^}]*\}|[A-Za-z_$][\w$]*)\s*=\s*(?:await\s+)?(?:require|import)\((["'])([^"']+)\2\)/g)) {
+            const to = resolveTs(root, path, m[3], read);
+            if (m[1].startsWith('{'))
+                for (const p of m[1].slice(1, -1).split(',')) {
+                    const [a, b] = p.split(':').map((x) => x.trim());
+                    if (a)
+                        add(a, b ?? a, to);
+                }
+            else
+                add('*', m[1], to);
+        }
+    }
+    else if (lang === 'py') {
+        const top = pyTop(root, path, read);
+        for (const m of keep.matchAll(/^[ \t]*from\s+([\w.]+)\s+import\s+(\([^)]*\)|[^\n]+)/gm)) {
+            const to = resolvePy(root, path, m[1], read, top);
+            for (const part of m[2].replace(/[()]/g, '').split(',')) {
+                const p = part.trim();
+                if (!p)
+                    continue;
+                const [a, b] = p.split(/\s+as\s+/).map((x) => x.trim());
+                const sub = resolvePy(root, path, (m[1].endsWith('.') ? m[1] : `${m[1]}.`) + a, read, top);
+                if (sub)
+                    add('*', b ?? a, sub);
+                else
+                    add(a, b ?? a, to);
+            }
+        }
+        for (const m of keep.matchAll(/^[ \t]*import\s+([\w.]+)(\s+as\s+(\w+))?/gm))
+            add('*', m[3] ?? m[1].split('.')[0], resolvePy(root, path, m[1], read, top));
+    }
+    else if (lang === 'go') {
+        const { mod, dir, text } = goModule(root, path, read);
+        let work;
+        for (const m of keep.matchAll(/^\s*(?:import\s+)?(\w+|\.|_)?\s*"([^"]+)"/gm)) {
+            const p = m[2];
+            const inside = (w) => w.mod && (p === w.mod || p.startsWith(`${w.mod}/`));
+            const own = [
+                { mod, dir },
+                ...(p.split('/')[0].includes('.') && !inside({ mod, dir }) ? (work ??= goWork(root, path, read)) : []),
+            ].find(inside);
+            const to = own
+                ? posix.join(own.dir, p.slice(own.mod.length + 1))
+                : p.split('/')[0].includes('.') && !goRequired(text, p)
+                    ? null
+                    : OUTSIDE;
+            add('*', m[1] ?? p.split('/').at(-1), to);
+        }
+    }
+    return out;
+}
+function reexports(root, file, name, read) {
+    const N = esc(name);
+    const out = [];
+    if (name === '*')
+        return out;
+    if (file.lang === 'py') {
+        if (new RegExp(`^(?:(?:async\\s+)?def|class)\\s+${N}\\b|^${N}\\s*[:=]`, 'm').test(file.code))
+            return out;
+        for (const i of importsOf(root, file, read))
+            if (i.local === name || i.local === '*')
+                out.push([i.path, i.local === '*' ? '?' : i.name]);
+        return out.length > 1 ? [[null, '?']] : out;
+    }
+    if (file.lang !== 'ts')
+        return out;
+    if (new RegExp(`^export\\s+(?:default\\s+)?(?:async\\s+)?(?:function\\s*\\*?|class|const|let|var|enum)\\s*${N}\\b`, 'm').test(file.code))
+        return out;
+    for (const m of file.keep.matchAll(/\bexport\s+(?:type\s+)?(\*(?:\s+as\s+([\w$]+))?|\{([^}]*)\})\s+from\s+(["'])([^"']+)\4/g)) {
+        const p = resolveTs(root, file.path, m[5], read);
+        if (m[3] != null) {
+            for (const part of m[3].split(',')) {
+                const [a, b] = part
+                    .trim()
+                    .replace(/^type\s+/, '')
+                    .split(/\s+as\s+/);
+                if (a && (b ?? a).trim() === name)
+                    out.push([p, a.trim()]);
+            }
+        }
+        else if (m[2] == null ? name !== 'default' : m[2] === name)
+            out.push([p, m[2] == null ? name : '*']);
+    }
+    for (const m of file.keep.matchAll(/\bexport\s*\{([^}]*)\}(?!\s*from)/g))
+        for (const part of m[1].split(',')) {
+            const [a, b] = part.trim().split(/\s+as\s+/);
+            if (!a || (b ?? a).trim() !== name)
+                continue;
+            const i = importsOf(root, file, read).find((x) => x.local === a.trim());
+            if (i)
+                out.push([i.path, i.name]);
+        }
+    return out;
+}
+export function leadsTo(root, fromPath, toPath, name, read = readFile, cache = new Map(), depth = 0) {
+    if (fromPath === toPath)
+        return name;
+    if (langOf(fromPath) == null)
+        return posix.dirname(toPath) === fromPath ? name : null;
+    const file = depth < 5 ? codeFile(root, fromPath, read, cache) : null;
+    if (!file)
+        return null;
+    let star = false;
+    for (const [path, inner] of reexports(root, file, name, read)) {
+        const r = path == null || inner === '?' ? null : leadsTo(root, path, toPath, inner, read, cache, depth + 1);
+        if (r === '?' || inner === '?')
+            star = true;
+        else if (r != null)
+            return r;
+    }
+    return star ? '?' : null;
+}

package/dist/mcp.js

@@ -6,7 +6,7 @@ import { GUIDE } from './guide.js';
 import { loadSpec, reportLines, sortFindings, svgWithSpec } from './load.js';
 import { check, render } from './svg.js';
 import { checkRendered } from './check.js';
-import { verify } from './verify.js';
+import { coverageLine, unsureLines, verifyReport } from './verify.js';
 import { VERSION } from './version.js';
 const specSchema = {
     description: 'The figure: the props object, { props }, or a path to a .json file or an SVG that flowfig wrote.',
@@ -115,6 +115,7 @@ function run(name, args) {
         types(args, name, { root: 'string', strict: 'boolean' });
         const root = args.root == null ? process.cwd() : String(args.root);
         const lines = [];
+        const counts = [];
         let errors = 0;
         for (const p of args.paths) {
             let props;
@@ -128,13 +129,15 @@ function run(name, args) {
                 lines.push(`${'error'.padEnd(8)} ${'missing-file'.padEnd(18)} ${e.message}`);
                 continue;
             }
-            const findings = sortFindings([...check(props), ...verify(props, { root })], args.strict === true);
+            const report = verifyReport(props, { root });
+            counts.push(coverageLine(p, report.coverage), ...unsureLines(report.coverage));
+            const findings = sortFindings([...check(props), ...report.findings], args.strict === true);
             errors += findings.filter((f) => f.severity === 'error').length;
             lines.push(...findings.map((f) => `${f.severity.padEnd(8)} ${f.rule.padEnd(18)} ${p}: ${f.message}`));
         }
         const n = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`;
         const total = lines.length;
-        lines.push(`${n(errors, 'error')}, ${n(total - errors, 'warning')}`);
+        lines.push(`${n(errors, 'error')}, ${n(total - errors, 'warning')}`, ...counts);
         return ok(lines.join('\n'), errors > 0);
     }
     if (name === 'diff') {

package/dist/model.d.ts

@@ -58,6 +58,8 @@ export type FigEdge = {
     quiet?: boolean;
     /** Code this draws: `path` or `path#symbol` from the repo root. Checked by `flowfig verify`. */
     source?: string;
+    /** The route, queue, topic or table that carries this edge. Checked by `flowfig verify`. */
+    via?: string;
 };
 /** One packet on one edge. A string is the edge `id`. */
 export type FigHop = string | {
@@ -73,6 +75,8 @@ export type FigHop = string | {
     async?: boolean;
     /** Code this draws: `path` or `path#symbol` from the repo root. Checked by `flowfig verify`. */
     source?: string;
+    /** The route, queue, topic or table that carries this edge. Checked by `flowfig verify`. */
+    via?: string;
 };
 /** One moment of a step. No edges means a pause. */
 export type FigBeat = {
@@ -161,6 +165,7 @@ export type Beat = Omit<FigBeat, 'edges'> & {
         tone?: FigTone;
         async?: boolean;
         source?: string;
+        via?: string;
     }[];
 };
 export declare const toBeat: (b: FigHop | FigHop[] | FigBeat) => Beat;

package/dist/source.d.ts

@@ -12,6 +12,6 @@ export type Link = {
     symbol?: string;
 };
 /** Every box, edge and hop with its raw `source`, well-formed or not. The one owner list that `links` and `checkSpec` share. */
-export declare function owners(fig: FlowProps): [string, string | undefined][];
+export declare function owners(fig: FlowProps): [string, string | undefined, string | undefined][];
 /** Every well-formed link in the figure, with the box, edge or hop that carries it. `bad-source` covers the rest. */
 export declare function links(fig: FlowProps): Link[];

package/dist/source.js

@@ -15,9 +15,9 @@ export const headingSlug = (text) => text
 /** Every box, edge and hop with its raw `source`, well-formed or not. The one owner list that `links` and `checkSpec` share. */
 export function owners(fig) {
     return [
-        ...nodes(fig.layout).map((n) => [`box "${n.id}"`, n.source]),
-        ...fig.edges.map((e) => [`edge "${edgeId(e)}"`, e.source]),
-        ...(fig.steps ?? []).flatMap((s) => s.flow.flatMap((b) => toBeat(b).hops.map((h) => [`hop on "${h.edge}"`, h.source]))),
+        ...nodes(fig.layout).map((n) => [`box "${n.id}"`, n.source, undefined]),
+        ...fig.edges.map((e) => [`edge "${edgeId(e)}"`, e.source, e.via]),
+        ...(fig.steps ?? []).flatMap((s) => s.flow.flatMap((b) => toBeat(b).hops.map((h) => [`hop on "${h.edge}"`, h.source, h.via]))),
     ];
 }
 /** Every well-formed link in the figure, with the box, edge or hop that carries it. `bad-source` covers the rest. */

package/dist/type-index.d.ts

@@ -0,0 +1,55 @@
+import { type CodeFile, type Lang, type Read } from './code.ts';
+export type Decl = {
+    info: CodeFile;
+    start: number;
+    end: number;
+    name: string;
+    kind: 'class' | 'interface';
+    dir?: string;
+};
+export type Bind = {
+    mod: string | null;
+    imported: string;
+    dir: boolean;
+};
+type Globals = {
+    types: Map<string, string[]>;
+    impls: Map<string, Set<string>>;
+    aliases: Map<string, {
+        to: string;
+        path: string;
+    }>;
+    usings: Set<string>;
+    projects: string[];
+};
+type Index = {
+    types: Map<string, Decl | null>;
+    binds: Map<string, Map<string, Bind>>;
+    repo: string[] | null;
+    globals: Map<Lang, Globals>;
+};
+type Cache = Map<string, CodeFile | null>;
+export type Ctx = {
+    root: string;
+    read: Read;
+    cache: Cache;
+    ix: Index;
+};
+export declare function makeCtx(root: string, read?: Read, cache?: Cache): Ctx;
+export declare const lastSeg: (s: string) => string;
+export declare const file: (cx: Ctx, path: string) => CodeFile | null;
+export declare function bindings(cx: Ctx, f: CodeFile): Map<string, Bind>;
+export declare function goDirFiles(cx: Ctx, dir: string): CodeFile[];
+export declare function global(cx: Ctx, lang: 'java' | 'cs' | 'rs'): Globals;
+export declare function declIn(info: CodeFile | null, name: string): Decl | null;
+export declare function findType(cx: Ctx, ctx: CodeFile, name: string | undefined, qual?: string | null): Decl | null;
+export declare function ancestors(cx: Ctx, d: Decl): {
+    name: string;
+    d: Decl | null;
+}[];
+export declare function goMethods(cx: Ctx, d: Decl): Set<string>;
+export declare const goIfaceMethods: (d: Decl) => string[];
+export declare function defines(cx: Ctx, d: Decl, n: string): boolean;
+export declare function rustUses(fi: CodeFile, n: string, tp: string): 'yes' | 'no' | 'outside';
+export declare const rustMod: (tp: string) => string;
+export {};