diff --git a/mk/tests.mk b/mk/tests.mk
index 04be295c2713..6c586957862b 100644
--- a/mk/tests.mk
+++ b/mk/tests.mk
@@ -199,14 +199,29 @@ check-docs: cleantestlibs cleantmptestlogs check-stage2-docs
 
 # Some less critical tests that are not prone to breakage.
 # Not run as part of the normal test suite, but tested by bors on checkin.
-check-secondary: check-lexer check-pretty
+check-secondary: check-build-compiletest check-lexer check-pretty
 
 # check + check-secondary.
-check-all: check check-secondary
+#
+# Issue #17883: build check-secondary first so hidden dependencies in
+# e.g. building compiletest are exercised (resolve those by adding
+# deps to rules that need them; not by putting `check` first here).
+check-all: check-secondary check
 
 # Pretty-printing tests.
 check-pretty: check-stage2-T-$(CFG_BUILD)-H-$(CFG_BUILD)-pretty-exec
 
+define DEF_CHECK_BUILD_COMPILETEST_FOR_STAGE
+check-stage$(1)-build-compiletest: 	$$(HBIN$(1)_H_$(CFG_BUILD))/compiletest$$(X_$(CFG_BUILD))
+endef
+
+$(foreach stage,$(STAGES), \
+ $(eval $(call DEF_CHECK_BUILD_COMPILETEST_FOR_STAGE,$(stage))))
+
+check-build-compiletest: \
+	check-stage1-build-compiletest \
+	check-stage2-build-compiletest
+
 .PHONY: cleantmptestlogs cleantestlibs
 
 cleantmptestlogs:
@@ -284,7 +299,7 @@ tidy:
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
 		$(Q)echo $(ALL_HS) \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
-		$(Q)find $(S)src -type f -perm a+x \
+		$(Q)find $(S)src -type f -perm +a+x \
 		    -not -name '*.rs' -and -not -name '*.py' \
 		    -and -not -name '*.sh' \
 		| grep '^$(S)src/jemalloc' -v \
@@ -720,6 +735,13 @@ PRETTY_DEPS_pretty-rpass-full = $(RPASS_FULL_TESTS)
 PRETTY_DEPS_pretty-rfail = $(RFAIL_TESTS)
 PRETTY_DEPS_pretty-bench = $(BENCH_TESTS)
 PRETTY_DEPS_pretty-pretty = $(PRETTY_TESTS)
+# The stage- and host-specific dependencies are for e.g. macro_crate_test which pulls in
+# external crates.
+PRETTY_DEPS$(1)_H_$(3)_pretty-rpass =
+PRETTY_DEPS$(1)_H_$(3)_pretty-rpass-full = $$(HLIB$(1)_H_$(3))/stamp.syntax $$(HLIB$(1)_H_$(3))/stamp.rustc
+PRETTY_DEPS$(1)_H_$(3)_pretty-rfail =
+PRETTY_DEPS$(1)_H_$(3)_pretty-bench =
+PRETTY_DEPS$(1)_H_$(3)_pretty-pretty =
 PRETTY_DIRNAME_pretty-rpass = run-pass
 PRETTY_DIRNAME_pretty-rpass-full = run-pass-fulldeps
 PRETTY_DIRNAME_pretty-rfail = run-fail
@@ -738,7 +760,8 @@ check-stage$(1)-T-$(2)-H-$(3)-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4
 
 $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
 	        $$(TEST_SREQ$(1)_T_$(2)_H_$(3)) \
-	        $$(PRETTY_DEPS_$(4))
+	        $$(PRETTY_DEPS_$(4)) \
+	        $$(PRETTY_DEPS$(1)_H_$(3)_$(4))
 	@$$(call E, run pretty-rpass [$(2)]: $$<)
 	$$(Q)$$(call CFG_RUN_CTEST_$(2),$(1),$$<,$(3)) \
 		$$(PRETTY_ARGS$(1)-T-$(2)-H-$(3)-$(4)) \
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index ab8d924a4426..ff6b1b153332 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -947,15 +947,12 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         String::from_chars(c.as_slice())
     }
 
-    #[cfg(target_os = "windows")]
+    #[cfg(windows)]
     fn prefix_matches( line : &str, prefix : &str ) -> bool {
         to_lower(line).as_slice().starts_with(to_lower(prefix).as_slice())
     }
 
-    #[cfg(any(target_os = "linux",
-              target_os = "macos",
-              target_os = "freebsd",
-              target_os = "dragonfly"))]
+    #[cfg(unix)]
     fn prefix_matches( line : &str, prefix : &str ) -> bool {
         line.starts_with( prefix )
     }
@@ -1356,24 +1353,21 @@ fn program_output(config: &Config, testfile: &Path, lib_path: &str, prog: String
 }
 
 // Linux and mac don't require adjusting the library search path
-#[cfg(any(target_os = "linux",
-          target_os = "macos",
-          target_os = "freebsd",
-          target_os = "dragonfly"))]
+#[cfg(unix)]
 fn make_cmdline(_libpath: &str, prog: &str, args: &[String]) -> String {
     format!("{} {}", prog, args.connect(" "))
 }
 
-#[cfg(target_os = "windows")]
+#[cfg(windows)]
 fn make_cmdline(libpath: &str, prog: &str, args: &[String]) -> String {
-    format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
-}
 
