Require alts to be exhaustive

middle::check_alt does the work. Lots of changes to add default cases
into alts that were previously inexhaustive.

Author: catamorphism

src/cargo/cargo.rs

@@ -93,6 +93,7 @@ fn load_link(mis: [@ast::meta_item]) -> (option::t<str>,
                     _ { }
                 }
             }
+            _ { fail "load_link: meta items must be name-values"; }
         }
     }
     (name, vers, uuid)
@@ -135,6 +136,7 @@ fn load_pkg(filename: str) -> option::t<pkg> {
                     uuid = u;
                 }
             }
+            _ { fail "load_pkg: pkg attributes may not contain meta_words"; }
         }
     }
 

src/comp/back/rpath.rs

@@ -11,6 +11,13 @@ import util::filesearch;
 
 export get_rpath_flags;
 
+pure fn not_win32(os: session::os) -> bool {
+  alt os {
+      session::os_win32 { false }
+      _ { true }
+  }
+}
+
 fn get_rpath_flags(sess: session::session, out_filename: str) -> [str] {
     let os = sess.targ_cfg.os;
 
@@ -99,12 +106,13 @@ fn get_rpaths_relative_to_output(os: session::os,
 fn get_rpath_relative_to_output(os: session::os,
                                 cwd: fs::path,
                                 output: fs::path,
-                                &&lib: fs::path) -> str {
+                                &&lib: fs::path) : not_win32(os) -> str {
     // Mac doesn't appear to support $ORIGIN
     let prefix = alt os {
         session::os_linux { "$ORIGIN" + fs::path_sep() }
         session::os_freebsd { "$ORIGIN" + fs::path_sep() }
         session::os_macos { "@executable_path" + fs::path_sep() }
+        session::os_win32 { std::util::unreachable(); }
     };
 
     prefix + get_relative_to(
@@ -309,24 +317,31 @@ mod test {
     #[test]
     #[cfg(target_os = "linux")]
     fn test_rpath_relative() {
-        let res = get_rpath_relative_to_output(session::os_linux,
+      let o = session::os_linux;
+      check not_win32(o);
+      let res = get_rpath_relative_to_output(o,
             "/usr", "bin/rustc", "lib/libstd.so");
-        assert res == "$ORIGIN/../lib";
+      assert res == "$ORIGIN/../lib";
     }
 
     #[test]
     #[cfg(target_os = "freebsd")]
     fn test_rpath_relative() {
-        let res = get_rpath_relative_to_output(session::os_freebsd,
+      let o = session::os_freebsd;
+      check not_win32(o);
+      let res = get_rpath_relative_to_output(o,
             "/usr", "bin/rustc", "lib/libstd.so");
-        assert res == "$ORIGIN/../lib";
+      assert res == "$ORIGIN/../lib";
     }
 
     #[test]
     #[cfg(target_os = "macos")]
     fn test_rpath_relative() {
-        let res = get_rpath_relative_to_output(session::os_macos,
-            "/usr", "bin/rustc", "lib/libstd.so");
+      // this is why refinements would be nice
+      let o = session::os_macos;
+      check not_win32(o);
+      let res = get_rpath_relative_to_output(o, "/usr", "bin/rustc",
+                                             "lib/libstd.so");
         assert res == "@executable_path/../lib";
     }
 

src/comp/driver/driver.rs

@@ -608,6 +608,8 @@ mod test {
         let match =
             alt getopts::getopts(["--test"], opts()) {
               ok(m) { m }
+              err(f) { fail "test_switch_implies_cfg_test: " +
+                       getopts::fail_str(f); }
             };
         let sessopts = build_session_options(match, diagnostic::emit);
         let sess = build_session(sessopts, "", diagnostic::emit);
@@ -622,6 +624,8 @@ mod test {
         let match =
             alt getopts::getopts(["--test", "--cfg=test"], opts()) {
               ok(m) { m }
+              err(f) { fail "test_switch_implies_cfg_test_unless_cfg_test: " +
+                       getopts::fail_str(f); }
             };
         let sessopts = build_session_options(match, diagnostic::emit);
         let sess = build_session(sessopts, "", diagnostic::emit);

src/comp/driver/session.rs

@@ -58,7 +58,7 @@ type session = @{targ_cfg: @config,
                  parse_sess: parse_sess,
                  codemap: codemap::codemap,
                  // For a library crate, this is always none
-                 mutable main_fn: option::t<node_id>,
+                 mutable main_fn: option::t<(node_id, codemap::span)>,
                  span_diagnostic: diagnostic::span_handler,
                  filesearch: filesearch::filesearch,
                  mutable building_library: bool,

src/comp/metadata/decoder.rs

@@ -3,6 +3,7 @@
 import std::{ebml, map, io};
 import io::writer_util;
 import syntax::{ast, ast_util};
+import driver::session::session;
 import front::attr;
 import middle::ty;
 import common::*;
@@ -302,7 +303,9 @@ fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
         let bounds = item_ty_param_bounds(mth, tcx, cdata);
         let name = item_name(mth);
         let ty = doc_type(mth, tcx, cdata);
-        let fty = alt ty::struct(tcx, ty) { ty::ty_fn(f) { f } };
+        let fty = alt ty::struct(tcx, ty) { ty::ty_fn(f) { f }
+          _ { tcx.sess.bug("get_iface_methods: id has non-function type");
+        } };
         result += [{ident: name, tps: bounds, fty: fty}];
     }
     @result

src/comp/metadata/encoder.rs

@@ -10,6 +10,7 @@ import middle::trans::common::crate_ctxt;
 import middle::ty;
 import middle::ty::node_id_to_type;
 import front::attr;
+import driver::session::session;
 
 export encode_metadata;
 export encoded_ty;
@@ -275,6 +276,8 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
             }
         }
       }
+      _ { ecx.ccx.tcx.sess.bug("encode_info_for_mod: \
+             undocumented invariant"); }
     }
     ebml::end_tag(ebml_w);
 }

src/comp/metadata/tyencode.rs

@@ -5,6 +5,7 @@ import io::writer_util;
 import std::map::hashmap;
 import option::{some, none};
 import syntax::ast::*;
+import driver::session::session;
 import middle::ty;
 import syntax::print::pprust::*;
 
@@ -213,6 +214,10 @@ fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) {
           by_copy { w.write_char('+'); }
           by_ref { w.write_char('='); }
           by_val { w.write_char('#'); }
+          // tediously, this has to be there until there's a way
+          // to constraint post-typeck types not to contain a mode_infer
+          mode_infer { cx.tcx.sess.bug("enc_ty_fn: shouldn't see \
+            mode_infer"); }
         }
         enc_ty(w, cx, arg.ty);
     }

src/comp/middle/alias.rs

@@ -6,10 +6,12 @@ import syntax::visit;
 import visit::vt;
 import core::{vec, option};
 import std::list;
+import std::util::unreachable;
 import option::{some, none, is_none};
 import list::list;
 import driver::session::session;
 import pat_util::*;
+import util::ppaux::ty_to_str;
 
 // This is not an alias-analyser (though it would merit from becoming one, or
 // getting input from one, to be more precise). It is a pass that checks
@@ -575,6 +577,11 @@ fn copy_is_expensive(tcx: ty::ctxt, ty: ty::t) -> bool {
             for f in fs { sum += score_ty(tcx, f.mt.ty); }
             sum
           }
+          _ {
+            tcx.sess.warn(#fmt("score_ty: unexpected type %s",
+               ty_to_str(tcx, ty)));
+            1u // ???
+          }
         };
     }
     ret score_ty(tcx, ty) > 8u;
