From a5dcbc66db50f338617cb4149c1f8a5cf6b1633c Mon Sep 17 00:00:00 2001
From: Tobias Bucher <tobiasbucher5991@gmail.com>
Date: Tue, 15 Apr 2014 09:56:21 +0200
Subject: Remove RUST_LOG="::help" from the docs

This feature is no longer present in the current version, it was removed along
with the crate map.
---
 src/doc/complement-lang-faq.md | 12 +++++++++---
 src/doc/rust.md                |  4 ----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/doc/complement-lang-faq.md b/src/doc/complement-lang-faq.md
index 3053c90217f..4b29a9559de 100644
--- a/src/doc/complement-lang-faq.md
+++ b/src/doc/complement-lang-faq.md
@@ -141,8 +141,14 @@ export RUST_LOG=hello
 ./hello
 ```
 
-**Long answer** RUST_LOG takes a 'logging spec' that consists of a comma-separated list of paths, where a path consists of the crate name and sequence of module names, each separated by double-colons. For standalone .rs files the crate is implicitly named after the source file, so in the above example we were setting RUST_LOG to the name of the hello crate. Multiple paths can be combined to control the exact logging you want to see. For example, when debugging linking in the compiler you might set `RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath`
-
-If you aren't sure which paths you need, try setting RUST_LOG to `::help` and running your program. This will print a list of paths available for logging. For a full description see [the language reference][1].
+**Long answer** RUST_LOG takes a 'logging spec' that consists of a
+comma-separated list of paths, where a path consists of the crate name and
+sequence of module names, each separated by double-colons. For standalone .rs
+files the crate is implicitly named after the source file, so in the above
+example we were setting RUST_LOG to the name of the hello crate. Multiple paths
+can be combined to control the exact logging you want to see. For example, when
+debugging linking in the compiler you might set
+`RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath`
+For a full description see [the language reference][1].
 
 [1]:http://doc.rust-lang.org/doc/master/rust.html#logging-system
diff --git a/src/doc/rust.md b/src/doc/rust.md
index f2df445a5a2..3ed76eeff98 100644
--- a/src/doc/rust.md
+++ b/src/doc/rust.md
@@ -4056,10 +4056,6 @@ crate name the crate is given a default name that matches the source file,
 with the extension removed. In that case, to turn on logging for a program
 compiled from, e.g. `helloworld.rs`, `RUST_LOG` should be set to `helloworld`.
 
-As a convenience, the logging spec can also be set to a special pseudo-crate,
-`::help`. In this case, when the application starts, the runtime will
-simply output a list of loaded modules containing log expressions, then exit.
-
 #### Logging Expressions
 
 Rust provides several macros to log information. Here's a simple Rust program
-- 
cgit 1.4.1-3-g733a5


From 8f3c2a6ffdd578eb0213c365fa75e9622167d63e Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Fri, 11 Apr 2014 18:20:10 -0700
Subject: dist: Make Windows installer uninstall first. Closes #9563

This will remove existing files before installing new ones. Note
that I took some code with no license from stackoverflow, as
indicated in comments.
---
 mk/dist.mk              |  2 +-
 src/etc/pkg/modpath.iss |  2 +-
 src/etc/pkg/rust.iss    | 13 ++++++++++-
 src/etc/pkg/upgrade.iss | 61 +++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 75 insertions(+), 3 deletions(-)
 create mode 100644 src/etc/pkg/upgrade.iss

diff --git a/mk/dist.mk b/mk/dist.mk
index b96d5bee3af..b14c6f279ef 100644
--- a/mk/dist.mk
+++ b/mk/dist.mk
@@ -118,7 +118,7 @@ PKG_EXE = dist/$(PKG_NAME)-install.exe
 %.ico: $(S)src/etc/pkg/%.ico
 	cp $< $@
 
-$(PKG_EXE): rust.iss modpath.iss LICENSE.txt rust-logo.ico \
+$(PKG_EXE): rust.iss modpath.iss upgrade.iss LICENSE.txt rust-logo.ico \
             $(CSREQ3_T_$(CFG_BUILD)_H_$(CFG_BUILD)) \
             dist-prepare-win
 	$(CFG_PYTHON) $(S)src/etc/copy-runtime-deps.py tmp/dist/win/bin
diff --git a/src/etc/pkg/modpath.iss b/src/etc/pkg/modpath.iss
index c0b4475ad05..35cc0097035 100644
--- a/src/etc/pkg/modpath.iss
+++ b/src/etc/pkg/modpath.iss
@@ -164,7 +164,7 @@ begin
 end;
 
 
-procedure CurStepChanged(CurStep: TSetupStep);
+procedure ModPathCurStepChanged(CurStep: TSetupStep);
 var
 	taskname:	String;
 begin
diff --git a/src/etc/pkg/rust.iss b/src/etc/pkg/rust.iss
index 66bb71527fe..053fe34952c 100644
--- a/src/etc/pkg/rust.iss
+++ b/src/etc/pkg/rust.iss
@@ -49,4 +49,15 @@ begin
 	setArrayLength(Result, 1)
 	Result[0] := ExpandConstant('{app}\bin');
 end;
-#include "modpath.iss"
\ No newline at end of file
+
+#include "modpath.iss"
+#include "upgrade.iss"
+
+// Both modpath.iss and upgrade.iss want to overload CurStepChanged.
+// This version does the overload then delegates to each.
+
+procedure CurStepChanged(CurStep: TSetupStep);
+begin
+  UpgradeCurStepChanged(CurStep);
+  ModPathCurStepChanged(CurStep);
+end;
diff --git a/src/etc/pkg/upgrade.iss b/src/etc/pkg/upgrade.iss
new file mode 100644
index 00000000000..1d36be57649
--- /dev/null
+++ b/src/etc/pkg/upgrade.iss
@@ -0,0 +1,61 @@
+// The following code taken from https://stackoverflow.com/questions/2000296/innosetup-how-to-automatically-uninstall-previous-installed-version
+// It performs upgrades by running the uninstaller before the install
+
+/////////////////////////////////////////////////////////////////////
+function GetUninstallString(): String;
+var
+  sUnInstPath: String;
+  sUnInstallString: String;
+begin
+  sUnInstPath := ExpandConstant('Software\Microsoft\Windows\CurrentVersion\Uninstall\Rust_is1');
+  sUnInstallString := '';
+  if not RegQueryStringValue(HKLM, sUnInstPath, 'UninstallString', sUnInstallString) then
+    RegQueryStringValue(HKCU, sUnInstPath, 'UninstallString', sUnInstallString);
+  Result := sUnInstallString;
+end;
+
+
+/////////////////////////////////////////////////////////////////////
+function IsUpgrade(): Boolean;
+begin
+  Result := (GetUninstallString() <> '');
+end;
+
+
+/////////////////////////////////////////////////////////////////////
+function UnInstallOldVersion(): Integer;
+var
+  sUnInstallString: String;
+  iResultCode: Integer;
+begin
+// Return Values:
+// 1 - uninstall string is empty
+// 2 - error executing the UnInstallString
+// 3 - successfully executed the UnInstallString
+
+  // default return value
+  Result := 0;
+
+  // get the uninstall string of the old app
+  sUnInstallString := GetUninstallString();
+  if sUnInstallString <> '' then begin
+    sUnInstallString := RemoveQuotes(sUnInstallString);
+    if Exec(sUnInstallString, '/SILENT /NORESTART /SUPPRESSMSGBOXES','', SW_HIDE, ewWaitUntilTerminated, iResultCode) then
+      Result := 3
+    else
+      Result := 2;
+  end else
+    Result := 1;
+end;
+
+/////////////////////////////////////////////////////////////////////
+procedure UpgradeCurStepChanged(CurStep: TSetupStep);
+begin
+  if (CurStep=ssInstall) then
+  begin
+    if (IsUpgrade()) then
+    begin
+      UnInstallOldVersion();
+    end;
+  end;
+end;
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From efc285b7e61e36e0bc9a3399a52c88966ada32f0 Mon Sep 17 00:00:00 2001
From: Tobias Bucher <tobiasbucher5991@gmail.com>
Date: Mon, 14 Apr 2014 23:55:40 +0200
Subject: Change AUTHORS section in the man pages

The man pages no longer contain Graydon Hoare as the project lead.

Fix #13509.
---
 man/rustc.1   | 3 +--
 man/rustdoc.1 | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/man/rustc.1 b/man/rustc.1
index 8fc6828ced1..41ca56f2aba 100644
--- a/man/rustc.1
+++ b/man/rustc.1
@@ -182,8 +182,7 @@ rustdoc
 See <\fBhttps://github.com/mozilla/rust/issues\fR> for issues.
 
 .SH "AUTHOR"
-See \fBAUTHORS.txt\fR in the rust source distribution. Graydon Hoare
-<\fIgraydon@mozilla.com\fR> is the project leader.
+See \fBAUTHORS.txt\fR in the Rust source distribution.
 
 .SH "COPYRIGHT"
 This work is dual-licensed under Apache 2.0 and MIT terms.  See \fBCOPYRIGHT\fR
diff --git a/man/rustdoc.1 b/man/rustdoc.1
index bf0b6a95187..04eab3e382c 100644
--- a/man/rustdoc.1
+++ b/man/rustdoc.1
@@ -90,8 +90,7 @@ rustc
 See <\fBhttps://github.com/mozilla/rust/issues\fR> for issues.
 
 .SH "AUTHOR"
-See \fBAUTHORS.txt\fR in the rust source distribution. Graydon Hoare
-<\fIgraydon@mozilla.com\fR> is the project leader.
+See \fBAUTHORS.txt\fR in the Rust source distribution.
 
 .SH "COPYRIGHT"
 This work is dual-licensed under Apache 2.0 and MIT terms.  See \fBCOPYRIGHT\fR
-- 
cgit 1.4.1-3-g733a5


From ca5babea5f12ed57365740c959b4f3c7316474a7 Mon Sep 17 00:00:00 2001
From: Mihnea Dobrescu-Balaur <mihnea@linux.com>
Date: Mon, 14 Apr 2014 23:03:33 +0200
Subject: Update GitHub's Rust projects page.

---
 src/doc/complement-lang-faq.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/complement-lang-faq.md b/src/doc/complement-lang-faq.md
index 4b29a9559de..6f3982d94df 100644
--- a/src/doc/complement-lang-faq.md
+++ b/src/doc/complement-lang-faq.md
@@ -27,7 +27,7 @@ Some examples that demonstrate different aspects of the language:
 
 You may also be interested in browsing [GitHub's Rust][github-rust] page.
 
-[github-rust]: https://github.com/languages/Rust
+[github-rust]: https://github.com/trending?l=rust
 
 ## Does it run on Windows?
 
-- 
cgit 1.4.1-3-g733a5


From efec34a95a76212b2324d98f3f6d94a1397c2544 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 14 Apr 2014 13:42:45 -0700
Subject: mk: Change windows to install from stage2

In the past, windows was installed from stage3 to guarantee convergence between
the host and target artifacts, but syntax extensions on all platforms are
currently relying on convergence, so special casing this one platform has become
less relevant over time.

This will also have the added benefit of dealing with #13474 and #13491. These
issues will be closed after next next nightly is confirmed to fix them.
---
 mk/prepare.mk | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/mk/prepare.mk b/mk/prepare.mk
index d850aba27cd..096887056bf 100644
--- a/mk/prepare.mk
+++ b/mk/prepare.mk
@@ -20,13 +20,7 @@
 #   PREPARE_TARGETS - the target triples, space separated
 #   PREPARE_DEST_DIR - the directory to put the image
 
-
-# On windows we install from stage3, but on unix only stage2
-ifdef CFG_WINDOWSY_$(CFG_BUILD)
-PREPARE_STAGE=3
-else
 PREPARE_STAGE=2
-endif
 
 DEFAULT_PREPARE_DIR_CMD = umask 022 && mkdir -p
 DEFAULT_PREPARE_BIN_CMD = install -m755
-- 
cgit 1.4.1-3-g733a5


From ea5d9088ad36d08671a5ac77697e9ba7f4340b1a Mon Sep 17 00:00:00 2001
From: Chris Shea <cmshea@gmail.com>
Date: Mon, 14 Apr 2014 15:48:30 -0400
Subject: liburl doc: insert missing hyphen

---
 src/liburl/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/liburl/lib.rs b/src/liburl/lib.rs
index 1ea67f2bee1..0d9ee2512cc 100644
--- a/src/liburl/lib.rs
+++ b/src/liburl/lib.rs
@@ -194,7 +194,7 @@ pub fn encode(s: &str) -> ~str {
 }
 
 /**
- * Encodes a URI component by replacing reserved characters with percent
+ * Encodes a URI component by replacing reserved characters with percent-
  * encoded character sequences.
  *
  * This function is compliant with RFC 3986.
-- 
cgit 1.4.1-3-g733a5


From 326f938730c1eaae48ed333907dce2cc92dc9aab Mon Sep 17 00:00:00 2001
From: Kang Seonghoon <public+git@mearie.org>
Date: Tue, 15 Apr 2014 03:39:59 +0900
Subject: rustdoc: Better sorting criteria for searching.

This essentially rewrites the sorting algorithm, which relied on
the implementation-defined handling of non-consistent sorting function
(cf. ECMA-262 5th edition, section 15.4.4.11)
and was also a bit inefficient.

The new criteria expands the prior criteria while adding these ones:

- The current crate is always preferred over other crates.
  (Closes #13178)
- An item with a description is preferred over one without it,
  if item names match. This is a heuristic assuming that
  the documented item is more likely to be relevant.
- An item with no literal occurrence of search query is handled correctly.
---
 src/librustdoc/html/static/main.js | 103 +++++++++++++++++++------------------
 1 file changed, 52 insertions(+), 51 deletions(-)

diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js
index 4b79ae89eef..e975fac6ed7 100644
--- a/src/librustdoc/html/static/main.js
+++ b/src/librustdoc/html/static/main.js
@@ -189,67 +189,68 @@
             for (var i = 0; i < nresults; i += 1) {
                 results[i].word = searchWords[results[i].id];
                 results[i].item = searchIndex[results[i].id] || {};
-                results[i].ty = results[i].item.ty;
-                results[i].path = results[i].item.path;
             }
             // if there are no results then return to default and fail
             if (results.length === 0) {
                 return [];
             }
 
-            // sort by exact match
-            results.sort(function search_complete_sort0(aaa, bbb) {
-                if (aaa.word === valLower &&
-                    bbb.word !== valLower) {
-                    return 1;
-                }
-            });
-            // first sorting attempt
-            // sort by item name length
-            results.sort(function search_complete_sort1(aaa, bbb) {
-                if (aaa.word.length > bbb.word.length) {
-                    return 1;
-                }
+            results.sort(function(aaa, bbb) {
+                var a, b;
+
+                // sort by crate (non-current crate goes later)
+                a = (aaa.item.crate !== window.currentCrate);
+                b = (bbb.item.crate !== window.currentCrate);
+                if (a !== b) return a - b;
+
+                // sort by exact match (mismatch goes later)
+                a = (aaa.word !== valLower);
+                b = (bbb.word !== valLower);
+                if (a !== b) return a - b;
+
+                // sort by item name length (longer goes later)
+                a = aaa.word.length;
+                b = bbb.word.length;
+                if (a !== b) return a - b;
+
+                // sort by item name (lexicographically larger goes later)
+                a = aaa.word;
+                b = bbb.word;
+                if (a !== b) return (a > b ? +1 : -1);
+
+                // sort by index of keyword in item name (no literal occurrence goes later)
+                a = (aaa.index < 0);
+                b = (bbb.index < 0);
+                if (a !== b) return a - b;
+                // (later literal occurrence, if any, goes later)
+                a = aaa.index;
+                b = bbb.index;
+                if (a !== b) return a - b;
+
+                // sort by description (no description goes later)
+                a = (aaa.item.desc === '');
+                b = (bbb.item.desc === '');
+                if (a !== b) return a - b;
+
+                // sort by type (later occurrence in `itemTypes` goes later)
+                a = aaa.item.ty;
+                b = bbb.item.ty;
+                if (a !== b) return a - b;
+
+                // sort by path (lexicographically larger goes later)
+                a = aaa.item.path;
+                b = bbb.item.path;
+                if (a !== b) return (a > b ? +1 : -1);
+
+                // que sera, sera
+                return 0;
             });
-            // second sorting attempt
-            // sort by item name
-            results.sort(function search_complete_sort1(aaa, bbb) {
-                if (aaa.word.length === bbb.word.length &&
-                    aaa.word > bbb.word) {
-                    return 1;
-                }
-            });
-            // third sorting attempt
-            // sort by index of keyword in item name
-            if (results[0].index !== -1) {
-                results.sort(function search_complete_sort1(aaa, bbb) {
-                    if (aaa.index > bbb.index && bbb.index === 0) {
-                        return 1;
-                    }
-                });
-            }
-            // fourth sorting attempt
-            // sort by type
-            results.sort(function search_complete_sort3(aaa, bbb) {
-                if (aaa.word === bbb.word &&
-                    aaa.ty > bbb.ty) {
-                    return 1;
-                }
-            });
-            // fifth sorting attempt
-            // sort by path
-            results.sort(function search_complete_sort4(aaa, bbb) {
-                if (aaa.word === bbb.word &&
-                    aaa.ty === bbb.ty && aaa.path > bbb.path) {
-                    return 1;
-                }
-            });
-            // sixth sorting attempt
+
             // remove duplicates, according to the data provided
             for (var i = results.length - 1; i > 0; i -= 1) {
                 if (results[i].word === results[i - 1].word &&
-                    results[i].ty === results[i - 1].ty &&
-                    results[i].path === results[i - 1].path)
+                    results[i].item.ty === results[i - 1].item.ty &&
+                    results[i].item.path === results[i - 1].item.path)
                 {
                     results[i].id = -1;
                 }
-- 
cgit 1.4.1-3-g733a5


From c836ff46215b743c0f681d3e4d799cde1832cde3 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Sun, 13 Apr 2014 14:39:04 -0700
Subject: std: Impl Deref/DerefMut for a borrowed task

---
 src/libstd/io/stdio.rs      |  6 ++----
 src/libstd/rt/local_heap.rs |  3 +--
 src/libstd/rt/local_ptr.rs  | 18 ++++++++++--------
 src/libstd/rt/task.rs       | 10 ++++------
 src/libstd/task.rs          |  9 +++------
 5 files changed, 20 insertions(+), 26 deletions(-)

diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 5f47e227901..34a57884398 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -160,7 +160,7 @@ fn reset_helper(w: ~Writer:Send,
 {
     let mut t = Local::borrow(None::<Task>);
     // Be sure to flush any pending output from the writer
-    match f(t.get(), w) {
+    match f(&mut *t, w) {
         Some(mut w) => {
             drop(t);
             // FIXME: is failing right here?
@@ -230,9 +230,7 @@ fn with_task_stdout(f: |&mut Writer| -> IoResult<()> ) {
             // To protect against this, we do a little dance in which we
             // temporarily take the task, swap the handles, put the task in TLS,
             // and only then drop the previous handle.
-            let mut t = Local::borrow(None::<Task>);
-            let prev = replace(&mut t.get().stdout, my_stdout);
-            drop(t);
+            let prev = replace(&mut Local::borrow(None::<Task>).stdout, my_stdout);
             drop(prev);
             ret
         }
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index b9d0d829374..caf0d9028c5 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -319,8 +319,7 @@ pub unsafe fn local_free(ptr: *u8) {
 }
 
 pub fn live_allocs() -> *mut Box {
-    let mut task = Local::borrow(None::<Task>);
-    task.get().heap.live_allocs
+    Local::borrow(None::<Task>).heap.live_allocs
 }
 
 #[cfg(test)]
diff --git a/src/libstd/rt/local_ptr.rs b/src/libstd/rt/local_ptr.rs
index e3f64f40c0d..6b61af1d9a2 100644
--- a/src/libstd/rt/local_ptr.rs
+++ b/src/libstd/rt/local_ptr.rs
@@ -18,7 +18,7 @@
 #![allow(dead_code)]
 
 use cast;
-use ops::Drop;
+use ops::{Drop, Deref, DerefMut};
 use ptr::RawPtr;
 
 #[cfg(windows)]               // mingw-w32 doesn't like thread_local things
@@ -48,13 +48,15 @@ impl<T> Drop for Borrowed<T> {
     }
 }
 
-impl<T> Borrowed<T> {
-    pub fn get<'a>(&'a mut self) -> &'a mut T {
-        unsafe {
-            let val_ptr: &mut ~T = cast::transmute(&mut self.val);
-            let val_ptr: &'a mut T = *val_ptr;
-            val_ptr
-        }
+impl<T> Deref<T> for Borrowed<T> {
+    fn deref<'a>(&'a self) -> &'a T {
+        unsafe { &*(self.val as *T) }
+    }
+}
+
+impl<T> DerefMut<T> for Borrowed<T> {
+    fn deref_mut<'a>(&'a mut self) -> &'a mut T {
+        unsafe { &mut *(self.val as *mut T) }
     }
 }
 
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index a112ed77f09..a3664b45a41 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -127,8 +127,8 @@ impl Task {
                 #[allow(unused_must_use)]
                 fn close_outputs() {
                     let mut task = Local::borrow(None::<Task>);
-                    let stderr = task.get().stderr.take();
-                    let stdout = task.get().stdout.take();
+                    let stderr = task.stderr.take();
+                    let stdout = task.stdout.take();
                     drop(task);
                     match stdout { Some(mut w) => { w.flush(); }, None => {} }
                     match stderr { Some(mut w) => { w.flush(); }, None => {} }
@@ -159,8 +159,7 @@ impl Task {
                 // be intertwined, and miraculously work for now...
                 let mut task = Local::borrow(None::<Task>);
                 let storage_map = {
-                    let task = task.get();
-                    let LocalStorage(ref mut optmap) = task.storage;
+                    let &LocalStorage(ref mut optmap) = &mut task.storage;
                     optmap.take()
                 };
                 drop(task);
@@ -332,8 +331,7 @@ impl BlockedTask {
     }
 
     /// Converts one blocked task handle to a list of many handles to the same.
-    pub fn make_selectable(self, num_handles: uint) -> Take<BlockedTasks>
-    {
+    pub fn make_selectable(self, num_handles: uint) -> Take<BlockedTasks> {
         let arc = match self {
             Owned(task) => {
                 let flag = unsafe { AtomicUint::new(cast::transmute(task)) };
diff --git a/src/libstd/task.rs b/src/libstd/task.rs
index ed10f6d15cd..df627809ea0 100644
--- a/src/libstd/task.rs
+++ b/src/libstd/task.rs
@@ -257,8 +257,8 @@ pub fn try<T:Send>(f: proc():Send -> T) -> Result<T, ~Any:Send> {
 pub fn with_task_name<U>(blk: |Option<&str>| -> U) -> U {
     use rt::task::Task;
 
-    let mut task = Local::borrow(None::<Task>);
-    match task.get().name {
+    let task = Local::borrow(None::<Task>);
+    match task.name {
         Some(ref name) => blk(Some(name.as_slice())),
         None => blk(None)
     }
@@ -276,11 +276,8 @@ pub fn deschedule() {
 
 pub fn failing() -> bool {
     //! True if the running task has failed
-
     use rt::task::Task;
-
-    let mut local = Local::borrow(None::<Task>);
-    local.get().unwinder.unwinding()
+    Local::borrow(None::<Task>).unwinder.unwinding()
 }
 
 // The following 8 tests test the following 2^3 combinations:
-- 
cgit 1.4.1-3-g733a5


From 4ca7abb1c4c76b4a23024baacdb7a023692c1d2d Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 14 Apr 2014 07:05:37 -0700
Subject: native: Be more stringent about pattern matching

Trying to avoid a wildcard where possible.
---
 src/libnative/io/timer_unix.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libnative/io/timer_unix.rs b/src/libnative/io/timer_unix.rs
index 0444604d42a..0a38a6ff0be 100644
--- a/src/libnative/io/timer_unix.rs
+++ b/src/libnative/io/timer_unix.rs
@@ -182,7 +182,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
                             let t = active.remove(i).unwrap();
                             ack.send(t);
                         }
-                        _ => break
+                        Err(..) => break
                     }
                 }
 
-- 
cgit 1.4.1-3-g733a5


From 93dc55518840ee3cbd570c0d85aa7a445752af8b Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 14 Apr 2014 07:06:14 -0700
Subject: native: Fix a race in select()

During selection, libnative would erroneously re-acquire ownership of a task
when a separate thread still had ownership of the task. The loop in select()
was rewritten to acknowledge this race and instead block waiting to re-acquire
ownership rather than plowing through.

Closes #13494
---
 src/libnative/task.rs            | 29 ++++++++++++++-------
 src/test/run-pass/issue-13494.rs | 56 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+), 9 deletions(-)
 create mode 100644 src/test/run-pass/issue-13494.rs

diff --git a/src/libnative/task.rs b/src/libnative/task.rs
index ddfd46ecad9..8a82ae55faa 100644
--- a/src/libnative/task.rs
+++ b/src/libnative/task.rs
@@ -201,19 +201,30 @@ impl rt::Runtime for Ops {
                     Err(task) => { cast::forget(task.wake()); }
                 }
             } else {
-                let mut iter = task.make_selectable(times);
+                let iter = task.make_selectable(times);
                 let guard = (*me).lock.lock();
                 (*me).awoken = false;
-                let success = iter.all(|task| {
-                    match f(task) {
-                        Ok(()) => true,
-                        Err(task) => {
-                            cast::forget(task.wake());
-                            false
+
+                // Apply the given closure to all of the "selectable tasks",
+                // bailing on the first one that produces an error. Note that
+                // care must be taken such that when an error is occurred, we
+                // may not own the task, so we may still have to wait for the
+                // task to become available. In other words, if task.wake()
+                // returns `None`, then someone else has ownership and we must
+                // wait for their signal.
+                match iter.map(f).filter_map(|a| a.err()).next() {
+                    None => {}
+                    Some(task) => {
+                        match task.wake() {
+                            Some(task) => {
+                                cast::forget(task);
+                                (*me).awoken = true;
+                            }
+                            None => {}
                         }
                     }
-                });
-                while success && !(*me).awoken {
+                }
+                while !(*me).awoken {
                     guard.wait();
                 }
             }
diff --git a/src/test/run-pass/issue-13494.rs b/src/test/run-pass/issue-13494.rs
new file mode 100644
index 00000000000..84da2d814d9
--- /dev/null
+++ b/src/test/run-pass/issue-13494.rs
@@ -0,0 +1,56 @@
+// Copyright 2013-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.
+
+// This test may not always fail, but it can be flaky if the race it used to
+// expose is still present.
+
+extern crate green;
+extern crate rustuv;
+extern crate native;
+
+#[start]
+fn start(argc: int, argv: **u8) -> int {
+    green::start(argc, argv, rustuv::event_loop, main)
+}
+
+fn helper(rx: Receiver<Sender<()>>) {
+    for tx in rx.iter() {
+        let _ = tx.send_opt(());
+    }
+}
+
+fn test() {
+    let (tx, rx) = channel();
+    spawn(proc() { helper(rx) });
+    let (snd, rcv) = channel();
+    for _ in range(1, 100000) {
+        snd.send(1);
+        let (tx2, rx2) = channel();
+        tx.send(tx2);
+        select! {
+            () = rx2.recv() => (),
+            _ = rcv.recv() => ()
+        }
+    }
+}
+
+fn main() {
+    let (tx, rx) = channel();
+    spawn(proc() {
+        tx.send(test());
+    });
+    rx.recv();
+
+    let (tx, rx) = channel();
+    native::task::spawn(proc() {
+        tx.send(test());
+    });
+    rx.recv();
+}
-- 
cgit 1.4.1-3-g733a5


From 54ec04f1c12c7fb4dbe5f01fdeb73d1079fef53d Mon Sep 17 00:00:00 2001
From: Huon Wilson <dbau.pp+github@gmail.com>
Date: Mon, 14 Apr 2014 20:04:14 +1000
Subject: Use the unsigned integer types for bitwise intrinsics.

Exposing ctpop, ctlz, cttz and bswap as taking signed i8/i16/... is just
exposing the internal LLVM names pointlessly (LLVM doesn't have "signed
integers" or "unsigned integers", it just has sized integer types
with (un)signed *operations*).

These operations are semantically working with raw bytes, which the
unsigned types model better.
---
 src/libnative/io/net.rs                 |   4 +-
 src/librustc/middle/typeck/check/mod.rs |  30 ++---
 src/librustc/util/sha2.rs               |  10 +-
 src/librustuv/net.rs                    |   4 +-
 src/libserialize/ebml.rs                |   4 +-
 src/libstd/intrinsics.rs                |  60 +++++++---
 src/libstd/io/extensions.rs             |  14 +--
 src/libstd/mem.rs                       |  96 ++++++++--------
 src/libstd/num/i16.rs                   |   6 +-
 src/libstd/num/i32.rs                   |   6 +-
 src/libstd/num/i64.rs                   |   6 +-
 src/libstd/num/i8.rs                    |   6 +-
 src/libuuid/lib.rs                      |  12 +-
 src/test/bench/sudoku.rs                |   6 +-
 src/test/run-pass/intrinsics-integer.rs | 193 ++++++++++++++++----------------
 15 files changed, 238 insertions(+), 219 deletions(-)

diff --git a/src/libnative/io/net.rs b/src/libnative/io/net.rs
index cef6a247a00..2e64b82a84a 100644
--- a/src/libnative/io/net.rs
+++ b/src/libnative/io/net.rs
@@ -26,10 +26,10 @@ use super::{IoResult, retry, keep_going};
 #[cfg(unix)]    pub type sock_t = super::file::fd_t;
 
 pub fn htons(u: u16) -> u16 {
-    mem::to_be16(u as i16) as u16
+    mem::to_be16(u)
 }
 pub fn ntohs(u: u16) -> u16 {
-    mem::from_be16(u as i16) as u16
+    mem::from_be16(u)
 }
 
 enum InAddr {
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index fee510b82b7..cff8c149bb6 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -4143,21 +4143,21 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
             "nearbyintf64" => (0, vec!( ty::mk_f64() ), ty::mk_f64()),
             "roundf32"     => (0, vec!( ty::mk_f32() ), ty::mk_f32()),
             "roundf64"     => (0, vec!( ty::mk_f64() ), ty::mk_f64()),
-            "ctpop8"       => (0, vec!( ty::mk_i8()  ), ty::mk_i8()),
-            "ctpop16"      => (0, vec!( ty::mk_i16() ), ty::mk_i16()),
-            "ctpop32"      => (0, vec!( ty::mk_i32() ), ty::mk_i32()),
-            "ctpop64"      => (0, vec!( ty::mk_i64() ), ty::mk_i64()),
-            "ctlz8"        => (0, vec!( ty::mk_i8()  ), ty::mk_i8()),
-            "ctlz16"       => (0, vec!( ty::mk_i16() ), ty::mk_i16()),
-            "ctlz32"       => (0, vec!( ty::mk_i32() ), ty::mk_i32()),
-            "ctlz64"       => (0, vec!( ty::mk_i64() ), ty::mk_i64()),
-            "cttz8"        => (0, vec!( ty::mk_i8()  ), ty::mk_i8()),
-            "cttz16"       => (0, vec!( ty::mk_i16() ), ty::mk_i16()),
-            "cttz32"       => (0, vec!( ty::mk_i32() ), ty::mk_i32()),
-            "cttz64"       => (0, vec!( ty::mk_i64() ), ty::mk_i64()),
-            "bswap16"      => (0, vec!( ty::mk_i16() ), ty::mk_i16()),
-            "bswap32"      => (0, vec!( ty::mk_i32() ), ty::mk_i32()),
-            "bswap64"      => (0, vec!( ty::mk_i64() ), ty::mk_i64()),
+            "ctpop8"       => (0, vec!( ty::mk_u8()  ), ty::mk_u8()),
+            "ctpop16"      => (0, vec!( ty::mk_u16() ), ty::mk_u16()),
+            "ctpop32"      => (0, vec!( ty::mk_u32() ), ty::mk_u32()),
+            "ctpop64"      => (0, vec!( ty::mk_u64() ), ty::mk_u64()),
+            "ctlz8"        => (0, vec!( ty::mk_u8()  ), ty::mk_u8()),
+            "ctlz16"       => (0, vec!( ty::mk_u16() ), ty::mk_u16()),
+            "ctlz32"       => (0, vec!( ty::mk_u32() ), ty::mk_u32()),
+            "ctlz64"       => (0, vec!( ty::mk_u64() ), ty::mk_u64()),
+            "cttz8"        => (0, vec!( ty::mk_u8()  ), ty::mk_u8()),
+            "cttz16"       => (0, vec!( ty::mk_u16() ), ty::mk_u16()),
+            "cttz32"       => (0, vec!( ty::mk_u32() ), ty::mk_u32()),
+            "cttz64"       => (0, vec!( ty::mk_u64() ), ty::mk_u64()),
+            "bswap16"      => (0, vec!( ty::mk_u16() ), ty::mk_u16()),
+            "bswap32"      => (0, vec!( ty::mk_u32() ), ty::mk_u32()),
+            "bswap64"      => (0, vec!( ty::mk_u64() ), ty::mk_u64()),
 
             "volatile_load" =>
                 (1, vec!( ty::mk_imm_ptr(tcx, param(ccx, 0)) ), param(ccx, 0)),
diff --git a/src/librustc/util/sha2.rs b/src/librustc/util/sha2.rs
index 17ea4d6b0b4..4571e6328cf 100644
--- a/src/librustc/util/sha2.rs
+++ b/src/librustc/util/sha2.rs
@@ -20,23 +20,21 @@ use serialize::hex::ToHex;
 /// Write a u32 into a vector, which must be 4 bytes long. The value is written in big-endian
 /// format.
 fn write_u32_be(dst: &mut[u8], input: u32) {
-    use std::cast::transmute;
     use std::mem::to_be32;
     assert!(dst.len() == 4);
     unsafe {
-        let x: *mut i32 = transmute(dst.unsafe_mut_ref(0));
-        *x = to_be32(input as i32);
+        let x = dst.unsafe_mut_ref(0) as *mut _ as *mut u32;
+        *x = to_be32(input);
     }
 }
 
 /// Read a vector of bytes into a vector of u32s. The values are read in big-endian format.
 fn read_u32v_be(dst: &mut[u32], input: &[u8]) {
-    use std::cast::transmute;
     use std::mem::to_be32;
     assert!(dst.len() * 4 == input.len());
     unsafe {
-        let mut x: *mut i32 = transmute(dst.unsafe_mut_ref(0));
-        let mut y: *i32 = transmute(input.unsafe_ref(0));
+        let mut x = dst.unsafe_mut_ref(0) as *mut _ as *mut u32;
+        let mut y = input.unsafe_ref(0) as *_ as *u32;
         for _ in range(0, dst.len()) {
             *x = to_be32(*y);
             x = x.offset(1);
diff --git a/src/librustuv/net.rs b/src/librustuv/net.rs
index b893f5f693f..280cd4bd592 100644
--- a/src/librustuv/net.rs
+++ b/src/librustuv/net.rs
@@ -32,8 +32,8 @@ use uvll;
 /// Generic functions related to dealing with sockaddr things
 ////////////////////////////////////////////////////////////////////////////////
 
-pub fn htons(u: u16) -> u16 { mem::to_be16(u as i16) as u16 }
-pub fn ntohs(u: u16) -> u16 { mem::from_be16(u as i16) as u16 }
+pub fn htons(u: u16) -> u16 { mem::to_be16(u) }
+pub fn ntohs(u: u16) -> u16 { mem::from_be16(u) }
 
 pub fn sockaddr_to_addr(storage: &libc::sockaddr_storage,
                         len: uint) -> ip::SocketAddr {
diff --git a/src/libserialize/ebml.rs b/src/libserialize/ebml.rs
index 9b2df307b99..0efa93011fc 100644
--- a/src/libserialize/ebml.rs
+++ b/src/libserialize/ebml.rs
@@ -179,8 +179,8 @@ pub mod reader {
         ];
 
         unsafe {
-            let ptr = data.as_ptr().offset(start as int) as *i32;
-            let val = from_be32(*ptr) as u32;
+            let ptr = data.as_ptr().offset(start as int) as *u32;
+            let val = from_be32(*ptr);
 
             let i = (val >> 28u) as uint;
             let (shift, mask) = SHIFT_MASK_TABLE[i];
diff --git a/src/libstd/intrinsics.rs b/src/libstd/intrinsics.rs
index 896ebcd6fb5..175c7fe57b3 100644
--- a/src/libstd/intrinsics.rs
+++ b/src/libstd/intrinsics.rs
@@ -394,26 +394,50 @@ extern "rust-intrinsic" {
 
     pub fn roundf32(x: f32) -> f32;
     pub fn roundf64(x: f64) -> f64;
+}
+#[cfg(not(stage0))]
+extern "rust-intrinsic" {
+    pub fn ctpop8(x: u8) -> u8;
+    pub fn ctpop16(x: u16) -> u16;
+    pub fn ctpop32(x: u32) -> u32;
+    pub fn ctpop64(x: u64) -> u64;
+
+    pub fn ctlz8(x: u8) -> u8;
+    pub fn ctlz16(x: u16) -> u16;
+    pub fn ctlz32(x: u32) -> u32;
+    pub fn ctlz64(x: u64) -> u64;
+
+    pub fn cttz8(x: u8) -> u8;
+    pub fn cttz16(x: u16) -> u16;
+    pub fn cttz32(x: u32) -> u32;
+    pub fn cttz64(x: u64) -> u64;
+
+    pub fn bswap16(x: u16) -> u16;
+    pub fn bswap32(x: u32) -> u32;
+    pub fn bswap64(x: u64) -> u64;
+}
 
-    pub fn ctpop8(x: i8) -> i8;
-    pub fn ctpop16(x: i16) -> i16;
-    pub fn ctpop32(x: i32) -> i32;
-    pub fn ctpop64(x: i64) -> i64;
-
-    pub fn ctlz8(x: i8) -> i8;
-    pub fn ctlz16(x: i16) -> i16;
-    pub fn ctlz32(x: i32) -> i32;
-    pub fn ctlz64(x: i64) -> i64;
-
-    pub fn cttz8(x: i8) -> i8;
-    pub fn cttz16(x: i16) -> i16;
-    pub fn cttz32(x: i32) -> i32;
-    pub fn cttz64(x: i64) -> i64;
-
-    pub fn bswap16(x: i16) -> i16;
-    pub fn bswap32(x: i32) -> i32;
-    pub fn bswap64(x: i64) -> i64;
+// NOTE: remove this after a snap, and merge the extern block above
+macro_rules! stage0_hack {
+    ($( $u_ty:ty, $i_ty:ty => $($name:ident),*);*) => {
+        $(
+            $(
+                #[cfg(stage0)]
+                pub unsafe fn $name(x: $u_ty) -> $u_ty {
+                    extern "rust-intrinsic" { fn $name(x: $i_ty) -> $i_ty; }
+                    $name(x as $i_ty) as $u_ty
+                }
+            )*)*
+    }
+}
+stage0_hack! {
+    u8, i8 => ctpop8, ctlz8, cttz8;
+    u16, i16 => ctpop16, ctlz16, cttz16, bswap16;
+    u32, i32 => ctpop32, ctlz32, cttz32, bswap32;
+    u64, i64 => ctpop64, ctlz64, cttz64, bswap64
+}
 
+extern "rust-intrinsic" {
     pub fn i8_add_with_overflow(x: i8, y: i8) -> (i8, bool);
     pub fn i16_add_with_overflow(x: i16, y: i16) -> (i16, bool);
     pub fn i32_add_with_overflow(x: i32, y: i32) -> (i32, bool);
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index b2202a13057..d8022b1e26c 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -83,9 +83,9 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
-      2u => f(unsafe { transmute::<i16, [u8, ..2]>(to_le16(n as i16)) }),
-      4u => f(unsafe { transmute::<i32, [u8, ..4]>(to_le32(n as i32)) }),
-      8u => f(unsafe { transmute::<i64, [u8, ..8]>(to_le64(n as i64)) }),
+      2u => f(unsafe { transmute::<_, [u8, ..2]>(to_le16(n as u16)) }),
+      4u => f(unsafe { transmute::<_, [u8, ..4]>(to_le32(n as u32)) }),
+      8u => f(unsafe { transmute::<_, [u8, ..8]>(to_le64(n)) }),
       _ => {
 
         let mut bytes = vec!();
@@ -123,9 +123,9 @@ pub fn u64_to_be_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
-      2u => f(unsafe { transmute::<i16, [u8, ..2]>(to_be16(n as i16)) }),
-      4u => f(unsafe { transmute::<i32, [u8, ..4]>(to_be32(n as i32)) }),
-      8u => f(unsafe { transmute::<i64, [u8, ..8]>(to_be64(n as i64)) }),
+      2u => f(unsafe { transmute::<_, [u8, ..2]>(to_be16(n as u16)) }),
+      4u => f(unsafe { transmute::<_, [u8, ..4]>(to_be32(n as u32)) }),
+      8u => f(unsafe { transmute::<_, [u8, ..8]>(to_be64(n)) }),
       _ => {
         let mut bytes = vec!();
         let mut i = size;
@@ -166,7 +166,7 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
         let ptr = data.as_ptr().offset(start as int);
         let out = buf.as_mut_ptr();
         copy_nonoverlapping_memory(out.offset((8 - size) as int), ptr, size);
-        from_be64(*(out as *i64)) as u64
+        from_be64(*(out as *u64))
     }
 }
 
diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs
index deefb3fe2ed..282cfe51782 100644
--- a/src/libstd/mem.rs
+++ b/src/libstd/mem.rs
@@ -99,128 +99,128 @@ pub unsafe fn move_val_init<T>(dst: &mut T, src: T) {
     intrinsics::move_val_init(dst, src)
 }
 
-/// Convert an i16 to little endian from the target's endianness.
+/// Convert an u16 to little endian from the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_le16(x: i16) -> i16 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn to_le16(x: u16) -> u16 { x }
 
-/// Convert an i16 to little endian from the target's endianness.
+/// Convert an u16 to little endian from the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn to_le16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "big")]    #[inline] pub fn to_le16(x: u16) -> u16 { unsafe { bswap16(x) } }
 
-/// Convert an i32 to little endian from the target's endianness.
+/// Convert an u32 to little endian from the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_le32(x: i32) -> i32 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn to_le32(x: u32) -> u32 { x }
 
-/// Convert an i32 to little endian from the target's endianness.
+/// Convert an u32 to little endian from the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn to_le32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "big")]    #[inline] pub fn to_le32(x: u32) -> u32 { unsafe { bswap32(x) } }
 
-/// Convert an i64 to little endian from the target's endianness.
+/// Convert an u64 to little endian from the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_le64(x: i64) -> i64 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn to_le64(x: u64) -> u64 { x }
 
-/// Convert an i64 to little endian from the target's endianness.
+/// Convert an u64 to little endian from the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn to_le64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "big")]    #[inline] pub fn to_le64(x: u64) -> u64 { unsafe { bswap64(x) } }
 
 
-/// Convert an i16 to big endian from the target's endianness.
+/// Convert an u16 to big endian from the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn to_be16(x: u16) -> u16 { unsafe { bswap16(x) } }
 
-/// Convert an i16 to big endian from the target's endianness.
+/// Convert an u16 to big endian from the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn to_be16(x: i16) -> i16 { x }
+#[cfg(target_endian = "big")]    #[inline] pub fn to_be16(x: u16) -> u16 { x }
 
-/// Convert an i32 to big endian from the target's endianness.
+/// Convert an u32 to big endian from the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn to_be32(x: u32) -> u32 { unsafe { bswap32(x) } }
 
-/// Convert an i32 to big endian from the target's endianness.
+/// Convert an u32 to big endian from the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn to_be32(x: i32) -> i32 { x }
+#[cfg(target_endian = "big")]    #[inline] pub fn to_be32(x: u32) -> u32 { x }
 
-/// Convert an i64 to big endian from the target's endianness.
+/// Convert an u64 to big endian from the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn to_be64(x: u64) -> u64 { unsafe { bswap64(x) } }
 
-/// Convert an i64 to big endian from the target's endianness.
+/// Convert an u64 to big endian from the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn to_be64(x: i64) -> i64 { x }
+#[cfg(target_endian = "big")]    #[inline] pub fn to_be64(x: u64) -> u64 { x }
 
 
-/// Convert an i16 from little endian to the target's endianness.
+/// Convert an u16 from little endian to the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le16(x: i16) -> i16 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn from_le16(x: u16) -> u16 { x }
 
-/// Convert an i16 from little endian to the target's endianness.
+/// Convert an u16 from little endian to the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn from_le16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "big")]    #[inline] pub fn from_le16(x: u16) -> u16 { unsafe { bswap16(x) } }
 
-/// Convert an i32 from little endian to the target's endianness.
+/// Convert an u32 from little endian to the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le32(x: i32) -> i32 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn from_le32(x: u32) -> u32 { x }
 
-/// Convert an i32 from little endian to the target's endianness.
+/// Convert an u32 from little endian to the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn from_le32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "big")]    #[inline] pub fn from_le32(x: u32) -> u32 { unsafe { bswap32(x) } }
 
-/// Convert an i64 from little endian to the target's endianness.
+/// Convert an u64 from little endian to the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le64(x: i64) -> i64 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn from_le64(x: u64) -> u64 { x }
 
-/// Convert an i64 from little endian to the target's endianness.
+/// Convert an u64 from little endian to the target's endianness.
 ///
 /// On little endian, this is a no-op.  On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn from_le64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "big")]    #[inline] pub fn from_le64(x: u64) -> u64 { unsafe { bswap64(x) } }
 
 
-/// Convert an i16 from big endian to the target's endianness.
+/// Convert an u16 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn from_be16(x: u16) -> u16 { unsafe { bswap16(x) } }
 
-/// Convert an i16 from big endian to the target's endianness.
+/// Convert an u16 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn from_be16(x: i16) -> i16 { x }
+#[cfg(target_endian = "big")]    #[inline] pub fn from_be16(x: u16) -> u16 { x }
 
-/// Convert an i32 from big endian to the target's endianness.
+/// Convert an u32 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn from_be32(x: u32) -> u32 { unsafe { bswap32(x) } }
 
-/// Convert an i32 from big endian to the target's endianness.
+/// Convert an u32 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn from_be32(x: i32) -> i32 { x }
+#[cfg(target_endian = "big")]    #[inline] pub fn from_be32(x: u32) -> u32 { x }
 
-/// Convert an i64 from big endian to the target's endianness.
+/// Convert an u64 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn from_be64(x: u64) -> u64 { unsafe { bswap64(x) } }
 
-/// Convert an i64 from big endian to the target's endianness.
+/// Convert an u64 from big endian to the target's endianness.
 ///
 /// On big endian, this is a no-op.  On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")]    #[inline] pub fn from_be64(x: i64) -> i64 { x }
+#[cfg(target_endian = "big")]    #[inline] pub fn from_be64(x: u64) -> u64 { x }
 
 
 /**
diff --git a/src/libstd/num/i16.rs b/src/libstd/num/i16.rs
index 42710a8b459..79827421f92 100644
--- a/src/libstd/num/i16.rs
+++ b/src/libstd/num/i16.rs
@@ -28,17 +28,17 @@ int_module!(i16, 16)
 impl Bitwise for i16 {
     /// Returns the number of ones in the binary representation of the number.
     #[inline]
-    fn count_ones(&self) -> i16 { unsafe { intrinsics::ctpop16(*self) } }
+    fn count_ones(&self) -> i16 { unsafe { intrinsics::ctpop16(*self as u16) as i16 } }
 
     /// Returns the number of leading zeros in the in the binary representation
     /// of the number.
     #[inline]
-    fn leading_zeros(&self) -> i16 { unsafe { intrinsics::ctlz16(*self) } }
+    fn leading_zeros(&self) -> i16 { unsafe { intrinsics::ctlz16(*self as u16) as i16 } }
 
     /// Returns the number of trailing zeros in the in the binary representation
     /// of the number.
     #[inline]
-    fn trailing_zeros(&self) -> i16 { unsafe { intrinsics::cttz16(*self) } }
+    fn trailing_zeros(&self) -> i16 { unsafe { intrinsics::cttz16(*self as u16) as i16 } }
 }
 
 impl CheckedAdd for i16 {
diff --git a/src/libstd/num/i32.rs b/src/libstd/num/i32.rs
index 69d4b0639f7..97f03299b87 100644
--- a/src/libstd/num/i32.rs
+++ b/src/libstd/num/i32.rs
@@ -28,17 +28,17 @@ int_module!(i32, 32)
 impl Bitwise for i32 {
     /// Returns the number of ones in the binary representation of the number.
     #[inline]
-    fn count_ones(&self) -> i32 { unsafe { intrinsics::ctpop32(*self) } }
+    fn count_ones(&self) -> i32 { unsafe { intrinsics::ctpop32(*self as u32) as i32 } }
 
     /// Returns the number of leading zeros in the in the binary representation
     /// of the number.
     #[inline]
-    fn leading_zeros(&self) -> i32 { unsafe { intrinsics::ctlz32(*self) } }
+    fn leading_zeros(&self) -> i32 { unsafe { intrinsics::ctlz32(*self as u32) as i32 } }
 
     /// Returns the number of trailing zeros in the in the binary representation
     /// of the number.
     #[inline]
-    fn trailing_zeros(&self) -> i32 { unsafe { intrinsics::cttz32(*self) } }
+    fn trailing_zeros(&self) -> i32 { unsafe { intrinsics::cttz32(*self as u32) as i32 } }
 }
 
 impl CheckedAdd for i32 {
diff --git a/src/libstd/num/i64.rs b/src/libstd/num/i64.rs
index 1f7066c25db..00823aa22c2 100644
--- a/src/libstd/num/i64.rs
+++ b/src/libstd/num/i64.rs
@@ -30,16 +30,16 @@ int_module!(i64, 64)
 impl Bitwise for i64 {
     /// Returns the number of ones in the binary representation of the number.
     #[inline]
-    fn count_ones(&self) -> i64 { unsafe { intrinsics::ctpop64(*self) } }
+    fn count_ones(&self) -> i64 { unsafe { intrinsics::ctpop64(*self as u64) as i64 } }
 
     /// Returns the number of leading zeros in the in the binary representation
     /// of the number.
     #[inline]
-    fn leading_zeros(&self) -> i64 { unsafe { intrinsics::ctlz64(*self) } }
+    fn leading_zeros(&self) -> i64 { unsafe { intrinsics::ctlz64(*self as u64) as i64 } }
 
     /// Counts the number of trailing zeros.
     #[inline]
-    fn trailing_zeros(&self) -> i64 { unsafe { intrinsics::cttz64(*self) } }
+    fn trailing_zeros(&self) -> i64 { unsafe { intrinsics::cttz64(*self as u64) as i64 } }
 }
 
 impl CheckedAdd for i64 {
diff --git a/src/libstd/num/i8.rs b/src/libstd/num/i8.rs
index 061ffddf231..2d349fa7f4f 100644
--- a/src/libstd/num/i8.rs
+++ b/src/libstd/num/i8.rs
@@ -28,17 +28,17 @@ int_module!(i8, 8)
 impl Bitwise for i8 {
     /// Returns the number of ones in the binary representation of the number.
     #[inline]
-    fn count_ones(&self) -> i8 { unsafe { intrinsics::ctpop8(*self) } }
+    fn count_ones(&self) -> i8 { unsafe { intrinsics::ctpop8(*self as u8) as i8 } }
 
     /// Returns the number of leading zeros in the in the binary representation
     /// of the number.
     #[inline]
-    fn leading_zeros(&self) -> i8 { unsafe { intrinsics::ctlz8(*self) } }
+    fn leading_zeros(&self) -> i8 { unsafe { intrinsics::ctlz8(*self as u8) as i8 } }
 
     /// Returns the number of trailing zeros in the in the binary representation
     /// of the number.
     #[inline]
-    fn trailing_zeros(&self) -> i8 { unsafe { intrinsics::cttz8(*self) } }
+    fn trailing_zeros(&self) -> i8 { unsafe { intrinsics::cttz8(*self as u8) as i8 } }
 }
 
 impl CheckedAdd for i8 {
diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs
index 2ac6780af4c..559edd587fd 100644
--- a/src/libuuid/lib.rs
+++ b/src/libuuid/lib.rs
@@ -220,9 +220,9 @@ impl Uuid {
                 data4: [0, ..8]
         };
 
-        fields.data1 = to_be32(d1 as i32) as u32;
-        fields.data2 = to_be16(d2 as i16) as u16;
-        fields.data3 = to_be16(d3 as i16) as u16;
+        fields.data1 = to_be32(d1);
+        fields.data2 = to_be16(d2);
+        fields.data3 = to_be16(d3);
         slice::bytes::copy_memory(fields.data4, d4);
 
         unsafe {
@@ -343,9 +343,9 @@ impl Uuid {
         unsafe {
             uf = transmute_copy(&self.bytes);
         }
-        uf.data1 = to_be32(uf.data1 as i32) as u32;
-        uf.data2 = to_be16(uf.data2 as i16) as u16;
-        uf.data3 = to_be16(uf.data3 as i16) as u16;
+        uf.data1 = to_be32(uf.data1);
+        uf.data2 = to_be16(uf.data2);
+        uf.data3 = to_be16(uf.data3);
         let s = format!("{:08x}-{:04x}-{:04x}-{:02x}{:02x}-\
                          {:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
             uf.data1,
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index 80fea6d4932..f5724fc1324 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -16,7 +16,7 @@ use std::io;
 use std::io::stdio::StdReader;
 use std::io::BufferedReader;
 use std::os;
-use std::intrinsics::cttz16;
+use std::num::Bitwise;
 
 // Computes a single solution to a given 9x9 sudoku
 //
@@ -187,9 +187,7 @@ impl Colors {
         if (0u16 == val) {
             return 0u8;
         } else {
-            unsafe {
-                return cttz16(val as i16) as u8;
-            }
+            return val.trailing_zeros() as u8
         }
     }
 
diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs
index 164d16fe503..e31b941f956 100644
--- a/src/test/run-pass/intrinsics-integer.rs
+++ b/src/test/run-pass/intrinsics-integer.rs
@@ -1,4 +1,3 @@
-
 // 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.
@@ -13,24 +12,24 @@
 
 mod rusti {
     extern "rust-intrinsic" {
-        pub fn ctpop8(x: i8) -> i8;
-        pub fn ctpop16(x: i16) -> i16;
-        pub fn ctpop32(x: i32) -> i32;
-        pub fn ctpop64(x: i64) -> i64;
-
-        pub fn ctlz8(x: i8) -> i8;
-        pub fn ctlz16(x: i16) -> i16;
-        pub fn ctlz32(x: i32) -> i32;
-        pub fn ctlz64(x: i64) -> i64;
-
-        pub fn cttz8(x: i8) -> i8;
-        pub fn cttz16(x: i16) -> i16;
-        pub fn cttz32(x: i32) -> i32;
-        pub fn cttz64(x: i64) -> i64;
-
-        pub fn bswap16(x: i16) -> i16;
-        pub fn bswap32(x: i32) -> i32;
-        pub fn bswap64(x: i64) -> i64;
+        pub fn ctpop8(x: u8) -> u8;
+        pub fn ctpop16(x: u16) -> u16;
+        pub fn ctpop32(x: u32) -> u32;
+        pub fn ctpop64(x: u64) -> u64;
+
+        pub fn ctlz8(x: u8) -> u8;
+        pub fn ctlz16(x: u16) -> u16;
+        pub fn ctlz32(x: u32) -> u32;
+        pub fn ctlz64(x: u64) -> u64;
+
+        pub fn cttz8(x: u8) -> u8;
+        pub fn cttz16(x: u16) -> u16;
+        pub fn cttz32(x: u32) -> u32;
+        pub fn cttz64(x: u64) -> u64;
+
+        pub fn bswap16(x: u16) -> u16;
+        pub fn bswap32(x: u32) -> u32;
+        pub fn bswap64(x: u64) -> u64;
     }
 }
 
@@ -38,83 +37,83 @@ pub fn main() {
     unsafe {
         use rusti::*;
 
-        assert_eq!(ctpop8(0i8), 0i8);
-        assert_eq!(ctpop16(0i16), 0i16);
-        assert_eq!(ctpop32(0i32), 0i32);
-        assert_eq!(ctpop64(0i64), 0i64);
-
-        assert_eq!(ctpop8(1i8), 1i8);
-        assert_eq!(ctpop16(1i16), 1i16);
-        assert_eq!(ctpop32(1i32), 1i32);
-        assert_eq!(ctpop64(1i64), 1i64);
-
-        assert_eq!(ctpop8(10i8), 2i8);
-        assert_eq!(ctpop16(10i16), 2i16);
-        assert_eq!(ctpop32(10i32), 2i32);
-        assert_eq!(ctpop64(10i64), 2i64);
-
-        assert_eq!(ctpop8(100i8), 3i8);
-        assert_eq!(ctpop16(100i16), 3i16);
-        assert_eq!(ctpop32(100i32), 3i32);
-        assert_eq!(ctpop64(100i64), 3i64);
-
-        assert_eq!(ctpop8(-1i8), 8i8);
-        assert_eq!(ctpop16(-1i16), 16i16);
-        assert_eq!(ctpop32(-1i32), 32i32);
-        assert_eq!(ctpop64(-1i64), 64i64);
-
-        assert_eq!(ctlz8(0i8), 8i8);
-        assert_eq!(ctlz16(0i16), 16i16);
-        assert_eq!(ctlz32(0i32), 32i32);
-        assert_eq!(ctlz64(0i64), 64i64);
-
-        assert_eq!(ctlz8(1i8), 7i8);
-        assert_eq!(ctlz16(1i16), 15i16);
-        assert_eq!(ctlz32(1i32), 31i32);
-        assert_eq!(ctlz64(1i64), 63i64);
-
-        assert_eq!(ctlz8(10i8), 4i8);
-        assert_eq!(ctlz16(10i16), 12i16);
-        assert_eq!(ctlz32(10i32), 28i32);
-        assert_eq!(ctlz64(10i64), 60i64);
-
-        assert_eq!(ctlz8(100i8), 1i8);
-        assert_eq!(ctlz16(100i16), 9i16);
-        assert_eq!(ctlz32(100i32), 25i32);
-        assert_eq!(ctlz64(100i64), 57i64);
-
-        assert_eq!(cttz8(-1i8), 0i8);
-        assert_eq!(cttz16(-1i16), 0i16);
-        assert_eq!(cttz32(-1i32), 0i32);
-        assert_eq!(cttz64(-1i64), 0i64);
-
-        assert_eq!(cttz8(0i8), 8i8);
-        assert_eq!(cttz16(0i16), 16i16);
-        assert_eq!(cttz32(0i32), 32i32);
-        assert_eq!(cttz64(0i64), 64i64);
-
-        assert_eq!(cttz8(1i8), 0i8);
-        assert_eq!(cttz16(1i16), 0i16);
-        assert_eq!(cttz32(1i32), 0i32);
-        assert_eq!(cttz64(1i64), 0i64);
-
-        assert_eq!(cttz8(10i8), 1i8);
-        assert_eq!(cttz16(10i16), 1i16);
-        assert_eq!(cttz32(10i32), 1i32);
-        assert_eq!(cttz64(10i64), 1i64);
-
-        assert_eq!(cttz8(100i8), 2i8);
-        assert_eq!(cttz16(100i16), 2i16);
-        assert_eq!(cttz32(100i32), 2i32);
-        assert_eq!(cttz64(100i64), 2i64);
-
-        assert_eq!(cttz8(-1i8), 0i8);
-        assert_eq!(cttz16(-1i16), 0i16);
-        assert_eq!(cttz32(-1i32), 0i32);
-        assert_eq!(cttz64(-1i64), 0i64);
-
-        assert_eq!(bswap16(0x0A0Bi16), 0x0B0Ai16);
-        assert_eq!(bswap32(0x0ABBCC0Di32), 0x0DCCBB0Ai32);
-        assert_eq!(bswap64(0x0122334455667708i64), 0x0877665544332201i64);
+        assert_eq!(ctpop8(0u8), 0u8);
+        assert_eq!(ctpop16(0u16), 0u16);
+        assert_eq!(ctpop32(0u32), 0u32);
+        assert_eq!(ctpop64(0u64), 0u64);
+
+        assert_eq!(ctpop8(1u8), 1u8);
+        assert_eq!(ctpop16(1u16), 1u16);
+        assert_eq!(ctpop32(1u32), 1u32);
+        assert_eq!(ctpop64(1u64), 1u64);
+
+        assert_eq!(ctpop8(10u8), 2u8);
+        assert_eq!(ctpop16(10u16), 2u16);
+        assert_eq!(ctpop32(10u32), 2u32);
+        assert_eq!(ctpop64(10u64), 2u64);
+
+        assert_eq!(ctpop8(100u8), 3u8);
+        assert_eq!(ctpop16(100u16), 3u16);
+        assert_eq!(ctpop32(100u32), 3u32);
+        assert_eq!(ctpop64(100u64), 3u64);
+
+        assert_eq!(ctpop8(-1u8), 8u8);
+        assert_eq!(ctpop16(-1u16), 16u16);
+        assert_eq!(ctpop32(-1u32), 32u32);
+        assert_eq!(ctpop64(-1u64), 64u64);
+
+        assert_eq!(ctlz8(0u8), 8u8);
+        assert_eq!(ctlz16(0u16), 16u16);
+        assert_eq!(ctlz32(0u32), 32u32);
+        assert_eq!(ctlz64(0u64), 64u64);
+
+        assert_eq!(ctlz8(1u8), 7u8);
+        assert_eq!(ctlz16(1u16), 15u16);
+        assert_eq!(ctlz32(1u32), 31u32);
+        assert_eq!(ctlz64(1u64), 63u64);
+
+        assert_eq!(ctlz8(10u8), 4u8);
+        assert_eq!(ctlz16(10u16), 12u16);
+        assert_eq!(ctlz32(10u32), 28u32);
+        assert_eq!(ctlz64(10u64), 60u64);
+
+        assert_eq!(ctlz8(100u8), 1u8);
+        assert_eq!(ctlz16(100u16), 9u16);
+        assert_eq!(ctlz32(100u32), 25u32);
+        assert_eq!(ctlz64(100u64), 57u64);
+
+        assert_eq!(cttz8(-1u8), 0u8);
+        assert_eq!(cttz16(-1u16), 0u16);
+        assert_eq!(cttz32(-1u32), 0u32);
+        assert_eq!(cttz64(-1u64), 0u64);
+
+        assert_eq!(cttz8(0u8), 8u8);
+        assert_eq!(cttz16(0u16), 16u16);
+        assert_eq!(cttz32(0u32), 32u32);
+        assert_eq!(cttz64(0u64), 64u64);
+
+        assert_eq!(cttz8(1u8), 0u8);
+        assert_eq!(cttz16(1u16), 0u16);
+        assert_eq!(cttz32(1u32), 0u32);
+        assert_eq!(cttz64(1u64), 0u64);
+
+        assert_eq!(cttz8(10u8), 1u8);
+        assert_eq!(cttz16(10u16), 1u16);
+        assert_eq!(cttz32(10u32), 1u32);
+        assert_eq!(cttz64(10u64), 1u64);
+
+        assert_eq!(cttz8(100u8), 2u8);
+        assert_eq!(cttz16(100u16), 2u16);
+        assert_eq!(cttz32(100u32), 2u32);
+        assert_eq!(cttz64(100u64), 2u64);
+
+        assert_eq!(cttz8(-1u8), 0u8);
+        assert_eq!(cttz16(-1u16), 0u16);
+        assert_eq!(cttz32(-1u32), 0u32);
+        assert_eq!(cttz64(-1u64), 0u64);
+
+        assert_eq!(bswap16(0x0A0Bu16), 0x0B0Au16);
+        assert_eq!(bswap32(0x0ABBCC0Du32), 0x0DCCBB0Au32);
+        assert_eq!(bswap64(0x0122334455667708u64), 0x0877665544332201u64);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From c7325bdd8e29d57e7bc971b86accfb352c4262bc Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Sun, 13 Apr 2014 20:22:58 -0700
Subject: Add a default impl for Set::is_superset

I also deleted a bunch of documentation that was copy/pasted from the
trait definition.
---
 src/libcollections/hashmap.rs | 15 ---------------
 src/libcollections/treemap.rs | 36 ++++++++----------------------------
 src/libstd/container.rs       |  4 +++-
 3 files changed, 11 insertions(+), 44 deletions(-)

diff --git a/src/libcollections/hashmap.rs b/src/libcollections/hashmap.rs
index a2413d78e5f..46b93242685 100644
--- a/src/libcollections/hashmap.rs
+++ b/src/libcollections/hashmap.rs
@@ -1424,43 +1424,28 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Eq for HashSet<T, H> {
 }
 
 impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Container for HashSet<T, H> {
-    /// Return the number of elements in the set
     fn len(&self) -> uint { self.map.len() }
 }
 
 impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Mutable for HashSet<T, H> {
-    /// Clear the set, removing all values.
     fn clear(&mut self) { self.map.clear() }
 }
 
 impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Set<T> for HashSet<T, H> {
-    /// Return true if the set contains a value
     fn contains(&self, value: &T) -> bool { self.map.search(value).is_some() }
 
-    /// Return true if the set has no elements in common with `other`.
-    /// This is equivalent to checking for an empty intersection.
     fn is_disjoint(&self, other: &HashSet<T, H>) -> bool {
         self.iter().all(|v| !other.contains(v))
     }
 
-    /// Return true if the set is a subset of another
     fn is_subset(&self, other: &HashSet<T, H>) -> bool {
         self.iter().all(|v| other.contains(v))
     }
-
-    /// Return true if the set is a superset of another
-    fn is_superset(&self, other: &HashSet<T, H>) -> bool {
-        other.is_subset(self)
-    }
 }
 
 impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> MutableSet<T> for HashSet<T, H> {
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
     fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
 
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
     fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
 }
 
diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs
index d964e73f696..b14c5fd9f29 100644
--- a/src/libcollections/treemap.rs
+++ b/src/libcollections/treemap.rs
@@ -573,74 +573,54 @@ impl<T: Ord + TotalOrd> Ord for TreeSet<T> {
 }
 
 impl<T: TotalOrd> Container for TreeSet<T> {
-    /// Return the number of elements in the set
     #[inline]
     fn len(&self) -> uint { self.map.len() }
-
-    /// Return true if the set contains no elements
-    #[inline]
-    fn is_empty(&self) -> bool { self.map.is_empty() }
 }
 
 impl<T: TotalOrd> Mutable for TreeSet<T> {
-    /// Clear the set, removing all values.
     #[inline]
     fn clear(&mut self) { self.map.clear() }
 }
 
 impl<T: TotalOrd> Set<T> for TreeSet<T> {
-    /// Return true if the set contains a value
     #[inline]
     fn contains(&self, value: &T) -> bool {
         self.map.contains_key(value)
     }
 
-    /// Return true if the set has no elements in common with `other`.
-    /// This is equivalent to checking for an empty intersection.
     fn is_disjoint(&self, other: &TreeSet<T>) -> bool {
         self.intersection(other).next().is_none()
     }
 
-    /// Return true if the set is a subset of another
-    #[inline]
     fn is_subset(&self, other: &TreeSet<T>) -> bool {
-        other.is_superset(self)
-    }
-
-    /// Return true if the set is a superset of another
-    fn is_superset(&self, other: &TreeSet<T>) -> bool {
         let mut x = self.iter();
         let mut y = other.iter();
         let mut a = x.next();
         let mut b = y.next();
-        while b.is_some() {
-            if a.is_none() {
-                return false
+        while a.is_some() {
+            if b.is_none() {
+                return false;
             }
 
             let a1 = a.unwrap();
             let b1 = b.unwrap();
 
-            match a1.cmp(b1) {
-              Less => (),
-              Greater => return false,
-              Equal => b = y.next(),
+            match b1.cmp(a1) {
+                Less => (),
+                Greater => return false,
+                Equal => a = x.next(),
             }
 
-            a = x.next();
+            b = y.next();
         }
         true
     }
 }
 
 impl<T: TotalOrd> MutableSet<T> for TreeSet<T> {
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
     #[inline]
     fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
 
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
     #[inline]
     fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
 }
diff --git a/src/libstd/container.rs b/src/libstd/container.rs
index 326b9fa3d33..e8ee3792dcf 100644
--- a/src/libstd/container.rs
+++ b/src/libstd/container.rs
@@ -88,7 +88,9 @@ pub trait Set<T>: Container {
     fn is_subset(&self, other: &Self) -> bool;
 
     /// Return true if the set is a superset of another
-    fn is_superset(&self, other: &Self) -> bool;
+    fn is_superset(&self, other: &Self) -> bool {
+        other.is_subset(self)
+    }
 
     // FIXME #8154: Add difference, sym. difference, intersection and union iterators
 }
-- 
cgit 1.4.1-3-g733a5


From 06edc6a3b6ba23832530e6c0d4727cbcdcfb8a0d Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Sun, 13 Apr 2014 20:30:08 -0700
Subject: More default impl and docs removal in treemap

---
 src/libcollections/treemap.rs | 27 ---------------------------
 1 file changed, 27 deletions(-)

diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs
index b14c5fd9f29..3db12b5a538 100644
--- a/src/libcollections/treemap.rs
+++ b/src/libcollections/treemap.rs
@@ -64,24 +64,13 @@ fn lt<K: Ord + TotalOrd, V: Ord>(a: &TreeMap<K, V>,
 impl<K: Ord + TotalOrd, V: Ord> Ord for TreeMap<K, V> {
     #[inline]
     fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) }
-    #[inline]
-    fn le(&self, other: &TreeMap<K, V>) -> bool { !lt(other, self) }
-    #[inline]
-    fn ge(&self, other: &TreeMap<K, V>) -> bool { !lt(self, other) }
-    #[inline]
-    fn gt(&self, other: &TreeMap<K, V>) -> bool { lt(other, self) }
 }
 
 impl<K: TotalOrd, V> Container for TreeMap<K, V> {
-    /// Return the number of elements in the map
     fn len(&self) -> uint { self.length }
-
-    /// Return true if the map contains no elements
-    fn is_empty(&self) -> bool { self.root.is_none() }
 }
 
 impl<K: TotalOrd, V> Mutable for TreeMap<K, V> {
-    /// Clear the map, removing all key-value pairs.
     fn clear(&mut self) {
         self.root = None;
         self.length = 0
@@ -89,7 +78,6 @@ impl<K: TotalOrd, V> Mutable for TreeMap<K, V> {
 }
 
 impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
-    /// Return a reference to the value corresponding to the key
     fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
         let mut current: &'a Option<~TreeNode<K, V>> = &self.root;
         loop {
@@ -108,22 +96,17 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
 }
 
 impl<K: TotalOrd, V> MutableMap<K, V> for TreeMap<K, V> {
-    /// Return a mutable reference to the value corresponding to the key
     #[inline]
     fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V> {
         find_mut(&mut self.root, key)
     }
 
-    /// Insert a key-value pair from the map. If the key already had a value
-    /// present in the map, that value is returned. Otherwise None is returned.
     fn swap(&mut self, key: K, value: V) -> Option<V> {
         let ret = insert(&mut self.root, key, value);
         if ret.is_none() { self.length += 1 }
         ret
     }
 
-    /// Removes a key from the map, returning the value at the key if the key
-    /// was previously in the map.
     fn pop(&mut self, key: &K) -> Option<V> {
         let ret = remove(&mut self.root, key);
         if ret.is_some() { self.length -= 1 }
@@ -531,7 +514,6 @@ impl<K, V> Iterator<(K, V)> for MoveEntries<K,V> {
 }
 
 impl<'a, T> Iterator<&'a T> for SetItems<'a, T> {
-    /// Advance the iterator to the next node (in order). If there are no more nodes, return `None`.
     #[inline]
     fn next(&mut self) -> Option<&'a T> {
         self.iter.next().map(|(value, _)| value)
@@ -539,7 +521,6 @@ impl<'a, T> Iterator<&'a T> for SetItems<'a, T> {
 }
 
 impl<'a, T> Iterator<&'a T> for RevSetItems<'a, T> {
-    /// Advance the iterator to the next node (in order). If there are no more nodes, return `None`.
     #[inline]
     fn next(&mut self) -> Option<&'a T> {
         self.iter.next().map(|(value, _)| value)
@@ -557,19 +538,11 @@ pub struct TreeSet<T> {
 impl<T: Eq + TotalOrd> Eq for TreeSet<T> {
     #[inline]
     fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map }
-    #[inline]
-    fn ne(&self, other: &TreeSet<T>) -> bool { self.map != other.map }
 }
 
 impl<T: Ord + TotalOrd> Ord for TreeSet<T> {
     #[inline]
     fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map }
-    #[inline]
-    fn le(&self, other: &TreeSet<T>) -> bool { self.map <= other.map }
-    #[inline]
-    fn ge(&self, other: &TreeSet<T>) -> bool { self.map >= other.map }
-    #[inline]
-    fn gt(&self, other: &TreeSet<T>) -> bool { self.map > other.map }
 }
 
 impl<T: TotalOrd> Container for TreeSet<T> {
-- 
cgit 1.4.1-3-g733a5


From 4a827f588e972668c122f70790ee45e4b3660ace Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 15 Apr 2014 18:25:38 -0700
Subject: workcache: Don't assume gcc exists on all platforms

FreeBSD has recently moved to clang by default, and no longer ship gcc. Instead
use "cc" on unix platforms (the default compiler) and "gcc" on windows.
---
 src/libworkcache/lib.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/libworkcache/lib.rs b/src/libworkcache/lib.rs
index 623488ac612..7dd2d945c26 100644
--- a/src/libworkcache/lib.rs
+++ b/src/libworkcache/lib.rs
@@ -512,8 +512,9 @@ fn test() {
         prep.declare_input("file", pth.as_str().unwrap(), file_content);
         prep.exec(proc(_exe) {
             let out = make_path(~"foo.o");
+            let compiler = if cfg!(windows) {"gcc"} else {"cc"};
             // FIXME (#9639): This needs to handle non-utf8 paths
-            Process::status("gcc", [pth.as_str().unwrap().to_owned(),
+            Process::status(compiler, [pth.as_str().unwrap().to_owned(),
                                     ~"-o",
                                     out.as_str().unwrap().to_owned()]).unwrap();
 
-- 
cgit 1.4.1-3-g733a5


From c8f5b701dcf0b7dc4d78ef0d29f10e4f080b2517 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 15 Apr 2014 18:18:08 -0700
Subject: std: Remove pub use globs

---
 src/libstd/os.rs           | 32 +++++++++++++++++++++-----------
 src/libstd/rt/local_ptr.rs |  6 ++++--
 2 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index a16113cb48f..25f503174bc 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -1294,37 +1294,47 @@ impl Drop for MemoryMap {
 /// Various useful system-specific constants.
 pub mod consts {
     #[cfg(unix)]
-    pub use os::consts::unix::*;
+    pub use os::consts::unix::FAMILY;
 
     #[cfg(windows)]
-    pub use os::consts::windows::*;
+    pub use os::consts::windows::FAMILY;
 
     #[cfg(target_os = "macos")]
-    pub use os::consts::macos::*;
+    pub use os::consts::macos::{SYSNAME, DLL_PREFIX, DLL_SUFFIX, DLL_EXTENSION};
+    #[cfg(target_os = "macos")]
+    pub use os::consts::macos::{EXE_SUFFIX, EXE_EXTENSION};
 
     #[cfg(target_os = "freebsd")]
-    pub use os::consts::freebsd::*;
+    pub use os::consts::freebsd::{SYSNAME, DLL_PREFIX, DLL_SUFFIX, DLL_EXTENSION};
+    #[cfg(target_os = "freebsd")]
+    pub use os::consts::freebsd::{EXE_SUFFIX, EXE_EXTENSION};
 
     #[cfg(target_os = "linux")]
-    pub use os::consts::linux::*;
+    pub use os::consts::linux::{SYSNAME, DLL_PREFIX, DLL_SUFFIX, DLL_EXTENSION};
+    #[cfg(target_os = "linux")]
+    pub use os::consts::linux::{EXE_SUFFIX, EXE_EXTENSION};
 
     #[cfg(target_os = "android")]
-    pub use os::consts::android::*;
+    pub use os::consts::android::{SYSNAME, DLL_PREFIX, DLL_SUFFIX, DLL_EXTENSION};
+    #[cfg(target_os = "android")]
+    pub use os::consts::android::{EXE_SUFFIX, EXE_EXTENSION};
 
     #[cfg(target_os = "win32")]
-    pub use os::consts::win32::*;
+    pub use os::consts::win32::{SYSNAME, DLL_PREFIX, DLL_SUFFIX, DLL_EXTENSION};
+    #[cfg(target_os = "win32")]
+    pub use os::consts::win32::{EXE_SUFFIX, EXE_EXTENSION};
 
     #[cfg(target_arch = "x86")]
-    pub use os::consts::x86::*;
+    pub use os::consts::x86::{ARCH};
 
     #[cfg(target_arch = "x86_64")]
-    pub use os::consts::x86_64::*;
+    pub use os::consts::x86_64::{ARCH};
 
     #[cfg(target_arch = "arm")]
-    pub use os::consts::arm::*;
+    pub use os::consts::arm::{ARCH};
 
     #[cfg(target_arch = "mips")]
-    pub use os::consts::mips::*;
+    pub use os::consts::mips::{ARCH};
 
     /// Constants for Unix systems.
     pub mod unix {
diff --git a/src/libstd/rt/local_ptr.rs b/src/libstd/rt/local_ptr.rs
index 6b61af1d9a2..ff82be97489 100644
--- a/src/libstd/rt/local_ptr.rs
+++ b/src/libstd/rt/local_ptr.rs
@@ -23,10 +23,12 @@ use ptr::RawPtr;
 
 #[cfg(windows)]               // mingw-w32 doesn't like thread_local things
 #[cfg(target_os = "android")] // see #10686
-pub use self::native::*;
+pub use self::native::{init, cleanup, put, take, try_take, unsafe_take, exists,
+                       unsafe_borrow, try_unsafe_borrow};
 
 #[cfg(not(windows), not(target_os = "android"))]
-pub use self::compiled::*;
+pub use self::compiled::{init, cleanup, put, take, try_take, unsafe_take, exists,
+                         unsafe_borrow, try_unsafe_borrow};
 
 /// Encapsulates a borrowed value. When this value goes out of scope, the
 /// pointer is returned.
-- 
cgit 1.4.1-3-g733a5


From 9e8a270681aa22b56cdb41f5e2537dace5c7fe75 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 15 Apr 2014 06:41:27 -0700
Subject: test: Un-ignore smallest-hello-world.rs

Rebased through the ages to bring the test up to date.

Closes #8538
---
 src/test/run-pass/smallest-hello-world.rs | 23 +++++++----------------
 1 file changed, 7 insertions(+), 16 deletions(-)

diff --git a/src/test/run-pass/smallest-hello-world.rs b/src/test/run-pass/smallest-hello-world.rs
index cd9afa0311b..0ec1ec79a60 100644
--- a/src/test/run-pass/smallest-hello-world.rs
+++ b/src/test/run-pass/smallest-hello-world.rs
@@ -8,30 +8,21 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-test - FIXME(#8538) some kind of problem linking induced by extern "C" fns
-
 // Smallest hello world with no runtime
 
 #![no_std]
 
-// This is an unfortunate thing to have to do on linux :(
-#[cfg(target_os = "linux")]
-#[doc(hidden)]
-pub mod linkhack {
-    #[link_args="-lrustrt -lrt"]
-    extern {}
-}
+extern crate libc;
 
-extern {
-    fn puts(s: *u8);
-}
+extern { fn puts(s: *u8); }
+extern "rust-intrinsic" { fn transmute<T, U>(t: T) -> U; }
 
-extern "rust-intrinsic" {
-    fn transmute<T, U>(t: T) -> U;
-}
+#[no_mangle]
+pub extern fn rust_stack_exhausted() {}
 
 #[start]
-pub fn main(_: int, _: **u8, _: *u8) -> int {
+#[no_split_stack]
+fn main(_: int, _: **u8) -> int {
     unsafe {
         let (ptr, _): (*u8, uint) = transmute("Hello!");
         puts(ptr);
-- 
cgit 1.4.1-3-g733a5


From 55f02b2c1bdb6a8947478b1bdfd16423bfa7e2f5 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 15 Apr 2014 06:35:15 -0700
Subject: std: Un-ignore some float tests on windows

These were fixed in the upgrade from mingw32 to mingw64.

Closes #8663
---
 src/libstd/num/f32.rs | 2 +-
 src/libstd/num/f64.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs
index 7c5fe4ff274..7cd6aaa6310 100644
--- a/src/libstd/num/f32.rs
+++ b/src/libstd/num/f32.rs
@@ -1037,7 +1037,7 @@ mod tests {
         assert_eq!(0f32.abs_sub(&INFINITY), 0f32);
     }
 
-    #[test] #[ignore(cfg(windows))] // FIXME #8663
+    #[test]
     fn test_abs_sub_nowin() {
         assert!(NAN.abs_sub(&-1f32).is_nan());
         assert!(1f32.abs_sub(&NAN).is_nan());
diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index 69328a5ecdc..8b52a6747f4 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -1041,7 +1041,7 @@ mod tests {
         assert_eq!(0f64.abs_sub(&INFINITY), 0f64);
     }
 
-    #[test] #[ignore(cfg(windows))] // FIXME #8663
+    #[test]
     fn test_abs_sub_nowin() {
         assert!(NAN.abs_sub(&-1f64).is_nan());
         assert!(1f64.abs_sub(&NAN).is_nan());
-- 
cgit 1.4.1-3-g733a5


From 0754d1d061761a5f9e7fc13d45579953d329cfe1 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 15 Apr 2014 06:27:09 -0700
Subject: green: Add a helper macro for booting libgreen

This one-liner should help booting libgreen with librustuv without having to
worry about all the fiddly bits of argc/argv and whatnot.
---
 src/libgreen/lib.rs | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/src/libgreen/lib.rs b/src/libgreen/lib.rs
index 820627b6b7d..dd897b9db4b 100644
--- a/src/libgreen/lib.rs
+++ b/src/libgreen/lib.rs
@@ -144,6 +144,19 @@
 //! }
 //! ```
 //!
