Rollup merge of rust-lang#73582 - RalfJung:miri-span-bug, r=oli-obk

Dylan-DPC · web-flow · commit b4745703b6d6 · 2020-06-22T14:44:35.000+02:00
Miri: replace many bug! by span_bug! r? @oli-obk
diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs
@@ -52,7 +52,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                         }
 
                         if self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
-                            bug!("reifying a fn ptr that requires const arguments");
+                            span_bug!(
+                                self.cur_span(),
+                                "reifying a fn ptr that requires const arguments"
+                            );
                         }
 
                         let instance = ty::Instance::resolve_for_fn_ptr(
@@ -66,7 +69,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                         let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
                         self.write_scalar(fn_ptr, dest)?;
                     }
-                    _ => bug!("reify fn pointer on {:?}", src.layout.ty),
+                    _ => span_bug!(self.cur_span(), "reify fn pointer on {:?}", src.layout.ty),
                 }
             }
 
@@ -77,7 +80,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                         // No change to value
                         self.write_immediate(*src, dest)?;
                     }
-                    _ => bug!("fn to unsafe fn cast on {:?}", cast_ty),
+                    _ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty),
                 }
             }
 
@@ -99,7 +102,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                         let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
                         self.write_scalar(fn_ptr, dest)?;
                     }
-                    _ => bug!("closure fn pointer on {:?}", src.layout.ty),
+                    _ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),
                 }
             }
         }
@@ -162,7 +165,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 assert!(src.layout.ty.is_unsafe_ptr());
                 return match *src {
                     Immediate::ScalarPair(data, _) => Ok(data.into()),
-                    Immediate::Scalar(..) => bug!(
+                    Immediate::Scalar(..) => span_bug!(
+                        self.cur_span(),
                         "{:?} input to a fat-to-thin cast ({:?} -> {:?})",
                         *src,
                         src.layout.ty,
@@ -216,7 +220,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             }
 
             // Casts to bool are not permitted by rustc, no need to handle them here.
-            _ => bug!("invalid int to {:?} cast", cast_ty),
+            _ => span_bug!(self.cur_span(), "invalid int to {:?} cast", cast_ty),
         }
     }
 
@@ -248,7 +252,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             // float -> f64
             Float(FloatTy::F64) => Scalar::from_f64(f.convert(&mut false).value),
             // That's it.
-            _ => bug!("invalid float to {:?} cast", dest_ty),
+            _ => span_bug!(self.cur_span(), "invalid float to {:?} cast", dest_ty),
         }
     }
 
@@ -287,7 +291,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 self.write_immediate(val, dest)
             }
 
-            _ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty),
+            _ => {
+                span_bug!(self.cur_span(), "invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty)
+            }
         }
     }
 
@@ -307,7 +313,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 assert_eq!(def_a, def_b);
                 if def_a.is_box() || def_b.is_box() {
                     if !def_a.is_box() || !def_b.is_box() {
-                        bug!("invalid unsizing between {:?} -> {:?}", src.layout.ty, cast_ty.ty);
+                        span_bug!(
+                            self.cur_span(),
+                            "invalid unsizing between {:?} -> {:?}",
+                            src.layout.ty,
+                            cast_ty.ty
+                        );
                     }
                     return self.unsize_into_ptr(
                         src,
@@ -335,7 +346,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 }
                 Ok(())
             }
-            _ => bug!("unsize_into: invalid conversion: {:?} -> {:?}", src.layout, dest.layout),
+            _ => span_bug!(
+                self.cur_span(),
+                "unsize_into: invalid conversion: {:?} -> {:?}",
+                src.layout,
+                dest.layout
+            ),
         }
     }
 }
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
@@ -536,7 +536,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                         if sized_size == Size::ZERO {
                             return Ok(None);
                         } else {
-                            bug!("Fields cannot be extern types, unless they are at offset 0")
+                            span_bug!(
+                                self.cur_span(),
+                                "Fields cannot be extern types, unless they are at offset 0"
+                            )
                         }
                     }
                 };
