ucn 5.6.0 → 5.6.1

package/core/verify.js

@@ -1777,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
@@ -1850,7 +1859,7 @@ 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 },
@@ -1863,7 +1872,7 @@ function analyzeCallSite(index, call, funcName, occurrence = 0) {
             isMethodCall,
             ...(indirectKind && { indirectKind }),
             ...ctx,
-        };
+        }, 'argumentFacts', { value: argumentFacts });
     } catch (e) {
         return { args: null, argCount: 0 };
     }
@@ -1967,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';
     }
@@ -2139,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 };
     }
@@ -2179,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);
@@ -2207,10 +2218,11 @@ function verify(index, name, options = {}) {
     // (the target-less check already resolved its base through the diff).
     const repoFile = index.repoPathOf ? index.repoPathOf(def.file) : def.file;
     if (options.base && options.checkBaseRef) assertGitCommit(repoFile, baseRef);
-    const baseRead = startBaseRead(def.file, baseRef, repoFile);
+    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 {
@@ -2296,6 +2308,7 @@ function verify(index, name, options = {}) {
         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.
@@ -2356,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).
@@ -2441,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
@@ -6961,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/csharp.js

@@ -3473,7 +3473,7 @@ function testUnits(fileEntry, helpers) {
         const generated = chain.some(fixtureRows);
         const row = {
             name: symbol.name, line: symbol.nameLine || symbol.startLine,
-            startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine,
+            startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
             ...(states.includes('skip') && { skipped: true }),
             ...(!states.includes('skip') && sometimes && { conditional: true }),
             // One declaration the runner reports as several tests: a
@@ -3539,12 +3539,12 @@ function testUnits(fileEntry, helpers) {
             ...([...chain, cls].some(each => stateOf(each, null) === 'sometimes') && { sometimes: true }),
             ...([...chain, cls].some(guarded) && { guard: true }),
             ...(cls.namespace && { namespace: cls.namespace }),
-            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine,
+            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine, sourceSpan: cls.sourceSpan,
             members: methodsOf(cls).map(symbol => symbol.name),
             // Where each method's body stands, for a test it gives the body to.
             memberRows: methodsOf(cls).map(symbol => ({
                 name: symbol.name, ...signatureOf(symbol), line: symbol.nameLine || symbol.startLine,
-                startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine,
+                startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
             })),
             ...([...chain, cls].some(fixtureRows) && { several: true, dynamic: 'generated-cases' }),
             ...(attributeNames(cls).includes('TestClass') && { marked: true }),
@@ -3554,7 +3554,7 @@ function testUnits(fileEntry, helpers) {
             units.push({
                 kind: 'suite', name: cls.name, suite: chain.map(outer => outer.name),
                 line: cls.nameLine || cls.startLine, startLine: cls.startLine,
-                endLine: cls.endLine ?? cls.startLine,
+                endLine: cls.endLine ?? cls.startLine, sourceSpan: cls.sourceSpan,
             });
         }
     }

package/languages/go.js

@@ -3952,7 +3952,7 @@ function testUnits(fileEntry, helpers) {
             // A file under a build constraint is compiled only sometimes.
             ...((fileEntry.buildConstraint || platform) && { conditional: true, notInEveryBuild: true }),
             line: symbol.nameLine || symbol.startLine, startLine: symbol.startLine,
-            endLine: symbol.endLine ?? symbol.startLine,
+            endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
         });
     }
     // Go has no test that is not a declaration: no unit, no test.

package/languages/index.js

@@ -139,6 +139,7 @@ const STRUCTURAL_TRAITS = {
     physicalCallTokenSyntax: true,
     scopeAlternativeBindings: false,
     nameReferenceFamily: 'js',
+    discardIdentifierNames: [],
     staticValueImportSyntax: null,
     implicitEnumCaseLabels: false,
     valuePatternConstants: false,
@@ -196,6 +197,13 @@ const STRUCTURAL_TRAITS = {
     memberHidingModifier: null,
     virtualMemberModifiers: null,
     hasArityOverloads: false,
+    // Bounded literal proofs for changed project calls; absent means unknown.
+    checkLiteralArguments: null,
+    checkDirectiveComment: null,
+    checkFileDirectiveComment: null,
+    checkDirectiveTarget: null,
+    checkDirectiveBarrier: null,
+    checkTypedComment: null,
     userDefinedConversions: null,
     overloadPhases: null,
     overloadFileSymbols: false,
@@ -537,6 +545,7 @@ const NOMINAL_TRAITS = {
     physicalCallTokenSyntax: true,
     scopeAlternativeBindings: false,
     nameReferenceFamily: null,
+    discardIdentifierNames: [],
     staticValueImportSyntax: null,
     implicitEnumCaseLabels: false,
     valuePatternConstants: false,
@@ -589,6 +598,13 @@ const NOMINAL_TRAITS = {
     // the caller contract: a pinned overload is only confirmed when the call
     // site provably binds it.
     hasArityOverloads: false,
+    // Bounded literal proofs for changed project calls; absent means unknown.
+    checkLiteralArguments: null,
+    checkDirectiveComment: null,
+    checkFileDirectiveComment: null,
+    checkDirectiveTarget: null,
+    checkDirectiveBarrier: null,
+    checkTypedComment: null,
     // User-defined conversions keep otherwise incompatible argument types
     // possible; selecting an overload still needs a positive conversion proof.
     userDefinedConversions: null,
@@ -919,6 +935,11 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-javascript'),
         traits: {
             ...STRUCTURAL_TRAITS,
+            checkTypedComment: text => /@ts-check\b|@(?:param|type|returns?)\s*\{/.test(text),
+            checkDirectiveComment: text => require('./javascript').checkDirectiveComment(text),
+            checkFileDirectiveComment: text => require('./javascript').checkFileDirectiveComment(text),
+            checkDirectiveTarget: 'next-line',
+            checkDirectiveBarrier: text => text.startsWith('/*'),
             testUnits: (fileEntry, helpers) => require('./javascript').testUnits(fileEntry, helpers),
             testRunnerModules: () => require('./javascript').TEST_RUNNER_MODULES,
             testExport: (fileEntry, helpers, name) => require('./javascript').testExport(fileEntry, helpers, name),
@@ -948,6 +969,11 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-typescript').typescript,
         traits: {
             ...STRUCTURAL_TRAITS,
+            checkLiteralArguments: { smallInteger: ['number'], string: ['string'], boolean: ['boolean'] },
+            checkDirectiveComment: text => require('./javascript').checkDirectiveComment(text),
+            checkFileDirectiveComment: text => require('./javascript').checkFileDirectiveComment(text),
+            checkDirectiveTarget: 'next-line',
+            checkDirectiveBarrier: text => text.startsWith('/*'),
             testUnits: (fileEntry, helpers) => require('./javascript').testUnits(fileEntry, helpers),
             testRunnerModules: () => require('./javascript').TEST_RUNNER_MODULES,
             testExport: (fileEntry, helpers, name) => require('./javascript').testExport(fileEntry, helpers, name),
@@ -981,6 +1007,11 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-typescript').tsx,
         traits: {
             ...STRUCTURAL_TRAITS,
+            checkLiteralArguments: { smallInteger: ['number'], string: ['string'], boolean: ['boolean'] },
+            checkDirectiveComment: text => require('./javascript').checkDirectiveComment(text),
+            checkFileDirectiveComment: text => require('./javascript').checkFileDirectiveComment(text),
+            checkDirectiveTarget: 'next-line',
+            checkDirectiveBarrier: text => text.startsWith('/*'),
             testUnits: (fileEntry, helpers) => require('./javascript').testUnits(fileEntry, helpers),
             testRunnerModules: () => require('./javascript').TEST_RUNNER_MODULES,
             testExport: (fileEntry, helpers, name) => require('./javascript').testExport(fileEntry, helpers, name),
@@ -1014,6 +1045,9 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-python'),
         traits: {
             ...STRUCTURAL_TRAITS,
+            checkLiteralArguments: { smallInteger: ['int', 'float'], string: ['str'], boolean: ['bool'] },
+            checkDirectiveComment: text => require('./python').checkDirectiveComment(text),
+            checkFileDirectiveComment: text => require('./python').checkFileDirectiveComment(text),
             testUnits: (fileEntry, helpers) => require('./python').testUnits(fileEntry, helpers),
             testRunnerFamily: 'python',
             testFileNames: [/^test_[^/]*\.py$/, /_test\.py$/],
@@ -1129,7 +1163,8 @@ const LANGUAGES = {
                     owners: ['Enum', 'IntEnum', 'StrEnum', 'Flag', 'IntFlag', 'ReprEnum'] },
             ]),
             reflectionApi: {
-                hintPattern: /\b(?:getattr|setattr|hasattr|delattr|eval|exec|globals|vars)\b/,
+                pythonBindingIdentity: true,
+                hintPattern: /\b(?:getattr|setattr|hasattr|delattr|eval|exec|globals|vars|patch|MonkeyPatch)\b/,
                 functions: [{ callee: /^(?:getattr|setattr|hasattr|delattr)$/, nameArg: 1, receiverArg: 0 }],
                 namespaceLookups: { calls: /^eval$/, subscriptOf: /^(?:globals|vars)\(\)$/ },
                 // `exec(code)` runs statements; it names nothing a lookup
@@ -1148,6 +1183,7 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-go'),
         traits: {
             ...NOMINAL_TRAITS,
+            checkLiteralArguments: { smallInteger: ['int', 'int8', 'int16', 'int32', 'int64', 'uint', 'uint8', 'uint16', 'uint32', 'uint64', 'uintptr', 'float32', 'float64'], string: ['string'], boolean: ['bool'] },
             testUnits: (fileEntry, helpers) => require('./go').testUnits(fileEntry, helpers),
             testGate: (fileEntry, helpers) => require('./go').testGate(fileEntry, helpers),
             testRunnerFamily: 'go',
@@ -1155,6 +1191,7 @@ const LANGUAGES = {
             selfParam: null,
             packageScope: 'directory',
             nameReferenceFamily: 'go',
+            discardIdentifierNames: ['_'],
             closedQueryBodies: ['function_declaration', 'method_declaration', 'func_literal'],
             hasReceiverPackageCalls: true,
             exportVisibility: 'capitalization',
@@ -1186,6 +1223,7 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-rust'),
         traits: {
             ...NOMINAL_TRAITS,
+            checkLiteralArguments: { smallInteger: ['i8', 'i16', 'i32', 'i64', 'i128', 'isize', 'u8', 'u16', 'u32', 'u64', 'u128', 'usize'], string: ['&str'], boolean: ['bool'] },
             testUnits: (fileEntry, helpers) => require('./rust').testUnits(fileEntry, helpers),
             testRunnerFamily: 'rust',
             testFileNames: [/(^|\/)tests\/[^/]+\.rs$/],
@@ -1384,6 +1422,7 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-c'),
         traits: {
             ...NOMINAL_TRAITS,
+            checkLiteralArguments: { smallInteger: ['int', 'short', 'long', 'long long', 'unsigned', 'unsigned int', 'unsigned short', 'unsigned long', 'unsigned long long', 'float', 'double'] },
             selfParam: null,
             packageScope: 'file',
             nameReferenceFamily: 'c',
@@ -1596,6 +1635,11 @@ const LANGUAGES = {
         treeSitterModule: () => require('tree-sitter-html'),
         traits: {
             ...STRUCTURAL_TRAITS,
+            checkTypedComment: text => /@ts-check\b|@(?:param|type|returns?)\s*\{/.test(text),
+            checkDirectiveComment: text => require('./javascript').checkDirectiveComment(text),
+            checkFileDirectiveComment: text => require('./javascript').checkFileDirectiveComment(text),
+            checkDirectiveTarget: 'next-line',
+            checkDirectiveBarrier: text => text.startsWith('/*'),
             lenientCallArity: true,
             // Embedded scripts supply their own parse trees.
             physicalCallTokenSyntax: false,

package/languages/java.js

@@ -3433,7 +3433,7 @@ function testUnits(fileEntry, helpers) {
             testngState(symbol).several || (byClass && testngState(owner).several) || chain.some(otherRunner);
         const row = {
             name: symbol.name, line: symbol.nameLine || symbol.startLine,
-            startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine,
+            startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
             ...(off && { skipped: true }),
             ...(!off && sometimes && { conditional: true }),
             // One declaration the runner reports as several tests.
@@ -3529,12 +3529,12 @@ function testUnits(fileEntry, helpers) {
             ...(maybeRefused.has(cls) && { mayRefuse: true }),
             ...([...chain, cls].some(otherRunner) && { runner: true }),
             ...(cls.namespace && { namespace: cls.namespace }),
-            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine,
+            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine, sourceSpan: cls.sourceSpan,
             members: methodsOf(cls).map(symbol => symbol.name),
             // Where each method's body stands, for a test it gives the body to.
             memberRows: methodsOf(cls).map(symbol => ({
                 name: symbol.name, ...signatureOf(symbol), line: symbol.nameLine || symbol.startLine,
-                startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine,
+                startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
                 ...(symbol.type !== 'constructor' && classCandidate(symbol) && { candidate: true }),
             })),
             // TestNG's @Test on the class makes its public methods tests,
@@ -3548,7 +3548,7 @@ function testUnits(fileEntry, helpers) {
             units.push({
                 kind: 'suite', name: cls.name, suite: chain.map(outer => outer.name),
                 line: cls.nameLine || cls.startLine, startLine: cls.startLine,
-                endLine: cls.endLine ?? cls.startLine,
+                endLine: cls.endLine ?? cls.startLine, sourceSpan: cls.sourceSpan,
             });
         }
     }

package/languages/javascript.js

@@ -7,6 +7,7 @@
 
 const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
 const { referenceScope, scopeFields } = require('./lexical-scope');
+const { jsStaticKey } = require('./static-js');
 
 
 const {
@@ -4356,13 +4357,14 @@ function findCallsInCode(code, parser) {
                     argCount: node.childForFieldName('arguments')?.namedChildCount ?? 0,
                     enclosingFunction,
                 });
-            } else if (funcNode.type === 'member_expression') {
+            } else if (funcNode.type === 'member_expression' ||
+                (funcNode.type === 'subscript_expression' && jsStaticKey(funcNode.childForFieldName('index')) != null)) {
                 // Method call: obj.foo() or foo.call/apply/bind()
-                const propNode = funcNode.childForFieldName('property');
+                const propNode = funcNode.childForFieldName('property') || funcNode.childForFieldName('index');
                 let objNode = funcNode.childForFieldName('object');
 
                 if (propNode) {
-                    const propName = propNode.text;
+                    const propName = funcNode.type === 'subscript_expression' ? jsStaticKey(propNode) : propNode.text;
 
                     // Handle .call(), .apply(), .bind() - these are calls TO the object.
                     // boundCall marks the indirection (fix #221, family B): the line
@@ -5726,6 +5728,19 @@ function findUsagesInCode(code, name, parser, tree, options = {}) {
     const scopeMemo = options.lexicalScopes ? new Map() : null;
 
     visitNameNodes(tree, code, name, (node) => {
+        // A literal bracket key is the member token of an ordinary call.
+        // Keep it in the same ground-set bucket as the dotted spelling.
+        const literal = node.type === 'string' ? node : node.parent?.type === 'string' ? node.parent : null;
+        const computed = literal?.parent;
+        if (computed?.type === 'subscript_expression' &&
+            sameNode(computed.childForFieldName('index'), literal) && jsStaticKey(literal) === name) {
+            const call = computed.parent;
+            const receiver = computed.childForFieldName('object');
+            usages.push({ line: node.startPosition.row + 1, column: node.startPosition.column,
+                usageType: call?.type === 'call_expression' && sameNode(call.childForFieldName('function'), computed) ? 'call' : 'reference',
+                ...(['identifier', 'this', 'super'].includes(receiver?.type) && { receiver: receiver.text }) });
+            return true;
+        }
         // Look for identifier, property_identifier (method names in obj.method() calls),
         // private_property_identifier (#method definitions and calls),
         // type_identifier (TypeScript type annotations), shorthand_property_identifier_pattern
@@ -5879,7 +5894,7 @@ function findUsagesInCode(code, name, parser, tree, options = {}) {
             }
             // JSX component usage: <Component /> or <Component>...</Component>
             else if (parent.type === 'jsx_self_closing_element' || parent.type === 'jsx_opening_element') {
-                usageType = 'call';  // Treat JSX component usage as a "call"
+                usageType = /^[A-Z]/.test(node.text) ? 'call' : 'intrinsic';
             }
         }
 
@@ -6898,6 +6913,9 @@ function testUnits(fileEntry, helpers) {
             kind: api.kind, name: title, titled: true, suite: ctx.suites.map(suite => suite.name),
             line: node.startPosition.row + 1, startLine: node.startPosition.row + 1,
             endLine: node.endPosition.row + 1,
+            sourceSpan: { start: node.startIndex, end: node.endIndex,
+                startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1,
+                startColumn: node.startPosition.column, endColumn: node.endPosition.column },
             parent: outer ? outer.index : -1,
             ...(api.only && { only: true }),
             ...(skipped && { skipped: true }),
@@ -7118,14 +7136,28 @@ const TS_DIRECTIVE_BLOCK = /^(?:\/|\*)*\s*@(?:ts-expect-error|ts-ignore)/;
 // A file pragma: `// @name`, the name ending at a space or a colon.
 const TS_FILE_PRAGMA = /^\/\/\/?\s*@([^\s:]+)/;
 
+function lineCheckDirective(text) {
+    return text.startsWith('//') ? TS_DIRECTIVE_LINE.test(text)
+        : TS_DIRECTIVE_BLOCK.test(text.slice(text.lastIndexOf('\n') + 1).trimStart());
+}
+
+/** The same scanner grammar used by check suppression and diff context. */
+function checkFileDirectiveComment(text) {
+    const pragma = text.startsWith('//') ? TS_FILE_PRAGMA.exec(text) : null;
+    const name = pragma ? pragma[1].toLowerCase() : null;
+    return name === 'ts-nocheck' || name === 'ts-check' ? 'leading' : null;
+}
+function checkDirectiveComment(text) {
+    return lineCheckDirective(text) || checkFileDirectiveComment(text) !== null;
+}
+
 /** Lines that hold a directive comment, and whether the file is unchecked. */
 function checkDirectives(root) {
     const lines = new Set();
     let unchecked = false;
     for (const comment of root.descendantsOfType('comment')) {
         const text = comment.text;
-        const directive = text.startsWith('//') ? TS_DIRECTIVE_LINE.test(text)
-            : TS_DIRECTIVE_BLOCK.test(text.slice(text.lastIndexOf('\n') + 1).trimStart());
+        const directive = lineCheckDirective(text);
         if (directive) lines.add(comment.endPosition.row + 1);
     }
     // `@ts-nocheck` and `@ts-check` are pragmas of the `//` comments
@@ -7343,6 +7375,8 @@ module.exports = {
     classMemberRole,
     typedLiteralMembers,
     checkSuppressedAt,
+    checkDirectiveComment,
+    checkFileDirectiveComment,
     checkedImportAt,
     CLASS_DECLARATION_NODES,
     findFunctions,

package/languages/python.js

@@ -342,6 +342,8 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 ...(paramTypes && { paramTypes }),
                 ...(docstring && { docstring }),
                 ...(decorators.length > 0 && { decorators }),
+                ...(decorators.length > 0 && { registrationUnknown: require('../core/python-binding-identity').registrationUnknown(node) }),
+                runtimeOwnerPath: require('../core/python-binding-identity').pythonRuntimeOwners(node),
                 ...(isOverloadDecorated(decorators) && { isSignature: true }),
                 ...(nameLine !== decoratorStartLine && { nameLine })
             });
@@ -389,6 +391,8 @@ function _processClass(node, classes, processedRanges, lines) {
             members,
             ...(docstring && { docstring }),
             ...(decorators.length > 0 && { decorators }),
+            ...(decorators.length > 0 && { registrationUnknown: require('../core/python-binding-identity').registrationUnknown(node) }),
+            runtimeOwnerPath: require('../core/python-binding-identity').pythonRuntimeOwners(node),
             ...(bases.length > 0 && { extends: bases.join(', ') }),
             // A protocol class is satisfied by shape: no class has to name it.
             ...(isProtocolClass(node) && { protocolClass: true }),
@@ -1317,6 +1321,8 @@ function extractClassMembers(classNode, code) {
                     ...(paramTypes && { paramTypes }),
                     ...(docstring && { docstring }),
                     ...(memberDecorators.length > 0 && { decorators: memberDecorators }),
+                    ...(memberDecorators.length > 0 && { registrationUnknown: require('../core/python-binding-identity').registrationUnknown(funcNode) }),
+                    runtimeOwnerPath: require('../core/python-binding-identity').pythonRuntimeOwners(funcNode),
                     ...(isOverloadDecorated(memberDecorators) && { isSignature: true }),
                     ...(isRequiredPythonMember(classNode, memberDecorators) && { requiredMember: true }),
                     ...(nameLine !== startLine && { nameLine })
@@ -2726,6 +2732,7 @@ function pythonModuleAliases(tree) {
 
 // Annotation positions whose value Python evaluates as an expression.
 const PY_ANNOTATION_OWNERS = new Set(['typed_parameter', 'typed_default_parameter', 'function_definition', 'assignment']);
+const annotationQuotesByTree = new WeakMap();
 
 /**
  * String annotations holding calls (fix #398F): `def f(v: "Annotated[int,
@@ -2735,9 +2742,13 @@ const PY_ANNOTATION_OWNERS = new Set(['typed_parameter', 'typed_default_paramete
  * interpolation); the result lists the byte ranges of their quotes.
  */
 function annotationStringQuotes(tree) {
+    const cached = annotationQuotesByTree.get(tree);
+    if (cached) return cached;
     const quotes = [];
-    for (const holder of getCachedNodeList(tree.rootNode).nodes) {
-        if (holder.type !== 'type') continue;
+    // The source tree is immutable. A multi-name query should discover
+    // these file-level ranges once, without rebuilding a flat node list
+    // whenever another file displaces the general traversal cache.
+    for (const holder of tree.rootNode.descendantsOfType('type')) {
         const string = holder.namedChildCount === 1 ? holder.namedChild(0) : null;
         if (string?.type !== 'string' || string.startPosition.row !== string.endPosition.row) continue;
         const owner = holder.parent;
@@ -2754,6 +2765,7 @@ function annotationStringQuotes(tree) {
         quotes.push({ open: parts[0].startIndex, close: parts[2].startIndex,
             contentStart: content.startIndex, contentEnd: content.endIndex });
     }
+    annotationQuotesByTree.set(tree, quotes);
     return quotes;
 }
 
@@ -6597,7 +6609,7 @@ function testUnits(fileEntry, helpers) {
             : (switchUnsettled || (written && written.on === 'unknown')) ? 'collection-switch' : null;
         return {
             name: symbol.name, line: symbol.nameLine || symbol.startLine, startLine: symbol.startLine,
-            endLine: symbol.endLine ?? symbol.startLine,
+            endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
             named: functionNamed(symbol.name), prefixed: symbol.name.startsWith('test'),
             // (Where a switch of the file is not read, off is not settled either.)
             ...(written && written.on === false && !switchUnsettled && { off: true }),
@@ -6804,7 +6816,7 @@ function testUnits(fileEntry, helpers) {
             ...((written.some(entry => entry.from.module === 'abc' && entry.from.name === 'ABC') || metaPath === 'abc.ABCMeta')
                 ? { abc: true } : metaclass ? { abc: 'unknown' } : {}),
             marks: ownMarks.marks, marksOpen: ownMarks.open,
-            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine,
+            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine, sourceSpan: cls.sourceSpan,
             members: [...members], tests,
         });
     }
@@ -7335,6 +7347,27 @@ function annotatedReceiverType(tree, line, column, receiver) {
 const TYPE_IGNORE = /(^|#)\s*type:\s*ignore(\[[\s\w-,]*\]|\s|$)/;
 const PYRIGHT_IGNORE = /(^|#)\s*pyright:\s*ignore(?:\[([\s\w-,]*)\]|\s|$)/;
 const CHECK_MODES = new Set(['basic', 'standard', 'strict']);
+
+function checkSettingOperands(text) {
+    const value = text.slice(1).trim();
+    if (!value.startsWith('pyright:')) return null;
+    const operands = value.slice('pyright:'.length);
+    return operands.trim().startsWith('ignore') ? null : operands;
+}
+
+/** Use the same ignore grammar for suppression and changed-code context. */
+function checkDirectiveComment(text) {
+    // Ordinary type annotations also affect checking. Keep those even
+    // though they are not suppressions read by checkSuppressedAt.
+    return /^#\s*(?:type|pyright)\s*:/.test(text) ||
+        TYPE_IGNORE.test(text) || PYRIGHT_IGNORE.test(text);
+}
+
+function checkFileDirectiveComment(text) {
+    if (TYPE_IGNORE.test(text)) return 'leading-or-local';
+    if (PYRIGHT_IGNORE.test(text)) return null;
+    return checkSettingOperands(text) !== null ? 'column-zero-file' : null;
+}
 // The rule each kind of break is reported under.
 const RULE_OF = Object.freeze({
     'arity': 'reportCallIssue',
@@ -7348,12 +7381,14 @@ const RULE_OF = Object.freeze({
  *   all      a `type: ignore` comment before any token: nothing is reported;
  *   lines    line -> null (everything on it is ignored: `type: ignore`,
  *            `pyright: ignore`) or the rules a `pyright: ignore[..]` names;
- *   levels   rule -> level set by `# pyright: rule=level` comments, which
- *            apply to the file wherever they stand, alone on their line.
+ *   levels   rule -> level set by `# pyright: rule=level` comments. The
+ *            checker applies them even at an invalid position, reporting
+ *            a separate placement diagnostic; changed-code context tracks
+ *            that column-zero requirement independently.
  *            `basic`, `standard` and `strict` choose a rule set: none of
  *            them turns a rule off.
  */
-function checkDirectives(root, lines) {
+function checkDirectives(root) {
     const ignored = new Map();
     const levels = new Map();
     let all = false;
@@ -7371,11 +7406,8 @@ function checkDirectives(root, lines) {
             ignored.set(line, scoped[2] === undefined ? null
                 : scoped[2].split(',').map(rule => rule.trim()).filter(Boolean));
         }
-        const value = text.slice(1).trim();
-        const ownLine = String(lines[line - 1] === undefined ? '' : lines[line - 1]).trim().startsWith('#');
-        if (!ownLine || !value.startsWith('pyright:')) continue;
-        const operands = value.slice('pyright:'.length);
-        if (operands.trim().startsWith('ignore')) continue;
+        const operands = checkSettingOperands(text);
+        if (operands === null) continue;
         const list = operands.split(',').map(operand => operand.trim()).filter(Boolean);
         if (list.some(operand => CHECK_MODES.has(operand))) levels.clear();
         for (const operand of list) {
@@ -7482,10 +7514,10 @@ function reportedRanges(root, site) {
  *   problem, module, memo }
  */
 function checkSuppressedAt(site) {
-    const { lines, root, memo } = site;
+    const { root, memo } = site;
     if (!root) return false;
-    if (memo && !memo.has('directives')) memo.set('directives', checkDirectives(root, lines));
-    const directives = memo ? memo.get('directives') : checkDirectives(root, lines);
+    if (memo && !memo.has('directives')) memo.set('directives', checkDirectives(root));
+    const directives = memo ? memo.get('directives') : checkDirectives(root);
     if (directives.all) return true;
     const rule = RULE_OF[site.kind] || null;
     const level = rule ? directives.levels.get(rule) : undefined;
@@ -7516,6 +7548,8 @@ function checkedImportAt(root, line, module) {
 }
 
 module.exports = {
+    checkDirectiveComment,
+    checkFileDirectiveComment,
     checkSuppressedAt,
     checkedImportAt,
     annotatedReceiverType,