---

yaml
---
r: 152305
b: refs/heads/try2
c: 5cdc365
h: refs/heads/master
i:
  152303: 2688048
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 124e997f364fb9e281516962d14af9c3415d3433
+refs/heads/try2: 5cdc36517ed9939ef9f10736c269e5988062e479
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/.travis.yml

@@ -40,7 +40,7 @@ script: |
     if [[ $LLVM_VERSION != '3.4' ]]; then exit 0; fi
   fi &&
   make tidy &&
-  travis_wait make -j4 rustc-stage1 &&
+  make -j4 rustc-stage1 &&
   make check-stage1-std check-stage1-rpass check-stage1-cfail check-stage1-rfail check-stage1-doc
 
 env:

branches/try2/AUTHORS.txt

@@ -3,7 +3,6 @@ Rust was written by these fine people:
 Aaron Laursen <[email protected]>
 Aaron Todd <[email protected]>
 Adam Bozanich <[email protected]>
-Adolfo Ochagavía <[email protected]>
 Adrien Tétar <[email protected]>
 Alan Andrade <[email protected]>
 Aleksander Balicki <[email protected]>
@@ -26,6 +25,7 @@ Andrew Chin <[email protected]>
 Andrew Dunham <[email protected]>
 Andrew Paseltiner <[email protected]>
 Anthony Juckel <[email protected]>
+aochagavia <[email protected]>
 Arcterus <[email protected]>
 Arkaitz Jimenez <[email protected]>
 Armin Ronacher <[email protected]>

branches/try2/configure

@@ -1136,7 +1136,7 @@ do
         CXXFLAGS=$LLVM_CXXFLAGS
         LDFLAGS=$LLVM_LDFLAGS
 
-        if [ -z "$CFG_DISABLE_LIBCPP" ] && [ -n "$CFG_USING_CLANG" ]; then
+        if [ "$CFG_DISABLE_LIBCPP" != 1 ] && [ "$CFG_USING_CLANG" == 1 ]; then
             LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
         fi
 

branches/try2/mk/crates.mk

@@ -84,7 +84,7 @@ DEPS_collections := core alloc
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
 DEPS_num := std
-DEPS_test := std getopts serialize term time regex
+DEPS_test := std getopts serialize term time regex native:rust_test_helpers
 DEPS_time := std serialize sync
 DEPS_rand := core
 DEPS_url := std

branches/try2/mk/rt.mk

@@ -35,7 +35,8 @@
 # that's per-target so you're allowed to conditionally add files based on the
 # target.
 ################################################################################
-NATIVE_LIBS := rustrt hoedown uv_support morestack miniz context_switch
+NATIVE_LIBS := rustrt hoedown uv_support morestack miniz context_switch \
+		rust_test_helpers
 
 # $(1) is the target triple
 define NATIVE_LIBRARIES
@@ -53,9 +54,9 @@ NATIVE_DEPS_uv_support_$(1) := rust_uv.c
 NATIVE_DEPS_miniz_$(1) = miniz.c
 NATIVE_DEPS_rustrt_$(1) := rust_builtin.c \
 			rust_android_dummy.c \
-			rust_test_helpers.c \
 			rust_try.ll \
 			arch/$$(HOST_$(1))/record_sp.S
+NATIVE_DEPS_rust_test_helpers_$(1) := rust_test_helpers.c
 NATIVE_DEPS_morestack_$(1) := arch/$$(HOST_$(1))/morestack.S
 NATIVE_DEPS_context_switch_$(1) := \
 			arch/$$(HOST_$(1))/_context.S

branches/try2/src/compiletest/errors.rs