+//! The above code can also be shortened with a macro from libgreen.
+//!
+//! ```
+//! #![feature(phase)]
+//! #[phase(syntax)] extern crate green;
+//!
+//! green_start!(main)
+//!
+//! fn main() {
+//!     // run inside of a green pool
+//! }
+//! ```
+//!
 //! # Using a scheduler pool
 //!
 //! ```rust
@@ -229,6 +242,33 @@ pub mod sleeper_list;
 pub mod stack;
 pub mod task;
 
+/// A helper macro for booting a program with libgreen
+///
+/// # Example
+///
+/// ```
+/// #![feature(phase)]
+/// #[phase(syntax)] extern crate green;
+///
+/// green_start!(main)
+///
+/// fn main() {
+///     // running with libgreen
+/// }
+/// ```
+#[macro_export]
+macro_rules! green_start( ($f:ident) => (
+    mod __start {
+        extern crate green;
+        extern crate rustuv;
+
+        #[start]
+        fn start(argc: int, argv: **u8) -> int {
+            green::start(argc, argv, rustuv::event_loop, super::$f)
+        }
+    }
+) )
+
 /// Set up a default runtime configuration, given compiler-supplied arguments.
 ///
 /// This function will block until the entire pool of M:N schedulers have
-- 
cgit 1.4.1-3-g733a5


