librustc_trans: use bug!(), span_bug!()

Author: ben0x539

src/librustc_trans/_match.rs

@@ -242,7 +242,7 @@ impl<'a> ConstantExpr<'a> {
     fn eq(self, other: ConstantExpr<'a>, tcx: &TyCtxt) -> bool {
         match compare_lit_exprs(tcx, self.0, other.0) {
             Some(result) => result == Ordering::Equal,
-            None => panic!("compare_list_exprs: type mismatch"),
+            None => bug!("compare_list_exprs: type mismatch"),
         }
     }
 }
@@ -828,7 +828,7 @@ impl FailureHandler {
     fn handle_fail(&self, bcx: Block) {
         match *self {
             Infallible =>
-                panic!("attempted to panic in a non-panicking panic handler!"),
+                bug!("attempted to panic in a non-panicking panic handler!"),
             JumpToBasicBlock(basic_block) =>
                 Br(bcx, basic_block, DebugLoc::None),
             Unreachable =>
@@ -939,11 +939,11 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
 
                     compare_str(cx, lhs_data, lhs_len, rhs_data, rhs_len, rhs_t, debug_loc)
                 },
-                _ => cx.sess().bug("only byte strings supported in compare_values"),
+                _ => bug!("only byte strings supported in compare_values"),
             },
-            _ => cx.sess().bug("only string and byte strings supported in compare_values"),
+            _ => bug!("only string and byte strings supported in compare_values"),
         },
-        _ => cx.sess().bug("only scalars, byte strings, and strings supported in compare_values"),
+        _ => bug!("only scalars, byte strings, and strings supported in compare_values"),
     }
 }
 
@@ -986,7 +986,7 @@ fn insert_lllocals<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                         Lvalue::new_with_hint("_match::insert_lllocals (match_input)",
                                               bcx, binding_info.id, hint_kind)
                     }
-                    _ => unreachable!(),
+                    _ => bug!(),
                 };
                 let datum = Datum::new(llval, binding_info.ty, lvalue);
                 call_lifetime_start(bcx, llbinding);
@@ -1317,7 +1317,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                             bcx = r.bcx;
                         }
                         _ => {
-                            bcx.sess().bug(
+                            bug!(
                                 "in compile_submatch, expected \
                                  opt.trans() to return a SingleResult")
                         }

src/librustc_trans/abi.rs

@@ -218,7 +218,7 @@ impl FnType {
             Rust | RustCall => llvm::CCallConv,
 
             // It's the ABI's job to select this, not us.
-            System => ccx.sess().bug("system abi should be selected elsewhere"),
+            System => bug!("system abi should be selected elsewhere"),
 
             Stdcall => llvm::X86StdcallCallConv,
             Fastcall => llvm::X86FastcallCallConv,
@@ -241,8 +241,8 @@ impl FnType {
                     &tupled_arguments[..]
                 }
                 _ => {
-                    unreachable!("argument to function with \"rust-call\" ABI \
-                                  is not a tuple");
+                    bug!("argument to function with \"rust-call\" ABI \
+                          is not a tuple");
                 }
             }
         } else {

src/librustc_trans/adt.rs

@@ -302,9 +302,8 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             // non-empty body, explicit discriminants should have
             // been rejected by a checker before this point.
             if !cases.iter().enumerate().all(|(i,c)| c.discr == Disr::from(i)) {
-                cx.sess().bug(&format!("non-C-like enum {} with specified \
-                                        discriminants",
-                                       cx.tcx().item_path_str(def.did)));
+                bug!("non-C-like enum {} with specified discriminants",
+                     cx.tcx().item_path_str(def.did));
             }
 
             if cases.len() == 1 {
@@ -430,7 +429,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
             General(ity, fields, dtor_to_init_u8(dtor))
         }
-        _ => cx.sess().bug(&format!("adt::represent_type called on non-ADT type: {}", t))
+        _ => bug!("adt::represent_type called on non-ADT type: {}", t)
     }
 }
 
