ucn 5.5.1 → 5.5.2

package/core/search.js

@@ -72,28 +72,28 @@ function appendTextComplements(index, {
         .filter(usage => usage.file === filePath)
         .map(usage => usage.line));
     const pattern = literalNameRegex(name);
+    let syntax;
     for (let idx = 0; idx < lines.length; idx++) {
         const line = lines[idx];
         const match = pattern.exec(line);
         if (!match || represented.has(idx + 1)) continue;
         const lineNum = idx + 1;
-        const commentOrString = index.isCommentOrStringAtPosition(
-            content, lineNum, match.index, filePath);
+        syntax ||= require('./text-usage-syntax').textUsageSyntax(index, filePath, fileEntry, content, name);
+        const textKind = syntax.kind(lineNum, match.index);
         // A literal match that no AST identifier record claimed and that is
         // not inside a comment or string is non-code text: JSX children,
         // HTML markup and attributes, regex bodies. The ACCOUNT counts these
         // lines as other-text; the escape hatch must list them too. A line
         // the AST scan classified and then deliberately dropped (Rust enum
         // variants against a struct pin, #234) is code, not text: skip it.
-        if (!commentOrString &&
-            index.isIdentifierAtPosition(content, lineNum, match.index, filePath, name)) continue;
+        if (textKind === 'identifier') continue;
         const usage = {
             file: filePath,
             relativePath: fileEntry.relativePath,
             line: lineNum,
             content: line,
             usageType: 'text',
-            textKind: commentOrString ? 'comment-or-string' : 'markup-or-text',
+            textKind,
             isDefinition: false,
         };
         if (context > 0) {
@@ -106,6 +106,7 @@ function appendTextComplements(index, {
         }
         usagesList.push(usage);
     }
+    syntax?.save();
 }
 
 /**
@@ -339,9 +340,11 @@ function usages(index, name, options = {}) {
                 options.internalEvidence ? { lexicalScopes: true } : undefined);
             if (astUsages !== null) {
                 for (const u of astUsages) {
-                    // Skip if this is a definition line (already added above)
+                    // Public usages groups declaration lines into their definition
+                    // entry. Refactoring needs every other AST token on that line.
                     if (definitions.some(d => d.file === filePath &&
-                        (d.startLine === u.line || d.nameLine === u.line))) {
+                        (d.startLine === u.line || d.nameLine === u.line)) &&
+                        (!options.internalEvidence || u.usageType === 'definition' || u.declarationName)) {
                         continue;
                     }
 
@@ -375,13 +378,22 @@ function usages(index, name, options = {}) {
                         // plan gains precision without changing that surface.
                         ...(options.internalEvidence && {
                             ...(Number.isInteger(u.column) && { column: u.column }),
+                            ...(u.receiverType && {
+                                receiverType: u.receiverType,
+                                ...(u.receiverTypeQualifier && { receiverTypeQualifier: u.receiverTypeQualifier }),
+                                ...(Number.isInteger(u.receiverTypeArgs) && { receiverTypeArgs: u.receiverTypeArgs }),
+                            }),
                             ...(u.receiverIsModule && { receiverIsModule: true }),
                             ...(u.receiverLocalBinding && { receiverLocalBinding: true }),
+                            // A path-qualified reference (`T::m`, fix #422).
+                            ...(u.scopedReference && { scopedReference: true }),
                             ...(u.namespace && { namespace: u.namespace }),
                             ...(u.scopeBinding && { scopeBinding: u.scopeBinding }),
                             ...(u.scopeDefLines && { scopeDefLines: u.scopeDefLines }),
                             ...(u.shorthandProperty && { shorthandProperty: true }),
                             ...(u.importAlias && { importAlias: true }),
+                            ...(u.modulePath && { modulePath: true }),
+                            ...(u.importSource && { importSource: true }),
                         }),
                         ...(callerSym && {
                             callerName: callerSym.name,
@@ -587,7 +599,7 @@ function search(index, term, options = {}) {
 
             // Use AST-based filtering for codeOnly mode when language is supported
             if (options.codeOnly) {
-                const language = detectLanguage(filePath);
+                const language = fileEntry.language || detectLanguage(filePath, index.root);
                 if (language) {
                     try {
                         const parser = getParser(language);
@@ -1323,6 +1335,11 @@ function tests(index, nameOrFile, options = {}) {
     } else if (!isFilePath) {
         targetDefs = index.find(nameOrFile, { exact: true, className: options.className });
     }
+    // A pinned definition among same-name ones (an overload, a constructor
+    // beside its class and siblings, fix #430): calls are this definition's
+    // only when the caller engine attributes them to it.
+    const pinnedFamily = !isFilePath && options.definition && targetDefs.length > 1;
+    if (!isFilePath && options.definition) targetDefs = [options.definition];
 
     // Find all test files
     const testFiles = [];
@@ -1522,6 +1539,7 @@ function tests(index, nameOrFile, options = {}) {
                 // own definition (fix #246).
                 if (localShadow && !usage.receiver && usage.usageType !== 'import') continue;
 
+                if (pinnedFamily && usage.usageType === 'call') continue;
                 // A line is claimed only by a usage that is recorded: two
                 // same-kind tokens on one line (`a.m = b.m`) are judged
                 // separately, so a rejected first token never hides a
@@ -1550,10 +1568,14 @@ function tests(index, nameOrFile, options = {}) {
                 // className scoping for references: require class-associated receiver
                 if (className && (matchType === 'reference' || matchType === 'string-ref' ||
                     matchType === 'unverified-reference')) {
-                    // Bare references (no receiver) like `fn = save` have no class
-                    // association — skip them. Only keep member-access references
-                    // where the receiver matches the target class.
-                    if (!usage.receiver && matchType !== 'unverified-reference') continue;
+                    // A bare name can bind an earlier class-body method.
+                    // Other references need a receiver matching the target.
+                    if (!usage.receiver && matchType !== 'unverified-reference') {
+                        if (!classBodyReferenceTargets(index, testPath, entry.language, usage, targetDefs)) continue;
+                        seenLines.add(lineKey);
+                        matches.push({ line: usage.line, content: lineContent.trim(), matchType: 'reference' });
+                        continue;
+                    }
                     if (!usage.receiver && matchType === 'unverified-reference') {
                         seenLines.add(lineKey);
                         matches.push({
@@ -1685,7 +1707,9 @@ function tests(index, nameOrFile, options = {}) {
     if (!isFilePath && targetDefs.length > 0) {
         const testInfo = new Map(testFiles.map(t => [t.path, t]));
         const callerSites = [];
-        const globallyUniqueTarget = index.find(searchTerm, { exact: true }).length === 1;
+        // A pinned definition's unverified sites were adjudicated against it
+        // alone, like a globally unique name's (fix #430).
+        const globallyUniqueTarget = !!options.definition || index.find(searchTerm, { exact: true }).length === 1;
         for (const def of targetDefs) {
             const raw = index.findCallers(searchTerm, {
                 targetDefinitions: [def],
@@ -1750,15 +1774,27 @@ function tests(index, nameOrFile, options = {}) {
         // receiver identity the accessor engine proves are test links; the
         // unverified ones join only for a globally unique name, as above.
         const accessorDefs = targetDefs.filter(isAccessorDefinition);
-        if (accessorDefs.length > 0) {
+        // A nested type's annotations and qualifiers are type references,
+        // not instance-member accesses of its containing class. Reuse the
+        // same language lookup as impact instead of requiring a receiver.
+        const nestedTypeDefs = targetDefs.filter(def => def.enclosingType &&
+            ['class', 'struct', 'interface', 'type', 'enum', 'trait', 'record', 'union'].includes(def.type));
+        if (accessorDefs.length > 0 || nestedTypeDefs.length > 0) {
             const testPaths = new Set(testFiles.map(t => t.path));
             const globallyUnique = index.find(searchTerm, { exact: true }).length === 1;
-            for (const def of accessorDefs) {
-                const refs = findAccessorReferences(index, searchTerm, def, { files: testPaths });
+            for (const def of [...accessorDefs, ...nestedTypeDefs]) {
+                const types = nestedTypeDefs.includes(def)
+                    ? require('./analysis').findTypeReferences(index, searchTerm, def, { files: testPaths }) : null;
+                const typeSite = site => ({ ...site, absoluteFile: path.join(index.root, site.file) });
+                const refs = types ? {
+                    confirmed: types.byFile.flatMap(group => group.sites).map(typeSite),
+                    unverified: types.unverifiedSites.map(typeSite),
+                } : findAccessorReferences(index, searchTerm, def, { files: testPaths });
                 if (!refs) continue;
                 const rows = [
                     ...refs.confirmed.map(r => ({ ...r, tierName: 'confirmed' })),
-                    ...(globallyUnique ? refs.unverified.map(r => ({ ...r, tierName: 'unverified' })) : []),
+                    ...(globallyUnique || types && options.definition
+                        ? refs.unverified.map(r => ({ ...r, tierName: 'unverified' })) : []),
                 ];
                 for (const ref of rows) {
                     const info = testInfo.get(ref.absoluteFile);
@@ -2092,6 +2128,23 @@ function _buildInstanceTypeMap(index, filePath, content, targetClassName) {
     return typeMap;
 }
 
+/** A bare name bound by one preceding declaration in a Python class body. */
+function classBodyReferenceTargets(index, file, language, usage, targets) {
+    if (!langTraits(language)?.assignmentDeclaresLocal || !targets.length) return false;
+    const tree = index._getParsedTree(file, index._readFile(file), language);
+    if (!tree) return false;
+    const node = tree.rootNode.namedDescendantForPosition({ row: usage.line - 1, column: usage.column });
+    const owner = require('./value-references').pythonClassBodyOf(node);
+    if (!owner) return false;
+    const { pythonBindingSites, pythonClassBodyOrder } = require('../languages/lexical-scope');
+    const bindings = pythonBindingSites(owner, node.text);
+    if (bindings.length !== 1 || pythonClassBodyOrder(owner, node, node.text) !== 'class') return false;
+    const binding = bindings[0];
+    return targets.some(def => def.file === file && def.name === node.text &&
+        def.startLine >= owner.startPosition.row + 1 && def.endLine <= owner.endPosition.row + 1 &&
+        binding.startPosition.row + 1 === (def.nameLine || def.startLine));
+}
+
 /**
  * Check if a usage's receiver matches the target className.
  * Uses direct receiver check and instance type map for indirect bindings.

package/core/shared.js

@@ -7,6 +7,11 @@ const path = require('path');
 const { isTestFile } = require('./discovery');
 const { detectLanguage } = require('./parser');
 
+// Modules read lazily (load cycles), each resolved once: a require() per
+// call in hot paths was measurable (fix #436).
+let lazyLanguagesModuleCache = null;
+const lazyLanguagesModule = () => lazyLanguagesModuleCache || (lazyLanguagesModuleCache = require('../languages'));
+
 /**
  * Security containment check (fix #285): is `candidate` inside `root`?
  *
@@ -63,7 +68,7 @@ function isTestPath(rp) {
     // has a `.spec` form, only C's patterns name `.h`): no header-language
     // detection, which walks the project directory (fix #396).
     const language = path.extname(rp).toLowerCase() === '.h' ? 'c' : detectLanguage(rp);
-    const { langTraits } = require('../languages');
+    const { langTraits } = lazyLanguagesModule();
     const specConvention = langTraits(language)?.testFileCandidates?.('sample', '')
         .some(candidate => candidate.includes('.spec'));
     return isTestFile(rp, language) ||
@@ -148,6 +153,22 @@ function escapeRegExp(text) {
 
 // Symbol types that are not callable (used to filter class/struct/type declarations from call analysis)
 const NON_CALLABLE_TYPES = new Set(['class', 'struct', 'interface', 'type', 'enum', 'trait', 'state', 'impl', 'field']);
+const VALUE_SYMBOL_KINDS = new Set(['field', 'private field', 'constant', 'state', 'variant']);
+
+/**
+ * A member a call can name (fix #423): a callable kind, or a class field the
+ * parser read as a function (`reset = () => {..}`, `isMethod`), which
+ * `form.reset()` and `this.reset()` call like a method.
+ */
+function isCallableMember(definition) {
+    return !!definition && (!NON_CALLABLE_TYPES.has(definition.type) ||
+        (definition.type === 'field' && definition.isMethod === true));
+}
+
+function isValueDefinition(definition) {
+    return !!definition && !definition.isMethod &&
+        (VALUE_SYMBOL_KINDS.has(definition.type) || VALUE_SYMBOL_KINDS.has(definition.memberType));
+}
 
 /**
  * Every function-shaped symbol kind across the parsers (fix #251 — stats
@@ -501,7 +522,81 @@ function isMacroNamespaceDefinition(def) {
         modifiers.includes('proc_macro_derive');
 }
 
+/** The names the inverted call index records, in first-occurrence order. */
+function calleeNames(calls) {
+    const names = new Set();
+    for (const call of calls || []) {
+        names.add(call.name);
+        if (call.resolvedName) names.add(call.resolvedName);
+        for (const name of call.resolvedNames || []) names.add(name);
+        if (call.ownClass) names.add(call.ownClass.name);
+        if (call.receiverIsTypeQualified && call.receiver) names.add(call.receiver);
+    }
+    return names;
+}
+
+// Declarations whose line extent holds a line, by symbol list (fix #418:
+// per-site scans of a whole symbol table made construction and namespace
+// lookups quadratic in large files). An index belongs to one list; a list
+// whose length or ends changed gets a new one.
+const SPAN_INDEXES = new WeakMap();
+
+function spanIndexOf(symbols) {
+    const known = SPAN_INDEXES.get(symbols);
+    if (known && known.length === symbols.length && known.first === symbols[0] &&
+        known.last === symbols[symbols.length - 1]) return known;
+    const regular = [], irregular = [];
+    for (let i = 0; i < symbols.length; i++) {
+        const symbol = symbols[i];
+        if (Number.isFinite(symbol?.startLine) && Number.isFinite(symbol?.endLine)) regular.push(i);
+        else irregular.push(i);
+    }
+    regular.sort((a, b) => symbols[a].startLine - symbols[b].startLine || a - b);
+    const starts = regular.map(i => symbols[i].startLine), ends = regular.map(i => symbols[i].endLine);
+    const maxEnd = new Array(regular.length);
+    const build = (lo, hi) => {
+        if (lo >= hi) return -Infinity;
+        const mid = (lo + hi) >> 1;
+        return (maxEnd[mid] = Math.max(ends[mid], build(lo, mid), build(mid + 1, hi)));
+    };
+    build(0, regular.length);
+    const index = { length: symbols.length, first: symbols[0], last: symbols[symbols.length - 1],
+        regular, starts, ends, maxEnd, irregular };
+    SPAN_INDEXES.set(symbols, index);
+    return index;
+}
+
+/**
+ * The symbols of `symbols` whose extent holds `line` (the comparisons
+ * `!(startLine > line) && !(endLine < line)`), in list order.
+ */
+function symbolsSpanning(symbols, line) {
+    if (!Array.isArray(symbols) || symbols.length === 0) return [];
+    const index = spanIndexOf(symbols);
+    const found = [];
+    const visit = (lo, hi) => {
+        if (lo >= hi) return;
+        const mid = (lo + hi) >> 1;
+        if (index.maxEnd[mid] < line) return;
+        visit(lo, mid);
+        if (index.starts[mid] > line) return;
+        if (index.ends[mid] >= line) found.push(index.regular[mid]);
+        visit(mid + 1, hi);
+    };
+    if (Number.isFinite(line)) visit(0, index.regular.length);
+    else for (let i = 0; i < index.regular.length; i++) {
+        if (!(index.starts[i] > line) && !(index.ends[i] < line)) found.push(index.regular[i]);
+    }
+    for (const i of index.irregular) {
+        const symbol = symbols[i];
+        if (!(symbol?.startLine > line) && !(symbol?.endLine < line)) found.push(i);
+    }
+    return found.sort((a, b) => a - b).map(i => symbols[i]);
+}
+
 module.exports = { literalNameRegex,
+    symbolsSpanning,
+    calleeNames,
     pickBestDefinition,
     addTestExclusions,
     escapeRegExp,
@@ -511,6 +606,8 @@ module.exports = { literalNameRegex,
     classDispatchNames,
     maskBlockComments,
     NON_CALLABLE_TYPES,
+    isCallableMember,
+    isValueDefinition,
     CALLABLE_SYMBOL_KINDS,
     formatSymbolHandle,
     parseSymbolHandle,

package/core/source-memo.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+
+// Bounded memos and source identities shared by the query-time syntax
+// caches (fix #418). A memo keys a value by the exact input that determines
+// it (a source text, a parsed view), never by a binding or ownership verdict.
+
+/** A least-recently-used map bounded by entry count and by total weight. */
+class BoundedMap {
+    constructor({ maxEntries = Infinity, maxWeight = Infinity, weigh = null } = {}) {
+        this.maxEntries = maxEntries;
+        this.maxWeight = maxWeight;
+        this.weigh = weigh;
+        this.entries = new Map();
+        this.weight = 0;
+    }
+
+    get size() { return this.entries.size; }
+
+    has(key) { return this.entries.has(key); }
+
+    /** The value, made most recently used; undefined when absent. */
+    get(key) {
+        const entry = this.entries.get(key);
+        if (entry === undefined) return undefined;
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry.value;
+    }
+
+    /** Store a value; one heavier than the whole bound is not kept. */
+    set(key, value) {
+        const weight = this.weigh ? this.weigh(value, key) : 0;
+        this.delete(key);
+        if (weight > this.maxWeight) return false;
+        while (this.entries.size > 0 && (this.entries.size >= this.maxEntries ||
+            this.weight + weight > this.maxWeight)) {
+            this.delete(this.entries.keys().next().value);
+        }
+        this.entries.set(key, { value, weight });
+        this.weight += weight;
+        return true;
+    }
+
+    delete(key) {
+        const entry = this.entries.get(key);
+        if (entry === undefined) return false;
+        this.entries.delete(key);
+        this.weight -= entry.weight;
+        return true;
+    }
+
+    clear() {
+        this.entries.clear();
+        this.weight = 0;
+    }
+
+    *[Symbol.iterator]() {
+        for (const [key, entry] of this.entries) yield [key, entry.value];
+    }
+}
+
+/**
+ * A memo of facts derived from a source text in one language. The text is
+ * the key itself, so a lookup never builds a key string as long as the
+ * source; its weight counts the retained text.
+ */
+class SourceMemo {
+    constructor({ maxEntries = 256, maxWeight = 32 * 1024 * 1024, weigh = () => 0 } = {}) {
+        this.memo = new BoundedMap({ maxEntries, maxWeight,
+            weigh: (byLanguage, source) => source.length * 2 + [...byLanguage.values()].reduce(
+                (sum, value) => sum + weigh(value), 0) });
+    }
+
+    get(language, source) {
+        return this.memo.get(source)?.get(language);
+    }
+
+    set(language, source, value) {
+        const byLanguage = new Map(this.memo.get(source) || []);
+        byLanguage.set(language, value);
+        this.memo.set(source, byLanguage);
+        return value;
+    }
+}
+
+// Parsed trees of recently read sources, by grammar. A tree is immutable
+// and collected by the runtime; a reader never edits one. Readers that ask
+// for whole-file syntax at many sites of the same few files share a parse
+// (fix #418: an overload check parsed both of its files for every argument).
+const parsedSources = new SourceMemo({ maxEntries: 32, maxWeight: 64 * 1024 * 1024 });
+
+/** The tree of `source` in the grammar `language`, or null when it cannot parse. */
+function parsedSource(language, source) {
+    if (typeof source !== 'string') return null;
+    let tree = parsedSources.get(language, source);
+    if (tree === undefined) {
+        const { getParser, safeParse } = require('../languages');
+        tree = safeParse(getParser(language), source) || null;
+        parsedSources.set(language, source, tree);
+    }
+    return tree;
+}
+
+// One stat per file per operation (fix #365), for every reader of the
+// operation (fix #418: the call-name cache stated a file per query).
+const OPERATION_STATS = new WeakMap(); // operation content cache -> Map<file, mtimeMs>
+
+/** The file's mtime, read once per operation; throws as statSync does. */
+function fileMtime(index, file) {
+    const scope = index._opContentCache;
+    let memo = scope ? OPERATION_STATS.get(scope) : null;
+    if (scope && !memo) OPERATION_STATS.set(scope, memo = new Map());
+    let mtime = memo?.get(file);
+    if (mtime === undefined) {
+        mtime = fs.statSync(file).mtimeMs;
+        memo?.set(file, mtime);
+    }
+    return mtime;
+}
+
+/** The SHA-256 of the JSON of `parts`: a view or option identity. */
+function digestOf(parts) {
+    return crypto.createHash('sha256').update(JSON.stringify(parts)).digest('hex');
+}
+
+/**
+ * Does `content` equal the source the index read for `file`? One hash per
+ * file and content in an operation (every syntax cache of an operation
+ * asks it of the same files).
+ */
+function indexedContent(index, file, entry, content) {
+    if (!entry?.hash || typeof content !== 'string') return false;
+    const memo = !index.isProvenanceFactIndex && typeof index._opMemo === 'function'
+        ? index._opMemo('indexedContent', () => new Map()) : null;
+    const saved = memo?.get(file);
+    if (saved && saved.content === content && saved.hash === entry.hash) return saved.fresh;
+    const fresh = crypto.createHash('md5').update(content).digest('hex') === entry.hash;
+    memo?.set(file, { content, hash: entry.hash, fresh });
+    return fresh;
+}
+
+/**
+ * Are the type names written in `file` usable as the index read them (trait
+ * `typeNameSourceCanonical` of `language`)? The index's own parse of the
+ * same content tells whether it had errors, so most sources need no second
+ * parse (fix #418). `lines` (`{ startLine, endLine }`) asks about the names
+ * of that line range only: a parse error confined to another member does not
+ * reach them (fix #421).
+ */
+function typeNamesCanonical(index, file, canonical, language, lines = null) {
+    const source = index._readFile(file);
+    // The verdict is the same with or without the hint, so a witness view
+    // takes it unrecorded from its live index; its replay derives it again.
+    const hint = live => {
+        const entry = live.files.get(file);
+        return entry?.language === language && indexedContent(live, file, entry, source)
+            ? !!entry.parseRecovery : undefined;
+    };
+    return canonical(source, () => index.isProvenanceFactIndex ? index.unrecordedHint(hint) : hint(index), lines);
+}
+
+/** The parsed views of a file: grammar, configured views, recovery blanks and external macro scope. */
+function parseViewParts(entry, language = entry.language) {
+    return [language, entry.conditionalViews, entry.recoveryBlanks, entry.externalMacroKey];
+}
+
+/**
+ * Persisted source-only syntax caches (fix #415): each family's mode
+ * prefix and the weight of one stored value in the usage-result LRU.
+ * A producer names its mode through `syntaxMode`, so a version bump in a
+ * prefix keeps its weight.
+ */
+const SYNTAX_FAMILIES = Object.freeze({
+    callToken: { prefix: 'call-token-v1', weight: 'rows' },
+    declarationToken: { prefix: 'declaration-token-v1', weight: 'rows' },
+    contractSyntax: { prefix: 'contract-syntax-v1', weight: 'json' },
+    usageText: { prefix: 'usage-text-v2', weight: 'json' },
+    enumSyntax: { prefix: 'enum-syntax-v2', weight: 'json' },
+    valueLocal: { prefix: 'value-local-v3', weight: 'json' },
+    valueBodies: { prefix: 'value-bodies-v4', weight: 'json' },
+    classFields: { prefix: 'class-fields-v1', weight: 'json' },
+});
+
+/** A family's mode: its prefix, an optional qualifier and the digest of `parts`. */
+function syntaxMode(family, parts, qualifier = null) {
+    return `${SYNTAX_FAMILIES[family].prefix}:${qualifier === null ? '' : `${qualifier}:`}${digestOf(parts)}`;
+}
+
+function syntaxWeightKind(mode) {
+    const prefix = String(mode).split(':', 1)[0];
+    for (const family of Object.values(SYNTAX_FAMILIES)) {
+        if (family.prefix === prefix) return family.weight;
+    }
+    return null;
+}
+
+module.exports = { BoundedMap, SourceMemo, parsedSource, fileMtime, digestOf, indexedContent, typeNamesCanonical, parseViewParts,
+    SYNTAX_FAMILIES, syntaxMode, syntaxWeightKind };

package/core/text-usage-syntax.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const cache = require('./cache');
+const { indexedContent, parseViewParts, syntaxMode } = require('./source-memo');
+
+/** Source positions only; no binding or ownership decisions are retained. */
+function textUsageSyntax(index, file, entry, content, name) {
+    const eligible = entry.hash && index._usageResultCache && !index.isProvenanceFactIndex &&
+        indexedContent(index, file, entry, content);
+    const mode = eligible ? syntaxMode('usageText', parseViewParts(entry)) : null;
+    const stored = eligible ? cache.getUsageResult(index, file, name, mode) : null;
+    const facts = new Map();
+    if (Array.isArray(stored) && stored.every(fact => Array.isArray(fact) && fact.length === 3 &&
+        Number.isInteger(fact[0]) && fact[0] > 0 && Number.isInteger(fact[1]) && fact[1] >= 0 &&
+        ['identifier', 'comment-or-string', 'markup-or-text'].includes(fact[2]))) {
+        for (const fact of stored) facts.set(fact[0], fact);
+    }
+    let dirty = false;
+    return {
+        kind(line, column) {
+            const saved = facts.get(line);
+            if (saved?.[1] === column) return saved[2];
+            const kind = index.isCommentOrStringAtPosition(content, line, column, file)
+                ? 'comment-or-string'
+                : index.isIdentifierAtPosition(content, line, column, file, name)
+                    ? 'identifier' : 'markup-or-text';
+            facts.set(line, [line, column, kind]);
+            dirty = true;
+            return kind;
+        },
+        save() {
+            if (eligible && dirty) cache.storeUsageResult(index, file, name, mode,
+                [...facts.values()].sort((a, b) => a[0] - b[0]));
+        },
+    };
+}
+
+module.exports = { textUsageSyntax };

package/core/tracing.js

@@ -231,6 +231,11 @@ function trace(index, name, options = {}) {
                     }
                 }
             }
+            // A construction whose constructor body is undecided (fix #421):
+            // its class edge is a child, the review a leaf beside it.
+            if (callees.initializerReviews && callees.initializerReviews.length > 0) {
+                node.initializerReviews = callees.initializerReviews;
+            }
             for (const callee of callees.slice(0, maxChildren)) {
                 // callee already has the best-matched definition from findCallees
                 const childTree = buildTree(callee, currentDepth + 1, 'down');
@@ -238,7 +243,8 @@ function trace(index, name, options = {}) {
                     node.children.push({
                         ...childTree,
                         callCount: callee.callCount,
-                        weight: callee.weight
+                        weight: callee.weight,
+                        ...(callee.initializerOf && { constructs: callee.initializerOf }),
                     });
                 }
             }