Utilize fewer reexports

In regards to:

https://github.com/rust-lang/rust/issues/19253#issuecomment-64836729

This commit:

* Changes the #deriving code so that it generates code that utilizes fewer
  reexports (in particur Option::* and Result::*), which is necessary to
  remove those reexports in the future
* Changes other areas of the codebase so that fewer reexports are utilized

diff --git a/src/doc/reference.md b/src/doc/reference.md
index 47c25548af0ce5baaad773a22fb66f3a9e6aee85..9ac4469d549838e828b7ddfa16cbcfe58adda26c 100644 (file)
--- a/src/doc/reference.md
+++ b/src/doc/reference.md
@@ -994,7 +994,7 @@ An example of `use` declarations:
 
 ```
 use std::iter::range_step;
-use std::option::{Some, None};
+use std::option::Option::{Some, None};
 use std::collections::hash_map::{mod, HashMap};
 
 fn foo<T>(_: T){}
@@ -1004,8 +1004,8 @@ fn main() {
     // Equivalent to 'std::iter::range_step(0u, 10u, 2u);'
     range_step(0u, 10u, 2u);
 
-    // Equivalent to 'foo(vec![std::option::Some(1.0f64),
-    // std::option::None]);'
+    // Equivalent to 'foo(vec![std::option::Option::Some(1.0f64),
+    // std::option::Option::None]);'
     foo(vec![Some(1.0f64), None]);
 
     // Both `hash_map` and `HashMap` are in scope.

diff --git a/src/etc/unicode.py b/src/etc/unicode.py
index 15263919fb9b88f6fd321938fef03875ee207a68..20edf9418f1486c7cdd871da888cbb1ed753b716 100755 (executable)
--- a/src/etc/unicode.py
+++ b/src/etc/unicode.py
@@ -292,7 +292,7 @@ def escape_char(c):
 def emit_bsearch_range_table(f):
     f.write("""
 fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
-    use core::cmp::{Equal, Less, Greater};
+    use core::cmp::Ordering::{Equal, Less, Greater};
     use core::slice::SlicePrelude;
     r.binary_search(|&(lo,hi)| {
         if lo <= c && c <= hi { Equal }
@@ -350,10 +350,11 @@ def emit_regex_module(f, cats, w_data):
 def emit_conversions_module(f, lowerupper, upperlower):
     f.write("pub mod conversions {")
     f.write("""
-    use core::cmp::{Equal, Less, Greater};
+    use core::cmp::Ordering::{Equal, Less, Greater};
     use core::slice::SlicePrelude;
     use core::tuple::Tuple2;
-    use core::option::{Option, Some, None};
+    use core::option::Option;
+    use core::option::Option::{Some, None};
     use core::slice;
 
     pub fn to_lower(c: char) -> char {
@@ -403,7 +404,7 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
     f.write("""    }
 
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
-        use core::cmp::{Equal, Less, Greater};
+        use core::cmp::Ordering::{Equal, Less, Greater};
         match r.binary_search(|&(lo, hi, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
@@ -430,12 +431,13 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
 
 def emit_charwidth_module(f, width_table):
     f.write("pub mod charwidth {\n")
-    f.write("    use core::option::{Option, Some, None};\n")
+    f.write("    use core::option::Option;\n")
+    f.write("    use core::option::Option::{Some, None};\n")
     f.write("    use core::slice::SlicePrelude;\n")
     f.write("    use core::slice;\n")
     f.write("""
     fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
-        use core::cmp::{Equal, Less, Greater};
+        use core::cmp::Ordering::{Equal, Less, Greater};
         match r.binary_search(|&(lo, hi, _, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
@@ -530,7 +532,7 @@ def emit_norm_module(f, canon, compat, combine, norm_props):
 
     f.write("""
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
-        use core::cmp::{Equal, Less, Greater};
+        use core::cmp::Ordering::{Equal, Less, Greater};
         use core::slice::SlicePrelude;
         use core::slice;
         match r.binary_search(|&(lo, hi, _)| {

diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 4f744b0b2dee1b271a2e99e646871dd65cd92920..ef05279e825eaad799ae0c4aea4a4114d1f47da5 100644 (file)
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -22,7 +22,8 @@
 use core::mem::{min_align_of, size_of, drop};
 use core::mem;
 use core::ops::{Drop, Deref};
-use core::option::{Some, None, Option};
+use core::option::Option;
+use core::option::Option::{Some, None};
 use core::ptr::RawPtr;
 use core::ptr;
 use heap::deallocate;
@@ -326,7 +327,8 @@ mod tests {
     use std::comm::channel;
     use std::mem::drop;
     use std::ops::Drop;
-    use std::option::{Option, Some, None};
+    use std::option::Option;
+    use std::option::Option::{Some, None};
     use std::str::Str;
     use std::sync::atomic;
     use std::task;

diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 000dda59e3ddaeb3e3e38d095abdda7c8b9794e3..eb483498998c5f3beaf177d35910152347fb60df 100644 (file)
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -19,7 +19,8 @@
 use core::mem;
 use core::option::Option;
 use core::raw::TraitObject;
-use core::result::{Ok, Err, Result};
+use core::result::Result;
+use core::result::Result::{Ok, Err};
 
 /// A value that represents the global exchange heap. This is the default
 /// place that the `box` keyword allocates into when no place is supplied.

diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs
index 067c235c9ae493a3c17ac452b00fbd05547c0757..c6b6a784f06e3f912f085a9f1d0cc0e6f3f30426 100644 (file)
--- a/src/liballoc/heap.rs
+++ b/src/liballoc/heap.rs
@@ -177,7 +177,8 @@ mod imp {
 
 #[cfg(all(not(external_funcs), not(external_crate), jemalloc))]
 mod imp {
-    use core::option::{None, Option};
+    use core::option::Option;
+    use core::option::Option::None;
     use core::ptr::{null_mut, null};
     use core::num::Int;
     use libc::{c_char, c_int, c_void, size_t};

diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
index e626d63937bc2a84e00c93f2d268424a32985ed5..53891583edb20c768fa2068498511b8a76b2c5b8 100644 (file)
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@@ -149,10 +149,12 @@
 use core::kinds::marker;
 use core::mem::{transmute, min_align_of, size_of, forget};
 use core::ops::{Deref, Drop};
-use core::option::{Option, Some, None};
+use core::option::Option;
+use core::option::Option::{Some, None};
 use core::ptr;
 use core::ptr::RawPtr;
-use core::result::{Result, Ok, Err};
+use core::result::Result;
+use core::result::Result::{Ok, Err};
 
 use heap::deallocate;
 
@@ -739,8 +741,9 @@ fn inner(&self) -> &RcBox<T> { unsafe { &(*self._ptr) } }
 mod tests {
     use super::{Rc, Weak, weak_count, strong_count};
     use std::cell::RefCell;
-    use std::option::{Option, Some, None};
-    use std::result::{Err, Ok};
+    use std::option::Option;
+    use std::option::Option::{Some, None};
+    use std::result::Result::{Err, Ok};
     use std::mem::drop;
     use std::clone::Clone;
 

diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index ad0a5e76176464fdcd2611adc612d7e284d76b82..78cdda61104f1a8107cf775b255af07f7a4563b6 100644 (file)
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -833,8 +833,10 @@ mod tests {
     use std::default::Default;
     use std::char::Char;
     use std::clone::Clone;
-    use std::cmp::{Equal, Greater, Less, Ord, PartialOrd, Equiv};
-    use std::option::{Some, None};
+    use std::cmp::{Ord, PartialOrd, Equiv};
+    use std::cmp::Ordering::{Equal, Greater, Less};
+    use std::option::Option;
+    use std::option::Option::{Some, None};
     use std::ptr::RawPtr;
     use std::iter::{Iterator, IteratorExt, DoubleEndedIteratorExt};
 

diff --git a/src/libcore/any.rs b/src/libcore/any.rs
index 5d1f996831e5bc4068439c3de965ad42e54e10bc..75feb4d88289e5faf1343176b6eb3c1f3b7327ee 100644 (file)
--- a/src/libcore/any.rs
+++ b/src/libcore/any.rs
@@ -72,7 +72,8 @@
 #![stable]
 
 use mem::{transmute};
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use raw::TraitObject;
 use intrinsics::TypeId;
 

diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index ed4df10120272e934d650140a361032726738fab..1ec2efaf801a41c9bb3ba94740b3a7245df33848 100644 (file)
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -160,7 +160,8 @@
 use default::Default;
 use kinds::{marker, Copy};
 use ops::{Deref, DerefMut, Drop};
-use option::{None, Option, Some};
+use option::Option;
+use option::Option::{None, Some};
 
 /// A mutable memory location that admits only `Copy` data.
 #[unstable = "likely to be renamed; otherwise stable"]

diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index a729596e9d29029b2593a77f1f2741db112810e1..2bebe87a14ce4e1772fdc78a05227f562c6262fa 100644 (file)
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -16,7 +16,8 @@
 #![doc(primitive = "char")]
 
 use mem::transmute;
-use option::{None, Option, Some};
+use option::Option;
+use option::Option::{None, Some};
 use iter::{range_step, Iterator, RangeStep};
 use slice::SlicePrelude;
 

diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index df19256471ede6db1caffc05207901bdc2955564..a5ba2b03b1565b2b8fa0158a9e26ab71e1534bdf 100644 (file)
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -44,7 +44,8 @@
 pub use self::Ordering::*;
 
 use kinds::Sized;
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 
 /// Trait for values that can be compared for equality and inequality.
 ///
@@ -288,10 +289,11 @@ pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
 
 // Implementation of PartialEq, Eq, PartialOrd and Ord for primitive types
 mod impls {
-    use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering,
-              Less, Greater, Equal};
+    use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering};
+    use cmp::Ordering::{Less, Greater, Equal};
     use kinds::Sized;
-    use option::{Option, Some, None};
+    use option::Option;
+    use option::Option::{Some, None};
 
     macro_rules! partial_eq_impl(
         ($($t:ty)*) => ($(

diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index 1e31df837794273f0ed9fd27b7ad7970671e27ec..400ce76baa0d27a865a2f1051c6bb36070f363d4 100644 (file)
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -20,7 +20,7 @@
 use iter::{range, DoubleEndedIteratorExt};
 use num::{Float, FPNaN, FPInfinite, ToPrimitive};
 use num::cast;
-use result::Ok;
+use result::Result::Ok;
 use slice::{mod, SlicePrelude};
 use str::StrPrelude;
 

diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 7b9dd70c58f023d1ad481c423234f7ea1af949f8..9b67cdd3e1275dd1a3dfe5eb75075a3c89115c48 100644 (file)
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -17,9 +17,10 @@
 use iter::{Iterator, IteratorExt, range};
 use kinds::{Copy, Sized};
 use mem;
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use ops::Deref;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use result;
 use slice::SlicePrelude;
 use slice;

diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index f137f43058fa6b64c3a66f9bdd63b08e2840ab7a..49865bd3c7d5726117db086f6086f14bb6b542ea 100644 (file)
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -62,7 +62,8 @@
 use mem;
 use num::{ToPrimitive, Int};
 use ops::{Add, Deref};
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use uint;
 
 #[deprecated = "renamed to Extend"] pub use self::Extend as Extendable;
@@ -2458,7 +2459,9 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> {
 pub mod order {
     use cmp;
     use cmp::{Eq, Ord, PartialOrd, PartialEq};
-    use option::{Option, Some, None};
+    use cmp::Ordering::{Equal, Less, Greater};
+    use option::Option;
+    use option::Option::{Some, None};
     use super::Iterator;
 
     /// Compare `a` and `b` for equality using `Eq`
@@ -2476,11 +2479,11 @@ pub fn equals<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool
     pub fn cmp<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> cmp::Ordering {
         loop {
             match (a.next(), b.next()) {
-                (None, None) => return cmp::Equal,
-                (None, _   ) => return cmp::Less,
-                (_   , None) => return cmp::Greater,
+                (None, None) => return Equal,
+                (None, _   ) => return Less,
+                (_   , None) => return Greater,
                 (Some(x), Some(y)) => match x.cmp(&y) {
-                    cmp::Equal => (),
+                    Equal => (),
                     non_eq => return non_eq,
                 },
             }
@@ -2492,11 +2495,11 @@ pub fn partial_cmp<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut
             -> Option<cmp::Ordering> {
         loop {
             match (a.next(), b.next()) {
-                (None, None) => return Some(cmp::Equal),
-                (None, _   ) => return Some(cmp::Less),
-                (_   , None) => return Some(cmp::Greater),
+                (None, None) => return Some(Equal),
+                (None, _   ) => return Some(Less),
+                (_   , None) => return Some(Greater),
                 (Some(x), Some(y)) => match x.partial_cmp(&y) {
-                    Some(cmp::Equal) => (),
+                    Some(Equal) => (),
                     non_eq => return non_eq,
                 },
             }

diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 748e8942a3fea73887a27278db57b42df7ef848f..e6946c83cebdfc46af3e2c25b95807c7acfa7598 100644 (file)
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -30,7 +30,8 @@
 use mem::size_of;
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use str::{FromStr, from_str, StrPrelude};
 
 /// Simultaneous division and remainder

diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index ef895a1d7fbcca26920c7858c65b430a11f7f1da..8ba41c3575fff5cb2afa11b87b71d63899cc128c 100644 (file)
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -149,7 +149,8 @@
 use default::Default;
 use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, ExactSizeIterator};
 use mem;
-use result::{Result, Ok, Err};
+use result::Result;
+use result::Result::{Ok, Err};
 use slice;
 use slice::AsSlice;
 use clone::Clone;

diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 416bc4588b43ca03945b1fd1529d7ea36b2c04a5..3f6ac49786d2e393e41c583fabc0357ce5701648 100644 (file)
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -90,9 +90,12 @@
 use mem;
 use clone::Clone;
 use intrinsics;
-use option::{Some, None, Option};
+use option::Option;
+use option::Option::{Some, None};
 
-use cmp::{PartialEq, Eq, PartialOrd, Equiv, Ordering, Less, Equal, Greater};
+use cmp::{PartialEq, Eq, PartialOrd, Equiv};
+use cmp::Ordering;
+use cmp::Ordering::{Less, Equal, Greater};
 
 pub use intrinsics::copy_memory;
 pub use intrinsics::copy_nonoverlapping_memory;

diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 7c88106c9ecedf0693a324d7d9f4040fc8e98d6a..0cf8e6affd71e0a18121e5f03b4013299a51f153 100644 (file)
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -236,7 +236,8 @@
 use slice;
 use slice::AsSlice;
 use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, ExactSizeIterator};
-use option::{None, Option, Some};
+use option::Option;
+use option::Option::{None, Some};
 
 /// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
 ///

diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index ce9f551670bb576f9d93703cb8f74d5915163b49..b8df36c91bc3e699852c9065849ec582ad86fa7c 100644 (file)
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -36,13 +36,15 @@
 
 use mem::transmute;
 use clone::Clone;
-use cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering, Less, Equal, Greater, Equiv};
+use cmp::{Ordering, PartialEq, PartialOrd, Eq, Ord, Equiv};
+use cmp::Ordering::{Less, Equal, Greater};
 use cmp;
 use default::Default;
 use iter::*;
 use num::Int;
 use ops;
-use option::{None, Option, Some};
+use option::Option;
+use option::Option::{None, Some};
 use ptr;
 use ptr::RawPtr;
 use mem;
@@ -1702,7 +1704,8 @@ pub mod raw {
     use mem::transmute;
     use ptr::RawPtr;
     use raw::Slice;
-    use option::{None, Option, Some};
+    use option::Option;
+    use option::Option::{None, Some};
 
     /// Form a slice from a pointer and length (as a number of units,
     /// not bytes).

diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 4be628f0ac3b3c757ca4af02beea1d88dc12ade6..1d59567cbe4474d7dc4c862fa58310262129aaf1 100644 (file)
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -29,7 +29,8 @@
 use kinds::Sized;
 use mem;
 use num::Int;
-use option::{Option, None, Some};
+use option::Option;
+use option::Option::{None, Some};
 use ptr::RawPtr;
 use raw::{Repr, Slice};
 use slice::{mod, SlicePrelude};
@@ -1209,9 +1210,11 @@ pub unsafe fn slice_unchecked<'a>(s: &'a str, begin: uint, end: uint) -> &'a str
 
 #[allow(missing_docs)]
 pub mod traits {
-    use cmp::{Ord, Ordering, Less, Equal, Greater, PartialEq, PartialOrd, Equiv, Eq};
+    use cmp::{Ordering, Ord, PartialEq, PartialOrd, Equiv, Eq};
+    use cmp::Ordering::{Less, Equal, Greater};
     use iter::IteratorExt;
-    use option::{Option, Some};
+    use option::Option;
+    use option::Option::Some;
     use ops;
     use str::{Str, StrPrelude, eq_slice};
 

diff --git a/src/libcore/tuple/mod.rs b/src/libcore/tuple/mod.rs
index 56ea7a4e7a1e98f724d6b50ea07b86d8d91b8f33..5ad01ae67442e6b4abf91bbfe48f43467c8dc80d 100644 (file)
--- a/src/libcore/tuple/mod.rs
+++ b/src/libcore/tuple/mod.rs
@@ -69,7 +69,8 @@
 use clone::Clone;
 use cmp::*;
 use default::Default;
-use option::{Option, Some};
+use option::Option;
+use option::Option::Some;
 
 // macro for implementing n-ary tuple functions and operations
 macro_rules! tuple_impls {

diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
index 0cd1ded21d6c6cdd269a12e5b3c6209ff0bae9a4..6ee3633d36c14dc64e81d68c217c23737ca2a657 100644 (file)
--- a/src/libcoretest/num/mod.rs
+++ b/src/libcoretest/num/mod.rs
@@ -48,7 +48,8 @@ pub fn test_num<T>(ten: T, two: T) where
 
 #[cfg(test)]
 mod test {
-    use core::option::{Option, Some, None};
+    use core::option::Option;
+    use core::option::Option::{Some, None};
     use core::num::Float;
     use core::num::from_str_radix;
 

diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs
index 1204ac18f99dc1c5f11e23a2b91bbf3e3ae569e3..e146e3c76eb2f22cb582d7e694e2ccfa8ca4f287 100644 (file)
--- a/src/libgetopts/lib.rs
+++ b/src/libgetopts/lib.rs
@@ -99,7 +99,7 @@
 use self::Optval::*;
 
 use std::fmt;
-use std::result::{Err, Ok};
+use std::result::Result::{Err, Ok};
 use std::result;
 use std::string::String;
 
@@ -951,7 +951,7 @@ mod tests {
     use super::*;
     use super::Fail::*;
 
-    use std::result::{Err, Ok};
+    use std::result::Result::{Err, Ok};
     use std::result;
 
     // Tests for reqopt
@@ -1392,8 +1392,8 @@ fn test_multi() {
         let args_single = vec!("-e".to_string(), "foo".to_string());
         let matches_single = &match getopts(args_single.as_slice(),
                                             opts.as_slice()) {
-          result::Ok(m) => m,
-          result::Err(_) => panic!()
+          result::Result::Ok(m) => m,
+          result::Result::Err(_) => panic!()
         };
         assert!(matches_single.opts_present(&["e".to_string()]));
         assert!(matches_single.opts_present(&["encrypt".to_string(), "e".to_string()]));
@@ -1412,8 +1412,8 @@ fn test_multi() {
                              "foo".to_string());
         let matches_both = &match getopts(args_both.as_slice(),
                                           opts.as_slice()) {
-          result::Ok(m) => m,
-          result::Err(_) => panic!()
+          result::Result::Ok(m) => m,
+          result::Result::Err(_) => panic!()
         };
         assert!(matches_both.opts_present(&["e".to_string()]));
         assert!(matches_both.opts_present(&["encrypt".to_string()]));
@@ -1437,8 +1437,8 @@ fn test_nospace() {
         let opts = vec!(optmulti("L", "", "library directory", "LIB"),
                      optmulti("M", "", "something", "MMMM"));
         let matches = &match getopts(args.as_slice(), opts.as_slice()) {
-          result::Ok(m) => m,
-          result::Err(_) => panic!()
+          result::Result::Ok(m) => m,
+          result::Result::Err(_) => panic!()
         };
         assert!(matches.opts_present(&["L".to_string()]));
         assert_eq!(matches.opts_str(&["L".to_string()]).unwrap(), "foo".to_string());
@@ -1453,8 +1453,8 @@ fn test_nospace_conflict() {
         let opts = vec!(optmulti("L", "", "library directory", "LIB"),
                      optflagmulti("v", "verbose", "Verbose"));
         let matches = &match getopts(args.as_slice(), opts.as_slice()) {
-          result::Ok(m) => m,
-          result::Err(e) => panic!( "{}", e )
+          result::Result::Ok(m) => m,
+          result::Result::Err(e) => panic!( "{}", e )
         };
         assert!(matches.opts_present(&["L".to_string()]));
         assert_eq!(matches.opts_str(&["L".to_string()]).unwrap(), "verbose".to_string());

diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
index 6f3fbe1251008dc5991aaae2f81f87a8f8d8a4c0..f65c4f4e3edcc06cc890b90da0b5bc23b53eec62 100644 (file)
--- a/src/librbml/lib.rs
+++ b/src/librbml/lib.rs
@@ -120,7 +120,8 @@ pub mod reader {
     use std::io::extensions::u64_from_be_bytes;
     use std::mem::transmute;
     use std::num::Int;
-    use std::option::{None, Option, Some};
+    use std::option::Option;
+    use std::option::Option::{None, Some};
 
     use serialize;
 
@@ -1060,7 +1061,8 @@ mod tests {
 
     use serialize::{Encodable, Decodable};
 
-    use std::option::{None, Option, Some};
+    use std::option::Option;
+    use std::option::Option::{None, Some};
 
     #[test]
     fn test_vuint_at() {

diff --git a/src/librustc_trans/trans/cabi.rs b/src/librustc_trans/trans/cabi.rs
index 0214bf29eeeb972f8d26278531d442de0544c9f3..518b0ba73f8b745744f5010384768bb5b11786e1 100644 (file)
--- a/src/librustc_trans/trans/cabi.rs
+++ b/src/librustc_trans/trans/cabi.rs
@@ -65,8 +65,8 @@ pub fn indirect(ty: Type, attr: option::Option<Attribute>) -> ArgType {
         ArgType {
             kind: Indirect,
             ty: ty,
-            cast: option::None,
-            pad: option::None,
+            cast: option::Option::None,
+            pad: option::Option::None,
             attr: attr
         }
     }

diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs
index 2b8a52f050d6f81d070e91dfb2440abb636fddcb..9eb0e17b8e5beafe3fd7efafcb8b01094f6766c1 100644 (file)
--- a/src/librustc_typeck/check/demand.rs
+++ b/src/librustc_typeck/check/demand.rs
@@ -15,8 +15,7 @@
 use middle::infer::resolve_type;
 use middle::infer::resolve::try_resolve_tvar_shallow;
 
-use std::result::{Err, Ok};
-use std::result;
+use std::result::Result::{Err, Ok};
 use syntax::ast;
 use syntax::codemap::Span;
 use util::ppaux::Repr;
@@ -38,8 +37,8 @@ pub fn suptype_with_fn<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
     // n.b.: order of actual, expected is reversed
     match infer::mk_subty(fcx.infcx(), b_is_expected, infer::Misc(sp),
                           ty_b, ty_a) {
-      result::Ok(()) => { /* ok */ }
-      result::Err(ref err) => {
+      Ok(()) => { /* ok */ }
+      Err(ref err) => {
           handle_err(sp, ty_a, ty_b, err);
       }
     }
@@ -69,8 +68,8 @@ pub fn coerce<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span,
                      try_resolve_tvar_shallow).unwrap_or(expected)
     } else { expected };
     match fcx.mk_assignty(expr, expr_ty, expected) {
-      result::Ok(()) => { /* ok */ }
-      result::Err(ref err) => {
+      Ok(()) => { /* ok */ }
+      Err(ref err) => {
         fcx.report_mismatched_types(sp, expected, expr_ty, err);
       }
     }

diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 403ca9d14321a0301f722ad321d2cc88440694fe..8fc3c23e88f153dc203ef25a77b5984b2615a3a1 100644 (file)
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -19,7 +19,8 @@
 use fmt;
 use iter::IteratorExt;
 use mem;
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use slice::{SlicePrelude, AsSlice};
 use str::{Str, StrPrelude};
 use string::{String, IntoString};

diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs
index d8023dd3e4e3bcf2c1be18d6b685fedc9fe2ba8d..8a90c06f0385c1395cc04dabd84af37a56e7defa 100644 (file)
--- a/src/libstd/bitflags.rs
+++ b/src/libstd/bitflags.rs
@@ -149,9 +149,9 @@ pub fn bits(&self) -> $T {
             #[inline]
             pub fn from_bits(bits: $T) -> ::std::option::Option<$BitFlags> {
                 if (bits & !$BitFlags::all().bits()) != 0 {
-                    ::std::option::None
+                    ::std::option::Option::None
                 } else {
-                    ::std::option::Some($BitFlags { bits: bits })
+                    ::std::option::Option::Some($BitFlags { bits: bits })
                 }
             }
 
@@ -261,7 +261,7 @@ fn not(&self) -> $BitFlags {
 #[allow(non_upper_case_globals)]
 mod tests {
     use hash;
-    use option::{Some, None};
+    use option::Option::{Some, None};
     use ops::{BitOr, BitAnd, BitXor, Sub, Not};
 
     bitflags! {

diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 1f94d7b4fa6117ae6ccc09e5f87ca53dc3586ff7..f89876f7245e60c861a73df35ce717f58d1df24e 100644 (file)
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -38,7 +38,8 @@
 use kinds::Send;
 use mem;
 use ops::Drop;
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use ptr::RawPtr;
 use ptr;
 use raw;

diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index cf09c93f91785ef35913a52ca2c7f020e94d366d..8f879bd50d0b3944acbcc41e79b24a6c9a7e8e08 100644 (file)
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -25,8 +25,10 @@
 use mem::{mod, replace};
 use num::{Int, UnsignedInt};
 use ops::{Deref, Index, IndexMut};
-use option::{Some, None, Option};
-use result::{Result, Ok, Err};
+use option::Option;
+use option::Option::{Some, None};
+use result::Result;
+use result::Result::{Ok, Err};
 
 use super::table;
 use super::table::{

diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index b40622171d52a2ab2c187262ddaf76e667c92eee..fd32d207e79e095ad94f14b94d819678c6b67ab8 100644 (file)
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -19,8 +19,8 @@
 use hash::{Hash, Hasher, RandomSipHasher};
 use iter::{Iterator, IteratorExt, FromIterator, FilterMap, Chain, Repeat, Zip, Extend, repeat};
 use iter;
-use option::{Some, None};
-use result::{Ok, Err};
+use option::Option::{Some, None};
+use result::Result::{Ok, Err};
 
 use super::map::{HashMap, Entries, MoveEntries, INITIAL_CAPACITY};
 

diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
index f41ccea0aaf0370dff35ceb188edaa58b01f0893..de06a1e0bbd6e5bb33b99a4d1fcd285cdd9c9db3 100644 (file)
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -21,7 +21,8 @@
 use mem;
 use num::{Int, UnsignedInt};
 use ops::{Deref, DerefMut, Drop};
-use option::{Some, None, Option};
+use option::Option;
+use option::Option::{Some, None};
 use ptr::{RawPtr, copy_nonoverlapping_memory, zero_memory};
 use ptr;
 use rt::heap::{allocate, deallocate};

diff --git a/src/libstd/collections/lru_cache.rs b/src/libstd/collections/lru_cache.rs
index 94bea37d187284630b25533b41e1903db3c4e797..adbc135364be7fc73e8f6b5103414943fcbc7596 100644 (file)
--- a/src/libstd/collections/lru_cache.rs
+++ b/src/libstd/collections/lru_cache.rs
@@ -44,10 +44,11 @@
 use iter::{range, Iterator, Extend};
 use mem;
 use ops::Drop;
-use option::{Some, None, Option};
+use option::Option;
+use option::Option::{Some, None};
 use boxed::Box;
 use ptr;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 
 // FIXME(conventions): implement iterators?
 // FIXME(conventions): implement indexing?

diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs
index 160365dac361223453acc70d19c9b4790edece75..aa0c8b53c2e897f4d123337156df11d828404a87 100644 (file)
--- a/src/libstd/dynamic_lib.rs
+++ b/src/libstd/dynamic_lib.rs
@@ -280,7 +280,8 @@ pub mod dl {
     use libc;
     use os;
     use ptr;
-    use result::{Ok, Err, Result};
+    use result::Result;
+    use result::Result::{Ok, Err};
     use slice::SlicePrelude;
     use str::StrPrelude;
     use str;

diff --git a/src/libstd/error.rs b/src/libstd/error.rs
index 82ad893f88a1a04cce4e85f3dae27d0be84422fa..9ad2655f6e9dbd30e08b5b64cb49839754e767d2 100644 (file)
--- a/src/libstd/error.rs
+++ b/src/libstd/error.rs
@@ -78,7 +78,8 @@
 //! }
 //! ```
 
