feat(kotlin): detect extension functions and mark is_exported (WI-fuhav)

Kotlin extension functions (``fun Receiver.name() { }``) were
invisible to the dead-code-maybe BFS: the static call graph never
reaches them because nothing textually "calls" an extension — the
runtime dispatches based on receiver type. Spring-boot's
SpringApplicationExtensions.kt was the top WI-tubot prospector
example (8339 cross-language hits, dominated the top-uncategorized
list because ``with`` is a Kotlin stdlib keyword).

Detect extension functions by walking the function_declaration
children in order: a ``user_type`` child that appears BEFORE the
``identifier`` (name) field is the distinguishing marker. Plain
functions have no preceding receiver; class method declarations
use a different AST path via _get_enclosing_class and are
unaffected.

When detected:
- Set Symbol.is_exported=True (extension functions are inherently
  part of the public API of their receiver type — something
  external invokes them).
- Record the receiver type text under meta.extension_receiver for
  future linker use (full receiver-typed dispatch resolution is a
  separate follow-up item).

Combined with the WI-zimum --seeds exports mode, these symbols
now count as reachable via the public-API seed set in
dead-code-maybe.

New helper in kotlin.py:
- _extract_kotlin_receiver_type(func_node, source): walks children
  in AST order, returning the user_type text when it precedes the
  identifier, None otherwise.

Tests (3 in TestKotlinExtensionFunctions):
- detects_extension_function: fun SpringApplication.configure(...)
- plain_function_not_flagged: fun greet() is NOT flagged
- extension_function_on_generic_receiver: fun List<Int>.sumSafe()

Refs: WI-fuhav-rigah-mojit-fuvom-vohim-jokiv-tosuj-ponah
Related: WI-tubot prospector 2026-04-11, WI-zimum Phase 1+2

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

Author: jgstern-agent

.ci/affected-tests.txt

@@ -1,9 +1,9 @@
 # Test selection manifest
-# Generated by smart-test at 2026-04-11T11:18:54-04:00
+# Generated by smart-test at 2026-04-11T11:42:46-04:00
 # Mode: targeted
 # Baseline: 94a6f0ca6c69d3de637c39e8e0667dff2382edbf
-# Changed files: 26
-# Changed source files: 9
+# Changed files: 29
+# Changed source files: 10
 # Selected tests: 200
 #
 # === CHANGED_SOURCE_FILES ===
@@ -15,6 +15,7 @@ packages/hypergumbo-core/src/hypergumbo_core/linkers/go_memberlist.py
 packages/hypergumbo-core/src/hypergumbo_core/sketch.py
 packages/hypergumbo-core/src/hypergumbo_core/supply_chain.py
 packages/hypergumbo-lang-mainstream/src/hypergumbo_lang_mainstream/js_ts.py
+packages/hypergumbo-lang-mainstream/src/hypergumbo_lang_mainstream/kotlin.py
 packages/hypergumbo-lang-mainstream/src/hypergumbo_lang_mainstream/py.py
 # === SELECTED_TESTS ===
 packages/hypergumbo-core/tests/BRANCHES_test_compact.py

CHANGELOG.md

@@ -40,6 +40,7 @@ This changelog tracks the **tool version** (package releases). The **schema vers
 
 - **Content-based `@generated` header detection** (WI-pofin): `classify_file` now scans the first 4 KiB of text-like source files for canonical generated-code headers in addition to the existing path-pattern check. Covered markers: `// @generated`, `/* @generated`, `# @generated`, `<!-- @generated -->` (JS/TS/Go/Python/Ruby/HTML/etc.); Go-stdlib `// Code generated by <tool>. DO NOT EDIT.`; and the alternate `Autogenerated`/`AUTO-GENERATED`/`automatically generated` spellings — all required to sit at a comment-line start so a mid-file prose mention of "generated" is not flagged. Content scan is gated on extension (`_CONTENT_SCAN_EXTS`, 36 text-like source suffixes) so images, archives, and other binary files are not opened. Bounded-cost: one 4 KiB read per scanned file. Follow-up for files flagged by header but not by path — e.g., repo code-gen that emits to hand-written directories.
 - **`is_generated_file` detection for TypeScript `openapi-gen/` output** (WI-vubad): extends `GENERATED_CODE_PATTERNS` in `supply_chain.py` with `(?:^|/)openapi-gen/.*\.(?:ts|tsx|js|jsx|mjs|cjs)$`. Airflow, FastAPI, and similar Python web projects ship a generated TypeScript SDK under an `openapi-gen/` directory (typical files: `request.ts`, `CancelablePromise.ts`, `ApiClient.ts`). The WI-tubot prospector run 2026-04-11 surfaced ~200 dead-code-maybe false positives per airflow run from a single `openapi-gen/requests/core/` directory; flagging those paths as generated demotes them out of the candidate ranking. Hand-written `request.ts` outside an `openapi-gen/` directory is not affected.
