ucn 5.4.2 → 5.5.1

package/languages/c-macro-invocations.js

@@ -0,0 +1,380 @@
+'use strict';
+
+/**
+ * Function-like macro invocations the C/C++ grammar misreads as declarations
+ * (fix #385).
+ *
+ * A function-like macro name followed by `(` is an invocation wherever the
+ * definition is in effect (C11 6.10.3p10). tree-sitter knows no macros, so an
+ * invocation in declaration or statement position is parsed as a
+ * declaration: `ERROR_DEF(Base, Name)` in a class body became a method named
+ * ERROR_DEF (and, without a trailing `;`, swallowed the class head),
+ * `LOG_ONCE(init());` in a function body declared a function `init`
+ * returning LOG_ONCE, `CATCH_ALL(...) { }` a nested function definition.
+ *
+ * This module reads the file's own `#define NAME(...)` / `#undef NAME`
+ * directives (the preprocessor's line grammar), finds the invocations of
+ * macros in effect that the tree holds in those declaration shapes, and
+ * gives recovery the byte ranges to blank:
+ *
+ *   statement position   the macro name only when a `;` follows, so its
+ *                        arguments stay expressions (their calls stay
+ *                        calls); the whole invocation otherwise
+ *   declaration/member   the whole invocation; its declarations are derived
+ *                        from the expansion (the replacement list is known)
+ *   file-scope with body `NAME(args) { ... }` is left as parsed (the body
+ *                        belongs to whatever the expansion declares); the
+ *                        definition is marked as a macro invocation
+ *
+ * Invocations of macros defined in other files are recognized at index time
+ * from the same shapes (see the `macroInvocation` fact).
+ */
+
+const { lexPP, splitArguments, functionMacroTemplate } = require('./c-preprocessor');
+
+const DECLARATION_CONTAINERS = new Set(['declaration', 'field_declaration', 'function_definition']);
+const SCOPE_BOUNDARIES = new Set([
+    'translation_unit', 'field_declaration_list', 'declaration_list', 'compound_statement',
+]);
+const MAX_EXPANSION_CHARS = 64 * 1024;
+const EXPRESSION_CONTINUATION = new Set(['=', '(', ',', '?', '!', '&', '|', '+', '-', '*', '/', '%',
+    '<', '>', '[', '^', '~', '.']);
+
+/**
+ * Function-like macro definitions and #undef lines of a file, read from its
+ * directive lines. Returns null when the file defines no function-like macro.
+ */
+function directiveFunctionMacros(code) {
+    if (!code.includes('define')) return null;
+    const defs = new Map();
+    const undefs = new Map();
+    const directive = /^[ \t]*#[ \t]*(define|undef)[ \t]+([A-Za-z_][A-Za-z0-9_]*)/gm;
+    let row = 1;
+    let counted = 0;
+    const rowAt = offset => {
+        for (let i = code.indexOf('\n', counted); i !== -1 && i < offset; i = code.indexOf('\n', i + 1)) row++;
+        counted = offset;
+        return row;
+    };
+    for (let match = directive.exec(code); match; match = directive.exec(code)) {
+        const line = rowAt(match.index);
+        const name = match[2];
+        if (match[1] === 'undef') {
+            if (!undefs.has(name)) undefs.set(name, []);
+            undefs.get(name).push(line);
+            continue;
+        }
+        const afterName = match.index + match[0].length;
+        if (code[afterName] !== '(') continue;
+        // The directive with its continuation lines.
+        let end = code.indexOf('\n', afterName);
+        let endLine = line;
+        while (end !== -1 && /\\[ \t\r]*$/.test(code.slice(Math.max(afterName, end - 64), end))) {
+            const next = code.indexOf('\n', end + 1);
+            endLine++;
+            end = next;
+        }
+        const text = code.slice(afterName, end === -1 ? code.length : end)
+            .replace(/\\[ \t\r]*\n/g, ' \n');
+        const template = functionMacroTemplate(text);
+        if (!template) continue;
+        if (!defs.has(name)) defs.set(name, []);
+        defs.get(name).push({ name, line, endLine, ...template });
+    }
+    return defs.size > 0 ? { defs, undefs } : null;
+}
+
+/** The definition of `name` in effect at `line` (nearest above, no #undef between). */
+function definitionInEffect(macros, name, line) {
+    const defs = macros.defs.get(name);
+    if (!defs) return null;
+    let best = null;
+    for (const def of defs) {
+        if (def.endLine < line && (!best || def.line > best.line)) best = def;
+    }
+    if (!best) return null;
+    const undone = (macros.undefs.get(name) || []).some(undef => undef > best.endLine && undef < line);
+    return undone ? null : best;
+}
+
+function isWordChar(code) {
+    return (code >= 48 && code <= 57) || (code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122) || code === 95;
+}
+
+function lineOfOffset(lineStarts, offset) {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineStarts[mid] <= offset) lo = mid;
+        else hi = mid - 1;
+    }
+    return lo + 1;
+}
+
+/**
+ * Offset after the parenthesis closing the one at `open` (string and
+ * character literals and comments skipped), or -1.
+ */
+function closingParenthesis(code, open) {
+    const limit = Math.min(code.length, open + MAX_EXPANSION_CHARS);
+    let depth = 0;
+    for (let i = open; i < limit; i++) {
+        const ch = code[i];
+        if (ch === '"' || ch === '\'') {
+            for (i++; i < limit && code[i] !== ch; i++) if (code[i] === '\\') i++;
+            continue;
+        }
+        if (ch === '/' && code[i + 1] === '/') {
+            while (i < limit && code[i] !== '\n') i++;
+            continue;
+        }
+        if (ch === '/' && code[i + 1] === '*') {
+            const close = code.indexOf('*/', i + 2);
+            if (close < 0) return -1;
+            i = close + 1;
+            continue;
+        }
+        if (ch === '(') depth++;
+        else if (ch === ')' && --depth === 0) return i + 1;
+    }
+    return -1;
+}
+
+/** End offset (after the closing parenthesis) and arguments of the list at `open`. */
+function argumentListEnd(code, open) {
+    const end = closingParenthesis(code, open);
+    if (end < 0) return null;
+    const tokens = lexPP(code.slice(open, end));
+    const split = splitArguments(tokens, 0);
+    if (!split) return null;
+    return { end: open + tokens[split.close].start + 1, args: split.args };
+}
+
+function sameNode(a, b) {
+    return !!a && !!b && (a === b || a.id === b.id);
+}
+
+/** Scope of a declaration container: 'statement', 'member' or 'declaration'. */
+function scopeOf(container) {
+    for (let up = container.parent; up; up = up.parent) {
+        if (!SCOPE_BOUNDARIES.has(up.type)) continue;
+        if (up.type === 'compound_statement') return 'statement';
+        if (up.type === 'field_declaration_list') return 'member';
+        return 'declaration';
+    }
+    return 'declaration';
+}
+
+/**
+ * The declaration a macro-name node was read into, and how: 'typeless' when
+ * it is the name of a function declarator in a declaration with no type
+ * (`NAME(args);`, `NAME(args) { }`), 'typed' when it is the type of a
+ * declaration (`NAME(x());` read as a function x returning NAME),
+ * 'type-specifier' for `NAME(args) value;` read as a macro type specifier,
+ * 'error' for any other non-call reading inside a syntax error.
+ */
+function misreadShape(node) {
+    const parent = node.parent;
+    if (!parent) return null;
+    if ((node.type === 'identifier' || node.type === 'field_identifier') &&
+        parent.type === 'function_declarator' &&
+        sameNode(parent.childForFieldName('declarator'), node)) {
+        const container = parent.parent;
+        if (container && DECLARATION_CONTAINERS.has(container.type) &&
+            sameNode(container.childForFieldName('declarator'), parent) &&
+            !container.childForFieldName('type')) {
+            return { shape: 'typeless', container };
+        }
+    }
+    if (node.type === 'type_identifier' && DECLARATION_CONTAINERS.has(parent.type) &&
+        sameNode(parent.childForFieldName('type'), node)) {
+        return { shape: 'typed', container: parent };
+    }
+    // `NAME(args)` read as a macro type specifier in a declaration's type:
+    // right only when the expansion is a type (checked by the caller).
+    if (parent.type === 'macro_type_specifier' && sameNode(parent.childForFieldName('name'), node) &&
+        parent.parent && DECLARATION_CONTAINERS.has(parent.parent.type) &&
+        sameNode(parent.parent.childForFieldName('type'), parent)) {
+        return { shape: 'type-specifier', container: parent.parent };
+    }
+    // Inside a syntax error the grammar already failed around the
+    // invocation: any reading of the name other than a call's function
+    // (`LIST(X)` statements with no `;`, read as a macro type specifier or
+    // a stray declarator) is the misread invocation.
+    if (parent.type === 'call_expression' && sameNode(parent.childForFieldName('function'), node)) {
+        return null;
+    }
+    for (let up = parent; up; up = up.parent) {
+        if (up.type === 'ERROR') return { shape: 'error', container: up };
+        if (SCOPE_BOUNDARIES.has(up.type)) break;
+    }
+    return null;
+}
+
+/** Does this invocation's expansion read as a type (`TYPE(x) value;`)? */
+function expandsToType(parser, definition, args) {
+    const text = substituteInvocation(definition, args);
+    if (text == null || !parser) return true;
+    const probe = parser.parse(`typedef ${text} __ucn_type_probe__;\n`);
+    return !probe.rootNode.hasError;
+}
+
+/**
+ * Invocations of the file's own function-like macros that the tree holds in
+ * a declaration shape. Each: { name, definition, line, start, nameEnd, end,
+ * args, scope, hasBody, blank: [start, end] | null }.
+ */
+function misreadMacroInvocations(tree, code, macros, parser = null) {
+    const invocations = [];
+    if (!macros) return invocations;
+    const lineStarts = [0];
+    for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) lineStarts.push(i + 1);
+    // Directive lines with their continuations: a macro body is never
+    // blanked, even where the grammar read it as code.
+    const directive = new Uint8Array(lineStarts.length + 1);
+    for (let row = 0; row < lineStarts.length; row++) {
+        let k = lineStarts[row];
+        while (k < code.length && (code[k] === ' ' || code[k] === '\t')) k++;
+        if (code[k] !== '#') continue;
+        for (;;) {
+            directive[row + 1] = 1;
+            const end = row + 1 < lineStarts.length ? lineStarts[row + 1] - 1 : code.length;
+            if (!/\\\s*$/.test(code.slice(lineStarts[row], end)) || row + 1 >= lineStarts.length) break;
+            row++;
+        }
+    }
+    const directiveRow = row => directive[row] === 1;
+    const root = tree.rootNode;
+    // One scan for identifiers followed by `(` (a prefilter: every hit is
+    // checked against the tree), instead of one text search per macro.
+    const candidate = /[A-Za-z_][A-Za-z0-9_]*[ \t]*\(/g;
+    for (let match = candidate.exec(code); match; match = candidate.exec(code)) {
+        const at = match.index;
+        if (at > 0 && isWordChar(code.charCodeAt(at - 1))) continue;
+        let nameEnd = at;
+        while (nameEnd < code.length && isWordChar(code.charCodeAt(nameEnd))) nameEnd++;
+        const name = code.slice(at, nameEnd);
+        if (!macros.defs.has(name)) continue;
+        // An invocation continuing an expression or a parameter list
+        // (`= M(x)`, `(M(x)`, `, M(x)`, `->M(x)`) is never read as a
+        // declaration of its own; skip the tree lookup.
+        let before = at - 1;
+        while (before >= 0 && (code[before] === ' ' || code[before] === '\t')) before--;
+        if (before >= 0 && EXPRESSION_CONTINUATION.has(code[before])) continue;
+        const open = match.index + match[0].length - 1;
+        {
+            const line = lineOfOffset(lineStarts, at);
+            if (directiveRow(line)) continue;
+            const definition = definitionInEffect(macros, name, line);
+            if (!definition) continue;
+            const node = root.descendantForIndex(at, nameEnd);
+            if (!node || node.startIndex !== at || node.endIndex !== nameEnd) continue;
+            const misread = misreadShape(node);
+            if (!misread) continue;
+            // Inside a syntax error only an invocation that begins its line
+            // stands in statement or declaration position (`LIST(X)` lines);
+            // one inside an expression (`if (LIKELY(x))`) is not misread.
+            if (misread.shape === 'error' &&
+                code.slice(lineStarts[line - 1], at).trim() !== '') continue;
+            const extent = argumentListEnd(code, open);
+            if (!extent) continue;
+            if (misread.shape === 'type-specifier' && expandsToType(parser, definition, extent.args)) continue;
+            const scope = scopeOf(misread.container);
+            const hasBody = misread.container.type === 'function_definition';
+            let after = extent.end;
+            while (after < code.length && (code[after] === ' ' || code[after] === '\t')) after++;
+            // A `typed` reading makes the invocation a prefix of the real
+            // declaration that follows (an attribute macro before a member,
+            // `M(x());` in a body); a `typeless` one with a body is a
+            // definition the expansion declares (`TEST(a, b) { }`), left as
+            // parsed and marked.
+            // Blanking never removes call syntax the source spells: an
+            // invocation whose arguments hold a parenthesis (a call,
+            // `f<T>(x)`, a cast) keeps them (only its name is blanked where
+            // a `;` makes the rest an expression statement, otherwise it is
+            // left as parsed).
+            const argumentsCall = extent.args.some(arg => arg.some(token => token.v === '('));
+            let blank = null;
+            if (scope === 'statement' && code[after] === ';' &&
+                !(hasBody && misread.shape === 'typeless')) {
+                blank = [at, nameEnd];
+            } else if (!argumentsCall && (scope === 'statement' || !hasBody || misread.shape !== 'typeless')) {
+                blank = [at, extent.end];
+            }
+            invocations.push({
+                name, definition, line, start: at, nameEnd, end: extent.end,
+                args: extent.args, scope, hasBody, blank,
+            });
+        }
+    }
+    return invocations.sort((a, b) => a.start - b.start);
+}
+
+/**
+ * The replacement of one invocation of a same-file macro: parameters
+ * substituted (arguments as written), `#param` stringized, `##` pasted.
+ * Macros the replacement invokes are not expanded again here; a nested
+ * invocation stays as written. Returns null when the arguments do not fit.
+ */
+function substituteInvocation(definition, args) {
+    const params = definition.params || [];
+    let actual = args;
+    if (params.length === 0 && actual.length === 1 && actual[0].length === 0) actual = [];
+    if (definition.variadic) {
+        const named = params.length - 1;
+        if (actual.length < named) return null;
+        const rest = [];
+        actual.slice(named).forEach((arg, i) => {
+            if (i > 0) rest.push({ v: ',', k: 'punct' });
+            rest.push(...arg);
+        });
+        actual = [...actual.slice(0, named), rest];
+    } else if (actual.length !== params.length) {
+        return null;
+    }
+    const index = new Map(params.map((param, i) => [param, i]));
+    const body = lexPP(definition.body || '');
+    const out = [];
+    for (let i = 0; i < body.length; i++) {
+        const token = body[i];
+        if (token.v === '#' && body[i + 1]?.k === 'id' && index.has(body[i + 1].v)) {
+            out.push({ v: JSON.stringify(actual[index.get(body[i + 1].v)].map(t => t.v).join(' ')), k: 'str' });
+            i++;
+            continue;
+        }
+        if (token.k === 'id' && index.has(token.v)) {
+            out.push(...actual[index.get(token.v)]);
+            continue;
+        }
+        out.push(token);
+    }
+    const pasted = [];
+    for (let i = 0; i < out.length; i++) {
+        if (out[i].v === '##' && pasted.length > 0 && out[i + 1]) {
+            const left = pasted.pop();
+            pasted.push({ v: left.v + out[i + 1].v, k: 'id' });
+            i++;
+            continue;
+        }
+        pasted.push(out[i]);
+    }
+    // Spaces only where two tokens would otherwise merge (two words, two
+    // punctuators), so types read as written (`std::string`, `T*`).
+    let text = '';
+    for (let i = 0; i < pasted.length; i++) {
+        const word = pasted[i].k !== 'punct';
+        if (i > 0 && word === (pasted[i - 1].k !== 'punct')) text += ' ';
+        else if (i > 0 && pasted[i - 1].v === ',') text += ' ';
+        text += pasted[i].v;
+    }
+    return text.length > MAX_EXPANSION_CHARS ? null : text;
+}
+
+module.exports = {
+    directiveFunctionMacros,
+    definitionInEffect,
+    misreadMacroInvocations,
+    substituteInvocation,
+};