@@ -584,7 +587,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
             ty::Foreign(_) => Ok(None),
 
-            _ => bug!("size_and_align_of::<{:?}> not supported", layout.ty),
+            _ => span_bug!(self.cur_span(), "size_and_align_of::<{:?}> not supported", layout.ty),
         }
     }
     #[inline]
diff --git a/src/librustc_mir/interpret/intrinsics.rs b/src/librustc_mir/interpret/intrinsics.rs
@@ -135,7 +135,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let bits = self.force_bits(val, layout_of.size)?;
                 let kind = match layout_of.abi {
                     Abi::Scalar(ref scalar) => scalar.value,
-                    _ => bug!("{} called on invalid type {:?}", intrinsic_name, ty),
+                    _ => span_bug!(
+                        self.cur_span(),
+                        "{} called on invalid type {:?}",
+                        intrinsic_name,
+                        ty
+                    ),
                 };
                 let (nonzero, intrinsic_name) = match intrinsic_name {
                     sym::cttz_nonzero => (true, sym::cttz),
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
@@ -311,7 +311,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         if let Ok(imm) = self.try_read_immediate(op)? {
             Ok(imm)
         } else {
-            bug!("primitive read failed for type: {:?}", op.layout.ty);
+            span_bug!(self.cur_span(), "primitive read failed for type: {:?}", op.layout.ty);
         }
     }
 
@@ -360,9 +360,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let val = if offset.bytes() == 0 { a } else { b };
                 Immediate::from(val)
             }
-            Immediate::Scalar(val) => {
-                bug!("field access on non aggregate {:#?}, {:#?}", val, op.layout)
-            }
+            Immediate::Scalar(val) => span_bug!(
+                self.cur_span(),
+                "field access on non aggregate {:#?}, {:#?}",
+                val,
+                op.layout
+            ),
         };
         Ok(OpTy { op: Operand::Immediate(immediate), layout: field_layout })
     }
@@ -545,7 +548,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             ty::ConstKind::Infer(..)
             | ty::ConstKind::Bound(..)
             | ty::ConstKind::Placeholder(..) => {
-                bug!("eval_const_to_op: Unexpected ConstKind {:?}", val)
+                span_bug!(self.cur_span(), "eval_const_to_op: Unexpected ConstKind {:?}", val)
             }
             ty::ConstKind::Value(val_val) => val_val,
         };
@@ -656,7 +659,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                             .discriminants(def_id, *self.tcx)
                             .find(|(_, var)| var.val == discr_bits)
                     }
-                    _ => bug!("tagged layout for non-adt non-generator"),
+                    _ => span_bug!(self.cur_span(), "tagged layout for non-adt non-generator"),
                 }
                 .ok_or_else(|| err_ub!(InvalidTag(tag_val.erase_tag())))?;
                 // Return the cast value, and the index.
diff --git a/src/librustc_mir/interpret/operator.rs b/src/librustc_mir/interpret/operator.rs
@@ -61,7 +61,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             Le => l <= r,
             Gt => l > r,
             Ge => l >= r,
-            _ => bug!("Invalid operation on char: {:?}", bin_op),
+            _ => span_bug!(self.cur_span(), "Invalid operation on char: {:?}", bin_op),
         };
         (Scalar::from_bool(res), false, self.tcx.types.bool)
     }
@@ -84,7 +84,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             BitAnd => l & r,
             BitOr => l | r,
             BitXor => l ^ r,
-            _ => bug!("Invalid operation on bool: {:?}", bin_op),
+            _ => span_bug!(self.cur_span(), "Invalid operation on bool: {:?}", bin_op),
         };
         (Scalar::from_bool(res), false, self.tcx.types.bool)
     }
@@ -110,7 +110,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             Mul => ((l * r).value.into(), ty),
             Div => ((l / r).value.into(), ty),
             Rem => ((l % r).value.into(), ty),
