fix(haskell): parse module exports → is_exported on symbols (WI-buvun / UAT BUG-12)

shellcheck had 0 recognized exports on UAT despite every module
declaring `module X (export1, export2, ...) where`. The dead-code-
maybe seed sets `exports` and `tests` were useless on Haskell —
every symbol had is_exported=False because the analyzer never
parsed module headers.

This PR adds export parsing:

- New _extract_module_exports walks the tree-sitter `header` node,
  finds the optional `exports` child, and collects names from each
  `export` entry. Functions / values come from `variable`; types
  and classes come from `name`.
- Returns None when no export list is present (the Haskell default
  is "export everything top-level"), or a set of names when one is.
- _extract_symbols_from_file consumes the tri-state and sets
  Symbol.is_exported correctly:
  * None → True for every module-level binding
  * set → True iff name in set
  * instances → True iff their class or type is in set
    (instances aren't named in Haskell exports but are externally
    reachable through them)

Net effect: dead-code-maybe's exports / tests seed selection now
works on Haskell. shellcheck and similar projects will get
meaningful candidate lists.

5 tests in TestHaskellModuleExports:
- Explicit list marks listed names; private names stay False.
- No export list = export-everything default.
- Type names in the list are exported (Person(..), Address).
- Class names in the list are exported.
- Instances follow class or type membership.

Signed-off-by: jgstern-agent <josh-agent@iterabloom.com>

Author: jgstern-agent

.ci/affected-tests.txt

@@ -1,17 +1,18 @@
 # Test selection manifest
-# Generated by smart-test at 2026-04-15T10:12:20-04:00
+# Generated by smart-test at 2026-04-15T10:38:39-04:00
 # Mode: targeted
 # Baseline: 02dba9744d2c86e26f06565aad4ebcae7ef0f4a8
-# Changed files: 38
-# Changed source files: 7
-# Selected tests: 66
+# Changed files: 41
+# Changed source files: 8
+# Selected tests: 67
 #
 # === CHANGED_SOURCE_FILES ===
 packages/hypergumbo-core/src/hypergumbo_core/cli.py
 packages/hypergumbo-core/src/hypergumbo_core/_hf_noise.py
 packages/hypergumbo-core/src/hypergumbo_core/io_boundary.py
 packages/hypergumbo-core/src/hypergumbo_core/profile.py
 packages/hypergumbo-core/src/hypergumbo_core/sketch_embeddings.py
+packages/hypergumbo-lang-common/src/hypergumbo_lang_common/haskell.py
 packages/hypergumbo-lang-mainstream/src/hypergumbo_lang_mainstream/php.py
 packages/hypergumbo-tracker/src/hypergumbo_tracker/cli.py
 # === SELECTED_TESTS ===
@@ -54,6 +55,7 @@ packages/hypergumbo-core/tests/test_tree_sitter_analyzer.py
 packages/hypergumbo-core/tests/test_verify_claims.py
 packages/hypergumbo-lang-common/tests/BRANCHES_test_dart.py
 packages/hypergumbo-lang-common/tests/BRANCHES_test_elixir.py
+packages/hypergumbo-lang-common/tests/BRANCHES_test_haskell.py
 packages/hypergumbo-lang-common/tests/test_haskell.py
 packages/hypergumbo-lang-mainstream/tests/BRANCHES_test_cpp.py
 packages/hypergumbo-lang-mainstream/tests/BRANCHES_test_c.py

CHANGELOG.md

@@ -12,6 +12,7 @@ This changelog tracks the **tool version** (package releases). The **schema vers
 
 ### Added
 
