ucn 5.3.4 → 5.3.6

package/core/receiver-types.js

@@ -0,0 +1,26 @@
+'use strict';
+
+// Shared by receiver resolution and the pure provenance validator.
+const BUILTIN_RECEIVER_TYPES = new Set([
+    'dict', 'list', 'set', 'tuple', 'str', 'int', 'float', 'bool', 'bytes', 'frozenset',
+    'Mapping', 'MutableMapping', 'Sequence', 'MutableSequence',
+    'Collection', 'Iterable', 'Iterator', 'KeysView', 'ValuesView', 'ItemsView',
+    'IO', 'TextIO', 'BinaryIO', 'StringIO', 'BytesIO',
+    'ZlibCompress', 'ZlibDecompress',
+    'AsyncEvent',
+    'Generator', 'AsyncGenerator', 'ContextManager', 'AsyncContextManager',
+    'Array', 'String', 'Object', 'RegExp', 'Number', 'Boolean', 'Map', 'Set', 'Promise',
+    'WeakMap', 'WeakSet',
+    'string', 'number', 'boolean', 'bigint', 'symbol',
+    'object', 'dynamic', 'decimal', 'byte', 'sbyte', 'char',
+    'short', 'ushort', 'uint', 'long', 'ulong', 'double',
+    'List', 'Dictionary', 'HashSet', 'Queue', 'Stack',
+    'Task', 'ValueTask', 'IEnumerable', 'ICollection', 'IList',
+]);
+
+function isProvenanceBuiltinReceiver(type, language) {
+    return BUILTIN_RECEIVER_TYPES.has(type) ||
+        (language === 'rust' && ['Option', 'Result', 'Vec'].includes(type));
+}
+
+module.exports = { BUILTIN_RECEIVER_TYPES, isProvenanceBuiltinReceiver };

package/core/rust-result-flow.js