@@ -611,6 +618,7 @@ fn pattern_roots(tcx: ty::ctxt, mut: option::t<unsafe_ty>, pat: @ast::pat)
             let ty = ty::node_id_to_type(tcx, pat.id);
             let m = alt ty::struct(tcx, ty) {
               ty::ty_box(mt) { mt.mut != ast::imm }
+              _ { tcx.sess.span_bug(pat.span, "box pat has non-box type"); }
             },
                 c = if m  {some(contains(ty)) } else { mut };
             walk(tcx, c, p, set);
@@ -619,6 +627,7 @@ fn pattern_roots(tcx: ty::ctxt, mut: option::t<unsafe_ty>, pat: @ast::pat)
             let ty = ty::node_id_to_type(tcx, pat.id);
             let m = alt ty::struct(tcx, ty) {
               ty::ty_uniq(mt) { mt.mut != ast::imm }
+              _ { tcx.sess.span_bug(pat.span, "uniq pat has non-uniq type"); }
             },
                 c = if m { some(contains(ty)) } else { mut };
             walk(tcx, c, p, set);
@@ -672,6 +681,10 @@ fn append_invalid(dest: list<@invalid>, src: list<@invalid>,
             }
             cur = *tail;
           }
+          list::nil {
+              fail "append_invalid: stop doesn't appear to be \
+                 a postfix of src";
+          }
         }
     }
     ret dest;