-use option::{Option, None};
+use option::Option;
+use option::Option::None;
 use kinds::Send;
 use string::String;
 

diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs
index d839c1484e56216492131f57df96eb384dfb9876..58a41f4d7d5a1cfab71b25ea2f35bdd2e922870e 100644 (file)
--- a/src/libstd/failure.rs
+++ b/src/libstd/failure.rs
@@ -16,8 +16,9 @@
 use fmt;
 use io::{Writer, IoResult};
 use kinds::Send;
-use option::{Some, None, Option};
-use result::Ok;
+use option::Option;
+use option::Option::{Some, None};
+use result::Result::Ok;
 use rt::backtrace;
 use rustrt::{Stderr, Stdio};
 use rustrt::local::Local;

diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs
index 7e1bfd704a9275af3bdde7e8314bb826fd224d82..6a2047d1cef30dffe4383168dd65084ac645cbd5 100644 (file)
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@@ -406,7 +406,7 @@
 
 use io::Writer;
 use io;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use string;
 use vec::Vec;
 

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index fba9e4f2e25e1445baea71efd37619d28202752e..0b2c6843c968e33c22566313cc8eac64b4e940b4 100644 (file)
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -16,8 +16,9 @@
 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
 use iter::ExactSizeIterator;
 use ops::Drop;
