---

yaml
---
r: 276543
b: refs/heads/try
c: 13877ac
h: refs/heads/master
i:
  276541: 9f53847
  276539: 05dcd25
  276535: 909b26a
  276527: bde2411
  276511: 2655537
  276479: 1837f60

Author: nikomatsakis

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: 671027817c6ef7351db6dbb47cfac42cf5f0707a
+refs/heads/try: 13877ac4428cc9cbf6b07ad98e0f0b152381fac7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/mk/tests.mk

@@ -383,7 +383,7 @@ $(3)/stage$(1)/test/$(4)test-$(2)$$(X_$(2)): \
 	@$$(call E, rustc: $$@)
 	$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(2)) \
 	    $$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) -o $$@ $$< --test \
-		-Cmetadata="test-crate" -L "$$(RT_OUTPUT_DIR_$(2))" \
+		-L "$$(RT_OUTPUT_DIR_$(2))" \
 		$$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
 		$$(RUSTFLAGS_$(4))
 

branches/try/src/compiletest/common.rs

@@ -69,10 +69,10 @@ impl fmt::Display for Mode {
 #[derive(Clone)]
 pub struct Config {
     // The library paths required for running the compiler
-    pub compile_lib_path: PathBuf,
+    pub compile_lib_path: String,
 
     // The library paths required for running compiled programs
-    pub run_lib_path: PathBuf,
+    pub run_lib_path: String,
 
     // The rustc executable
     pub rustc_path: PathBuf,

branches/try/src/compiletest/compiletest.rs

@@ -118,17 +118,9 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         }
     }
 
-    fn make_absolute(path: PathBuf) -> PathBuf {
-        if path.is_relative() {
-            env::current_dir().unwrap().join(path)
-        } else {
-            path
-        }
-    }
-
     Config {
-        compile_lib_path: make_absolute(opt_path(matches, "compile-lib-path")),
-        run_lib_path: make_absolute(opt_path(matches, "run-lib-path")),
+        compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
+        run_lib_path: matches.opt_str("run-lib-path").unwrap(),
         rustc_path: opt_path(matches, "rustc-path"),
         rustdoc_path: opt_path(matches, "rustdoc-path"),
         python: matches.opt_str("python").unwrap(),

branches/try/src/compiletest/runtest.rs

@@ -316,7 +316,7 @@ fn run_pretty_test_revision(config: &Config,
                                      testpaths,
                                      pretty_type.to_owned()),
                         props.exec_env.clone(),
-                        config.compile_lib_path.to_str().unwrap(),
+                        &config.compile_lib_path,
                         Some(aux_dir.to_str().unwrap()),
                         Some(src))
     }
@@ -635,7 +635,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testpaths: &TestPa
                                                   testpaths,
                                                   proc_args,
                                                   environment,
-                                                  config.run_lib_path.to_str().unwrap(),
+                                                  &config.run_lib_path,
                                                   None,
                                                   None);
         }
@@ -1315,7 +1315,7 @@ fn exec_compiled_test(config: &Config, props: &TestProps,
                             testpaths,
                             make_run_args(config, props, testpaths),
                             env,
-                            config.run_lib_path.to_str().unwrap(),
+                            &config.run_lib_path,
                             Some(aux_dir.to_str().unwrap()),
                             None)
         }
@@ -1387,7 +1387,7 @@ fn compose_and_run_compiler(config: &Config, props: &TestProps,
                                      &aux_testpaths,
                                      aux_args,
                                      Vec::new(),
-                                     config.compile_lib_path.to_str().unwrap(),
+                                     &config.compile_lib_path,
                                      Some(aux_dir.to_str().unwrap()),
                                      None);
         if !auxres.status.success() {
@@ -1410,7 +1410,7 @@ fn compose_and_run_compiler(config: &Config, props: &TestProps,
                     testpaths,
                     args,
                     props.rustc_env.clone(),
-                    config.compile_lib_path.to_str().unwrap(),
+                    &config.compile_lib_path,
                     Some(aux_dir.to_str().unwrap()),
                     input)
 }

branches/try/src/doc/book/drop.md

@@ -55,7 +55,7 @@ BOOM times 100!!!
 BOOM times 1!!!
 ```
 
-The `tnt` goes off before the `firecracker` does, because it was declared
+The TNT goes off before the firecracker does, because it was declared
 afterwards. Last in, first out.
 
 So what is `Drop` good for? Generally, `Drop` is used to clean up any resources

branches/try/src/libcore/clone.rs

@@ -18,29 +18,6 @@
 //! them cheap and safe to copy. For other types copies must be made
 //! explicitly, by convention implementing the `Clone` trait and calling
 //! the `clone` method.
-//!
-//! Basic usage example:
-//!
-//! ```
-//! let s = String::new(); // String type implements Clone
-//! let copy = s.clone(); // so we can clone it
-//! ```
-//!
-//! To easily implement the Clone trait, you can also use
-//! `#[derive(Clone)]`. Example:
-//!
-//! ```
-//! #[derive(Clone)] // we add the Clone trait to Morpheus struct
-//! struct Morpheus {
-//!    blue_pill: f32,
-//!    red_pill: i64,
-//! }
-//!
-//! fn main() {
-//!    let f = Morpheus { blue_pill: 0.0, red_pill: 0 };
-//!    let copy = f.clone(); // and now we can clone it!
-//! }
-//! ```
 
 #![stable(feature = "rust1", since = "1.0.0")]
 