@@ -615,7 +614,7 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp
     match hint {
         attr::ReprInt(span, ity) => {
             if !bounds_usable(cx, ity, bounds) {
-                cx.sess().span_bug(span, "representation hint insufficient for discriminant range")
+                span_bug!(span, "representation hint insufficient for discriminant range")
             }
             return ity;
         }
@@ -632,10 +631,10 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp
             attempts = choose_shortest;
         },
         attr::ReprPacked => {
-            cx.tcx().sess.bug("range_to_inttype: found ReprPacked on an enum");
+            bug!("range_to_inttype: found ReprPacked on an enum");
         }
         attr::ReprSimd => {
-            cx.tcx().sess.bug("range_to_inttype: found ReprSimd on an enum");
+            bug!("range_to_inttype: found ReprSimd on an enum");
         }
     }
     for &ity in attempts {
@@ -835,7 +834,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                  Type::array(&Type::i64(cx), align_units),
                 a if a.count_ones() == 1 => Type::array(&Type::vector(&Type::i32(cx), a / 4),
                                                               align_units),
-                _ => panic!("unsupported enum alignment: {}", align)
+                _ => bug!("unsupported enum alignment: {}", align)
             };
             assert_eq!(machine::llalign_of_min(cx, fill_ty), align);
             assert_eq!(padded_discr_size % discr_size, 0); // Ensure discr_ty can fill pad evenly
@@ -984,7 +983,7 @@ pub fn trans_case<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr, discr: Disr)
             C_integral(ll_inttype(bcx.ccx(), ity), discr.0, true)
         }
         Univariant(..) => {
-            bcx.ccx().sess().bug("no cases for univariants or structs")
+            bug!("no cases for univariants or structs")
         }
         RawNullablePointer { .. } |
         StructWrappedNullablePointer { .. } => {
@@ -1088,7 +1087,7 @@ pub fn trans_field_ptr_builder<'blk, 'tcx>(bcx: &BlockAndBuilder<'blk, 'tcx>,
     // someday), it will need to return a possibly-new bcx as well.
     match *r {
         CEnum(..) => {
-            bcx.ccx().sess().bug("element access in C-like enum")
+            bug!("element access in C-like enum")
         }
         Univariant(ref st, _dtor) => {
             assert_eq!(discr, Disr(0));
@@ -1279,7 +1278,7 @@ pub fn fold_variants<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
 
             bcx_next
         }
-        _ => unreachable!()
+        _ => bug!()
     }
 }
 
@@ -1319,7 +1318,7 @@ pub fn trans_drop_flag_ptr<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             fcx.pop_custom_cleanup_scope(custom_cleanup_scope);
             datum::DatumBlock::new(bcx, expr_datum)
         }
-        _ => bcx.ccx().sess().bug("tried to get drop flag of non-droppable type")
+        _ => bug!("tried to get drop flag of non-droppable type")
     }
 }
 
@@ -1478,7 +1477,7 @@ pub fn const_get_discrim(r: &Repr, val: ValueRef) -> Disr {
         }
         Univariant(..) => Disr(0),
         RawNullablePointer { .. } | StructWrappedNullablePointer { .. } => {
-            unreachable!("const discrim access of non c-like enum")
+            bug!("const discrim access of non c-like enum")
         }
     }
 }
