hullproof 0.0.0-stage → 0.5.0

package/dist/map/lex.js

@@ -0,0 +1,425 @@
+// Text helpers for the extractors (approach (b) in docs/PHASE-2-DESIGN.md): blank out comments and string contents while
+// keeping every position, match brackets, and cut function bodies. No parser, no dependency.
+import { maskMore } from './lex-more.js';
+const blank = (s) => s.replace(/[^\n]/g, ' ');
+// Whether a "/" at `i` starts a regular expression literal (and is not a division or a JSX closing tag), judged from the
+// text before it.
+function regexAllowed(text, i) {
+    let k = i - 1;
+    while (k >= 0 && /\s/.test(text[k]))
+        k--;
+    if (k < 0)
+        return true;
+    if ('(,=:[!&|?{;+-*%~^'.includes(text[k]))
+        return true;
+    const m = /([A-Za-z_$][\w$]*)$/.exec(text.slice(Math.max(0, k - 12), k + 1));
+    return !!m && /^(return|typeof|case|in|of|delete|void|throw|new|else|do|yield|await)$/.test(m[1]);
+}
+// A copy of `text` with the same length in which comments and the insides of string literals are spaces. Quote characters
+// and newlines stay, so a regular expression run on the copy never matches inside a comment or a string, and a position in
+// the copy is the same position in the original.
+export function mask(text, lang) {
+    if (lang !== 'js' && lang !== 'py')
+        return maskMore(text, lang);
+    const n = text.length;
+    const out = [];
+    let i = 0;
+    let prevSig = '';
+    const put = (from, to) => { out.push(blank(text.slice(from, to))); };
+    const keep = (from, to) => { out.push(text.slice(from, to)); };
+    const skipTemplate = (start) => {
+        let j = start + 1;
+        while (j < n) {
+            const c = text[j];
+            if (c === '\\') {
+                j += 2;
+                continue;
+            }
+            if (c === '`')
+                return j + 1;
+            if (c === '$' && text[j + 1] === '{') {
+                let depth = 1;
+                j += 2;
+                while (j < n && depth > 0) {
+                    const d = text[j];
+                    if (d === '`') {
+                        j = skipTemplate(j);
+                        continue;
+                    }
+                    if (d === '"' || d === "'") {
+                        j++;
+                        while (j < n && text[j] !== d && text[j] !== '\n') {
+                            if (text[j] === '\\')
+                                j++;
+                            j++;
+                        }
+                        j++;
+                        continue;
+                    }
+                    if (d === '{')
+                        depth++;
+                    else if (d === '}')
+                        depth--;
+                    j++;
+                }
+                continue;
+            }
+            j++;
+        }
+        return n;
+    };
+    while (i < n) {
+        const c = text[i];
+        const c2 = text[i + 1];
+        if (lang === 'js') {
+            if (c === '/' && c2 === '/') {
+                const e = text.indexOf('\n', i);
+                const end = e < 0 ? n : e;
+                put(i, end);
+                i = end;
+                continue;
+            }
+            if (c === '/' && c2 === '*') {
+                const e = text.indexOf('*/', i + 2);
+                const end = e < 0 ? n : e + 2;
+                put(i, end);
+                i = end;
+                continue;
+            }
+            if (c === '`') {
+                const end = skipTemplate(i);
+                keep(i, i + 1);
+                put(i + 1, Math.max(i + 1, end - 1));
+                if (end - 1 > i)
+                    keep(end - 1, end);
+                i = end;
+                prevSig = '`';
+                continue;
+            }
+            if (c === '"' || c === "'") {
+                let j = i + 1;
+                while (j < n && text[j] !== c && text[j] !== '\n') {
+                    if (text[j] === '\\')
+                        j++;
+                    j++;
+                }
+                const close = j < n && text[j] === c ? j : -1;
+                keep(i, i + 1);
+                put(i + 1, close < 0 ? Math.min(j, n) : close);
+                if (close >= 0)
+                    keep(close, close + 1);
+                i = close < 0 ? Math.min(j, n) : close + 1;
+                prevSig = c;
+                continue;
+            }
+            if (c === '/' && regexAllowed(text, i)) {
+                // regular expression literal
+                let j = i + 1;
+                let inClass = false;
+                while (j < n && text[j] !== '\n') {
+                    if (text[j] === '\\') {
+                        j += 2;
+                        continue;
+                    }
+                    if (text[j] === '[')
+                        inClass = true;
+                    else if (text[j] === ']')
+                        inClass = false;
+                    else if (text[j] === '/' && !inClass)
+                        break;
+                    j++;
+                }
+                if (j < n && text[j] === '/') {
+                    keep(i, i + 1);
+                    put(i + 1, j);
+                    keep(j, j + 1);
+                    i = j + 1;
+                    prevSig = '/';
+                    continue;
+                }
+            }
+        }
+        else {
+            if (c === '#') {
+                const e = text.indexOf('\n', i);
+                const end = e < 0 ? n : e;
+                put(i, end);
+                i = end;
+                continue;
+            }
+            if (c === '"' || c === "'") {
+                const triple = text[i + 1] === c && text[i + 2] === c;
+                if (triple) {
+                    const e = text.indexOf(c.repeat(3), i + 3);
+                    const end = e < 0 ? n : e + 3;
+                    keep(i, i + 3);
+                    put(i + 3, Math.max(i + 3, end - 3));
+                    if (e >= 0)
+                        keep(end - 3, end);
+                    i = end;
+                    prevSig = c;
+                    continue;
+                }
+                let j = i + 1;
+                while (j < n && text[j] !== c && text[j] !== '\n') {
+                    if (text[j] === '\\')
+                        j++;
+                    j++;
+                }
+                const close = j < n && text[j] === c ? j : -1;
+                keep(i, i + 1);
+                put(i + 1, close < 0 ? Math.min(j, n) : close);
+                if (close >= 0)
+                    keep(close, close + 1);
+                i = close < 0 ? Math.min(j, n) : close + 1;
+                prevSig = c;
+                continue;
+            }
+        }
+        keep(i, i + 1);
+        if (!/\s/.test(c))
+            prevSig = c;
+        i++;
+    }
+    return out.join('');
+}
+// Line numbers from character positions, by binary search over the line starts. Built once per file.
+export class Lines {
+    starts = [0];
+    constructor(text) { for (let i = 0; i < text.length; i++)
+        if (text.charCodeAt(i) === 10)
+            this.starts.push(i + 1); }
+    at(index) {
+        let lo = 0;
+        let hi = this.starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (this.starts[mid] <= index)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    }
+    start(line) { return this.starts[Math.max(0, Math.min(this.starts.length - 1, line - 1))]; }
+    get count() { return this.starts.length; }
+}
+const PAIR = { '(': ')', '{': '}', '[': ']' };
+// The index just past the bracket that closes the one at `open`, in masked text, or -1.
+export function closeOf(masked, open) {
+    const stack = [];
+    for (let i = open; i < masked.length; i++) {
+        const c = masked[i];
+        if (PAIR[c])
+            stack.push(PAIR[c]);
+        else if (c === ')' || c === '}' || c === ']') {
+            if (c !== stack[stack.length - 1])
+                return -1;
+            stack.pop();
+            if (stack.length === 0)
+                return i + 1;
+        }
+    }
+    return -1;
+}
+// Top level argument ranges of the call whose "(" is at `open`: [{start, end}] with end exclusive, trimmed.
+export function splitArgs(masked, open) {
+    const close = closeOf(masked, open);
+    if (close < 0)
+        return [];
+    const args = [];
+    let depth = 0;
+    let from = open + 1;
+    const push = (end) => {
+        let s = from;
+        let e = end;
+        while (s < e && /\s/.test(masked[s]))
+            s++;
+        while (e > s && /\s/.test(masked[e - 1]))
+            e--;
+        if (e > s)
+            args.push({ start: s, end: e });
+    };
+    for (let i = open + 1; i < close - 1; i++) {
+        const c = masked[i];
+        if (c === '(' || c === '[' || c === '{')
+            depth++;
+        else if (c === ')' || c === ']' || c === '}')
+            depth--;
+        else if (c === ',' && depth === 0) {
+            push(i);
+            from = i + 1;
+        }
+        else if (c === '=' && masked[i + 1] === '>') { /* arrow: the body follows; handled by depth of braces */ }
+    }
+    push(close - 1);
+    return args;
+}
+// The end (exclusive) of the statement that starts at `from`: the first ";" at depth 0, or a newline at depth 0 after which
+// the next code character does not continue the expression (a ".", "?", ":", operator or closing bracket).
+export function statementEnd(masked, from) {
+    let depth = 0;
+    for (let i = from; i < masked.length; i++) {
+        const c = masked[i];
+        if (c === '(' || c === '[' || c === '{')
+            depth++;
+        else if (c === ')' || c === ']' || c === '}') {
+            if (depth === 0)
+                return i;
+            depth--;
+        }
+        else if (c === ';' && depth === 0)
+            return i;
+        else if (c === '\n' && depth === 0) {
+            const rest = masked.slice(i + 1, i + 200);
+            const next = /\S/.exec(rest);
+            const prev = masked.slice(from, i).trimEnd().slice(-1);
+            if (!next)
+                return i;
+            const nc = rest[next.index];
+            if (nc === '.' || nc === '?' || nc === ':' || nc === '+' || nc === '|' || nc === '&' || nc === ',' || nc === ')' || nc === ']')
+                continue;
+            if (prev === ',' || prev === '+' || prev === '=' || prev === '?' || prev === ':' || prev === '|' || prev === '&' || prev === '(')
+                continue;
+            return i;
+        }
+    }
+    return masked.length;
+}
+// The extent of the JavaScript or TypeScript function that begins at `from` (the index of "async", "function", "(" or a
+// single parameter name before "=>"). bodyStart is the first index of the body text (the "{" or the first token of an
+// expression body). Returns null when the text there is not a function.
+// `method`: the text is a class method, so a "{" after the return type at bracket depth 0 is the body and never an object type.
+export function jsFunction(masked, from, method = false) {
+    let i = from;
+    const ws = () => { while (i < masked.length && /\s/.test(masked[i]))
+        i++; };
+    ws();
+    if (masked.startsWith('async', i) && /\W/.test(masked[i + 5] ?? ' ')) {
+        i += 5;
+        ws();
+    }
+    let isFunctionKeyword = false;
+    if (masked.startsWith('function', i) && /\W/.test(masked[i + 8] ?? ' ')) {
+        isFunctionKeyword = true;
+        i += 8;
+        ws();
+        if (masked[i] === '*') {
+            i++;
+            ws();
+        }
+        while (/[\w$]/.test(masked[i] ?? ''))
+            i++;
+        ws();
+        if (masked[i] === '<') {
+            let d = 0;
+            for (; i < masked.length; i++) {
+                if (masked[i] === '<')
+                    d++;
+                else if (masked[i] === '>') {
+                    d--;
+                    if (d === 0) {
+                        i++;
+                        break;
+                    }
+                }
+            }
+            ws();
+        }
+    }
+    if (masked[i] === '(') {
+        const pc = closeOf(masked, i);
+        if (pc < 0)
+            return null;
+        i = pc;
+    }
+    else if (!isFunctionKeyword && /[\w$]/.test(masked[i] ?? '')) {
+        while (/[\w$]/.test(masked[i] ?? ''))
+            i++;
+        ws();
+        if (!(masked[i] === '=' && masked[i + 1] === '>'))
+            return null;
+    }
+    else
+        return null;
+    ws();
+    // Optional return type annotation: scan to the "{" (function) or "=>" (arrow) at bracket depth 0.
+    if (masked[i] === ':') {
+        let depth = 0;
+        for (i = i + 1; i < masked.length; i++) {
+            const c = masked[i];
+            if (c === '(' || c === '[')
+                depth++;
+            else if (c === ')' || c === ']')
+                depth--;
+            else if (c === '<')
+                depth++;
+            else if (c === '>' && masked[i - 1] !== '=')
+                depth--;
+            else if (c === '{' && depth <= 0 && !isFunctionKeyword && !method) {
+                depth++;
+            }
+            else if (c === '}' && depth > 0 && !isFunctionKeyword && !method) {
+                depth--;
+            }
+            else if (c === '=' && masked[i + 1] === '>' && depth <= 0)
+                break;
+            else if (c === '{' && depth <= 0 && (isFunctionKeyword || method))
+                break;
+        }
+    }
+    ws();
+    if (masked[i] === '=' && masked[i + 1] === '>') {
+        i += 2;
+        ws();
+        if (masked[i] === '{') {
+            const e = closeOf(masked, i);
+            return e < 0 ? null : { start: from, end: e, bodyStart: i };
+        }
+        const e = statementEnd(masked, i);
+        return { start: from, end: e, bodyStart: i };
+    }
+    if (masked[i] === '{') {
+        const e = closeOf(masked, i);
+        return e < 0 ? null : { start: from, end: e, bodyStart: i };
+    }
+    return null;
+}
+// The Python block that belongs to the "def" or "class" line starting at `lineStart` (an index at the start of the line):
+// the header (which may span several lines until the colon that ends it) and every following line indented deeper.
+export function pyBlock(masked, lines, lineStart) {
+    const indentOf = (ls) => { let k = ls; let w = 0; while (masked[k] === ' ' || masked[k] === '\t') {
+        w += masked[k] === '\t' ? 8 : 1;
+        k++;
+    } return w; };
+    const base = indentOf(lineStart);
+    // header ends at the first ":" at bracket depth 0 followed by end of line
+    let depth = 0;
+    let i = lineStart;
+    for (; i < masked.length; i++) {
+        const c = masked[i];
+        if (c === '(' || c === '[' || c === '{')
+            depth++;
+        else if (c === ')' || c === ']' || c === '}')
+            depth--;
+        else if (c === ':' && depth === 0 && /^[ \t]*(\n|$)/.test(masked.slice(i + 1, i + 40)))
+            break;
+        else if (c === ':' && depth === 0 && /^[ \t]*\S/.test(masked.slice(i + 1, i + 40)) && /^\s*(def|class|async\s+def)\b/.test(masked.slice(lineStart, lineStart + 12))) { /* annotation colon, keep scanning */ }
+    }
+    const bodyStart = Math.min(masked.length, i + 1);
+    let end = bodyStart;
+    const total = lines.count;
+    let ln = lines.at(bodyStart) + 1;
+    for (; ln <= total; ln++) {
+        const ls = lines.start(ln);
+        const le = masked.indexOf('\n', ls);
+        const row = masked.slice(ls, le < 0 ? masked.length : le);
+        if (row.trim() === '') {
+            continue;
+        }
+        if (indentOf(ls) <= base)
+            break;
+        end = le < 0 ? masked.length : le;
+    }
+    return { start: lineStart, end, bodyStart };
+}