branches/try/src/libcore/ops.rs

@@ -1446,24 +1446,7 @@ pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
     fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
 }
 
-/// An unbounded range. Use `..` (two dots) for its shorthand.
-///
-/// Its primary use case is slicing index. It cannot serve as an iterator
-/// because it doesn't have a starting point.
-///
-/// # Examples
-///
-/// ```
-/// fn main() {
-///     assert_eq!((..), std::ops::RangeFull);
-///
-///     let arr = [0, 1, 2, 3];
-///     assert_eq!(arr[ .. ], [0,1,2,3]);  // RangeFull
-///     assert_eq!(arr[ ..3], [0,1,2  ]);
-///     assert_eq!(arr[1.. ], [  1,2,3]);
-///     assert_eq!(arr[1..3], [  1,2  ]);
-/// }
-/// ```
+/// An unbounded range.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeFull;
@@ -1475,26 +1458,7 @@ impl fmt::Debug for RangeFull {
     }
 }
 
-/// A (half-open) range which is bounded at both ends: { x | start <= x < end }.
-/// Use `start..end` (two dots) for its shorthand.
-///
-/// See the [`contains()`](#method.contains) method for its characterization.
-///
-/// # Examples
-///
-/// ```
-/// #![feature(iter_arith)]
-/// fn main() {
-///     assert_eq!((3..5), std::ops::Range{ start: 3, end: 5 });
-///     assert_eq!(3+4+5, (3..6).sum());
-///
-///     let arr = [0, 1, 2, 3];
-///     assert_eq!(arr[ .. ], [0,1,2,3]);
-///     assert_eq!(arr[ ..3], [0,1,2  ]);
-///     assert_eq!(arr[1.. ], [  1,2,3]);
-///     assert_eq!(arr[1..3], [  1,2  ]);  // Range
-/// }
-/// ```
+/// A (half-open) range which is bounded at both ends.
 #[derive(Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Range<Idx> {
@@ -1513,47 +1477,7 @@ impl<Idx: fmt::Debug> fmt::Debug for Range<Idx> {
     }
 }
 
-#[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
-impl<Idx: PartialOrd<Idx>> Range<Idx> {
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(range_contains)]
-    /// fn main() {
-    ///     assert!( ! (3..5).contains(2));
-    ///     assert!(   (3..5).contains(3));
-    ///     assert!(   (3..5).contains(4));
-    ///     assert!( ! (3..5).contains(5));
-    ///
-    ///     assert!( ! (3..3).contains(3));
-    ///     assert!( ! (3..2).contains(3));
-    /// }
-    /// ```
-    pub fn contains(&self, item: Idx) -> bool {
-        (self.start <= item) && (item < self.end)
-    }
-}
-
-/// A range which is only bounded below: { x | start <= x }.
-/// Use `start..` for its shorthand.
-///
-/// See the [`contains()`](#method.contains) method for its characterization.
-///
-/// # Examples
-///
-/// ```
-/// #![feature(iter_arith)]
-/// fn main() {
-///     assert_eq!((2..), std::ops::RangeFrom{ start: 2 });
-///     assert_eq!(2+3+4, (2..).take(3).sum());
-///
-///     let arr = [0, 1, 2, 3];
-///     assert_eq!(arr[ .. ], [0,1,2,3]);
-///     assert_eq!(arr[ ..3], [0,1,2  ]);
-///     assert_eq!(arr[1.. ], [  1,2,3]);  // RangeFrom
-///     assert_eq!(arr[1..3], [  1,2  ]);
-/// }
-/// ```
+/// A range which is only bounded below.
 #[derive(Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeFrom<Idx> {
@@ -1569,40 +1493,7 @@ impl<Idx: fmt::Debug> fmt::Debug for RangeFrom<Idx> {
     }
 }
 