-            _ => bug!("invalid float op: `{:?}`", bin_op),
+            _ => span_bug!(self.cur_span(), "invalid float op: `{:?}`", bin_op),
         };
         (val, false, ty)
     }
@@ -154,7 +154,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
         // For the remaining ops, the types must be the same on both sides
         if left_layout.ty != right_layout.ty {
-            bug!(
+            span_bug!(
+                self.cur_span(),
                 "invalid asymmetric binary op {:?}: {:?} ({:?}), {:?} ({:?})",
                 bin_op,
                 l,
@@ -251,7 +252,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 ));
             }
 
-            _ => bug!(
+            _ => span_bug!(
+                self.cur_span(),
                 "invalid binary op {:?}: {:?}, {:?} (both {:?})",
                 bin_op,
                 l,
@@ -333,7 +335,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
                 M::binary_ptr_op(self, bin_op, left, right)
             }
-            _ => bug!("Invalid MIR: bad LHS type for binop: {:?}", left.layout.ty),
+            _ => span_bug!(
+                self.cur_span(),
+                "Invalid MIR: bad LHS type for binop: {:?}",
+                left.layout.ty
+            ),
         }
     }
 
@@ -367,15 +373,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let val = val.to_bool()?;
                 let res = match un_op {
                     Not => !val,
-                    _ => bug!("Invalid bool op {:?}", un_op),
+                    _ => span_bug!(self.cur_span(), "Invalid bool op {:?}", un_op),
                 };
                 Ok((Scalar::from_bool(res), false, self.tcx.types.bool))
             }
             ty::Float(fty) => {
                 let res = match (un_op, fty) {
                     (Neg, FloatTy::F32) => Scalar::from_f32(-val.to_f32()?),
                     (Neg, FloatTy::F64) => Scalar::from_f64(-val.to_f64()?),
-                    _ => bug!("Invalid float op {:?}", un_op),
+                    _ => span_bug!(self.cur_span(), "Invalid float op {:?}", un_op),
                 };
                 Ok((res, false, layout.ty))
             }
diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs
@@ -232,7 +232,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     ty::FnDef(..) => instance_ty.fn_sig(*self.tcx).abi(),
                     ty::Closure(..) => Abi::RustCall,
                     ty::Generator(..) => Abi::Rust,
-                    _ => bug!("unexpected callee ty: {:?}", instance_ty),
+                    _ => span_bug!(self.cur_span(), "unexpected callee ty: {:?}", instance_ty),
                 }
             };
             let normalize_abi = |abi| match abi {

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`if self.tcx.has_attr(def_id, sym::rustc_args_required_const) {`
`55`		`- bug!("reifying a fn ptr that requires const arguments");`
	`55`	`+ span_bug!(`
	`56`	`+ self.cur_span(),`
	`57`	`+ "reifying a fn ptr that requires const arguments"`
	`58`	`+ );`
`56`	`59`	`}`
`57`	`60`
`58`	`61`	`let instance = ty::Instance::resolve_for_fn_ptr(`
`@@ -66,7 +69,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`66`	`69`	`let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));`
`67`	`70`	`self.write_scalar(fn_ptr, dest)?;`
`68`	`71`	`}`
`69`		`- _ => bug!("reify fn pointer on {:?}", src.layout.ty),`
	`72`	`+ _ => span_bug!(self.cur_span(), "reify fn pointer on {:?}", src.layout.ty),`
`70`	`73`	`}`
`71`	`74`	`}`
`72`	`75`
`@@ -77,7 +80,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`77`	`80`	`// No change to value`
`78`	`81`	`self.write_immediate(*src, dest)?;`
`79`	`82`	`}`
`80`		`- _ => bug!("fn to unsafe fn cast on {:?}", cast_ty),`
	`83`	`+ _ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty),`