package/dist/map/light-index.js

@@ -0,0 +1,191 @@
+// An index of the repository's own functions by name for Go, Ruby and PHP: where a function starts and ends, so a handler
+// can be followed to its definition and one hop into the helpers it calls. Built once per language and repository.
+import { cmp } from '../util.js';
+import { closeOf, statementEnd } from './lex.js';
+// The extent of a Go function whose "func" keyword is at `at`: [start, end) with the body inside braces.
+export function goFunc(masked, at) {
+    let i = at + 4;
+    while (/\s/.test(masked[i] ?? ''))
+        i++;
+    if (masked[i] === '(' && /^\(\s*\w*\s*\*?\s*[\w.[\]]+\s*\)\s*\w/.test(masked.slice(i, i + 120))) {
+        const c = closeOf(masked, i);
+        if (c < 0)
+            return null;
+        i = c;
+        while (/\s/.test(masked[i] ?? ''))
+            i++;
+    }
+    while (/[\w]/.test(masked[i] ?? ''))
+        i++;
+    while (/\s/.test(masked[i] ?? ''))
+        i++;
+    if (masked[i] === '[') {
+        const c = closeOf(masked, i);
+        if (c < 0)
+            return null;
+        i = c;
+    }
+    if (masked[i] !== '(')
+        return null;
+    const pc = closeOf(masked, i);
+    if (pc < 0)
+        return null;
+    const params = masked.slice(i + 1, pc - 1);
+    for (i = pc; i < masked.length; i++) {
+        const c = masked[i];
+        if (c === '{') {
+            const before = masked.slice(Math.max(0, i - 12), i).trimEnd();
+            if (/(?:interface|struct)$/.test(before)) {
+                const e = closeOf(masked, i);
+                if (e < 0)
+                    return null;
+                i = e - 1;
+                continue;
+            }
+            const e = closeOf(masked, i);
+            return e < 0 ? null : { start: at, end: e, bodyStart: i, params };
+        }
+        if (c === ';')
+            return null;
+    }
+    return null;
+}
+// A Ruby method: from "def" to the "end" at the same indentation.
+export function rubyDef(masked, defAt) {
+    const ls = masked.lastIndexOf('\n', defAt) + 1;
+    const indent = /^[ \t]*/.exec(masked.slice(ls))[0].length;
+    const oneLine = /^[^\n]*\bdef\b[^\n]*=\s*\S/.exec(masked.slice(defAt, defAt + 200));
+    const firstEnd = masked.indexOf('\n', defAt);
+    if (oneLine && !/\bend\b/.test(masked.slice(defAt, firstEnd < 0 ? masked.length : firstEnd)))
+        return { start: defAt, end: firstEnd < 0 ? masked.length : firstEnd };
+    let pos = firstEnd < 0 ? masked.length : firstEnd + 1;
+    while (pos < masked.length) {
+        const e = masked.indexOf('\n', pos);
+        const row = masked.slice(pos, e < 0 ? masked.length : e);
+        const ind = /^[ \t]*/.exec(row)[0].length;
+        if (row.trim() !== '' && ind <= indent && /^\s*end\b/.test(row))
+            return { start: defAt, end: pos + row.length };
+        if (row.trim() !== '' && ind < indent)
+            return { start: defAt, end: pos };
+        if (e < 0)
+            break;
+        pos = e + 1;
+    }
+    return { start: defAt, end: masked.length };
+}
+// A PHP function or method: from "function" to the closing brace of its body.
+export function phpFunc(masked, at) {
+    const open = masked.indexOf('(', at);
+    if (open < 0)
+        return null;
+    const pc = closeOf(masked, open);
+    if (pc < 0)
+        return null;
+    const params = masked.slice(open + 1, pc - 1);
+    const m = /^[^{;]*\{/.exec(masked.slice(pc, pc + 300));
+    if (!m)
+        return null;
+    const bodyStart = pc + m[0].length - 1;
+    const e = closeOf(masked, bodyStart);
+    return e < 0 ? null : { start: at, end: e, bodyStart, params };
+}
+// A Java or C# method whose name starts at `at`: the parameters, then a block body, or in C# an expression body after "=>". An abstract or
+// interface method (ending in ";") has no body and gives null.
+export function cMethod(masked, at) {
+    let i = at;
+    while (/[\w$]/.test(masked[i] ?? ''))
+        i++;
+    while (/\s/.test(masked[i] ?? ''))
+        i++;
+    if (masked[i] === '<') {
+        let d = 0;
+        for (; i < masked.length; i++) {
+            if (masked[i] === '<')
+                d++;
+            else if (masked[i] === '>' && --d === 0) {
+                i++;
+                break;
+            }
+            else if (masked[i] === '\n' && d > 4)
+                return null;
+        }
+        while (/\s/.test(masked[i] ?? ''))
+            i++;
+    }
+    if (masked[i] !== '(')
+        return null;
+    const pc = closeOf(masked, i);
+    if (pc < 0)
+        return null;
+    const params = masked.slice(i + 1, pc - 1);
+    for (let j = pc; j < masked.length; j++) {
+        const c = masked[j];
+        if (c === '{') {
+            const e = closeOf(masked, j);
+            return e < 0 ? null : { start: at, end: e, bodyStart: j, params };
+        }
+        if (c === ';')
+            return null;
+        if (c === '=' && masked[j + 1] === '>')
+            return { start: at, end: statementEnd(masked, j + 2), bodyStart: j + 2, params };
+    }
+    return null;
+}
+// Method declarations: at least one modifier, a type, a name and "(".
+export const C_METHOD = /^[ \t]*(?:@\w+(?:\([^)\n]*\))?[ \t]*)*(?:(?:public|protected|private|internal|static|final|abstract|synchronized|async|override|virtual|sealed|partial|new|extern|unsafe|default)\s+)+[^;{}()=\n]*?\s(\w+)\s*(?:<[^>\n]*>)?\s*\(/gm;
+export class FnIndex {
+    idx = new Map();
+    repo;
+    lang;
+    constructor(repo, lang) {
+        this.repo = repo;
+        this.lang = lang;
+        const put = (name, ref) => { const l = this.idx.get(name); if (l)
+            l.push(ref);
+        else
+            this.idx.set(name, [ref]); };
+        for (const file of repo.filesOf(lang)) {
+            const v = repo.view(file);
+            if (!v)
+                continue;
+            const m = v.masked;
+            if (lang === 'go') {
+                for (const x of m.matchAll(/^func\s+(?:\(\s*\w*\s*\*?\s*[\w.[\]]+\s*\)\s*)?(\w+)\s*[([]/gm)) {
+                    const f = goFunc(m, x.index);
+                    if (f)
+                        put(x[1], { view: v, start: f.start, end: f.end });
+                }
+            }
+            else if (lang === 'rb') {
+                for (const x of m.matchAll(/^[ \t]*def\s+(?:self\.)?(\w+[?!=]?)/gm)) {
+                    const d = rubyDef(m, x.index + x[0].indexOf('def'));
+                    put(x[1], { view: v, start: d.start, end: d.end });
+                }
+            }
+            else if (lang === 'java' || lang === 'cs') {
+                for (const x of m.matchAll(C_METHOD)) {
+                    const f = cMethod(m, x.index + x[0].lastIndexOf(x[1]));
+                    if (f)
+                        put(x[1], { view: v, start: f.start, end: f.end });
+                }
+            }
+            else {
+                for (const x of m.matchAll(/\bfunction\s+&?\s*(\w+)\s*\(/g)) {
+                    const f = phpFunc(m, x.index);
+                    if (f)
+                        put(x[1], { view: v, start: f.start, end: f.end });
+                }
+            }
+        }
+    }
+    defs(name) { return (this.idx.get(name) ?? []).slice().sort((a, b) => cmp(a.view.file, b.view.file) || a.start - b.start); }
+    find = (name, fromFile) => {
+        const refs = this.idx.get(name);
+        if (!refs)
+            return null;
+        if (refs.length === 1)
+            return refs[0];
+        const same = refs.filter((r) => r.view.file === fromFile);
+        return same.length === 1 ? same[0] : null;
+    };
+}