@@ -31,7 +31,7 @@ pub fn load_errors(re: &Regex, testfile: &Path) -> Vec<ExpectedError> {
 fn parse_expected(line_num: uint, line: &str, re: &Regex) -> Option<ExpectedError> {
     re.captures(line).and_then(|caps| {
         let adjusts = caps.name("adjusts").len();
-        let kind = caps.name("kind").to_ascii().to_lower().into_str();
+        let kind = caps.name("kind").to_ascii().to_lower().into_str().to_string();
         let msg = caps.name("msg").trim().to_string();
 
         debug!("line={} kind={} msg={}", line_num, kind, msg);

branches/try2/src/compiletest/util.rs

@@ -41,7 +41,7 @@ pub fn make_new_path(path: &str) -> String {
       Some(curr) => {
         format!("{}{}{}", path, path_div(), curr)
       }
-      None => path.to_str()
+      None => path.to_str().to_string()
     }
 }
 

branches/try2/src/doc/complement-cheatsheet.md

@@ -8,7 +8,7 @@ Use [`ToStr`](std/to_str/trait.ToStr.html).
 
 ~~~
 let x: int = 42;
-let y: String = x.to_str();
+let y: String = x.to_str().to_string();
 ~~~
 
 **String to int**

branches/try2/src/doc/guide-lifetimes.md

@@ -14,9 +14,9 @@ Despite their complete safety, a reference's representation at runtime
 is the same as that of an ordinary pointer in a C program. They introduce zero
 overhead. The compiler does all safety checks at compile time.
 
-Although references have rather elaborate theoretical underpinnings
-(e.g. region pointers), the core concepts will be familiar to anyone
-who has worked with C or C++. The best way to explain how they are
+Although references have rather elaborate theoretical underpinnings usually
+introduced as (e.g. region pointers), the core concepts will be familiar to
+anyone who has worked with C or C++. The best way to explain how they are
 used—and their limitations—is probably just to work through several examples.
 
 # By example

branches/try2/src/doc/guide-tasks.md

@@ -467,7 +467,7 @@ fn stringifier(channel: &sync::DuplexStream<String, uint>) {
     let mut value: uint;
     loop {
         value = channel.recv();
-        channel.send(value.to_str());
+        channel.send(value.to_str().to_string());
         if value == 0 { break; }
     }
 }
@@ -492,7 +492,7 @@ extern crate sync;
 #     let mut value: uint;
 #     loop {
 #         value = channel.recv();
-#         channel.send(value.to_str());
+#         channel.send(value.to_str().to_string());
 #         if value == 0u { break; }
 #     }
 # }

branches/try2/src/doc/rust.md

@@ -3579,7 +3579,7 @@ trait Printable {
 }
 
 impl Printable for int {
-  fn to_string(&self) -> String { self.to_str() }
+  fn to_string(&self) -> String { self.to_str().to_string() }
 }
 
 fn print(a: Box<Printable>) {

branches/try2/src/etc/licenseck.py

@@ -42,7 +42,6 @@
     "libstd/sync/spsc_queue.rs", # BSD
     "libstd/sync/mpmc_bounded_queue.rs", # BSD
     "libsync/mpsc_intrusive.rs", # BSD
-    "test/bench/shootout-meteor.rs", # BSD
 ]
 
 def check_license(name, contents):

branches/try2/src/libcollections/vec.rs

@@ -782,11 +782,11 @@ impl<T> Vec<T> {
         self.as_mut_slice().sort_by(compare)
     }
 
-    /// Returns a slice of self spanning the interval [`start`, `end`).
+    /// Returns a slice of `self` between `start` and `end`.
     ///
     /// # Failure
     ///
-    /// Fails when the slice (or part of it) is outside the bounds of self, or when
+    /// Fails when `start` or `end` point outside the bounds of `self`, or when
     /// `start` > `end`.
     ///
     /// # Example

branches/try2/src/libcore/slice.rs

@@ -366,9 +366,9 @@ impl<T> Container for ~[T] {
 /// Extension methods for vectors
 pub trait ImmutableVector<'a, T> {
     /**
-     * Returns a slice of self spanning the interval [`start`, `end`).
+     * Returns a slice of self between `start` and `end`.
      *
-     * Fails when the slice (or part of it) is outside the bounds of self,
+     * Fails when `start` or `end` point outside the bounds of self,
      * or when `start` > `end`.
      */
     fn slice(&self, start: uint, end: uint) -> &'a [T];

branches/try2/src/libgetopts/lib.rs

@@ -222,7 +222,7 @@ impl Name {
 
     fn to_str(&self) -> String {
         match *self {
-            Short(ch) => ch.to_str(),
+            Short(ch) => ch.to_str().to_string(),
             Long(ref s) => s.to_string()
         }
     }

branches/try2/src/libnum/bigint.rs

@@ -653,8 +653,6 @@ impl FromStrRadix for BigUint {
 
 impl BigUint {
     /// Creates and initializes a `BigUint`.
-    ///
-    /// The digits are be in base 2^32.
     #[inline]
     pub fn new(v: Vec<BigDigit>) -> BigUint {
         // omit trailing zeros
@@ -667,8 +665,6 @@ impl BigUint {
     }
 
     /// Creates and initializes a `BigUint`.
-    ///
-    /// The digits are be in base 2^32.
     #[inline]
     pub fn from_slice(slice: &[BigDigit]) -> BigUint {
         return BigUint::new(Vec::from_slice(slice));
@@ -1319,16 +1315,12 @@ impl<R: Rng> RandBigInt for R {
 
 impl BigInt {
     /// Creates and initializes a BigInt.
-    ///
-    /// The digits are be in base 2^32.
     #[inline]
     pub fn new(sign: Sign, v: Vec<BigDigit>) -> BigInt {
         BigInt::from_biguint(sign, BigUint::new(v))
     }
 
     /// Creates and initializes a `BigInt`.
-    ///
-    /// The digits are be in base 2^32.
     #[inline]
     pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt {
         if sign == Zero || data.is_zero() {

branches/try2/src/libnum/complex.rs

@@ -349,7 +349,7 @@ mod test {
     #[test]
     fn test_to_str() {
         fn test(c : Complex64, s: String) {
-            assert_eq!(c.to_str(), s);
+            assert_eq!(c.to_str().to_string(), s);
         }
         test(_0_0i, "0+0i".to_string());
         test(_1_0i, "1+0i".to_string());

branches/try2/src/libnum/rational.rs

@@ -559,7 +559,7 @@ mod test {
     fn test_to_from_str() {
         fn test(r: Rational, s: String) {
             assert_eq!(FromStr::from_str(s.as_slice()), Some(r));
-            assert_eq!(r.to_str(), s);
+            assert_eq!(r.to_str().to_string(), s);
         }
         test(_1, "1/1".to_string());
         test(_0, "0/1".to_string());

branches/try2/src/libregex_macros/lib.rs

@@ -620,7 +620,7 @@ fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option<String> {
     let regex = match entry.node {
         ast::ExprLit(lit) => {
             match lit.node {
-                ast::LitStr(ref s, _) => s.to_str(),
+                ast::LitStr(ref s, _) => s.to_str().to_string(),
                 _ => {
                     cx.span_err(entry.span, format!(
                         "expected string literal but got `{}`",

branches/try2/src/librustc/driver/driver.rs

@@ -533,15 +533,15 @@ impl pprust::PpAnn for IdentifiedAnnotation {
         match node {
             pprust::NodeItem(item) => {
                 try!(pp::space(&mut s.s));
-                s.synth_comment(item.id.to_str())
+                s.synth_comment(item.id.to_str().to_string())
             }
             pprust::NodeBlock(blk) => {
                 try!(pp::space(&mut s.s));
                 s.synth_comment((format!("block {}", blk.id)).to_string())
             }
             pprust::NodeExpr(expr) => {
                 try!(pp::space(&mut s.s));
-                try!(s.synth_comment(expr.id.to_str()));
+                try!(s.synth_comment(expr.id.to_str().to_string()));
                 s.pclose()
             }
             pprust::NodePat(pat) => {

branches/try2/src/librustc/middle/liveness.rs

@@ -324,7 +324,7 @@ impl<'a> IrMaps<'a> {
     fn variable_name(&self, var: Variable) -> String {
         match self.var_kinds.get(var.get()) {
             &Local(LocalInfo { ident: nm, .. }) | &Arg(_, nm) => {
-                token::get_ident(nm).get().to_str()
+                token::get_ident(nm).get().to_str().to_string()
             },
             &ImplicitRet => "<implicit-ret>".to_string()
         }

branches/try2/src/librustc/middle/mem_categorization.rs

@@ -1303,7 +1303,7 @@ impl Repr for InteriorKind {
     fn repr(&self, _tcx: &ty::ctxt) -> String {
         match *self {
             InteriorField(NamedField(fld)) => {
-                token::get_name(fld).get().to_str()
+                token::get_name(fld).get().to_str().to_string()
             }
             InteriorField(PositionalField(i)) => format!("\\#{:?}", i),
             InteriorElement(_) => "[]".to_string(),

branches/try2/src/librustc/middle/trans/base.rs

@@ -1927,7 +1927,7 @@ fn exported_name(ccx: &CrateContext, id: ast::NodeId,
         _ => ccx.tcx.map.with_path(id, |mut path| {
             if attr::contains_name(attrs, "no_mangle") {
                 // Don't mangle
-                path.last().unwrap().to_str()
+                path.last().unwrap().to_str().to_string()
             } else {
                 match weak_lang_items::link_name(attrs) {
                     Some(name) => name.get().to_string(),

branches/try2/src/librustc/middle/typeck/infer/to_str.rs

@@ -79,13 +79,13 @@ impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {
 
 impl InferStr for IntVarValue {
     fn inf_str(&self, _cx: &InferCtxt) -> String {
-        self.to_str()
+        self.to_str().to_string()
     }
 }
 
 impl InferStr for ast::FloatTy {
     fn inf_str(&self, _cx: &InferCtxt) -> String {
-        self.to_str()
+        self.to_str().to_string()
     }
 }
 

branches/try2/src/librustc/util/ppaux.rs

@@ -366,7 +366,7 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> String {
       ty_bare_fn(ref f) => {
           bare_fn_to_str(cx, f.fn_style, f.abi, None, &f.sig)
       }
-      ty_infer(infer_ty) => infer_ty.to_str(),
+      ty_infer(infer_ty) => infer_ty.to_str().to_string(),
       ty_err => "[type error]".to_string(),
       ty_param(param_ty {idx: id, def_id: did}) => {
           let ident = match cx.ty_param_defs.borrow().find(&did.node) {
@@ -753,10 +753,7 @@ impl Repr for ty::ItemVariances {
 
 impl Repr for ty::Variance {
     fn repr(&self, _: &ctxt) -> String {
-        // The first `.to_str()` returns a &'static str (it is not an implementation
-        // of the ToStr trait). Because of that, we need to call `.to_str()` again
-        // if we want to have a `String`.
-        self.to_str().to_str()
+        self.to_str().to_string()
     }
 }
 
@@ -953,13 +950,13 @@ impl UserString for ast::Ident {
 
 impl Repr for abi::Abi {
     fn repr(&self, _tcx: &ctxt) -> String {
-        self.to_str()
+        self.to_str().to_string()
     }
 }
 
 impl UserString for abi::Abi {
     fn user_string(&self, _tcx: &ctxt) -> String {
-        self.to_str()
+        self.to_str().to_string()
     }
 }
 

branches/try2/src/librustdoc/clean/inline.rs

@@ -93,7 +93,7 @@ fn try_inline_def(cx: &core::DocContext,
     cx.inlined.borrow_mut().get_mut_ref().insert(did);
     ret.push(clean::Item {
         source: clean::Span::empty(),
-        name: Some(fqn.last().unwrap().to_str()),
+        name: Some(fqn.last().unwrap().to_str().to_string()),
         attrs: load_attrs(tcx, did),
         inner: inner,
         visibility: Some(ast::Public),