diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs
index 76a8f456cd5..b3c0b8cad7a 100644
--- a/src/libcore/bool.rs
+++ b/src/libcore/bool.rs
@@ -49,12 +49,10 @@ pub fn is_false(v: bool) -> bool { !v }
 /// Parse logic value from `s`
 impl FromStr for bool {
     fn from_str(s: &str) -> Option<bool> {
-        if s == "true" {
-            Some(true)
-        } else if s == "false" {
-            Some(false)
-        } else {
-            None
+        match s {
+            "true"  => Some(true),
+            "false" => Some(false),
+            _       => None,
         }
     }
 }
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 80f1f05961a..ca9c49b2c06 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -127,12 +127,11 @@ totalord_impl!(uint)
 
 totalord_impl!(char)
 
+/// Compares (a1, b1) against (a2, b2), where the a values are more significant.
 pub fn cmp2<A:TotalOrd,B:TotalOrd>(
     a1: &A, b1: &B,
     a2: &A, b2: &B) -> Ordering
 {
-    //! Compares (a1, b1) against (a2, b2), where the a values are more significant.
-
     match a1.cmp(a2) {
         Less => Less,
         Greater => Greater,
diff --git a/src/libcore/either.rs b/src/libcore/either.rs
index 8c16f5c6482..f89bb3b2f90 100644
--- a/src/libcore/either.rs
+++ b/src/libcore/either.rs
@@ -26,26 +26,22 @@ pub enum Either<T, U> {
     Right(U)
 }
 
+/// Applies a function based on the given either value
+///
+/// If `value` is left(T) then `f_left` is applied to its contents, if
+/// `value` is right(U) then `f_right` is applied to its contents, and the
+/// result is returned.
 #[inline(always)]
 pub fn either<T, U, V>(f_left: &fn(&T) -> V,
                        f_right: &fn(&U) -> V, value: &Either<T, U>) -> V {
-    /*!
-     * Applies a function based on the given either value
-     *
-     * If `value` is left(T) then `f_left` is applied to its contents, if
-     * `value` is right(U) then `f_right` is applied to its contents, and the
-     * result is returned.
-     */
-
     match *value {
-      Left(ref l) => f_left(l),
-      Right(ref r) => f_right(r)
+        Left(ref l) => f_left(l),
+        Right(ref r) => f_right(r)
     }
 }
 
+/// Extracts from a vector of either all the left values
 pub fn lefts<T:Copy,U>(eithers: &[Either<T, U>]) -> ~[T] {
-    //! Extracts from a vector of either all the left values
-
     do vec::build_sized(eithers.len()) |push| {
         for eithers.each |elt| {
             match *elt {
@@ -56,9 +52,8 @@ pub fn lefts<T:Copy,U>(eithers: &[Either<T, U>]) -> ~[T] {
     }
 }
 
+/// Extracts from a vector of either all the right values
 pub fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
-    //! Extracts from a vector of either all the right values
-
     do vec::build_sized(eithers.len()) |push| {
         for eithers.each |elt| {
             match *elt {
@@ -69,80 +64,73 @@ pub fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
     }
 }
 
-pub fn partition<T, U>(eithers: ~[Either<T, U>])
-    -> (~[T], ~[U]) {
-    /*!
-     * Extracts from a vector of either all the left values and right values
-     *
-     * Returns a structure containing a vector of left values and a vector of
-     * right values.
-     */
-
+/// Extracts from a vector of either all the left values and right values
+///
+/// Returns a structure containing a vector of left values and a vector of
+/// right values.
+pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
     let mut lefts: ~[T] = ~[];
     let mut rights: ~[U] = ~[];
     do vec::consume(eithers) |_i, elt| {
         match elt {
-          Left(l) => lefts.push(l),
-          Right(r) => rights.push(r)
+            Left(l) => lefts.push(l),
+            Right(r) => rights.push(r)
         }
     }
     return (lefts, rights);
 }
 
+/// Flips between left and right of a given either
 #[inline(always)]
 pub fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> {
-    //! Flips between left and right of a given either
-
     match eith {
-      Right(r) => Left(r),
-      Left(l) => Right(l)
+        Right(r) => Left(r),
+        Left(l) => Right(l)
     }
 }
 
+/// Converts either::t to a result::t
+///
+/// Converts an `either` type to a `result` type, making the "right" choice
+/// an ok result, and the "left" choice a fail
 #[inline(always)]
-pub fn to_result<T, U>(eith: Either<T, U>)
-    -> Result<U, T> {
-    /*!
-     * Converts either::t to a result::t
-     *
-     * Converts an `either` type to a `result` type, making the "right" choice
-     * an ok result, and the "left" choice a fail
-     */
-
+pub fn to_result<T, U>(eith: Either<T, U>) -> Result<U, T> {
     match eith {
-      Right(r) => result::Ok(r),
-      Left(l) => result::Err(l)
+        Right(r) => result::Ok(r),
+        Left(l) => result::Err(l)
     }
 }
 
+/// Checks whether the given value is a left
 #[inline(always)]
 pub fn is_left<T, U>(eith: &Either<T, U>) -> bool {
-    //! Checks whether the given value is a left
-
-    match *eith { Left(_) => true, _ => false }
+    match *eith {
+        Left(_) => true,
+        _ => false
+    }
 }
 
+/// Checks whether the given value is a right
 #[inline(always)]
 pub fn is_right<T, U>(eith: &Either<T, U>) -> bool {
-    //! Checks whether the given value is a right
-
-    match *eith { Right(_) => true, _ => false }
+    match *eith {
+        Right(_) => true,
+        _ => false
+    }
 }
 
+/// Retrieves the value in the left branch. Fails if the either is Right.
 #[inline(always)]
 pub fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
-    //! Retrieves the value in the left branch. Fails if the either is Right.
-
     match eith {
         Left(x) => x,
         Right(_) => fail!("either::unwrap_left Right")
     }
 }
 
+/// Retrieves the value in the right branch. Fails if the either is Left.
 #[inline(always)]
 pub fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
-    //! Retrieves the value in the right branch. Fails if the either is Left.
-
     match eith {
         Right(x) => x,
         Left(_) => fail!("either::unwrap_right Left")
diff --git a/src/libcore/managed.rs b/src/libcore/managed.rs
index d2bb88ca302..ecde1eb1917 100644
--- a/src/libcore/managed.rs
+++ b/src/libcore/managed.rs
@@ -35,16 +35,16 @@ pub mod raw {
 
 }
 
+/// Determine if two shared boxes point to the same object
 #[inline(always)]
 pub fn ptr_eq<T>(a: @T, b: @T) -> bool {
-    //! Determine if two shared boxes point to the same object
     let a_ptr: *T = to_unsafe_ptr(&*a), b_ptr: *T = to_unsafe_ptr(&*b);
     a_ptr == b_ptr
 }
 
+/// Determine if two mutable shared boxes point to the same object
 #[inline(always)]
 pub fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool {
-    //! Determine if two mutable shared boxes point to the same object
     let a_ptr: *T = to_unsafe_ptr(&*a), b_ptr: *T = to_unsafe_ptr(&*b);
     a_ptr == b_ptr
 }
diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs
index 4a3ec3528f2..d580f7aa26c 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -248,8 +248,7 @@ impl Orderable for f32 {
         if self.is_NaN() || other.is_NaN() { Float::NaN() } else { fmax(*self, *other) }
     }
 
-    /// Returns the number constrained within the range `mn <= self <= mx`.
-    /// If any of the numbers are `NaN` then `NaN` is returned.
+    #[cfg(stage0)]
     #[inline(always)]
     fn clamp(&self, mn: &f32, mx: &f32) -> f32 {
         if self.is_NaN() { *self }
@@ -257,6 +256,19 @@ impl Orderable for f32 {
         else if !(*self >= *mn) { *mn }
         else { *self }
     }
+
+    /// Returns the number constrained within the range `mn <= self <= mx`.
+    /// If any of the numbers are `NaN` then `NaN` is returned.
+    #[cfg(not(stage0))]
+    #[inline(always)]
+    fn clamp(&self, mn: &f32, mx: &f32) -> f32 {
+        cond!(
+            (self.is_NaN())   { *self }
+            (!(*self <= *mx)) { *mx   }
+            (!(*self >= *mn)) { *mn   }
+            _                 { *self }
+        )
+    }
 }
 
 impl Zero for f32 {
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
index e370f43a003..d140df30c42 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -270,8 +270,7 @@ impl Orderable for f64 {
         if self.is_NaN() || other.is_NaN() { Float::NaN() } else { fmax(*self, *other) }
     }
 
-    /// Returns the number constrained within the range `mn <= self <= mx`.
-    /// If any of the numbers are `NaN` then `NaN` is returned.
+    #[cfg(stage0)]
     #[inline(always)]
     fn clamp(&self, mn: &f64, mx: &f64) -> f64 {
         if self.is_NaN() { *self }
@@ -279,6 +278,19 @@ impl Orderable for f64 {
         else if !(*self >= *mn) { *mn }
         else { *self }
     }
+
+    /// Returns the number constrained within the range `mn <= self <= mx`.
+    /// If any of the numbers are `NaN` then `NaN` is returned.
+    #[cfg(not(stage0))]
+    #[inline(always)]
+    fn clamp(&self, mn: &f64, mx: &f64) -> f64 {
+        cond!(
+            (self.is_NaN())   { *self }
+            (!(*self <= *mx)) { *mx   }
+            (!(*self >= *mn)) { *mn   }
+            _                 { *self }
+        )
+    }
 }
 
 impl Zero for f64 {
diff --git a/src/libcore/num/int-template.rs b/src/libcore/num/int-template.rs
index 348f72f9f0a..d0e6174ec63 100644
--- a/src/libcore/num/int-template.rs
+++ b/src/libcore/num/int-template.rs
@@ -187,11 +187,23 @@ impl Orderable for T {
         if *self > *other { *self } else { *other }
     }
 
+    #[cfg(stage0)]
     #[inline(always)]
     fn clamp(&self, mn: &T, mx: &T) -> T {
         if *self > *mx { *mx } else
         if *self < *mn { *mn } else { *self }
     }
+
+    /// Returns the number constrained within the range `mn <= self <= mx`.
+    #[cfg(not(stage0))]
+    #[inline(always)]
+    fn clamp(&self, mn: &T, mx: &T) -> T {
+        cond!(
+            (*self > *mx) { *mx   }
+            (*self < *mn) { *mn   }
+            _             { *self }
+        )
+    }
 }
 
 impl Zero for T {
diff --git a/src/libcore/num/uint-template.rs b/src/libcore/num/uint-template.rs
index da0815c264b..f3e14094505 100644
--- a/src/libcore/num/uint-template.rs
+++ b/src/libcore/num/uint-template.rs
@@ -153,11 +153,23 @@ impl Orderable for T {
         if *self > *other { *self } else { *other }
     }
 
+    #[cfg(stage0)]
     #[inline(always)]
     fn clamp(&self, mn: &T, mx: &T) -> T {
         if *self > *mx { *mx } else
         if *self < *mn { *mn } else { *self }
     }
+
+    /// Returns the number constrained within the range `mn <= self <= mx`.
+    #[cfg(not(stage0))]
+    #[inline(always)]
+    fn clamp(&self, mn: &T, mx: &T) -> T {
+        cond!(
+            (*self > *mx) { *mx   }
+            (*self < *mn) { *mn   }
+            _             { *self }
+        )
+    }
 }
 
 impl Zero for T {
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 5aee3077e48..0212d4abd29 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -89,11 +89,11 @@ impl<T:Ord> Ord for Option<T> {
     }
 
     fn ge(&self, other: &Option<T>) -> bool {
-        ! (self < other)
+        !(self < other)
     }
 
     fn gt(&self, other: &Option<T>) -> bool {
-        ! (self <= other)
+        !(self <= other)
     }
 }
 
@@ -182,12 +182,10 @@ pub impl<T> Option<T> {
     #[inline(always)]
     fn is_some(&const self) -> bool { !self.is_none() }
 
+    /// Update an optional value by optionally running its content through a
+    /// function that returns an option.
     #[inline(always)]
     fn chain<U>(self, f: &fn(t: T) -> Option<U>) -> Option<U> {
-        /*!
-         * Update an optional value by optionally running its content through a
-         * function that returns an option.
-         */
 
         match self {
             Some(t) => f(t),
@@ -195,21 +193,17 @@ pub impl<T> Option<T> {
         }
     }
 
+    /// Returns the leftmost Some() value, or None if both are None.
     #[inline(always)]
     fn or(self, optb: Option<T>) -> Option<T> {
-        /*!
-         * Returns the leftmost Some() value, or None if both are None.
-         */
         match self {
             Some(opta) => Some(opta),
             _ => optb
         }
     }
 
-    /**
-     * Update an optional value by optionally running its content by reference
-     * through a function that returns an option.
-     */
+    /// Update an optional value by optionally running its content by reference
+    /// through a function that returns an option.
     #[inline(always)]
     fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option<U>) -> Option<U> {
         match *self { Some(ref x) => f(x), None => None }
diff --git a/src/libcore/path.rs b/src/libcore/path.rs
index 2015c5474be..8a5d9c0416d 100644
--- a/src/libcore/path.rs
+++ b/src/libcore/path.rs
@@ -311,9 +311,10 @@ pub impl Path {
         unsafe {
              do str::as_c_str(self.to_str()) |buf| {
                 let mut st = stat::arch::default_stat();
-                let r = libc::stat(buf, &mut st);
-
-                if r == 0 { Some(st) } else { None }
+                match libc::stat(buf, &mut st) {
+                    0 => Some(st),
+                    _ => None,
+                }
             }
         }
     }
@@ -323,9 +324,10 @@ pub impl Path {
         unsafe {
             do str::as_c_str(self.to_str()) |buf| {
                 let mut st = stat::arch::default_stat();
-                let r = libc::lstat(buf, &mut st);
-
-                if r == 0 { Some(st) } else { None }
+                match libc::lstat(buf, &mut st) {
+                    0 => Some(st),
+                    _ => None,
+                }
             }
         }
     }
@@ -450,55 +452,56 @@ impl GenericPath for PosixPath {
             components.push(s.to_owned())
         }
         let is_absolute = (s.len() != 0 && s[0] == '/' as u8);
-        return PosixPath { is_absolute: is_absolute,
-                           components: components }
+        PosixPath {
+            is_absolute: is_absolute,
+            components: components,
+        }
     }
 
     fn dirname(&self) -> ~str {
         let s = self.dir_path().to_str();
-        if s.len() == 0 {
-            ~"."
-        } else {
-            s
+        match s.len() {
+            0 => ~".",
+            _ => s,
         }
     }
 
     fn filename(&self) -> Option<~str> {
         match self.components.len() {
-          0 => None,
-          n => Some(copy self.components[n - 1])
+            0 => None,
+            n => Some(copy self.components[n - 1]),
         }
     }
 
     fn filestem(&self) -> Option<~str> {
         match self.filename() {
-          None => None,
-          Some(ref f) => {
-            match str::rfind_char(*f, '.') {
-              Some(p) => Some(f.slice(0, p).to_owned()),
-              None => Some(copy *f)
+            None => None,
+            Some(ref f) => {
+                match str::rfind_char(*f, '.') {
+                    Some(p) => Some(f.slice(0, p).to_owned()),
+                    None => Some(copy *f),
+                }
             }
-          }
         }
     }
 
     fn filetype(&self) -> Option<~str> {
         match self.filename() {
-          None => None,
-          Some(ref f) => {
-            match str::rfind_char(*f, '.') {
-              Some(p) if p < f.len() => Some(f.slice(p, f.len()).to_owned()),
-              _ => None
+            None => None,
+            Some(ref f) => {
+                match str::rfind_char(*f, '.') {
+                    Some(p) if p < f.len() => Some(f.slice(p, f.len()).to_owned()),
+                    _ => None,
+                }
             }
-          }
         }
     }
 
     fn with_dirname(&self, d: &str) -> PosixPath {
         let dpath = PosixPath(d);
         match self.filename() {
-          Some(ref f) => dpath.push(*f),
-          None => dpath
+            Some(ref f) => dpath.push(*f),
+            None => dpath,
         }
     }
 
@@ -509,31 +512,24 @@ impl GenericPath for PosixPath {
 
     fn with_filestem(&self, s: &str) -> PosixPath {
         match self.filetype() {
-          None => self.with_filename(s),
-          Some(ref t) => self.with_filename(str::to_owned(s) + *t)
+            None => self.with_filename(s),
+            Some(ref t) => self.with_filename(str::to_owned(s) + *t),
         }
     }
 
     fn with_filetype(&self, t: &str) -> PosixPath {
-        if t.len() == 0 {
-            match self.filestem() {
-              None => copy *self,
-              Some(ref s) => self.with_filename(*s)
-            }
-        } else {
-            let t = ~"." + str::to_owned(t);
-            match self.filestem() {
-              None => self.with_filename(t),
-              Some(ref s) => self.with_filename(*s + t)
-            }
+        match (t.len(), self.filestem()) {
+            (0, None)        => copy *self,
+            (0, Some(ref s)) => self.with_filename(*s),
+            (_, None)        => self.with_filename(fmt!(".%s", t)),
+            (_, Some(ref s)) => self.with_filename(fmt!("%s.%s", *s, t)),
         }
     }
 
     fn dir_path(&self) -> PosixPath {
-        if self.components.len() != 0 {
-            self.pop()
-        } else {
-            copy *self
+        match self.components.len() {
+            0 => copy *self,
+            _ => self.pop(),
         }
     }
 
@@ -542,8 +538,10 @@ impl GenericPath for PosixPath {
           None => ~[],
           Some(ref f) => ~[copy *f]
         };
-        return PosixPath { is_absolute: false,
-                           components: cs }
+        PosixPath {
+            is_absolute: false,
+            components: cs,
+        }
     }
 
     fn push_rel(&self, other: &PosixPath) -> PosixPath {
@@ -553,8 +551,10 @@ impl GenericPath for PosixPath {
 
     fn unsafe_join(&self, other: &PosixPath) -> PosixPath {
         if other.is_absolute {
-            PosixPath { is_absolute: true,
-                        components: copy other.components }
+            PosixPath {
+                is_absolute: true,
+                components: copy other.components,
+            }
         } else {
             self.push_rel(other)
         }
@@ -573,8 +573,10 @@ impl GenericPath for PosixPath {
             }
             v.push_all_move(ss);
         }
-        PosixPath { is_absolute: self.is_absolute,
-                    components: v }
+        PosixPath {
+            is_absolute: self.is_absolute,
+            components: v,
+        }
     }
 
     fn push(&self, s: &str) -> PosixPath {
@@ -592,19 +594,17 @@ impl GenericPath for PosixPath {
         if cs.len() != 0 {
             cs.pop();
         }
-        return PosixPath {
+        PosixPath {
             is_absolute: self.is_absolute,
-            components: cs
-        }
-                          //..self }
+            components: cs,
+        } //..self }
     }
 
     fn normalize(&self) -> PosixPath {
-        return PosixPath {
+        PosixPath {
             is_absolute: self.is_absolute,
-            components: normalize(self.components)
-          //  ..self
-        }
+            components: normalize(self.components),
+        } // ..self }
     }
 
     fn is_absolute(&self) -> bool {
@@ -638,26 +638,25 @@ impl GenericPath for WindowsPath {
         let device;
         let rest;
 
-        match windows::extract_drive_prefix(s) {
-          Some((ref d, ref r)) => {
-            host = None;
-            device = Some(copy *d);
-            rest = copy *r;
-          }
-          None => {
-            match windows::extract_unc_prefix(s) {
-              Some((ref h, ref r)) => {
+        match (
+            windows::extract_drive_prefix(s),
+            windows::extract_unc_prefix(s),
+        ) {
+            (Some((ref d, ref r)), _) => {
+                host = None;
+                device = Some(copy *d);
+                rest = copy *r;
+            }
+            (None, Some((ref h, ref r))) => {
                 host = Some(copy *h);
                 device = None;
                 rest = copy *r;
-              }
-              None => {
+            }
+            (None, None) => {
                 host = None;
                 device = None;
                 rest = str::to_owned(s);
-              }
             }
-          }
         }
 
         let mut components = ~[];
@@ -665,37 +664,38 @@ impl GenericPath for WindowsPath {
             components.push(s.to_owned())
         }
         let is_absolute = (rest.len() != 0 && windows::is_sep(rest[0]));
-        return WindowsPath { host: host,
-                             device: device,
-                             is_absolute: is_absolute,
-                             components: components }
+        WindowsPath {
+            host: host,
+            device: device,
+            is_absolute: is_absolute,
+            components: components,
+        }
     }
 
     fn dirname(&self) -> ~str {
         let s = self.dir_path().to_str();
-        if s.len() == 0 {
-            ~"."
-        } else {
-            s
+        match s.len() {
+            0 => ~".",
+            _ => s,
         }
     }
 
     fn filename(&self) -> Option<~str> {
         match self.components.len() {
-          0 => None,
-          n => Some(copy self.components[n - 1])
+            0 => None,
+            n => Some(copy self.components[n - 1]),
         }
     }
 
     fn filestem(&self) -> Option<~str> {
         match self.filename() {
-          None => None,
-          Some(ref f) => {
-            match str::rfind_char(*f, '.') {
-              Some(p) => Some(f.slice(0, p).to_owned()),
-              None => Some(copy *f)
+            None => None,
+            Some(ref f) => {
+                match str::rfind_char(*f, '.') {
+                    Some(p) => Some(f.slice(0, p).to_owned()),
+                    None => Some(copy *f),
+                }
             }
-          }
         }
     }
 
@@ -704,8 +704,8 @@ impl GenericPath for WindowsPath {
           None => None,
           Some(ref f) => {
             match str::rfind_char(*f, '.') {
-              Some(p) if p < f.len() => Some(f.slice(p, f.len()).to_owned()),
-              _ => None
+                Some(p) if p < f.len() => Some(f.slice(p, f.len()).to_owned()),
+                _ => None,
             }
           }
         }
@@ -714,8 +714,8 @@ impl GenericPath for WindowsPath {
     fn with_dirname(&self, d: &str) -> WindowsPath {
         let dpath = WindowsPath(d);
         match self.filename() {
-          Some(ref f) => dpath.push(*f),
-          None => dpath
+            Some(ref f) => dpath.push(*f),
+            None => dpath,
         }
     }
 
@@ -726,44 +726,37 @@ impl GenericPath for WindowsPath {
 
     fn with_filestem(&self, s: &str) -> WindowsPath {
         match self.filetype() {
-          None => self.with_filename(s),
-          Some(ref t) => self.with_filename(str::to_owned(s) + *t)
+            None => self.with_filename(s),
+            Some(ref t) => self.with_filename(str::to_owned(s) + *t),
         }
     }
 
     fn with_filetype(&self, t: &str) -> WindowsPath {
-        if t.len() == 0 {
-            match self.filestem() {
-              None => copy *self,
-              Some(ref s) => self.with_filename(*s)
-            }
-        } else {
-            let t = ~"." + str::to_owned(t);
-            match self.filestem() {
-              None => self.with_filename(t),
-              Some(ref s) =>
-              self.with_filename(*s + t)
-            }
+        match (t.len(), self.filestem()) {
+            (0, None)        => copy *self,
+            (0, Some(ref s)) => self.with_filename(*s),
+            (_, None)        => self.with_filename(fmt!(".%s", t)),
+            (_, Some(ref s)) => self.with_filename(fmt!("%s.%s", *s, t)),
         }
     }
 
     fn dir_path(&self) -> WindowsPath {
-        if self.components.len() != 0 {
-            self.pop()
-        } else {
-            copy *self
+        match self.components.len() {
+            0 => copy *self,
+            _ => self.pop(),
         }
     }
 
     fn file_path(&self) -> WindowsPath {
-        let cs = match self.filename() {
-          None => ~[],
-          Some(ref f) => ~[copy *f]
-        };
-        return WindowsPath { host: None,
-                             device: None,
-                             is_absolute: false,
-                             components: cs }
+        WindowsPath {
+            host: None,
+            device: None,
+            is_absolute: false,
+            components: match self.filename() {
+                None => ~[],
+                Some(ref f) => ~[copy *f],
+            }
+        }
     }
 
     fn push_rel(&self, other: &WindowsPath) -> WindowsPath {
@@ -784,7 +777,7 @@ impl GenericPath for WindowsPath {
                     host: Some(host),
                     device: copy other.device,
                     is_absolute: true,
-                    components: copy other.components
+                    components: copy other.components,
                 };
             }
             _ => {}
@@ -797,7 +790,7 @@ impl GenericPath for WindowsPath {
                     host: None,
                     device: Some(device),
                     is_absolute: true,
-                    components: copy other.components
+                    components: copy other.components,
                 };
             }
             _ => {}
@@ -809,7 +802,7 @@ impl GenericPath for WindowsPath {
             host: copy self.host,
             device: copy self.device,
             is_absolute: self.is_absolute || other.is_absolute,
-            components: copy other.components
+            components: copy other.components,
         }
     }
 
@@ -838,7 +831,7 @@ impl GenericPath for WindowsPath {
             v.push_all_move(ss);
         }
         // tedious, but as-is, we can't use ..self
-        return WindowsPath {
+        WindowsPath {
             host: copy self.host,
             device: copy self.device,
             is_absolute: self.is_absolute,
@@ -853,7 +846,7 @@ impl GenericPath for WindowsPath {
             ss.push(s.to_owned())
         }
         v.push_all_move(ss);
-        return WindowsPath { components: v, ..copy *self }
+        WindowsPath { components: v, ..copy *self }
     }
 
     fn pop(&self) -> WindowsPath {
@@ -861,16 +854,16 @@ impl GenericPath for WindowsPath {
         if cs.len() != 0 {
             cs.pop();
         }
-        return WindowsPath {
+        WindowsPath {
             host: copy self.host,
             device: copy self.device,
             is_absolute: self.is_absolute,
-            components: cs
+            components: cs,
         }
     }
 
     fn normalize(&self) -> WindowsPath {
-        return WindowsPath {
+        WindowsPath {
             host: copy self.host,
             device: match self.device {
                 None => None,
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index ec7177e5211..59f769fd92d 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -128,57 +128,43 @@ pub fn push_char(s: &mut ~str, ch: char) {
         let off = len;
         do as_buf(*s) |buf, _len| {
             let buf: *mut u8 = ::cast::transmute(buf);
-            if nb == 1u {
-                *ptr::mut_offset(buf, off) =
-                    code as u8;
-            } else if nb == 2u {
-                *ptr::mut_offset(buf, off) =
-                    (code >> 6u & 31u | tag_two_b) as u8;
-                *ptr::mut_offset(buf, off + 1u) =
-                    (code & 63u | tag_cont) as u8;
-            } else if nb == 3u {
-                *ptr::mut_offset(buf, off) =
-                    (code >> 12u & 15u | tag_three_b) as u8;
-                *ptr::mut_offset(buf, off + 1u) =
-                    (code >> 6u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 2u) =
-                    (code & 63u | tag_cont) as u8;
-            } else if nb == 4u {
-                *ptr::mut_offset(buf, off) =
-                    (code >> 18u & 7u | tag_four_b) as u8;
-                *ptr::mut_offset(buf, off + 1u) =
-                    (code >> 12u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 2u) =
-                    (code >> 6u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 3u) =
-                    (code & 63u | tag_cont) as u8;
-            } else if nb == 5u {
-                *ptr::mut_offset(buf, off) =
-                    (code >> 24u & 3u | tag_five_b) as u8;
-                *ptr::mut_offset(buf, off + 1u) =
-                    (code >> 18u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 2u) =
-                    (code >> 12u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 3u) =
-                    (code >> 6u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 4u) =
-                    (code & 63u | tag_cont) as u8;
-            } else if nb == 6u {
-                *ptr::mut_offset(buf, off) =
-                    (code >> 30u & 1u | tag_six_b) as u8;
-                *ptr::mut_offset(buf, off + 1u) =
-                    (code >> 24u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 2u) =
-                    (code >> 18u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 3u) =
-                    (code >> 12u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 4u) =
-                    (code >> 6u & 63u | tag_cont) as u8;
-                *ptr::mut_offset(buf, off + 5u) =
-                    (code & 63u | tag_cont) as u8;
+            match nb {
+                1u => {
+                    *ptr::mut_offset(buf, off) = code as u8;
+                }
+                2u => {
+                    *ptr::mut_offset(buf, off) = (code >> 6u & 31u | tag_two_b) as u8;
+                    *ptr::mut_offset(buf, off + 1u) = (code & 63u | tag_cont) as u8;
+                }
+                3u => {
+                    *ptr::mut_offset(buf, off) = (code >> 12u & 15u | tag_three_b) as u8;
+                    *ptr::mut_offset(buf, off + 1u) = (code >> 6u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 2u) = (code & 63u | tag_cont) as u8;
+                }
+                4u => {
+                    *ptr::mut_offset(buf, off) = (code >> 18u & 7u | tag_four_b) as u8;
+                    *ptr::mut_offset(buf, off + 1u) = (code >> 12u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 2u) = (code >> 6u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 3u) = (code & 63u | tag_cont) as u8;
+                }
+                5u => {
+                    *ptr::mut_offset(buf, off) = (code >> 24u & 3u | tag_five_b) as u8;
+                    *ptr::mut_offset(buf, off + 1u) = (code >> 18u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 2u) = (code >> 12u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 3u) = (code >> 6u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 4u) = (code & 63u | tag_cont) as u8;
+                }
+                6u => {
+                    *ptr::mut_offset(buf, off) = (code >> 30u & 1u | tag_six_b) as u8;
+                    *ptr::mut_offset(buf, off + 1u) = (code >> 24u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 2u) = (code >> 18u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 3u) = (code >> 12u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 4u) = (code >> 6u & 63u | tag_cont) as u8;
+                    *ptr::mut_offset(buf, off + 5u) = (code & 63u | tag_cont) as u8;
+                }
+                _ => {}
             }
         }
-
         raw::set_len(s, new_len);
     }
 }
diff --git a/src/libcore/unicode.rs b/src/libcore/unicode.rs
index d6e2c5eee6a..3b7fdcc85be 100644
--- a/src/libcore/unicode.rs
+++ b/src/libcore/unicode.rs
@@ -14,6 +14,7 @@
 
 pub mod general_category {
 
+    #[cfg(stage0)]
     fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
         use cmp::{Equal, Less, Greater};
         use vec::bsearch;
@@ -25,6 +26,18 @@ pub mod general_category {
         }) != None
     }
 
+    #[cfg(not(stage0))]
+    fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
+        use cmp::{Equal, Less, Greater};
+        use vec::bsearch;
+        use option::None;
+        (do bsearch(r) |&(lo,hi)| { cond!(
+            (lo <= c && c <= hi) { Equal   }
+            (hi < c)             { Less    }
+            _                    { Greater }
+        )}) != None
+    }
+
 
     static Cc_table : &'static [(char,char)] = &[
         ('\x00', '\x1f'), ('\x7f', '\x9f')
@@ -1449,8 +1462,7 @@ pub mod general_category {
 }
 
 pub mod derived_property {
-
-
+    #[cfg(stage0)]
     fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
         use cmp::{Equal, Less, Greater};
         use vec::bsearch;
@@ -1462,6 +1474,18 @@ pub mod derived_property {
         }) != None
     }
 
+    #[cfg(not(stage0))]
+    fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
+        use cmp::{Equal, Less, Greater};
+        use vec::bsearch;
+        use option::None;
+        (do bsearch(r) |&(lo,hi)| { cond!(
+            (lo <= c && c <= hi) { Equal   }
+            (hi < c)             { Less    }
+            _                    { Greater }
+        )}) != None
+    }
+
 
     static Alphabetic_table : &'static [(char,char)] = &[
         ('\x41', '\x5a'), ('\x61', '\x7a'),