Remove some checks and associated FIXMEs from trans code

Such intentions are better tracked in the bug tracker, don't need
to litter the code with repetetive comments.

Author: marijnh

src/comp/middle/trans/alt.rs

@@ -63,7 +63,6 @@ fn trans_opt(bcx: block, o: opt) -> opt_result {
     }
 }
 
-// FIXME: invariant -- pat_id is bound in the def_map?
 fn variant_opt(ccx: @crate_ctxt, pat_id: ast::node_id) -> opt {
     let vdef = ast_util::variant_def_ids(ccx.tcx.def_map.get(pat_id));
     let variants = ty::enum_variants(ccx.tcx, vdef.enm);
@@ -499,20 +498,13 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef], f: mk_fail,
           _ { }
         }
     }
-    let else_cx =
-        alt kind {
-          no_branch | single { bcx }
-          _ { sub_block(bcx, "match_else") }
-        };
-    let sw;
-    if kind == switch {
-        sw = Switch(bcx, test_val, else_cx.llbb, opts.len());
-        // FIXME This statement is purely here as a work-around for a bug that
-        // I expect to be the same as issue #951. If I remove it, sw ends up
-        // holding a corrupted value (when the compiler is optimized).
-        // This can be removed after our next LLVM upgrade.
-        val_ty(sw);
-    } else { sw = C_int(ccx, 0); } // Placeholder for when not using a switch
+    let else_cx = alt kind {
+      no_branch | single { bcx }
+      _ { sub_block(bcx, "match_else") }
+    };
+    let sw = if kind == switch {
+        Switch(bcx, test_val, else_cx.llbb, opts.len())
+    } else { C_int(ccx, 0) }; // Placeholder for when not using a switch
 
      // Compile subtrees for each option
     for opt: opt in opts {
@@ -694,9 +686,6 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
       ast::pat_ident(_,inner) {
         if make_copy || ccx.copy_map.contains_key(pat.id) {
             let ty = node_id_type(bcx, pat.id);
-            // FIXME: Could constrain pat_bind to make this
-            // check unnecessary.
-            check (type_has_static_size(ccx, ty));
             let llty = type_of(ccx, ty);
             let alloc = alloca(bcx, llty);
             bcx = copy_val(bcx, INIT, alloc,

src/comp/middle/trans/base.rs

@@ -186,10 +186,6 @@ fn type_of_ty_param_bounds_and_ty
         // fall through
       }
     }
-    // FIXME: could have a precondition on tpt, but that
-    // doesn't work right now because one predicate can't imply
-    // another
-    check type_has_static_size(ccx, t);
     type_of(ccx, t)
 }
 
@@ -523,7 +519,6 @@ fn trans_malloc_boxed_raw(bcx: block, t: ty::t,
     // Grab the TypeRef type of box_ptr, because that's what trans_raw_malloc
     // wants.
     let box_ptr = ty::mk_imm_box(bcx.tcx(), t);
-    check (type_has_static_size(ccx, box_ptr));
     let llty = type_of(ccx, box_ptr);
 
     // Get the tydesc for the body:
@@ -792,7 +787,6 @@ fn declare_generic_glue(ccx: @crate_ctxt, t: ty::t, llfnty: TypeRef,
     ret llfn;
 }
 
-// FIXME: was this causing the leak?
 fn make_generic_glue_inner(ccx: @crate_ctxt, t: ty::t,
                            llfn: ValueRef, helper: glue_helper,
                            ty_params: [uint]) -> ValueRef {
@@ -1218,7 +1212,6 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
                 j += 1u;
             }
           }
-          // Precondition?
           _ { cx.tcx().sess.bug("iter_variant: not a function type"); }
         }
         ret cx;
@@ -1460,7 +1453,6 @@ fn drop_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block {
       ty::ty_box(_) | ty::ty_opaque_box {
         decr_refcnt_maybe_free(bcx, v, t)
       }
-      // Precondition?
       _ { bcx.tcx().sess.bug("drop_ty_immediate: non-box ty"); }
     }
 }
