test: inline-extern shape coverage (Refs #346)

Adds class-level coverage for the "inline extern fed to every
downstream consumer" surface that produced the PR #346 FnExtern
interp bug (Interp.eval_decl's TopFn arm missing the FnExtern
match arm — silent pattern-match failure since the interpreter
was written; fired the moment STDLIB-04a's tests became the first
to hand an inline `extern fn` to Interp.eval_program).

Four fixtures under test/e2e/fixtures/:

  inline_extern_pure.affine          — no effects
  inline_extern_effectful.affine     — return type carries effect row
  inline_extern_polymorphic.affine   — `extern fn host_identity[T]`
  inline_extern_type_consumed.affine — `extern type` + consuming fn

Each fed through parse → resolve → typecheck → interp via the new
`inline_extern_pipeline_ok` helper in test/test_e2e.ml; assertion
is that all four phases return Ok. A regression that re-introduces
the silent pattern-match-failure path that broke main between #334
and #346 would fail loudly here.

Suite registered as "E2E Inline Extern Shapes (Refs #346)".

Queued as a comment on PR #346 in the previous session; this is
the follow-up. Per the CLAUDE.md "Test-fixture hygiene for latent
bug surfaces" rule landed this session, this treats "first user of
an existing-but-untested declaration shape" as a class-level
surface, not a single test case.

Not yet locally verified — no OCaml toolchain in remote execution
env. CI is the verification surface; the fixtures use only
already-parseable surface syntax (effects/extern/type-params), so
risk is low.

Refs #346, Refs CLAUDE.md §"Test-fixture hygiene"

Author: claude

test/e2e/fixtures/inline_extern_effectful.affine

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MPL-2.0
+// SPDX-FileCopyrightText: 2026 hyperpolymath
+//
+// Inline-extern fixture (effectful): an `extern fn` declaration
+// whose return type carries an effect row.  Exercises the same path
+// as inline_extern_pure plus the effect-row resolution branch in
+// typecheck.  Pinned against the gate so a regression to the
+// pre-#346 silent-failure shape would fail loudly.
+//
+// See .claude/CLAUDE.md §"Test-fixture hygiene for latent bug
+// surfaces".
+
+effect IO;
+
+extern fn host_log(msg: String) -> Unit / IO;
+
+pub fn main() -> Int {
+  return 0;
+}

test/e2e/fixtures/inline_extern_polymorphic.affine

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MPL-2.0
+// SPDX-FileCopyrightText: 2026 hyperpolymath
+//
+// Inline-extern fixture (polymorphic): an `extern fn` declaration
+// with type parameters.  Exercises the polymorphic-scheme registration
+// path that the FnExtern special case in typecheck handles
+// (see lib/typecheck.ml `check_fn_decl` `FnExtern` arm).
+//
+// See .claude/CLAUDE.md §"Test-fixture hygiene for latent bug
+// surfaces".
+
+extern fn host_identity[T](x: T) -> T;
+
+pub fn main() -> Int {
+  return 0;
+}

test/e2e/fixtures/inline_extern_pure.affine

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MPL-2.0
+// SPDX-FileCopyrightText: 2026 hyperpolymath
+//
+// Inline-extern fixture (pure): an `extern fn` declaration with no
+// effect row, fed to the full pipeline (parse → resolve → typecheck
+// → interp).  Counterpart to the missing `FnExtern` arm in
+// Interp.eval_decl that PR #346 fixed; this fixture pins the
+// "no-effect inline extern" shape against the gate so a regression
+// to the silent-pattern-match-failure path of the kind that broke
+// main between #334 and #346 would fail loudly here instead.
+//
+// See .claude/CLAUDE.md §"Test-fixture hygiene for latent bug
+// surfaces" and the comment on PR #346 for the rationale.
+
+extern fn host_pure_identity(x: Int) -> Int;
+
+pub fn main() -> Int {
+  // The call itself doesn't have to succeed at runtime — the
+  // interpreter's VBuiltin table doesn't know about
+  // host_pure_identity — but parse + resolve + typecheck + the
+  // eval_decl arm for FnExtern MUST all return Ok.  The check_program
+  // test driver asserts that, not the runtime value.
+  return 0;
+}

test/e2e/fixtures/inline_extern_type_consumed.affine

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MPL-2.0
+// SPDX-FileCopyrightText: 2026 hyperpolymath
+//
+// Inline-extern fixture (extern type + extern fn together):
+// an opaque host type declared inline and consumed by an extern
+// function in the same unit.  Exercises both TyExtern registration
+// and the FnExtern path that consumes the resulting type.
+//
+// See .claude/CLAUDE.md §"Test-fixture hygiene for latent bug
+// surfaces".
+
+extern type Handle;
+
+extern fn host_use(h: Handle) -> Int;
+
+pub fn main() -> Int {
+  return 0;
+}

test/test_e2e.ml

@@ -3834,6 +3834,80 @@ let qualified_value_tests = [
   Alcotest.test_case "use Mod as M; M::fn(x) resolves (#178 follow-up)" `Quick test_qualval_coloncolon_alias_call;
 ]
 
+(* ---- Inline `extern fn` / `extern type` shape-coverage fixtures ----
+   Class-level coverage for the "first user of an inline extern shape
+   feeds it to every downstream consumer" surface that produced the
+   PR #346 FnExtern interp bug (eval_decl missing match arm — survived
+   since the interpreter was written, fired the moment STDLIB-04a's
+   tests became the first to hand an inline extern fn to
+   Interp.eval_program).
+
+   See .claude/CLAUDE.md §"Test-fixture hygiene for latent bug
+   surfaces" for the rationale. Each fixture is fed through
+   parse → resolve → typecheck → interp; the assertion is that ALL
+   four return Ok. A regression that re-introduces the silent
+   pattern-match-failure path of the kind that broke main between
+   #334 and #346 would fail loudly here. *)
+
+let inline_extern_pipeline_ok path : bool =
+  let loader = Module_loader.create {
+    Module_loader.stdlib_path = "stdlib";
+    search_paths = [];
+    current_dir = fixture_dir;
+  } in
+  match parse_fixture path with
+  | Error _ -> false
+  | Ok raw ->
+    let prog = Resolve.lower_qualified_value_paths raw in
+    (match Resolve.resolve_program_with_loader prog loader with
+     | Error _ -> false
+     | Ok (resolve_ctx, import_type_ctx) ->
+       (match Typecheck.check_program
+                ~import_types:import_type_ctx.Typecheck.name_types
+                resolve_ctx.symbols prog with
+        | Error _ -> false
+        | Ok _ ->
+          (* The PR #346 root cause was here: Interp.eval_decl's TopFn
+             arm didn't match FnExtern, raising Match_failure. The
+             fixtures don't *call* the extern at runtime (the host
+             impl isn't registered), but eval_program walks every
+             TopFn through eval_decl as part of building the initial
+             env — that's the path that fired the missing arm. *)
+          (match Interp.eval_program prog with
+           | Ok _ -> true
+           | Error _ -> false)))
+
+let test_inline_extern_pure () =
+  Alcotest.(check bool)
+    "inline `extern fn host_pure_identity(x: Int) -> Int;` passes the pipeline"
+    true
+    (inline_extern_pipeline_ok (fixture "inline_extern_pure.affine"))
+
+let test_inline_extern_effectful () =
+  Alcotest.(check bool)
+    "inline `extern fn host_log(msg) -> Unit / IO;` passes the pipeline"
+    true
+    (inline_extern_pipeline_ok (fixture "inline_extern_effectful.affine"))
+
+let test_inline_extern_polymorphic () =
+  Alcotest.(check bool)
+    "inline `extern fn host_identity[T](x: T) -> T;` passes the pipeline"
+    true
+    (inline_extern_pipeline_ok (fixture "inline_extern_polymorphic.affine"))
+
+let test_inline_extern_type_consumed () =
+  Alcotest.(check bool)
+    "inline `extern type Handle; extern fn host_use(h: Handle) -> Int;` passes the pipeline"
+    true
+    (inline_extern_pipeline_ok (fixture "inline_extern_type_consumed.affine"))
+
+let inline_extern_shape_tests = [
+  Alcotest.test_case "pure (no effects)"           `Quick test_inline_extern_pure;
+  Alcotest.test_case "effectful (effect row)"      `Quick test_inline_extern_effectful;
+  Alcotest.test_case "polymorphic (type params)"   `Quick test_inline_extern_polymorphic;
+  Alcotest.test_case "extern type + consuming fn"  `Quick test_inline_extern_type_consumed;
+]
+
 (* ---- Type-syntax sugars: fn(...) -> T, Option<T>, (A, B) -> C ---- *)
 
 let parse_check_passes src : bool =
@@ -4304,6 +4378,7 @@ let tests =
     ("E2E Array Type Sugar",     array_type_tests);
     ("E2E Qualified Paths #228",  qualified_path_tests);
     ("E2E Qualified Value #178",  qualified_value_tests);
+    ("E2E Inline Extern Shapes (Refs #346)", inline_extern_shape_tests);
     ("E2E WasmGC PatCon Destructure", wasm_gc_patcon_tests);
     ("E2E Type Syntax Sugar",         type_syntax_sugar_tests);
   ]