feat(typechecker): 增强类型检查逻辑，支持模块间枚举有效载荷的 ABI 稳定性

Author: IGCrystal

compiler/driver/src/pipeline.rs

@@ -34,7 +34,14 @@ pub fn check(path: &std::path::Path, opts: &CompilerOptions) -> CompileResult {
     let _sem = semantic::analyze_program(&module, &arena, &module_of_item, &mut diags);
     semantic::resolve_imports_program(&module, &mut arena, &module_of_item, &mut diags);
     let names = semantic::resolve_names_program(&module, &arena, &module_of_item, &mut diags);
-    let tc_out = typechecker::check_program(&module, &arena, &module_of_item, &names, &mut diags);
+    let tc_out = typechecker::check_program(
+        &module,
+        &arena,
+        &module_of_item,
+        &entry_module,
+        &names,
+        &mut diags,
+    );
     borrow_checker::check_module(&module, &arena, &mut diags);
 
     if diags.has_errors() {

compiler/driver/tests/compile_fail.rs

@@ -700,6 +700,62 @@ fn per_module_llvm_ir_units_split_definitions_and_declarations() {
     );
 }
 
+#[test]
+fn per_module_llvm_ir_units_preserve_enum_payload_abi_across_modules() {
+    let path = fixture("ok_enum_payload_across_modules.w");
+    let opts = CompilerOptions {
+        emit_llvm_ir_units: true,
+        ..Default::default()
+    };
+
+    let result = whatever_driver::check(&path, &opts);
+    assert!(
+        result.ok,
+        "expected fixture to pass, got:\n{}",
+        result.rendered_diags
+    );
+
+    let units = result
+        .llvm_ir_units
+        .expect("emit_llvm_ir_units should produce per-module LLVM IR units");
+    let entry = units
+        .get("ok_enum_payload_across_modules")
+        .expect("expected entry module unit: ok_enum_payload_across_modules");
+    let eabi = units.get("eabi").expect("expected module unit: eabi");
+
+    assert!(
+        entry.contains("declare") && entry.contains("@eabi__takes"),
+        "expected entry unit to declare eabi::takes, got:\n{entry}"
+    );
+    assert!(
+        entry.contains("call") && entry.contains("@eabi__takes"),
+        "expected entry unit to call eabi::takes, got:\n{entry}"
+    );
+    assert!(
+        !entry.contains("define ccc i32 @eabi__takes"),
+        "expected entry unit to not define eabi::takes, got:\n{entry}"
+    );
+
+    assert!(
+        eabi.contains("define ccc") && eabi.contains("@eabi__takes"),
+        "expected eabi unit to define eabi::takes, got:\n{eabi}"
+    );
+    assert!(
+        !eabi.contains("declare i32 @eabi__takes"),
+        "expected eabi unit to not declare eabi::takes (it defines it), got:\n{eabi}"
+    );
+
+    // Shape-level ABI stability: both units should agree on the enum representation.
+    assert!(
+        entry.contains("{ i32, i1, i32 }"),
+        "expected entry unit to contain enum repr shape, got:\n{entry}"
+    );
+    assert!(
+        eabi.contains("{ i32, i1, i32 }"),
+        "expected eabi unit to contain enum repr shape, got:\n{eabi}"
+    );
+}
+
 fn tool_available(tool: &str) -> bool {
     std::process::Command::new(tool)
         .arg("--version")
@@ -769,6 +825,52 @@ fn separate_compilation_emits_per_module_objects_when_clang_is_available() {
     assert!(foo_o.exists(), "expected foo object to exist: {foo_o:?}");
 }
 
+#[test]
+fn separate_compilation_emits_per_module_objects_for_enum_payload_when_clang_is_available() {
+    // Strong regression for cross-module ABI: compiles per-module objects.
+    if !tool_available("clang") {
+        eprintln!(
+            "skipping: clang not found in PATH (install LLVM/Clang to enable separate-compilation object emission regression)"
+        );
+        return;
+    }
+
+    let path = fixture("ok_enum_payload_across_modules.w");
+    let out_dir = unique_temp_out_dir("separate_compilation_enum_payload_emits_objects");
+
+    let opts = CompilerOptions {
+        emit_object: true,
+        link_executable: false,
+        separate_compilation: true,
+        codegen_tool: Some("clang".to_string()),
+        output_dir: Some(out_dir.clone()),
+        ..Default::default()
+    };
+
+    let result = whatever_driver::check(&path, &opts);
+    assert!(
+        result.ok,
+        "expected fixture to pass, got:\n{}",
+        result.rendered_diags
+    );
+
+    let entry_ll = out_dir.join("ok_enum_payload_across_modules.ll");
+    let entry_o = out_dir.join("ok_enum_payload_across_modules.o");
+    let eabi_ll = out_dir.join("eabi.ll");
+    let eabi_o = out_dir.join("eabi.o");
+
+    assert!(
+        entry_ll.exists(),
+        "expected entry ll to exist: {entry_ll:?}"
+    );
+    assert!(
+        entry_o.exists(),
+        "expected entry object to exist: {entry_o:?}"
+    );
+    assert!(eabi_ll.exists(), "expected eabi ll to exist: {eabi_ll:?}");
+    assert!(eabi_o.exists(), "expected eabi object to exist: {eabi_o:?}");
+}
+
 #[test]
 fn separate_compilation_links_executable_when_toolchain_is_available() {
     // Strong regression: exercises the link stage.

compiler/driver/tests/fixtures/eabi.w

@@ -0,0 +1,12 @@
+enum E { A(bool, i32), B }
+
+fn make() -> E {
+    E::A(true, 7)
+}
+
+fn takes(e: E) -> i32 {
+    match e {
+        E::A(b, n) => n,
+        E::B => 0,
+    }
+}

compiler/driver/tests/fixtures/ok_enum_payload_across_modules.w

@@ -0,0 +1,8 @@
+use eabi::E;
+use eabi::make;
+use eabi::takes;
+
+fn main() -> i32 {
+    let v: E = make();
+    takes(v)
+}