-#[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
-impl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(range_contains)]
-    /// fn main() {
-    ///     assert!( ! (3..).contains(2));
-    ///     assert!(   (3..).contains(3));
-    ///     assert!(   (3..).contains(1_000_000_000));
-    /// }
-    /// ```
-    pub fn contains(&self, item: Idx) -> bool {
-        (self.start <= item)
-    }
-}
-
-/// A range which is only bounded above: { x | x < end }.
-/// Use `..end` (two dots) for its shorthand.
-///
-/// See the [`contains()`](#method.contains) method for its characterization.
-///
-/// It cannot serve as an iterator because it doesn't have a starting point.
-/// ```
-/// fn main() {
-///     assert_eq!((..5), std::ops::RangeTo{ end: 5 });
-///
-///     let arr = [0, 1, 2, 3];
-///     assert_eq!(arr[ .. ], [0,1,2,3]);
-///     assert_eq!(arr[ ..3], [0,1,2  ]);  // RangeTo
-///     assert_eq!(arr[1.. ], [  1,2,3]);
-///     assert_eq!(arr[1..3], [  1,2  ]);
-/// }
-/// ```
+/// A range which is only bounded above.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeTo<Idx> {
@@ -1618,41 +1509,7 @@ impl<Idx: fmt::Debug> fmt::Debug for RangeTo<Idx> {
     }
 }
 
-#[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
-impl<Idx: PartialOrd<Idx>> RangeTo<Idx> {
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(range_contains)]
-    /// fn main() {
-    ///     assert!(   (..5).contains(-1_000_000_000));
-    ///     assert!(   (..5).contains(4));
-    ///     assert!( ! (..5).contains(5));
-    /// }
-    /// ```
-    pub fn contains(&self, item: Idx) -> bool {
-        (item < self.end)
-    }
-}
-
-/// An inclusive range which is bounded at both ends: { x | start <= x <= end }.
-/// Use `start...end` (three dots) for its shorthand.
-///
-/// See the [`contains()`](#method.contains) method for its characterization.
-///
-/// # Examples
-///
-/// ```
-/// #![feature(inclusive_range,inclusive_range_syntax,iter_arith)]
-/// fn main() {
-///     assert_eq!((3...5), std::ops::RangeInclusive::NonEmpty{ start: 3, end: 5 });
-///     assert_eq!(3+4+5, (3...5).sum());
-///
-///     let arr = [0, 1, 2, 3];
-///     assert_eq!(arr[ ...2], [0,1,2  ]);
-///     assert_eq!(arr[1...2], [  1,2  ]);  // RangeInclusive
-/// }
-/// ```
+/// An inclusive range which is bounded at both ends.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
 pub enum RangeInclusive<Idx> {
@@ -1715,49 +1572,7 @@ impl<Idx: PartialOrd + One + Sub<Output=Idx>> From<Range<Idx>> for RangeInclusiv
     }
 }
 
-#[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
-impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(range_contains,inclusive_range_syntax)]
-    /// fn main() {
-    ///     assert!( ! (3...5).contains(2));
-    ///     assert!(   (3...5).contains(3));
-    ///     assert!(   (3...5).contains(4));
-    ///     assert!(   (3...5).contains(5));
-    ///     assert!( ! (3...5).contains(6));
-    ///
-    ///     assert!(   (3...3).contains(3));
-    ///     assert!( ! (3...2).contains(3));
-    /// }
-    /// ```
-    pub fn contains(&self, item: Idx) -> bool {
-        if let &RangeInclusive::NonEmpty{ref start, ref end} = self {
-            (*start <= item) && (item <= *end)
-        } else { false }
-    }
-}
-
-/// An inclusive range which is only bounded above: { x | x <= end }.
-/// Use `...end` (three dots) for its shorthand.
-///
-/// See the [`contains()`](#method.contains) method for its characterization.
-///
-/// It cannot serve as an iterator because it doesn't have a starting point.
-///
-/// # Examples
-///
-/// ```
-/// #![feature(inclusive_range,inclusive_range_syntax)]
-/// fn main() {
-///     assert_eq!((...5), std::ops::RangeToInclusive{ end: 5 });
-///
-///     let arr = [0, 1, 2, 3];
-///     assert_eq!(arr[ ...2], [0,1,2  ]);  // RangeToInclusive
-///     assert_eq!(arr[1...2], [  1,2  ]);
-/// }
-/// ```
+/// An inclusive range which is only bounded above.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
 pub struct RangeToInclusive<Idx> {
@@ -1775,23 +1590,6 @@ impl<Idx: fmt::Debug> fmt::Debug for RangeToInclusive<Idx> {
     }
 }
 
-#[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
-impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(range_contains,inclusive_range_syntax)]
-    /// fn main() {
-    ///     assert!(   (...5).contains(-1_000_000_000));
-    ///     assert!(   (...5).contains(5));
-    ///     assert!( ! (...5).contains(6));
-    /// }
-    /// ```
-    pub fn contains(&self, item: Idx) -> bool {
-        (item <= self.end)
-    }
-}
-
 // RangeToInclusive<Idx> cannot impl From<RangeTo<Idx>>
 // because underflow would be possible with (..0).into()