ucn 5.1.1 → 5.2.1

package/languages/c-family.js

@@ -313,6 +313,7 @@ const allSourceTreeBySelected = new WeakMap();
 // name merely to rediscover the same handful of macro definitions. Trees are
 // immutable, so retain the exact AST node set without retaining dead trees.
 const macroDefinitionsByTree = new WeakMap();
+const macroParamEffectsByDefinition = new WeakMap();
 
 function macroDefinitionNodes(tree) {
     const cached = macroDefinitionsByTree.get(tree);
@@ -512,27 +513,18 @@ function conditionalRecoverySources(code) {
 }
 
 function treeStructureScore(tree) {
-    let declarations = 0;
-    let calls = 0;
     const declarationTypes = new Set([
         'function_definition', 'class_specifier', 'struct_specifier',
         'union_specifier', 'enum_specifier', 'type_definition',
     ]);
-    const cursor = tree.walk();
-    let entered = true;
-    while (entered) {
-        const type = cursor.nodeType;
-        if (declarationTypes.has(type)) declarations++;
-        else if (type === 'call_expression') calls++;
-        if (cursor.gotoFirstChild()) continue;
-        while (!cursor.gotoNextSibling()) {
-            if (!cursor.gotoParent()) {
-                entered = false;
-                break;
-            }
-        }
-    }
-    cursor.delete?.();
+    // `descendantsOfType` performs the filtering in tree-sitter's native
+    // cursor. Recovery can score the same large source under as many as 14
+    // bounded preprocessor views; walking every node through the JS bridge
+    // made scoring alone a material part of cold C/C++ build CPU. The native
+    // query returns the exact same node sets and therefore preserves the
+    // recovery ordering contract while avoiding thousands of wrapper calls.
+    const declarations = tree.rootNode.descendantsOfType([...declarationTypes]).length;
+    const calls = tree.rootNode.descendantsOfType('call_expression').length;
     return declarations * 1000 + calls;
 }
 
@@ -964,6 +956,24 @@ function isTemplateDependentCallable(node) {
     return false;
 }
 
+// `template <> bool f<bool>(...)` is a FULL specialization: the same compiler
+// symbol as its primary template, selected by substitution rather than
+// overload resolution (fix #299). Every enclosing template head must be
+// empty — one non-empty parameter list means a member of a class template
+// (partial-specialization territory for classes; ordinary dependence here).
+function isFullSpecializationCallable(node) {
+    let sawTemplateHead = false;
+    for (let parent = node?.parent; parent; parent = parent.parent) {
+        if (parent.type === 'template_declaration') {
+            const params = parent.childForFieldName('parameters');
+            if (!params || params.namedChildCount > 0) return false;
+            sawTemplateHead = true;
+        }
+        if (parent.type === 'translation_unit') break;
+    }
+    return sawTemplateHead;
+}
+
 // Full type text for a NAMED parameter: the parameter's own text with the
 // name removed — `const char *s` → `const char *`, `int **pp` → `int **`,
 // `void (*cb)(int)` → `void (*)(int)`. Reading around the identifier keeps
@@ -1217,6 +1227,9 @@ function memberFromNode(node, className, access, lines, mode) {
         ...(mode === 'cpp' && isTemplateDependentCallable(node) && {
             templateDependent: true,
         }),
+        ...(mode === 'cpp' && isFullSpecializationCallable(node) && {
+            isSpecialization: true,
+        }),
         ...(mode === 'cpp' && cLanguageLinkage(node) && {
             linkage: cLanguageLinkage(node),
         }),
@@ -1516,6 +1529,9 @@ function findFunctionsInTree(code, tree, mode, sourceLines = null) {
             ...(mode === 'cpp' && isTemplateDependentCallable(node) && {
                 templateDependent: true,
             }),
+            ...(mode === 'cpp' && isFullSpecializationCallable(node) && {
+                isSpecialization: true,
+            }),
             ...(returnedConcreteType && { returnedConcreteType }),
             ...(mode === 'cpp' && cLanguageLinkage(node) && {
                 linkage: cLanguageLinkage(node),
@@ -1658,7 +1674,112 @@ function findStateObjects(code, parser) {
         item => `${item.name}:${item.startLine}`) : primary;
 }
 
-function findMacrosInTree(tree, lines) {
+function collectMacroParameterEffects(nestedTree, parameters) {
+    const effects = [];
+    traverseTree(nestedTree.rootNode, node => {
+        // Token-paste after a global qualifier (`::_##call`) is not C++
+        // until preprocessing. tree-sitter preserves the `#call` token as
+        // a preprocessor node next to an AST global qualified identifier;
+        // that exact shape still proves the substituted callable is
+        // globally qualified.
+        if (node.type === 'preproc_directive' &&
+            node.text.startsWith('#')) {
+            const paramIndex = parameters.indexOf(node.text.slice(1));
+            let globalSibling = false;
+            let container = node.parent;
+            for (let hops = 0; container && hops < 3 && !globalSibling;
+                hops++, container = container.parent) {
+                const stack = [...(container.namedChildren || [])];
+                while (stack.length > 0 && !globalSibling) {
+                    const sibling = stack.pop();
+                    if (sibling === node) continue;
+                    if (sibling.type === 'qualified_identifier' &&
+                        sibling.children?.[0]?.type === '::') {
+                        globalSibling = true;
+                        break;
+                    }
+                    for (const child of sibling.namedChildren || []) {
+                        stack.push(child);
+                    }
+                }
+            }
+            if (paramIndex >= 0 && globalSibling) {
+                effects.push({
+                    paramIndex,
+                    kind: 'qualified',
+                    qualifier: 'global',
+                });
+            }
+            return true;
+        }
+        if (node.type !== 'identifier') return true;
+        const paramIndex = parameters.indexOf(node.text);
+        if (paramIndex < 0) return true;
+        const parent = node.parent;
+        if (parent?.type === 'qualified_identifier' &&
+            parent.childForFieldName('name') === node) {
+            const scope = parent.childForFieldName('scope');
+            effects.push({
+                paramIndex,
+                kind: 'qualified',
+                qualifier: scope?.text || 'global',
+            });
+            return true;
+        }
+        if (parent?.type === 'argument_list' &&
+            parent.parent?.type === 'call_expression') {
+            const wrapper = callIdentity(
+                parent.parent.childForFieldName('function'));
+            if (!wrapper.name || !isMacroToken(wrapper.name)) return true;
+            const args = (parent.namedChildren || [])
+                .filter(child => !child.type.endsWith('comment'));
+            const argIndex = args.findIndex(argument =>
+                argument.startIndex <= node.startIndex &&
+                node.endIndex <= argument.endIndex);
+            if (argIndex >= 0) {
+                effects.push({
+                    paramIndex,
+                    kind: 'forwarded',
+                    macro: wrapper.name,
+                    argIndex,
+                });
+            }
+        }
+        return true;
+    });
+    return effects;
+}
+
+function macroParameterEffects(definitionNode, valueNode, paramsNode, parser) {
+    if (definitionNode && macroParamEffectsByDefinition.has(definitionNode)) {
+        return macroParamEffectsByDefinition.get(definitionNode);
+    }
+    if (!valueNode || !paramsNode || !parser) return [];
+    const parameters = (paramsNode.namedChildren || [])
+        .filter(child => child.type === 'identifier')
+        .map(child => child.text);
+    if (parameters.length === 0) return [];
+    const body = valueNode.text.replace(/\\(?=\r?\n)/g, ' ');
+    // Cheap parse-avoidance only; every semantic decision below comes from
+    // the replacement list's tree. Ordinary value/punctuation macros need no
+    // extra native tree.
+    if (!body.includes('::') &&
+        !/[A-Z_][A-Z0-9_]*\s*\(/.test(body)) return [];
+    const prefix = 'void __ucn_macro_effect__(void) {\n';
+    const synthetic = `${prefix}${body}\n;}`;
+    const nestedTree = safeParse(parser, synthetic, undefined, PARSE_OPTIONS);
+    try {
+        const effects = collectMacroParameterEffects(nestedTree, parameters);
+        if (definitionNode) {
+            macroParamEffectsByDefinition.set(definitionNode, effects);
+        }
+        return effects;
+    } finally {
+        nestedTree.delete?.();
+    }
+}
+
+function findMacrosInTree(tree, lines, parser) {
     const macros = [];
     for (const node of macroDefinitionNodes(tree)) {
         const nameNode = node.childForFieldName('name') ||
@@ -1684,6 +1805,17 @@ function findMacrosInTree(tree, lines) {
                 : undefined,
             modifiers: [],
             functionLike: node.type === 'preproc_function_def',
+            ...(() => {
+                const effects = macroParameterEffects(
+                    node,
+                    node.childForFieldName('value') ||
+                        (node.namedChildren || []).find(child =>
+                            child.type === 'preproc_arg'),
+                    paramsNode,
+                    parser);
+                return effects.length > 0
+                    ? { macroParamEffects: effects } : {};
+            })(),
             docstring: extractJSDocstring(lines, startLine),
         });
     }
@@ -1693,10 +1825,10 @@ function findMacrosInTree(tree, lines) {
 function findMacros(code, parser) {
     const tree = parseTree(parser, code);
     const lines = code.split('\n');
-    const primary = findMacrosInTree(tree, lines);
+    const primary = findMacrosInTree(tree, lines, parser);
     const literal = literalRecoveryTree(parser, code, tree);
     return literal ? mergeExtracted(primary,
-        findMacrosInTree(literal, lines),
+        findMacrosInTree(literal, lines, parser),
         item => `${item.name}:${item.startLine}:${item.functionLike ? 1 : 0}`) : primary;
 }
 
@@ -1789,6 +1921,23 @@ function buildVariableTypes(tree) {
     // block declaration.
     const memberReceiverUses = [];
     const ambiguousDirectInitializers = [];
+    const declaratorStaticType = (type, declarator) => {
+        // The declaration's type node carries only the base type. Preserve
+        // array rank from the AST declarator for overload arguments:
+        // `wchar_t format_str[]; runtime(format_str)` passes a wide-character
+        // array (and decays to wchar_t*), not a scalar wchar_t. Receiver
+        // typing continues to use the base `type`; only static argument shape
+        // consumes this fuller spelling.
+        let arrays = 0;
+        const stack = [declarator];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (!current) continue;
+            if (current.type === 'array_declarator') arrays++;
+            for (const child of current.namedChildren || []) stack.push(child);
+        }
+        return arrays > 0 ? `${type}${'[]'.repeat(arrays)}` : type;
+    };
     const addBindings = (node, type, pointeeType, scope, declarators) => {
         for (const declarator of declarators) {
             const identity = declaratorIdentity(declarator);
@@ -1796,6 +1945,7 @@ function buildVariableTypes(tree) {
             bindings.push({
                 name: identity.name,
                 type,
+                staticType: declaratorStaticType(type, declarator),
                 ...(pointeeType && { pointeeType }),
                 declaredAt: node.type === 'parameter_declaration'
                     ? scope.startIndex : declarator.startIndex,
@@ -1893,6 +2043,7 @@ function buildVariableTypes(tree) {
     };
     return {
         get: (name, atNode) => resolveBinding(name, atNode)?.type,
+        getStatic: (name, atNode) => resolveBinding(name, atNode)?.staticType,
         getPointee: (name, atNode) =>
             resolveBinding(name, atNode)?.pointeeType,
         has: (name, atNode) => resolveBinding(name, atNode) !== undefined,
@@ -1963,7 +2114,8 @@ function staticArgumentKind(node, variableTypes) {
     if (node.type === 'true' || node.type === 'false') return 'bool';
     if (node.type === 'null' || node.type === 'nullptr') return 'null';
     if (node.type === 'identifier') {
-        const type = variableTypes?.get(node.text, node);
+        const type = variableTypes?.getStatic(node.text, node) ||
+            variableTypes?.get(node.text, node);
         return type ? `type:${type}` : 'expr';
     }
     if (node.type === 'compound_literal_expression') {
@@ -1998,6 +2150,18 @@ function staticArgumentKind(node, variableTypes) {
             const type = typeName(typeNode);
             if (type) return `type:${type}`;
         }
+        // Bare-identifier producers are name-resolvable (fix #299B): mark
+        // them `bcall:` so the overload discipline can type the argument
+        // from the producer's declared return type. A local callable
+        // variable shadows the project name — those record plain 'expr'
+        // (the #203 localShadow rule at kind-recording time). Member,
+        // qualified, and template-explicit producers keep `call:NAME`.
+        if (identity.name && !identity.isMethod && !identity.isPathCall &&
+            identity.nameNode && IDENTIFIER_NODES.has(identity.nameNode.type) &&
+            fnNode && IDENTIFIER_NODES.has(fnNode.type)) {
+            if (variableTypes?.get(identity.name, node)) return 'expr';
+            return `bcall:${identity.name}`;
+        }
         return identity.name ? `call:${identity.name}` : 'expr';
     }
     return 'expr';
@@ -2202,6 +2366,46 @@ function fieldReceiverPath(node) {
     return { root: base.root, fields: [...base.fields, field.text] };
 }
 
+/** Macro invocations whose argument expression contains this call node. */
+function enclosingMacroArguments(node) {
+    const wrappers = [];
+    let current = node;
+    let hops = 0;
+    while (current?.parent && hops++ < 24) {
+        const argumentsNode = current.parent;
+        const outerCall = argumentsNode?.type === 'argument_list'
+            ? argumentsNode.parent : null;
+        if (outerCall?.type === 'call_expression') {
+            const wrapper = callIdentity(
+                outerCall.childForFieldName('function'));
+            if (wrapper.name && isMacroToken(wrapper.name)) {
+                const args = (argumentsNode.namedChildren || [])
+                    .filter(child => !child.type.endsWith('comment'));
+                const argIndex = args.findIndex(argument =>
+                    argument.startIndex <= node.startIndex &&
+                    node.endIndex <= argument.endIndex);
+                if (argIndex >= 0) {
+                    wrappers.push({ name: wrapper.name, argIndex });
+                }
+            }
+            current = outerCall;
+            continue;
+        }
+        // Once the walk leaves an expression, no outer macro invocation can
+        // contain this call. Stopping here keeps the common non-macro path
+        // constant-depth instead of climbing every call to the translation
+        // unit (material on template-heavy fmt headers).
+        if (/(?:statement|declaration|definition)$/.test(
+            argumentsNode.type) ||
+            argumentsNode.type === 'translation_unit' ||
+            argumentsNode.type === 'init_declarator') {
+            break;
+        }
+        current = current.parent;
+    }
+    return wrappers;
+}
+
 function findCallsInTree(code, parser, _options = {}, existingTree = null,
     includeMacroBodies = true) {
     const tree = existingTree || parseTree(parser, code);
@@ -2281,6 +2485,7 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
                 : undefined;
             const assignedTo = assignmentTargetOf(node);
             const compileTimeOnly = compileTimeOnlyContext(node);
+            const macroArguments = enclosingMacroArguments(node);
             calls.push({
                 name: identity.name,
                 line: identity.nameNode?.startPosition.row + 1 || node.startPosition.row + 1,
@@ -2295,6 +2500,7 @@ function findCallsInTree(code, parser, _options = {}, existingTree = null,
                     explicitTemplateCall: true,
                 }),
                 ...(compileTimeOnly && { compileTimeOnly }),
+                ...(macroArguments.length > 0 && { macroArguments }),
                 ...(directReceiverType && { receiverType: directReceiverType }),
                 ...(receiverCall && {
                     receiverCall,
@@ -2474,9 +2680,10 @@ function findMacroBodyCalls(tree, code, parser, onlyName = null) {
         if (onlyName && !valueNode.text.includes(onlyName)) continue;
         const paramsNode = node.childForFieldName('parameters') ||
             (node.namedChildren || []).find(child => child.type === 'preproc_params');
-        const parameters = new Set((paramsNode?.namedChildren || [])
+        const parameterNames = (paramsNode?.namedChildren || [])
             .filter(child => child.type === 'identifier')
-            .map(child => child.text));
+            .map(child => child.text);
+        const parameters = new Set(parameterNames);
         // Replace only the continuation backslash. Keeping the newline and
         // every other byte makes source-line/column and span remapping exact.
         const body = valueNode.text.replace(/\\(?=\r?\n)/g, ' ');
@@ -2490,6 +2697,12 @@ function findMacroBodyCalls(tree, code, parser, onlyName = null) {
         const nestedTree = safeParse(parser, synthetic, undefined, PARSE_OPTIONS);
         let nested;
         try {
+            macroParamEffectsByDefinition.set(
+                node,
+                body.includes('::') ||
+                    /[A-Z_][A-Z0-9_]*\s*\(/.test(body)
+                    ? collectMacroParameterEffects(nestedTree, parameterNames)
+                    : []);
             nested = findCallsInCode(synthetic, parser, {}, nestedTree, false);
         } finally {
             nestedTree.delete?.();
@@ -2725,10 +2938,10 @@ function parse(code, parser, mode, options = {}) {
                     item => `${item.name}:${item.startLine}`)
                 : findStateObjectsInTree(tree, lines),
             macros: literal
-                ? mergeExtracted(findMacrosInTree(tree, lines),
-                    findMacrosInTree(literal, lines),
+                ? mergeExtracted(findMacrosInTree(tree, lines, parser),
+                    findMacrosInTree(literal, lines, parser),
                     item => `${item.name}:${item.startLine}:${item.functionLike ? 1 : 0}`)
-                : findMacrosInTree(tree, lines),
+                : findMacrosInTree(tree, lines, parser),
             imports,
             exports: [
                 ...functions

package/languages/csharp.js

@@ -293,7 +293,7 @@ function propertyMember(node, lines) {
         endLine,
         indent,
         modifiers: modifiersOf(node),
-        memberType: 'field',
+        memberType: 'property',
         fieldType: typeNode?.text || null,
     };
 }
@@ -1155,10 +1155,21 @@ function findCallsInCode(code, parser) {
                 : functionNode?.type === 'conditional_access_expression'
                     ? functionNode.childForFieldName('condition') || functionNode.namedChild(0)
                     : null;
-            const receiverTypeInfo = receiverTypeFromNode(receiverNode, variableTypes) ||
-                normalizeReceiverType(receiverRoot && variableTypes.get(receiverRoot));
-            const receiverType = receiverTypeInfo?.name;
             const unwrappedReceiverNode = unwrapReceiverNode(receiverNode);
+            // A root variable's type is the receiver type only for a direct
+            // `value.Method()` call. For `value.Property.Method()` the static
+            // receiver type is the property's declared type, not `value`'s
+            // type. Preserve that shape as a field path for query-time
+            // declaration walking; collapsing it to the root class falsely
+            // confirms sibling overrides (Newtonsoft JProperty.Value is a
+            // JToken, not a JProperty).
+            const receiverTypeInfo = receiverTypeFromNode(
+                receiverNode, variableTypes) ||
+                (unwrappedReceiverNode?.type === 'identifier'
+                    ? normalizeReceiverType(
+                        receiverRoot && variableTypes.get(receiverRoot))
+                    : null);
+            const receiverType = receiverTypeInfo?.name;
             const receiverCastThis = receiverCastIsThis(receiverNode);
             const receiverIsTypeQualified = !!(identity.isMethod &&
                 unwrappedReceiverNode?.type === 'identifier' &&
@@ -1301,6 +1312,7 @@ function findImportsInCode(code, parser) {
 function findUsagesInCode(code, name, parser, existingTree) {
     const tree = existingTree || parseTree(parser, code);
     const usages = [];
+    const variableTypesByScope = buildVariableTypes(tree, parser);
     visitNameNodes(tree, code, name, node => {
         if (!IDENTIFIER_NODES.has(node.type) || node.text !== name) return;
         let usageType = 'reference';
@@ -1309,6 +1321,8 @@ function findUsagesInCode(code, name, parser, existingTree) {
             if ((parent.type === 'method_declaration' ||
                 parent.type === 'constructor_declaration' ||
                 TYPE_DECLARATIONS.has(parent.type) ||
+                parent.type === 'property_declaration' ||
+                parent.type === 'event_declaration' ||
                 parent.type === 'parameter' ||
                 parent.type === 'variable_declarator') &&
                 (sameNode(parent.childForFieldName('name'), node))) {
@@ -1319,6 +1333,28 @@ function findUsagesInCode(code, name, parser, existingTree) {
             } else if (parent.type === 'using_directive') {
                 usageType = 'import';
             }
+            if (parent.type === 'member_access_expression' &&
+                sameNode(parent.childForFieldName('name'), node)) {
+                const receiverNode = parent.childForFieldName('expression') ||
+                    parent.namedChild(0);
+                const receiver = receiverNode?.text;
+                const scopeTypes = variableTypesByScope.get(variableScopeKey(node)) ||
+                    variableTypesByScope.get('global');
+                const declared = receiverNode?.type === 'identifier'
+                    ? normalizeReceiverType(scopeTypes?.get(receiver)) : null;
+                const sameClass = ['this', 'base'].includes(receiver)
+                    ? enclosingClassName(node) : null;
+                usages.push({
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                    usageType,
+                    ...(receiver && { receiver }),
+                    ...((declared?.name || sameClass) && {
+                        receiverType: declared?.name || sameClass,
+                    }),
+                });
+                return true;
+            }
         }
         usages.push({
             line: node.startPosition.row + 1,