`81`	`84`	`}`
`82`	`85`	`}`
`83`	`86`
`@@ -99,7 +102,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`99`	`102`	`let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));`
`100`	`103`	`self.write_scalar(fn_ptr, dest)?;`
`101`	`104`	`}`
`102`		`- _ => bug!("closure fn pointer on {:?}", src.layout.ty),`
	`105`	`+ _ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),`
`103`	`106`	`}`
`104`	`107`	`}`
`105`	`108`	`}`
`@@ -162,7 +165,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`162`	`165`	`assert!(src.layout.ty.is_unsafe_ptr());`
`163`	`166`	`return match *src {`
`164`	`167`	`Immediate::ScalarPair(data, _) => Ok(data.into()),`
`165`		`- Immediate::Scalar(..) => bug!(`
	`168`	`+ Immediate::Scalar(..) => span_bug!(`
	`169`	`+ self.cur_span(),`
`166`	`170`	`"{:?} input to a fat-to-thin cast ({:?} -> {:?})",`
`167`	`171`	`*src,`
`168`	`172`	`src.layout.ty,`
`@@ -216,7 +220,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`216`	`220`	`}`
`217`	`221`
`218`	`222`	`// Casts to bool are not permitted by rustc, no need to handle them here.`
`219`		`- _ => bug!("invalid int to {:?} cast", cast_ty),`
	`223`	`+ _ => span_bug!(self.cur_span(), "invalid int to {:?} cast", cast_ty),`
`220`	`224`	`}`
`221`	`225`	`}`
`222`	`226`
`@@ -248,7 +252,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`248`	`252`	`// float -> f64`
`249`	`253`	`Float(FloatTy::F64) => Scalar::from_f64(f.convert(&mut false).value),`
`250`	`254`	`// That's it.`
`251`		`- _ => bug!("invalid float to {:?} cast", dest_ty),`
	`255`	`+ _ => span_bug!(self.cur_span(), "invalid float to {:?} cast", dest_ty),`
