flowfig 0.7.0 → 0.8.0

package/dist/type-index.js

@@ -0,0 +1,383 @@
+import { basename, dirname, posix, resolve } from 'node:path';
+import { codeFile, esc, locate, matchClose, pyBody, readFile } from './code.js';
+import { importsOf, resolveTs } from './imports.js';
+const indexes = new WeakMap();
+export function makeCtx(root, read = readFile, cache = new Map()) {
+    let ix = indexes.get(cache);
+    if (!ix)
+        indexes.set(cache, (ix = { types: new Map(), binds: new Map(), repo: null, globals: new Map() }));
+    return { root, read, cache, ix };
+}
+export const lastSeg = (s) => s.split(/\.|::/).at(-1);
+export const file = (cx, path) => codeFile(cx.root, path, cx.read, cx.cache);
+export function bindings(cx, f) {
+    let out = cx.ix.binds.get(f.path);
+    if (!out) {
+        out = new Map(importsOf(cx.root, f, cx.read).map((i) => [i.local, { mod: i.path, imported: i.name, dir: f.lang === 'go' }]));
+        cx.ix.binds.set(f.path, out);
+    }
+    return out;
+}
+const SKIP = new Set(['target', 'bin', 'obj', 'build', 'dist']);
+function repoFiles(cx) {
+    return (cx.ix.repo ??= (cx.read.files ?? readFile.files)(cx.root));
+}
+export function goDirFiles(cx, dir) {
+    return repoFiles(cx)
+        .filter((f) => f.endsWith('.go') && !f.endsWith('_test.go') && posix.dirname(f) === dir)
+        .map((f) => file(cx, f))
+        .filter((f) => f != null);
+}
+const project = (g, path) => g.projects.find((p) => `/${path}`.startsWith(p === './' ? '/' : `/${p}`)) ?? '';
+export function global(cx, lang) {
+    const hit = cx.ix.globals.get(lang);
+    if (hit)
+        return hit;
+    const ext = { java: '.java', cs: '.cs', rs: '.rs' }[lang];
+    const g = {
+        types: new Map(),
+        impls: new Map(),
+        aliases: new Map(),
+        usings: new Set(),
+        projects: repoFiles(cx)
+            .filter((f) => f.endsWith('.csproj'))
+            .map((f) => `${posix.dirname(f)}/`)
+            .sort((a, b) => b.length - a.length),
+    };
+    for (const rel of repoFiles(cx)) {
+        if (!rel.endsWith(ext) || rel.split('/').some((s) => SKIP.has(s)))
+            continue;
+        const src = cx.read(resolve(cx.root, rel));
+        if (src == null)
+            continue;
+        for (const m of src.matchAll(/\b(class|interface|record|struct|enum|trait)\s+([A-Za-z_]\w*)/g)) {
+            const list = g.types.get(m[2]) ?? [];
+            if (!list.includes(rel))
+                list.push(rel);
+            g.types.set(m[2], list);
+        }
+        if (lang === 'cs')
+            for (const m of src.matchAll(/^\s*global\s+using\s+([\w.]+)\s*;/gm))
+                g.usings.add(`${project(g, rel)}|${m[1]}`);
+        if (lang !== 'rs')
+            continue;
+        for (const m of src.matchAll(/\btype\s+(\w+)\s*(?:<[^>]*>)?\s*=\s*([^;]+);/g))
+            g.aliases.set(m[1], { to: m[2], path: rel });
+        for (const m of src.matchAll(/\bimpl\b\s*(?:<[^>]*>)?\s*([\w:]+)(?:<[^>]*>)?\s+for\s+(?:&\s*)?([\w:]+)/g)) {
+            const ty = lastSeg(m[2]);
+            g.impls.set(ty, (g.impls.get(ty) ?? new Set()).add(lastSeg(m[1])));
+        }
+    }
+    cx.ix.globals.set(lang, g);
+    return g;
+}
+const DECL = (lang, n) => ({
+    ts: new RegExp(`\\b(class|interface)\\s+${esc(n)}\\b`, 'g'),
+    py: new RegExp(`(^|\\n)[ \\t]*class\\s+${esc(n)}\\b`, 'g'),
+    go: new RegExp(`\\btype\\s+${esc(n)}(\\[[^\\]]*\\])?\\s+(struct\\b|interface\\b|[\\w.*[])`, 'g'),
+    java: new RegExp(`\\b(class|interface|record|enum)\\s+${esc(n)}\\b`, 'g'),
+    cs: new RegExp(`\\b(class|interface|record|struct)\\s+${esc(n)}\\b`, 'g'),
+    rs: new RegExp(`\\b(struct|trait|enum)\\s+${esc(n)}\\b`, 'g'),
+})[lang];
+export function declIn(info, name) {
+    if (!info)
+        return null;
+    const m = DECL(info.lang, name).exec(info.code);
+    if (!m)
+        return null;
+    const start = m.index + (m[1] === '\n' ? 1 : 0);
+    let end;
+    if (info.lang === 'py')
+        end = pyBody(info.code, start)[1];
+    else if (info.lang === 'go' && !/(struct|interface)$/.test(m[0])) {
+        const nl = info.code.indexOf('\n', m.index);
+        end = nl < 0 ? info.code.length : nl;
+    }
+    else {
+        const unit = info.lang === 'rs' && /struct/.test(m[0]) && /^[^{]*;/.test(info.code.slice(m.index, m.index + 200));
+        const open = info.code.indexOf(unit ? ';' : '{', m.index);
+        end = open < 0 ? info.code.length : info.code[open] === ';' ? open : matchClose(info.code, open) + 1;
+    }
+    return { info, start, end, name, kind: /interface|trait/.test(m[0]) ? 'interface' : 'class' };
+}
+export function findType(cx, ctx, name, qual) {
+    if (!name || name.startsWith('#'))
+        return null;
+    const key = `${ctx.path}|${qual ?? ''}|${name}`;
+    if (cx.ix.types.has(key))
+        return cx.ix.types.get(key);
+    cx.ix.types.set(key, null);
+    const r = findType0(cx, ctx, name, qual);
+    cx.ix.types.set(key, r);
+    return r;
+}
+function findType0(cx, ctx, name, qual) {
+    const lang = ctx.lang;
+    if (lang === 'go') {
+        let dir = dirname(ctx.path);
+        if (qual) {
+            const b = bindings(cx, ctx).get(qual);
+            if (!b?.mod)
+                return null;
+            dir = b.mod;
+        }
+        for (const f of goDirFiles(cx, dir)) {
+            const d = declIn(f, name);
+            if (d)
+                return { ...d, dir };
+        }
+        return null;
+    }
+    if (!qual) {
+        const d = declIn(ctx, name);
+        if (d)
+            return d;
+    }
+    if (lang === 'ts' || lang === 'py') {
+        const b = bindings(cx, ctx).get(qual ? qual.split('.')[0] : name);
+        if (!b?.mod)
+            return null;
+        return followExport(cx, b.mod, qual ? name : b.imported === 'default' || b.imported === '*' ? name : b.imported, lang, 0);
+    }
+    if (lang === 'java') {
+        const outer = qual ? findType(cx, ctx, lastSeg(qual)) : null;
+        if (outer)
+            return declIn(outer.info, name);
+        const imp = new RegExp(`^\\s*import\\s+([\\w.]+)\\.${esc(name)}\\s*;`, 'm').exec(ctx.keep);
+        const g = global(cx, 'java').types.get(name) ?? [];
+        const pick = imp
+            ? g.find((p) => p.replace(/\.java$/, '').endsWith(`${imp[1].replace(/\./g, '/')}/${name}`))
+            : (g.find((p) => dirname(p) === dirname(ctx.path)) ?? wild(g, ctx));
+        return pick ? declIn(file(cx, pick), name) : null;
+    }
+    if (lang === 'rs') {
+        const d = rustFollow(cx, ctx, qual ? [qual.replace(/\./g, '::')] : rustUsePaths(ctx, name), name, 0);
+        return d === 'absent' ? null : d;
+    }
+    const all = (global(cx, lang).types.get(name) ?? []).map((p) => declIn(file(cx, p), name)).filter((d) => d != null);
+    const ns = (f) => /\bnamespace\s+([\w.]+)/.exec(f.code)?.[1] ?? '';
+    const usings = new Set([...ctx.code.matchAll(/^\s*using\s+([\w.]+)\s*;/gm)].map((m) => m[1]));
+    const g = global(cx, 'cs');
+    const tiers = [
+        (n) => n === ns(ctx) || ns(ctx).startsWith(`${n}.`),
+        (n) => usings.has(n),
+        (n) => !n || g.usings.has(`${project(g, ctx.path)}|${n}`),
+    ];
+    for (const tier of tiers) {
+        const hits = all.filter((d) => tier(ns(d.info)));
+        if (hits.length)
+            return hits.length === 1 ? hits[0] : null;
+    }
+    return null;
+}
+function rustModFile(cx, from, path) {
+    const own = /^(mod|lib|main)\.rs$/.test(basename(from.path)) ? dirname(from.path) : from.path.slice(0, -3);
+    const segs = path.split('::');
+    let dir;
+    if (segs[0] === 'crate') {
+        dir = dirname(from.path);
+        while (!['lib.rs', 'main.rs'].some((f) => file(cx, posix.join(dir, f))) && dir !== '.' && dir !== '/')
+            dir = dirname(dir);
+    }
+    else if (segs[0] === 'self')
+        dir = own;
+    else
+        dir = dirname(own);
+    for (const s of segs.slice(1)) {
+        if (s === 'super')
+            dir = dirname(dir);
+        else
+            dir = posix.join(dir, s);
+    }
+    if (segs.length === 1 && segs[0] === 'crate')
+        return file(cx, posix.join(dir, 'lib.rs')) ?? file(cx, posix.join(dir, 'main.rs'));
+    if (segs.length === 1 && segs[0] === 'self')
+        return from;
+    return file(cx, `${dir}.rs`) ?? file(cx, posix.join(dir, 'mod.rs'));
+}
+function rustOuter(code) {
+    let out = code;
+    for (const m of code.matchAll(/\bmod\s+\w+\s*\{/g)) {
+        const open = m.index + m[0].length - 1;
+        const close = matchClose(code, open);
+        out = out.slice(0, open + 1) + out.slice(open + 1, close).replace(/[^\n]/g, ' ') + out.slice(close);
+    }
+    return out;
+}
+function rustFollow(cx, from, mods, name, depth) {
+    if (!mods.length || depth > 3 || mods.some((m) => !/^(crate|self|super)\b/.test(m)))
+        return null;
+    const hits = [];
+    for (const m of mods) {
+        const f = rustModFile(cx, from, m);
+        if (!f)
+            return null;
+        const top = rustOuter(f.code);
+        const N = esc(name);
+        let r;
+        if (new RegExp(`\\b(?:struct|enum|trait)\\s+${N}\\b`).test(top)) {
+            const d = declIn({ ...f, code: top }, name);
+            r = d && { ...d, info: f };
+        }
+        else if (new RegExp(`\\b(?:struct|enum|trait|type|mod|fn|const|static|union)\\s+${N}\\b`).test(top))
+            r = null;
+        else {
+            const next = rustUsePaths(f, name, true);
+            if (next.length)
+                r = rustFollow(cx, f, next, name, depth + 1);
+            else
+                r = new RegExp(`\\buse\\b[^;]*\\b${N}\\b`).test(top) ? null : 'absent';
+        }
+        if (r === null)
+            return null;
+        if (r !== 'absent')
+            hits.push(r);
+    }
+    return hits.length === 1 ? hits[0] : hits.length ? null : 'absent';
+}
+function wild(g, ctx) {
+    const pkgs = [...ctx.keep.matchAll(/^\s*import\s+([\w.]+)\.\*\s*;/gm)].map((m) => `/${m[1].replace(/\./g, '/')}`);
+    const hits = g.filter((p) => pkgs.some((k) => `/${dirname(p)}`.endsWith(k)));
+    return hits.length === 1 ? hits[0] : null;
+}
+function followExport(cx, mod, name, lang, depth) {
+    const info = file(cx, mod);
+    if (!info)
+        return null;
+    const d = declIn(info, name);
+    if (d)
+        return d;
+    if (depth > 1)
+        return null;
+    const sub = bindings(cx, info).get(name);
+    if (sub?.mod && sub.mod !== mod)
+        return followExport(cx, sub.mod, sub.imported === 'default' || sub.imported === '*' ? name : sub.imported, lang, depth + 1);
+    if (lang === 'ts')
+        for (const m of info.keep.matchAll(/\bexport\s+(\*|\{[^}]*\})\s+from\s+(["'])([^"']+)\2/g)) {
+            if (m[1] !== '*' && !new RegExp(`\\b${esc(name)}\\b`).test(m[1]))
+                continue;
+            const p = resolveTs(cx.root, mod, m[3], cx.read);
+            const r = p && followExport(cx, p, name, lang, depth + 1);
+            if (r)
+                return r;
+        }
+    return null;
+}
+function basesOf(cx, d) {
+    const { info, start, name } = d;
+    const lang = info.lang;
+    let head = info.code.slice(start, info.code.indexOf(lang === 'py' ? ':' : '{', start + name.length) + 1 || start + 300);
+    const at = head.indexOf(name) + name.length;
+    if (head[at] === '<') {
+        let depth = 0;
+        let j = at;
+        for (; j < head.length; j++) {
+            if (head[j] === '<')
+                depth++;
+            else if (head[j] === '>' && --depth === 0)
+                break;
+        }
+        head = head.slice(0, at) + head.slice(j + 1);
+    }
+    const split = (s) => s
+        .replace(/<[^<>]*(<[^<>]*>[^<>]*)*>/g, '')
+        .split(',')
+        .map((x) => x.trim().split(/\s+/)[0])
+        .filter(Boolean)
+        .map(lastSeg);
+    let out = [];
+    if (lang === 'ts' || lang === 'java') {
+        const e = /\bextends\s+([^{]*?)(\bimplements\b|\{|$)/.exec(head);
+        if (e)
+            out.push(...split(e[1]));
+        const i = /\bimplements\s+([^{]*)/.exec(head);
+        if (i)
+            out.push(...split(i[1]));
+    }
+    else if (lang === 'py') {
+        const m = new RegExp(`class\\s+${esc(name)}\\s*\\(([^)]*)\\)`).exec(head);
+        if (m)
+            out = split(m[1].replace(/\w+\s*=\s*[\w.]+/g, ''));
+    }
+    else if (lang === 'cs') {
+        const h = head.replace(new RegExp(`^[\\s\\S]*?\\b${esc(name)}\\s*(<[^>]*>)?\\s*(\\([^)]*\\))?`), '');
+        const m = /^\s*:\s*([^{]*?)(\bwhere\b|\{|$)/.exec(h);
+        if (m)
+            out = split(m[1].replace(/\([^)]*\)/g, ''));
+    }
+    else if (lang === 'go') {
+        for (const m of info.code.slice(start, d.end).matchAll(/\n[ \t]*\*?([\w.]+)[ \t]*(?=\n)/g))
+            out.push(lastSeg(m[1]));
+    }
+    else if (lang === 'rs')
+        out = [...(global(cx, 'rs').impls.get(name) ?? [])];
+    return out.filter((x) => x && x !== name);
+}
+export function ancestors(cx, d) {
+    const out = [];
+    const seen = new Set([d.name]);
+    const todo = [d];
+    while (todo.length && out.length < 30) {
+        const c = todo.shift();
+        for (const b of basesOf(cx, c)) {
+            if (seen.has(b))
+                continue;
+            seen.add(b);
+            const bd = c.info.lang === 'rs' ? null : findType(cx, c.info, b);
+            out.push({ name: b, d: bd });
+            if (bd)
+                todo.push(bd);
+        }
+    }
+    return out;
+}
+export function goMethods(cx, d) {
+    const out = new Set();
+    for (const f of goDirFiles(cx, dirname(d.info.path)))
+        for (const m of f.code.matchAll(new RegExp(`\\bfunc\\s*\\(\\s*\\w*\\s*\\*?\\s*${esc(d.name)}(\\[[^\\]]*\\])?\\s*\\)\\s*(\\w+)`, 'g')))
+            out.add(m[2]);
+    return out;
+}
+export const goIfaceMethods = (d) => [...d.info.code.slice(d.start, d.end).matchAll(/\n[ \t]*([A-Za-z_]\w*)\s*\(/g)].map((m) => m[1]);
+export function defines(cx, d, n) {
+    if (d.info.lang === 'go')
+        return (goMethods(cx, d).has(n) ||
+            (d.kind === 'interface' && new RegExp(`\\n[ \\t]*${esc(n)}\\s*\\(`).test(d.info.code.slice(d.start, d.end))));
+    return locate(d.info, `${d.name}.${n}`) != null;
+}
+export function rustUses(fi, n, tp) {
+    const mods = rustUsePaths(fi, n);
+    if (mods.some((m) => !/^(crate|self|super)\b/.test(m)))
+        return 'outside';
+    return mods.some((m) => lastSeg(m) === rustMod(tp)) ? 'yes' : 'no';
+}
+function expandUse(item) {
+    const open = item.indexOf('{');
+    if (open < 0)
+        return [item.trim()];
+    const close = matchClose(item, open);
+    const parts = [];
+    let depth = 0;
+    let last = open + 1;
+    for (let i = open + 1; i < close; i++) {
+        if (item[i] === '{')
+            depth++;
+        else if (item[i] === '}')
+            depth--;
+        else if (item[i] === ',' && depth === 0) {
+            parts.push(item.slice(last, i));
+            last = i + 1;
+        }
+    }
+    parts.push(item.slice(last, close));
+    return parts.filter((p) => p.trim()).flatMap((p) => expandUse(item.slice(0, open) + p.trim()));
+}
+function rustUsePaths(fi, n, pubOnly = false) {
+    const items = pubOnly ? /\bpub(?:\([^)]*\))?\s+use\s+([^;]+);/g : /\buse\s+([^;]+);/g;
+    const paths = [...rustOuter(fi.code).matchAll(items)].flatMap((m) => expandUse(m[1].replace(/\s+/g, ' ')));
+    const named = paths.filter((p) => (/\sas\s+(\w+)$/.exec(p)?.[1] ?? lastSeg(p)) === n);
+    if (named.length)
+        return named.map((p) => (/\sas\s/.test(p) ? '#alias' : p.split('::').slice(0, -1).join('::')));
+    return paths.filter((p) => p.endsWith('::*')).map((p) => p.slice(0, -3));
+}
+export const rustMod = (tp) => (basename(tp) === 'mod.rs' ? basename(dirname(tp)) : basename(tp, '.rs'));

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+import { type CodeFile, type Lang } from './code.ts';
+import { type Ctx, type Decl } from './type-index.ts';
+export { makeCtx, bindings, declIn, defines, ancestors, file, findType, rustMod, rustUses, type Ctx, type Decl } from './type-index.ts';
+export type Reach = 'yes' | 'no' | 'unsure';
+export type Rt = {
+    kind: 'unknown' | 'type' | 'module' | 'value' | 'super' | 'rsmod';
+    name?: string;
+    qual?: string | null;
+    ctx?: CodeFile;
+    decl?: Decl | null;
+    mod?: string | null;
+    dir?: boolean;
+};
+type Local = {
+    chain?: string[];
+    type?: string;
+    ctor?: string;
+    declared?: boolean;
+};
+export declare const isUpper: (s: string) => boolean;
+export declare function receiverChain(body: string, idx: number, lang: Lang): {
+    chain: string[];
+    complex: boolean;
+} | null;
+export declare function normType(raw: string | undefined, lang: Lang): {
+    name: string;
+    qual?: string | null;
+} | null;
+export declare function localType(cx: Ctx, info: CodeFile, text: string, n: string, lang: Lang, hasHead?: boolean): Local | null;
+export declare function receiver(cx: Ctx, fi: CodeFile, body: string, chain: string[], fromContainer: string | null, fromDecl: Decl | null, depth?: number): Rt;
+export declare function reaches(cx: Ctx, rt: Rt, ownerDecl: Decl | null, owner: string, method: string, ownerPath: string): Reach;
+export declare function inTypePosition(body: string, idx: number, lang: Lang): boolean;