@@ -1608,9 +1600,8 @@ fn move_val(cx: block, action: copy_action, dst: ValueRef,
         revoke_clean(cx, src_val);
         ret cx;
     }
-    /* FIXME: suggests a type constraint */
     cx.sess().bug("unexpected type in trans::move_val: " +
-                             ty_to_str(tcx, t));
+                  ty_to_str(tcx, t));
 }
 
 fn store_temp_expr(cx: block, action: copy_action, dst: ValueRef,
@@ -1718,9 +1709,7 @@ fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef,
       ast::eq | ast::ne { llop = C_u8(abi::cmp_glue_op_eq); }
       ast::lt | ast::ge { llop = C_u8(abi::cmp_glue_op_lt); }
       ast::le | ast::gt { llop = C_u8(abi::cmp_glue_op_le); }
-      // Precondition?
-      _ { cx.tcx().sess.bug("trans_compare got\
-              non-comparison-op"); }
+      _ { cx.tcx().sess.bug("trans_compare got non-comparison-op"); }
     }
 
     let rs = call_cmp_glue(cx, lhs, rhs, rhs_t, llop);
@@ -2000,7 +1989,6 @@ fn store_in_dest(bcx: block, val: ValueRef, dest: dest) -> block {
 fn get_dest_addr(dest: dest) -> ValueRef {
     alt dest {
        save_in(a) { a }
-       // Precondition?
        _ { fail "get_dest_addr: not a save_in"; }
     }
 }
@@ -2079,7 +2067,7 @@ fn trans_while(cx: block, cond: @ast::expr, body: ast::blk)
     -> block {
     let next_cx = sub_block(cx, "while next");
     let cond_cx = loop_scope_block(cx, cont_self, next_cx,
-                                            "while cond", body.span);
+                                   "while cond", body.span);
     let body_cx = scope_block(cond_cx, "while loop body");
     Br(cx, cond_cx.llbb);
     let cond_res = trans_temp_expr(cond_cx, cond);
@@ -2483,9 +2471,9 @@ fn trans_callee(bcx: block, e: @ast::expr) -> lval_maybe_callee {
               some(origin) { // An impl method
                 ret impl::trans_method_callee(bcx, e.id, base, origin);
               }
-              // Precondition?
-              _ { bcx.tcx().sess.span_bug(e.span, "trans_callee: weird\
-                    expr"); }
+              _ {
+                bcx.ccx().sess.span_bug(e.span, "trans_callee: weird expr");
+              }
             }
         }
       }