+- **Kotlin extension functions → `Symbol.is_exported`** (WI-fuhav): the Kotlin analyzer detects extension functions (`fun Receiver.name() { }`) by walking the `function_declaration` children in order — a `user_type` child that appears before the `identifier`/name field is the distinctive marker of an extension receiver. Extension-function symbols get `is_exported=True` (they're inherently part of the public API of their receiver type) and carry the receiver text under `meta.extension_receiver`. Addresses the WI-tubot prospector finding where spring-boot's `SpringApplicationExtensions.kt#with` and similar symbols dominated the dead-code candidate list because nothing in the static call graph reaches them. Follow-up: full receiver-typed dispatch resolution (emit edges from `receiver.extMethod()` call sites to matching extension functions in scope) is a separate larger item.
 - **TypeScript/JavaScript `export` → `Symbol.is_exported`** (WI-zimum Phase 2b, WI-nimug): the js_ts analyzer now marks `Symbol.is_exported=True` for any top-level declaration appearing under an `export_statement`. Covered syntaxes: `export function`, `export class`, `export const/let/var` (all variable declarators), `export { foo, bar }` clauses (including `export { foo as bar }` where the alias is used), `export default <named_decl>`, and `export default <identifier>`. Anonymous `export default` expressions without a name (`export default () => {}`, `export default 42`) are not flagged because there is no symbol name to join on. The module pseudo-node is never flagged. Pairs with WI-gipag (Python `__all__`) to close out WI-zimum Phase 2 for the two languages with the highest dead-code-maybe false-positive rates in the WI-tubot prospector cohort.
 - **Python `__all__` → `Symbol.is_exported`** (WI-zimum Phase 2, WI-gipag): the Python analyzer now decides `is_exported` for top-level classes and functions based on the module's `__all__` list (when present) or the leading-underscore convention (when absent). When a module defines `__all__ = ["foo", "bar"]`, only symbols whose name appears in the list are flagged exported — even if their name is public. When `__all__` is absent, any top-level (col_offset == 0) class/function whose name doesn't start with `_` is flagged exported; nested functions (col_offset > 0) are never flagged regardless of name. Supports `__all__` as a list literal, tuple literal, or annotated assignment (`__all__: list[str] = [...]`). Non-literal forms (`__all__ = other.__all__`, list comprehensions) are treated as "no __all__" and fall back to the underscore rule. Combined with the WI-zimum `--seeds exports` dead-code-maybe mode, this drops Python framework libraries (Airflow, Django, Superset — observed at 70–83 % dead rate in the WI-tubot prospector run) out of the false-positive bucket. Follow-up: TypeScript/JavaScript top-level `export` declarations (tracked separately).
 - **FFI-signature auto-flag for `dead-code-maybe` ranking** (WI-hadap Heuristic 2): dead-code candidates whose decorators or modifiers match FFI markers get a new `ffi_signature: true` field in the JSON output and a +10 rank boost so they sort above regular orphans. An FFI-shaped candidate that isn't reached from any entrypoint is almost definitionally a "free hit" — a missing cross-language linker edge. Covered markers: Rust `#[no_mangle]`, `#[pyo3*]`, `#[napi]`, `#[wasm_bindgen]`; Python `@ctypes.CFUNCTYPE`, `@cffi.*`, `@cython.*`; C/C++ `JNIEXPORT`, `extern`/`extern "C"`; C# `[DllImport]`; Java `native` modifier. Exact-match substring check on the decorator's name (so `pyo3::pyfunction` matches via the `pyo3` fragment) and exact-match string check on modifiers.

packages/hypergumbo-lang-mainstream/src/hypergumbo_lang_mainstream/kotlin.py

@@ -78,6 +78,53 @@ def _find_child_by_field(node: "tree_sitter.Node", field_name: str) -> Optional[
     return node.child_by_field_name(field_name)
 
 
+def _extract_kotlin_receiver_type(
+    func_node: "tree_sitter.Node",
+    source: bytes,
+) -> Optional[str]:
+    """Return the receiver type name if *func_node* is an extension function.
+
+    WI-fuhav: tree-sitter-kotlin parses ``fun Receiver.name(...) { }``
+    as a ``function_declaration`` whose children run as
+    ``[fun, user_type, '.', identifier, function_value_parameters, ...]``.
+    The ``user_type`` child sits BEFORE the ``identifier`` that carries
+    the function name — this is the distinguishing marker of an
+    extension function. Regular functions (``fun name() {}``) have
+    no receiver sibling.
+
+    Returns the text of the receiver user_type when detected, or
+    None for plain (non-extension) functions.
+    """
+    saw_user_type = False
+    receiver_text: Optional[str] = None
+    for child in func_node.children:
+        if child.type in ("simple_identifier", "identifier") and saw_user_type:
+            # We reached the function name after already seeing the
+            # receiver user_type — confirmed extension function.
+            return receiver_text
+        if child.type == "user_type":
+            # Record (but don't commit yet — the function_declaration
+            # body may contain user_type nodes further down that
+            # aren't receivers). We only commit if the NEXT identifier
+            # arrives before any structural block starts.
+            saw_user_type = True
+            receiver_text = (
+                child.text.decode("utf-8", errors="replace")
+                if child.text else None
+            )
+        elif child.type in (
+            "function_value_parameters",
+            "function_body",
+            "type_parameters",
+            "modifiers",
+            "{",
+        ):
+            # These sit after the name — if we hit one before confirming
+            # the name, there was no preceding receiver.
+            return None
+    return None  # pragma: no cover - defensive fallback for malformed AST
+
+
 # Kotlin modifier keyword types grouped by category.
 # tree-sitter-kotlin wraps each in a typed node (visibility_modifier,
 # inheritance_modifier, etc.) whose single child is the keyword.
@@ -587,6 +634,23 @@ def _extract_symbols_from_file(
                 if annotations:
                     func_meta = {"decorators": annotations}
 
+                # WI-fuhav: detect Kotlin extension functions.
+                # fun Receiver.name() {} is an extension function; the
+                # receiver type is the user_type sibling before the
+                # name identifier. Extension functions are inherently
+                # part of the public API of their receiver — something
+                # external calls them — so mark is_exported=True so
+                # dead-code-maybe's --seeds exports mode treats them
+                # as reachable. Also record the receiver type in meta
+                # for future linker use.
+                receiver_type = _extract_kotlin_receiver_type(node, source)
+                func_is_exported = False
+                if receiver_type is not None:
+                    if func_meta is None:
+                        func_meta = {}
+                    func_meta["extension_receiver"] = receiver_type
+                    func_is_exported = True
+
                 symbol = Symbol(
                     id=make_symbol_id("kotlin", str(file_path), start_line, end_line, full_name, kind),
                     name=full_name,
@@ -606,6 +670,7 @@ def _extract_symbols_from_file(
                     modifiers=modifiers,
                     meta=func_meta,
                     shape_id=_analyzer.compute_shape_id(node),
+                    is_exported=func_is_exported,
                 )
                 analysis.symbols.append(symbol)
                 analysis.symbol_by_name[func_name] = symbol

packages/hypergumbo-lang-mainstream/tests/test_kotlin.py

@@ -75,6 +75,74 @@ def test_extracts_function(self, tmp_path: Path) -> None:
         assert "main" in func_names
         assert "helper" in func_names
 
+class TestKotlinExtensionFunctions:
+    """WI-fuhav: Kotlin extension function detection (``fun Receiver.name()``)."""
+
+    def test_detects_extension_function(self, tmp_path: Path) -> None:
+        """A ``fun Receiver.name()`` declaration is flagged as an extension."""
+        from hypergumbo_lang_mainstream.kotlin import analyze_kotlin
+
+        kt_file = tmp_path / "SpringApplicationExtensions.kt"
+        kt_file.write_text(
+            "package org.springframework.boot\n\n"
+            "class SpringApplication\n\n"
+            "fun SpringApplication.configure(block: () -> Unit) {\n"
+            "    block()\n"
+            "}\n",
+        )
+
+        result = analyze_kotlin(tmp_path)
+        funcs = [s for s in result.symbols if s.kind == "function"]
+        configure = next(
+            (s for s in funcs if s.name == "configure"), None,
+        )
+        assert configure is not None
+        assert configure.is_exported is True
+        assert configure.meta is not None
+        assert configure.meta.get("extension_receiver") == "SpringApplication"
+
+    def test_plain_function_not_flagged(self, tmp_path: Path) -> None:
+        """A regular (non-extension) top-level function is not flagged."""
+        from hypergumbo_lang_mainstream.kotlin import analyze_kotlin
+
+        kt_file = tmp_path / "Main.kt"
+        kt_file.write_text(
+            "fun greet(name: String) {\n"
+            "    println(\"hello, $name\")\n"
+            "}\n",
+        )
+        result = analyze_kotlin(tmp_path)
+        greet = next(
+            (s for s in result.symbols
+             if s.kind == "function" and s.name == "greet"),
+            None,
+        )
+        assert greet is not None
+        assert greet.is_exported is False
+        assert (greet.meta or {}).get("extension_receiver") is None
+
+    def test_extension_function_on_generic_receiver(
+        self, tmp_path: Path,
+    ) -> None:
+        """Extension on a generic receiver (``List<T>``) is detected."""
+        from hypergumbo_lang_mainstream.kotlin import analyze_kotlin
+
+        kt_file = tmp_path / "Ext.kt"
+        kt_file.write_text(
+            "fun List<Int>.sumSafe(): Int = this.fold(0) { acc, x -> acc + x }\n",
+        )
+        result = analyze_kotlin(tmp_path)
+        sum_safe = next(
+            (s for s in result.symbols
+             if s.kind == "function" and s.name == "sumSafe"),
+            None,
+        )
+        assert sum_safe is not None
+        assert sum_safe.is_exported is True
+        # Generic receiver text is preserved in the meta.
+        assert "List" in (sum_safe.meta or {}).get("extension_receiver", "")
+
+
 class TestKotlinClassExtraction:
     """Tests for extracting Kotlin classes."""