-use option::{Some, None, Option};
-use result::{Ok, Err};
+use option::Option;
+use option::Option::{Some, None};
+use result::Result::{Ok, Err};
 use slice::{SlicePrelude};
 use slice;
 use vec::Vec;

diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index a90b6bbbb8e8e4188f7b82097a2e39b84fac82f8..3de0a7be95e8bc8500d5db75dbe5c3584a8c7119 100644 (file)
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -12,8 +12,8 @@
 use cmp;
 use comm::{Sender, Receiver};
 use io;
-use option::{None, Some};
-use result::{Ok, Err};
+use option::Option::{None, Some};
+use result::Result::{Ok, Err};
 use slice::{bytes, CloneSliceAllocPrelude, SlicePrelude};
 use super::{Buffer, Reader, Writer, IoResult};
 use vec::Vec;

diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 4b2ffb4d559c443da994b00354900029e79f97bf..1bdf99f6d6dce82d1048c0a1173fdd209df641e8 100644 (file)
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -19,9 +19,10 @@
 use io;
 use iter::Iterator;
 use num::Int;
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use ptr::RawPtr;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use slice::{SlicePrelude, AsSlice};
 
 /// An iterator that reads a single byte on each iteration,

diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index e52c00f8247a81a71257410c913cab354937fbbf..86b2dc4d94053a8bba0c6efb709970d29157fd1e 100644 (file)
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -59,10 +59,11 @@
 use io::UpdateIoError;
 use io;
 use iter::{Iterator, Extend};
