ucn 5.5.1 → 5.5.3

package/core/inprocess-clients.js

@@ -195,9 +195,23 @@ class PythonClientResolver {
 
     /** The fixture named `name` a test in `file` requests: same module first,
      *  then conftest.py files from the test's directory up to the root. */
-    fixtureDef(file, name) {
-        const key = `${file}\0${name}`;
+    fixtureDef(file, name, requester = null) {
+        let owner = requester?.parent;
+        while (owner && owner.type !== 'class_definition') owner = owner.parent;
+        const key = `${file}\0${name}\0${owner?.startIndex ?? ''}`;
         if (this.fixtureMemo.has(key)) return this.fixtureMemo.get(key);
+        this.fixtureMemo.set(key, null);
+        if (owner) {
+            const matches = namedChildren(field(owner, 'body')).map(stmt =>
+                stmt.type === 'decorated_definition' ? field(stmt, 'definition') : stmt)
+                .filter(fn => fn?.type === 'function_definition' && field(fn, 'name')?.text === name);
+            if (matches.length) {
+                const found = matches.length === 1 && this.isFixture(file, matches[0])
+                    ? { file, fnNode: matches[0] } : null;
+                this.fixtureMemo.set(key, found);
+                return found;
+            }
+        }
         let found = this.moduleFixture(file, name);
         if (!found) {
             for (let dir = path.dirname(file); dir.startsWith(this.index.root); dir = path.dirname(dir)) {
@@ -213,7 +227,8 @@ class PythonClientResolver {
         return found;
     }
 
-    moduleFixture(file, name) {
+    moduleFixture(file, name, depth = 0) {
+        if (depth > MAX_HOPS) return null;
         const root = this.sess.root(file);
         if (!root) return null;
         const hits = [];
@@ -222,7 +237,12 @@ class PythonClientResolver {
             if (fn?.type === 'function_definition' && field(fn, 'name')?.text === name &&
                 this.isFixture(file, fn)) hits.push(fn);
         }
-        return hits.length === 1 ? { file, fnNode: hits[0] } : null;
+        if (hits.length) return hits.length === 1 ? { file, fnNode: hits[0] } : null;
+        const entry = this.sess.entry(file);
+        const bindings = (entry?.importBindings || []).filter(b => (b.alias || b.name) === name && !b.deferred);
+        if (bindings.length !== 1 || bindings[0].kind !== 'from') return null;
+        const relative = entry.moduleResolved?.[bindings[0].module];
+        return relative ? this.moduleFixture(path.join(this.index.root, relative), bindings[0].name, depth + 1) : null;
     }
 
     /** The expression a fixture provides: its single yielded/returned value,
@@ -253,11 +273,14 @@ class PythonClientResolver {
         if (!expr || expr.type !== 'identifier' || hops > MAX_HOPS) return { file, expr };
         if (fnNode) {
             const values = boundValues(field(fnNode, 'body'), expr.text, this.bindingMemo);
-            if (values === null) return null;
+            if (values === null) {
+                const decl = routeGraph.findDecl(this.sess, file, expr.text, expr);
+                return decl?.kind === 'function' ? { file, expr: decl.valueNode } : null;
+            }
             if (values.length === 1) return this.followBinding(file, fnNode, unwrap(values[0].node), hops + 1);
             if (values.length > 1) return null;
             if (isParameterOf(fnNode, expr.text)) {
-                const fixture = this.fixtureDef(file, expr.text);
+                const fixture = this.fixtureDef(file, expr.text, fnNode);
                 return fixture ? this.fixtureValue(fixture.file, fixture.fnNode, hops + 1) : null;
             }
         }
@@ -319,7 +342,7 @@ class PythonClientResolver {
         if (expr.type !== 'identifier') return null;
         const fnNode = enclosingFunctionNode(expr);
         if (fnNode && isParameterOf(fnNode, expr.text)) {
-            const fixture = this.fixtureDef(file, expr.text);
+            const fixture = this.fixtureDef(file, expr.text, fnNode);
             if (!fixture) return null;
             const value = this.fixtureValue(fixture.file, fixture.fnNode, hops + 1);
             if (!value?.expr) return null;
@@ -345,13 +368,8 @@ class PythonClientResolver {
         return null;
     }
 
-    /**
-     * { appKey } for a request `receiver.verb(path)` at `line` of `file` made
-     * through an in-process client, { inProcess: true } when the client is
-     * built from an app that did not resolve, else null (not a client built
-     * from an app).
-     */
-    resolve(file, line, receiver, name) {
+    /** Values bound to a request receiver, without assuming they are clients. */
+    clientValues(file, line, receiver, name) {
         const root = this.sess.root(file);
         if (!root) return null;
         const sites = requestCallNodes(root, line, receiver, name);
@@ -365,7 +383,7 @@ class PythonClientResolver {
             if (values.length > 0) {
                 clients = this.bindingInEffect(values, receiverNode).map(node => ({ file, expr: unwrap(node) }));
             } else if (isParameterOf(fnNode, receiver)) {
-                const fixture = this.fixtureDef(file, receiver);
+                const fixture = this.fixtureDef(file, receiver, fnNode);
                 const value = fixture ? this.fixtureValue(fixture.file, fixture.fnNode, 1) : null;
                 clients = value ? [value] : [];
             }
@@ -376,6 +394,14 @@ class PythonClientResolver {
                 clients = this.bindingInEffect(values, receiverNode).map(node => ({ file, expr: unwrap(node) }));
             }
         }
+        const values = clients?.map(c => this.followBinding(c.file,
+            enclosingFunctionNode(c.expr), c.expr, 0));
+        return values?.every(Boolean) ? values : null;
+    }
+
+    /** The served app key, an unresolved in-process app, or null. */
+    resolve(file, line, receiver, name) {
+        const clients = this.clientValues(file, line, receiver, name);
         if (!clients || clients.length === 0 || clients.some(c => c.expr?.type !== 'call')) return null;
         const keys = clients.map(c => this.clientAppOnce(c.file, c.expr));
         if (keys.every(key => key && key === keys[0])) {

package/core/ir.js

@@ -62,8 +62,8 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
         modifiers: [...(symbol.modifiers || [])],
     };
     const passthrough = [
-        'docstring', 'returnedFunctionResult', 'isFunctionVariable', 'paramTypes',
-        'isAsync', 'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'extends', 'implements', 'indent',
+        'docstring', 'sourceSpan', 'returnedFunctionResult', 'isFunctionVariable', 'paramTypes',
+        'isAsync', 'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'typeParameterConstraints', 'extends', 'implements', 'indent',
         'isNested', 'enclosingType', 'isMethod', 'memberType', 'fieldType', 'embedded',
         'aliasOf', 'aliasQualifier', 'aliasMembers', 'aliasTypeText', 'aliasTypeParameters', 'aliasTypeDefaults', 'derefTarget', 'decorators', 'decoratorsWithArgs',
         'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
@@ -82,7 +82,9 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
         'generatedByMacro',
         'typeArity', 'ownerTypeArity',
         'annotationType', 'valueShape', 'friendOf', 'templateParams', 'delegateParams',
-        'typedefName',
+        'typedefName', 'forwardDeclaration', 'anonymousNamespace', 'specialization',
+        'memberConst', 'refQualifier', 'fieldPointers', 'memberPaths', 'instanceAttribute',
+        'ambientAugmentation',
     ];
     for (const field of passthrough) {
         if (symbol[field] !== undefined && symbol[field] !== null) {
@@ -110,9 +112,15 @@ function createFileIR({
     const append = (symbol, family, kind, owner = null) => {
         // Members one macro invocation declares share its lines (fix #385):
         // their own binding ids keep overloads apart.
-        const key = `${owner || symbol.className || ''}\0${symbol.name}\0${kind}\0` +
-            `${symbol.startLine}\0${symbol.endLine}` +
-            (symbol.generatedByMacro ? `\0${symbol.bindingId || ''}` : '');
+        const key = JSON.stringify([
+            owner || symbol.className || '', symbol.name, kind,
+            symbol.startLine, symbol.endLine, symbol.namespace || '',
+            symbol.enclosingType || '', symbol.lexicalScopeStartLine ?? null,
+            symbol.lexicalScopeEndLine ?? null, symbol.anonymousNamespace || false,
+            symbol.typeArity ?? null, symbol.ownerTypeArity ?? null,
+            symbol.params ?? null,
+            symbol.generatedByMacro ? symbol.bindingId || '' : '',
+        ]);
         if (seen.has(key)) return;
         seen.add(key);
         normalizedSymbols.push(normalizeSymbol(symbol, family, language, kind, owner));
@@ -236,6 +244,10 @@ function createFileIR({
         ...(parsed.asyncClosureNames?.length > 0 && {
             asyncClosureNames: [...parsed.asyncClosureNames],
         }),
+        // Rust item-position macro invocations of each module (fix #422).
+        ...(parsed.itemMacros?.length > 0 && {
+            itemMacros: parsed.itemMacros.map(item => ({ ...item })),
+        }),
         // Shapes of calls whose value is not consumed where it is produced
         // (fix #371/#372): audit-async reads a file's call records only when
         // one of these can reach a future producer.
@@ -249,12 +261,18 @@ function createFileIR({
         ...(parsed.reflectionSites?.length > 0 && {
             reflectionSites: parsed.reflectionSites.map(item => ({ ...item })),
         }),
+        ...(Array.isArray(parsed.computedDispatchSites) && {
+            computedDispatchSites: parsed.computedDispatchSites.map(item => ({ ...item })),
+        }),
         ...(parsed.macroScopeMarkers?.length > 0 && {
             macroScopeMarkers: parsed.macroScopeMarkers.map(item => ({ ...item })),
         }),
         ...(parsed.cppUsings?.length > 0 && {
             cppUsings: parsed.cppUsings.map(item => ({ ...item })),
         }),
+        // Type-parameter names a file declares (fix #421), when the parser
+        // read them from the raw source.
+        ...(Array.isArray(parsed.typeParameterNames) && { typeParameterNames: [...parsed.typeParameterNames] }),
         ...(parsed.languageFeatures?.length > 0 && {
             languageFeatures: [...parsed.languageFeatures],
         }),
@@ -289,6 +307,9 @@ function createFileIR({
         }),
         // The byte ranges the C/C++ recovery blanked (fix #387): a query
         // rebuilds the recovered tree with one parse.
+        ...(Array.isArray(parsed.cppBaseSyntax) && { cppBaseSyntax: parsed.cppBaseSyntax.map(row => ({
+            ...row, syntax: row.syntax && { ...row.syntax, namespaces: [...row.syntax.namespaces], classes: [...row.syntax.classes] },
+        })) }),
         ...(Array.isArray(parsed.recoveryBlanks) && {
             recoveryBlanks: parsed.recoveryBlanks.map(range => [...range]),
         }),

package/core/macro-expansion.js

@@ -384,6 +384,37 @@ function macroBodyTokens(index, def) {
     return expansionState(index).tokensOf(def);
 }
 
+class DeclarationChoice extends Error {
+    constructor(name, definitions) { super(name); this.definitions = definitions; }
+}
+
+/** Expand every bounded macro configuration of a declaration fragment. */
+function expandDeclaration(index, file, line, source) {
+    const state = expansionState(index);
+    const pending = [new Map()], variants = [];
+    while (pending.length) {
+        const choices = pending.pop();
+        const site = { file, line, lines: index._getFileLines(file), fileState: {},
+            lookupMemo: new Map(), usedDefs: new Set(), budget: MAX_TOKENS, ambiguous: false,
+            declarationChoices: choices };
+        try {
+            const tokens = expandTokens(index, state, site, lexPP(source), new Set(), 0);
+            const text = tokens.map(token => token.v).join(' ');
+            const complete = !site.ambiguous && !tokens.some(token => token.opaque || token.noexpand);
+            if (!variants.some(variant => variant.text === text)) variants.push({ text, complete });
+        } catch (error) {
+            if (error instanceof DeclarationChoice) {
+                if (pending.length + variants.length + error.definitions.length > MAX_VARIANTS) {
+                    variants.push({ text: source, complete: false }); break;
+                }
+                for (const definition of error.definitions) pending.push(new Map(choices).set(error.message, definition));
+            } else if (error instanceof BlindExpansion) variants.push({ text: source, complete: false });
+            else throw error;
+        }
+    }
+    return { ...variants[0], complete: variants.length === 1 && variants[0].complete, variants };
+}
+
 /** Does an invocation with `args` fit the macro's parameter list? */
 function arityFits(def, args) {
     const params = def.ppParams || [];
@@ -508,7 +539,12 @@ function expandTokens(index, state, site, tokens, hide, depth) {
             out.push({ ...t, noexpand: true });
             continue;
         }
-        const scope = definitionsInScope(index, state, site, t.v);
+        let scope = definitionsInScope(index, state, site, t.v);
+        if (site.declarationChoices && scope.defs.length > 1 && !scope.truncated) {
+            const chosen = site.declarationChoices.get(t.v);
+            if (!chosen) throw new DeclarationChoice(t.v, scope.defs);
+            scope = { defs: [chosen], ambiguous: false, truncated: false };
+        }
         let def = scope.defs[0];
         if (!def) {
             out.push(t);
@@ -1413,4 +1449,4 @@ function macroExpansionSummary(index) {
 }
 
 module.exports = { withMacroExpansion, macroExpansionSummary, expansionState, persistableMacroExpansion,
-    macroDefinitionsAt, macroBodyTokens, codeTokens, pastedNameSites };
+    macroDefinitionsAt, macroBodyTokens, expandDeclaration, codeTokens, pastedNameSites };

package/core/out-of-class-members.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * core/out-of-class-members.js - constructors defined outside their class
+ * body (fix #421): the C++ header + source layout, where `W::W(int)` in
+ * w.cpp defines the `W(int)` its class declares in w.h (trait
+ * `outOfClassMemberDefinitions`).
+ *
+ * The constructor family of a class is its in-class declarations; an
+ * out-of-class definition holds the body of exactly one of them. Linkage is
+ * by the owner's scope path, textual visibility of the class (same file or
+ * include closure) and the declaration's parameter signature. Anything less
+ * certain links nothing: the caller keeps its review result.
+ */
+
+const { langTraits } = require('../languages');
+
+const OWNER_KINDS = new Set(['class', 'struct', 'union']);
+
+const scopePath = def => [def.namespace, def.enclosingType].filter(Boolean).join('::');
+
+const outOfClassLanguage = (index, file) => !!langTraits(index.files.get(file)?.language)?.outOfClassMemberDefinitions;
+const applies = (index, def) => !!def?.className && outOfClassLanguage(index, def.file);
+
+function memo(index, name) {
+    return index.isProvenanceFactIndex ? null : index._opMemo?.(name, () => new WeakMap());
+}
+
+/** A definition outside every class body (its symbol's span lies in no owner). */
+function isOutOfClass(index, def) {
+    const { ownerDefinitionOf } = require('./class-identity');
+    return !def.isSignature && !ownerDefinitionOf(index, def);
+}
+
+/**
+ * The class an out-of-class constructor definition belongs to: the one
+ * class of its name whose scope path equals the definition's qualifier and
+ * that the definition's file sees. Null when none or several qualify.
+ */
+function definitionOwner(index, def) {
+    if (!applies(index, def) || !isOutOfClass(index, def)) return null;
+    const saved = memo(index, 'outOfClassOwner');
+    if (saved?.has(def)) return saved.get(def);
+    const visible = require('./cpp-scope').includeClosure(index, def.file);
+    const path = scopePath(def);
+    const owners = (index.symbols.get(def.className) || []).filter(owner => OWNER_KINDS.has(owner.type) &&
+        !owner.forwardDeclaration && scopePath(owner) === path && visible.has(owner.file));
+    const owner = owners.length === 1 ? owners[0] : null;
+    saved?.set(def, owner);
+    return owner;
+}
+
+/** The in-class constructor declaration an out-of-class definition defines. */
+function declarationOf(index, def) {
+    const owner = definitionOwner(index, def);
+    if (!owner) return null;
+    const { ownConstructors } = require('./constructor-calls');
+    const { _cFamilySignatureKey } = require('./callers');
+    const key = _cFamilySignatureKey(def);
+    const declared = ownConstructors(index, owner).filter(member => member.isSignature &&
+        _cFamilySignatureKey(member) === key);
+    return declared.length === 1 ? declared[0] : null;
+}
+
+/**
+ * The definition holding the body of an in-class constructor declaration:
+ * the declaration itself when it has a body, else its one linked
+ * out-of-class definition (null when there is none or several).
+ */
+function bodyDefinitionOf(index, declaration) {
+    if (!declaration?.isSignature || !applies(index, declaration)) return declaration;
+    const saved = memo(index, 'outOfClassBody');
+    if (saved?.has(declaration)) return saved.get(declaration);
+    const definitions = (index.symbols.get(declaration.name) || []).filter(def => def !== declaration &&
+        def.type === declaration.type && def.className === declaration.className && !def.isSignature &&
+        declarationOf(index, def) === declaration);
+    const body = definitions.length === 1 ? definitions[0] : null;
+    saved?.set(declaration, body);
+    return body;
+}
+
+/** The out-of-class constructor definition enclosing a call record of `file`. */
+function enclosingDefinition(index, file, call, owner) {
+    const enclosing = call.enclosingFunction;
+    if (!enclosing || !outOfClassLanguage(index, file)) return null;
+    const matches = (index.files.get(file)?.symbols || []).filter(def => def.name === owner.name &&
+        def.className === owner.name && !def.isSignature && def.startLine === enclosing.startLine &&
+        def.endLine === enclosing.endLine && require('./constructor-calls').isConstructor(def, index));
+    return matches.length === 1 && definitionOwner(index, matches[0]) === owner ? matches[0] : null;
+}
+
+/**
+ * Does a mem-initializer of an out-of-class constructor definition
+ * (parser `memberInitializer`) initialize a data member rather than
+ * construct a base (fix #421)? A name that is no project type, or a field
+ * of the definition's class, is a member; the record is then no call.
+ */
+function initializesMember(index, file, call, namesType) {
+    if (!call.memberInitializer) return false;
+    if (!namesType(call.name)) return true;
+    const enclosing = call.enclosingFunction;
+    if (!enclosing) return false;
+    const { isConstructor } = require('./constructor-calls');
+    const definitions = (index.files.get(file)?.symbols || []).filter(def => !def.isSignature &&
+        def.startLine === enclosing.startLine && def.endLine === enclosing.endLine && isConstructor(def, index));
+    const owner = definitions.length === 1 ? definitionOwner(index, definitions[0]) : null;
+    return !!owner && (index.symbols.get(call.name) || []).some(def => def.className === owner.name &&
+        def.file === owner.file && def.startLine >= owner.startLine && def.endLine <= owner.endLine &&
+        (def.type === 'field' || def.memberType === 'field'));
+}
+
+/**
+ * The project bases an out-of-class constructor definition leaves to
+ * implicit construction (fix #421): its class's written bases that none of
+ * its mem-initializers names, none when it delegates. `isProjectType(name)`
+ * keeps the bases the project declares.
+ */
+function omittedBases(index, def, isProjectType) {
+    const owner = definitionOwner(index, def);
+    if (!owner?.extends) return [];
+    const { getCachedCalls } = require('./callers');
+    const { splitParentList } = require('./graph-build');
+    const initializers = (getCachedCalls(index, def.file) || []).filter(call => call.constructorSyntax === 'delegation' &&
+        call.line >= def.startLine && call.line <= def.endLine &&
+        call.enclosingFunction?.startLine === def.startLine && call.enclosingFunction?.endLine === def.endLine);
+    if (initializers.some(call => call.ctorDelegation === 'this')) return [];
+    const initialized = new Set(initializers.map(call => call.name));
+    return splitParentList(owner.extends).map(spelling => {
+        const parts = String(spelling).replace(/<.*$/s, '').trim().split('::');
+        const name = parts.pop().trim();
+        return { name, qualifier: parts.join('::') || null };
+    }).filter(base => base.name && !initialized.has(base.name) && isProjectType(base.name));
+}
+
+/**
+ * Call records for the omitted base initializers of an out-of-class
+ * constructor definition (fix #421): the base's default constructor runs
+ * there, read from the class declaration in another place, so the site is
+ * a visible unverified candidate (`implicitOutOfClass`), never a confirmed
+ * edge.
+ */
+function implicitBaseRecords(index, def, isProjectType) {
+    if (!applies(index, def) || def.isSignature || !require('./constructor-calls').isConstructor(def, index)) return [];
+    const saved = memo(index, 'outOfClassImplicitBases');
+    if (saved?.has(def)) return saved.get(def);
+    const records = omittedBases(index, def, isProjectType).map(base => ({
+        name: base.name, line: def.startLine, isMethod: false, isConstructor: true,
+        constructorSyntax: 'implicit', argCount: 0, argKinds: [],
+        ...(base.qualifier && { constructorQualifier: base.qualifier }),
+        implicitOutOfClass: { owner: def.className },
+        enclosingFunction: { name: def.name, startLine: def.startLine, endLine: def.endLine, className: def.className },
+    }));
+    saved?.set(def, records);
+    return records;
+}
+
+/**
+ * The out-of-class constructor definitions of classes derived from `base`
+ * that construct it implicitly (fix #421), as unverified caller rows.
+ */
+function implicitBaseCallerRows(index, base, isProjectType) {
+    if (!outOfClassLanguage(index, base.file)) return [];
+    const rows = [];
+    const derived = new Set((index.extendedByGraph?.get(base.name) || [])
+        .map(child => typeof child === 'string' ? child : child.name));
+    for (const name of [...derived].sort()) {
+        for (const def of index.symbols.get(name) || []) {
+            if (def.className !== name || def.isSignature || !require('./constructor-calls').isConstructor(def, index)) continue;
+            const owner = definitionOwner(index, def);
+            if (!owner || !implicitBaseRecords(index, def, isProjectType).some(record => record.name === base.name)) continue;
+            // The derived class's written base must be this class.
+            const { resolveClassRef } = require('./class-identity');
+            const ref = resolveClassRef(index, base.name, owner.file);
+            if (ref?.def && ref.def !== base) continue;
+            rows.push(def);
+        }
+    }
+    return rows;
+}
+
+module.exports = { definitionOwner, declarationOf, bodyDefinitionOf, enclosingDefinition, initializesMember,
+    implicitBaseRecords, implicitBaseCallerRows };

package/core/output/analysis-ext.js

@@ -3,7 +3,7 @@
  */
 
 const { dynamicImportsNote, formatLineRanges, unverifiedReasonLabel, advisoryLine } = require('./shared');
-const { formatAccountLines, formatCalleeAccountLine, unverifiedCalleeLines } = require('./analysis');
+const { formatAccountLines, formatCalleeAccountLine, unverifiedCalleeLines, initializerReviewLines } = require('./analysis');
 
 /**
  * Format related command output - text
@@ -146,6 +146,7 @@ function formatSmart(smart, options = {}) {
     // v4 callee contract: unresolved calls inside the target — visible with
     // reasons (they may be dependencies smart could not inline).
     lines.push(...unverifiedCalleeLines(smart.unverifiedCallees, false));
+    lines.push(...initializerReviewLines(smart.initializerReviews, false));
     const smartCalleeAcct = formatCalleeAccountLine(smart.meta && smart.meta.calleeAccount);
     if (smartCalleeAcct) lines.push(`\n${smartCalleeAcct}`);
 
@@ -185,7 +186,8 @@ function formatSmartJson(result) {
             types: result.types || [],
             // v4 callee contract: visible unresolved-call entries, reconciled
             // by meta.calleeAccount.
-            unverifiedCallees: result.unverifiedCallees || []
+            unverifiedCallees: result.unverifiedCallees || [],
+            ...(result.initializerReviews?.length && { initializerReviews: result.initializerReviews }),
         }
     });
 }