cowork-bot: dynamic import() and require() now consume target module's whole export surface (previously invisible -> exports used only via lazy loading flagged removable=True); +3 regression tests

Author: cowork-bot

src/deadcode/scanner.py

@@ -136,6 +136,15 @@ def unreferenced_components(self) -> list[Finding]:
     r"^\s*import\s*['\"]([^'\"]+)['\"]", re.MULTILINE
 )
 
+# Dynamic import: `const m = await import('./heavy');` — lazily loads the whole
+# module at runtime; individual consumed names are invisible statically, so the
+# module's entire export surface counts as used.
+_DYNAMIC_IMPORT_PATTERN = re.compile(r"import\(\s*['\"]([^'\"]+)['\"]\s*\)")
+
+# CommonJS require: `const m = require('./legacy');` — same whole-module
+# consumption semantics as a dynamic import.
+_REQUIRE_PATTERN = re.compile(r"(?<![\w$.])require\(\s*['\"]([^'\"]+)['\"]\s*\)")
+
 # className="..." or className={...} in JSX
 _CLASSNAME_PATTERN = re.compile(
     r"class(?:Name)?\s*[=:]\s*['\"]([^'\"]+)['\"]|"
@@ -454,6 +463,11 @@ def _parse_reexports(
         for m in _SIDE_EFFECT_IMPORT_PATTERN.finditer(content):
             # `import './mod'` — side-effect-only consumption.
             star_reexports.append((rel_path, m.group(1)))
+        for pattern in (_DYNAMIC_IMPORT_PATTERN, _REQUIRE_PATTERN):
+            for m in pattern.finditer(content):
+                # `import('./mod')` / `require('./mod')` — lazily loads the
+                # whole module; consumed names are invisible statically.
+                star_reexports.append((rel_path, m.group(1)))
 
     @staticmethod
     def _resolve_relative_module(importer_rel: str, spec: str, file_set: set[str]) -> str | None:

tests/test_namespace_sideeffect_imports.py

@@ -78,3 +78,34 @@ def test_no_consumer_still_flags_exports(self, tmp_path):
         flagged = _flagged_names(project)
         assert "helper" in flagged
         assert "RATE" in flagged
+
+
+class TestDynamicAndRequireImports:
+    """`import('./mod')` and `require('./mod')` load the whole module at
+    runtime; statically invisible name consumption must not flag exports."""
+
+    def test_dynamic_import_marks_all_exports_used(self, tmp_path):
+        project = _make_project(
+            tmp_path,
+            "export async function load() {\n"
+            "  const u = await import('./utils');\n"
+            "  return u.helper() + u.RATE;\n"
+            "}\n",
+        )
+        assert not [f for _n, f in _unused_names(project) if f.endswith("utils.ts")]
+
+    def test_require_marks_all_exports_used(self, tmp_path):
+        project = _make_project(
+            tmp_path,
+            "const u = require('./utils');\nexport const total = u.helper();\n",
+        )
+        assert not [f for _n, f in _unused_names(project) if f.endswith("utils.ts")]
+
+    def test_bare_specifier_dynamic_import_cannot_mark_used(self, tmp_path):
+        # Dynamic import of a package ('lodash') says nothing about local
+        # modules — utils.ts must still be reported as unused.
+        project = _make_project(
+            tmp_path,
+            "export async function load() {\n  return import('lodash');\n}\n",
+        )
+        assert {n for n, _f in _unused_names(project)} == {"helper", "RATE"}