-use option::{Some, None, Option};
+use option::Option;
+use option::Option::{Some, None};
 use path::{Path, GenericPath};
 use path;
-use result::{Err, Ok};
+use result::Result::{Err, Ok};
 use slice::SlicePrelude;
 use string::String;
 use vec::Vec;

diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 8a329a5d27c08b61e3c5f2e368cc6f0d32394042..39ddbab0bd58d06ce4fa743a8571c4107370a383 100644 (file)
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -15,8 +15,8 @@
 #![allow(deprecated)]
 
 use cmp::min;
-use option::None;
-use result::{Err, Ok};
+use option::Option::None;
+use result::Result::{Err, Ok};
 use io;
 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
 use slice::{mod, AsSlice, SlicePrelude};

diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index b2e4fc75cf2387bd7068589bd49bf487cdd6a0aa..e0857fd27ffdf35a0649cd60dedd87bfdbda3d2e 100644 (file)
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -233,10 +233,12 @@
 use iter::{Iterator, IteratorExt};
 use mem::transmute;
 use ops::{BitOr, BitXor, BitAnd, Sub, Not};
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use os;
 use boxed::Box;
-use result::{Ok, Err, Result};
+use result::Result;
+use result::Result::{Ok, Err};
 use sys;
 use slice::{AsSlice, SlicePrelude};
 use str::{Str, StrPrelude};

diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs
index 7de786921309153ed13eb6eb214c32980c17583a..fea8372733c29d7833f338b13c025d543f53dd46 100644 (file)
--- a/src/libstd/io/net/addrinfo.rs
+++ b/src/libstd/io/net/addrinfo.rs
@@ -22,7 +22,8 @@
 use iter::IteratorExt;
 use io::{IoResult};
 use io::net::ip::{SocketAddr, IpAddr};
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use sys;
 use vec::Vec;
 

diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index 4812e911cc4812ce6497a56ff0306e41700551bc..9c0fbbe274b3eb5bbeee9b1c884861f8a6b7a445 100644 (file)
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -21,8 +21,9 @@
 use io::{mod, IoResult, IoError};
 use io::net;
 use iter::{Iterator, IteratorExt};
-use option::{Option, None, Some};
-use result::{Ok, Err};
+use option::Option;
+use option::Option::{None, Some};
+use result::Result::{Ok, Err};
 use str::{FromStr, StrPrelude};
 use slice::{CloneSlicePrelude, SlicePrelude};
 use vec::Vec;

diff --git a/src/libstd/io/net/mod.rs b/src/libstd/io/net/mod.rs
index 5b1747876d7e0c537226ad6b5c6db166269a6dbf..09e5639bea9440424c339f8ae5bf97286a0e8c76 100644 (file)
--- a/src/libstd/io/net/mod.rs
+++ b/src/libstd/io/net/mod.rs
@@ -11,8 +11,8 @@
 //! Networking I/O
 
 use io::{IoError, IoResult, InvalidInput};
-use option::None;
-use result::{Ok, Err};
+use option::Option::None;
+use result::Result::{Ok, Err};
 use self::ip::{SocketAddr, ToSocketAddr};
 
 pub use self::addrinfo::get_host_addresses;

diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index aa2234175917c3c3e7dff2c9de72919b9dbe7ad6..a7b1b077eff0b1b46cc7d88828a38c6ccbaabe4c 100644 (file)
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -19,11 +19,12 @@
 
 use clone::Clone;
 use io::IoResult;
-use result::Err;
+use result::Result::Err;
 use io::net::ip::{SocketAddr, ToSocketAddr};
 use io::{Reader, Writer, Listener, Acceptor};
 use io::{standard_error, TimedOut};
-use option::{None, Some, Option};
+use option::Option;
+use option::Option::{None, Some};
 use time::Duration;
 
 use sys::tcp::TcpStream as TcpStreamImp;

diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index a7239ca0f2f984b7d607cc9f0884954bb196b913..a2ad365dd2a0e2f64ff02eb0c36a06b614687ee6 100644 (file)
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -19,7 +19,7 @@
 use io::net::ip::{SocketAddr, IpAddr, ToSocketAddr};
 use io::{Reader, Writer, IoResult};
 use option::Option;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use sys::udp::UdpSocket as UdpSocketImp;
 use sys_common;
 

diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs
index 305bcf9ecbc9cf9194d95f8b917b53ebf60801cd..32965d23971ed132de3376e702d907d6bc9d1b60 100644 (file)
--- a/src/libstd/io/result.rs
+++ b/src/libstd/io/result.rs
@@ -15,7 +15,7 @@
 //! as a `Reader` without unwrapping the result first.
 
 use clone::Clone;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use super::{Reader, Writer, Listener, Acceptor, Seek, SeekStyle, IoResult};
 
 impl<W: Writer> Writer for IoResult<W> {

diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index ad5dcf71df737e304ed1a3ef276d030324fbdb24..cf2df0da7fe7b05befb242baa4024bc8d5b583ae 100644 (file)
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -37,9 +37,10 @@
 use kinds::Send;
 use libc;
 use mem;
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use ops::{Deref, DerefMut};
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use rustrt;
 use rustrt::local::Local;
 use rustrt::task::Task;

diff --git a/src/libstd/io/tempfile.rs b/src/libstd/io/tempfile.rs
index 4788ba79b7fa8451f684d8e614b5c9a90bb6d541..f3a119399952d7c1ee02fc0a840eef26bb288d08 100644 (file)
--- a/src/libstd/io/tempfile.rs
+++ b/src/libstd/io/tempfile.rs
@@ -14,10 +14,11 @@
 use io;
 use libc;
 use ops::Drop;
-use option::{Option, None, Some};
+use option::Option;
+use option::Option::{None, Some};
 use os;
 use path::{Path, GenericPath};
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use sync::atomic;
 
 /// A wrapper for a path to temporary directory implementing automatic

diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index a8adfec34ed683c48ed07f56e5244e4d14d4bd10..ba9bcc05546cd4d0786d981bd98fae03de0d1a9d 100644 (file)
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -40,14 +40,16 @@
 use libc;
 use boxed::Box;
 use ops::Drop;
-use option::{Some, None, Option};
+use option::Option;
+use option::Option::{Some, None};
 use os;
 use path::{Path, GenericPath, BytesContainer};
 use sys;
 use sys::os as os_imp;
 use ptr::RawPtr;
 use ptr;
-use result::{Err, Ok, Result};
+use result::Result;
+use result::Result::{Err, Ok};
 use slice::{AsSlice, SlicePrelude, PartialEqSlicePrelude};
 use slice::CloneSliceAllocPrelude;
 use str::{Str, StrPrelude, StrAllocating};
@@ -160,7 +162,8 @@ pub fn getcwd() -> IoResult<Path> {
 pub mod windows {
     use libc::types::os::arch::extra::DWORD;
     use libc;
-    use option::{None, Option};
+    use option::Option;
+    use option::Option::None;
     use option;
     use os::TMPBUF_SZ;
     use slice::{SlicePrelude};
@@ -196,7 +199,7 @@ pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD)
                     // set `res` to None and continue.
                     let s = String::from_utf16(sub)
                         .expect("fill_utf16_buf_and_decode: closure created invalid UTF-16");
-                    res = option::Some(s)
+                    res = option::Option::Some(s)
                 }
             }
             return res;
@@ -1797,7 +1800,7 @@ fn test_num_cpus() {
     fn test_setenv() {
         let n = make_rand_name();
         setenv(n.as_slice(), "VALUE");
-        assert_eq!(getenv(n.as_slice()), option::Some("VALUE".to_string()));
+        assert_eq!(getenv(n.as_slice()), option::Option::Some("VALUE".to_string()));
     }
 
     #[test]
@@ -1805,7 +1808,7 @@ fn test_unsetenv() {
         let n = make_rand_name();
         setenv(n.as_slice(), "VALUE");
         unsetenv(n.as_slice());
-        assert_eq!(getenv(n.as_slice()), option::None);
+        assert_eq!(getenv(n.as_slice()), option::Option::None);
     }
 
     #[test]
@@ -1814,9 +1817,9 @@ fn test_setenv_overwrite() {
         let n = make_rand_name();
         setenv(n.as_slice(), "1");
         setenv(n.as_slice(), "2");
-        assert_eq!(getenv(n.as_slice()), option::Some("2".to_string()));
+        assert_eq!(getenv(n.as_slice()), option::Option::Some("2".to_string()));
         setenv(n.as_slice(), "");
-        assert_eq!(getenv(n.as_slice()), option::Some("".to_string()));
+        assert_eq!(getenv(n.as_slice()), option::Option::Some("".to_string()));
     }
 
     // Windows GetEnvironmentVariable requires some extra work to make sure
@@ -1833,7 +1836,7 @@ fn test_getenv_big() {
         let n = make_rand_name();
         setenv(n.as_slice(), s.as_slice());
         debug!("{}", s.clone());
-        assert_eq!(getenv(n.as_slice()), option::Some(s));
+        assert_eq!(getenv(n.as_slice()), option::Option::Some(s));
     }
 
     #[test]
@@ -1870,7 +1873,7 @@ fn test_env_getenv() {
             // MingW seems to set some funky environment variables like
             // "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned
             // from env() but not visible from getenv().
-            assert!(v2.is_none() || v2 == option::Some(v));
+            assert!(v2.is_none() || v2 == option::Option::Some(v));
         }
     }
 