@@ -0,0 +1,206 @@
+'use strict';
+
+const path = require('path');
+const { declarationIdentity, identityKey } = require('./provenance');
+const { resolveRustImport } = require('./imports');
+
+const TYPE_KINDS = new Set(['class', 'struct', 'enum', 'type', 'trait', 'interface']);
+
+function parseGeneric(value) {
+    if (typeof value !== 'string') return null;
+    const text = value.trim(), start = text.indexOf('<');
+    if (start < 1 || !text.endsWith('>')) return null;
+    const args = [];
+    let depth = 0, current = '';
+    for (const character of text.slice(start + 1, -1)) {
+        if ('<(['.includes(character)) depth++;
+        else if ('>)]'.includes(character)) depth--;
+        if (character === ',' && depth === 0) { args.push(current.trim()); current = ''; }
+        else current += character;
+        if (depth < 0) return null;
+    }
+    if (depth) return null;
+    args.push(current.trim());
+    return args.every(Boolean) ? { head: text.slice(0, start).trim(), args } : null;
+}
+
+function projectTuple(text, projection) {
+    for (const position of projection) {
+        text = text.trim();
+        if (!Number.isInteger(position) || position < 0 || !text.startsWith('(') || !text.endsWith(')')) return null;
+        const tuple = parseGeneric(`Tuple<${text.slice(1, -1)}>`);
+        if (!tuple || position >= tuple.args.length) return null;
+        text = tuple.args[position];
+    }
+    return text;
+}
+
+/** Preserve the payload of a proven standard Result/Option annotation.
+ * Generic arguments retain their own declaration scope through alias hops;
+ * a project type merely named Result is not a standard wrapper.
+ */
+function rustWrapperContract(index, text, file, options) {
+    const expression = parseGeneric(text);
+    if (!expression) return null;
+    const seen = new Set();
+    const chain = [];
+    const resolve = (head, args, context) => {
+        const key = `${context}:${head}`;
+        if (seen.has(key) || seen.size >= 12) return null;
+        seen.add(key);
+        const entry = index.files.get(context);
+        if (!entry) return null;
+        const standard = /^(?:std|core)::(?:result::Result|option::Option)$/.test(head);
+        if (standard) {
+            const root = head.split('::')[0];
+            if ((index.symbols.get(root) || []).some(d => d.file === context) ||
+                (entry.importBindings || []).some(b => (b.alias || b.name) === root)) return null;
+            const kind = head.split('::').at(-1);
+            if (args.length !== (kind === 'Result' ? 2 : 1)) return null;
+            chain.push({ standard: head, fromFile: entry.relativePath,
+                rootDeclarations: [], rootBindings: [] });
+            return { kind, item: args[0] };
+        }
+        if (head.includes('::')) {
+            const parts = head.split('::');
+            const name = parts.pop();
+            const prefix = parts.join('::');
+            const relative = entry.moduleResolved?.[prefix];
+            const destination = relative ? path.resolve(index.root, relative)
+                : resolveRustImport(prefix, context, index.root);
+            if (!destination || !index.files.has(destination)) return null;
+            chain.push({ fromFile: entry.relativePath, typePath: head,
+                toFile: path.relative(index.root, destination) });
+            return resolve(name, args, destination);
+        }
+        const local = (index.symbols.get(head) || []).filter(d =>
+            d.file === context && TYPE_KINDS.has(d.type));
+        if (local.length) {
+            if (local.length !== 1) return null;
+            const alias = local[0];
+            if (alias.type !== 'type' || !alias.aliasTypeText ||
+                !alias.aliasTypeParameters?.every(Boolean) ||
+                alias.aliasTypeParameters.length < args.length) return null;
+            const body = parseGeneric(alias.aliasTypeText);
+            if (!body) return null;
+            const parameters = new Map();
+            for (const [i, name] of alias.aliasTypeParameters.entries()) {
+                const fallback = alias.aliasTypeDefaults?.[i];
+                const value = args[i] || (fallback && (parameters.get(fallback) || { text: fallback, file: context }));
+                if (!value || (!args[i] && !parameters.has(fallback) &&
+                    fallback.split(/[^\w]+/).some(token => parameters.has(token)))) return null;
+                parameters.set(name, value);
+            }
+            const forwarded = body.args.map(text => parameters.get(text) || { text, file: context });
+            // Nested generic substitution needs its own type-expression model.
+            // Do not resolve an unsubstituted parameter in the alias's scope.
+            if (body.args.some(text => !parameters.has(text) &&
+                text.split(/[^\w]+/).some(token => parameters.has(token)))) return null;
+            chain.push({ declaration: declarationIdentity(alias), type: alias.aliasTypeText,
+                parameters: alias.aliasTypeParameters, defaults: alias.aliasTypeDefaults,
+                arguments: args.map(argument => ({ text: argument.text, file: path.relative(index.root, argument.file) })) });
+            return resolve(body.head, forwarded, context);
+        }
+        const bindings = (entry.importBindings || []).filter(b => (b.alias || b.name) === head);
+        if (bindings.length) {
+            if (bindings.length !== 1) return null;
+            const binding = bindings[0];
+            const destination = entry.moduleResolved?.[binding.module];
+            chain.push({ fromFile: entry.relativePath, binding: { ...binding }, toFile: destination || null });
+            return destination
+                ? resolve(binding.module.split('::').at(-1), args, path.resolve(index.root, destination))
+                : resolve(binding.module, args, context);
+        }
+        if (head === 'Result' || head === 'Option') {
+            if ((entry.importBindings || []).some(b => b.name === '*' || b.module?.endsWith('::*'))) return null;
+            chain.push({ prelude: head, fromFile: entry.relativePath,
+                declarations: [], bindings: [], wildcardImports: [] });
+            return resolve(head === 'Result' ? 'std::result::Result' : 'std::option::Option', args, context);
+        }
+        return null;
+    };
+    const resolved = resolve(expression.head, expression.args.map(text => ({ text, file })), file);
+    if (!resolved) return null;
+    const wrapper = { kind: resolved.kind, annotation: { text, file: path.relative(index.root, file) }, chain };
+    const projection = options.projection || [];
+    const projected = projectTuple(resolved.item.text, projection);
+    const item = projected && options.parseType(projected);
+    if (!item) return options.allowUnknownPayload ? wrapper : null;
+    const origin = options.resolveType(resolved.item.file, item.name, item.qualifier);
+    const declarations = origin?.fromFile && (index.symbols.get(item.name) || []).filter(d =>
+        d.file === origin.fromFile && TYPE_KINDS.has(d.type));
+    if (declarations?.length !== 1) return options.allowUnknownPayload ? wrapper : null;
+    return { kind: resolved.kind, type: item.name, fromFile: origin.fromFile,
+        payload: { text: resolved.item.text, file: path.relative(index.root, resolved.item.file),
+            ...(projection.length && { projection, projected }),
+            declaration: declarationIdentity(declarations[0]) },
+        annotation: { text, file: path.relative(index.root, file) }, chain };
+}
+
+/** Replay the type arguments and scope hops without consulting the resolver. */
+function validateRustWrapperContract(contract, ownershipOnly = false) {
+    const initial = parseGeneric(contract?.annotation?.text);
+    if (!initial || !contract.annotation.file || !Array.isArray(contract.chain) ||
+        contract.chain.length > 24 || !identityKey(contract.producer) ||
+        contract.producer.file !== contract.annotation.file ||
+        contract.producer.returnType !== contract.annotation.text) return false;
+    let head = initial.head, file = contract.annotation.file;
+    let args = initial.args.map(text => ({ text, file }));
+    const empty = value => Array.isArray(value) && value.length === 0;
+    let standard;
+    for (const hop of contract.chain) {
+        if (standard) return false;
+        if (hop.declaration) {
+            if (!identityKey(hop.declaration) || hop.declaration.name !== head || hop.declaration.file !== file ||
+                hop.declaration.kind !== 'type' || !Array.isArray(hop.parameters) ||
+                !hop.parameters.every(name => typeof name === 'string' && name) ||
+                hop.parameters.length < args.length ||
+                JSON.stringify(hop.arguments) !== JSON.stringify(args)) return false;
+            const body = parseGeneric(hop.type);
+            if (!body) return false;
+            const parameters = new Map();
+            for (const [i, name] of hop.parameters.entries()) {
+                const fallback = hop.defaults?.[i];
+                const value = args[i] || (fallback && (parameters.get(fallback) || { text: fallback, file }));
+                if (!value || (!args[i] && !parameters.has(fallback) &&
+                    fallback.split(/[^\w]+/).some(token => parameters.has(token)))) return false;
+                parameters.set(name, value);
+            }
+            if (body.args.some(text => !parameters.has(text) &&
+                text.split(/[^\w]+/).some(token => parameters.has(token)))) return false;
+            args = body.args.map(text => parameters.get(text) || { text, file });
+            head = body.head;
+        } else if (hop.binding) {
+            if (hop.fromFile !== file || (hop.binding.alias || hop.binding.name) !== head ||
+                typeof hop.binding.module !== 'string') return false;
+            head = hop.toFile ? hop.binding.module.split('::').at(-1) : hop.binding.module;
+            file = hop.toFile || file;
+        } else if (hop.typePath) {
+            if (hop.fromFile !== file || hop.typePath !== head || !hop.toFile) return false;
+            head = head.split('::').at(-1);
+            file = hop.toFile;
+        } else if (hop.prelude) {
+            if (hop.fromFile !== file || hop.prelude !== head || !['Result', 'Option'].includes(head) ||
+                !empty(hop.declarations) || !empty(hop.bindings) || !empty(hop.wildcardImports)) return false;
+            head = head === 'Result' ? 'std::result::Result' : 'std::option::Option';
+        } else if (hop.standard) {
+            if (hop.fromFile !== file || hop.standard !== head ||
+                !/^(std|core)::(result::Result|option::Option)$/.test(head) ||
+                !empty(hop.rootDeclarations) || !empty(hop.rootBindings)) return false;
+            standard = head.split('::').at(-1);
+        } else return false;
+    }
+    if (!standard || standard !== contract.kind || args.length !== (standard === 'Result' ? 2 : 1)) return false;
+    if (ownershipOnly) return true;
+    if (args[0].text !== contract.payload?.text || args[0].file !== contract.payload?.file) return false;
+    const projected = projectTuple(args[0].text, contract.payload.projection || []);
+    if (!projected || (contract.payload.projection?.length && contract.payload.projected !== projected)) return false;
+    let payloadHead = projected.replace(/^&(?:\s*'\w+)?\s*/, '').replace(/^mut\s+/, '').trim();
+    payloadHead = (parseGeneric(payloadHead)?.head || payloadHead).split('::').at(-1);
+    if (payloadHead === 'Self') payloadHead = contract.producer.className;
+    return payloadHead === contract.type && identityKey(contract.payload.declaration) !== null &&
+        contract.payload.declaration?.name === contract.type &&
+        TYPE_KINDS.has(contract.payload.declaration?.kind);
+}
+
+module.exports = { rustWrapperContract, validateRustWrapperContract };

package/core/verify.js

@@ -9,6 +9,7 @@ const { detectLanguage, getParser, getLanguageAdapter, safeParse, langTraits } =
 const { sameNode } = require('../languages/utils');
 const { escapeRegExp, codeUnitCompare, NON_CALLABLE_TYPES } = require('./shared');
 const { findAccessorReferences } = require('./accessors');
+const { validateCallMismatch, declarationIdentity } = require('./provenance');
 
 function codeUnitColumnForByteColumn(line, byteColumn) {
     if (!Number.isInteger(byteColumn) || byteColumn < 0) return null;
@@ -1340,7 +1341,10 @@ function verify(index, name, options = {}) {
 
     // Convert caller results to usage-like objects for analyzeCallSite.
     // Carry callerFile/callerStartLine through so we can compute inTestCase.
-    const calls = callerResults.map(c => ({
+    const invalidFamilyCalls = sweepUnverified.filter(c =>
+        validateCallMismatch(c.provenance, declarationIdentity(def)));
+    const calls = [...callerResults, ...invalidFamilyCalls].map(c => ({
+        invalidOverload: invalidFamilyCalls.includes(c),
         file: c.file,
         relativePath: c.relativePath,
         line: c.line,
@@ -1448,12 +1452,12 @@ function verify(index, name, options = {}) {
         const countOk = hasRest
             ? argCount >= minArgs
             : (argCount >= minArgs && argCount <= expectedParamCount);
-        if (!countOk) {
+        if (!countOk || call.invalidOverload) {
             mismatches.push({
                 file: call.relativePath,
                 line: call.line,
                 expression: call.content.trim(),
-                expected: hasRest
+                expected: call.invalidOverload && countOk ? 'a compatible overload signature' : hasRest
                     ? `at least ${minArgs} arg(s)`
                     : (minArgs === expectedParamCount
                         ? `${expectedParamCount} arg(s)`

package/languages/adapter.js

@@ -26,6 +26,8 @@ const OPTIONAL_HELPERS = Object.freeze([
     'findTestCallRanges',
     'getBuiltinCallReturnType',
     'getBuiltinFieldType',
+    'findPytestFunctions',
+    'findPythonModuleEvidence',
     'isPlatformConcreteCall',
     'isPlatformConcreteType',
 ]);

package/languages/c-family.js

@@ -8,6 +8,9 @@
  * source fallback.
  */
 
+const { typeOrigin } = require('./type-evidence');
+
+
 const {
     traverseTree,
     traverseTreeCached,
@@ -1946,6 +1949,10 @@ function buildVariableTypes(tree) {
                 name: identity.name,
                 type,
                 staticType: declaratorStaticType(type, declarator),
+                origin: typeOrigin(node.type === 'declaration' &&
+                    (declarator.type === 'identifier' ||
+                     declarator.childForFieldName('value')?.type === 'new_expression')
+                    ? 'constructor' : 'annotation', declarator),
                 ...(pointeeType && { pointeeType }),
                 declaredAt: node.type === 'parameter_declaration'
                     ? scope.startIndex : declarator.startIndex,
@@ -2044,6 +2051,12 @@ function buildVariableTypes(tree) {
     return {
         get: (name, atNode) => resolveBinding(name, atNode)?.type,
         getStatic: (name, atNode) => resolveBinding(name, atNode)?.staticType,
+        evidence: (name, atNode) => {
+            const binding = resolveBinding(name, atNode);
+            return { receiverTypeSource: binding?.origin?.source || 'unknown',
+                ...(binding && { receiverTypeEvidence: { ...binding.origin, name, type: binding.type } }),
+            };
+        },
         getPointee: (name, atNode) =>
             resolveBinding(name, atNode)?.pointeeType,
         has: (name, atNode) => resolveBinding(name, atNode) !== undefined,
@@ -2501,7 +2514,7 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
                 }),
                 ...(compileTimeOnly && { compileTimeOnly }),
                 ...(macroArguments.length > 0 && { macroArguments }),
-                ...(directReceiverType && { receiverType: directReceiverType }),
+                ...(directReceiverType && { receiverType: directReceiverType, ...variableTypes.evidence(receiverRoot, node) }),
                 ...(receiverCall && {
                     receiverCall,
                     receiverIsChainRoot: true,

package/languages/csharp.js

@@ -587,6 +587,9 @@ function enclosingClassName(node) {
 }
 
 /** Whether a bare identifier is a field/property/event of the enclosing type. */
+
+const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
+
 function enclosingTypeDeclaresMember(node, memberName) {
     let typeNode = null;
     for (let parent = node?.parent; parent; parent = parent.parent) {
@@ -648,10 +651,10 @@ function variableScopeKey(node) {
 }
 
 function buildVariableTypes(tree, parser) {
-    const byScope = new Map([['global', new Map()]]);
+    const byScope = new Map([['global', new ReceiverTypeMap()]]);
     const conflictsByScope = new Map([['global', new Set()]]);
     const scopeStack = [];
-    const setType = (scope, name, type) => {
+    const setType = (scope, name, type, source = 'unknown', node = null) => {
         if (!name || !type) return;
         if (!conflictsByScope.has(scope)) conflictsByScope.set(scope, new Set());
         const conflicts = conflictsByScope.get(scope);
@@ -663,14 +666,14 @@ function buildVariableTypes(tree, parser) {
             conflicts.add(name);
             return;
         }
-        types.set(name, type);
+        types.set(name, type, source, node);
     };
     traverseTree(tree.rootNode, node => {
         if (CALLABLE_SCOPE_NODES.has(node.type) &&
             !isControlFlowLocalArtifact(node)) {
             const key = node.startPosition.row + 1;
             scopeStack.push(key);
-            if (!byScope.has(key)) byScope.set(key, new Map());
+            if (!byScope.has(key)) byScope.set(key, new ReceiverTypeMap());
             if (!conflictsByScope.has(key)) conflictsByScope.set(key, new Set());
         }
         const currentKey = scopeStack[scopeStack.length - 1] || 'global';
@@ -694,7 +697,7 @@ function buildVariableTypes(tree, parser) {
                     const type =
                         recoveredNode.childForFieldName('type')?.text ||
                         recoveredNode.namedChild(0)?.text;
-                    setType(currentKey, name, type);
+                    setType(currentKey, name, type, 'annotation', node);
                     return true;
                 });
             }
@@ -711,14 +714,14 @@ function buildVariableTypes(tree, parser) {
             if (artifactParameter) return true;
             const name = node.childForFieldName('name')?.text;
             const type = node.childForFieldName('type')?.text;
-            setType(currentKey, name, type);
+            setType(currentKey, name, type, 'annotation', node);
         } else if (node.type === 'declaration_pattern' ||
             node.type === 'declaration_expression') {
             const name = node.childForFieldName('name')?.text ||
                 node.namedChildren.at(-1)?.text;
             const type = node.childForFieldName('type')?.text ||
                 node.namedChild(0)?.text;
-            setType(currentKey, name, type);
+            setType(currentKey, name, type, 'annotation', node);
         } else if (node.type === 'variable_declaration') {
             // Class fields have their own declared-field receiver path; do not
             // leak them into the top-level-program local scope.
@@ -747,7 +750,7 @@ function buildVariableTypes(tree, parser) {
                 const dynamicType = value?.type === 'object_creation_expression'
                     ? value.childForFieldName('type')?.text : null;
                 const type = dynamicType || (typeNode?.text !== 'var' ? typeNode?.text : null);
-                setType(currentKey, name, type);
+                setType(currentKey, name, type, dynamicType ? 'constructor' : 'annotation', value || typeNode);
             }
         }
         return true;
@@ -1206,12 +1209,19 @@ function findCallsInCode(code, parser) {
                 }
             }
             calls.push({
+                callSite: typeOrigin('call', identity.nameNode || node),
                 name: identity.name,
                 line: identity.nameNode?.startPosition.row + 1 || node.startPosition.row + 1,
                 isMethod: identity.isMethod,
                 ...(identity.receiver && { receiver: identity.receiver }),
                 ...(receiverIsTypeQualified && { receiverIsTypeQualified: true }),
-                ...(receiverType && { receiverType }),
+                ...(receiverType && { receiverType, ...(unwrappedReceiverNode?.type === 'cast_expression' ? {
+                    receiverTypeSource: 'cast', receiverTypeEvidence: typeOrigin('cast', unwrappedReceiverNode),
+                } : unwrappedReceiverNode?.type === 'object_creation_expression' ? {
+                    receiverTypeSource: 'constructor', receiverTypeEvidence: typeOrigin('constructor', unwrappedReceiverNode),
+                } : literalReceiverType(unwrappedReceiverNode) ? {
+                    receiverTypeSource: 'literal', receiverTypeEvidence: typeOrigin('literal', unwrappedReceiverNode),
+                } : variableTypes.fields(identity.receiver)) }),
                 ...(receiverCastThis && { receiverCastThis: true }),
                 ...(receiverType && receiverTypeInfo.namespace && {
                     receiverTypeNamespace: receiverTypeInfo.namespace,
@@ -1255,6 +1265,7 @@ function findCallsInCode(code, parser) {
                 }
                 if (!callbackName) continue;
                 calls.push({
+                    callSite: typeOrigin('call', value),
                     name: callbackName,
                     line: value.startPosition.row + 1,
                     isMethod: !!callbackReceiver,
@@ -1274,6 +1285,7 @@ function findCallsInCode(code, parser) {
             const raw = typeNode.text.replace(/<.*>$/, '');
             const name = raw.split('.').pop();
             calls.push({
+                callSite: typeOrigin('call', typeNode),
                 name,
                 line: typeNode.startPosition.row + 1,
                 isMethod: false,