ucn 4.0.1 → 4.1.0

package/languages/javascript.js

@@ -14,6 +14,7 @@ const {
     extractJSDocstring,
     buildTypeAnnotations,
     visitNameNodes,
+    sameNode,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -99,14 +100,37 @@ function getAssignmentName(leftNode) {
 }
 
 /**
- * Extract modifiers from function text
+ * Extract modifiers from a declaration NODE — AST tokens, never text
+ * (fix #249: the first-line regex fabricated export/async/default from
+ * string literals, comments, and `m?.default?.()` on one-line functions,
+ * leaking fake exports into api/fileExports and corrupting isAsync).
+ * Accepts the declaration or its export_statement wrapper.
  */
-function extractModifiers(text) {
+function extractModifiers(node) {
     const mods = [];
-    const firstLine = text.split('\n')[0];
-    if (/\bexport\b/.test(firstLine)) mods.push('export');
-    if (/\basync\b/.test(firstLine)) mods.push('async');
-    if (/\bdefault\b/.test(firstLine)) mods.push('default');
+    if (!node) return mods;
+    let decl = node;
+    if (node.type === 'export_statement') {
+        mods.push('export');
+        decl = node.childForFieldName('declaration') || node;
+    }
+    // Resolve to the actual function-shaped node: `const x = async () => {}`
+    // keeps its async token on the arrow, not the declaration.
+    if (decl.type === 'lexical_declaration' || decl.type === 'variable_declaration') {
+        const declarator = decl.namedChildren.find(c => c.type === 'variable_declarator');
+        const value = declarator && declarator.childForFieldName('value');
+        if (value) decl = value;
+    }
+    let isAsync = false;
+    for (let i = 0; i < decl.childCount; i++) {
+        if (decl.child(i).type === 'async') { isAsync = true; break; }
+    }
+    if (isAsync) mods.push('async');
+    if (node.type === 'export_statement') {
+        for (let i = 0; i < node.childCount; i++) {
+            if (node.child(i).type === 'default') { mods.push('default'); break; }
+        }
+    }
     return mods;
 }
 
@@ -277,8 +301,8 @@ function _processFunction(node, functions, processedRanges, lines) {
             const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
             // Check parent for export status (function_declaration inside export_statement)
             const modifiers = node.parent && node.parent.type === 'export_statement'
-                ? extractModifiers(node.parent.text)
-                : extractModifiers(node.text);
+                ? extractModifiers(node.parent)
+                : extractModifiers(node);
             // Feature B: explicit isAsync flag (auditAsync needs to know whether
             // the fn was declared `async function`).
             const isAsync = modifiers.includes('async');
@@ -364,8 +388,8 @@ function _processFunction(node, functions, processedRanges, lines) {
                         const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
                         // Check parent for export status (lexical_declaration inside export_statement)
                         const modifiers = node.parent && node.parent.type === 'export_statement'
-                            ? extractModifiers(node.parent.text)
-                            : extractModifiers(node.text);
+                            ? extractModifiers(node.parent)
+                            : extractModifiers(node);
                         // Feature B: detect async — for arrow/fn-expressions the `async`
                         // keyword precedes the parameter list on the value node, NOT on
                         // the lexical_declaration text. extractModifiers walked the full
@@ -417,8 +441,8 @@ function _processFunction(node, functions, processedRanges, lines) {
                                         const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
                                         const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
                                         const modifiers = node.parent && node.parent.type === 'export_statement'
-                                            ? extractModifiers(node.parent.text)
-                                            : extractModifiers(node.text);
+                                            ? extractModifiers(node.parent)
+                                            : extractModifiers(node);
 
                                         functions.push({
                                             name: nameNode.text,
@@ -509,6 +533,48 @@ function _processFunction(node, functions, processedRanges, lines) {
                         ...(docstring && { docstring })
                     });
                 }
+            } else if (rightNode.type === 'object') {
+                // CJS export object maps (fix #252): the functions in
+                // `module.exports = { doThing(x) {...}, h: function() {...} }`
+                // are the module's public API — prototype and exports.h
+                // assignments were indexed while this shape was invisible
+                // to fn/find/toc.
+                const lhsText = leftNode.text;
+                if (lhsText === 'module.exports' || lhsText === 'exports' ||
+                    lhsText.startsWith('module.exports.') || lhsText.startsWith('exports.')) {
+                    processedRanges.add(rangeKey);
+                    for (let pi = 0; pi < rightNode.namedChildCount; pi++) {
+                        const prop = rightNode.namedChild(pi);
+                        let nameNode = null;
+                        let fnNode = null;
+                        if (prop.type === 'method_definition') {
+                            nameNode = prop.childForFieldName('name');
+                            fnNode = prop;
+                        } else if (prop.type === 'pair') {
+                            const v = prop.childForFieldName('value');
+                            if (v && (v.type === 'function_expression' ||
+                                v.type === 'arrow_function' || v.type === 'generator_function')) {
+                                nameNode = prop.childForFieldName('key');
+                                fnNode = v;
+                            }
+                        }
+                        if (!nameNode || !fnNode) continue;
+                        const paramsNode = fnNode.childForFieldName('parameters');
+                        const { startLine, endLine, indent } = nodeToLocation(prop, lines);
+                        const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                        functions.push({
+                            name: nameNode.text,
+                            params: extractParams(paramsNode),
+                            paramsStructured,
+                            startLine,
+                            endLine,
+                            indent,
+                            isArrow: fnNode.type === 'arrow_function',
+                            isGenerator: isGenerator(fnNode),
+                            modifiers: [],
+                        });
+                    }
+                }
             }
         }
         return true;
@@ -959,6 +1025,13 @@ function extractClassMembers(classNode, codeOrLines) {
                 const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
 
                 const decoratorsWithArgs = extractDecoratorsWithArgs(child);
+                // TS accessibility keywords (fix #247): `private`/`protected`
+                // members are not public API — without this, deadcode's
+                // exported-member check treated them as implicitly public and
+                // hid them from the default audit. `public` is the default
+                // and stays unrecorded (recording it would read as an export
+                // marker in symbolIsExported).
+                const accessMatch = text.match(/^\s*(private|protected)\s/);
                 members.push({
                     name,
                     params: extractParams(paramsNode),
@@ -966,9 +1039,14 @@ function extractClassMembers(classNode, codeOrLines) {
                     startLine,
                     endLine,
                     memberType,
+                    ...(accessMatch && { modifiers: [accessMatch[1]] }),
                     isAsync,
                     isGenerator: isGen,
                     isMethod: true,  // Mark as method for context() lookups
+                    // TS method OVERLOAD signatures (body-less method_signature
+                    // in a class body) mirror the standalone-function marker
+                    // (fix #230) — pickBestDefinition prefers the implementation.
+                    ...(child.type === 'method_signature' && { isSignature: true }),
                     ...typeAnno,
                     ...(docstring && { docstring }),
                     ...(decorators.length > 0 && { decorators }),
@@ -1657,6 +1735,25 @@ function findCallsInCode(code, parser) {
                     localVarTypes.set(left.text, ctorName);
                 }
             }
+            // Handler-registration references (fix #252, the #221 family's
+            // missing shape): `window.onload = secondPageInit` /
+            // `element.onclick = handler` establish the call relationship
+            // through property assignment — plain assignment RHS and
+            // argument-position references were captured, the
+            // member-expression LHS shape recorded nothing, so search
+            // --unused claimed live handlers dead.
+            if (left?.type === 'member_expression' && right?.type === 'identifier' &&
+                !SKIP_IDENTS.has(right.text) && !nonCallableNames.has(right.text)) {
+                calls.push({
+                    name: right.text,
+                    line: right.startPosition.row + 1,
+                    isMethod: false,
+                    isFunctionReference: true,
+                    isPotentialCallback: true,
+                    ...(isShadowedByLocal(right, right.text) && { localShadow: true }),
+                    enclosingFunction: getCurrentEnclosingFunction(),
+                });
+            }
         }
 
         // Handle regular function calls: foo(), obj.foo(), foo.call()
@@ -1694,6 +1791,21 @@ function findCallsInCode(code, parser) {
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
                     ...(optionsMethod && { optionsMethod })
                 });
+            } else if (funcNode.type === 'super') {
+                // super(config) — the subclass constructor invoking the
+                // parent class's constructor (fix #238; these sites were
+                // invisible to every command). Recorded as a super-received
+                // 'constructor' method call so the super walk resolves it to
+                // the parent class's constructor definition.
+                calls.push({
+                    name: 'constructor',
+                    line: node.startPosition.row + 1,
+                    isMethod: true,
+                    receiver: 'super',
+                    argCount: node.childForFieldName('arguments')?.namedChildCount ?? 0,
+                    enclosingFunction,
+                    uncertain: false,
+                });
             } else if (funcNode.type === 'member_expression') {
                 // Method call: obj.foo() or foo.call/apply/bind()
                 const propNode = funcNode.childForFieldName('property');
@@ -2238,6 +2350,21 @@ function findImportsInCode(code, parser) {
                     const text = child.text;
                     modulePath = text.slice(1, -1);
                 }
+                // TS import-equals: `import x = require('./y')` — the
+                // dependency edge was invisible to imports/exporters/graph/
+                // circularDeps (fix #245; `export = fn` was already captured).
+                if (child.type === 'import_require_clause') {
+                    let alias = null, src = null;
+                    for (let j = 0; j < child.namedChildCount; j++) {
+                        const c = child.namedChild(j);
+                        if (c.type === 'identifier') alias = c.text;
+                        if (c.type === 'string') src = c.text.slice(1, -1);
+                    }
+                    if (src) {
+                        imports.push({ module: src, names: alias ? [alias] : [], type: 'require', line });
+                    }
+                    return true;
+                }
                 if (child.type === 'import_clause') {
                     // Process import clause
                     for (let j = 0; j < child.namedChildCount; j++) {
@@ -2475,11 +2602,42 @@ function findExportsInCode(code, parser) {
                     if (nameNode) {
                         exports.push({ name: nameNode.text, type: isDefaultExport ? 'default' : 'named', line });
                     }
-                } else if (child.type === 'class_declaration') {
+                } else if (child.type === 'class_declaration' || child.type === 'abstract_class_declaration') {
+                    // tree-sitter-typescript emits abstract_class_declaration
+                    // for `export abstract class X` — the symbol extractor
+                    // knew the node type, the export scanner did not (fix
+                    // #245: the class was never recorded as an export).
                     const nameNode = child.childForFieldName('name');
                     if (nameNode) {
                         exports.push({ name: nameNode.text, type: isDefaultExport ? 'default' : 'named', line });
                     }
+                } else if (child.type === 'ambient_declaration') {
+                    // export declare function/class/const X — the ambient
+                    // wrapper holds the real declaration (fix #245).
+                    for (let j = 0; j < child.namedChildCount; j++) {
+                        const inner = child.namedChild(j);
+                        const nameNode = inner.childForFieldName?.('name');
+                        if (nameNode) {
+                            exports.push({ name: nameNode.text, type: 'named', line });
+                        } else if (inner.type === 'lexical_declaration' || inner.type === 'variable_declaration') {
+                            for (let k = 0; k < inner.namedChildCount; k++) {
+                                const d = inner.namedChild(k);
+                                const n = d.type === 'variable_declarator' && d.childForFieldName('name');
+                                if (n && n.type === 'identifier') {
+                                    exports.push({ name: n.text, type: 'named', line, isVariable: true, declKind: 'declare' });
+                                }
+                            }
+                        }
+                    }
+                } else if (child.type === 'internal_module' || child.type === 'module') {
+                    // export namespace Geo { ... } — the NAMESPACE is the
+                    // importable name; its inner members are reached as
+                    // Geo.member (fix #245: only inner names were listed,
+                    // none of them importable).
+                    const nameNode = child.childForFieldName('name');
+                    if (nameNode) {
+                        exports.push({ name: nameNode.text, type: 'named', line });
+                    }
                 } else if (child.type === 'type_alias_declaration') {
                     // export type X = ...
                     const nameNode = child.childForFieldName('name');
@@ -2554,6 +2712,14 @@ function findExportsInCode(code, parser) {
                                 } else if (prop.type === 'pair') {
                                     const key = prop.childForFieldName('key');
                                     if (key) exports.push({ name: key.text, type: 'module.exports', line });
+                                } else if (prop.type === 'method_definition') {
+                                    // Shorthand methods are exports too
+                                    // (fix #252 — `module.exports =
+                                    // { doThing(x) {} }` was invisible to the
+                                    // export list, so deadcode audited a
+                                    // require()-reachable function).
+                                    const mName = prop.childForFieldName('name');
+                                    if (mName) exports.push({ name: mName.text, type: 'module.exports', line });
                                 }
                             }
                         } else if (rightNode && rightNode.type === 'identifier') {
@@ -2594,18 +2760,23 @@ function findExportsInCode(code, parser) {
  * @param {string} code - Source code
  * @param {string} name - Symbol name to find
  * @param {object} parser - Tree-sitter parser instance
+ * @param {object} [tree] - Pre-parsed tree (per-operation cache); parsed here when absent
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
-function findUsagesInCode(code, name, parser) {
-    const tree = parseTree(parser, code);
+function findUsagesInCode(code, name, parser, tree) {
+    tree = tree || parseTree(parser, code);
     const usages = [];
 
     visitNameNodes(tree, code, name, (node) => {
         // Look for identifier, property_identifier (method names in obj.method() calls),
-        // type_identifier (TypeScript type annotations), and shorthand_property_identifier_pattern
-        // (destructured names in `const { name } = require(...)`)
+        // type_identifier (TypeScript type annotations), shorthand_property_identifier_pattern
+        // (destructured names in `const { name } = require(...)`), and
+        // shorthand_property_identifier (value-position shorthand — CJS export
+        // objects `module.exports = { helper }` and option objects `f({ helper })`
+        // reference the symbol but produced no usage record at all, fix #241)
         const isIdentifier = node.type === 'identifier' || node.type === 'property_identifier' ||
-            node.type === 'type_identifier' || node.type === 'shorthand_property_identifier_pattern';
+            node.type === 'type_identifier' || node.type === 'shorthand_property_identifier_pattern' ||
+            node.type === 'shorthand_property_identifier';
         if (!isIdentifier || node.text !== name) {
             return true;
         }
@@ -2626,38 +2797,55 @@ function findUsagesInCode(code, name, parser) {
             }
             // Call: identifier is function in call_expression
             else if (parent.type === 'call_expression' &&
-                     parent.childForFieldName('function') === node) {
+                     sameNode(parent.childForFieldName('function'), node)) {
                 usageType = 'call';
             }
             // New expression: identifier is constructor
             else if (parent.type === 'new_expression' &&
-                     parent.childForFieldName('constructor') === node) {
+                     sameNode(parent.childForFieldName('constructor'), node)) {
                 usageType = 'call';
             }
             // Definition: function name in declaration
             else if ((parent.type === 'function_declaration' ||
                       parent.type === 'generator_function_declaration') &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
-            // Definition: variable name in declarator (left side of =)
+            // Definition: variable name in declarator (left side of =).
+            // When the right side is require()/import() the line IS the import
+            // of the symbol — `const Service = require('./service')` classified
+            // as 'definition' made the project's only import invisible (fix #241).
             else if (parent.type === 'variable_declarator' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
+                let value = parent.childForFieldName('value');
+                if (value && value.type === 'await_expression') {
+                    value = value.namedChild(0);
+                }
+                // Unwrap require('./x').member — still an import binding
+                if (value && value.type === 'member_expression') {
+                    value = value.childForFieldName('object');
+                }
+                if (value && value.type === 'call_expression') {
+                    const func = value.childForFieldName('function');
+                    if (func && (func.text === 'require' || func.type === 'import')) {
+                        usageType = 'import';
+                    }
+                }
             }
             // Definition: class name
             else if (parent.type === 'class_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: method name
             else if (parent.type === 'method_definition' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: function expression name (named function expressions)
             else if (parent.type === 'function' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Require: identifier is the name in require('...')
@@ -2689,7 +2877,7 @@ function findUsagesInCode(code, name, parser) {
             }
             // Property access (method call): a.name() - the name after dot
             else if (parent.type === 'member_expression' &&
-                     parent.childForFieldName('property') === node) {
+                     sameNode(parent.childForFieldName('property'), node)) {
                 // Skip built-in objects and common module names (JSON.parse, path.parse, etc.)
                 const object = parent.childForFieldName('object');
                 const builtins = [

package/languages/python.js

@@ -13,6 +13,7 @@ const {
     extractPythonDocstring,
     paramTypesFromStructured,
     visitNameNodes,
+    sameNode,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -58,10 +59,13 @@ function getIndent(node, code) {
  * Extract Python parameters
  */
 function extractPythonParams(paramsNode) {
+    // Distinguish "we have no node" (genuinely unknown) from "node is empty".
+    // Returning '...' for empty parens conflated zero-param functions with
+    // unknown signatures in JSON output (fix #241; go/rust got this in #238,
+    // the shared utils.extractParams already had it).
     if (!paramsNode) return '...';
     const text = paramsNode.text;
     let params = text.replace(/^\(|\)$/g, '').trim();
-    if (!params) return '...';
     return params;
 }
 
@@ -297,6 +301,52 @@ function extractDecorators(node) {
     return decorators;
 }
 
+
+/**
+ * Type aliases (fix #251 — rule 7: TS/Rust/Go aliases are indexed, Python's
+ * were invisible to typedef/find): PEP 695 `type X = int` and annotated
+ * `X: TypeAlias = ...` assignments become 'type' symbols with aliasOf.
+ */
+function _processTypeAlias(node, classes, processedRanges, lines) {
+    let name = null;
+    let valueText = null;
+    if (node.type === 'type_alias_statement') {
+        // grammar shape: type <left> = <right>
+        const left = node.namedChild(0);
+        const right = node.namedChild(1);
+        if (!left) return false;
+        name = left.text.replace(/\[.*\]$/, ''); // strip PEP 695 type params
+        valueText = right ? right.text : null;
+    } else if (node.type === 'expression_statement') {
+        const child = node.namedChild(0);
+        if (!child || child.type !== 'assignment') return false;
+        const typeNode = child.childForFieldName('type');
+        if (!typeNode || !/\bTypeAlias\b/.test(typeNode.text)) return false;
+        const leftNode = child.childForFieldName('left');
+        const rightNode = child.childForFieldName('right');
+        if (!leftNode || leftNode.type !== 'identifier') return false;
+        name = leftNode.text;
+        valueText = rightNode ? rightNode.text : null;
+    } else {
+        return false;
+    }
+    if (!name) return false;
+    const rangeKey = `${node.startIndex}-${node.endIndex}`;
+    if (processedRanges.has(rangeKey)) return true;
+    processedRanges.add(rangeKey);
+    const { startLine, endLine } = nodeToLocation(node, lines);
+    classes.push({
+        name,
+        type: 'type',
+        startLine,
+        endLine,
+        methods: [],
+        members: [],
+        ...(valueText && { aliasOf: valueText.trim() }),
+    });
+    return true;
+}
+
 /**
  * Find all classes in Python code using tree-sitter
  */
@@ -306,7 +356,8 @@ function findClasses(code, parser) {
     const classes = [];
     const processedRanges = new Set();
     traverseTreeCached(tree.rootNode, (node) => {
-        _processClass(node, classes, processedRanges, lines);
+        _processClass(node, classes, processedRanges, lines) ||
+            _processTypeAlias(node, classes, processedRanges, lines);
         return true;
     });
     classes.sort((a, b) => a.startLine - b.startLine);
@@ -460,7 +511,8 @@ function parse(code, parser) {
 
     traverseTreeCached(tree.rootNode, (node) => {
         _processFunction(node, functions, processedFn, lines, code);
-        _processClass(node, classes, processedCls, lines);
+        _processClass(node, classes, processedCls, lines) ||
+            _processTypeAlias(node, classes, processedCls, lines);
         _processState(node, stateObjects, lines);
         _processModuleAssign(node, moduleAssigned);
         return true;
@@ -1344,10 +1396,11 @@ function findExportsInCode(code, parser) {
  * @param {string} code - Source code
  * @param {string} name - Symbol name to find
  * @param {object} parser - Tree-sitter parser instance
+ * @param {object} [tree] - Pre-parsed tree (per-operation cache); parsed here when absent
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
-function findUsagesInCode(code, name, parser) {
-    const tree = parseTree(parser, code);
+function findUsagesInCode(code, name, parser, tree) {
+    tree = tree || parseTree(parser, code);
     const usages = [];
 
     visitNameNodes(tree, code, name, (node) => {
@@ -1378,17 +1431,17 @@ function findUsagesInCode(code, name, parser) {
             }
             // Call: name()
             else if (parent.type === 'call' &&
-                     parent.childForFieldName('function') === node) {
+                     sameNode(parent.childForFieldName('function'), node)) {
                 usageType = 'call';
             }
             // Definition: def name(...):
             else if (parent.type === 'function_definition' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: class name:
             else if (parent.type === 'class_definition' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: parameter
@@ -1400,17 +1453,17 @@ function findUsagesInCode(code, name, parser) {
             }
             // Definition: assignment target (x = ...)
             else if (parent.type === 'assignment' &&
-                     parent.childForFieldName('left') === node) {
+                     sameNode(parent.childForFieldName('left'), node)) {
                 usageType = 'definition';
             }
             // Definition: for loop variable
             else if (parent.type === 'for_statement' &&
-                     parent.childForFieldName('left') === node) {
+                     sameNode(parent.childForFieldName('left'), node)) {
                 usageType = 'definition';
             }
             // Method call: obj.name()
             else if (parent.type === 'attribute' &&
-                     parent.childForFieldName('attribute') === node) {
+                     sameNode(parent.childForFieldName('attribute'), node)) {
                 const grandparent = parent.parent;
                 if (grandparent && grandparent.type === 'call') {
                     usageType = 'call';
@@ -1423,6 +1476,19 @@ function findUsagesInCode(code, name, parser) {
                     usages.push({ line, column, usageType, receiver: object.text });
                     return true;
                 }
+                // self.attr receiver (unittest setUp idiom: self.w = Widget(3);
+                // self.w.render()) — record the ATTR name so the instance-type
+                // map built from the assignment line ('w' → Widget) matches
+                // (fix #244: class-scoped tests dropped these calls entirely).
+                if (object && object.type === 'attribute') {
+                    const innerObj = object.childForFieldName('object');
+                    const innerAttr = object.childForFieldName('attribute');
+                    if (innerObj && innerObj.type === 'identifier' &&
+                        ['self', 'cls'].includes(innerObj.text) && innerAttr) {
+                        usages.push({ line, column, usageType, receiver: innerAttr.text });
+                        return true;
+                    }
+                }
             }
         }
 
@@ -1458,43 +1524,43 @@ function findInstanceAttributeTypes(code, parser) {
 
         const attrTypes = new Map();
 
-        // Check for @dataclass decorator — scan annotated class-level fields
+        // Scan annotated class-level fields: name: Type [= ...]. Originally
+        // @dataclass-only (fix #28); a BARE class-body annotation is the
+        // same compiler-visible typing evidence (`engine: Engine` inside
+        // class Car types self.engine — pyright enforces it), so those scan
+        // for every class (fix #234). Annotations WITH a value stay
+        // dataclass-only: `tracker: BracketTracker = None` in a plain class
+        // is routinely rebound to something else per-instance, while a
+        // dataclass field default is constructor-managed.
         const parentNode = node.parent;
-        if (parentNode?.type === 'decorated_definition') {
-            for (let d = 0; d < parentNode.childCount; d++) {
-                const dec = parentNode.child(d);
-                if (dec.type !== 'decorator') continue;
-                // Match @dataclass or @dataclasses.dataclass
-                const decText = dec.text;
-                if (decText.startsWith('@dataclass') || decText.includes('.dataclass')) {
-                    // Scan class body for annotated fields: name: Type = ...
-                    for (let i = 0; i < body.childCount; i++) {
-                        const stmt = body.child(i);
-                        if (stmt.type !== 'expression_statement') continue;
-                        const assign = stmt.firstChild;
-                        if (!assign || assign.type !== 'assignment') continue;
-
-                        // Must have a type annotation
-                        const typeNode = assign.childForFieldName('type');
-                        if (!typeNode) continue;
-
-                        // Extract type name from annotation
-                        const typeIdent = typeNode.type === 'type' ? typeNode.firstChild : typeNode;
-                        if (!typeIdent || typeIdent.type !== 'identifier') continue;
-                        const typeName = typeIdent.text;
-
-                        // Skip primitives and lowercase types
-                        if (PRIMITIVE_TYPES.has(typeName)) continue;
-                        if (typeName[0] < 'A' || typeName[0] > 'Z') continue;
-
-                        // Field name from LHS
-                        const lhs = assign.childForFieldName('left');
-                        if (!lhs || lhs.type !== 'identifier') continue;
-                        attrTypes.set(lhs.text, typeName);
-                    }
-                    break;
-                }
-            }
+        const isDataclass = parentNode?.type === 'decorated_definition' &&
+            Array.from({ length: parentNode.childCount }, (_, d) => parentNode.child(d))
+                .some(dec => dec.type === 'decorator' &&
+                    (dec.text.startsWith('@dataclass') || dec.text.includes('.dataclass')));
+        for (let i = 0; i < body.childCount; i++) {
+            const stmt = body.child(i);
+            if (stmt.type !== 'expression_statement') continue;
+            const assign = stmt.firstChild;
+            if (!assign || assign.type !== 'assignment') continue;
+
+            // Must have a type annotation
+            const typeNode = assign.childForFieldName('type');
+            if (!typeNode) continue;
+            if (!isDataclass && assign.childForFieldName('right')) continue;
+
+            // Extract type name from annotation
+            const typeIdent = typeNode.type === 'type' ? typeNode.firstChild : typeNode;
+            if (!typeIdent || typeIdent.type !== 'identifier') continue;
+            const typeName = typeIdent.text;
+
+            // Skip primitives and lowercase types
+            if (PRIMITIVE_TYPES.has(typeName)) continue;
+            if (typeName[0] < 'A' || typeName[0] > 'Z') continue;
+
+            // Field name from LHS
+            const lhs = assign.childForFieldName('left');
+            if (!lhs || lhs.type !== 'identifier') continue;
+            attrTypes.set(lhs.text, typeName);
         }
 
         // Scan __init__ for self.X = ClassName(...) assignments