@@ -1488,10 +1487,10 @@ pub fn const_get_discrim(r: &Repr, val: ValueRef) -> Disr {
 ///
 /// (Not to be confused with `common::const_get_elt`, which operates on
 /// raw LLVM-level structs and arrays.)
-pub fn const_get_field(ccx: &CrateContext, r: &Repr, val: ValueRef,
-                       _discr: Disr, ix: usize) -> ValueRef {
+pub fn const_get_field(r: &Repr, val: ValueRef, _discr: Disr,
+                       ix: usize) -> ValueRef {
     match *r {
-        CEnum(..) => ccx.sess().bug("element access in C-like enum const"),
+        CEnum(..) => bug!("element access in C-like enum const"),
         Univariant(..) => const_struct_field(val, ix),
         General(..) => const_struct_field(val, ix + 1),
         RawNullablePointer { .. } => {

src/librustc_trans/assert_dep_graph.rs

@@ -221,7 +221,7 @@ fn dump_graph(tcx: &TyCtxt) {
             // Expect one of: "-> target", "source -> target", or "source ->".
             let parts: Vec<_> = string.split("->").collect();
             if parts.len() > 2 {
-                panic!("Invalid RUST_DEP_GRAPH_FILTER: expected '[source] -> [target]'");
+                bug!("Invalid RUST_DEP_GRAPH_FILTER: expected '[source] -> [target]'");
             }
             let sources = node_set(&query, &parts[0]);
             let targets = node_set(&query, &parts[1]);

src/librustc_trans/back/link.rs

@@ -187,8 +187,8 @@ pub fn link_binary(sess: &Session,
     let mut out_filenames = Vec::new();
     for &crate_type in sess.crate_types.borrow().iter() {
         if invalid_output_for_target(sess, crate_type) {
-            sess.bug(&format!("invalid output type `{:?}` for target os `{}`",
-                             crate_type, sess.opts.target_triple));
+           bug!("invalid output type `{:?}` for target os `{}`",
+                crate_type, sess.opts.target_triple);
         }
         let out_file = link_binary_output(sess, trans, crate_type, outputs,
                                           crate_name);
@@ -282,7 +282,7 @@ pub fn each_linked_rlib(sess: &Session,
     let fmts = fmts.get(&config::CrateTypeExecutable).or_else(|| {
         fmts.get(&config::CrateTypeStaticlib)
     }).unwrap_or_else(|| {
-        sess.bug("could not find formats for rlibs")
+        bug!("could not find formats for rlibs")
     });
     for (cnum, path) in crates {
         match fmts[cnum as usize - 1] {
@@ -895,7 +895,7 @@ fn add_local_native_libraries(cmd: &mut Linker, sess: &Session) {
         match kind {
             NativeLibraryKind::NativeUnknown => cmd.link_dylib(l),
             NativeLibraryKind::NativeFramework => cmd.link_framework(l),
-            NativeLibraryKind::NativeStatic => unreachable!(),
+            NativeLibraryKind::NativeStatic => bug!(),
         }
     }
 }
@@ -1081,7 +1081,7 @@ fn add_upstream_native_libraries(cmd: &mut Linker, sess: &Session) {
                 NativeLibraryKind::NativeUnknown => cmd.link_dylib(lib),
                 NativeLibraryKind::NativeFramework => cmd.link_framework(lib),
                 NativeLibraryKind::NativeStatic => {
-                    sess.bug("statics shouldn't be propagated");
+                    bug!("statics shouldn't be propagated");
                 }
             }
         }

src/librustc_trans/back/linker.rs

@@ -271,10 +271,10 @@ impl<'a> Linker for MsvcLinker<'a> {
     }
 
     fn framework_path(&mut self, _path: &Path) {
-        panic!("frameworks are not supported on windows")
+        bug!("frameworks are not supported on windows")
     }
     fn link_framework(&mut self, _framework: &str) {
-        panic!("frameworks are not supported on windows")
+        bug!("frameworks are not supported on windows")
     }
 
     fn link_whole_staticlib(&mut self, lib: &str, _search_path: &[PathBuf]) {

src/librustc_trans/back/symbol_names.rs

@@ -224,8 +224,8 @@ fn exported_name_with_opt_suffix<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                 // to be a value or type-def or something in there
                 // *somewhere*
                 ty_def_id.index = key.parent.unwrap_or_else(|| {
-                    panic!("finding type for {:?}, encountered def-id {:?} with no \
-                            parent", def_id, ty_def_id);
+                    bug!("finding type for {:?}, encountered def-id {:?} with no \
+                         parent", def_id, ty_def_id);
                 });
             }
         }

src/librustc_trans/back/write.rs

@@ -113,7 +113,7 @@ impl Emitter for SharedEmitter {
     }
 
     fn custom_emit(&mut self, _sp: &errors::RenderSpan, _msg: &str, _lvl: Level) {
-        panic!("SharedEmitter doesn't support custom_emit");
+        bug!("SharedEmitter doesn't support custom_emit");
     }
 }
 
@@ -159,7 +159,7 @@ pub fn create_target_machine(sess: &Session) -> TargetMachineRef {
                                  .cg
                                  .relocation_model));
             sess.abort_if_errors();
-            unreachable!();
+            bug!();
         }
     };
 
@@ -190,7 +190,7 @@ pub fn create_target_machine(sess: &Session) -> TargetMachineRef {
                                  .cg
                                  .code_model));
             sess.abort_if_errors();
-            unreachable!();
+            bug!();
         }
     };