@@ -1957,7 +1960,7 @@ fn homedir() {
 
     #[test]
     fn memory_map_rw() {
-        use result::{Ok, Err};
+        use result::Result::{Ok, Err};
 
         let chunk = match os::MemoryMap::new(16, &[
             os::MapReadable,
@@ -1976,7 +1979,7 @@ fn memory_map_rw() {
 
     #[test]
     fn memory_map_file() {
-        use result::{Ok, Err};
+        use result::Result::{Ok, Err};
         use os::*;
         use libc::*;
         use io::fs;

diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index b17106e811f622f5201baf2d6624020c2bc01cd8..01b42395471fc5ea6630dd92a9fba32add809f6f 100644 (file)
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -66,7 +66,8 @@
 use clone::Clone;
 use fmt;
 use iter::IteratorExt;
-use option::{Option, None, Some};
+use option::Option;
+use option::Option::{None, Some};
 use str;
 use str::{CowString, MaybeOwned, Str, StrPrelude};
 use string::String;

diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index f6778588addb9f0c8ce3f6ec8af058d6e55ec715..d6d27daf4ae8bd5770ca71ddffc5d55669a5060a 100644 (file)
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -17,7 +17,8 @@
 use io::Writer;
 use iter::{DoubleEndedIteratorExt, AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map};
-use option::{Option, None, Some};
+use option::Option;
+use option::Option::{None, Some};
 use kinds::Sized;
 use str::{FromStr, Str};
 use str;

diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 13891a63330144da656fdd005f12b13ede1fcb9a..08e318d32b9fc8ca42ce7b661b99381c0c33c26a 100644 (file)
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -23,7 +23,8 @@
 use iter::{AdditiveIterator, DoubleEndedIteratorExt, Extend};
 use iter::{Iterator, IteratorExt, Map};
 use mem;
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use slice::{AsSlice, SlicePrelude};
 use str::{CharSplits, FromStr, Str, StrAllocating, StrVector, StrPrelude};
 use string::String;

diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index da690f5d154df658ea66267c5e4b9ab47142ef80..413d9267152ebdcc07323c3e654a2a20145c800d 100644 (file)
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -227,7 +227,7 @@
 use iter::{Iterator, IteratorExt};
 use mem;
 use rc::Rc;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use vec::Vec;
 
 #[cfg(not(target_word_size="64"))]

diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index 2a4d8347c30c9a68aa061f0118e1acd2de654777..37628b65388e7d20266838e50c06072e7fd0fd50 100644 (file)
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -23,7 +23,7 @@ mod imp {
     use path::Path;
     use rand::Rng;
     use rand::reader::ReaderRng;
-    use result::{Ok, Err};
+    use result::Result::{Ok, Err};
     use slice::SlicePrelude;
     use mem;
     use os::errno;
@@ -173,7 +173,7 @@ mod imp {
     use mem;
     use os;
     use rand::Rng;
-    use result::{Ok};
+    use result::Result::{Ok};
     use self::libc::{c_int, size_t};
     use slice::{SlicePrelude};
 
@@ -240,7 +240,7 @@ mod imp {
     use ops::Drop;
     use os;
     use rand::Rng;
-    use result::{Ok, Err};
+    use result::Result::{Ok, Err};
     use self::libc::{DWORD, BYTE, LPCSTR, BOOL};
     use self::libc::types::os::arch::extra::{LONG_PTR};
     use slice::{SlicePrelude};

diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index 796bf7853f73bbb3d2b95f8ea1883a25f8f8d7ff..ca6322247c2ab0a3bc60cae03e9b9819781fae5c 100644 (file)
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -12,7 +12,7 @@
 
 use io::Reader;
 use rand::Rng;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use slice::SlicePrelude;
 
 /// An RNG that reads random bytes straight from a `Reader`. This will

diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 159fc3080e836aba0adfbcb74a53d15e6c5a8233..3698a91855cd621fcf664ec0386eaa7956f159c6 100644 (file)
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -14,9 +14,9 @@
 
 use io::{IoResult, Writer};
 use iter::{Iterator, IteratorExt};
-use option::{Some, None};
+use option::Option::{Some, None};
 use os;
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use str::{StrPrelude, from_str};
 use sync::atomic;
 use unicode::char::UnicodeChar;
@@ -236,8 +236,9 @@ mod imp {
     use io::{IoResult, Writer};
     use libc;
     use mem;
-    use option::{Some, None, Option};
-    use result::{Ok, Err};
+    use option::Option;
+    use option::Option::{Some, None};
+    use result::Result::{Ok, Err};
     use sync::{StaticMutex, MUTEX_INIT};
 
     /// As always - iOS on arm uses SjLj exceptions and
@@ -664,9 +665,9 @@ mod imp {
     use libc;
     use mem;
     use ops::Drop;
-    use option::{Some, None};
+    use option::Option::{Some, None};
     use path::Path;
-    use result::{Ok, Err};
+    use result::Result::{Ok, Err};
     use sync::{StaticMutex, MUTEX_INIT};
     use slice::SlicePrelude;
     use str::StrPrelude;

diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index 92657d1b59bee8723bcdbb57fdc363d08912ec0d..ce359c7b0e00630cb00380ab4261ac80a5eca55a 100644 (file)
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -9,7 +9,8 @@
 // except according to those terms.
 
 use libc::uintptr_t;
-use option::{Some, None, Option};
+use option::Option;
+use option::Option::{Some, None};
 use os;
 use str::{FromStr, from_str, Str};
 use sync::atomic;

diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs
index 4b47b768d600c5176dda94dba70e8974b1032f0a..a773ef7e31747c9c1623ee4657de672b4e48616b 100644 (file)
--- a/src/libstd/sys/unix/fs.rs
+++ b/src/libstd/sys/unix/fs.rs
@@ -20,7 +20,7 @@
 use io::{FilePermission, Write, UnstableFileStat, Open, FileAccess, FileMode};
 use io::{IoResult, FileStat, SeekStyle, Reader};
 use io::{Read, Truncate, SeekCur, SeekSet, ReadWrite, SeekEnd, Append};
-use result::{Ok, Err};
+use result::Result::{Ok, Err};
 use sys::retry;
 use sys_common::{keep_going, eof, mkerr_libc};
 

diff --git a/src/libstd/task.rs b/src/libstd/task.rs
index a0ee08570d90d03050573a72d906b34fea994315..8b4dbf61c181d448291b0f2bfb30c88cfa375b3f 100644 (file)
--- a/src/libstd/task.rs
+++ b/src/libstd/task.rs
@@ -49,7 +49,8 @@
 use comm::channel;
 use io::{Writer, stdio};
 use kinds::{Send, marker};
-use option::{None, Some, Option};
+use option::Option;
+use option::Option::{None, Some};
 use result::Result;
 use rustrt::local::Local;
 use rustrt::task::Task;
@@ -172,9 +173,10 @@ pub fn spawn(self, f: proc():Send) {
     /// # Return value
     ///
     /// If the child task executes successfully (without panicking) then the
-    /// future returns `result::Ok` containing the value returned by the
-    /// function. If the child task panics then the future returns `result::Err`
-    /// containing the argument to `panic!(...)` as an `Any` trait object.
+    /// future returns `result::Result::Ok` containing the value returned by the
+    /// function. If the child task panics then the future returns
+    /// `result::Result::Err` containing the argument to `panic!(...)` as an
+    /// `Any` trait object.
     #[experimental = "Futures are experimental."]
     pub fn try_future<T:Send>(self, f: proc():Send -> T)
                               -> Future<Result<T, Box<Any + Send>>> {
@@ -268,7 +270,7 @@ mod test {
     use borrow::IntoCow;
     use boxed::BoxAny;
     use prelude::*;
-    use result::{Ok, Err};
+    use result::Result::{Ok, Err};
     use result;
     use std::io::{ChanReader, ChanWriter};
     use string::String;
@@ -330,7 +332,7 @@ fn test_try_success() {
         match try(proc() {
             "Success!".to_string()
         }).as_ref().map(|s| s.as_slice()) {
-            result::Ok("Success!") => (),
+            result::Result::Ok("Success!") => (),
             _ => panic!()
         }
     }
@@ -340,8 +342,8 @@ fn test_try_panic() {
         match try(proc() {
             panic!()
         }) {
-            result::Err(_) => (),
-            result::Ok(()) => panic!()
+            result::Result::Err(_) => (),
+            result::Result::Ok(()) => panic!()
         }
     }
 

diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs
index e2e8461ea54d44d9aa356f0a2b3ac7ed6b4fcd4a..029b8bf1138779a6fab4b2c15e01317c125df14f 100644 (file)
--- a/src/libstd/thread_local/mod.rs
+++ b/src/libstd/thread_local/mod.rs
@@ -115,7 +115,7 @@ macro_rules! thread_local(
             use std::cell::UnsafeCell as __UnsafeCell;
             use std::thread_local::KeyInner as __KeyInner;
             use std::option::Option as __Option;
-            use std::option::None as __None;
+            use std::option::Option::None as __None;
 
             __thread_local_inner!(static __KEY: __UnsafeCell<__Option<$t>> = {
                 __UnsafeCell { value: __None }
@@ -132,7 +132,7 @@ fn __getit() -> &'static __KeyInner<__UnsafeCell<__Option<$t>>> {
             use std::cell::UnsafeCell as __UnsafeCell;
             use std::thread_local::KeyInner as __KeyInner;
             use std::option::Option as __Option;
-            use std::option::None as __None;
+            use std::option::Option::None as __None;
 
             __thread_local_inner!(static __KEY: __UnsafeCell<__Option<$t>> = {
                 __UnsafeCell { value: __None }
@@ -198,7 +198,7 @@ macro_rules! __thread_local_inner(
                 inner: ::std::cell::UnsafeCell { value: $init },
                 os: ::std::thread_local::OsStaticKey {
                     inner: ::std::thread_local::OS_INIT_INNER,
-                    dtor: ::std::option::Some(__destroy),
+                    dtor: ::std::option::Option::Some(__destroy),
                 },
             }
         };

diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs
index ec2d62ff85cb183df7c1c6173646e6e2f71df698..63eb9a9873624a4d580e0bdc01a06b0ea7f62564 100644 (file)
--- a/src/libstd/time/duration.rs
+++ b/src/libstd/time/duration.rs
@@ -14,9 +14,11 @@
 
 use {fmt, i64};
 use ops::{Add, Sub, Mul, Div, Neg};
-use option::{Option, Some, None};
+use option::Option;
+use option::Option::{Some, None};
 use num::Int;
-use result::{Result, Ok, Err};
+use result::Result;
+use result::Result::{Ok, Err};
 
 /// The number of nanoseconds in a microsecond.
 const NANOS_PER_MICRO: i32 = 1000;
@@ -387,7 +389,7 @@ fn div_rem_64(this: i64, other: i64) -> (i64, i64) {
 mod tests {
     use super::{Duration, MIN, MAX};
     use {i32, i64};
-    use option::{Some, None};
+    use option::Option::{Some, None};
     use string::ToString;
 
     #[test]

diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index bd01e5e643020315703951e5a97f888badfeffea..b4bb1a1a52963cbdeff903363e5316c7129166ad 100644 (file)
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -680,6 +680,7 @@ fn expr_some(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
         let some = vec!(
             self.ident_of("std"),
             self.ident_of("option"),
+            self.ident_of("Option"),
             self.ident_of("Some"));
         self.expr_call_global(sp, some, vec!(expr))
     }
@@ -688,6 +689,7 @@ fn expr_none(&self, sp: Span) -> P<ast::Expr> {
         let none = self.path_global(sp, vec!(
             self.ident_of("std"),
             self.ident_of("option"),
+            self.ident_of("Option"),
             self.ident_of("None")));
         self.expr_path(none)
     }
@@ -732,6 +734,7 @@ fn expr_ok(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
         let ok = vec!(
             self.ident_of("std"),
             self.ident_of("result"),
+            self.ident_of("Result"),
             self.ident_of("Ok"));
         self.expr_call_global(sp, ok, vec!(expr))
     }
@@ -740,6 +743,7 @@ fn expr_err(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
         let err = vec!(
             self.ident_of("std"),
             self.ident_of("result"),
+            self.ident_of("Result"),
             self.ident_of("Err"));
         self.expr_call_global(sp, err, vec!(expr))
     }
@@ -810,6 +814,7 @@ fn pat_some(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
         let some = vec!(
             self.ident_of("std"),
             self.ident_of("option"),
+            self.ident_of("Option"),
             self.ident_of("Some"));
         let path = self.path_global(span, some);
         self.pat_enum(span, path, vec!(pat))
@@ -819,6 +824,7 @@ fn pat_none(&self, span: Span) -> P<ast::Pat> {
         let some = vec!(
             self.ident_of("std"),
             self.ident_of("option"),
+            self.ident_of("Option"),
             self.ident_of("None"));
         let path = self.path_global(span, some);
         self.pat_enum(span, path, vec!())
@@ -828,6 +834,7 @@ fn pat_ok(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
         let some = vec!(
             self.ident_of("std"),
             self.ident_of("result"),
+            self.ident_of("Result"),
             self.ident_of("Ok"));
         let path = self.path_global(span, some);
         self.pat_enum(span, path, vec!(pat))
@@ -837,6 +844,7 @@ fn pat_err(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
         let some = vec!(
             self.ident_of("std"),
             self.ident_of("result"),
+            self.ident_of("Result"),
             self.ident_of("Err"));
         let path = self.path_global(span, some);
         self.pat_enum(span, path, vec!(pat))

diff --git a/src/libsyntax/ext/deriving/cmp/ord.rs b/src/libsyntax/ext/deriving/cmp/ord.rs
index 98345e1dd6724854634fd411b7cfd4d1df9108ec..787c6e844d5141e53f87059d6fe70ab890e3af66 100644 (file)
--- a/src/libsyntax/ext/deriving/cmp/ord.rs
+++ b/src/libsyntax/ext/deriving/cmp/ord.rs
@@ -105,6 +105,7 @@ pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span,
     let ordering = cx.path_global(span,
                                   vec!(cx.ident_of("std"),
                                        cx.ident_of("cmp"),
+                                       cx.ident_of("Ordering"),
                                        cx.ident_of("Equal")));
     let ordering = cx.expr_path(ordering);
     let equals_expr = cx.expr_some(span, ordering);
@@ -120,9 +121,9 @@ pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span,
     Builds:
 
     let __test = ::std::cmp::PartialOrd::partial_cmp(&self_field1, &other_field1);
-    if __test == ::std::option::Some(::std::cmp::Equal) {
+    if __test == ::std::option::Option::Some(::std::cmp::Ordering::Equal) {
         let __test = ::std::cmp::PartialOrd::partial_cmp(&self_field2, &other_field2);
-        if __test == ::std::option::Some(::std::cmp::Equal) {
+        if __test == ::std::option::Option::Some(::std::cmp::Ordering::Equal) {
             ...
         } else {
             __test
@@ -139,7 +140,7 @@ pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span,
         false,
         |cx, span, old, self_f, other_fs| {
             // let __test = new;
-            // if __test == Some(::std::cmp::Equal) {
+            // if __test == Some(::std::cmp::Ordering::Equal) {
             //    old
             // } else {
             //    __test

diff --git a/src/libsyntax/ext/deriving/cmp/totalord.rs b/src/libsyntax/ext/deriving/cmp/totalord.rs
index d84ad677e5df50f85fe44f9d6dbb05ae67e49ba8..83af45462ec6e212a3cac37da74dc15222ed459b 100644 (file)
--- a/src/libsyntax/ext/deriving/cmp/totalord.rs
+++ b/src/libsyntax/ext/deriving/cmp/totalord.rs
@@ -70,9 +70,9 @@ pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
     Builds:
 
     let __test = self_field1.cmp(&other_field2);
-    if other == ::std::cmp::Equal {
+    if other == ::std::cmp::Ordering::Equal {
         let __test = self_field2.cmp(&other_field2);
-        if __test == ::std::cmp::Equal {
+        if __test == ::std::cmp::Ordering::Equal {
             ...
         } else {
             __test
@@ -89,7 +89,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
         false,
         |cx, span, old, new| {
             // let __test = new;
-            // if __test == ::std::cmp::Equal {
+            // if __test == ::std::cmp::Ordering::Equal {
             //    old
             // } else {
             //    __test

diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs
index 87e257c52cd25d631ab116c62cb710bb928ca089..e6a44c57f1b6581a8cc810ae559160ef20401b4f 100644 (file)
--- a/src/libsyntax/ext/env.rs
+++ b/src/libsyntax/ext/env.rs
@@ -36,6 +36,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT
                                    true,
                                    vec!(cx.ident_of("std"),
                                         cx.ident_of("option"),
+                                        cx.ident_of("Option"),
                                         cx.ident_of("None")),
                                    Vec::new(),
                                    vec!(cx.ty_rptr(sp,
@@ -50,6 +51,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT
           cx.expr_call_global(sp,
                               vec!(cx.ident_of("std"),
                                    cx.ident_of("option"),
+                                   cx.ident_of("Option"),
                                    cx.ident_of("Some")),
                               vec!(cx.expr_str(sp,
                                                token::intern_and_get_ident(

diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs
index d644542db0732532ccf49db2121b5c77cb57f613..3c909a3c708429ee34d969df83187911fb7e7b50 100644 (file)
--- a/src/libterm/terminfo/parm.rs
+++ b/src/libterm/terminfo/parm.rs
@@ -576,7 +576,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,String> {
 #[cfg(test)]
 mod test {
     use super::{expand,Param,Words,Variables,Number};
-    use std::result::Ok;
+    use std::result::Result::Ok;
 
     #[test]
     fn test_basic_setabf() {

diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs
index a77a6276a8b4ecc7122d4c196dc8040a6964ecdb..06a0df852b93623e24db19a3090ddb493d050121 100644 (file)
--- a/src/libtime/lib.rs
+++ b/src/libtime/lib.rs
@@ -1262,7 +1262,7 @@ mod tests {
                 InvalidFormatSpecifier};
 
     use std::f64;
-    use std::result::{Err, Ok};
+    use std::result::Result::{Err, Ok};
     use std::time::Duration;
     use self::test::Bencher;
 

diff --git a/src/libunicode/normalize.rs b/src/libunicode/normalize.rs
index cd46fc6a56dd0a85732c73eb7d6b637f6fad4dc4..29a8b1204b85603640436cc12d8b57b33fcfb798 100644 (file)
--- a/src/libunicode/normalize.rs
+++ b/src/libunicode/normalize.rs
@@ -10,8 +10,9 @@
 
 //! Functions for computing canonical and compatible decompositions for Unicode characters.
 
-use core::cmp::{Equal, Less, Greater};
-use core::option::{Option, Some, None};
+use core::cmp::Ordering::{Equal, Less, Greater};
+use core::option::Option;
+use core::option::Option::{Some, None};
 use core::slice;
 use core::slice::SlicePrelude;
 use tables::normalization::{canonical_table, compatibility_table, composition_table};

diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs
index 7cece6701dc85c0367362ec64ca365ca7a8d0a26..c91ce5c6464e854fd2aa5087f5aba9e2b12a7408 100644 (file)
--- a/src/libunicode/tables.rs
+++ b/src/libunicode/tables.rs
@@ -17,7 +17,7 @@
 pub const UNICODE_VERSION: (uint, uint, uint) = (7, 0, 0);
 
 fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
-    use core::cmp::{Equal, Less, Greater};
+    use core::cmp::Ordering::{Equal, Less, Greater};
     use core::slice::SlicePrelude;
     r.binary_search(|&(lo,hi)| {
         if lo <= c && c <= hi { Equal }
@@ -6241,7 +6241,7 @@ pub mod normalization {
 
 
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
-        use core::cmp::{Equal, Less, Greater};
+        use core::cmp::Ordering::{Equal, Less, Greater};
         use core::slice::SlicePrelude;
         use core::slice;
         match r.binary_search(|&(lo, hi, _)| {
@@ -6366,10 +6366,11 @@ pub fn canonical_combining_class(c: char) -> u8 {
 }
 
 pub mod conversions {
-    use core::cmp::{Equal, Less, Greater};
+    use core::cmp::Ordering::{Equal, Less, Greater};
     use core::slice::SlicePrelude;
     use core::tuple::Tuple2;
-    use core::option::{Option, Some, None};
+    use core::option::Option;
+    use core::option::Option::{Some, None};
     use core::slice;
 
     pub fn to_lower(c: char) -> char {
@@ -6934,12 +6935,13 @@ fn bsearch_case_table(c: char, table: &'static [(char, char)]) -> Option<uint> {
 }
 
 pub mod charwidth {
-    use core::option::{Option, Some, None};
+    use core::option::Option;
+    use core::option::Option::{Some, None};
     use core::slice::SlicePrelude;
     use core::slice;
 
     fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
-        use core::cmp::{Equal, Less, Greater};
+        use core::cmp::Ordering::{Equal, Less, Greater};
         match r.binary_search(|&(lo, hi, _, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
@@ -7154,7 +7156,7 @@ pub enum GraphemeCat {
     }
 
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
-        use core::cmp::{Equal, Less, Greater};
+        use core::cmp::Ordering::{Equal, Less, Greater};
         match r.binary_search(|&(lo, hi, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }

diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs
index a5f761425759510a168fcf25601433ba1dd538ed..e4b2b682b2cffddbe62419edd58436f44d7226a4 100644 (file)
--- a/src/libunicode/u_str.rs
+++ b/src/libunicode/u_str.rs
@@ -21,7 +21,8 @@
 use core::iter::{Filter, AdditiveIterator, Iterator, IteratorExt};
 use core::iter::{DoubleEndedIterator, DoubleEndedIteratorExt};
 use core::kinds::Sized;
-use core::option::{Option, None, Some};
+use core::option::Option;
+use core::option::Option::{None, Some};
 use core::str::{CharSplits, StrPrelude};
 use u_char::UnicodeChar;
 use tables::grapheme::GraphemeCat;

diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index 4005c11e6b614a463d0570d9288e876fdd6ed5b9..45d2cbea8fad985d7f52a8d3bd9b25a788998c9d 100644 (file)
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -77,8 +77,8 @@ fn sortKV(mut orig: Vec<(Vec<u8> ,f64)> ) -> Vec<(Vec<u8> ,f64)> {
 fn find(mm: &HashMap<Vec<u8> , uint>, key: String) -> uint {
    let key = key.into_ascii().as_slice().to_lowercase().into_string();
    match mm.get(key.as_bytes()) {
-      option::None      => { return 0u; }
-      option::Some(&num) => { return num; }
+      option::Option::None      => { return 0u; }
+      option::Option::Some(&num) => { return num; }
    }
 }
 
@@ -190,8 +190,8 @@ fn main() {
            // start processing if this is the one
            ('>', false) => {
                match line.as_slice().slice_from(1).find_str("THREE") {
-                   option::Some(_) => { proc_mode = true; }
-                   option::None    => { }
+                   option::Option::Some(_) => { proc_mode = true; }
+                   option::Option::None    => { }
                }
            }
 

diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 9cc86e91fbed719c80268fb506883fb0e1489ee5..15a5cb0c9bfffcbf01f95c2a2544805443541086 100644 (file)
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -21,7 +21,7 @@
 extern crate getopts;
 
 use std::os;
-use std::result::{Ok, Err};
+use std::result::Result::{Ok, Err};
 use std::task;
 use std::time::Duration;
 

diff --git a/src/test/compile-fail/lint-unused-imports.rs b/src/test/compile-fail/lint-unused-imports.rs
index d9bf722f73e4230f9a4e63df29f874006cc3b7db..b1a6c82a734fe20003c2f342cc03dbd3dccf8eee 100644 (file)
--- a/src/test/compile-fail/lint-unused-imports.rs
+++ b/src/test/compile-fail/lint-unused-imports.rs
@@ -18,8 +18,8 @@
                             // everything imported
 
 // Should get errors for both 'Some' and 'None'
-use std::option::{Some, None}; //~ ERROR unused import
-                                //~^ ERROR unused import
+use std::option::Option::{Some, None}; //~ ERROR unused import
+                                     //~^ ERROR unused import
 
 use test::A;       //~ ERROR unused import
 // Be sure that if we just bring some methods into scope that they're also

diff --git a/src/test/run-fail/result-get-panic.rs b/src/test/run-fail/result-get-panic.rs
index 6098b97c79a947a8f2e9a01a5de8623bdeceb30a..df14efd6c3a97a1ea46e0260c2f7f221f2d2348f 100644 (file)
--- a/src/test/run-fail/result-get-panic.rs
+++ b/src/test/run-fail/result-get-panic.rs
@@ -10,8 +10,8 @@
 
 // error-pattern:called `Result::unwrap()` on an `Err` value
 
-use std::result;
+use std::result::Result::Err;
 
 fn main() {
-    println!("{}", result::Err::<int,String>("kitty".to_string()).unwrap());
+    println!("{}", Err::<int,String>("kitty".to_string()).unwrap());
 }

diff --git a/src/test/run-pass/deriving-cmp-shortcircuit.rs b/src/test/run-pass/deriving-cmp-shortcircuit.rs
index fd59b804da3769c93bb027f19b265d14cbb9ea95..b68d8058381d2322c67c3e97ee6787db203b4972 100644 (file)
--- a/src/test/run-pass/deriving-cmp-shortcircuit.rs
+++ b/src/test/run-pass/deriving-cmp-shortcircuit.rs
@@ -39,5 +39,5 @@ pub fn main() {
 
     assert!(a != b);
     assert!(a < b);
-    assert_eq!(a.cmp(&b), ::std::cmp::Less);
+    assert_eq!(a.cmp(&b), ::std::cmp::Ordering::Less);
 }

diff --git a/src/test/run-pass/deriving-self-lifetime-totalord-totaleq.rs b/src/test/run-pass/deriving-self-lifetime-totalord-totaleq.rs
index 1187a9a8bc4a768cae546898576d1625131719f3..d63c264479a93b9cf1012b2fd939fd31473fb979 100644 (file)
--- a/src/test/run-pass/deriving-self-lifetime-totalord-totaleq.rs
+++ b/src/test/run-pass/deriving-self-lifetime-totalord-totaleq.rs
@@ -10,7 +10,7 @@
 
 // ignore-test FIXME #11820: & is unreliable in deriving
 
-use std::cmp::{Less,Equal,Greater};
+use std::cmp::Ordering::{Less,Equal,Greater};
 
 #[deriving(Eq,Ord)]
 struct A<'a> {

diff --git a/src/test/run-pass/enum-nullable-const-null-with-fields.rs b/src/test/run-pass/enum-nullable-const-null-with-fields.rs
index a48f3bcd59ca41e6ecc577d4cc595bd495246928..4b839d740fc7aeaecf574b9adf9f7394b734c0d4 100644 (file)
--- a/src/test/run-pass/enum-nullable-const-null-with-fields.rs
+++ b/src/test/run-pass/enum-nullable-const-null-with-fields.rs
@@ -8,7 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::result::{Result,Ok};
+use std::result::Result;
+use std::result::Result::Ok;
 
 static C: Result<(), Box<int>> = Ok(());
 

diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs
index ec19b95ab1a48a5bd7ca936428160ab2349555f8..6f1f2cea8ec3ce3182840f057878d2918f0a8347 100644 (file)
--- a/src/test/run-pass/issue-2804.rs
+++ b/src/test/run-pass/issue-2804.rs
@@ -24,14 +24,14 @@ enum object {
 fn lookup(table: json::Object, key: String, default: String) -> String
 {
     match table.find(&key.to_string()) {
-        option::Some(&Json::String(ref s)) => {
+        option::Option::Some(&Json::String(ref s)) => {
             s.to_string()
         }
-        option::Some(value) => {
+        option::Option::Some(value) => {
             println!("{} was expected to be a string but is a {}", key, value);
             default
         }
-        option::None => {
+        option::Option::None => {
             default
         }
     }

diff --git a/src/test/run-pass/issue-3424.rs b/src/test/run-pass/issue-3424.rs
index 2dac64b2ec81ffc3cdf5013f15a0bf935e1d956e..81efacb9bcbadb876ce1d95cb02b84e42ea16800 100644 (file)
--- a/src/test/run-pass/issue-3424.rs
+++ b/src/test/run-pass/issue-3424.rs
@@ -20,7 +20,7 @@
 fn tester()
 {
     let loader: rsrc_loader = proc(_path) {
-        result::Ok("more blah".to_string())
+        result::Result::Ok("more blah".to_string())
     };
 
     let path = path::Path::new("blah");

diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index 520d067bca326a8e2cdb771702b0c478128823a4..da1ad094df6a035effb8e693b581bd3d393bc310 100644 (file)
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -41,9 +41,9 @@ macro_rules! check_option {
         check_option!($e: $T, |ptr| assert!(*ptr == $e));
     }};
     ($e:expr: $T:ty, |$v:ident| $chk:expr) => {{
-        assert!(option::None::<$T>.is_none());
+        assert!(option::Option::None::<$T>.is_none());
         let e = $e;
-        let s_ = option::Some::<$T>(e);
+        let s_ = option::Option::Some::<$T>(e);
         let $v = s_.as_ref().unwrap();
         $chk
     }}

diff --git a/src/test/run-pass/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs
index ef485723c7e2b7c189b449f3fc1d5ee29927e8d6..1b0f2ec0a327f72390f321ad9e116841a7e1113d 100644 (file)
--- a/src/test/run-pass/send_str_hashmap.rs
+++ b/src/test/run-pass/send_str_hashmap.rs
@@ -11,7 +11,7 @@
 extern crate collections;
 
 use std::collections::HashMap;
-use std::option::Some;
+use std::option::Option::Some;
 use std::str::SendStr;
 
 pub fn main() {

diff --git a/src/test/run-pass/send_str_treemap.rs b/src/test/run-pass/send_str_treemap.rs
index f72ca109b6e68e2946a90574c2e9ad8057a6419c..9334b673b515e9630527a0e21c44ec39f80b3563 100644 (file)
--- a/src/test/run-pass/send_str_treemap.rs
+++ b/src/test/run-pass/send_str_treemap.rs
@@ -11,7 +11,7 @@
 extern crate collections;
 
 use self::collections::TreeMap;
-use std::option::Some;
+use std::option::Option::Some;
 use std::str::SendStr;
 use std::string::ToString;