homegraph 1.6.1 → 1.6.2

package/dist/resolution/c-feature-variants.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCFeatureVariantMemos = clearCFeatureVariantMemos;
+exports.isCFeatureVariant = isCFeatureVariant;
+exports.isOffByDefault = isOffByDefault;
+const cpp_macro_visibility_1 = require("./cpp-macro-visibility");
+const MEMO = new WeakMap();
+function clearCFeatureVariantMemos(context) {
+    MEMO.delete(context);
+}
+function memoFor(context) {
+    let memo = MEMO.get(context);
+    if (!memo) {
+        memo = { files: new Map(), buildText: new Map(), components: new Map(), cFiles: null, defines: new Map(), named: new Map(), answers: new Map() };
+        MEMO.set(context, memo);
+    }
+    return memo;
+}
+const and = (a, b) => (a === false || b === false ? false : a === true && b === true ? true : undefined);
+const or = (a, b) => (a === true || b === true ? true : a === false && b === false ? false : undefined);
+const not = (a) => (a === undefined ? undefined : !a);
+const C_FAMILY_FILE = /\.(c|h|cc|cpp|cxx|c\+\+|hpp|hh|hxx|h\+\+|inl|ipp|tcc|inc|m|mm)$/i;
+const PLATFORM_FLAGS = new Set(['WIN32', 'WIN64', 'linux', 'unix']);
+const BUILD_FILES = [
+    'Makefile', 'makefile', 'GNUmakefile', 'Makefile.am', 'Makefile.in', 'CMakeLists.txt', 'meson.build',
+    'meson_options.txt', 'configure.ac', 'configure.in', 'config.h.in', 'BUILD', 'BUILD.bazel', 'SConstruct', 'SConscript',
+];
+const dirOf = (file) => file.slice(0, Math.max(0, file.lastIndexOf('/')));
+/** `a/b/c.h` → `a/b`, `a`, `` (the project root). */
+function ancestors(file) {
+    const dirs = [];
+    for (let dir = dirOf(file);; dir = dirOf(dir)) {
+        dirs.push(dir);
+        if (dir === '')
+            return dirs;
+    }
+}
+/**
+ * Is `fn`'s definition compiled only by a build that sets a flag nothing in
+ * the project sets, for the call at `ref`? A branch around both the
+ * definition and the call, in the call's own file, decides nothing.
+ */
+function isCFeatureVariant(fn, ref, context) {
+    const memo = memoFor(context);
+    const sameFile = fn.filePath === ref.filePath;
+    const key = `v\0${fn.id}\0${sameFile ? ref.line : dirOf(ref.filePath)}`;
+    const hit = memo.answers.get(key);
+    if (hit !== undefined)
+        return hit;
+    const file = directivesOf(fn.filePath, context, memo);
+    let groups = enclosingTests(file.conditionals, fn.startLine);
+    if (sameFile) {
+        const around = enclosingTests(file.conditionals, ref.line);
+        let shared = 0;
+        while (shared < groups.length && shared < around.length &&
+            groups[shared][0] === around[shared][0] && groups[shared].length === around[shared].length)
+            shared++;
+        groups = groups.slice(shared);
+    }
+    const off = groups.length > 0 && isOff(groups, file, [fn.filePath, ref.filePath], context, memo);
+    memo.answers.set(key, off);
+    return off;
+}
+/** Is line `line` of `path` compiled only by a build that sets a flag nothing in the project sets? */
+function isOffByDefault(path, line, context) {
+    const memo = memoFor(context);
+    const key = `o\0${path}\0${line}`;
+    const hit = memo.answers.get(key);
+    if (hit !== undefined)
+        return hit;
+    const file = directivesOf(path, context, memo);
+    const groups = enclosingTests(file.conditionals, line);
+    const off = groups.length > 0 && isOff(groups, file, [path], context, memo);
+    memo.answers.set(key, off);
+    return off;
+}
+/** Is a branch of `groups` off when no flag `scope`'s files see is set? */
+function isOff(groups, file, scope, context, memo) {
+    const dirs = [...new Set(scope.flatMap(ancestors))];
+    const flag = (name) => {
+        if (name.startsWith('_') || PLATFORM_FLAGS.has(name) || file.defines.has(name))
+            return undefined;
+        let named = memo.named.get(name);
+        // A word of its own, or a compiler flag's `-DX` / `/DX`.
+        if (!named)
+            memo.named.set(name, (named = new RegExp(`(?:^|[^\\w]|[-/]D)${name}\\b`, 'm')));
+        if (dirs.some((dir) => named.test(buildTextOf(dir, context, memo))))
+            return undefined;
+        const components = new Set(scope.map((f) => componentOf(dirOf(f), context, memo)));
+        return [...components].some((component) => isDefinedIn(name, component, context, memo)) ? undefined : false;
+    };
+    return groups.some((tests) => branchTruth(tests, flag) === false);
+}
+/**
+ * The branches around `line`, innermost last: for each, the tests of its
+ * group's branches up to and including the one `line` is in (`#else` has no
+ * test).
+ */
+function enclosingTests(conditionals, line) {
+    const groups = [];
+    for (const d of conditionals) {
+        if (d.line >= line)
+            break;
+        if (d.op === 'if' || d.op === 'ifdef' || d.op === 'ifndef')
+            groups.push([d]);
+        else if (d.op === 'endif')
+            groups.pop();
+        else
+            groups[groups.length - 1]?.push(d);
+    }
+    return groups;
+}
+/** Whether the last branch of `tests` is taken: no earlier test held, and its own does. */
+function branchTruth(tests, flag) {
+    let earlier = false;
+    for (let i = 0; i < tests.length - 1; i++) {
+        earlier = or(earlier, testTruth(tests[i], flag));
+        if (earlier === true)
+            return false;
+    }
+    return and(not(earlier), testTruth(tests[tests.length - 1], flag));
+}
+function testTruth(d, flag) {
+    const name = d.expression.trim().match(/^\w+$/)?.[0];
+    switch (d.op) {
+        case 'ifdef':
+        case 'elifdef':
+            return name ? flag(name) : undefined;
+        case 'ifndef':
+        case 'elifndef':
+            return name ? not(flag(name)) : undefined;
+        case 'else':
+            return true;
+        default:
+            return evaluate(d.expression, flag);
+    }
+}
+/**
+ * A `#if` expression of `defined`, flags, integers, `!`, `&&`, `||` and
+ * parentheses; anything else is unknown. A flag that is set nowhere reads as
+ * `0`, as the preprocessor reads a name no `#define` gave a value.
+ */
+function evaluate(expression, flag) {
+    const tokens = expression.match(/0x[\da-f]+\w*|\d\w*|[A-Za-z_]\w*|&&|\|\||\S/gi) ?? [];
+    // Check the shape first, so an unsupported test reads no flag.
+    let i = 0;
+    const shape = () => {
+        const term = () => {
+            const t = tokens[i++];
+            if (t === '!')
+                return term();
+            if (t === '(')
+                return shape() && tokens[i++] === ')';
+            if (t === 'defined') {
+                const paren = tokens[i] === '(';
+                if (paren)
+                    i++;
+                return /^[A-Za-z_]\w*$/.test(tokens[i++] ?? '') && (!paren || tokens[i++] === ')');
+            }
+            return t !== undefined && (/^(0x[\da-f]+|\d+)[ul]*$/i.test(t) || /^[A-Za-z_]\w*$/.test(t));
+        };
+        if (!term())
+            return false;
+        while (tokens[i] === '&&' || tokens[i] === '||') {
+            i++;
+            if (!term())
+                return false;
+        }
+        return true;
+    };
+    if (tokens.length === 0 || !shape() || i !== tokens.length)
+        return undefined;
+    i = 0;
+    const disjunction = () => {
+        let value = conjunction();
+        while (tokens[i] === '||') {
+            i++;
+            value = or(value, conjunction());
+        }
+        return value;
+    };
+    const conjunction = () => {
+        let value = term();
+        while (tokens[i] === '&&') {
+            i++;
+            value = and(value, term());
+        }
+        return value;
+    };
+    const term = () => {
+        const t = tokens[i++];
+        if (t === '!')
+            return not(term());
+        if (t === '(') {
+            const value = disjunction();
+            i++;
+            return value;
+        }
+        if (t === 'defined') {
+            if (tokens[i] === '(') {
+                const value = flag(tokens[i + 1]);
+                i += 3;
+                return value;
+            }
+            return flag(tokens[i++]);
+        }
+        if (/^\d|^0x/i.test(t))
+            return Number.parseInt(t.replace(/[ul]+$/i, ''), /^0x/i.test(t) ? 16 : 10) !== 0;
+        return flag(t) === false ? false : undefined;
+    };
+    return disjunction();
+}
+function directivesOf(file, context, memo) {
+    const hit = memo.files.get(file);
+    if (hit)
+        return hit;
+    const lines = (0, cpp_macro_visibility_1.directiveLines)(context.readFile(file) ?? '');
+    const conditionals = [];
+    const defines = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const define = lines[i].match(/^\s*#\s*define\s+(\w+)/);
+        if (define) {
+            defines.add(define[1]);
+            continue;
+        }
+        const m = lines[i].match(/^\s*#\s*(ifdef|ifndef|if|elifdef|elifndef|elif|else|endif)\b(.*)$/);
+        if (!m)
+            continue;
+        // A test continued with a backslash goes on over the next lines.
+        let expression = m[2];
+        for (let j = i; /\\\s*$/.test(lines[j]) && j + 1 < lines.length; j++) {
+            expression = expression.replace(/\\\s*$/, ' ') + lines[j + 1];
+        }
+        conditionals.push({ op: m[1], expression, line: i + 1 });
+    }
+    const directives = { conditionals, defines };
+    memo.files.set(file, directives);
+    return directives;
+}
+function buildTextOf(dir, context, memo) {
+    const hit = memo.buildText.get(dir);
+    if (hit !== undefined)
+        return hit;
+    const text = BUILD_FILES.map((name) => context.readFile(dir ? `${dir}/${name}` : name) ?? '').join('\n');
+    memo.buildText.set(dir, text);
+    return text;
+}
+/** The nearest directory at or above `dir` with a build file, else the project root. */
+function componentOf(dir, context, memo) {
+    const hit = memo.components.get(dir);
+    if (hit !== undefined)
+        return hit;
+    const component = dir === '' || buildTextOf(dir, context, memo).trim() ? dir : componentOf(dirOf(dir), context, memo);
+    memo.components.set(dir, component);
+    return component;
+}
+/** Does a C or C++ file under `component` `#define` `name`? Read only from files whose bytes hold the name. */
+function isDefinedIn(name, component, context, memo) {
+    const key = `${name}\0${component}`;
+    const hit = memo.defines.get(key);
+    if (hit !== undefined)
+        return hit;
+    memo.cFiles ??= context.getAllFiles().filter((file) => C_FAMILY_FILE.test(file));
+    const prefix = component ? `${component}/` : '';
+    const define = new RegExp(`^[ \\t]*#[ \\t]*define[ \\t]+${name}\\b`, 'm');
+    const defined = memo.cFiles.some((file) => file.startsWith(prefix) &&
+        (context.fileContains ? context.fileContains(file, name) : true) &&
+        define.test(context.readFile(file) ?? ''));
+    memo.defines.set(key, defined);
+    return defined;
+}
+//# sourceMappingURL=c-feature-variants.js.map

package/dist/resolution/cpp-macro-visibility.d.ts

@@ -0,0 +1,21 @@
+import { type ResolutionContext, type UnresolvedRef } from './types';
+export declare function clearCppMacroVisibility(context: ResolutionContext): void;
+/**
+ * Is this C/C++ `calls` ref a macro expansion rather than a call? True when
+ * the index knows the name as a function-like macro (extraction mints a
+ * `constant` per `preproc_function_def`) and either nothing but macros bears
+ * the name — there is no function to call, and a case-insensitive fuzzy
+ * match (`SWAP` → `swap`) must not invent one — or the macro is definitely
+ * visible at the call site.
+ */
+export declare function isVisibleCppMacro(ref: UnresolvedRef, context: ResolutionContext): boolean;
+/**
+ * The file's lines with comments removed — only as far as the preprocessor
+ * needs: a line inside a block comment is blank, a directive line loses its
+ * trailing `//` / `/* … *\/`, and every other line is kept verbatim (its
+ * content is never read, only whether a block comment opens on it). The
+ * generic comment stripper is a regex pass over the whole file and this walk
+ * touches every header of a translation unit, vendor trees included.
+ */
+export declare function directiveLines(source: string): string[];
+//# sourceMappingURL=cpp-macro-visibility.d.ts.map

package/dist/resolution/cpp-macro-visibility.js

@@ -0,0 +1,393 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCppMacroVisibility = clearCppMacroVisibility;
+exports.isVisibleCppMacro = isVisibleCppMacro;
+exports.directiveLines = directiveLines;
+/**
+ * Is a C/C++ call's name a function-like macro visible at the call site?
+ *
+ * `TRACE_POINT(1)` parses as a call_expression, so extraction records a
+ * `calls` ref named `TRACE_POINT`. If the translation unit defines
+ * `#define TRACE_POINT(value) ...` (in the file itself or through an
+ * include), the "call" is a macro expansion — and binding it to a
+ * same-spelled free function in an unrelated file fabricates a caller and a
+ * callee that never existed (#1838). The resolver asks this before trying
+ * any strategy and drops such a ref.
+ *
+ * Directive summaries are cached per file, but evaluated in translation-unit
+ * order on every inclusion. Only #pragma once and actual guard state suppress
+ * reinclusion; an active recursion stack breaks include cycles. Unknown build
+ * flags remain possible, so only definite macro visibility suppresses a call.
+ * Object-like definitions participate in conditions but never enter the cached
+ * call-site timelines (vendor headers can contain tens of thousands of them).
+ *
+ * A guard the walk cannot decide (`#define X_H 1`, or any header reached under
+ * an unknown `#if`) re-enters its header on every inclusion path, which is
+ * exponential in the include graph's depth (#2127). A re-entry that provably
+ * repeats an earlier visit which changed nothing is skipped, and a hard budget
+ * bounds whatever is left: past it, nothing is known and nothing is suppressed.
+ */
+const path = __importStar(require("path"));
+const c_cpp_1 = require("../extraction/languages/c-cpp");
+const types_1 = require("./types");
+const import_resolver_1 = require("./import-resolver");
+const memo = new WeakMap();
+const ROOT_TIMELINE_CAP = 32;
+/** Directive events one translation-unit walk may evaluate (#2127). */
+const WALK_EVENT_BUDGET = 1_000_000;
+const NO_CUTS = [];
+const and = (a, b) => a === false || b === false ? false : a === true && b === true ? true : undefined;
+const or = (a, b) => a === true || b === true ? true : a === false && b === false ? false : undefined;
+const not = (a) => (a === undefined ? undefined : !a);
+function clearCppMacroVisibility(context) {
+    memo.delete(context);
+}
+const isDefine = (n) => n.kind === 'constant' && types_1.CPP_DEFINE_SIGNATURE.test(n.signature ?? '');
+/**
+ * Is this C/C++ `calls` ref a macro expansion rather than a call? True when
+ * the index knows the name as a function-like macro (extraction mints a
+ * `constant` per `preproc_function_def`) and either nothing but macros bears
+ * the name — there is no function to call, and a case-insensitive fuzzy
+ * match (`SWAP` → `swap`) must not invent one — or the macro is definitely
+ * visible at the call site.
+ */
+function isVisibleCppMacro(ref, context) {
+    if (ref.language !== 'c' && ref.language !== 'cpp')
+        return false;
+    if (ref.referenceKind !== 'calls' || !/^\w+$/.test(ref.referenceName))
+        return false;
+    // The name cache is the index's truth, invalidated with the resolver's other
+    // caches; a per-context name set would go stale between indexing batches.
+    const sameName = context.getNodesByName(ref.referenceName);
+    if (!sameName.some(isDefine))
+        return false;
+    if (!sameName.some((n) => !isDefine(n)))
+        return true;
+    const cache = cacheFor(context);
+    const rootKey = `${ref.language}\0${ref.filePath}`;
+    let timeline = cache.roots.get(rootKey);
+    if (!timeline) {
+        timeline = walkTranslationUnit(ref.filePath, ref.language, context, cache);
+        if (cache.roots.size >= ROOT_TIMELINE_CAP)
+            cache.roots.delete(cache.roots.keys().next().value);
+        cache.roots.set(rootKey, timeline);
+    }
+    if (ref.line >= timeline.cutoff)
+        return false;
+    const before = (timeline.events.get(ref.referenceName) ?? []).filter((e) => e.line <= ref.line);
+    return before.length > 0 && before[before.length - 1].defined === true;
+}
+function cacheFor(context) {
+    let cache = memo.get(context);
+    if (!cache) {
+        cache = { summaries: new Map(), includes: new Map(), byBasename: null, roots: new Map() };
+        memo.set(context, cache);
+    }
+    return cache;
+}
+/** Cache syntax, never conditional truth: an included file can change its flags. */
+function summarize(file, context, cache) {
+    const cached = cache.summaries.get(file);
+    if (cached)
+        return cached;
+    const events = [];
+    const lines = directiveLines(context.readFile(file) ?? '');
+    for (let i = 0; i < lines.length; i++) {
+        const text = lines[i];
+        const branch = text.match(/^\s*#\s*(ifdef|ifndef|if|elif|else|endif)\b(.*)$/);
+        if (branch) {
+            events.push({ kind: 'branch', op: branch[1], expression: branch[2],
+                guard: guardsItself(lines, i, branch[1], branch[2]), line: i + 1 });
+            continue;
+        }
+        const directive = text.match(/^\s*#\s*(define|undef)\s+(\w+)(\(?)/);
+        if (directive) {
+            events.push({ kind: directive[1], name: directive[2], line: i + 1,
+                functionLike: directive[3] === '(', value: text.slice(directive[0].length),
+                wrapsItself: directive[3] === '(' && callsItself(lines, i, directive[2]) });
+            continue;
+        }
+        const include = text.match(/^\s*#\s*include\s*([<"])([^>"]+)[>"]/);
+        if (include)
+            events.push({ kind: 'include', quote: include[1], spec: include[2], line: i + 1 });
+        if (/^\s*#\s*pragma\s+once\b/.test(text))
+            events.push({ kind: 'once', line: i + 1 });
+    }
+    cache.summaries.set(file, events);
+    return events;
+}
+/**
+ * The file's lines with comments removed — only as far as the preprocessor
+ * needs: a line inside a block comment is blank, a directive line loses its
+ * trailing `//` / `/* … *\/`, and every other line is kept verbatim (its
+ * content is never read, only whether a block comment opens on it). The
+ * generic comment stripper is a regex pass over the whole file and this walk
+ * touches every header of a translation unit, vendor trees included.
+ */
+function directiveLines(source) {
+    const out = [];
+    let inBlock = false;
+    for (const raw of (0, c_cpp_1.maskCppRawStrings)(source).source.split(/\r?\n/)) {
+        let text = raw;
+        if (inBlock) {
+            const end = text.indexOf('*/');
+            if (end < 0) {
+                out.push('');
+                continue;
+            }
+            text = text.slice(end + 2);
+            inBlock = false;
+        }
+        const directive = /^\s*#/.test(text);
+        let kept = '';
+        let quote = '';
+        for (let i = 0; i < text.length; i++) {
+            const c = text[i];
+            if (quote) {
+                if (c === '\\')
+                    i++;
+                else if (c === quote)
+                    quote = '';
+                continue;
+            }
+            if (c === '"' || c === "'") {
+                quote = c;
+                continue;
+            }
+            if (c === '/' && text[i + 1] === '/') {
+                kept = text.slice(0, i);
+                break;
+            }
+            if (c === '/' && text[i + 1] === '*') {
+                const end = text.indexOf('*/', i + 2);
+                if (end < 0) {
+                    inBlock = true;
+                    kept = text.slice(0, i);
+                    break;
+                }
+                text = text.slice(0, i) + ' ' + text.slice(end + 2);
+                i--;
+                continue;
+            }
+        }
+        out.push(directive ? kept || text : raw);
+    }
+    return out;
+}
+/** Does the body of the `#define NAME(` at `index` (continuation lines included) call `NAME`? */
+function callsItself(lines, index, name) {
+    let text = lines[index];
+    for (let j = index; /\\\s*$/.test(lines[j]) && j + 1 < lines.length; j++)
+        text += ' ' + lines[j + 1];
+    const body = text.slice(text.indexOf('(') + 1);
+    return new RegExp(`(?:\\b${name}\\s*\\(|\\(\\s*${name}\\s*\\)\\s*\\()`).test(body);
+}
+/**
+ * The include-guard idiom: `#ifndef X_H` (or `#if !defined(X_H)`) whose next
+ * directive is `#define X_H`. Nothing in the file defines the guard before
+ * the test, so this is the first inclusion and the guarded body is active.
+ * The same shape around a fallback function-like macro (`#ifndef MIN` /
+ * `#define MIN(a, b) …`) is read the same way. A default VALUE
+ * (`#ifndef ENABLE_X` / `#define ENABLE_X 0`) is not: that is the flag a
+ * build overrides on the command line, so it stays unknown.
+ */
+function guardsItself(lines, index, op, expression) {
+    const name = op === 'ifndef'
+        ? expression.trim()
+        : expression.match(/^\s*!\s*defined\s*(?:\(\s*(\w+)\s*\)|(\w+))\s*$/)?.slice(1).find(Boolean);
+    if (!name || !/^\w+$/.test(name))
+        return false;
+    for (let j = index + 1; j < lines.length; j++) {
+        const text = lines[j];
+        if (!/^\s*#/.test(text))
+            continue;
+        return new RegExp(`^\\s*#\\s*define\\s+${name}(?:\\s*$|\\()`).test(text);
+    }
+    return false;
+}
+function resolveInclude(file, quote, spec, language, context, cache) {
+    const key = `${language}\0${file}\0${quote}${spec}`;
+    const cached = cache.includes.get(key);
+    if (cached !== undefined)
+        return cached;
+    const local = path.posix.normalize(path.posix.join(path.posix.dirname(file), spec.replace(/\\/g, '/')));
+    let target = quote === '"' && !local.startsWith('../') && !path.posix.isAbsolute(local) && context.fileExists(local)
+        ? local
+        : (0, import_resolver_1.resolveImportPath)(spec, file, language, context);
+    if (!target) {
+        if (!cache.byBasename) {
+            cache.byBasename = new Map();
+            for (const f of context.getAllFiles()) {
+                const base = f.slice(f.lastIndexOf('/') + 1);
+                const list = cache.byBasename.get(base);
+                if (list)
+                    list.push(f);
+                else
+                    cache.byBasename.set(base, [f]);
+            }
+        }
+        const normalized = spec.replace(/\\/g, '/');
+        const matches = (cache.byBasename.get(normalized.slice(normalized.lastIndexOf('/') + 1)) ?? []).filter((f) => f === normalized || f.endsWith('/' + normalized));
+        if (matches.length === 1)
+            target = matches[0];
+    }
+    cache.includes.set(key, target);
+    return target;
+}
+function walkTranslationUnit(rootFile, language, context, cache) {
+    const timeline = new Map();
+    const definitions = new Map();
+    const scanning = new Set();
+    const macroNames = new Set();
+    const once = new Map();
+    // Every change a later directive could observe (definitions, `#pragma once`,
+    // the macro-name set) bumps `version`. A visit that left it unchanged, entered
+    // again with the same inherited truth while it is still unchanged, starts from
+    // the same state, so it would take the same branches and change nothing again;
+    // the events it would push repeat each name's current state, which is already
+    // its last event. Include cycles cut by the recursion stack (`cuts`) must still
+    // be cut for the repeat to hold.
+    let version = 0;
+    const cuts = [];
+    const visits = new Map();
+    let budget = WALK_EVENT_BUDGET;
+    let cutoff = Infinity;
+    const condition = (expression) => {
+        const text = expression.trim();
+        if (/^(?:0x[\da-f]+|\d+)[uUlL]*$/i.test(text))
+            return Number(text.replace(/[uUlL]+$/, '')) !== 0;
+        const def = text.match(/^(!)?\s*defined\s*(?:\(\s*(\w+)\s*\)|(\w+))$/);
+        if (def) {
+            const known = definitions.get(def[2] ?? def[3])?.defined;
+            return def[1] ? not(known) : known;
+        }
+        return /^\w+$/.test(text) ? definitions.get(text)?.value : undefined;
+    };
+    const scan = (file, inherited, includeLine) => {
+        if (inherited === false || once.get(file) === true || cutoff !== Infinity)
+            return;
+        if (scanning.has(file)) {
+            cuts.push(file);
+            return;
+        }
+        const seen = visits.get(file);
+        if (seen && seen.inherited === inherited && seen.start === seen.end && seen.end === version &&
+            seen.cuts.every((c) => scanning.has(c))) {
+            cuts.push(...seen.cuts);
+            return;
+        }
+        const start = version;
+        const firstCut = cuts.length;
+        scanning.add(file);
+        let active = inherited;
+        const frames = [];
+        for (const ev of summarize(file, context, cache)) {
+            const line = includeLine ?? ev.line;
+            if (cutoff === Infinity && --budget < 0)
+                cutoff = line;
+            if (cutoff !== Infinity)
+                break;
+            if (ev.kind === 'branch') {
+                if (ev.op === 'if' || ev.op === 'ifdef' || ev.op === 'ifndef') {
+                    const known = definitions.get(ev.expression.trim())?.defined;
+                    let selected = ev.op === 'if' ? condition(ev.expression) : ev.op === 'ifndef' ? not(known) : known;
+                    if (selected === undefined && ev.guard)
+                        selected = true;
+                    frames.push({ parent: active, taken: selected });
+                    active = and(active, selected);
+                }
+                else if (ev.op === 'endif') {
+                    active = frames.pop()?.parent ?? inherited;
+                }
+                else {
+                    const frame = frames[frames.length - 1];
+                    if (frame) {
+                        const test = ev.op === 'else' ? true : condition(ev.expression);
+                        active = and(frame.parent, and(not(frame.taken), test));
+                        frame.taken = or(frame.taken, test);
+                    }
+                }
+                continue;
+            }
+            if (active === false)
+                continue;
+            if (ev.kind === 'once') {
+                const next = or(once.get(file) ?? false, active);
+                if (next !== (once.get(file) ?? false))
+                    version++;
+                once.set(file, next);
+                continue;
+            }
+            if (ev.kind === 'include') {
+                const target = resolveInclude(file, ev.quote, ev.spec, language, context, cache);
+                if (target)
+                    scan(target, active, line);
+                continue;
+            }
+            const prior = definitions.get(ev.name);
+            const defining = ev.kind === 'define';
+            const macro = defining && ev.functionLike && !ev.wrapsItself;
+            const now = active === true ? macro : prior?.macro === macro ? macro : undefined;
+            // A name no directive has touched is unknown, not undefined: the build
+            // can set it on the command line. So an `#undef` under an undecidable
+            // `#if` leaves it unknown (#2069); only a certain one clears it.
+            const next = {
+                defined: defining ? or(prior?.defined, active) : and(prior?.defined, not(active)),
+                value: defining && active === true ? condition(ev.value) : undefined,
+                macro: now,
+            };
+            if (next.defined !== prior?.defined || next.value !== prior?.value || next.macro !== prior?.macro)
+                version++;
+            definitions.set(ev.name, next);
+            if (ev.functionLike && !macroNames.has(ev.name)) {
+                macroNames.add(ev.name);
+                version++;
+            }
+            if (macroNames.has(ev.name)) {
+                const events = timeline.get(ev.name) ?? [];
+                events.push({ line, defined: now });
+                timeline.set(ev.name, events);
+            }
+        }
+        scanning.delete(file);
+        const own = cuts.length > firstCut ? [...new Set(cuts.splice(firstCut))] : NO_CUTS;
+        cuts.push(...own);
+        visits.set(file, { inherited, start, end: version, cuts: own });
+    };
+    scan(rootFile, true);
+    return { events: timeline, cutoff };
+}
+//# sourceMappingURL=cpp-macro-visibility.js.map