Remove preconditions from libraries

Closes #1805

9 files changed, 3 insertions, 28 deletions

diff --git a/src/comp/back/rpath.rs b/src/comp/back/rpath.rs
index 7ed80f0d6d7..a66f5d87024 100644
--- a/src/comp/back/rpath.rs
+++ b/src/comp/back/rpath.rs
@@ -40,7 +40,6 @@ fn get_sysroot_absolute_rt_lib(sess: session::session) -> fs::path {
         + filesearch::relative_target_lib_path(
             sess.opts.target_triple)
         + [os::dylib_filename("rustrt")];
-    check vec::is_not_empty(path);
     fs::connect_many(path)
 }
 
@@ -174,7 +173,6 @@ fn get_install_prefix_rpath(cwd: fs::path, target_triple: str) -> str {
 
     let path = [install_prefix]
         + filesearch::relative_target_lib_path(target_triple);
-    check vec::is_not_empty(path);
     get_absolute(cwd, fs::connect_many(path))
 }
 
diff --git a/src/comp/middle/last_use.rs b/src/comp/middle/last_use.rs
index 69166d3ba7f..dca76bddf66 100644
--- a/src/comp/middle/last_use.rs
+++ b/src/comp/middle/last_use.rs
@@ -209,7 +209,6 @@ fn visit_block(tp: block_type, cx: ctx, visit: fn()) {
     cx.current = start_current;
     visit();
     let cx_blocks = cx.blocks;
-    check is_not_empty(cx_blocks);
     cx.blocks = tail(cx_blocks);
     let branches = if tp == func { local.exits + [cx.current] }
                    else { local.exits };
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index befab011b7f..76aea3a1e3b 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -289,7 +289,6 @@ fn map_crate(e: @env, c: @ast::crate) {
                 alt follow_import(*e, sc, *path, vp.span) {
                   some(imp) {
                     let glob = {def: imp, path: vp};
-                    check list::is_not_empty(sc);
                     alt list::head(sc) {
                       scope_item(i) {
                         e.mod_map.get(i.id).glob_imports += [glob];
@@ -585,7 +584,6 @@ fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {
 }
 
 fn visit_decl_with_scope(d: @decl, sc: scopes, v: vt<scopes>) {
-    check list::is_not_empty(sc);
     let loc_pos = alt list::head(sc) {
       scope_block(_, _, pos) { pos }
       _ { @mutable 0u }
diff --git a/src/comp/middle/trans/alt.rs b/src/comp/middle/trans/alt.rs
index 2057296d197..c15acf64af0 100644
--- a/src/comp/middle/trans/alt.rs
+++ b/src/comp/middle/trans/alt.rs
@@ -278,7 +278,6 @@ fn extract_variant_args(bcx: block, pat_id: ast::node_id,
     let vdefs_tg = vdefs.enm;
     let vdefs_var = vdefs.var;
     while i < size {
-        check (valid_variant_index(i, bcx, vdefs_tg, vdefs_var));
         let r =
             // invariant needed:
             // how do we know it even makes sense to pass in ty_param_substs
diff --git a/src/comp/middle/trans/base.rs b/src/comp/middle/trans/base.rs
index eb25415357a..d0370d992a8 100644
--- a/src/comp/middle/trans/base.rs
+++ b/src/comp/middle/trans/base.rs
@@ -355,9 +355,10 @@ fn GEP_tup_like(bcx: block, t: ty::t, base: ValueRef, ixs: [int])
 // is meaningless, as it will be cast away.
 fn GEP_enum(cx: block, llblobptr: ValueRef, enum_id: ast::def_id,
            variant_id: ast::def_id, ty_substs: [ty::t],
-           ix: uint) : valid_variant_index(ix, cx, enum_id, variant_id) ->
-   result {
+           ix: uint) -> result {
     let variant = ty::enum_variant_with_id(cx.tcx(), enum_id, variant_id);
+    assert ix < variant.args.len();
+
     // Synthesize a tuple type so that GEP_tup_like() can work its magic.
     // Separately, store the type of the element we're interested in.
 
@@ -1119,7 +1120,6 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
             let j = 0u;
             let v_id = variant.id;
             for a: ty::arg in args {
-                check (valid_variant_index(j, cx, tid, v_id));
                 let rslt = GEP_enum(cx, a_tup, tid, v_id, tps, j);
                 let llfldp_a = rslt.val;
                 cx = rslt.bcx;
@@ -4031,7 +4031,6 @@ fn trans_enum_variant(ccx: crate_ctxt, enum_id: ast::node_id,
     let t_id = local_def(enum_id);
     let v_id = local_def(variant.node.id);
     for va: ast::variant_arg in variant.node.args {
-        check (valid_variant_index(i, bcx, t_id, v_id));
         let rslt = GEP_enum(bcx, llblobptr, t_id, v_id, ty_param_substs, i);
         bcx = rslt.bcx;
         let lldestptr = rslt.val;
diff --git a/src/comp/middle/trans/build.rs b/src/comp/middle/trans/build.rs
index 91dcb347135..0559a6b02af 100644
--- a/src/comp/middle/trans/build.rs
+++ b/src/comp/middle/trans/build.rs
@@ -529,7 +529,6 @@ fn add_span_comment(bcx: block, sp: span, text: str) {
 fn add_comment(bcx: block, text: str) {
     let ccx = bcx.ccx();
     if (!ccx.sess.opts.no_asm_comments) {
-        check str::is_not_empty("$");
         let sanitized = str::replace(text, "$", "");
         let comment_text = "; " + sanitized;
         let asm = str::as_buf(comment_text, {|c|
diff --git a/src/comp/middle/trans/common.rs b/src/comp/middle/trans/common.rs
index a5d83906749..24af4e33b9a 100644
--- a/src/comp/middle/trans/common.rs
+++ b/src/comp/middle/trans/common.rs
@@ -835,20 +835,6 @@ fn C_shape(ccx: crate_ctxt, bytes: [u8]) -> ValueRef {
     ret llvm::LLVMConstPointerCast(llglobal, T_ptr(T_i8()));
 }
 
-
-pure fn valid_variant_index(ix: uint, cx: block, enum_id: ast::def_id,
-                            variant_id: ast::def_id) -> bool {
-
-    // Handwaving: it's ok to pretend this code is referentially
-    // transparent, because the relevant parts of the type context don't
-    // change. (We're not adding new variants during trans.)
-    unchecked{
-        let variant =
-            ty::enum_variant_with_id(cx.tcx(), enum_id, variant_id);
-        ix < variant.args.len()
-    }
-}
-
 pure fn type_has_static_size(cx: crate_ctxt, t: ty::t) -> bool {
     !ty::type_has_dynamic_size(cx.tcx, t)
 }
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index a6f56b611d7..7cdb5667665 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -888,7 +888,6 @@ fn parse_bottom_expr(p: parser) -> pexpr {
         /* Should be a predicate (pure boolean function) applied to
            arguments that are all either slot variables or literals.
            but the typechecker enforces that. */
-
         let e = parse_expr(p);
         hi = e.span.hi;
         ex = ast::expr_check(ast::checked_expr, e);
diff --git a/src/comp/util/filesearch.rs b/src/comp/util/filesearch.rs
index d5919ea3e5a..3e23e09f8ea 100644
--- a/src/comp/util/filesearch.rs
+++ b/src/comp/util/filesearch.rs
@@ -89,7 +89,6 @@ fn relative_target_lib_path(target_triple: str) -> [fs::path] {
 fn make_target_lib_path(sysroot: fs::path,
                         target_triple: str) -> fs::path {
     let path = [sysroot] + relative_target_lib_path(target_triple);
-    check vec::is_not_empty(path);
     let path = fs::connect_many(path);
     ret path;
 }
@@ -112,7 +111,6 @@ fn get_sysroot(maybe_sysroot: option<fs::path>) -> fs::path {
 
 fn get_cargo_sysroot() -> result::t<fs::path, str> {
     let path = [get_default_sysroot(), libdir(), "cargo"];
-    check vec::is_not_empty(path);
     result::ok(fs::connect_many(path))
 }