`252`	`256`	`}`
`253`	`257`	`}`
`254`	`258`
`@@ -287,7 +291,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`287`	`291`	`self.write_immediate(val, dest)`
`288`	`292`	`}`
`289`	`293`
`290`		`- _ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty),`
	`294`	`+ _ => {`
	`295`	`+ span_bug!(self.cur_span(), "invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty)`
	`296`	`+ }`
`291`	`297`	`}`
`292`	`298`	`}`
`293`	`299`
`@@ -307,7 +313,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`307`	`313`	`assert_eq!(def_a, def_b);`
`308`	`314`	`if def_a.is_box() \|\| def_b.is_box() {`
`309`	`315`	`if !def_a.is_box() \|\| !def_b.is_box() {`
`310`		`- bug!("invalid unsizing between {:?} -> {:?}", src.layout.ty, cast_ty.ty);`
	`316`	`+ span_bug!(`
	`317`	`+ self.cur_span(),`
	`318`	`+ "invalid unsizing between {:?} -> {:?}",`
	`319`	`+ src.layout.ty,`
	`320`	`+ cast_ty.ty`
	`321`	`+ );`
`311`	`322`	`}`
`312`	`323`	`return self.unsize_into_ptr(`
`313`	`324`	`src,`
`@@ -335,7 +346,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`335`	`346`	`}`
`336`	`347`	`Ok(())`
`337`	`348`	`}`
`338`		`- _ => bug!("unsize_into: invalid conversion: {:?} -> {:?}", src.layout, dest.layout),`
	`349`	`+ _ => span_bug!(`
	`350`	`+ self.cur_span(),`
	`351`	`+ "unsize_into: invalid conversion: {:?} -> {:?}",`
	`352`	`+ src.layout,`
	`353`	`+ dest.layout`
	`354`	`+ ),`
`339`	`355`	`}`
`340`	`356`	`}`
`341`	`357`	`}`
Original file line number	Diff line number	Diff line change
`@@ -536,7 +536,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`536`	`536`	`if sized_size == Size::ZERO {`
`537`	`537`	`return Ok(None);`
`538`	`538`	`} else {`
`539`		`- bug!("Fields cannot be extern types, unless they are at offset 0")`
	`539`	`+ span_bug!(`
	`540`	`+ self.cur_span(),`
	`541`	`+ "Fields cannot be extern types, unless they are at offset 0"`
	`542`	`+ )`
`540`	`543`	`}`
`541`	`544`	`}`
`542`	`545`	`};`
`@@ -584,7 +587,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`584`	`587`
`585`	`588`	`ty::Foreign(_) => Ok(None),`
`586`	`589`
`587`		`- _ => bug!("size_and_align_of::<{:?}> not supported", layout.ty),`
	`590`	`+ _ => span_bug!(self.cur_span(), "size_and_align_of::<{:?}> not supported", layout.ty),`
`588`	`591`	`}`
`589`	`592`	`}`
`590`	`593`	`#[inline]`
Original file line number	Diff line number	Diff line change
`@@ -311,7 +311,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`311`	`311`	`if let Ok(imm) = self.try_read_immediate(op)? {`
`312`	`312`	`Ok(imm)`
`313`	`313`	`} else {`
`314`		`- bug!("primitive read failed for type: {:?}", op.layout.ty);`
	`314`	`+ span_bug!(self.cur_span(), "primitive read failed for type: {:?}", op.layout.ty);`
`315`	`315`	`}`
`316`	`316`	`}`
`317`	`317`
`@@ -360,9 +360,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`360`	`360`	`let val = if offset.bytes() == 0 { a } else { b };`
`361`	`361`	`Immediate::from(val)`
`362`	`362`	`}`
`363`		`- Immediate::Scalar(val) => {`
`364`		`- bug!("field access on non aggregate {:#?}, {:#?}", val, op.layout)`
`365`		`- }`
	`363`	`+ Immediate::Scalar(val) => span_bug!(`
	`364`	`+ self.cur_span(),`
	`365`	`+ "field access on non aggregate {:#?}, {:#?}",`
	`366`	`+ val,`
	`367`	`+ op.layout`
	`368`	`+ ),`
`366`	`369`	`};`
`367`	`370`	`Ok(OpTy { op: Operand::Immediate(immediate), layout: field_layout })`
`368`	`371`	`}`
`@@ -545,7 +548,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`545`	`548`	`ty::ConstKind::Infer(..)`
`546`	`549`	`\| ty::ConstKind::Bound(..)`
`547`	`550`	`\| ty::ConstKind::Placeholder(..) => {`
`548`		`- bug!("eval_const_to_op: Unexpected ConstKind {:?}", val)`
	`551`	`+ span_bug!(self.cur_span(), "eval_const_to_op: Unexpected ConstKind {:?}", val)`
`549`	`552`	`}`
`550`	`553`	`ty::ConstKind::Value(val_val) => val_val,`
`551`	`554`	`};`
`@@ -656,7 +659,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`656`	`659`	`.discriminants(def_id, *self.tcx)`
`657`	`660`	`.find(\|(_, var)\| var.val == discr_bits)`
`658`	`661`	`}`
`659`		`- _ => bug!("tagged layout for non-adt non-generator"),`
	`662`	`+ _ => span_bug!(self.cur_span(), "tagged layout for non-adt non-generator"),`
`660`	`663`	`}`
`661`	`664`	`.ok_or_else(\|\| err_ub!(InvalidTag(tag_val.erase_tag())))?;`
`662`	`665`	`// Return the cast value, and the index.`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`232`	`232`	`ty::FnDef(..) => instance_ty.fn_sig(*self.tcx).abi(),`
`233`	`233`	`ty::Closure(..) => Abi::RustCall,`
`234`	`234`	`ty::Generator(..) => Abi::Rust,`
`235`		`- _ => bug!("unexpected callee ty: {:?}", instance_ty),`
	`235`	`+ _ => span_bug!(self.cur_span(), "unexpected callee ty: {:?}", instance_ty),`
`236`	`236`	`}`
`237`	`237`	`};`
`238`	`238`	`let normalize_abi = \|abi\| match abi {`