refactor(rustc_codegen_tuffy): replace silent skip with unimplemented!() for unsupported MIR

Change MIR-to-IR translation to panic with unimplemented!() instead of
silently returning None/false when encountering unsupported constructs:
- Unsupported rvalue kinds (catch-all and PtrMetadata)
- Unsupported place projections (OpaqueCast, UnwrapUnsafeBinder)
- Unhandled intrinsics and memory intrinsics
- Unhandled terminator and statement kinds

Also fix coerce_to_ptr missing function body in ctx.rs and a partial
move error for float_ty in rvalue.rs.

Update README.md with the error policy.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: dtcxzyw

rustc_codegen_tuffy/README.md

@@ -51,6 +51,10 @@ The downstream crates (`tuffy_ir`, `tuffy_opt`, `tuffy_target`, `tuffy_target_x8
 - Handles i128/u128 types through annotation-based legalization rather than type splitting at the IR level.
 - Supports `dump-ir` via `-C llvm-args=dump-ir` for debugging IR output.
 
+## Error Policy
+
+Unsupported MIR constructs (rvalue kinds, statement kinds, terminator kinds, intrinsics, place projections) must **not** be silently skipped. Use `unimplemented!()` with a descriptive message so the missing support is immediately visible. When an `unimplemented!()` is hit, the correct response is to add a concrete implementation for that construct — not to suppress the error.
+
 ## Dependencies
 
 - `tuffy_ir` — IR definitions

rustc_codegen_tuffy/src/mir_to_ir/ctx.rs

@@ -183,6 +183,11 @@ impl<'a, 'tcx> TranslationCtx<'a, 'tcx> {
 
     /// If `val` is an Int, insert inttoptr to coerce it to Ptr.
     pub(super) fn coerce_to_ptr(&mut self, val: ValueRef) -> ValueRef {
+        match self.builder.value_type(val) {
+            Some(Type::Int) => self.builder.inttoptr(val.into(), 0, Origin::synthetic()),
+            _ => val,
+        }
+    }
 
     /// Create a static `&Location` for a `#[track_caller]` call site.
     ///

rustc_codegen_tuffy/src/mir_to_ir/intrinsic.rs

@@ -429,8 +429,8 @@ pub(super) fn translate_intrinsic<'tcx>(
             true
         }
 
-        // Unhandled intrinsics fall through to normal call path.
-        _ => false,
+        // Unhandled intrinsics must be reported.
+        _ => unimplemented!("MIR intrinsic: {}", name),
     }
 }
 
@@ -892,7 +892,7 @@ pub(super) fn translate_memory_intrinsic<'tcx>(
             Some(new_mem)
         }
 
-        _ => None,
+        _ => unimplemented!("MIR memory intrinsic: {}", name),
     }
 }
 

rustc_codegen_tuffy/src/mir_to_ir/rvalue.rs

@@ -264,8 +264,7 @@ impl<'a, 'tcx> TranslationCtx<'a, 'tcx> {
                     };
                 }
                 _ => {
-                    // OpaqueCast, UnwrapUnsafeBinder — not yet handled.
-                    return None;
+                    unimplemented!("MIR place projection: {:?}", elem);
                 }
             }
         }
@@ -838,7 +837,7 @@ impl<'a, 'tcx> TranslationCtx<'a, 'tcx> {
                 };
 
                 // Float arithmetic: bitcast Int→Float, dispatch to fadd/fsub/fmul/fdiv, bitcast back.
-                if let Some(fty) = float_ty {
+                if let Some(ref fty) = float_ty {
                     if matches!(
                         op,
                         BinOp::Add
@@ -868,35 +867,35 @@ impl<'a, 'tcx> TranslationCtx<'a, 'tcx> {
                                 l_f.into(),
                                 r_f.into(),
                                 flags,
-                                fty,
+                                fty.clone(),
                                 Origin::synthetic(),
                             ),
                             BinOp::Sub | BinOp::SubUnchecked => self.builder.fsub(
                                 l_f.into(),
                                 r_f.into(),
                                 flags,
-                                fty,
+                                fty.clone(),
                                 Origin::synthetic(),
                             ),
                             BinOp::Mul | BinOp::MulUnchecked => self.builder.fmul(
                                 l_f.into(),
                                 r_f.into(),
                                 flags,
-                                fty,
+                                fty.clone(),
                                 Origin::synthetic(),
                             ),
                             BinOp::Rem => self.builder.frem(
                                 l_f.into(),
                                 r_f.into(),
                                 flags,
-                                fty,
+                                fty.clone(),
                                 Origin::synthetic(),
                             ),
                             _ => self.builder.fdiv(
                                 l_f.into(),
                                 r_f.into(),
                                 flags,
-                                fty,
+                                fty.clone(),
                                 Origin::synthetic(),
                             ),
                         };
@@ -1922,7 +1921,9 @@ impl<'a, 'tcx> TranslationCtx<'a, 'tcx> {
                 }
                 None
             }
-            Rvalue::UnaryOp(mir::UnOp::PtrMetadata, _) => None,
+            Rvalue::UnaryOp(mir::UnOp::PtrMetadata, _) => {
+                unimplemented!("MIR rvalue: UnaryOp::PtrMetadata")
+            }
             Rvalue::UnaryOp(mir::UnOp::Neg, operand) => {
                 let v = self.translate_operand(operand)?;
                 let neg_ann = match operand {
@@ -2058,7 +2059,7 @@ impl<'a, 'tcx> TranslationCtx<'a, 'tcx> {
                 self.stack_locals.mark(dest_place.local);
                 Some(slot)
             }
-            _ => None,
+            _ => unimplemented!("MIR rvalue: {:?}", rvalue),
         }
     }
 

rustc_codegen_tuffy/src/mir_to_ir/statement.rs

@@ -924,7 +924,9 @@ impl<'a, 'tcx> TranslationCtx<'a, 'tcx> {
                     }
                 }
             }
-            _ => {}
+            _ => {
+                unimplemented!("MIR statement: {:?}", stmt.kind);
+            }
         }
     }
 

rustc_codegen_tuffy/src/mir_to_ir/terminator.rs

@@ -440,9 +440,7 @@ impl<'a, 'tcx> TranslationCtx<'a, 'tcx> {
                 }
             }
             _ => {
-                // Unhandled terminator kind — emit unreachable so the block
-                // is never empty and the IR verifier stays happy.
-                self.builder.unreachable(Origin::synthetic());
+                unimplemented!("MIR terminator: {:?}", term.kind);
             }
         }
     }