+- **Haskell module exports recognized as dead-code seeds** (WI-buvun / UAT BUG-12): the Haskell analyzer now parses module headers (`module Foo (publicFn, Type(..)) where`) and marks listed symbols as `is_exported=True`. Modules with no export list (`module Foo where`) get the Haskell default — every top-level binding is exported. Type names in the export list count for data/class declarations. Instances follow their class/type: an `instance ClassName TypeName` is considered exported when either name is in the export list (instances aren't named directly in Haskell exports but are externally reachable through them). Before this, every Haskell symbol had `is_exported=False` and the `exports` / `tests` seed sets for `dead-code-maybe` were useless on Haskell — UAT showed shellcheck had 0 recognized exports.
 - **Yesod framework detection + pattern set** (WI-vabiv / UAT BUG-16): Yesod (Haskell — haskellers) is now detected from `*.cabal` / `package.yaml` dependencies (`yesod`, `yesod-core`, `yesod-auth`, `yesod-persistent`) and a new `frameworks/yesod.yaml` ships patterns for the Yesod conventions: `mkYesod` / `mkYesodData` / `mkYesodSubData` / `parseRoutes` quasi-quoter calls, Warp runner (`warp`/`warpTLS`/`toWaiApp`), `Yesod` / `YesodSubsite` typeclass memberships, `RenderRoute` / `ParseRoute` router class, standard mixin typeclasses (`YesodPersist`, `YesodAuth`, `YesodBreadcrumbs`), and the `<method><Resource>R` handler naming convention (getHomeR, postUserR, deleteUserR, ...). Route materialization for the non-GET/non-POST methods is a later materializer expansion; concepts are attached today so downstream analysis recognizes the handlers as web-handler entry points.
 - **Elixir I/O primitive catalog** (WI-vibur / UAT BUG-09b): new `io_primitives/elixir.yaml` fixes the "0 boundaries on plausible (Phoenix/Ecto)" gap. Covers Elixir stdlib (`File.read`/`write`/`stream!`, `IO.puts`/`write`/`read`, `System.cmd`/`get_env`, `Logger.*`), the idiomatic HTTP-client galaxy (`HTTPoison`, `Tesla`, `Req`, `Finch`, `Mint.HTTP*`, plus Erlang `:httpc`), Phoenix server surface (`Phoenix.Router.get/post/...`, `Phoenix.Controller.render/json`, `Plug.Conn.send_resp/read_body`, `Phoenix.Channel.broadcast`, `Phoenix.Endpoint.broadcast`), databases (Ecto.Repo read/write verbs, `Ecto.Multi`, `Postgrex.query`, `MyXQL.query`, `Redix.command`), and IPC (`GenServer.call/cast`, `Process.send`, `Oban.insert`, `Task.async`). `elixir` added to `_CATALOG_PARENTS` with `erlang` as parent so atom-access into Erlang (`:gen_tcp.send`, `:ets.lookup`, `:file.read_file`) is still matched. Elixir-specific `ambiguous_names` prevents Elixir pipe/Enum verbs and scope functions from producing short-name false positives.
 - **Kotlin I/O primitive catalog** (WI-rujos / UAT BUG-09d): new `io_primitives/kotlin.yaml` with Kotlin-specific entries. Kotlin was previously aliased to `java.yaml` verbatim via `_CATALOG_ALIASES`, which produced only 1 boundary (net_send) on detekt because Kotlin idiom uses extension functions and top-level stdlib functions that have no Java analog. The new catalog covers: `kotlin.io` File extensions (`readText`, `writeText`, `forEachLine`, `useLines`, `copyTo`, `walk`), `kotlin.io.path` Path extensions (Kotlin 1.5+), top-level `println`/`print` (receiver `kotlin.io.ConsoleKt`), ktor client + server, `android.util.Log`, `kotlin-logging` (`mu.KLogger` and the 5.x relocated `io.github.oshai.kotlinlogging.KLogger`), and Exposed ORM read/write. Kotlin-specific `ambiguous_names` prevent scope functions (`apply`, `run`, `let`, `use`) and coroutine/Flow verbs (`send`, `receive`, `collect`) from producing short-name false positives. `kotlin` moved from `_CATALOG_ALIASES` to `_CATALOG_PARENTS` so the Java parent still provides the raw `java.io/java.net/JDBC/SLF4J` entries for Kotlin code that uses those APIs directly.

packages/hypergumbo-lang-common/src/hypergumbo_lang_common/haskell.py

@@ -146,6 +146,42 @@ def _extract_haskell_signature(
     return None  # pragma: no cover - defensive, called only when signature exists
 
 
+def _extract_module_exports(tree: "tree_sitter.Tree", source: bytes) -> Optional[set[str]]:
+    """Parse the module header's optional export list.
+
+    Returns a set of exported names when the module declares
+    ``module Foo.Bar (a, b, Type(..)) where``; returns None when no
+    export list is present (``module Foo.Bar where``) — Haskell's
+    default is to export every top-level binding in that case.
+
+    The caller uses the tri-state to decide the ``is_exported`` flag:
+    - None → mark all module-level symbols as exported (WI-buvun).
+    - a set → mark only names in the set as exported; others are
+      module-private.
+    """
+    for node in iter_tree(tree.root_node):
+        if node.type != "header":
+            continue
+        exports_node = find_child_by_type(node, "exports")
+        if exports_node is None:
+            return None
+        names: set[str] = set()
+        for child in exports_node.children:
+            if child.type != "export":
+                continue
+            # Each `export` has either a `variable` (fn/value) or a
+            # `name` (type / constructor). Both count as exported.
+            var = find_child_by_type(child, "variable")
+            if var is not None:
+                names.add(node_text(var, source))
+                continue
+            type_name = find_child_by_type(child, "name")
+            if type_name is not None:
+                names.add(node_text(type_name, source))
+        return names
+    return None  # pragma: no cover - every Haskell file has a header
+
+
 def _extract_symbols_from_file(
     tree: "tree_sitter.Tree",
     source: bytes,
@@ -163,6 +199,12 @@ def _extract_symbols_from_file(
     symbols: list[Symbol] = []
     seen_names: set[str] = set()
 
+    # WI-buvun: parse the module header's export list so module-level
+    # symbols carry is_exported correctly. shellcheck had zero exports
+    # recognized before this — the `exports` and `tests` seed sets for
+    # `dead-code-maybe` were therefore useless on Haskell.
+    exported_names = _extract_module_exports(tree, source)
+
     # First pass: collect type signatures
     type_signatures: dict[str, str] = {}
 
@@ -196,6 +238,21 @@ def add_symbol(
             end_col=node.end_point[1],
         )
         sym_id = make_symbol_id("haskell", file_path, start_line, end_line, name, kind)
+        # WI-buvun: is_exported tri-state. No export list = all top-level
+        # bindings are exported (Haskell default). With a list, only
+        # names explicitly in it are exported. Instances aren't named in
+        # the export list the same way, so they follow the class they
+        # implement — if that's exported, they're externally reachable.
+        if exported_names is None:
+            is_exported = True
+        elif kind == "instance":
+            # Instance: exported iff its class/type name is exported.
+            # `name` here is "ClassName TypeName"; match either.
+            parts = name.split()
+            is_exported = any(p in exported_names for p in parts)
+        else:
+            is_exported = name in exported_names
+
         symbols.append(Symbol(
             id=sym_id,
             name=name,
@@ -206,6 +263,7 @@ def add_symbol(
             origin=PASS_ID,
             origin_run_id=run_id,
             signature=signature,
+            is_exported=is_exported,
         ))
 
     # Second pass: extract symbols

packages/hypergumbo-lang-common/tests/test_haskell.py

@@ -756,3 +756,126 @@ def test_normal_name_call_gets_full_confidence(self, tmp_path: Path) -> None:
         assert len(helper_edges) >= 1
         for edge in helper_edges:
             assert edge.confidence > 0.50
+
+
+# ============================================================================
+# WI-buvun: module export list parsing → is_exported on symbols
+# ============================================================================
+
+
+class TestHaskellModuleExports:
+    """WI-buvun: dead-code-maybe needs is_exported on Haskell symbols.
+
+    Before this fix, every Haskell symbol had is_exported=False because
+    the analyzer never parsed module headers. The `exports` and `tests`
+    seed sets for `dead-code-maybe` were therefore empty on Haskell —
+    UAT BUG-12: shellcheck had 0 recognized exports.
+    """
+
+    def test_explicit_export_list_marks_listed_symbols(self, tmp_path) -> None:
+        """`module Foo (a, b) where` exports only a and b; c is private."""
+        from hypergumbo_lang_common.haskell import analyze_haskell
+
+        (tmp_path / "Foo.hs").write_text("""module Foo (publicFn, exportedValue) where
+publicFn :: Int -> Int
+publicFn x = x + 1
+
+exportedValue :: Int
+exportedValue = 42
+
+privateHelper :: Int -> Int
+privateHelper x = x * 2
+""")
+        result = analyze_haskell(tmp_path)
+        by_name = {s.name: s for s in result.symbols if s.name in (
+            "publicFn", "exportedValue", "privateHelper",
+        )}
+        assert by_name["publicFn"].is_exported is True
+        assert by_name["exportedValue"].is_exported is True
+        assert by_name["privateHelper"].is_exported is False
+
+    def test_no_export_list_marks_all_top_level_exported(self, tmp_path) -> None:
+        """`module Foo where` (no parens) is Haskell's "export everything"
+        default — every top-level binding is exported.
+        """
+        from hypergumbo_lang_common.haskell import analyze_haskell
+
+        (tmp_path / "Bar.hs").write_text("""module Bar where
+foo :: Int
+foo = 1
+
+bar :: Int -> Int
+bar x = x + foo
+
+baz :: String
+baz = "hello"
+""")
+        result = analyze_haskell(tmp_path)
+        for sym in result.symbols:
+            if sym.name in ("foo", "bar", "baz"):
+                assert sym.is_exported is True, (
+                    f"{sym.name} should be exported (no export list "
+                    f"means Haskell's export-everything default)"
+                )
+
+    def test_data_type_in_export_list_marks_exported(self, tmp_path) -> None:
+        """Type names in the export list (e.g. `Type(..)`) are exported."""
+        from hypergumbo_lang_common.haskell import analyze_haskell
+
+        (tmp_path / "Types.hs").write_text("""module Types (Person(..), Address) where
+data Person = Person { name :: String, age :: Int }
+data Address = Address { street :: String }
+data Internal = Internal Int
+""")
+        result = analyze_haskell(tmp_path)
+        by_name = {s.name: s for s in result.symbols
+                   if s.name in ("Person", "Address", "Internal")}
+        assert by_name["Person"].is_exported is True
+        assert by_name["Address"].is_exported is True
+        assert by_name["Internal"].is_exported is False
+
+    def test_class_in_export_list_marks_exported(self, tmp_path) -> None:
+        """Type class names in the export list are exported."""
+        from hypergumbo_lang_common.haskell import analyze_haskell
+
+        (tmp_path / "Classes.hs").write_text("""module Classes (Showable, internalClass) where
+class Showable a where
+  showMe :: a -> String
+
+class InternalClass a where
+  internalOp :: a -> Int
+
+internalClass :: Int
+internalClass = 0
+""")
+        result = analyze_haskell(tmp_path)
+        by_name = {s.name: s for s in result.symbols if s.name in (
+            "Showable", "InternalClass",
+        )}
+        assert by_name["Showable"].is_exported is True
+        assert by_name["InternalClass"].is_exported is False
+
+    def test_instance_exported_iff_class_or_type_exported(
+        self, tmp_path,
+    ) -> None:
+        """An instance `instance ClassName TypeName where ...` is
+        considered exported when ClassName or TypeName is in the export
+        list — instances aren't named explicitly in Haskell exports but
+        they're externally reachable through their class / type.
+        """
+        from hypergumbo_lang_common.haskell import analyze_haskell
+
+        (tmp_path / "Insts.hs").write_text("""module Insts (Showable, Person) where
+class Showable a where
+  showMe :: a -> String
+
+data Person = Person String
+
+instance Showable Person where
+  showMe (Person n) = n
+""")
+        result = analyze_haskell(tmp_path)
+        instance_syms = [s for s in result.symbols if s.kind == "instance"]
+        assert len(instance_syms) >= 1
+        # Both Showable and Person are in exports, so the instance is exported
+        assert any(s.is_exported for s in instance_syms)