package/languages/c-preprocessor.js

@@ -0,0 +1,254 @@
+'use strict';
+
+/**
+ * C/C++ preprocessing tokens (C11 6.4 / C++ [lex.pptoken]).
+ *
+ * Tree-sitter keeps a macro replacement list as one opaque `preproc_arg`, and
+ * `##` / `#` are not expression syntax, so a function-like macro that builds a
+ * call target by token pasting (`fs__##lc(req)`) is invisible to the AST. The
+ * preprocessor itself is defined over this token grammar, not over the AST:
+ * substituting arguments and pasting operands is a token-sequence operation.
+ * This module is that token layer. It never classifies code; callers parse
+ * the substituted token stream with tree-sitter to decide what is a call,
+ * a declaration, or a value reference.
+ */
+
+const PUNCTUATORS = [
+    '%:%:', '...', '<<=', '>>=', '->*', '<=>',
+    '##', '->', '++', '--', '<<', '>>', '<=', '>=', '==', '!=', '&&', '||',
+    '*=', '/=', '%=', '+=', '-=', '&=', '^=', '|=', '::', '.*', '<:', ':>',
+    '<%', '%>', '%:',
+];
+
+// Characters that never begin a multi-character punctuator.
+const SINGLE_PUNCTUATORS = new Set(['(', ')', '{', '}', '[', ']', ';', ',', '?', '~']);
+
+function isIdentStart(ch) {
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_' ||
+        ch === '$' || ch > '\x7f';
+}
+
+function isIdentPart(ch) {
+    return isIdentStart(ch) || (ch >= '0' && ch <= '9');
+}
+
+/**
+ * Tokenize `text` into preprocessing tokens. Comments and whitespace are
+ * dropped; a line splice (`\` + newline) joins lines. Each token records its
+ * offset in `text` (`start`) and its kind: 'id', 'num', 'str', 'chr', 'punct'.
+ *
+ * One sticky scanner handles the common token classes (identifiers,
+ * whitespace, comments, numbers); literals and punctuators fall through to
+ * the exact per-character rules below.
+ */
+const FAST_TOKEN = /([ \t\r\n\f\v]+|\\\r?\n)|(\/\/[^\n]*)|(\/\*[\s\S]*?(?:\*\/|$))|([A-Za-z_$\u0080-\uffff][A-Za-z0-9_$\u0080-\uffff]*)(?![A-Za-z0-9_$\u0080-\uffff"'])|((?:\.?[0-9])(?:[eEpP][+-]|[A-Za-z0-9_.]|'(?=[A-Za-z0-9_]))*)/y;
+
+function lexPP(text) {
+    const tokens = [];
+    const n = text.length;
+    let i = 0;
+    while (i < n) {
+        FAST_TOKEN.lastIndex = i;
+        const match = FAST_TOKEN.exec(text);
+        if (match) {
+            if (match[4] !== undefined) {
+                tokens.push({ v: match[4], k: 'id', start: i });
+            } else if (match[5] !== undefined) {
+                tokens.push({ v: match[5], k: 'num', start: i });
+            }
+            i = FAST_TOKEN.lastIndex;
+            continue;
+        }
+        const ch = text[i];
+        const start = i;
+        if (isIdentStart(ch)) {
+            // Identifier directly followed by a quote: an encoding prefix
+            // (L"", u8"", R"(...)") belongs to the literal.
+            while (i < n && isIdentPart(text[i])) i++;
+            const prefix = text.slice(start, i);
+            if (/^(?:L|u8|u|U|R|LR|u8R|uR|UR)$/.test(prefix)) {
+                i = scanQuoted(text, i, prefix.endsWith('R'));
+                tokens.push({ v: text.slice(start, i), k: text[start + prefix.length] === '\'' ? 'chr' : 'str', start });
+            } else {
+                tokens.push({ v: prefix, k: 'id', start });
+            }
+            continue;
+        }
+        if (ch === '"' || ch === '\'') {
+            i = scanQuoted(text, i, false);
+            tokens.push({ v: text.slice(start, i), k: ch === '"' ? 'str' : 'chr', start });
+            continue;
+        }
+        if (SINGLE_PUNCTUATORS.has(ch)) {
+            tokens.push({ v: ch, k: 'punct', start });
+            i++;
+            continue;
+        }
+        let punct = null;
+        for (const p of PUNCTUATORS) {
+            if (text.startsWith(p, i)) {
+                punct = p;
+                break;
+            }
+        }
+        if (!punct) punct = ch;
+        i += punct.length;
+        tokens.push({ v: punct === '%:%:' ? '##' : punct === '%:' ? '#' : punct, k: 'punct', start });
+    }
+    return tokens;
+}
+
+function scanQuoted(text, i, raw) {
+    const quote = text[i];
+    if (raw && quote === '"') {
+        const open = text.indexOf('(', i);
+        if (open > 0) {
+            const delimiter = text.slice(i + 1, open);
+            const close = text.indexOf(`)${delimiter}"`, open);
+            if (close >= 0) return close + delimiter.length + 2;
+        }
+    }
+    i++;
+    while (i < text.length) {
+        const c = text[i];
+        if (c === '\\') { i += 2; continue; }
+        if (c === quote) return i + 1;
+        if (c === '\n') return i;
+        i++;
+    }
+    return i;
+}
+
+/**
+ * Split the tokens of a macro invocation `NAME ( a , b )` (starting at
+ * `openIndex`, the `(` token) into argument token lists. Returns
+ * { args, close } or null when the parentheses do not balance.
+ */
+function splitArguments(tokens, openIndex) {
+    if (tokens[openIndex]?.v !== '(') return null;
+    const args = [[]];
+    let depth = 0;
+    for (let i = openIndex; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.k === 'punct' && t.v === '(') {
+            depth++;
+            if (depth === 1) continue;
+        } else if (t.k === 'punct' && t.v === ')') {
+            depth--;
+            if (depth === 0) {
+                // `F()` has one empty argument; the caller reconciles that
+                // with a zero-parameter macro.
+                return { args, close: i };
+            }
+        } else if (depth === 1 && t.k === 'punct' && t.v === ',') {
+            args.push([]);
+            continue;
+        }
+        args[args.length - 1].push(t);
+    }
+    return null;
+}
+
+/**
+ * Replacement-list template of a function-like macro, read from its
+ * logical `#define` line (text after the macro name). Returns
+ * { params, variadic, body } or null. `params` lists parameter names;
+ * a trailing `...` is exposed as `__VA_ARGS__`, GNU `name...` as `name`.
+ * `body` is the replacement list as space-joined preprocessing tokens.
+ */
+function functionMacroTemplate(afterName) {
+    const tokens = lexPP(afterName);
+    if (tokens[0]?.v !== '(') return null;
+    const params = [];
+    let variadic = false;
+    let i = 1;
+    let expectName = true;
+    for (; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.v === ')') break;
+        if (t.v === ',') {
+            expectName = true;
+            continue;
+        }
+        if (t.v === '...') {
+            variadic = true;
+            if (expectName) params.push('__VA_ARGS__');
+            continue;
+        }
+        if (t.k === 'id' && expectName) {
+            params.push(t.v);
+            expectName = false;
+            continue;
+        }
+        return null;
+    }
+    if (tokens[i]?.v !== ')') return null;
+    const body = tokens.slice(i + 1).map(t => t.v).join(' ');
+    return { params, variadic, body };
+}
+
+// Object-like replacement lists longer than this are not kept (they are
+// declarations or statement blocks, never a name fragment for a paste).
+const MAX_OBJECT_MACRO_CHARS = 256;
+
+/** Replacement list of an object-like macro (text after its name), or null. */
+function objectMacroBody(afterName) {
+    const tokens = lexPP(afterName);
+    const body = tokens.map(t => t.v).join(' ');
+    return body.length <= MAX_OBJECT_MACRO_CHARS ? body : null;
+}
+
+/**
+ * Pasting patterns of a template: each `a ## b ## c` chain that involves a
+ * parameter, as a sequence of literal strings and parameter wildcards
+ * (null). A chain of only literals pastes a fixed token and is ignored.
+ */
+function pastePatterns(template) {
+    if (!template || !template.body.includes('##')) return [];
+    const tokens = lexPP(template.body);
+    const params = new Set(template.params);
+    const patterns = [];
+    for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i + 1]?.v !== '##') continue;
+        const operands = [tokens[i]];
+        let j = i + 1;
+        while (tokens[j]?.v === '##' && tokens[j + 1]) {
+            operands.push(tokens[j + 1]);
+            j += 2;
+        }
+        i = j - 1;
+        if (!operands.some(op => op.k === 'id' && params.has(op.v))) continue;
+        // A chain whose operands are not identifier-shaped (`, ## __VA_ARGS__`
+        // comma elision) never produces a name.
+        if (operands.some(op => op.k !== 'id' && op.k !== 'num')) continue;
+        patterns.push(operands.map(op => op.k === 'id' && params.has(op.v) ? null : op.v));
+    }
+    return patterns;
+}
+
+/** Does `name` fit a paste pattern (literal pieces in order, wildcards between)? */
+function matchesPastePattern(pattern, name) {
+    let position = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const piece = pattern[i];
+        if (piece === null) continue;
+        if (i === 0) {
+            if (!name.startsWith(piece)) return false;
+            position = piece.length;
+            continue;
+        }
+        if (i === pattern.length - 1) {
+            return name.length - piece.length >= position && name.endsWith(piece) &&
+                (pattern[i - 1] !== null || name.length - piece.length === position);
+        }
+        const found = name.indexOf(piece, position + (pattern[i - 1] === null ? 1 : 0));
+        if (found < 0 || (pattern[i - 1] !== null && found !== position)) return false;
+        position = found + piece.length;
+    }
+    // A trailing wildcard must produce at least one character.
+    return pattern[pattern.length - 1] !== null || name.length > position;
+}
+
+module.exports = {
+    lexPP, splitArguments, functionMacroTemplate, objectMacroBody, pastePatterns, matchesPastePattern,
+};