@@ -2515,7 +2503,7 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result {
         let ccx = cx.ccx();
         let sub = trans_temp_expr(cx, base);
         let t = expr_ty(cx, base);
-        let val = alt ty::get(t).struct {
+        let val = alt check ty::get(t).struct {
           ty::ty_box(_) {
             GEPi(sub.bcx, sub.val, [0, abi::box_field_body])
           }
@@ -2524,18 +2512,12 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result {
           }
           ty::ty_enum(_, _) {
             let ety = expr_ty(cx, e);
-            let ellty =
-                if check type_has_static_size(ccx, ety) {
+            let ellty = if check type_has_static_size(ccx, ety) {
                 T_ptr(type_of(ccx, ety))
             } else { T_typaram_ptr(ccx.tn) };
             PointerCast(sub.bcx, sub.val, ellty)
           }
           ty::ty_ptr(_) | ty::ty_uniq(_) { sub.val }
-          // Precondition?
-          _ {
-            cx.tcx().sess.span_bug(e.span, "trans_lval:\
-                                               Weird argument in deref");
-          }
         };
         ret lval_owned(sub.bcx, val);
       }
@@ -2602,9 +2584,6 @@ fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id,
     let e_res = trans_temp_expr(cx, e);
     let ll_t_in = val_ty(e_res.val);
     let t_in = expr_ty(cx, e);
-    // Check should be avoidable because it's a cast.
-    // FIXME: Constrain types so as to avoid this check.
-    check (type_has_static_size(ccx, t_out));
     let ll_t_out = type_of(ccx, t_out);
 
     enum kind { pointer, integral, float, enum_, other, }
@@ -3210,11 +3189,6 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
         ret trans_ret(bcx, ex);
       }
       ast::expr_be(ex) {
-        // Ideally, the expr_be enum would have a precondition
-        // that is_call_expr(ex) -- but we don't support that
-        // yet
-        // FIXME
-        check (ast_util::is_call_expr(ex));
         ret trans_be(bcx, ex);
       }
       ast::expr_fail(expr) {
@@ -3526,9 +3500,7 @@ fn trans_ret(bcx: block, e: option<@ast::expr>) -> block {
 
 fn build_return(bcx: block) { Br(bcx, bcx.fcx.llreturn); }
 
-// fn trans_be(cx: &block, e: &@ast::expr) -> result {
-fn trans_be(cx: block, e: @ast::expr) : ast_util::is_call_expr(e) ->
-   block {
+fn trans_be(cx: block, e: @ast::expr) -> block {
     // FIXME: Turn this into a real tail call once
     // calling convention issues are settled
     ret trans_ret(cx, some(e));
@@ -4399,13 +4371,11 @@ fn trans_mod(ccx: @crate_ctxt, m: ast::_mod) {
 
 fn get_pair_fn_ty(llpairty: TypeRef) -> TypeRef {
     // Bit of a kludge: pick the fn typeref out of the pair.
-
     ret struct_elt(llpairty, 0u);
 }
 
 fn register_fn(ccx: @crate_ctxt, sp: span, path: path, flav: str,
                ty_params: [ast::ty_param], node_id: ast::node_id) {
-    // FIXME: pull this out
     let t = ty::node_id_to_type(ccx.tcx, node_id);
     register_fn_full(ccx, sp, path, flav, ty_params, node_id, t);
 }
@@ -4461,7 +4431,6 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
         let vecarg_ty: ty::arg =
             {mode: ast::expl(ast::by_val),
              ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mutbl: ast::m_imm})};
-        // FIXME: mk_nil should have a postcondition
         let nt = ty::mk_nil(ccx.tcx);
         let llfty = type_of_fn(ccx, [vecarg_ty], nt, []);
         let llfdecl = decl_fn(ccx.llmod, "_rust_main",
@@ -4600,10 +4569,7 @@ fn collect_item(ccx: @crate_ctxt, abi: @mutable option<ast::native_abi>,
       ast::item_const(_, _) {
         let typ = ty::node_id_to_type(ccx.tcx, i.id);
         let s = mangle_exported_name(ccx, my_path, typ);
-        // FIXME: Could follow from a constraint on types of const
-        // items
         let g = str::as_buf(s, {|buf|
-            check (type_has_static_size(ccx, typ));
             llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, typ), buf)
         });
         ccx.item_symbols.insert(i.id, s);
@@ -4639,7 +4605,6 @@ fn collect_item(ccx: @crate_ctxt, abi: @mutable option<ast::native_abi>,
         // ty_res, which would have to carry around two def_ids otherwise
         // -- one to identify the type, and one to find the dtor symbol.
         let t = ty::node_id_to_type(ccx.tcx, dtor_id);
-        // FIXME: how to get rid of this check?
         register_fn_full(ccx, i.span, my_path + [path_name("dtor")],
                          "res_dtor", tps, i.id, t);
       }

src/comp/middle/trans/closure.rs

@@ -718,17 +718,7 @@ fn trans_bind_thunk(ccx: @crate_ctxt,
                     param_bounds: [ty::param_bounds],
                     target_info: target_info)
     -> {val: ValueRef, ty: TypeRef} {
-
-    // If we supported constraints on record fields, we could make the
-    // constraints for this function:
-    /*
-    : returns_non_ty_var(outgoing_fty),
-      type_has_static_size(ccx, incoming_fty) ->
-    */
-    // but since we don't, we have to do the checks at the beginning.
     let tcx = ccx.tcx;
-    check type_has_static_size(ccx, incoming_fty);
-
     #debug["trans_bind_thunk[incoming_fty=%s,outgoing_fty=%s,\
             cdata_ty=%s,param_bounds=%?]",
            ty_to_str(tcx, incoming_fty),

src/comp/middle/trans/common.rs

@@ -294,7 +294,7 @@ fn get_res_dtor(ccx: @crate_ctxt, did: ast::def_id, inner_t: ty::t)
     if did.crate == ast::local_crate {
         alt ccx.item_ids.find(did.node) {
           some(x) { ret x; }
-          _ { ccx.tcx.sess.bug("get_res_dtor: can't find resource dtor!"); }
+          _ { ccx.sess.bug("get_res_dtor: can't find resource dtor!"); }
         }
     }
 
@@ -364,8 +364,8 @@ type block = @{
 // First two args are retptr, env
 const first_tp_arg: uint = 2u;
 
-// FIXME: we should be able to use option<@block_parent> here but
-// the infinite-enum check in rustboot gets upset.
+// FIXME move blocks to a class once those are finished, and simply use
+// option<block> for this.
 enum block_parent { parent_none, parent_some(block), }
 
 type result = {bcx: block, val: ValueRef};

src/comp/middle/trans/debuginfo.rs

@@ -601,7 +601,7 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty)
           ty::ty_vec(mt) { ast::ty_vec({ty: t_to_ty(cx, mt.ty, span),
                                         mutbl: mt.mutbl}) }
           _ {
-            cx.tcx.sess.span_bug(span, "t_to_ty: Can't handle this type");
+            cx.sess.span_bug(span, "t_to_ty: Can't handle this type");
           }
         };
         ret @{node: ty, span: span};
@@ -611,7 +611,7 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty)
       ast::ty_box(mt) {
         let inner_t = alt ty::get(t).struct {
           ty::ty_box(boxed) { boxed.ty }
-          _ { cx.tcx.sess.span_bug(ty.span, "t_to_ty was incoherent"); }
+          _ { cx.sess.span_bug(ty.span, "t_to_ty was incoherent"); }
         };
         let md = create_ty(cx, inner_t, mt.ty);
         let box = create_boxed_type(cx, t, inner_t, ty.span, md);
@@ -622,7 +622,7 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty)
         let inner_t = alt ty::get(t).struct {
           ty::ty_uniq(boxed) { boxed.ty }
           // Hoping we'll have a way to eliminate this check soon.
-          _ { cx.tcx.sess.span_bug(ty.span, "t_to_ty was incoherent"); }
+          _ { cx.sess.span_bug(ty.span, "t_to_ty was incoherent"); }
         };
         let md = create_ty(cx, inner_t, mt.ty);
         ret create_pointer_type(cx, t, ty.span, md);

src/comp/middle/trans/impl.rs

@@ -53,7 +53,7 @@ fn trans_impl(ccx: @crate_ctxt, path: path, name: ast::ident,
                      tps + m.tps, none, m.id);
           }
           _ {
-            ccx.tcx.sess.bug("Unbound id in trans_impl");
+            ccx.sess.bug("Unbound id in trans_impl");
           }
         }
     }
@@ -337,7 +337,7 @@ fn trans_impl_vtable(ccx: @crate_ctxt, pt: path,
                                target)
           }
           _ {
-            ccx.tcx.sess.span_bug(it.span, "No matching method \
+            ccx.sess.span_bug(it.span, "No matching method \
                in trans_impl_vtable");
           }
         }

src/comp/middle/trans/native.rs

@@ -34,10 +34,7 @@ fn c_arg_and_ret_lltys(ccx: @crate_ctxt,
         let llretty = type_of(ccx, ret_ty);
         (llargtys, llretty, ret_ty)
       }
-      _ {
-          // Precondition?
-          ccx.tcx.sess.bug("c_arg_and_ret_lltys called on non-function type");
-      }
+      _ { ccx.sess.bug("c_arg_and_ret_lltys called on non-function type"); }
     }
 }