ucn 5.5.3 → 5.6.0

package/core/tracing.js

@@ -21,9 +21,11 @@
 
 const path = require('path');
 const { escapeRegExp, codeUnitCompare, inlineTestRanges, lineInRanges, classDispatchNames } = require('./shared');
+const { paramDefault } = require('./registry');
 const { isTestFile } = require('./discovery');
 const { getCachedCalls } = require('./callers');
 const { getLanguageAdapter } = require('../languages');
+const { createTestModel, addTestCaseRows, linkFiles, commandsFor } = require('./test-units');
 
 /**
  * Contract-mode caller expansion for the tree commands. Memoizes the full
@@ -147,7 +149,7 @@ function trace(index, name, options = {}) {
     index._beginOp();
     try {
     // Sanitize depth: use default for null/undefined, clamp negative to 0
-    const rawDepth = options.depth ?? 3;
+    const rawDepth = options.depth ?? paramDefault('depth', 'trace');
     const maxDepth = Math.max(0, rawDepth);
     const direction = options.direction || 'down';  // 'down' = callees, 'up' = callers, 'both'
     const maxChildren = options.all ? Infinity : 10;
@@ -340,7 +342,7 @@ function trace(index, name, options = {}) {
 function blast(index, name, options = {}) {
     index._beginOp();
     try {
-        const maxDepth = Math.max(0, options.depth ?? 3);
+        const maxDepth = Math.max(0, options.depth ?? paramDefault('depth', 'trace'));
         const maxChildren = options.all ? Infinity : 10;
         const includeMethods = options.includeMethods ?? true;
         const exclude = options.exclude || [];
@@ -354,7 +356,9 @@ function blast(index, name, options = {}) {
         if (!def) return null;
 
         const visited = new Set();
-        const callerCache = new Map();
+        // A caller's answer about one definition is the same whichever
+        // root the walk started from: a selection over many roots shares it.
+        const callerCache = options._callerCache || new Map();
         const affectedFunctions = new Set();
         const possiblyAffectedSet = new Set();
         const affectedFiles = new Set();
@@ -590,7 +594,7 @@ function blast(index, name, options = {}) {
 function reverseTrace(index, name, options = {}) {
     index._beginOp();
     try {
-        const maxDepth = Math.max(0, options.depth ?? 5);
+        const maxDepth = Math.max(0, options.depth ?? paramDefault('depth', 'trace', 'entrypoints'));
         const maxChildren = options.all ? Infinity : 10;
         const includeMethods = options.includeMethods ?? true;
         const exclude = options.exclude || [];
@@ -855,6 +859,10 @@ function affectedTests(index, name, options = {}) {
             depth: maxDepth,
             file: options.file,
             className: options.className,
+            // A pin on the declaration's line: one of several same-name
+            // definitions in a file.
+            line: options.line,
+            _callerCache: options._callerCache,
             all: true,
             exclude: options.exclude,
             includeMethods: options.includeMethods,
@@ -900,12 +908,22 @@ function affectedTests(index, name, options = {}) {
         const excludeArr = exclude ? (Array.isArray(exclude) ? exclude : [exclude]) : [];
         const includeMethods = options.includeMethods ?? true;
         const possiblyNames = new Set();
+        // The one model of what a test is (core/test-units.js); a caller
+        // that asks about several names hands in its own.
+        const model = options._testModel || createTestModel(index);
+        // Code a test executes in a file whose name is no test file's: the
+        // lines the model says so (a test of its own, the body of a test a
+        // class of another file inherits), or null.
+        const modelRanges = filePath => {
+            const ranges = model.testRangesOf(filePath);
+            return ranges.length > 0 ? ranges : null;
+        };
         // Test FILES containing an unverified call site of an affected name
         // (relativePath → funcName → Set(lines)) — merged into
         // possiblyAffectedTests after the scan (fix #244).
         const frontierTestHits = new Map();
         {
-            const callerCache = new Map();
+            const callerCache = options._callerCache || new Map();
             const possibleVisited = new Set();
             const queue = [];
             const enqueueCaller = (c, depth) => {
@@ -954,6 +972,11 @@ function affectedTests(index, name, options = {}) {
                             const ranges = inlineTestRanges(cfe);
                             if (ranges.length > 0 && lineInRanges(fe.line, ranges)) isTestCaller = true;
                         }
+                        if (!isTestCaller && fe.line != null) {
+                            // A line the test model says a test executes.
+                            const ranges = modelRanges(siteFile);
+                            if (ranges && lineInRanges(fe.line, ranges)) isTestCaller = true;
+                        }
                         if (isTestCaller &&
                             (excludeArr.length === 0 || index.matchesFilters(cfe.relativePath, { exclude: excludeArr }))) {
                             const affName = fe.atNode?.name || name;
@@ -991,10 +1014,26 @@ function affectedTests(index, name, options = {}) {
         // Step 3: Scan test files for all affected names using AST
         // Only count call and test-case matches as real coverage — not imports or bare references.
         const className = options.className || null;
+        const absoluteOf = new Map(); // relative test path -> absolute
         const results = [];
         const possibleResults = [];
         const scanNames = [...affectedNames, ...possiblyNames];
         const dispatchNamesCache = new Map(); // `${class}:${name}` → Set(classNames)
+        // Files whose name is no test file's that hold a call of a scanned
+        // name: a confirmed edge of the engine, or (a name whose callers
+        // the engine did not search) a call by that name. Only these are
+        // asked of the test model.
+        const callSiteFiles = new Set();
+        for (const byFile of confirmedSitesByName.values()) {
+            for (const relativePath of byFile.keys()) callSiteFiles.add(relativePath);
+        }
+        for (const funcName of scanNames) {
+            if (expandedNames.has(funcName)) continue;
+            for (const calling of index.getCalleeFiles(funcName) || []) {
+                const entry = index.files.get(calling);
+                if (entry) callSiteFiles.add(entry.relativePath);
+            }
+        }
         for (const [filePath, fileEntry] of index.files) {
             let isTest = isTestFile(fileEntry.relativePath, fileEntry.language);
             // Rust inline #[cfg(test)] modules: source files with #[test]-marked symbols
@@ -1009,6 +1048,17 @@ function affectedTests(index, name, options = {}) {
                     testRanges = ranges;
                 }
             }
+            // A file's name does not decide what a test executes: the body
+            // of a test a class inherits stands where its base class is,
+            // and a runner takes tests from files of any name. Such a file
+            // is test code within the lines the test model names.
+            if (!isTest && callSiteFiles.has(fileEntry.relativePath)) {
+                const ranges = modelRanges(filePath);
+                if (ranges) {
+                    isTest = true;
+                    testRanges = ranges;
+                }
+            }
             if (!isTest) continue;
             if (excludeArr.length > 0 && !index.matchesFilters(fileEntry.relativePath, { exclude: excludeArr })) continue;
             try {
@@ -1025,6 +1075,12 @@ function affectedTests(index, name, options = {}) {
                     // scan remains their best-effort fallback).
                     const engineAdjudicated = expandedNames.has(funcName);
 
+                    // The engine searched this name's callers and confirmed
+                    // none in this file: a call here is not credited (below),
+                    // and an import or a bare reference links nothing by
+                    // itself, so there is nothing a scan could add.
+                    if (engineAdjudicated && !engineFileSites) continue;
+
                     // Fast pre-check
                     if (!content.includes(funcName) && !engineFileSites) continue;
 
@@ -1172,9 +1228,17 @@ function affectedTests(index, name, options = {}) {
                         }
                     }
 
-                    // Language-aware test-case detection
-                    _addAffectedTestCases(index, filePath, fileEntry, funcName, fileMatches);
+                    // The tests that hold a call, and the titled ones that
+                    // name the function around one (core/test-units.js).
+                    if (fileMatches.has(funcName)) {
+                        addTestCaseRows(model, index, filePath, funcName, fileMatches.get(funcName), {
+                            counts: match => match.matchType === 'call',
+                            titleNeedsMatch: true,
+                            extra: { functionName: funcName },
+                        });
+                    }
                 }
+                if (fileMatches.size > 0) absoluteOf.set(fileEntry.relativePath, filePath);
 
                 if (fileMatches.size > 0) {
                     const linkedFunctions = [...fileMatches.keys()];
@@ -1283,6 +1347,68 @@ function affectedTests(index, name, options = {}) {
             });
         }
 
+        // What each file is to its runner, which tests hold the links, and
+        // how many tests that is.
+        for (const [absFile, entry] of frontierTestHits) absoluteOf.set(entry.rel, absFile);
+        const confirmedTests = new Set();
+        const conditionalTests = new Set();
+        const describeBand = (rows, confirmed) => {
+            const linesByFile = new Map();
+            for (const row of rows) {
+                const absFile = absoluteOf.get(row.file);
+                if (!absFile) continue;
+                linesByFile.set(absFile, row.matches
+                    .filter(match => match.matchType === 'call' || match.matchType === 'test-case')
+                    .map(match => match.line));
+            }
+            const byFile = new Map(rows.map(row => [row.file, row]));
+            for (const [absFile, linked] of linkFiles(model, index, linesByFile)) {
+                const relativePath = index.files.get(absFile).relativePath;
+                let row = byFile.get(relativePath);
+                if (!row) {
+                    // The file of a class that inherits a linked test: the
+                    // test runs there, whatever file its body stands in.
+                    const sources = (linked.from || []).map(from => byFile.get(from)).filter(Boolean);
+                    row = {
+                        file: relativePath,
+                        linkedFunctions: [...new Set(sources.flatMap(source => source.linkedFunctions))]
+                            .sort(codeUnitCompare),
+                        matchCount: 0,
+                        matches: [],
+                    };
+                    byFile.set(relativePath, row);
+                    absoluteOf.set(relativePath, absFile);
+                    rows.push(row);
+                }
+                for (const unit of linked.units) {
+                    if (!unit.inheritedFrom) continue;
+                    row.matches.push({
+                        line: unit.line,
+                        content: (index.getLineContent(absFile, unit.line) || '').trim(),
+                        matchType: 'inherited-test',
+                        functionName: row.linkedFunctions[0] || name,
+                        name: unit.name,
+                        from: unit.inheritedFrom,
+                    });
+                    row.matchCount = row.matches.length;
+                }
+                row.role = linked.role;
+                if (linked.runner) row.runner = linked.runner;
+                row.testCount = linked.tests;
+                if (linked.moreTests) row.moreTests = true;
+                if (linked.conditionalTests) row.conditionalTests = linked.conditionalTests;
+                if (linked.units.length > 0) row.units = linked.units;
+                if (linked.run) row.run = linked.run;
+                else if (linked.runWithheld) row.runWithheld = linked.runWithheld;
+                if (confirmed) {
+                    for (const key of linked.testKeys) confirmedTests.add(key);
+                    for (const key of linked.conditionalKeys) conditionalTests.add(key);
+                }
+            }
+        };
+        describeBand(results, true);
+        describeBand(possibleResults, false);
+
         // Sort by linkage breadth then alphabetically
         results.sort((a, b) => b.linkedFunctions.length - a.linkedFunctions.length || codeUnitCompare(a.file, b.file));
         possibleResults.sort((a, b) => b.linkedFunctions.length - a.linkedFunctions.length || codeUnitCompare(a.file, b.file));
@@ -1295,11 +1421,16 @@ function affectedTests(index, name, options = {}) {
             // functions (#[test] fns in Rust's #[cfg(test)] mods, Go Test*)
             // live in production-path FILES but are tests themselves — the
             // language's getEntryPointKind says so; they need no coverage.
-            for (const [, fe] of index.files) {
+            for (const [filePath, fe] of index.files) {
                 if (isTestFile(fe.relativePath, fe.language)) continue;
                 const langModule = getLanguageAdapter(fe.language);
                 const kindOf = langModule?.getEntryPointKind;
-                if (fe.symbols?.some(s => s.name === n && (!kindOf || kindOf(s) !== 'test'))) {
+                // A declaration the test model found test code in (asked
+                // above, where the file held a call): a test, not a
+                // production symbol.
+                const ranges = model.ranges.get(filePath) || [];
+                if (fe.symbols?.some(s => s.name === n && (!kindOf || kindOf(s) !== 'test') &&
+                    !(ranges.length > 0 && lineInRanges(s.startLine, ranges)))) {
                     return true;
                 }
             }
@@ -1331,11 +1462,21 @@ function affectedTests(index, name, options = {}) {
             possiblyAffected: possiblyProduction,
             testFiles: results,
             possiblyAffectedTests: possibleResults,
+            // The commands that run the confirmed files, where a runner is
+            // proven and its command is known.
+            commands: commandsFor(model, results.filter(row => row.role === 'tests')
+                .map(row => absoluteOf.get(row.file)).filter(Boolean)),
             ...(blastResult.account && { account: blastResult.account }),
             treeAccount: blastResult.treeAccount,
             summary: {
                 totalAffected: namesForCoverage.size,
                 totalTestFiles: results.length,
+                totalTests: confirmedTests.size,
+                // A file among them holds tests that are not listed: the
+                // total is a lower bound.
+                ...(results.some(row => row.moreTests) && { moreTests: true }),
+                ...(conditionalTests.size > 0 && { conditionalTests: conditionalTests.size }),
+                supportFiles: results.filter(row => row.role === 'support').length,
                 staticallyLinkedFunctions: linkedSet.size,
                 notStaticallyLinkedCount: notStaticallyLinked.length,
                 possiblyAffected: possiblyProduction.length,
@@ -1348,73 +1489,6 @@ function affectedTests(index, name, options = {}) {
     } finally { index._endOp(); }
 }
 
-/**
- * Add test-case matches for a function name in a test file (language-aware).
- * Only adds test-case when the test body has a call match (not just import/reference).
- */
-function _addAffectedTestCases(index, filePath, fileEntry, funcName, fileMatches) {
-    const lang = fileEntry.language;
-    const existingMatches = fileMatches.get(funcName) || [];
-    const existingLines = new Set(existingMatches.map(m => m.line));
-
-    if (lang === 'javascript' || lang === 'typescript' || lang === 'tsx') {
-        const calls = getCachedCalls(index, filePath);
-        if (!calls) return;
-        const testFrameworkCalls = new Set(['describe', 'it', 'test', 'spec']);
-        // Word-boundary match (fix #246): substring matched mid-word titles.
-        const termPattern = new RegExp('(^|[^\\w$])' + escapeRegExp(funcName) + '([^\\w$]|$)');
-        for (const call of calls) {
-            if (!testFrameworkCalls.has(call.name)) continue;
-            const lineContent = index.getLineContent(filePath, call.line);
-            if (termPattern.test(lineContent) && !existingLines.has(call.line)) {
-                // Only add test-case if a call match exists in the test body
-                const endLine = _estimateTestBlockEndTracing(index, filePath, call.line);
-                const hasCallMatch = existingMatches.some(m =>
-                    m.line >= call.line && m.line <= endLine &&
-                    m.matchType === 'call'
-                );
-                if (!hasCallMatch) continue;
-                if (!fileMatches.has(funcName)) fileMatches.set(funcName, []);
-                fileMatches.get(funcName).push({
-                    line: call.line, content: lineContent.trim(),
-                    matchType: 'test-case', functionName: funcName
-                });
-                existingLines.add(call.line);
-            }
-        }
-    } else {
-        if (!fileEntry.symbols) return;
-        try {
-            const langModule = getLanguageAdapter(lang);
-            if (!langModule) return;
-            // Prefer the kinded predicate so we don't mis-tag fn main() / fn init()
-            // (runtime entries) as test cases (BUG-CX). Fall back to isEntryPoint
-            // for backward compat with language modules that haven't been migrated.
-            const classify = langModule.getEntryPointKind
-                ? (s) => langModule.getEntryPointKind(s) === 'test'
-                : langModule.isEntryPoint;
-            if (!classify) return;
-            for (const symbol of fileEntry.symbols) {
-                if (!classify(symbol)) continue;
-                // Only add test-case if a call match exists in the test body
-                const hasCallInRange = existingMatches.some(m =>
-                    m.line >= symbol.startLine && m.line <= symbol.endLine &&
-                    m.matchType === 'call'
-                );
-                if (hasCallInRange && !existingLines.has(symbol.startLine)) {
-                    const lineContent = index.getLineContent(filePath, symbol.startLine);
-                    if (!fileMatches.has(funcName)) fileMatches.set(funcName, []);
-                    fileMatches.get(funcName).push({
-                        line: symbol.startLine, content: lineContent.trim(),
-                        matchType: 'test-case', functionName: funcName
-                    });
-                    existingLines.add(symbol.startLine);
-                }
-            }
-        } catch (e) { /* skip */ }
-    }
-}
-
 /**
  * Build instance type map for className scoping in affectedTests.
  * Same logic as _buildInstanceTypeMap in search.js.
@@ -1476,26 +1550,6 @@ function _receiverMatchesClassTracing(usage, dispatchNames, instanceTypeMap, lin
     return false;
 }
 
-/**
- * Estimate the end line of a test block by tracking brace/paren nesting.
- */
-function _estimateTestBlockEndTracing(index, filePath, startLine) {
-    const content = index._readFile(filePath);
-    if (!content) return startLine + 5;
-    const lines = content.split('\n');
-    let depth = 0;
-    let started = false;
-    for (let i = startLine - 1; i < lines.length; i++) {
-        const line = lines[i];
-        for (const ch of line) {
-            if (ch === '{' || ch === '(') { depth++; started = true; }
-            else if (ch === '}' || ch === ')') { depth--; }
-        }
-        if (started && depth <= 0) return i + 1;
-    }
-    return Math.min(startLine + 10, lines.length);
-}
-
 function _matchPriority(matchType) {
     const p = { 'test-case': 5, 'call': 4, 'import': 3, 'string-ref': 2, 'reference': 1 };
     return p[matchType] || 0;

package/core/verify.js

@@ -1215,7 +1215,7 @@ const GIT_REF_FORMAT = /^[a-zA-Z0-9._\-~\/^@{}:]+$/;  // eslint-disable-line no-
  */
 let baseReadSerial = 0;
 
-function startBaseRead(file, base) {
+function startBaseRead(file, base, repoFile = file) {
     if (process.platform === 'win32' || !file || !GIT_REF_FORMAT.test(base)) return null;
     const out = path.join(os.tmpdir(),
         `ucn-base-${process.pid}-${++baseReadSerial}-${Math.random().toString(36).slice(2, 10)}`);
@@ -1225,8 +1225,8 @@ function startBaseRead(file, base) {
         // marks a revision that does not hold the file.
         child = spawn('/bin/sh', ['-c',
             'git show "$1" > "$2.part" 2>/dev/null && mv "$2.part" "$2" || { rm -f "$2.part"; : > "$2.none"; }',
-            'ucn-base', `${base}:./${path.basename(file)}`, out],
-        { cwd: path.dirname(file), stdio: 'ignore' });
+            'ucn-base', `${base}:./${path.basename(repoFile)}`, out],
+        { cwd: path.dirname(repoFile), stdio: 'ignore' });
     } catch {
         child = null;
     }
@@ -1299,8 +1299,11 @@ function baseDeclarationChanges(index, name, def, base = 'HEAD', baseRead = null
         if (baseContent === null) continue;
         if (baseContent === undefined) {
             try {
-                baseContent = execFileSync('git', ['show', `${base}:./${path.basename(file)}`], {
-                    cwd: path.dirname(file), encoding: 'utf-8', maxBuffer: 256 * 1024 * 1024,
+                // The repository's copy of the file (a snapshot exported
+                // from the git index is not a repository).
+                const repoFile = index.repoPathOf ? index.repoPathOf(file) : file;
+                baseContent = execFileSync('git', ['show', `${base}:./${path.basename(repoFile)}`], {
+                    cwd: path.dirname(repoFile), encoding: 'utf-8', maxBuffer: 256 * 1024 * 1024,
                     stdio: ['ignore', 'pipe', 'ignore'],
                 });
             } catch {
@@ -1848,6 +1851,9 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
         }
 
         return {
+            // Where the call is in the source: the same node, whoever reads
+            // the file next (an alias, the second call on a line).
+            span: { start: callNode.startIndex, end: callNode.endIndex },
             args,
             argCount: args.length,
             hasSpread: args.some(a => a.startsWith('...')) || unpackingArgs > 0,
@@ -2199,8 +2205,9 @@ function verify(index, name, options = {}) {
     // A base the user names must be a commit: a misspelled ref would read as
     // a file absent at base and check nothing against the old declaration
     // (the target-less check already resolved its base through the diff).
-    if (options.base && options.checkBaseRef) assertGitCommit(def.file, baseRef);
-    const baseRead = startBaseRead(def.file, baseRef);
+    const repoFile = index.repoPathOf ? index.repoPathOf(def.file) : def.file;
+    if (options.base && options.checkBaseRef) assertGitCommit(repoFile, baseRef);
+    const baseRead = startBaseRead(def.file, baseRef, repoFile);
     let sweep;
     try {
         sweep = contractedCallerSweep(index, name, def, {
@@ -2274,6 +2281,15 @@ function verify(index, name, options = {}) {
         };
     }
 
+    // A mismatch remembers which call it is (not part of what is printed).
+    const located = (record, analysis) => {
+        if (analysis && analysis.span) Object.defineProperty(record, 'span', { value: analysis.span, enumerable: false });
+        // `f.call(self, ..)`: the arguments start one slot later.
+        if (analysis && analysis.indirectKind) {
+            Object.defineProperty(record, 'indirect', { value: analysis.indirectKind, enumerable: false });
+        }
+        return record;
+    };
     const verifyLineSeen = new Map(); // 'file:line' -> per-line ordinal (fix #231)
     for (const call of calls) {
         const siteKey = `${call.file}:${call.line}:${call.calledAs || name}`;
@@ -2364,7 +2380,7 @@ function verify(index, name, options = {}) {
             continue;
         }
         if (!countOk || call.invalidOverload) {
-            mismatches.push({
+            mismatches.push(located({
                 file: call.relativePath,
                 line: call.line,
                 expression: call.content.trim(),
@@ -2378,7 +2394,7 @@ function verify(index, name, options = {}) {
                 args: analysis.args,
                 patterns: patternFlagsFrom(analysis),
                 ...carry,
-            });
+            }, analysis));
             continue;
         }
 
@@ -2399,7 +2415,7 @@ function verify(index, name, options = {}) {
                     ...carry,
                 });
             } else {
-                mismatches.push({
+                mismatches.push(located({
                     file: call.relativePath,
                     line: call.line,
                     expression: call.content.trim(),
@@ -2413,7 +2429,7 @@ function verify(index, name, options = {}) {
                     problem: bindingProblems.join('; '),
                     patterns: patternFlagsFrom(analysis),
                     ...carry,
-                });
+                }, analysis));
             }
             continue;
         }

package/languages/adapter.js

@@ -147,13 +147,18 @@ function createLanguageAdapter(config) {
             // safeParse returns the tree the extractors above just built.
             if (config.traits?.reflectionApi && !parsed.reflectionSites) {
                 const { safeParse } = require('./index');
-                const { reflectionSitesInTree } = require('../core/reflection');
+                const { reflectionFactsInTree } = require('../core/reflection');
                 // A language reading the file through its own view (C#
                 // conditional compilation, fix #391) supplies that tree.
                 const analysisTree = typeof languageModule.analysisTree === 'function'
                     ? languageModule.analysisTree(code, parser) : safeParse(parser, code);
-                const sites = reflectionSitesInTree(analysisTree, config.name, code);
-                if (sites.length > 0) parsed.reflectionSites = sites;
+                const facts = reflectionFactsInTree(analysisTree, config.name, code, { imports });
+                if (facts.sites.length > 0) parsed.reflectionSites = facts.sites;
+                // How often the file uses the reflection and code-execution
+                // vocabulary: what `repo` and the completeness footer count,
+                // read from the index instead of from every file's text.
+                if (facts.reflectionUses > 0) parsed.reflectionUses = facts.reflectionUses;
+                if (facts.evalUses > 0) parsed.evalUses = facts.evalUses;
             }
             // Computed dispatch sites (`handlers[name]()`) of the literal
             // parse the doctor's blind-spot inventory reads (fix #436): a

package/languages/c-family.js

@@ -3633,6 +3633,17 @@ function memberQualifiers(declarator) {
     return out;
 }
 
+/**
+ * `virtual R f(...) = 0;`: a member function declaration whose initializer
+ * is the literal 0 is pure virtual. A concrete derived class must override
+ * it. (A data member `int x = 0;` has no function declarator and never
+ * reaches the caller.)
+ */
+function isPureVirtual(node) {
+    const value = templatedDeclaration(node).childForFieldName('default_value');
+    return !!value && value.type === 'number_literal' && value.text === '0';
+}
+
 function memberFromNode(node, className, access, lines, mode) {
     const declarator = functionDeclarator(node);
     if (!declarator) return null;
@@ -3662,6 +3673,7 @@ function memberFromNode(node, className, access, lines, mode) {
         memberType: isConstructor ? 'constructor' : 'method',
         isMethod: true,
         isConstructor,
+        ...(mode === 'cpp' && !isConstructor && isPureVirtual(node) && { requiredMember: true }),
         ...(mode === 'cpp' && memberQualifiers(declarator)),
         ...(enclosingNamespace(node) && {
             namespace: enclosingNamespace(node),