ucn 4.1.3 → 4.2.1

package/languages/go.js

@@ -31,6 +31,14 @@ function extractReturnType(node) {
     return null;
 }
 
+/** Compiler-declared result of a returned function type, if any. */
+function extractReturnedFunctionResult(node) {
+    const resultNode = node.childForFieldName('result');
+    if (resultNode?.type !== 'function_type') return null;
+    const innerResult = resultNode.childForFieldName('result');
+    return innerResult?.text.trim() || null;
+}
+
 /**
  * Extract Go parameters
  */
@@ -70,6 +78,46 @@ function extractReceiver(receiverNode) {
  * Returns true if node was matched, false otherwise
  */
 function _processFunction(node, functions, processedRanges, lines) {
+    // Package-level function-valued variables are callable symbols with a
+    // compiler-declared signature (`var DefaultLogger func(next
+    // http.Handler) http.Handler`). Indexing them as functions lets return
+    // flow type the result and prevents downstream interface calls from
+    // falling into global same-name guesses. Local function variables remain
+    // lexical values and are handled by call-site shadowing instead.
+    if (node.type === 'var_spec') {
+        const container = node.parent?.type === 'var_spec_list' ? node.parent?.parent : node.parent;
+        const isPackageLevel = container?.type === 'var_declaration' &&
+            container.parent?.type === 'source_file';
+        const typeNode = node.childForFieldName('type');
+        if (!isPackageLevel || typeNode?.type !== 'function_type') return false;
+        const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return false;
+        processedRanges.add(rangeKey);
+        const paramsNode = typeNode.childForFieldName('parameters');
+        const resultNode = typeNode.childForFieldName('result');
+        const names = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child.type === 'identifier') names.push(child);
+        }
+        const { startLine, endLine, indent } = nodeToLocation(node, lines);
+        for (const nameNode of names) {
+            const isExported = /^[A-Z]/.test(nameNode.text);
+            functions.push({
+                name: nameNode.text,
+                params: extractGoParams(paramsNode),
+                paramsStructured: parseStructuredParams(paramsNode, 'go'),
+                startLine,
+                endLine,
+                indent,
+                modifiers: isExported ? ['export'] : [],
+                isFunctionVariable: true,
+                ...(resultNode?.text.trim() && { returnType: resultNode.text.trim() }),
+            });
+        }
+        return true;
+    }
+
     if (node.type === 'function_declaration') {
         const rangeKey = `${node.startIndex}-${node.endIndex}`;
         if (processedRanges.has(rangeKey)) return false;
@@ -81,6 +129,7 @@ function _processFunction(node, functions, processedRanges, lines) {
         if (nameNode) {
             const { startLine, endLine, indent } = nodeToLocation(node, lines);
             const returnType = extractReturnType(node);
+            const returnedFunctionResult = extractReturnedFunctionResult(node);
             const docstring = extractGoDocstring(lines, startLine);
             const typeParams = extractTypeParams(node);
             const isExported = /^[A-Z]/.test(nameNode.text);
@@ -94,6 +143,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                 indent,
                 modifiers: isExported ? ['export'] : [],
                 ...(returnType && { returnType }),
+                ...(returnedFunctionResult && { returnedFunctionResult }),
                 ...(docstring && { docstring }),
                 ...(typeParams && { generics: typeParams })
             });
@@ -114,6 +164,7 @@ function _processFunction(node, functions, processedRanges, lines) {
             const { startLine, endLine, indent } = nodeToLocation(node, lines);
             const receiver = extractReceiver(receiverNode);
             const returnType = extractReturnType(node);
+            const returnedFunctionResult = extractReturnedFunctionResult(node);
             const docstring = extractGoDocstring(lines, startLine);
             const isExported = /^[A-Z]/.test(nameNode.text);
 
@@ -128,6 +179,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                 receiver,
                 modifiers: isExported ? ['export'] : [],
                 ...(returnType && { returnType }),
+                ...(returnedFunctionResult && { returnedFunctionResult }),
                 ...(docstring && { docstring })
             });
         }
@@ -567,6 +619,7 @@ function parse(code, parser) {
         functions,
         classes,
         stateObjects,
+        ...(tree.rootNode.hasError && { parseRecovery: true }),
         imports: [],
         exports: []
     };