-// Build the LD_LIBRARY_PATH variable as it would be seen on the command line
-// for diagnostic purposes
-#[cfg(target_os = "windows")]
-fn lib_path_cmd_prefix(path: &str) -> String {
-    format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
+    // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
+    // for diagnostic purposes
+    fn lib_path_cmd_prefix(path: &str) -> String {
+        format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
+    }
+
+    format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
 }
 
 fn dump_output(config: &Config, testfile: &Path, out: &str, err: &str) {
diff --git a/src/doc/README.md b/src/doc/README.md
index cf1557e66049..50222973509a 100644
--- a/src/doc/README.md
+++ b/src/doc/README.md
@@ -1,4 +1,6 @@
-# Dependencies
+# Rust documentations
+
+## Dependencies
 
 [Pandoc](http://johnmacfarlane.net/pandoc/installing.html), a universal
 document converter, is required to generate docs as HTML from Rust's
@@ -10,7 +12,7 @@ docs from the master (English) docs.
 [GNU gettext](http://www.gnu.org/software/gettext/) is required for managing
 the translation data.
 
-# Building
+## Building
 
 To generate all the docs, just run `make docs` from the root of the repository.
 This will convert the distributed Markdown docs to HTML and generate HTML doc
@@ -24,7 +26,7 @@ rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
 
 (This, of course, requires a working build of the `rustdoc` tool.)
 
-# Additional notes
+## Additional notes
 
 To generate an HTML version of a doc from Markdown manually, you can do
 something like:
@@ -33,37 +35,39 @@ something like:
 pandoc --from=markdown --to=html5 --number-sections -o reference.html reference.md
 ~~~~
 
-(reference.md being the Rust Reference Manual.)
+(`reference.md` being the Rust Reference Manual.)
 
 The syntax for pandoc flavored markdown can be found at:
-http://johnmacfarlane.net/pandoc/README.html#pandocs-markdown
+
+- http://johnmacfarlane.net/pandoc/README.html#pandocs-markdown
 
 A nice quick reference (for non-pandoc markdown) is at:
-http://kramdown.rubyforge.org/quickref.html
 
-# Notes for translators
+- http://kramdown.gettalong.org/quickref.html
+
+## Notes for translators
 
 Notice: The procedure described below is a work in progress. We are working on
 translation system but the procedure contains some manual operations for now.
 
-To start the translation for a new language, see po4a.conf at first.
+To start the translation for a new language, see `po4a.conf` at first.
 
-To generate .pot and .po files, do something like:
+To generate `.pot` and `.po` files, do something like:
 
 ~~~~
 po4a --copyright-holder="The Rust Project Developers" \
     --package-name="Rust" \
-    --package-version="0.11.0" \
+    --package-version="0.13.0" \
     -M UTF-8 -L UTF-8 \
     src/doc/po4a.conf
 ~~~~
 
-(the version number must be changed if it is not 0.11.0 now.)
+(the version number must be changed if it is not `0.13.0` now.)
 
-Now you can translate documents with .po files, commonly used with gettext. If
+Now you can translate documents with `.po` files, commonly used with gettext. If
 you are not familiar with gettext-based translation, please read the online
 manual linked from http://www.gnu.org/software/gettext/ . We use UTF-8 as the
-file encoding of .po files.
+file encoding of `.po` files.
 
 When you want to make a commit, do the command below before staging your
 change:
@@ -79,4 +83,4 @@ for f in src/doc/po/**/*.po; do
 done
 ~~~~
 
-This removes untranslated entries from .po files to save disk space.
+This removes untranslated entries from `.po` files to save disk space.
diff --git a/src/doc/guide-ffi.md b/src/doc/guide-ffi.md
index abd2cd7b33e4..0b0a6b7b6971 100644
--- a/src/doc/guide-ffi.md
+++ b/src/doc/guide-ffi.md
@@ -298,7 +298,7 @@ fn main() {
 C code:
 
 ~~~~c
-typedef void (*rust_callback)(int32_t);
+typedef void (*rust_callback)(void*, int32_t);
 void* cb_target;
 rust_callback cb;
 
diff --git a/src/doc/guide-strings.md b/src/doc/guide-strings.md
index a49132ec8be9..afca75a76d44 100644
--- a/src/doc/guide-strings.md
+++ b/src/doc/guide-strings.md
@@ -206,5 +206,5 @@ Many more bytes than graphemes!
 
 # Other Documentation
 
-* [the `&str` API documentation](/std/str/index.html)
+* [the `&str` API documentation](std/str/index.html)
 * [the `String` API documentation](std/string/index.html)
diff --git a/src/doc/guide.md b/src/doc/guide.md
index 4e9966cb3db2..5357a0fcafa1 100644
--- a/src/doc/guide.md
+++ b/src/doc/guide.md
@@ -1746,8 +1746,7 @@ For our first project, we'll implement a classic beginner programming problem:
 the guessing game. Here's how it works: Our program will generate a random
 integer between one and a hundred. It will then prompt us to enter a guess.
 Upon entering our guess, it will tell us if we're too low or too high. Once we
-guess correctly, it will congratulate us, and print the number of guesses we've
-taken to the screen. Sound good?
+guess correctly, it will congratulate us. Sound good?
 
 ## Set up
 
@@ -3538,9 +3537,8 @@ restriction:
 
 1. If the borrow is immutable, you may read the data the pointer points to.
 2. If the borrow is mutable, you may read and write the data the pointer points to.
-3. You may lend the pointer to someone else in an immutable fashion, **BUT**
-4. When you do so, they must return it to you before you must give your own
-   borrow back.
+3. You may lend the pointer to someone else, **BUT**
+4. When you do so, they must return it before you can give your own borrow back.
 
 This last requirement can seem odd, but it also makes sense. If you have to
 return something, and you've lent it to someone, they need to give it back to
@@ -5062,8 +5060,8 @@ println!("The value of x[0] is: {}", x[0]); // error: use of moved value: `x`
 ```
 
 `x` is now owned by the proc, and so we can't use it anymore. Many other
-languages would let us do this, but it's not safe to do so. Rust's type system
-catches the error.
+languages would let us do this, but it's not safe to do so. Rust's borrow
+checker catches the error.
 
 If tasks were only able to capture these values, they wouldn't be very useful.
 Luckily, tasks can communicate with each other through **channel**s. Channels
diff --git a/src/doc/reference.md b/src/doc/reference.md
index 131637948c8d..3c4b973002e9 100644
--- a/src/doc/reference.md
+++ b/src/doc/reference.md
@@ -185,40 +185,24 @@ grammar as double-quoted strings. Other tokens have exact rules given.
 
 ### Keywords
 
-The keywords are the following strings, organized by first letter:
+<p id="keyword-table-marker">The keywords are the following strings, organized by first letter:</p>
 
-<div id="keywords">
 |          |        |        |       |
 |----------|--------|--------|-------|
 | as       |        |        |       |
-|----------|--------|--------|-------|
 | box      | break  |        |       |
-|----------|--------|--------|-------|
 | continue | crate  |        |       |
-|----------|--------|--------|-------|
 | else     | enum   | extern |       |
-|----------|--------|--------|-------|
 | false    | fn     | for    |       |
-|----------|--------|--------|-------|
 | if       | impl   | in     |       |
-|----------|--------|--------|-------|
 | let      | loop   |        |       |
-|----------|--------|--------|-------|
 | match    | mod    | mut    |       |
-|----------|--------|--------|-------|
 | priv     | proc   | pub    |       |
-|----------|--------|--------|-------|
 | ref      | return |        |       |
-|----------|--------|--------|-------|
 | self     | static | struct | super |
-|----------|--------|--------|-------|
 | trait    | true   | type   |       |
-|----------|--------|--------|-------|
 | unsafe   | use    |        |       |
-|----------|--------|--------|-------|
 | while    |        |        |       |
-|----------|--------|--------|-------|
-</div>
 
 Each of these keywords has special meaning in its grammar, and all of them are
 excluded from the `ident` rule.
diff --git a/src/doc/rust.css b/src/doc/rust.css
index b615c392bd5e..4bbb80984021 100644
--- a/src/doc/rust.css
+++ b/src/doc/rust.css
@@ -393,4 +393,9 @@ pre.rust { position: relative; }
     }
 }
 
-#keywords table td { border: none; }
+#keyword-table-marker + table thead { display: none; }
+#keyword-table-marker + table td { border: none; }
+#keyword-table-marker + table {
+    margin-left: 2em;
+    margin-bottom: 1em;
+}
diff --git a/src/etc/unicode.py b/src/etc/unicode.py
index 0b128686690f..d3de1d2b64e0 100755
--- a/src/etc/unicode.py
+++ b/src/etc/unicode.py
@@ -604,6 +604,15 @@ if __name__ == "__main__":
         rf.write(preamble)
 
         # download and parse all the data
+        fetch("ReadMe.txt")
+        with open("ReadMe.txt") as readme:
+            pattern = "for Version (\d+)\.(\d+)\.(\d+) of the Unicode"
+            unicode_version = re.search(pattern, readme.read()).groups()
+        rf.write("""
+/// The version of [Unicode](http://www.unicode.org/)
+/// that the `UnicodeChar` and `UnicodeStrSlice` traits are based on.
+pub const UNICODE_VERSION: (uint, uint, uint) = (%s, %s, %s);
+""" % unicode_version)
         (canon_decomp, compat_decomp, gencats, combines,
                 lowerupper, upperlower) = load_unicode_data("UnicodeData.txt")
         want_derived = ["XID_Start", "XID_Continue", "Alphabetic", "Lowercase", "Uppercase"]
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 39524ed547d5..a2483f23534e 100644
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -276,7 +276,6 @@ impl<T: Sync + Send> Drop for Weak<T> {
 #[allow(experimental)]
 mod tests {
     use std::clone::Clone;
-    use std::collections::MutableSeq;
     use std::comm::channel;
     use std::mem::drop;
     use std::ops::Drop;
diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs
index fa9ed335f1f5..9ead4cbcfd0d 100644
--- a/src/libcollections/bitv.rs
+++ b/src/libcollections/bitv.rs
@@ -2659,7 +2659,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
-            for i in range(0u, 100) {
+            for _ in range(0u, 100) {
                 bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen());
             }
             &bitv
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index 87e07b7b1b66..088784070e71 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -890,13 +890,13 @@ mod tests {
         }
 
         let v = vec![1i,2,3,4,5];
-        let u = vec![9i,8,1,2,3,4,5];
+        let mut u = vec![9i,8,1,2,3,4,5];
         let mut m = list_from(v.as_slice());
         m.prepend(list_from(u.as_slice()));
         check_links(&m);
-        let sum = u.append(v.as_slice());
-        assert_eq!(sum.len(), m.len());
-        for elt in sum.into_iter() {
+        u.extend(v.as_slice().iter().map(|&b| b));
+        assert_eq!(u.len(), m.len());
+        for elt in u.into_iter() {
             assert_eq!(m.pop_front(), Some(elt))
         }
     }
diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
index c9c824ac9ceb..4d8e67f6ac8f 100644
--- a/src/libcollections/ringbuf.rs
+++ b/src/libcollections/ringbuf.rs
@@ -611,10 +611,10 @@ mod tests {
         assert_eq!(deq.len(), 3);
         deq.push_front(a.clone());
         assert_eq!(deq.len(), 4);
-        assert_eq!((*deq.get(0)).clone(), a.clone());
-        assert_eq!((*deq.get(1)).clone(), b.clone());
-        assert_eq!((*deq.get(2)).clone(), c.clone());
-        assert_eq!((*deq.get(3)).clone(), d.clone());
+        assert_eq!(deq[0].clone(), a.clone());
+        assert_eq!(deq[1].clone(), b.clone());
+        assert_eq!(deq[2].clone(), c.clone());
+        assert_eq!(deq[3].clone(), d.clone());
     }
 
     #[test]
@@ -626,7 +626,7 @@ mod tests {
         assert_eq!(deq.len(), 66);
 
         for i in range(0u, 66) {
-            assert_eq!(*deq.get(i), 65 - i);
+            assert_eq!(deq[i], 65 - i);
         }
 
         let mut deq = RingBuf::new();
@@ -635,7 +635,7 @@ mod tests {
         }
 
         for i in range(0u, 66) {
-            assert_eq!(*deq.get(i), i);
+            assert_eq!(deq[i], i);
         }
     }
 
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index f3d3506de837..f49371b8e886 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -883,6 +883,7 @@ mod tests {
     use std::slice::{AsSlice, ImmutableSlice};
     use string::String;
     use vec::Vec;
+    use slice::CloneableVector;
 
     use unicode::char::UnicodeChar;
 
@@ -1504,7 +1505,7 @@ mod tests {
     fn vec_str_conversions() {
         let s1: String = String::from_str("All mimsy were the borogoves");
 
-        let v: Vec<u8> = Vec::from_slice(s1.as_bytes());
+        let v: Vec<u8> = s1.as_bytes().to_vec();
         let s2: String = String::from_str(from_utf8(v.as_slice()).unwrap());
         let mut i: uint = 0u;
         let n1: uint = s1.len();
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index 848068f20c2d..061064ff803d 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -1036,6 +1036,7 @@ mod tests {
     use str::{Str, StrSlice, Owned};
     use super::{as_string, String};
     use vec::Vec;
+    use slice::CloneableVector;
 
     #[test]
     fn test_as_string() {
@@ -1051,15 +1052,15 @@ mod tests {
 
     #[test]
     fn test_from_utf8() {
-        let xs = Vec::from_slice(b"hello");
+        let xs = b"hello".to_vec();
         assert_eq!(String::from_utf8(xs), Ok(String::from_str("hello")));
 
-        let xs = Vec::from_slice("ศไทย中华Việt Nam".as_bytes());
+        let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
         assert_eq!(String::from_utf8(xs), Ok(String::from_str("ศไทย中华Việt Nam")));
 
-        let xs = Vec::from_slice(b"hello\xFF");
+        let xs = b"hello\xFF".to_vec();
         assert_eq!(String::from_utf8(xs),
-                   Err(Vec::from_slice(b"hello\xFF")));
+                   Err(b"hello\xFF".to_vec()));
     }
 
     #[test]
@@ -1211,7 +1212,8 @@ mod tests {
     fn test_push_bytes() {
         let mut s = String::from_str("ABC");
         unsafe {
-            s.push_bytes([b'D']);
+            let mv = s.as_mut_vec();
+            mv.push_all([b'D']);
         }
         assert_eq!(s.as_slice(), "ABCD");
     }
@@ -1239,17 +1241,18 @@ mod tests {
     }
 
     #[test]
-    fn test_pop_char() {
+    fn test_pop() {
         let mut data = String::from_str("ประเทศไทย中华b¢€𤭢");
-        assert_eq!(data.pop_char().unwrap(), '𤭢'); // 4 bytes
-        assert_eq!(data.pop_char().unwrap(), '€'); // 3 bytes
-        assert_eq!(data.pop_char().unwrap(), '¢'); // 2 bytes
-        assert_eq!(data.pop_char().unwrap(), 'b'); // 1 bytes
-        assert_eq!(data.pop_char().unwrap(), '华');
+        assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes
+        assert_eq!(data.pop().unwrap(), '€'); // 3 bytes
+        assert_eq!(data.pop().unwrap(), '¢'); // 2 bytes
+        assert_eq!(data.pop().unwrap(), 'b'); // 1 bytes
+        assert_eq!(data.pop().unwrap(), '华');
         assert_eq!(data.as_slice(), "ประเทศไทย中");
     }
 
     #[test]
+    #[allow(deprecated)] // use remove(0) instead
     fn test_shift_char() {
         let mut data = String::from_str("𤭢€¢b华ประเทศไทย中");
         assert_eq!(data.shift_char().unwrap(), '𤭢'); // 4 bytes
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index f922c189fefa..c714e3935706 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -2266,8 +2266,8 @@ mod tests {
     }
 
     #[test]
-    fn test_mut_slice_from() {
-        let mut values = Vec::from_slice([1u8,2,3,4,5]);
+    fn test_slice_from_mut() {
+        let mut values = vec![1u8,2,3,4,5];
         {
             let slice = values.slice_from_mut(2);
             assert!(slice == [3, 4, 5]);
@@ -2280,8 +2280,8 @@ mod tests {
     }
 
     #[test]
-    fn test_mut_slice_to() {
-        let mut values = Vec::from_slice([1u8,2,3,4,5]);
+    fn test_slice_to_mut() {
+        let mut values = vec![1u8,2,3,4,5];
         {
             let slice = values.slice_to_mut(2);
             assert!(slice == [1, 2]);
@@ -2294,8 +2294,8 @@ mod tests {
     }
 
     #[test]
-    fn test_mut_split_at() {
-        let mut values = Vec::from_slice([1u8,2,3,4,5]);
+    fn test_split_at_mut() {
+        let mut values = vec![1u8,2,3,4,5];
         {
             let (left, right) = values.split_at_mut(2);
             {
@@ -2315,7 +2315,7 @@ mod tests {
             }
         }
 
-        assert!(values == Vec::from_slice([2u8, 3, 5, 6, 7]));
+        assert!(values == vec![2u8, 3, 5, 6, 7]);
     }
 
     #[test]
@@ -2355,16 +2355,16 @@ mod tests {
 
     #[test]
     fn test_grow_fn() {
-        let mut v = Vec::from_slice([0u, 1]);
+        let mut v = vec![0u, 1];
         v.grow_fn(3, |i| i);
-        assert!(v == Vec::from_slice([0u, 1, 0, 1, 2]));
+        assert!(v == vec![0u, 1, 0, 1, 2]);
     }
 
     #[test]
     fn test_retain() {
-        let mut vec = Vec::from_slice([1u, 2, 3, 4]);
+        let mut vec = vec![1u, 2, 3, 4];
         vec.retain(|x| x%2 == 0);
-        assert!(vec == Vec::from_slice([2u, 4]));
+        assert!(vec == vec![2u, 4]);
     }
 
     #[test]
@@ -2567,32 +2567,32 @@ mod tests {
 
     #[test]
     fn test_move_items() {
-        let mut vec = vec!(1i, 2, 3);
-        let mut vec2 : Vec<int> = vec!();
+        let vec = vec![1, 2, 3];
+        let mut vec2 : Vec<i32> = vec![];
         for i in vec.into_iter() {
             vec2.push(i);
         }
-        assert!(vec2 == vec!(1i, 2, 3));
+        assert!(vec2 == vec![1, 2, 3]);
     }
 
     #[test]
     fn test_move_items_reverse() {
-        let mut vec = vec!(1i, 2, 3);
-        let mut vec2 : Vec<int> = vec!();
+        let vec = vec![1, 2, 3];
+        let mut vec2 : Vec<i32> = vec![];
         for i in vec.into_iter().rev() {
             vec2.push(i);
         }
-        assert!(vec2 == vec!(3i, 2, 1));
+        assert!(vec2 == vec![3, 2, 1]);
     }
 
     #[test]
     fn test_move_items_zero_sized() {
-        let mut vec = vec!((), (), ());
-        let mut vec2 : Vec<()> = vec!();
+        let vec = vec![(), (), ()];
+        let mut vec2 : Vec<()> = vec![];
         for i in vec.into_iter() {
             vec2.push(i);
         }
-        assert!(vec2 == vec!((), (), ()));
+        assert!(vec2 == vec![(), (), ()]);
     }
 
     #[test]
@@ -2707,7 +2707,7 @@ mod tests {
         b.bytes = src_len as u64;
 
         b.iter(|| {
-            let dst = Vec::from_slice(src.clone().as_slice());
+            let dst = src.clone().as_slice().to_vec();
             assert_eq!(dst.len(), src_len);
             assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
         });
@@ -2871,7 +2871,7 @@ mod tests {
 
         b.iter(|| {
             let mut dst = dst.clone();
-            dst.push_all_move(src.clone());
+            dst.extend(src.clone().into_iter());
             assert_eq!(dst.len(), dst_len + src_len);
             assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
         });
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 8f3ecf0633cf..f507556909c8 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -147,7 +147,7 @@ pub fn to_digit(c: char, radix: uint) -> Option<uint> {
 #[inline]
 pub fn from_digit(num: uint, radix: uint) -> Option<char> {
     if radix > 36 {
-        fail!("from_digit: radix is to high (maximum 36)");
+        fail!("from_digit: radix is too high (maximum 36)");
     }
     if num < radix {
         unsafe {
diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs
index 9628d7950b5c..8807756d01b7 100644
--- a/src/libcoretest/char.rs
+++ b/src/libcoretest/char.rs
@@ -117,7 +117,7 @@ fn test_is_digit() {
 fn test_escape_default() {
     fn string(c: char) -> String {
         let mut result = String::new();
-        escape_default(c, |c| { result.push_char(c); });
+        escape_default(c, |c| { result.push(c); });
         return result;
     }
     let s = string('\n');
@@ -152,7 +152,7 @@ fn test_escape_default() {
 fn test_escape_unicode() {
     fn string(c: char) -> String {
         let mut result = String::new();
-        escape_unicode(c, |c| { result.push_char(c); });
+        escape_unicode(c, |c| { result.push(c); });
         return result;
     }
     let s = string('\x00');
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index 4135a02cc618..476a2b50fcc8 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -868,7 +868,7 @@ fn bench_multiple_take(b: &mut Bencher) {
     let mut it = range(0u, 42).cycle();
     b.iter(|| {
         let n = it.next().unwrap();
-        for m in range(0u, n) {
+        for _ in range(0u, n) {
             it.take(it.next().unwrap()).all(|_| true);
         }
     });
diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs
index 76409c8612f3..e4dde7c641e1 100644
--- a/src/libcoretest/mem.rs
+++ b/src/libcoretest/mem.rs
@@ -109,7 +109,7 @@ fn test_transmute() {
     }
 
     unsafe {
-        assert!(Vec::from_slice([76u8]) == transmute("L".to_string()));
+        assert!(vec![76u8] == transmute("L".to_string()));
     }
 }
 
diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs
index b45ac6a993ef..b023833f3947 100644
--- a/src/libcoretest/result.rs
+++ b/src/libcoretest/result.rs
@@ -89,6 +89,7 @@ fn test_collect() {
 }
 
 #[test]
+#[allow(deprecated)] // we know fold_ is deprecated
 fn test_fold() {
     assert_eq!(fold_(range(0i, 0)
                     .map(|_| Ok::<(), ()>(()))),
diff --git a/src/libglob/lib.rs b/src/libglob/lib.rs
index d9584c2db4eb..0313c22933cf 100644
--- a/src/libglob/lib.rs
+++ b/src/libglob/lib.rs
@@ -682,7 +682,7 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME (#9406)
+    #[cfg_attr(windows, ignore)] // FIXME (#9406)
     fn test_lots_of_files() {
         // this is a good test because it touches lots of differently named files
         glob("/*/*/*/*").skip(10000).next();
diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs
index f7908b76ab51..e21186a5fc87 100644
--- a/src/libgraphviz/lib.rs
+++ b/src/libgraphviz/lib.rs
@@ -735,6 +735,20 @@ r#"digraph single_edge {
 "#);
     }
 
+    #[test]
+    fn test_some_labelled() {
+        let labels : Trivial = SomeNodesLabelled(vec![Some("A"), None]);
+        let result = test_input(LabelledGraph::new("test_some_labelled", labels,
+                                                   vec![edge(0, 1, "A-1")]));
+        assert_eq!(result.unwrap().as_slice(),
+r#"digraph test_some_labelled {
+    N0[label="A"];
+    N1[label="N1"];
+    N0 -> N1[label="A-1"];
+}
+"#);
+    }
+
     #[test]
     fn single_cyclic_node() {
         let labels : Trivial = UnlabelledNodes(1);
diff --git a/src/libgreen/sched.rs b/src/libgreen/sched.rs
index f36a43c3c291..f46d96ffe4a3 100644
--- a/src/libgreen/sched.rs
+++ b/src/libgreen/sched.rs
@@ -1027,7 +1027,6 @@ mod test {
     use std::rt::task::TaskOpts;
     use std::rt::task::Task;
     use std::rt::local::Local;
-    use std::time::Duration;
 
     use {TaskState, PoolConfig, SchedPool};
     use basic;
diff --git a/src/libnum/integer.rs b/src/libnum/integer.rs
index 7c7869766994..c5d076a70b58 100644
--- a/src/libnum/integer.rs
+++ b/src/libnum/integer.rs
@@ -462,6 +462,7 @@ macro_rules! impl_integer_for_uint {
             }
 
             #[test]
+            #[allow(type_overflow)]
             fn test_lcm() {
                 assert_eq!((1 as $T).lcm(&0), 0 as $T);
                 assert_eq!((0 as $T).lcm(&1), 0 as $T);
diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs
index 62c179f598c9..d6b02a1d0639 100644
--- a/src/librustc/metadata/loader.rs
+++ b/src/librustc/metadata/loader.rs
@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -641,41 +641,50 @@ impl<'a> Context<'a> {
         // rlibs/dylibs.
         let sess = self.sess;
         let dylibname = self.dylibname();
-        let mut locs = locs.iter().map(|l| Path::new(l.as_slice())).filter(|loc| {
-            if !loc.exists() {
-                sess.err(format!("extern location does not exist: {}",
-                                 loc.display()).as_slice());
-                return false;
-            }
-            let file = loc.filename_str().unwrap();
-            if file.starts_with("lib") && file.ends_with(".rlib") {
-                return true
-            } else {
-                match dylibname {
-                    Some((prefix, suffix)) => {
-                        if file.starts_with(prefix) && file.ends_with(suffix) {
-                            return true
-                        }
-                    }
-                    None => {}
-                }
-            }
-            sess.err(format!("extern location is of an unknown type: {}",
-                             loc.display()).as_slice());
-            false
-        });
-
-        // Now that we have an iterator of good candidates, make sure there's at
-        // most one rlib and at most one dylib.
         let mut rlibs = HashSet::new();
         let mut dylibs = HashSet::new();
-        for loc in locs {
-            if loc.filename_str().unwrap().ends_with(".rlib") {
-                rlibs.insert(fs::realpath(&loc).unwrap());
-            } else {
-                dylibs.insert(fs::realpath(&loc).unwrap());
+        {
+            let mut locs = locs.iter().map(|l| Path::new(l.as_slice())).filter(|loc| {
+                if !loc.exists() {
+                    sess.err(format!("extern location for {} does not exist: {}",
+                                     self.crate_name, loc.display()).as_slice());
+                    return false;
+                }
+                let file = match loc.filename_str() {
+                    Some(file) => file,
+                    None => {
+                        sess.err(format!("extern location for {} is not a file: {}",
+                                         self.crate_name, loc.display()).as_slice());
+                        return false;
+                    }
+                };
+                if file.starts_with("lib") && file.ends_with(".rlib") {
+                    return true
+                } else {
+                    match dylibname {
+                        Some((prefix, suffix)) => {
+                            if file.starts_with(prefix) && file.ends_with(suffix) {
+                                return true
+                            }
+                        }
+                        None => {}
+                    }
+                }
+                sess.err(format!("extern location for {} is of an unknown type: {}",
+                                 self.crate_name, loc.display()).as_slice());
+                false
+            });
+
+            // Now that we have an iterator of good candidates, make sure there's at
+            // most one rlib and at most one dylib.
+            for loc in locs {
+                if loc.filename_str().unwrap().ends_with(".rlib") {
+                    rlibs.insert(fs::realpath(&loc).unwrap());
+                } else {
+                    dylibs.insert(fs::realpath(&loc).unwrap());
+                }
             }
-        }
+        };
 
         // Extract the rlib/dylib pair.
         let mut metadata = None;
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index 84367090b26d..3f725b86420c 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -32,7 +32,7 @@ use syntax::ptr::P;
 use syntax::visit::{mod, Visitor, FnKind};
 use util::ppaux::ty_to_string;
 
-pub const DUMMY_WILD_PAT: Pat = Pat {
+pub const DUMMY_WILD_PAT: &'static Pat = &Pat {
     id: DUMMY_NODE_ID,
     node: PatWild(PatWildSingle),
     span: DUMMY_SP
@@ -309,12 +309,11 @@ fn raw_pat<'a>(p: &'a Pat) -> &'a Pat {
 }
 
 fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix) {
-    match is_useful(cx, matrix, &[&DUMMY_WILD_PAT], ConstructWitness) {
+    match is_useful(cx, matrix, &[DUMMY_WILD_PAT], ConstructWitness) {
         UsefulWithWitness(pats) => {
-            let dummy = DUMMY_WILD_PAT.clone();
             let witness = match pats.as_slice() {
                 [ref witness] => &**witness,
-                [] => &dummy,
+                [] => DUMMY_WILD_PAT,
                 _ => unreachable!()
             };
             span_err!(cx.tcx.sess, sp, E0004,
@@ -568,9 +567,8 @@ fn is_useful(cx: &MatchCheckCtxt,
                             let arity = constructor_arity(cx, &c, left_ty);
                             let mut result = {
                                 let pat_slice = pats.as_slice();
-                                let dummy = DUMMY_WILD_PAT.clone();
                                 let subpats = Vec::from_fn(arity, |i| {
-                                    pat_slice.get(i).map_or(&dummy, |p| &**p)
+                                    pat_slice.get(i).map_or(DUMMY_WILD_PAT, |p| &**p)
                                 });
                                 vec![construct_witness(cx, &c, subpats, left_ty)]
                             };
@@ -592,9 +590,8 @@ fn is_useful(cx: &MatchCheckCtxt,
                 }).collect();
                 match is_useful(cx, &matrix, v.tail(), witness) {
                     UsefulWithWitness(pats) => {
-                        let dummy = DUMMY_WILD_PAT.clone();
                         let arity = constructor_arity(cx, &constructor, left_ty);
-                        let wild_pats = Vec::from_elem(arity, &dummy);
+                        let wild_pats = Vec::from_elem(arity, DUMMY_WILD_PAT);
                         let enum_pat = construct_witness(cx, &constructor, wild_pats, left_ty);
                         let mut new_pats = vec![enum_pat];
                         new_pats.extend(pats.into_iter());
@@ -615,11 +612,10 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, &Matrix(ref m): &Matrix,
                          v: &[&Pat], ctor: Constructor, lty: ty::t,
                          witness: WitnessPreference) -> Usefulness {
     let arity = constructor_arity(cx, &ctor, lty);
-    let dummy = DUMMY_WILD_PAT.clone();
     let matrix = Matrix(m.iter().filter_map(|r| {
-        specialize(cx, r.as_slice(), &dummy, &ctor, 0u, arity)
+        specialize(cx, r.as_slice(), &ctor, 0u, arity)
     }).collect());
-    match specialize(cx, v, &dummy, &ctor, 0u, arity) {
+    match specialize(cx, v, &ctor, 0u, arity) {
         Some(v) => is_useful(cx, &matrix, v.as_slice(), witness),
         None => NotUseful
     }
@@ -741,7 +737,7 @@ fn range_covered_by_constructor(ctor: &Constructor,
 /// different patterns.
 /// Structure patterns with a partial wild pattern (Foo { a: 42, .. }) have their missing
 /// fields filled with wild patterns.
-pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], dummy: &'a Pat,
+pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
                       constructor: &Constructor, col: uint, arity: uint) -> Option<Vec<&'a Pat>> {
     let &Pat {
         id: pat_id, node: ref node, span: pat_span
@@ -749,7 +745,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], dummy: &'a Pat,
     let head: Option<Vec<&Pat>> = match node {
 
         &PatWild(_) =>
-            Some(Vec::from_elem(arity, dummy)),
+            Some(Vec::from_elem(arity, DUMMY_WILD_PAT)),
 
         &PatIdent(_, _, _) => {
             let opt_def = cx.tcx.def_map.borrow().find_copy(&pat_id);
@@ -762,7 +758,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], dummy: &'a Pat,
                 } else {
                     None
                 },
-                _ => Some(Vec::from_elem(arity, dummy))
+                _ => Some(Vec::from_elem(arity, DUMMY_WILD_PAT))
             }
         }
 
@@ -776,7 +772,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], dummy: &'a Pat,
                 DefVariant(..) | DefStruct(..) => {
                     Some(match args {
                         &Some(ref args) => args.iter().map(|p| &**p).collect(),
-                        &None => Vec::from_elem(arity, dummy)
+                        &None => Vec::from_elem(arity, DUMMY_WILD_PAT)
                     })
                 }
                 _ => None
@@ -812,7 +808,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], dummy: &'a Pat,
                 let args = struct_fields.iter().map(|sf| {
                     match pattern_fields.iter().find(|f| f.ident.name == sf.name) {
                         Some(ref f) => &*f.pat,
-                        _ => dummy
+                        _ => DUMMY_WILD_PAT
                     }
                 }).collect();
                 args
@@ -855,13 +851,13 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat], dummy: &'a Pat,
                 // Fixed-length vectors.
                 Single => {
                     let mut pats: Vec<&Pat> = before.iter().map(|p| &**p).collect();
-                    pats.grow_fn(arity - before.len() - after.len(), |_| dummy);
+                    pats.grow_fn(arity - before.len() - after.len(), |_| DUMMY_WILD_PAT);
                     pats.extend(after.iter().map(|p| &**p));
                     Some(pats)
                 },
                 Slice(length) if before.len() + after.len() <= length && slice.is_some() => {
                     let mut pats: Vec<&Pat> = before.iter().map(|p| &**p).collect();
-                    pats.grow_fn(arity - before.len() - after.len(), |_| dummy);
+                    pats.grow_fn(arity - before.len() - after.len(), |_| DUMMY_WILD_PAT);
                     pats.extend(after.iter().map(|p| &**p));
                     Some(pats)
                 },
@@ -931,7 +927,7 @@ fn check_fn(cx: &mut MatchCheckCtxt,
 
 fn is_refutable<A>(cx: &MatchCheckCtxt, pat: &Pat, refutable: |&Pat| -> A) -> Option<A> {
     let pats = Matrix(vec!(vec!(pat)));
-    match is_useful(cx, &pats, [&DUMMY_WILD_PAT], ConstructWitness) {
+    match is_useful(cx, &pats, [DUMMY_WILD_PAT], ConstructWitness) {
         UsefulWithWitness(pats) => {
             assert_eq!(pats.len(), 1);
             Some(refutable(&*pats[0]))
diff --git a/src/librustc/middle/check_rvalues.rs b/src/librustc/middle/check_rvalues.rs
index 21023986e1c2..2a2655cc49c6 100644
--- a/src/librustc/middle/check_rvalues.rs
+++ b/src/librustc/middle/check_rvalues.rs
@@ -32,13 +32,16 @@ struct RvalueContext<'a, 'tcx: 'a> {
 
 impl<'a, 'tcx, 'v> visit::Visitor<'v> for RvalueContext<'a, 'tcx> {
     fn visit_fn(&mut self,
-                _: visit::FnKind<'v>,
+                fk: visit::FnKind<'v>,
                 fd: &'v ast::FnDecl,
                 b: &'v ast::Block,
-                _: Span,
+                s: Span,
                 _: ast::NodeId) {
-        let mut euv = euv::ExprUseVisitor::new(self, self.tcx);
-        euv.walk_fn(fd, b);
+        {
+            let mut euv = euv::ExprUseVisitor::new(self, self.tcx);
+            euv.walk_fn(fd, b);
+        }
+        visit::walk_fn(self, fk, fd, b, s)
     }
 }
 
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
index ff3720381009..61b013d795ea 100644
--- a/src/librustc/middle/dead.rs
+++ b/src/librustc/middle/dead.rs
@@ -441,6 +441,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
     fn should_warn_about_item(&mut self, item: &ast::Item) -> bool {
         let should_warn = match item.node {
             ast::ItemStatic(..)
+            | ast::ItemConst(..)
             | ast::ItemFn(..)
             | ast::ItemEnum(..)
             | ast::ItemStruct(..) => true,
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 55486354e7d6..3a1058c009f6 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -352,19 +352,6 @@ struct Match<'a, 'p: 'a, 'blk: 'a, 'tcx: 'blk> {
     pats: Vec<&'p ast::Pat>,
     data: &'a ArmData<'p, 'blk, 'tcx>,
     bound_ptrs: Vec<(Ident, ValueRef)>,
-
-    // This is a pointer to an instance of check_match::DUMMY_WILD_PAT. The
-    // check_match code requires that we pass this in (with the same lifetime as
-    // the patterns passed in). Unfortunately this is required to be propagated
-    // into this structure in order to get the lifetimes to work.
-    //
-    // Lots of the `check_match` code will deal with &DUMMY_WILD_PAT when
-    // returning references, which used to have the `'static` lifetime before
-    // const was added to the language. The DUMMY_WILD_PAT does not implement
-    // Sync, however, so it must be a const, which longer has a static lifetime,
-    // hence we're passing it in here. This certainly isn't crucial, and if it
-    // can be removed, please do!
-    dummy: &'p ast::Pat,
 }
 
 impl<'a, 'p, 'blk, 'tcx> Repr for Match<'a, 'p, 'blk, 'tcx> {
@@ -417,7 +404,6 @@ fn expand_nested_bindings<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         *pats.get_mut(col) = pat;
         Match {
             pats: pats,
-            dummy: br.dummy,
             data: &*br.data,
             bound_ptrs: bound_ptrs
         }
@@ -465,7 +451,6 @@ fn enter_match<'a, 'b, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             }
             Match {
                 pats: pats,
-                dummy: br.dummy,
                 data: br.data,
                 bound_ptrs: bound_ptrs
             }
@@ -560,8 +545,7 @@ fn enter_opt<'a, 'p, 'blk, 'tcx>(
 
     let mcx = check_match::MatchCheckCtxt { tcx: bcx.tcx() };
     enter_match(bcx, dm, m, col, val, |pats|
-        check_match::specialize(&mcx, pats.as_slice(), m[0].dummy, &ctor, col,
-                                variant_size)
+        check_match::specialize(&mcx, pats.as_slice(), &ctor, col, variant_size)
     )
 }
 
@@ -1051,7 +1035,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     match adt_vals {
         Some(field_vals) => {
             let pats = enter_match(bcx, dm, m, col, val, |pats|
-                check_match::specialize(&mcx, pats, m[0].dummy,
+                check_match::specialize(&mcx, pats,
                                         &check_match::Single, col,
                                         field_vals.len())
             );
@@ -1375,7 +1359,6 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>,
         bindings_map: create_bindings_map(bcx, &**arm.pats.get(0), discr_expr, &*arm.body)
     }).collect();
 
-    let dummy = check_match::DUMMY_WILD_PAT.clone();
     let mut static_inliner = StaticInliner::new(scope_cx.tcx());
     let arm_pats: Vec<Vec<P<ast::Pat>>> = arm_datas.iter().map(|arm_data| {
         arm_data.arm.pats.iter().map(|p| static_inliner.fold_pat((*p).clone())).collect()
@@ -1384,7 +1367,6 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>,
     for (arm_data, pats) in arm_datas.iter().zip(arm_pats.iter()) {
         matches.extend(pats.iter().map(|p| Match {
             pats: vec![&**p],
-            dummy: &dummy,
             data: arm_data,
             bound_ptrs: Vec::new(),
         }));
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
index bc562b39c98f..1b23841c913c 100644
--- a/src/librustc/middle/trans/callee.rs
+++ b/src/librustc/middle/trans/callee.rs
@@ -788,7 +788,7 @@ pub fn trans_call_inner<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                          llself.is_some(),
                          abi);
 
-        fcx.pop_custom_cleanup_scope(arg_cleanup_scope);
+        fcx.scopes.borrow_mut().last_mut().unwrap().drop_non_lifetime_clean();
 
         // Invoke the actual rust fn and update bcx/llresult.
         let (llret, b) = base::invoke(bcx,
@@ -829,12 +829,15 @@ pub fn trans_call_inner<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                          cleanup::CustomScope(arg_cleanup_scope),
                          false,
                          abi);
-        fcx.pop_custom_cleanup_scope(arg_cleanup_scope);
+        fcx.scopes.borrow_mut().last_mut().unwrap().drop_non_lifetime_clean();
+
         bcx = foreign::trans_native_call(bcx, callee_ty,
                                          llfn, opt_llretslot.unwrap(),
                                          llargs.as_slice(), arg_tys);
     }
 
+    fcx.pop_and_trans_custom_cleanup_scope(bcx, arg_cleanup_scope);
+
     // If the caller doesn't care about the result of this fn call,
     // drop the temporary slot we made.
     match (dest, opt_llretslot) {
diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs
index 392436d3a806..f3844a956fad 100644
--- a/src/librustc/middle/trans/cleanup.rs
+++ b/src/librustc/middle/trans/cleanup.rs
@@ -74,6 +74,7 @@ pub struct CachedEarlyExit {
 pub trait Cleanup {
     fn must_unwind(&self) -> bool;
     fn clean_on_unwind(&self) -> bool;
+    fn is_lifetime_end(&self) -> bool;
     fn trans<'blk, 'tcx>(&self,
                          bcx: Block<'blk, 'tcx>,
                          debug_loc: Option<NodeInfo>)
@@ -875,6 +876,10 @@ impl<'blk, 'tcx> CleanupScope<'blk, 'tcx> {
             LoopScopeKind(id, _) => format!("{}_loop_{}_", prefix, id),
         }
     }
+
+    pub fn drop_non_lifetime_clean(&mut self) {
+        self.cleanups.retain(|c| c.is_lifetime_end());
+    }
 }
 
 impl<'blk, 'tcx> CleanupScopeKind<'blk, 'tcx> {
@@ -943,6 +948,10 @@ impl Cleanup for DropValue {
         self.must_unwind
     }
 
+    fn is_lifetime_end(&self) -> bool {
+        false
+    }
+
     fn trans<'blk, 'tcx>(&self,
                          bcx: Block<'blk, 'tcx>,
                          debug_loc: Option<NodeInfo>)
@@ -978,6 +987,10 @@ impl Cleanup for FreeValue {
         true
     }
 
+    fn is_lifetime_end(&self) -> bool {
+        false
+    }
+
     fn trans<'blk, 'tcx>(&self,
                          bcx: Block<'blk, 'tcx>,
                          debug_loc: Option<NodeInfo>)
@@ -1008,6 +1021,10 @@ impl Cleanup for FreeSlice {
         true
     }
 
+    fn is_lifetime_end(&self) -> bool {
+        false
+    }
+
     fn trans<'blk, 'tcx>(&self,
                          bcx: Block<'blk, 'tcx>,
                          debug_loc: Option<NodeInfo>)
@@ -1035,6 +1052,10 @@ impl Cleanup for LifetimeEnd {
         true
     }
 
+    fn is_lifetime_end(&self) -> bool {
+        true
+    }
+
     fn trans<'blk, 'tcx>(&self,
                          bcx: Block<'blk, 'tcx>,
                          debug_loc: Option<NodeInfo>)
diff --git a/src/librustrt/mutex.rs b/src/librustrt/mutex.rs
index 7d4fb2f5c529..b328df1949e0 100644
--- a/src/librustrt/mutex.rs
+++ b/src/librustrt/mutex.rs
@@ -655,19 +655,19 @@ mod test {
 
     #[test]
     fn smoke_lock() {
-        static lock: StaticNativeMutex = NATIVE_MUTEX_INIT;
+        static LK: StaticNativeMutex = NATIVE_MUTEX_INIT;
         unsafe {
-            let _guard = lock.lock();
+            let _guard = LK.lock();
         }
     }
 
     #[test]
     fn smoke_cond() {
-        static lock: StaticNativeMutex = NATIVE_MUTEX_INIT;
+        static LK: StaticNativeMutex = NATIVE_MUTEX_INIT;
         unsafe {
-            let guard = lock.lock();
+            let guard = LK.lock();
             let t = Thread::start(proc() {
-                let guard = lock.lock();
+                let guard = LK.lock();
                 guard.signal();
             });
             guard.wait();
@@ -679,25 +679,25 @@ mod test {
 
     #[test]
     fn smoke_lock_noguard() {
-        static lock: StaticNativeMutex = NATIVE_MUTEX_INIT;
+        static LK: StaticNativeMutex = NATIVE_MUTEX_INIT;
         unsafe {
-            lock.lock_noguard();
-            lock.unlock_noguard();
+            LK.lock_noguard();
+            LK.unlock_noguard();
         }
     }
 
     #[test]
     fn smoke_cond_noguard() {
-        static lock: StaticNativeMutex = NATIVE_MUTEX_INIT;
+        static LK: StaticNativeMutex = NATIVE_MUTEX_INIT;
         unsafe {
-            lock.lock_noguard();
+            LK.lock_noguard();
             let t = Thread::start(proc() {
-                lock.lock_noguard();
-                lock.signal_noguard();
-                lock.unlock_noguard();
+                LK.lock_noguard();
+                LK.signal_noguard();
+                LK.unlock_noguard();
             });
-            lock.wait_noguard();
-            lock.unlock_noguard();
+            LK.wait_noguard();
+            LK.unlock_noguard();
 
             t.join();
         }
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index 5d9211caac1b..eda38e96cbb1 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -2964,8 +2964,8 @@ mod tests {
         let s = "{\"f\":null,\"a\":[null,123]}";
         let obj: FloatStruct = super::decode(s).unwrap();
         assert!(obj.f.is_nan());
-        assert!(obj.a.get(0).is_nan());
-        assert_eq!(obj.a.get(1), &123f64);
+        assert!(obj.a[0].is_nan());
+        assert_eq!(obj.a[1], 123f64);
     }
 
     #[test]
diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 7a36680b3a62..71d38ac66597 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -582,15 +582,15 @@ mod tests {
         assert_eq!('A'.to_ascii().to_char(), 'A');
         assert_eq!('A'.to_ascii().to_byte(), 65u8);
 
-        assert_eq!('A'.to_ascii().to_lower().to_char(), 'a');
-        assert_eq!('Z'.to_ascii().to_lower().to_char(), 'z');
-        assert_eq!('a'.to_ascii().to_upper().to_char(), 'A');
-        assert_eq!('z'.to_ascii().to_upper().to_char(), 'Z');
+        assert_eq!('A'.to_ascii().to_lowercase().to_char(), 'a');
+        assert_eq!('Z'.to_ascii().to_lowercase().to_char(), 'z');
+        assert_eq!('a'.to_ascii().to_uppercase().to_char(), 'A');
+        assert_eq!('z'.to_ascii().to_uppercase().to_char(), 'Z');
 
-        assert_eq!('@'.to_ascii().to_lower().to_char(), '@');
-        assert_eq!('['.to_ascii().to_lower().to_char(), '[');
-        assert_eq!('`'.to_ascii().to_upper().to_char(), '`');
-        assert_eq!('{'.to_ascii().to_upper().to_char(), '{');
+        assert_eq!('@'.to_ascii().to_lowercase().to_char(), '@');
+        assert_eq!('['.to_ascii().to_lowercase().to_char(), '[');
+        assert_eq!('`'.to_ascii().to_uppercase().to_char(), '`');
+        assert_eq!('{'.to_ascii().to_uppercase().to_char(), '{');
 
         assert!('0'.to_ascii().is_digit());
         assert!('9'.to_ascii().is_digit());
diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs
index adb55f2cc8cf..42e3a823ff4f 100644
--- a/src/libstd/bitflags.rs
+++ b/src/libstd/bitflags.rs
@@ -273,8 +273,8 @@ mod tests {
     }
 
     bitflags! {
-        flags AnotherSetOfFlags: uint {
-            const AnotherFlag = 1u,
+        flags AnotherSetOfFlags: i8 {
+            const AnotherFlag = -1_i8,
         }
     }
 
@@ -283,6 +283,9 @@ mod tests {
         assert_eq!(Flags::empty().bits(), 0x00000000);
         assert_eq!(FlagA.bits(), 0x00000001);
         assert_eq!(FlagABC.bits(), 0x00000111);
+
+        assert_eq!(AnotherSetOfFlags::empty().bits(), 0x00);
+        assert_eq!(AnotherFlag.bits(), !0_i8);
     }
 
     #[test]
@@ -292,6 +295,8 @@ mod tests {
         assert!(Flags::from_bits(0x10) == Some(FlagB));
         assert!(Flags::from_bits(0x11) == Some(FlagA | FlagB));
         assert!(Flags::from_bits(0x1000) == None);
+
+        assert!(AnotherSetOfFlags::from_bits(!0_i8) == Some(AnotherFlag));
     }
 
     #[test]
@@ -302,6 +307,8 @@ mod tests {
         assert!(Flags::from_bits_truncate(0x11) == (FlagA | FlagB));
         assert!(Flags::from_bits_truncate(0x1000) == Flags::empty());
         assert!(Flags::from_bits_truncate(0x1001) == FlagA);
+
+        assert!(AnotherSetOfFlags::from_bits_truncate(0_i8) == AnotherSetOfFlags::empty());
     }
 
     #[test]
@@ -309,6 +316,8 @@ mod tests {
         assert!(Flags::empty().is_empty());
         assert!(!FlagA.is_empty());
         assert!(!FlagABC.is_empty());
+
+        assert!(!AnotherFlag.is_empty());
     }
 
     #[test]
@@ -316,6 +325,8 @@ mod tests {
         assert!(Flags::all().is_all());
         assert!(!FlagA.is_all());
         assert!(FlagABC.is_all());
+
+        assert!(AnotherFlag.is_all());
     }
 
     #[test]
@@ -323,6 +334,8 @@ mod tests {
         let e1 = Flags::empty();
         let e2 = Flags::empty();
         assert!(!e1.intersects(e2));
+
+        assert!(AnotherFlag.intersects(AnotherFlag));
     }
 
     #[test]
@@ -353,6 +366,8 @@ mod tests {
         assert!(!e1.contains(e2));
         assert!(e2.contains(e1));
         assert!(FlagABC.contains(e2));
+
+        assert!(AnotherFlag.contains(AnotherFlag));
     }
 
     #[test]
@@ -361,6 +376,10 @@ mod tests {
         let e2 = FlagA | FlagB;
         e1.insert(e2);
         assert!(e1 == e2);
+
+        let mut e3 = AnotherSetOfFlags::empty();
+        e3.insert(AnotherFlag);
+        assert!(e3 == AnotherFlag);
     }
 
     #[test]
@@ -369,6 +388,10 @@ mod tests {
         let e2 = FlagA | FlagC;
         e1.remove(e2);
         assert!(e1 == FlagB);
+
+        let mut e3 = AnotherFlag;
+        e3.remove(AnotherFlag);
+        assert!(e3 == AnotherSetOfFlags::empty());
     }
 
     #[test]
@@ -383,6 +406,10 @@ mod tests {
         let mut e3 = e1;
         e3.toggle(e2);
         assert!(e3 == FlagA | FlagB);
+
+        let mut m4 = AnotherSetOfFlags::empty();
+        m4.toggle(AnotherSetOfFlags::empty());
+        assert!(m4 == AnotherSetOfFlags::empty());
     }
 
     #[test]
diff --git a/src/libstd/collections/hashmap/map.rs b/src/libstd/collections/hashmap/map.rs
index ef40402105b5..bdd9d8d9d1f5 100644
--- a/src/libstd/collections/hashmap/map.rs
+++ b/src/libstd/collections/hashmap/map.rs
@@ -1930,6 +1930,7 @@ mod test_map {
     }
 
     #[test]
+    #[allow(deprecated)] // insert_or_update_with
     fn test_update_with() {
         let mut m = HashMap::with_capacity(4);
         assert!(m.insert(1i, 2i));
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 754b440b0de8..8ab0d3a55040 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -400,7 +400,7 @@ mod test {
 
     impl Reader for ShortReader {
         fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
-            match self.lengths.shift() {
+            match self.lengths.remove(0) {
                 Some(i) => Ok(i),
                 None => Err(io::standard_error(io::EndOfFile))
             }
@@ -551,7 +551,7 @@ mod test {
 
     #[test]
     fn test_read_line() {
-        let in_buf = MemReader::new(Vec::from_slice(b"a\nb\nc"));
+        let in_buf = MemReader::new(b"a\nb\nc".to_vec());
         let mut reader = BufferedReader::with_capacity(2, in_buf);
         assert_eq!(reader.read_line(), Ok("a\n".to_string()));
         assert_eq!(reader.read_line(), Ok("b\n".to_string()));
@@ -561,7 +561,7 @@ mod test {
 
     #[test]
     fn test_lines() {
-        let in_buf = MemReader::new(Vec::from_slice(b"a\nb\nc"));
+        let in_buf = MemReader::new(b"a\nb\nc".to_vec());
         let mut reader = BufferedReader::with_capacity(2, in_buf);
         let mut it = reader.lines();
         assert_eq!(it.next(), Some(Ok("a\n".to_string())));
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index 82494d41aa3f..e8fed67fffed 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -1415,7 +1415,7 @@ mod test {
         check!(copy(&input, &output));
 
         assert_eq!(check!(File::open(&output).read_to_end()),
-                   (Vec::from_slice(b"foo")));
+                   b"foo".to_vec());
     }
 
     #[test]
@@ -1459,7 +1459,7 @@ mod test {
         }
         assert_eq!(check!(stat(&out)).size, check!(stat(&input)).size);
         assert_eq!(check!(File::open(&out).read_to_end()),
-                   (Vec::from_slice(b"foobar")));
+                   b"foobar".to_vec());
     }
 
     #[cfg(not(windows))] // apparently windows doesn't like symlinks
@@ -1497,7 +1497,7 @@ mod test {
         assert_eq!(check!(stat(&out)).size, check!(stat(&input)).size);
         assert_eq!(check!(stat(&out)).size, check!(input.stat()).size);
         assert_eq!(check!(File::open(&out).read_to_end()),
-                   (Vec::from_slice(b"foobar")));
+                   b"foobar".to_vec());
 
         // can't link to yourself
         match link(&input, &input) {
@@ -1560,7 +1560,7 @@ mod test {
         check!(file.fsync());
         assert_eq!(check!(file.stat()).size, 10);
         assert_eq!(check!(File::open(&path).read_to_end()),
-                   (Vec::from_slice(b"foobar\0\0\0\0")));
+                   b"foobar\0\0\0\0".to_vec());
 
         // Truncate to a smaller length, don't seek, and then write something.
         // Ensure that the intermediate zeroes are all filled in (we're seeked
@@ -1571,7 +1571,7 @@ mod test {
         check!(file.fsync());
         assert_eq!(check!(file.stat()).size, 9);
         assert_eq!(check!(File::open(&path).read_to_end()),
-                   (Vec::from_slice(b"fo\0\0\0\0wut")));
+                   b"fo\0\0\0\0wut".to_vec());
         drop(file);
     }
 
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 0f8e0ed52f8b..f86ae05d623c 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -617,7 +617,7 @@ mod test {
     #[bench]
     fn bench_mem_reader(b: &mut Bencher) {
         b.iter(|| {
-            let buf = Vec::from_slice([5 as u8, ..100]);
+            let buf = [5 as u8, ..100].to_vec();
             {
                 let mut rdr = MemReader::new(buf);
                 for _i in range(0u, 10) {
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index d18b3cdf2e75..8592d48974a2 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -1949,62 +1949,62 @@ mod tests {
                         return Ok(0);
                     }
                 };
-                behavior.shift();
+                behavior.remove(0);
             }
         }
     }
 
     #[test]
     fn test_read_at_least() {
-        let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")),
-                                   Vec::from_slice([GoodBehavior(uint::MAX)]));
+        let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
+                                   vec![GoodBehavior(uint::MAX)]);
         let mut buf = [0u8, ..5];
         assert!(r.read_at_least(1, buf).unwrap() >= 1);
         assert!(r.read_exact(5).unwrap().len() == 5); // read_exact uses read_at_least
         assert!(r.read_at_least(0, buf).is_ok());
 
-        let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")),
-                                   Vec::from_slice([BadBehavior(50), GoodBehavior(uint::MAX)]));
+        let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
+                                   vec![BadBehavior(50), GoodBehavior(uint::MAX)]);
         assert!(r.read_at_least(1, buf).unwrap() >= 1);
 
-        let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")),
-                                   Vec::from_slice([BadBehavior(1), GoodBehavior(1),
-                                                    BadBehavior(50), GoodBehavior(uint::MAX)]));
+        let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
+                                   vec![BadBehavior(1), GoodBehavior(1),
+                                        BadBehavior(50), GoodBehavior(uint::MAX)]);
         assert!(r.read_at_least(1, buf).unwrap() >= 1);
         assert!(r.read_at_least(1, buf).unwrap() >= 1);
 
-        let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")),
-                                   Vec::from_slice([BadBehavior(uint::MAX)]));
+        let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
+                                   vec![BadBehavior(uint::MAX)]);
         assert_eq!(r.read_at_least(1, buf).unwrap_err().kind, NoProgress);
 
-        let mut r = MemReader::new(Vec::from_slice(b"hello, world!"));
+        let mut r = MemReader::new(b"hello, world!".to_vec());
         assert_eq!(r.read_at_least(5, buf).unwrap(), 5);
         assert_eq!(r.read_at_least(6, buf).unwrap_err().kind, InvalidInput);
     }
 
     #[test]
     fn test_push_at_least() {
-        let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")),
-                                   Vec::from_slice([GoodBehavior(uint::MAX)]));
+        let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
+                                   vec![GoodBehavior(uint::MAX)]);
         let mut buf = Vec::new();
         assert!(r.push_at_least(1, 5, &mut buf).unwrap() >= 1);
         assert!(r.push_at_least(0, 5, &mut buf).is_ok());
 
-        let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")),
-                                   Vec::from_slice([BadBehavior(50), GoodBehavior(uint::MAX)]));
+        let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
+                                   vec![BadBehavior(50), GoodBehavior(uint::MAX)]);
         assert!(r.push_at_least(1, 5, &mut buf).unwrap() >= 1);
 
-        let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")),
-                                   Vec::from_slice([BadBehavior(1), GoodBehavior(1),
-                                                    BadBehavior(50), GoodBehavior(uint::MAX)]));
+        let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
+                                   vec![BadBehavior(1), GoodBehavior(1),
+                                        BadBehavior(50), GoodBehavior(uint::MAX)]);
         assert!(r.push_at_least(1, 5, &mut buf).unwrap() >= 1);
         assert!(r.push_at_least(1, 5, &mut buf).unwrap() >= 1);
 
-        let mut r = BadReader::new(MemReader::new(Vec::from_slice(b"hello, world!")),
-                                   Vec::from_slice([BadBehavior(uint::MAX)]));
+        let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
+                                   vec![BadBehavior(uint::MAX)]);
         assert_eq!(r.push_at_least(1, 5, &mut buf).unwrap_err().kind, NoProgress);
 
-        let mut r = MemReader::new(Vec::from_slice(b"hello, world!"));
+        let mut r = MemReader::new(b"hello, world!".to_vec());
         assert_eq!(r.push_at_least(5, 1, &mut buf).unwrap_err().kind, InvalidInput);
     }
 
diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs
index 27241f9bfa55..9d85701eb298 100644
--- a/src/libstd/io/net/addrinfo.rs
+++ b/src/libstd/io/net/addrinfo.rs
@@ -126,9 +126,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>)
 #[cfg(all(test, not(target_os = "android")))]
 mod test {
     use super::*;
-    use io::net::tcp::*;
     use io::net::ip::*;
-    use io::net::udp::*;
 
     #[test]
     fn dns_smoke_test() {
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index e2a850c58e44..d6528ce977e9 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -521,10 +521,8 @@ impl Clone for TcpAcceptor {
 #[cfg(test)]
 #[allow(experimental)]
 mod test {
-    use super::*;
     use io::net::tcp::*;
     use io::net::ip::*;
-    use io::net::udp::*;
     use io::*;
     use io::test::*;
     use prelude::*;
diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs
index d7d478bd458c..9362a48a6f00 100644
--- a/src/libstd/io/pipe.rs
+++ b/src/libstd/io/pipe.rs
@@ -118,7 +118,6 @@ impl Writer for PipeStream {
 
 #[cfg(test)]
 mod test {
-    use super::*;
     use prelude::*;
 
     #[test]
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index 5de4bc10e1ae..88f8434b9576 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -727,7 +727,7 @@ mod tests {
         assert!(p.is_ok());
         let mut p = p.unwrap();
         assert!(p.stdout.is_some());
-        let ret = read_all(p.stdout.get_mut_ref() as &mut Reader);
+        let ret = read_all(p.stdout.as_mut().unwrap() as &mut Reader);
         assert!(p.wait().unwrap().success());
         return ret;
     }
@@ -758,9 +758,9 @@ mod tests {
                             .stdin(CreatePipe(true, false))
                             .stdout(CreatePipe(false, true))
                             .spawn().unwrap();
-        p.stdin.get_mut_ref().write("foobar".as_bytes()).unwrap();
+        p.stdin.as_mut().unwrap().write("foobar".as_bytes()).unwrap();
         drop(p.stdin.take());
-        let out = read_all(p.stdout.get_mut_ref() as &mut Reader);
+        let out = read_all(p.stdout.as_mut().unwrap() as &mut Reader);
         assert!(p.wait().unwrap().success());
         assert_eq!(out, "foobar\n".to_string());
     }
@@ -1019,7 +1019,7 @@ mod tests {
     fn test_add_to_env() {
         let prog = env_cmd().env("RUN_TEST_NEW_ENV", "123").spawn().unwrap();
         let result = prog.wait_with_output().unwrap();
-        let output = str::from_utf8_lossy(result.output.as_slice()).into_string();
+        let output = String::from_utf8_lossy(result.output.as_slice()).into_string();
 
         assert!(output.as_slice().contains("RUN_TEST_NEW_ENV=123"),
                 "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index b174f19f1982..93037f765d63 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -385,6 +385,7 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    #[test]
     fn smoke() {
         // Just make sure we can acquire handles
         stdin();
@@ -392,6 +393,7 @@ mod tests {
         stderr();
     }
 
+    #[test]
     fn capture_stdout() {
         use io::{ChanReader, ChanWriter};
 
@@ -404,9 +406,10 @@ mod tests {
         assert_eq!(r.read_to_string().unwrap(), "hello!\n".to_string());
     }
 
+    #[test]
     fn capture_stderr() {
         use realstd::comm::channel;
-        use realstd::io::{Writer, ChanReader, ChanWriter, Reader};
+        use realstd::io::{ChanReader, ChanWriter, Reader};
 
         let (tx, rx) = channel();
         let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs
index e7df02855406..a657989fe124 100644
--- a/src/libstd/io/timer.rs
+++ b/src/libstd/io/timer.rs
@@ -235,7 +235,6 @@ mod test {
     use super::*;
     use time::Duration;
     use task::spawn;
-    use io::*;
     use prelude::*;
 
     #[test]
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index f97bbe0dc8ea..48ee7664c16a 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -819,72 +819,82 @@ mod bench {
     mod uint {
         use super::test::Bencher;
         use rand::{weak_rng, Rng};
-        use num::ToStrRadix;
+        use std::fmt;
+
+        #[inline]
+        fn to_string(x: uint, base: u8) {
+            format!("{}", fmt::radix(x, base));
+        }
 
         #[bench]
         fn to_str_bin(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<uint>().to_str_radix(2); })
+            b.iter(|| { to_string(rng.gen::<uint>(), 2); })
         }
 
         #[bench]
         fn to_str_oct(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<uint>().to_str_radix(8); })
+            b.iter(|| { to_string(rng.gen::<uint>(), 8); })
         }
 
         #[bench]
         fn to_str_dec(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<uint>().to_str_radix(10); })
+            b.iter(|| { to_string(rng.gen::<uint>(), 10); })
         }
 
         #[bench]
         fn to_str_hex(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<uint>().to_str_radix(16); })
+            b.iter(|| { to_string(rng.gen::<uint>(), 16); })
         }
 
         #[bench]
         fn to_str_base_36(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<uint>().to_str_radix(36); })
+            b.iter(|| { to_string(rng.gen::<uint>(), 36); })
         }
     }
 
     mod int {
         use super::test::Bencher;
         use rand::{weak_rng, Rng};
-        use num::ToStrRadix;
+        use std::fmt;
+
+        #[inline]
+        fn to_string(x: int, base: u8) {
+            format!("{}", fmt::radix(x, base));
+        }
 
         #[bench]
         fn to_str_bin(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<int>().to_str_radix(2); })
+            b.iter(|| { to_string(rng.gen::<int>(), 2); })
         }
 
         #[bench]
         fn to_str_oct(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<int>().to_str_radix(8); })
+            b.iter(|| { to_string(rng.gen::<int>(), 8); })
         }
 
         #[bench]
         fn to_str_dec(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<int>().to_str_radix(10); })
+            b.iter(|| { to_string(rng.gen::<int>(), 10); })
         }
 
         #[bench]
         fn to_str_hex(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<int>().to_str_radix(16); })
+            b.iter(|| { to_string(rng.gen::<int>(), 16); })
         }
 
         #[bench]
         fn to_str_base_36(b: &mut Bencher) {
             let mut rng = weak_rng();
-            b.iter(|| { rng.gen::<int>().to_str_radix(36); })
+            b.iter(|| { to_string(rng.gen::<int>(), 36); })
         }
     }
 
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index f7fb9adb1fb6..27eafdab642a 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -775,7 +775,7 @@ mod tests {
         t!(s: "a/b/c", ["d".to_string(), "e".to_string()], "a/b/c/d/e");
         t!(v: b"a/b/c", [b"d", b"e"], b"a/b/c/d/e");
         t!(v: b"a/b/c", [b"d", b"/e", b"f"], b"/e/f");
-        t!(v: b"a/b/c", [Vec::from_slice(b"d"), Vec::from_slice(b"e")], b"a/b/c/d/e");
+        t!(v: b"a/b/c", [b"d".to_vec(), b"e".to_vec()], b"a/b/c/d/e");
     }
 
     #[test]
@@ -879,7 +879,7 @@ mod tests {
         t!(s: "a/b/c", ["d", "/e", "f"], "/e/f");
         t!(s: "a/b/c", ["d".to_string(), "e".to_string()], "a/b/c/d/e");
         t!(v: b"a/b/c", [b"d", b"e"], b"a/b/c/d/e");
-        t!(v: b"a/b/c", [Vec::from_slice(b"d"), Vec::from_slice(b"e")], b"a/b/c/d/e");
+        t!(v: b"a/b/c", [b"d".to_vec(), b"e".to_vec()], b"a/b/c/d/e");
     }
 
     #[test]
diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index fe5d8fc068c9..8ca1cec3e0ae 100644
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -76,7 +76,6 @@ mod test {
 
     use super::ReaderRng;
     use io::MemReader;
-    use mem;
     use rand::Rng;
 
     #[test]
@@ -87,25 +86,25 @@ mod test {
                      0,   0, 0, 0, 0, 0, 0, 3];
         let mut rng = ReaderRng::new(MemReader::new(v));
 
-        assert_eq!(rng.next_u64(), mem::to_be64(1));
-        assert_eq!(rng.next_u64(), mem::to_be64(2));
-        assert_eq!(rng.next_u64(), mem::to_be64(3));
+        assert_eq!(rng.next_u64(), 1_u64.to_be());
+        assert_eq!(rng.next_u64(), 2_u64.to_be());
+        assert_eq!(rng.next_u64(), 3_u64.to_be());
     }
     #[test]
     fn test_reader_rng_u32() {
         let v = vec![0u8, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3];
         let mut rng = ReaderRng::new(MemReader::new(v));
 
-        assert_eq!(rng.next_u32(), mem::to_be32(1));
-        assert_eq!(rng.next_u32(), mem::to_be32(2));
-        assert_eq!(rng.next_u32(), mem::to_be32(3));
+        assert_eq!(rng.next_u32(), 1_u32.to_be());
+        assert_eq!(rng.next_u32(), 2_u32.to_be());
+        assert_eq!(rng.next_u32(), 3_u32.to_be());
     }
     #[test]
     fn test_reader_rng_fill_bytes() {
         let v = [1u8, 2, 3, 4, 5, 6, 7, 8];
         let mut w = [0u8, .. 8];
 
-        let mut rng = ReaderRng::new(MemReader::new(Vec::from_slice(v)));
+        let mut rng = ReaderRng::new(MemReader::new(v.as_slice().to_vec()));
         rng.fill_bytes(w);
 
         assert!(v == w);
diff --git a/src/libstd/task.rs b/src/libstd/task.rs
index 977b3018fa74..04d3bb8b3a7e 100644
--- a/src/libstd/task.rs
+++ b/src/libstd/task.rs
@@ -447,6 +447,7 @@ mod test {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_with_wrapper() {
         let (tx, rx) = channel();
         TaskBuilder::new().with_wrapper(proc(body) {
diff --git a/src/libsync/comm/duplex.rs b/src/libsync/comm/duplex.rs
index 587827d2bc57..1dc1f4b87f27 100644
--- a/src/libsync/comm/duplex.rs
+++ b/src/libsync/comm/duplex.rs
@@ -59,10 +59,11 @@ impl<S:Send,R:Send> DuplexStream<S, R> {
     }
 }
 
+#[allow(deprecated)]
 #[cfg(test)]
 mod test {
     use std::prelude::*;
-    use comm::{duplex};
+    use comm::duplex;
 
     #[test]
     pub fn duplex_stream_1() {
diff --git a/src/libsync/deque.rs b/src/libsync/deque.rs
index 338816293298..09fa8920a07d 100644
--- a/src/libsync/deque.rs
+++ b/src/libsync/deque.rs
@@ -553,14 +553,12 @@ mod tests {
         let threads = range(0, NTHREADS).map(|_| {
             let s = s.clone();
             Thread::start(proc() {
-                unsafe {
-                    loop {
-                        match s.steal() {
-                            Data(2) => { HITS.fetch_add(1, SeqCst); }
-                            Data(..) => fail!(),
-                            _ if DONE.load(SeqCst) => break,
-                            _ => {}
-                        }
+                loop {
+                    match s.steal() {
+                        Data(2) => { HITS.fetch_add(1, SeqCst); }
+                        Data(..) => fail!(),
+                        _ if DONE.load(SeqCst) => break,
+                        _ => {}
                     }
                 }
             })
@@ -572,7 +570,7 @@ mod tests {
             if rng.gen_range(0i, 3) == 2 {
                 match w.pop() {
                     None => {}
-                    Some(2) => unsafe { HITS.fetch_add(1, SeqCst); },
+                    Some(2) => { HITS.fetch_add(1, SeqCst); },
                     Some(_) => fail!(),
                 }
             } else {
@@ -581,22 +579,20 @@ mod tests {
             }
         }
 
-        unsafe {
-            while HITS.load(SeqCst) < AMT as uint {
-                match w.pop() {
-                    None => {}
-                    Some(2) => { HITS.fetch_add(1, SeqCst); },
-                    Some(_) => fail!(),
-                }
+        while HITS.load(SeqCst) < AMT as uint {
+            match w.pop() {
+                None => {}
+                Some(2) => { HITS.fetch_add(1, SeqCst); },
+                Some(_) => fail!(),
             }
-            DONE.store(true, SeqCst);
         }
+        DONE.store(true, SeqCst);
 
         for thread in threads.into_iter() {
             thread.join();
         }
 
-        assert_eq!(unsafe { HITS.load(SeqCst) }, expected as uint);
+        assert_eq!(HITS.load(SeqCst), expected as uint);
     }
 
     #[test]
@@ -655,7 +651,7 @@ mod tests {
             }
         }
 
-        unsafe { DONE.store(true, SeqCst); }
+        DONE.store(true, SeqCst);
 
         for thread in threads.into_iter() {
             thread.join();
diff --git a/src/libsync/mutex.rs b/src/libsync/mutex.rs
index 9861d27c8cdf..796c62354c31 100644
--- a/src/libsync/mutex.rs
+++ b/src/libsync/mutex.rs
@@ -536,32 +536,32 @@ mod test {
 
     #[test]
     fn smoke_static() {
-        static m: StaticMutex = MUTEX_INIT;
+        static M: StaticMutex = MUTEX_INIT;
         unsafe {
-            drop(m.lock());
-            drop(m.lock());
-            m.destroy();
+            drop(M.lock());
+            drop(M.lock());
+            M.destroy();
         }
     }
 
     #[test]
     fn lots_and_lots() {
-        static m: StaticMutex = MUTEX_INIT;
+        static M: StaticMutex = MUTEX_INIT;
         static mut CNT: uint = 0;
-        static M: uint = 1000;
-        static N: uint = 3;
+        static J: uint = 1000;
+        static K: uint = 3;
 
         fn inc() {
-            for _ in range(0, M) {
+            for _ in range(0, J) {
                 unsafe {
-                    let _g = m.lock();
+                    let _g = M.lock();
                     CNT += 1;
                 }
             }
         }
 
         let (tx, rx) = channel();
-        for _ in range(0, N) {
+        for _ in range(0, K) {
             let tx2 = tx.clone();
             native::task::spawn(proc() { inc(); tx2.send(()); });
             let tx2 = tx.clone();
@@ -569,12 +569,12 @@ mod test {
         }
 
         drop(tx);
-        for _ in range(0, 2 * N) {
+        for _ in range(0, 2 * K) {
             rx.recv();
         }
-        assert_eq!(unsafe {CNT}, M * N * 2);
+        assert_eq!(unsafe {CNT}, J * K * 2);
         unsafe {
-            m.destroy();
+            M.destroy();
         }
     }
 
diff --git a/src/libsync/one.rs b/src/libsync/one.rs
index f0c72780be10..62b376609122 100644
--- a/src/libsync/one.rs
+++ b/src/libsync/one.rs
@@ -126,17 +126,17 @@ mod test {
 
     #[test]
     fn smoke_once() {
-        static o: Once = ONCE_INIT;
+        static O: Once = ONCE_INIT;
         let mut a = 0i;
-        o.doit(|| a += 1);
+        O.doit(|| a += 1);
         assert_eq!(a, 1);
-        o.doit(|| a += 1);
+        O.doit(|| a += 1);
         assert_eq!(a, 1);
     }
 
     #[test]
     fn stampede_once() {
-        static o: Once = ONCE_INIT;
+        static O: Once = ONCE_INIT;
         static mut run: bool = false;
 
         let (tx, rx) = channel();
@@ -145,7 +145,7 @@ mod test {
             spawn(proc() {
                 for _ in range(0u, 4) { task::deschedule() }
                 unsafe {
-                    o.doit(|| {
+                    O.doit(|| {
                         assert!(!run);
                         run = true;
                     });
@@ -156,7 +156,7 @@ mod test {
         }
 
         unsafe {
-            o.doit(|| {
+            O.doit(|| {
                 assert!(!run);
                 run = true;
             });
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index bf4734529a29..c1aa588eecc4 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -1333,6 +1333,7 @@ impl Item_ {
     pub fn descriptive_variant(&self) -> &str {
         match *self {
             ItemStatic(..) => "static item",
+            ItemConst(..) => "constant item",
             ItemFn(..) => "function",
             ItemMod(..) => "module",
             ItemForeignMod(..) => "foreign module",
@@ -1340,7 +1341,8 @@ impl Item_ {
             ItemEnum(..) => "enum",
             ItemStruct(..) => "struct",
             ItemTrait(..) => "trait",
-            _ => "item"
+            ItemMac(..) |
+            ItemImpl(..) => "item"
         }
     }
 }
diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs
index 736cacbdeb78..a1bce6e8e8b0 100644
--- a/src/libterm/terminfo/parm.rs
+++ b/src/libterm/terminfo/parm.rs
@@ -575,7 +575,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,String> {
 
 #[cfg(test)]
 mod test {
-    use super::{expand,Words,Variables,Number};
+    use super::{expand,Param,Words,Variables,Number};
     use std::result::Ok;
 
     #[test]
@@ -605,40 +605,39 @@ mod test {
     fn test_param_stack_failure_conditions() {
         let mut varstruct = Variables::new();
         let vars = &mut varstruct;
+        fn get_res(fmt: &str, cap: &str, params: &[Param], vars: &mut Variables) ->
+            Result<Vec<u8>, String>
+        {
+            let mut u8v: Vec<_> = fmt.bytes().collect();
+            u8v.extend(cap.as_bytes().iter().map(|&b| b));
+            expand(u8v.as_slice(), params, vars)
+        }
+
         let caps = ["%d", "%c", "%s", "%Pa", "%l", "%!", "%~"];
-        for cap in caps.iter() {
-            let res = expand(cap.as_bytes(), [], vars);
+        for &cap in caps.iter() {
+            let res = get_res("", cap, [], vars);
             assert!(res.is_err(),
-                    "Op {} succeeded incorrectly with 0 stack entries", *cap);
-            let p = if *cap == "%s" || *cap == "%l" {
+                    "Op {} succeeded incorrectly with 0 stack entries", cap);
+            let p = if cap == "%s" || cap == "%l" {
                 Words("foo".to_string())
             } else {
                 Number(97)
             };
-            let res = expand("%p1".bytes().collect::<Vec<_>>()
-                             .append(cap.as_bytes()).as_slice(),
-                             [p],
-                             vars);
+            let res = get_res("%p1", cap, [p], vars);
             assert!(res.is_ok(),
-                    "Op {} failed with 1 stack entry: {}", *cap, res.unwrap_err());
+                    "Op {} failed with 1 stack entry: {}", cap, res.unwrap_err());
         }
         let caps = ["%+", "%-", "%*", "%/", "%m", "%&", "%|", "%A", "%O"];
-        for cap in caps.iter() {
+        for &cap in caps.iter() {
             let res = expand(cap.as_bytes(), [], vars);
             assert!(res.is_err(),
-                    "Binop {} succeeded incorrectly with 0 stack entries", *cap);
-            let res = expand("%{1}".bytes().collect::<Vec<_>>()
-                             .append(cap.as_bytes()).as_slice(),
-                              [],
-                              vars);
+                    "Binop {} succeeded incorrectly with 0 stack entries", cap);
+            let res = get_res("%{1}", cap, [], vars);
             assert!(res.is_err(),
-                    "Binop {} succeeded incorrectly with 1 stack entry", *cap);
-            let res = expand("%{1}%{2}".bytes().collect::<Vec<_>>()
-                             .append(cap.as_bytes()).as_slice(),
-                             [],
-                             vars);
+                    "Binop {} succeeded incorrectly with 1 stack entry", cap);
+            let res = get_res("%{1}%{2}", cap, [], vars);
             assert!(res.is_ok(),
-                    "Binop {} failed with 2 stack entries: {}", *cap, res.unwrap_err());
+                    "Binop {} failed with 2 stack entries: {}", cap, res.unwrap_err());
         }
     }
 
diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs
index 2918bad03df2..b84aec77a09c 100644
--- a/src/libunicode/lib.rs
+++ b/src/libunicode/lib.rs
@@ -64,6 +64,7 @@ pub mod char {
     pub use normalize::{decompose_canonical, decompose_compatible, compose};
 
     pub use tables::normalization::canonical_combining_class;
+    pub use tables::UNICODE_VERSION;
 
     pub use u_char::{is_alphabetic, is_XID_start, is_XID_continue};
     pub use u_char::{is_lowercase, is_uppercase, is_whitespace};
diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs
index e359883295f4..3f15abcad6dc 100644
--- a/src/libunicode/tables.rs
+++ b/src/libunicode/tables.rs
@@ -12,6 +12,10 @@
 
 #![allow(missing_doc, non_uppercase_statics, non_snake_case)]
 
+/// The version of [Unicode](http://www.unicode.org/)
+/// that the `UnicodeChar` and `UnicodeStrSlice` traits are based on.
+pub const UNICODE_VERSION: (uint, uint, uint) = (7, 0, 0);
+
 fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
     use core::cmp::{Equal, Less, Greater};
     use core::slice::ImmutableSlice;
diff --git a/src/test/compile-fail/empty-extern-arg.rs b/src/test/compile-fail/empty-extern-arg.rs
new file mode 100644
index 000000000000..9b7df81a5dcb
--- /dev/null
+++ b/src/test/compile-fail/empty-extern-arg.rs
@@ -0,0 +1,14 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: --extern std=
+// error-pattern: is not a file
+
+fn main() {}
diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs
new file mode 100644
index 000000000000..ef8174a26aa8
--- /dev/null
+++ b/src/test/compile-fail/issue-17651.rs
@@ -0,0 +1,17 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test that moves of unsized values within closures are caught
+// and rejected.
+
+fn main() {
+    (|| box *[0u].as_slice())();
+    //~^ ERROR cannot move a value of type [uint]
+}
diff --git a/src/test/compile-fail/issue-17718-const-naming.rs b/src/test/compile-fail/issue-17718-const-naming.rs
index 046f038847b7..0cfee6daf3f1 100644
--- a/src/test/compile-fail/issue-17718-const-naming.rs
+++ b/src/test/compile-fail/issue-17718-const-naming.rs
@@ -12,5 +12,6 @@
 
 const foo: int = 3;
 //~^ ERROR: should have an uppercase name such as
+//~^^ ERROR: constant item is never used
 
 fn main() {}
diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs
index a4320b8dc775..96d40c52657f 100644
--- a/src/test/compile-fail/lint-dead-code-1.rs
+++ b/src/test/compile-fail/lint-dead-code-1.rs
@@ -35,6 +35,13 @@ pub static used_static2: int = used_static;
 const USED_STATIC: int = 0;
 const STATIC_USED_IN_ENUM_DISCRIMINANT: int = 10;
 
+pub const pub_const: int = 0;
+const priv_const: int = 0; //~ ERROR: constant item is never used
+const used_const: int = 0;
+pub const used_const2: int = used_const;
+const USED_CONST: int = 1;
+const CONST_USED_IN_ENUM_DISCRIMINANT: int = 11;
+
 pub type typ = *const UsedStruct4;
 pub struct PubStruct;
 struct PrivStruct; //~ ERROR: struct is never used
@@ -61,7 +68,10 @@ pub struct PubStruct2 {
 
 pub enum pub_enum { foo1, bar1 }
 pub enum pub_enum2 { a(*const StructUsedInEnum) }
-pub enum pub_enum3 { Foo = STATIC_USED_IN_ENUM_DISCRIMINANT }
+pub enum pub_enum3 {
+    Foo = STATIC_USED_IN_ENUM_DISCRIMINANT,
+    Bar = CONST_USED_IN_ENUM_DISCRIMINANT,
+}
 
 enum priv_enum { foo2, bar2 } //~ ERROR: enum is never used
 enum used_enum {
@@ -82,6 +92,7 @@ pub fn pub_fn() {
     let i = 1i;
     match i {
         USED_STATIC => (),
+        USED_CONST => (),
         _ => ()
     }
     f::<StructUsedInGeneric>();
diff --git a/src/test/run-pass/lang-item-public.rs b/src/test/run-pass/lang-item-public.rs
index abd5f8326b07..982d4f6a0b56 100644
--- a/src/test/run-pass/lang-item-public.rs
+++ b/src/test/run-pass/lang-item-public.rs
@@ -28,6 +28,10 @@ extern {}
 #[link(name = "execinfo")]
 extern {}
 
+#[cfg(target_os = "freebsd")]
+#[link(name = "c")]
+extern {}
+
 #[cfg(target_os = "dragonfly")]
 #[link(name = "c")]
 extern {}