@@ -686,6 +699,10 @@ fn filter_invalid(src: list<@invalid>, bs: [binding]) -> list<@invalid> {
             if !is_none(p) { out = list::cons(head, @out); }
             cur = *tail;
           }
+          list::nil {
+            // typestate would help...
+            unreachable();
+          }
         }
     }
     ret out;

src/comp/middle/ast_map.rs

@@ -44,15 +44,15 @@ fn map_fn(cx: ctx, _fk: visit::fn_kind, decl: fn_decl, _body: blk,
 }
 
 fn map_local(cx: ctx, loc: @local) {
-    pat_util::pat_bindings(loc.node.pat) {|p|
-        cx.map.insert(p.id, node_local(cx.local_id));
+    pat_util::pat_bindings(loc.node.pat) {|p_id, _s, _p|
+        cx.map.insert(p_id, node_local(cx.local_id));
         cx.local_id += 1u;
     };
 }
 
 fn map_arm(cx: ctx, arm: arm) {
-    pat_util::pat_bindings(arm.pats[0]) {|p|
-        cx.map.insert(p.id, node_local(cx.local_id));
+    pat_util::pat_bindings(arm.pats[0]) {|p_id, _s, _p|
+        cx.map.insert(p_id, node_local(cx.local_id));
         cx.local_id += 1u;
     };
 }
@@ -79,50 +79,6 @@ fn map_expr(cx: ctx, ex: @expr) {
     cx.map.insert(ex.id, node_expr(ex));
 }
 
-fn node_span(node: ast_node) -> codemap::span {
-    alt node {
-      node_item(item) { item.span }
-      node_native_item(nitem) { nitem.span }
-      node_expr(expr) { expr.span }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    import syntax::ast_util;
-
-    #[test]
-    fn test_node_span_item() {
-        let expected: codemap::span = ast_util::mk_sp(20u, 30u);
-        let node =
-            node_item(@{ident: "test",
-                        attrs: [],
-                        id: 0,
-                        node: item_mod({view_items: [], items: []}),
-                        span: expected});
-        assert (node_span(node) == expected);
-    }
-
-    #[test]
-    fn test_node_span_native_item() {
-        let expected: codemap::span = ast_util::mk_sp(20u, 30u);
-        let node =
-            node_native_item(@{ident: "test",
-                               attrs: [],
-                               node: native_item_ty,
-                               id: 0,
-                               span: expected});
-        assert (node_span(node) == expected);
-    }
-
-    #[test]
-    fn test_node_span_expr() {
-        let expected: codemap::span = ast_util::mk_sp(20u, 30u);
-        let node = node_expr(@{id: 0, node: expr_break, span: expected});
-        assert (node_span(node) == expected);
-    }
-}
-
 // Local Variables:
 // mode: rust
 // fill-column: 78;