From c18c9284b352f3605553343cd78c7a8eb75b5cd2 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 15 Apr 2014 08:32:35 -0700
Subject: Test fixes from the rollup

Closes #13546 (workcache: Don't assume gcc exists on all platforms)
Closes #13545 (std: Remove pub use globs)
Closes #13530 (test: Un-ignore smallest-hello-world.rs)
Closes #13529 (std: Un-ignore some float tests on windows)
Closes #13528 (green: Add a helper macro for booting libgreen)
Closes #13526 (Remove RUST_LOG="::help" from the docs)
Closes #13524 (dist: Make Windows installer uninstall first. Closes #9563)
Closes #13521 (Change AUTHORS section in the man pages)
Closes #13519 (Update GitHub's Rust projects page.)
Closes #13518 (mk: Change windows to install from stage2)
Closes #13516 (liburl doc: insert missing hyphen)
Closes #13514 (rustdoc: Better sorting criteria for searching.)
Closes #13512 (native: Fix a race in select())
Closes #13506 (Use the unsigned integer types for bitwise intrinsics.)
Closes #13502 (Add a default impl for Set::is_superset)
---
 src/libgreen/sched.rs                     | 4 ++--
 src/librustuv/lib.rs                      | 2 +-
 src/test/run-pass/smallest-hello-world.rs | 4 +++-
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/libgreen/sched.rs b/src/libgreen/sched.rs
index e214797d4f8..dd9df8063f0 100644
--- a/src/libgreen/sched.rs
+++ b/src/libgreen/sched.rs
@@ -1035,10 +1035,10 @@ mod test {
 
     fn sched_id() -> uint {
         let mut task = Local::borrow(None::<Task>);
-        match task.get().maybe_take_runtime::<GreenTask>() {
+        match task.maybe_take_runtime::<GreenTask>() {
             Some(green) => {
                 let ret = green.sched.get_ref().sched_id();
-                task.get().put_runtime(green);
+                task.put_runtime(green);
                 return ret;
             }
             None => fail!()
diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs
index 8f5d4a72514..4f2b7103b79 100644
--- a/src/librustuv/lib.rs
+++ b/src/librustuv/lib.rs
@@ -462,7 +462,7 @@ fn local_loop() -> &'static mut uvio::UvIoFactory {
     unsafe {
         cast::transmute({
             let mut task = Local::borrow(None::<Task>);
-            let mut io = task.get().local_io().unwrap();
+            let mut io = task.local_io().unwrap();
             let (_vtable, uvio): (uint, &'static mut uvio::UvIoFactory) =
                 cast::transmute(io.get());
             uvio
diff --git a/src/test/run-pass/smallest-hello-world.rs b/src/test/run-pass/smallest-hello-world.rs
index 0ec1ec79a60..65288cf0416 100644
--- a/src/test/run-pass/smallest-hello-world.rs
+++ b/src/test/run-pass/smallest-hello-world.rs
@@ -8,7 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Smallest hello world with no runtime
+// ignore-android
+
+// Smallest "hello world" with a libc runtime
 
 #![no_std]
 
-- 
cgit 1.4.1-3-g733a5