ucn 5.5.3 → 5.6.1

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 {
@@ -1774,10 +1777,19 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
         if (!argsNode) return { args: [], argCount: 0, isMethodCall, ...ctx };
 
         let args = [];
+        const argumentFacts = [];
         for (let i = 0; i < argsNode.namedChildCount; i++) {
             const argNode = argsNode.namedChild(i);
             if (argNode.type.includes('comment')) continue;
             args.push(argNode.text.trim());
+            let value = argNode.type === 'keyword_argument' ? argNode.childForFieldName('value') : argNode;
+            // C# wraps each ordinary value in an argument node. Named or
+            // ref/out arguments remain outside the literal proof domain.
+            if (value?.type === 'argument' && value.namedChildCount === 1 && value.childCount === 1) {
+                value = value.namedChild(0);
+            }
+            argumentFacts.push({ kind: classifyArgNode(value), nodeType: value?.type, text: value?.text,
+                ...(argNode.type === 'keyword_argument' && { keyword: argNode.childForFieldName('name')?.text }) });
         }
 
         // Python argument structure (fix #281): keyword arguments bind by
@@ -1847,7 +1859,10 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
             }
         }
 
-        return {
+        return Object.defineProperty({
+            // 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,
@@ -1857,7 +1872,7 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
             isMethodCall,
             ...(indirectKind && { indirectKind }),
             ...ctx,
-        };
+        }, 'argumentFacts', { value: argumentFacts });
     } catch (e) {
         return { args: null, argCount: 0 };
     }
@@ -1961,7 +1976,7 @@ function classifyArgNode(node) {
     }
     // Numbers
     if (t === 'number' || t === 'integer' || t === 'float' || t === 'number_literal' ||
-        t === 'integer_literal' || t === 'float_literal' || t === 'decimal_integer_literal' ||
+        t === 'integer_literal' || t === 'int_literal' || t === 'float_literal' || t === 'decimal_integer_literal' ||
         t === 'hex_integer_literal' || t === 'real_literal') {
         return 'number_literal';
     }
@@ -2133,10 +2148,11 @@ function bindKeywordCall(params, analysis) {
  * @param {object} options - { file }
  * @returns {object} Verification results with mismatches
  */
-function verify(index, name, options = {}) {
+function verify(index, name, options = {}, direct = null) {
     index._beginOp();
     try {
-    const { def, warnings } = index.resolveSymbol(name, { file: options.file, className: options.className, line: options.line });
+    const { def, warnings } = direct ? { def: direct.definition, warnings: [] }
+        : index.resolveSymbol(name, { file: options.file, className: options.className, line: options.line });
     if (!def) {
         return { found: false, function: name };
     }
@@ -2173,6 +2189,7 @@ function verify(index, name, options = {}) {
     const rawParamLists = ctorParamLists ||
         (callableIdentityParams?.length ? callableIdentityParams : null) ||
         [(arrowTypes?.paramsStructured) || def.paramsStructured || []];
+    if (direct) direct.parameterLists = rawParamLists.map(stripSelf);
     const params = stripSelf(rawParamLists[0]);
     const arities = rawParamLists.map(l => {
         const list = stripSelf(l);
@@ -2199,11 +2216,13 @@ 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 = direct ? null : startBaseRead(def.file, baseRef, repoFile);
     let sweep;
     try {
-        sweep = contractedCallerSweep(index, name, def, {
+        sweep = direct ? { confirmed: direct.sites, unverified: [], account: null, rebound: [], baseChanges: [] }
+            : contractedCallerSweep(index, name, def, {
             baseChanges: () => baseDeclarationChanges(index, name, def, baseRef, baseRead),
         });
     } finally {
@@ -2274,12 +2293,22 @@ 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}`;
         const occurrence = verifyLineSeen.get(siteKey) || 0;
         verifyLineSeen.set(siteKey, occurrence + 1);
         const analysis = analyzeCallSite(index, call, name, occurrence);
+        if (direct) (direct.callShapes ||= []).push(analysis);
 
         // Carry callerFile/callerStartLine so tagInTestCase can resolve the
         // enclosing function in a later pass.
@@ -2340,9 +2369,10 @@ function verify(index, name, options = {}) {
         }
 
         // Check if arg count is valid
-        const countOk = hasRest
-            ? argCount >= minArgs
-            : (argCount >= minArgs && argCount <= expectedParamCount);
+        const countOk = direct && !inheritedCtorOnly
+            ? arities.some(arity => argCount >= arity.min && (arity.hasRest || argCount <= arity.max))
+            : hasRest ? argCount >= minArgs
+                : (argCount >= minArgs && argCount <= expectedParamCount);
         if (call.rebind && call.rebind.kind !== 'no-overload' && (countOk || call.rebind.kind !== 'count')) {
             // Bound the base declaration; the new one may still take it, or
             // another overload may: the compiler decides (fix #394).
@@ -2364,7 +2394,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 +2408,7 @@ function verify(index, name, options = {}) {
                 args: analysis.args,
                 patterns: patternFlagsFrom(analysis),
                 ...carry,
-            });
+            }, analysis));
             continue;
         }
 
@@ -2399,7 +2429,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 +2443,7 @@ function verify(index, name, options = {}) {
                     problem: bindingProblems.join('; '),
                     patterns: patternFlagsFrom(analysis),
                     ...carry,
-                });
+                }, analysis));
             }
             continue;
         }
@@ -2425,7 +2455,7 @@ function verify(index, name, options = {}) {
             ...carry,
         });
     }
-    clearTreeCache(index);
+    if (!direct) clearTreeCache(index);
 
     // Feature A: tag each entry with `inTestCase` based on its enclosing function.
     // Done after the per-call loop because tagInTestCase prefers a single pass
@@ -6945,4 +6975,15 @@ function _methodGroupPass(index, name, renameTo, renamedDefs, changes, usages) {
 
 const IDENTITY_TYPE_KINDS_FOR_CREF = new Set(['class', 'struct', 'interface', 'record', 'enum', 'trait', 'type']);
 
-module.exports = { verify, plan, baseCounterpartOf, sitesReboundByChange, computePlanCallSites, analyzeCallSite, analyzeCallSiteAST, analyzeCallShape, classifyArgNode, findCallNode, clearTreeCache, identifyCallPatterns };
+/** Check already-resolved call sites using exactly the signature rules of verify. */
+function verifyCallSites(index, definition, sites) {
+    const direct = { definition, sites };
+    const result = verify(index, definition.name, {}, direct);
+    Object.defineProperties(result, {
+        parameterLists: { value: direct.parameterLists },
+        callShapes: { value: direct.callShapes },
+    });
+    return result;
+}
+
+module.exports = { verify, verifyCallSites, plan, baseCounterpartOf, sitesReboundByChange, computePlanCallSites, analyzeCallSite, analyzeCallSiteAST, analyzeCallShape, classifyArgNode, findCallNode, clearTreeCache, identifyCallPatterns };

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),