@@ -656,7 +709,7 @@ function findCallsInCode(code, parser, options = {}) {
         if (!argsNode) return null;
         for (let i = 0; i < argsNode.namedChildCount; i++) {
             const arg = argsNode.namedChild(i);
-            if (arg.type === 'comment') continue;
+            if (arg.type.endsWith('comment')) continue;
             // fmt.Sprintf interpolation
             if (arg.type === 'call_expression') {
                 const inner = arg.childForFieldName('function');
@@ -678,6 +731,8 @@ function findCallsInCode(code, parser, options = {}) {
     const closureScopes = new Map();
     // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
     const scopeTypes = new Map();
+    // Package qualifier paired with an inferred/declared receiver type.
+    const scopeTypeQualifiers = new Map();
     // Names whose scope type is a New*-prefix GUESS (fix #266) — per scope
     const scopeGuesses = new Map();
     // Track function-typed parameter names per scope (scopeStartLine -> Set<name>)
@@ -717,11 +772,31 @@ function findCallsInCode(code, parser, options = {}) {
         return null;
     };
 
+    // Preserve the package qualifier separately from the bare type name.
+    // `http.Handler` and a project-local `Handler` are different identities;
+    // dropping `http.` lets an unrelated same-named project type steal method
+    // dispatch. Pointer wrappers do not change that provenance.
+    const extractTypeQualifier = (typeNode) => {
+        if (!typeNode) return null;
+        if (typeNode.type === 'pointer_type') {
+            for (let i = 0; i < typeNode.namedChildCount; i++) {
+                const q = extractTypeQualifier(typeNode.namedChild(i));
+                if (q) return q;
+            }
+        }
+        if (typeNode.type === 'qualified_type') {
+            const pkg = typeNode.childForFieldName('package') || typeNode.namedChild(0);
+            return pkg?.text || null;
+        }
+        return null;
+    };
+
     // Build type map from function/method parameters and receiver.
     // Also returns funcParamNames: parameter names with function types (func(...) ...)
     // so calls to them can be skipped (they're local parameter calls, not global function calls).
     const buildScopeTypeMap = (node) => {
         const typeMap = new Map();
+        const typeQualifierMap = new Map();
         const funcParamNames = new Set();
 
         // Method receiver: func (f *Framework) Method()
@@ -736,6 +811,8 @@ function findCallsInCode(code, parser, options = {}) {
                         const typeName = extractTypeName(typeNode);
                         if (nameNode && typeName) {
                             typeMap.set(nameNode.text, typeName);
+                            const qualifier = extractTypeQualifier(typeNode);
+                            if (qualifier) typeQualifierMap.set(nameNode.text, qualifier);
                         }
                     }
                 }
@@ -764,14 +841,18 @@ function findCallsInCode(code, parser, options = {}) {
                     } else {
                         const typeName = extractTypeName(typeNode);
                         if (typeName) {
-                            for (const nn of nameNodes) typeMap.set(nn.text, typeName);
+                            const qualifier = extractTypeQualifier(typeNode);
+                            for (const nn of nameNodes) {
+                                typeMap.set(nn.text, typeName);
+                                if (qualifier) typeQualifierMap.set(nn.text, qualifier);
+                            }
                         }
                     }
                 }
             }
         }
 
-        return { typeMap, funcParamNames };
+        return { typeMap, typeQualifierMap, funcParamNames };
     };
 
     // Helper to extract function name from a function node
@@ -824,6 +905,13 @@ function findCallsInCode(code, parser, options = {}) {
         }
         return undefined;
     };
+    const getReceiverTypeQualifier = (varName) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const qualifiers = scopeTypeQualifiers.get(functionStack[i].startLine);
+            if (qualifiers?.has(varName)) return qualifiers.get(varName);
+        }
+        return undefined;
+    };
     // Is the FIRST scope-chain hit for this variable a New*-prefix GUESS
     // (fix #266, viper-measured)? `registry := NewCodecRegistry()` types
     // registry as 'CodecRegistry' by NAME CONVENTION — the actual return
@@ -947,8 +1035,9 @@ function findCallsInCode(code, parser, options = {}) {
                 endLine: node.endPosition.row + 1
             };
             functionStack.push(entry);
-            const { typeMap, funcParamNames } = buildScopeTypeMap(node);
+            const { typeMap, typeQualifierMap, funcParamNames } = buildScopeTypeMap(node);
             scopeTypes.set(entry.startLine, typeMap);
+            scopeTypeQualifiers.set(entry.startLine, typeQualifierMap);
             if (funcParamNames.size > 0) {
                 funcParamScopes.set(entry.startLine, funcParamNames);
             }
@@ -974,15 +1063,20 @@ function findCallsInCode(code, parser, options = {}) {
                     for (let vi = 0; vi < Math.min(names.length, values.length); vi++) {
                         const val = values[vi];
                         let typeName = null;
+                        let typeQualifier = null;
                         let typeGuessed = false;
                         // &Type{...} or Type{...}
                         if (val.type === 'composite_literal') {
-                            typeName = extractTypeName(val.childForFieldName('type'));
+                            const typeNode = val.childForFieldName('type');
+                            typeName = extractTypeName(typeNode);
+                            typeQualifier = extractTypeQualifier(typeNode);
                         } else if (val.type === 'unary_expression' && val.childCount > 0) {
                             for (let ci = 0; ci < val.namedChildCount; ci++) {
                                 const ch = val.namedChild(ci);
                                 if (ch.type === 'composite_literal') {
-                                    typeName = extractTypeName(ch.childForFieldName('type'));
+                                    const typeNode = ch.childForFieldName('type');
+                                    typeName = extractTypeName(typeNode);
+                                    typeQualifier = extractTypeQualifier(typeNode);
                                     break;
                                 }
                             }
@@ -1020,12 +1114,20 @@ function findCallsInCode(code, parser, options = {}) {
                                             : argNode.type === 'selector_expression'
                                                 ? argNode.childForFieldName('field')?.text || null
                                                 : extractTypeName(argNode);
+                                        if (argNode.type === 'selector_expression') {
+                                            typeQualifier = argNode.childForFieldName('operand')?.text || null;
+                                        } else {
+                                            typeQualifier = extractTypeQualifier(argNode);
+                                        }
                                     }
                                 }
                             }
                         }
                         if (typeName) {
                             typeMap.set(names[vi], typeName);
+                            const qualifiers = scopeTypeQualifiers.get(scopeKey);
+                            if (typeQualifier) qualifiers?.set(names[vi], typeQualifier);
+                            else qualifiers?.delete(names[vi]);
                             let gset = scopeGuesses.get(scopeKey);
                             if (typeGuessed) {
                                 if (!gset) { gset = new Set(); scopeGuesses.set(scopeKey, gset); }
@@ -1052,10 +1154,14 @@ function findCallsInCode(code, parser, options = {}) {
                     if (spec.type !== 'var_spec') return;
                     const typeName = extractTypeName(spec.childForFieldName('type'));
                     if (!typeName) return;
+                    const qualifier = extractTypeQualifier(spec.childForFieldName('type'));
                     for (let j = 0; j < spec.namedChildCount; j++) {
                         const id = spec.namedChild(j);
                         if (id.type === 'identifier') {
                             varTypeMap.set(id.text, typeName);
+                            const qualifiers = scopeTypeQualifiers.get(scopeKey);
+                            if (qualifier) qualifiers?.set(id.text, qualifier);
+                            else qualifiers?.delete(id.text);
                             scopeGuesses.get(scopeKey)?.delete(id.text); // declared type clears any guess
                         }
                     }
@@ -1134,7 +1240,7 @@ function findCallsInCode(code, parser, options = {}) {
             let argSpread = false;
             if (argsNode) {
                 for (let i = 0; i < argsNode.namedChildCount; i++) {
-                    if (argsNode.namedChild(i).type === 'comment') continue;
+                    if (argsNode.namedChild(i).type.endsWith('comment')) continue;
                     argCount++;
                 }
                 for (let i = 0; i < argsNode.childCount; i++) {
@@ -1183,20 +1289,32 @@ function findCallsInCode(code, parser, options = {}) {
                     // If receiver is a known import alias, this is a package call, not a method call
                     const isPkgCall = receiver && importAliases.has(receiver);
                     const receiverType = (!isPkgCall && receiver) ? getReceiverType(receiver) : undefined;
+                    const receiverTypeQualifier = receiverType
+                        ? getReceiverTypeQualifier(receiver) : undefined;
                     // fix #202: one-hop declared-field receivers — h.inner.Run().
                     // receiverRoot/Field/RootType let findCallers hop to the
                     // field's declared struct-field type cross-file.
-                    let receiverRoot, receiverFieldName, receiverRootType, receiverRootTypeGuessed;
+                    let receiverRoot, receiverFieldName, receiverRootType,
+                        receiverRootTypeQualifier, receiverRootTypeGuessed,
+                        receiverRootIsModule;
                     if (!receiver && operandNode?.type === 'selector_expression') {
                         const rootNode = operandNode.childForFieldName('operand');
                         const fldNode = operandNode.childForFieldName('field');
-                        if (rootNode?.type === 'identifier' && fldNode &&
-                            !importAliases.has(rootNode.text)) {
+                        if (rootNode?.type === 'identifier' && fldNode) {
                             receiverRoot = rootNode.text;
                             receiverFieldName = fldNode.text;
-                            receiverRootType = getReceiverType(rootNode.text);
-                            if (receiverRootType && isGuessedType(rootNode.text)) {
-                                receiverRootTypeGuessed = true;
+                            if (importAliases.has(rootNode.text)) {
+                                // Package-owned value receiver:
+                                // io.Discard.Write(...). The package qualifier
+                                // is identity evidence even though the value's
+                                // concrete type lives outside the project.
+                                receiverRootIsModule = true;
+                            } else {
+                                receiverRootType = getReceiverType(rootNode.text);
+                                receiverRootTypeQualifier = getReceiverTypeQualifier(rootNode.text);
+                                if (receiverRootType && isGuessedType(rootNode.text)) {
+                                    receiverRootTypeGuessed = true;
+                                }
                             }
                         }
                     }
@@ -1243,9 +1361,12 @@ function findCallsInCode(code, parser, options = {}) {
                         isMethod: !isPkgCall,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverTypeQualifier && { receiverTypeQualifier }),
                         ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                         ...(receiverFieldName && { receiverRoot, receiverField: receiverFieldName }),
+                        ...(receiverRootIsModule && { receiverRootIsModule: true }),
                         ...(receiverFieldName && receiverRootType && { receiverRootType }),
+                        ...(receiverFieldName && receiverRootTypeQualifier && { receiverRootTypeQualifier }),
                         ...(receiverFieldName && receiverRootType && receiverRootTypeGuessed && { receiverRootTypeGuessed: true }),
                         ...(receiverCall && { receiverCall }),
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
@@ -1323,6 +1444,8 @@ function findCallsInCode(code, parser, options = {}) {
                 if (fieldNode && operandNode) {
                     const receiver = operandNode.type === 'identifier' ? operandNode.text : undefined;
                     const receiverType = receiver ? getReceiverType(receiver) : undefined;
+                    const receiverTypeQualifier = receiverType
+                        ? getReceiverTypeQualifier(receiver) : undefined;
                     const enclosingFunction = getCurrentEnclosingFunction();
                     calls.push({
                         name: fieldNode.text,
@@ -1330,6 +1453,7 @@ function findCallsInCode(code, parser, options = {}) {
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverTypeQualifier && { receiverTypeQualifier }),
                         ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                         enclosingFunction,
                         isPotentialCallback: true,
@@ -1379,6 +1503,8 @@ function findCallsInCode(code, parser, options = {}) {
                         if (fieldNode && operandNode) {
                             const receiver = operandNode.type === 'identifier' ? operandNode.text : undefined;
                             const receiverType = receiver ? getReceiverType(receiver) : undefined;
+                            const receiverTypeQualifier = receiverType
+                                ? getReceiverTypeQualifier(receiver) : undefined;
                             const enclosingFunction = getCurrentEnclosingFunction();
                             calls.push({
                                 name: fieldNode.text,
@@ -1386,6 +1512,7 @@ function findCallsInCode(code, parser, options = {}) {
                                 isMethod: true,
                                 receiver,
                                 ...(receiverType && { receiverType }),
+                                ...(receiverTypeQualifier && { receiverTypeQualifier }),
                                 ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                                 enclosingFunction,
                                 isPotentialCallback: true,
@@ -1474,6 +1601,8 @@ function findCallsInCode(code, parser, options = {}) {
                     if (fieldNode && operandNode) {
                         const receiver = operandNode.type === 'identifier' ? operandNode.text : undefined;
                         const receiverType = receiver ? getReceiverType(receiver) : undefined;
+                        const receiverTypeQualifier = receiverType
+                            ? getReceiverTypeQualifier(receiver) : undefined;
                         const enclosingFunction = getCurrentEnclosingFunction();
                         calls.push({
                             name: fieldNode.text,
@@ -1481,6 +1610,7 @@ function findCallsInCode(code, parser, options = {}) {
                             isMethod: true,
                             receiver,
                             ...(receiverType && { receiverType }),
+                            ...(receiverTypeQualifier && { receiverTypeQualifier }),
                             ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                             enclosingFunction,
                             isPotentialCallback: true,

package/languages/html.js

@@ -224,6 +224,9 @@ function extractEventHandlerCalls(htmlContent, htmlParser) {
 // ── Exported language module interface ──────────────────────────────────────
 
 function parse(code, parser) {
+    const { safeParse, getParseOptions } = require('./index');
+    const htmlTree = safeParse(parser, code, undefined, getParseOptions(code.length));
+    const htmlRecovery = !!htmlTree.rootNode.hasError;
     const result = extractJS(code, parser);
     if (!result) {
         return {
@@ -232,6 +235,7 @@ function parse(code, parser) {
             functions: [],
             classes: [],
             stateObjects: [],
+            ...(htmlRecovery && { parseRecovery: true }),
             imports: [],
             exports: []
         };
@@ -240,6 +244,7 @@ function parse(code, parser) {
     const jsResult = result.jsModule.parse(result.virtualJS, result.jsParser);
     jsResult.language = 'html';
     jsResult.totalLines = code.split('\n').length;
+    if (htmlRecovery) jsResult.parseRecovery = true;
     return jsResult;
 }
 

package/languages/index.js

@@ -50,6 +50,9 @@ const STRUCTURAL_TRAITS = {
     // assignment rebinds functions onto objects (obj.print = print), so the
     // #218b gate routes such calls visible instead of excluding (fix #220).
     methodCallReachesFunctions: true,
+    // Whether `Type(...)` constructs a class without a `new` token. Python
+    // classes are ordinary callable objects; JS/TS classes require `new`.
+    classesCallableWithoutNew: false,
 };
 const NOMINAL_TRAITS = {
     typeSystem: 'nominal',
@@ -113,6 +116,7 @@ const NOMINAL_TRAITS = {
     // Go method values (obj.Method) and Java `::` references DO denote
     // methods — false. Per-language override, not preset-wide.
     memberAccessNeverMethod: false,
+    classesCallableWithoutNew: false,
 };
 
 // Language configurations
@@ -170,6 +174,7 @@ const LANGUAGES = {
             // and query code treats such receivers as module receivers. JS
             // from-imports bind values only (`import * as ns` is parser-marked).
             submoduleImports: true,
+            classesCallableWithoutNew: true,
             testFileCandidates: (base, ext) => [`test_${base}.py`, `${base}_test.py`],
             testDirs: ['tests'],
         },

package/languages/java.js

@@ -295,6 +295,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 isConstructor: true,
                 ...(docstring && { docstring }),
                 ...(annotations.length > 0 && { annotations }),
+                ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
                 ...(nameLine !== startLine && { nameLine })
             });
         }
@@ -423,7 +424,8 @@ function _processClass(node, classes, processedRanges, lines, code) {
                 members: extractEnumConstants(node, lines),
                 modifiers,
                 ...(docstring && { docstring }),
-                ...(annotations.length > 0 && { annotations })
+                ...(annotations.length > 0 && { annotations }),
+                ...(annotationsWithArgs.length > 0 && { annotationsWithArgs })
             });
         }
         return true;
@@ -479,6 +481,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
                 ...(docstring && { docstring }),
                 ...(generics && { generics }),
                 ...(annotations.length > 0 && { annotations }),
+                ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
                 ...(implementsInfo.length > 0 && { implements: implementsInfo })
             });
         }
@@ -843,6 +846,7 @@ function parse(code, parser) {
         functions,
         classes,
         stateObjects,
+        ...(tree.rootNode.hasError && { parseRecovery: true }),
         imports: [],
         exports: []
     };
@@ -869,7 +873,7 @@ function findCallsInCode(code, parser) {
         if (!argsNode) return null;
         for (let i = 0; i < argsNode.namedChildCount; i++) {
             const arg = argsNode.namedChild(i);
-            if (arg.type === 'comment') continue;
+            if (arg.type.endsWith('comment')) continue;
             return _extractStringArg(arg);
         }
         return null;
@@ -979,6 +983,7 @@ function findCallsInCode(code, parser) {
     // as an implicit-this field when NO local of that name is declared —
     // mistyping a shadowed local could wrongly exclude a true caller.
     const scopeDeclared = new Map();
+    const scopedTypeRestores = new Map();
     const collectDeclaredNames = (fnNode) => {
         const declared = new Set();
         const walk = (n) => {
@@ -1064,6 +1069,27 @@ function findCallsInCode(code, parser) {
                 const tn = arg.childForFieldName('type');
                 return tn ? `cast:${bareTypeName(tn.text)}` : 'expr';
             }
+            case 'class_literal': {
+                const tn = arg.namedChild(0);
+                return tn ? `class:${bareTypeName(tn.text)}` : 'class:Object';
+            }
+            case 'identifier': {
+                const typeName = getReceiverType(arg.text);
+                return typeName ? `type:${bareTypeName(typeName)}` : 'expr';
+            }
+            case 'method_invocation': {
+                // Preserve compiler-visible producer ownership for nested
+                // static factories: build(CodeBlock.of(...)) can select a
+                // CodeBlock overload without guessing from the method name.
+                const ownerNode = arg.childForFieldName('object');
+                const methodNode = arg.childForFieldName('name');
+                if (ownerNode?.type === 'identifier' && methodNode) {
+                    const ownerType = getReceiverType(ownerNode.text) ||
+                        (/^[A-Z]/.test(ownerNode.text) ? ownerNode.text : null);
+                    if (ownerType) return `call:${bareTypeName(ownerType)}:${methodNode.text}`;
+                }
+                return 'expr';
+            }
             case 'lambda_expression':
             case 'method_reference': return 'lambda';
             case 'unary_expression':
@@ -1078,7 +1104,7 @@ function findCallsInCode(code, parser) {
         const kinds = [];
         for (let i = 0; i < argsNode.namedChildCount; i++) {
             const arg = argsNode.namedChild(i);
-            if (arg.type === 'comment') continue;
+            if (arg.type.endsWith('comment')) continue;
             kinds.push(argKindOf(arg));
         }
         return { argCount: kinds.length, argKinds: kinds.some(k => k !== 'expr') ? kinds : null };
@@ -1097,6 +1123,26 @@ function findCallsInCode(code, parser) {
             scopeDeclared.set(entry.startLine, collectDeclaredNames(node));
         }
 
+        // Enhanced-for variables are compiler-typed locals whose scope is
+        // exactly the loop body. Record the type before visiting the body and
+        // restore any shadowed outer binding on leave.
+        if (node.type === 'enhanced_for_statement' && functionStack.length > 0) {
+            const typeNode = node.childForFieldName('type');
+            const nameNode = node.childForFieldName('name');
+            const typeName = extractTypeName(typeNode);
+            const scopeKey = functionStack[functionStack.length - 1].startLine;
+            const typeMap = scopeTypes.get(scopeKey);
+            if (nameNode && typeName && typeMap) {
+                scopedTypeRestores.set(node.id, {
+                    typeMap,
+                    name: nameNode.text,
+                    had: typeMap.has(nameNode.text),
+                    previous: typeMap.get(nameNode.text),
+                });
+                typeMap.set(nameNode.text, typeName);
+            }
+        }
+
         // Handle method invocations: foo(), obj.foo(), this.foo()
         if (node.type === 'method_invocation') {
             const nameNode = node.childForFieldName('name');
@@ -1121,7 +1167,12 @@ function findCallsInCode(code, parser) {
                                 receiverFieldName = fldNode.text;
                                 receiverRootType = findEnclosingClassName(node);
                             } else if (rootNode.type === 'identifier') {
-                                const rootType = getReceiverType(rootNode.text);
+                                // `TypeName.CONSTANT.method()` is a one-hop
+                                // static-field receiver. The capitalized root
+                                // is type identity, then the field declaration
+                                // supplies the value's static type.
+                                const rootType = getReceiverType(rootNode.text) ||
+                                    (/^[A-Z]/.test(rootNode.text) ? rootNode.text : undefined);
                                 if (rootType) {
                                     receiverRoot = rootNode.text;
                                     receiverFieldName = fldNode.text;
@@ -1363,6 +1414,12 @@ function findCallsInCode(code, parser) {
         return true;
     }, {
         onLeave: (node) => {
+            const restore = scopedTypeRestores.get(node.id);
+            if (restore) {
+                if (restore.had) restore.typeMap.set(restore.name, restore.previous);
+                else restore.typeMap.delete(restore.name);
+                scopedTypeRestores.delete(node.id);
+            }
             if (isFunctionNode(node)) {
                 const leaving = functionStack.pop();
                 if (leaving) {