---

yaml
---
r: 187115
b: refs/heads/try
c: 1212fd8
h: refs/heads/master
i:
  187113: af76bd9
  187111: 3d56230
v: v3

Author: brooksbp

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b4c965ee803a4521d8b4575f634e036f93e408f3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 3a96d6a9818fe2affc98a187fb1065120458cee9
-refs/heads/try: 67eb38ee4cfd7b28f8498b5b6492da172768dcb9
+refs/heads/try: 1212fd8abc7602f6c506c936908a799c76549a14
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/CONTRIBUTING.md

@@ -14,7 +14,7 @@ links to the major sections:
 If you have questions, please make a post on [internals.rust-lang.org][internals] or
 hop on [#rust-internals][pound-rust-internals].
 
-As a reminder, all contributors are expected to follow our [Code of Conduct][coc].
+As a reminder, all contributors are expected to follow our [Code of Conduct](coc).
 
 [pound-rust-internals]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
 [internals]: http://internals.rust-lang.org

branches/try/RELEASES.md

@@ -51,7 +51,7 @@ Version 1.0.0-alpha.2 (February 2015)
     * Abstract [OS-specific string types][osstr], `std::ff::{OsString,
       OsStr}`, provide strings in platform-specific encodings for easier
       interop with system APIs. [RFC][osstr-rfc].
-    * The `boxed::into_raw` and `Box::from_raw` functions [convert
+    * The `boxed::into_raw` and `Box::frow_raw` functions [convert
       between `Box<T>` and `*mut T`][boxraw], a common pattern for
       creating raw pointers.
 

branches/try/configure

@@ -374,12 +374,8 @@ case $CFG_OSTYPE in
         CFG_OSTYPE=unknown-dragonfly
         ;;
 
-    Bitrig)
-        CFG_OSTYPE=unknown-bitrig
-        ;;
-
     OpenBSD)
-        CFG_OSTYPE=unknown-openbsd
+	CFG_OSTYPE=unknown-openbsd
        ;;
 
     Darwin)
@@ -751,13 +747,6 @@ then
     CFG_ENABLE_CLANG=1
 fi
 
-# Force bitrig to build with clang; gcc doesn't like us there
-if [ $CFG_OSTYPE = unknown-bitrig ]
-then
-    step_msg "on Bitrig, forcing use of clang"
-    CFG_ENABLE_CLANG=1
-fi
-
 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 then
     err "either clang or gcc is required"

branches/try/mk/cfg/x86_64-unknown-bitrig.mk

@@ -144,14 +144,14 @@ FIND_COMPILER = $(word 1,$(1:ccache=))
 define CFG_MAKE_TOOLCHAIN
   # Prepend the tools with their prefix if cross compiling
   ifneq ($(CFG_BUILD),$(1))
-       CC_$(1)=$(CROSS_PREFIX_$(1))$(CC_$(1))
-       CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
-       CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
-       AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
-       RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CC_$(1))) \
-           -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
-
-       RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
+	CC_$(1)=$(CROSS_PREFIX_$(1))$(CC_$(1))
+	CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
+	CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
+	AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
+	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CC_$(1))) \
+	    -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
+
+	RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
   endif
 
   CFG_COMPILE_C_$(1) = $$(CC_$(1)) \
@@ -179,19 +179,11 @@ define CFG_MAKE_TOOLCHAIN
 
   ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
 
-  # On Bitrig, we need the relocation model to be PIC for everthing
-  ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
-    LLVM_MC_RELOCATION_MODEL="pic"
-  else
-    LLVM_MC_RELOCATION_MODEL="default"
-  endif
-
   # We're using llvm-mc as our assembler because it supports
   # .cfi pseudo-ops on mac
   CFG_ASSEMBLE_$(1)=$$(CPP_$(1)) -E $$(CFG_DEPEND_FLAGS) $$(2) | \
                     $$(LLVM_MC_$$(CFG_BUILD)) \
                     -assemble \
-                    -relocation-model=$$(LLVM_MC_RELOCATION_MODEL) \
                     -filetype=obj \
                     -triple=$(1) \
                     -o=$$(1)
@@ -200,7 +192,7 @@ define CFG_MAKE_TOOLCHAIN
   # For the ARM, AARCH64, MIPS and POWER crosses, use the toolchain assembler
   # FIXME: We should be able to use the LLVM assembler
   CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
-                   $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
+		    $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
 
   endif
 

branches/try/mk/platform.mk

@@ -58,7 +58,7 @@ pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
 fn parse_expected(last_nonfollow_error: Option<uint>,
                   line_num: uint,
                   line: &str) -> Option<(WhichLine, ExpectedError)> {
-    let start = match line.find("//~") { Some(i) => i, None => return None };
+    let start = match line.find_str("//~") { Some(i) => i, None => return None };
     let (follow, adjusts) = if line.char_at(start + 3) == '|' {
         (true, 0)
     } else {

branches/try/src/compiletest/errors.rs

@@ -330,7 +330,7 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
 pub fn parse_name_value_directive(line: &str, directive: &str)
                                   -> Option<String> {
     let keycolon = format!("{}:", directive);
-    match line.find(&keycolon) {
+    match line.find_str(&keycolon) {
         Some(colon) => {
             let value = line[(colon + keycolon.len()) .. line.len()].to_string();
             debug!("{}: {}", directive, value);

branches/try/src/compiletest/header.rs

@@ -847,7 +847,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
             check_lines.iter().map(|s| {
                 s
                  .trim()
-                 .split("[...]")
+                 .split_str("[...]")
                  .map(|x| x.to_string())
                  .collect()
             }).collect();
@@ -866,7 +866,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
                         None
                     }
                 } else {
-                    rest.find(frag)
+                    rest.find_str(frag)
                 };
                 match found {
                     None => {

branches/try/src/compiletest/runtest.rs

@@ -23,7 +23,6 @@ static OS_TABLE: &'static [(&'static str, &'static str)] = &[
     ("linux", "linux"),
     ("freebsd", "freebsd"),
     ("dragonfly", "dragonfly"),
-    ("bitrig", "bitrig"),
     ("openbsd", "openbsd"),
 ];
 

branches/try/src/compiletest/util.rs

@@ -2188,8 +2188,8 @@ The following configurations must be defined by the implementation:
   `"unix"` or `"windows"`. The value of this configuration option is defined
   as a configuration itself, like `unix` or `windows`.
 * `target_os = "..."`. Operating system of the target, examples include
-  `"win32"`, `"macos"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"`,
-  `"bitrig"` or `"openbsd"`.
+  `"win32"`, `"macos"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"` or
+  `"openbsd"`.
 * `target_word_size = "..."`. Target word size in bits. This is set to `"32"`
   for targets with 32-bit pointers, and likewise set to `"64"` for 64-bit
   pointers.

branches/try/src/doc/reference.md

@@ -91,7 +91,7 @@ fn main() {
 ```
 
 You've seen this code before, when we talked about standard input. We
-import the `std::old_io` module with `use`, and then our `main` function contains
+import the `std::io` module with `use`, and then our `main` function contains
 our program's logic. We print a little message announcing the game, ask the
 user to input a guess, get their input, and then print it out.
 

branches/try/src/doc/trpl/guessing-game.md

@@ -34,20 +34,6 @@ if x == 5 {
 }
 ```
 
-If there is more than one case, use an `else if`:
-
-```rust
-let x = 5;
-
-if x == 5 {
-    println!("x is five!");
-} else if x == 6 {
-    println!("x is six!");
-} else {
-    println!("x is not five or six :(");
-}
-```
-
 This is all pretty standard. However, you can also do this:
 
 

branches/try/src/doc/trpl/if.md

@@ -687,9 +687,7 @@ than the hundred `int`s that make up the `BigStruct`.
 
 This is an antipattern in Rust. Instead, write this:
 
-```rust
-#![feature(box_syntax)]
-
+```{rust}
 struct BigStruct {
     one: i32,
     two: i32,
@@ -708,13 +706,10 @@ fn main() {
         one_hundred: 100,
     });
 
-    let y = box foo(x);
+    let y = Box::new(foo(x));
 }
 ```
 
-Note that this uses the `box_syntax` feature gate, so this syntax may change in
-the future.
-
 This gives you flexibility without sacrificing performance.
 
 You may think that this gives us terrible performance: return a value and then

branches/try/src/doc/trpl/pointers.md

@@ -84,7 +84,7 @@ inlining and hence usually higher performance. It also has some downsides:
 causing code bloat due to many copies of the same function existing in the
 binary, one for each type.
 
-Furthermore, compilers aren’t perfect and may “optimize” code to become slower.
+Furthermore, compilers aren’t perfect and may “optimise” code to become slower.
 For example, functions inlined too eagerly will bloat the instruction cache
 (cache rules everything around us). This is part of the reason that `#[inline]`
 and `#[inline(always)]` should be used carefully, and one reason why using a
@@ -104,15 +104,15 @@ objects, like `&Foo` or `Box<Foo>`, are normal values that store a value of
 known at runtime. The methods of the trait can be called on a trait object via
 a special record of function pointers (created and managed by the compiler).
 
-A function that takes a trait object is not specialized to each of the types
+A function that takes a trait object is not specialised to each of the types
 that implements `Foo`: only one copy is generated, often (but not always)
 resulting in less code bloat. However, this comes at the cost of requiring
 slower virtual function calls, and effectively inhibiting any chance of
 inlining and related optimisations from occurring.
 
 Trait objects are both simple and complicated: their core representation and
 layout is quite straight-forward, but there are some curly error messages and
-surprising behaviors to discover.
+surprising behaviours to discover.
 
 ### Obtaining a trait object
 
@@ -140,13 +140,13 @@ and casts are identical.
 
 This operation can be seen as "erasing" the compiler's knowledge about the
 specific type of the pointer, and hence trait objects are sometimes referred to
-as "type erasure".
+"type erasure".
 
 ### Representation
 
 Let's start simple, with the runtime representation of a trait object. The
 `std::raw` module contains structs with layouts that are the same as the
-complicated built-in types, [including trait objects][stdraw]:
+complicated build-in types, [including trait objects][stdraw]:
 
 ```rust
 # mod foo {
@@ -223,14 +223,14 @@ static Foo_for_String_vtable: FooVtable = FooVtable {
 The `destructor` field in each vtable points to a function that will clean up
 any resources of the vtable's type, for `u8` it is trivial, but for `String` it
 will free the memory. This is necessary for owning trait objects like
-`Box<Foo>`, which need to clean-up both the `Box` allocation as well as the
+`Box<Foo>`, which need to clean-up both the `Box` allocation and as well as the
 internal type when they go out of scope. The `size` and `align` fields store
 the size of the erased type, and its alignment requirements; these are
 essentially unused at the moment since the information is embedded in the
-destructor, but will be used in the future, as trait objects are progressively
-made more flexible.
+destructor, but will be used in future, as trait objects are progressively made
+more flexible.
 
-Suppose we've got some values that implement `Foo`, then the explicit form of
+Suppose we've got some values that implement `Foo`, the explicit form of
 construction and use of `Foo` trait objects might look a bit like (ignoring the
 type mismatches: they're all just pointers anyway):
 

branches/try/src/doc/trpl/static-and-dynamic-dispatch.md

@@ -18,7 +18,7 @@ LIB_PREFIX=lib
 
 OS=`uname -s`
 case $OS in
-    ("Linux"|"FreeBSD"|"DragonFly"|"Bitrig"|"OpenBSD")
+    ("Linux"|"FreeBSD"|"DragonFly"|"OpenBSD")
     BIN_SUF=
     LIB_SUF=.so
     ;;

branches/try/src/etc/local_stage0.sh

@@ -57,16 +57,7 @@ def run(args):
 args.extend(components)
 out = run(args)
 for lib in out.strip().replace("\n", ' ').split(' '):
-    if len(lib) == 0:
-        continue
-    # in some cases we get extra spaces in between libs so ignore those
-    if len(lib) == 1 and lib == ' ':
-        continue
-    # not all libs strictly follow -lfoo, on Bitrig, there is -pthread
-    if lib[0:2] == '-l':
-        lib = lib.strip()[2:]
-    elif lib[0] == '-':
-        lib = lib.strip()[1:]
+    lib = lib.strip()[2:] # chop of the leading '-l'
     f.write("#[link(name = \"" + lib + "\"")
     # LLVM libraries are all static libraries
     if 'LLVM' in lib:

branches/try/src/etc/mklldeps.py

@@ -46,13 +46,13 @@ def scrub(b):
         "winnt": ["bin/rustc.exe"],
         "freebsd": ["bin/rustc"],
         "dragonfly": ["bin/rustc"],
-        "bitrig": ["bin/rustc"],
         "openbsd": ["bin/rustc"],
         }
 
 winnt_runtime_deps_32 = ["libgcc_s_dw2-1.dll", "libstdc++-6.dll"]
 winnt_runtime_deps_64 = ["libgcc_s_seh-1.dll", "libstdc++-6.dll"]
 
+
 def parse_line(n, line):
     global snapshotfile
 
@@ -101,8 +101,6 @@ def get_kernel(triple):
         return "freebsd"
     if os_name == "dragonfly":
         return "dragonfly"
-    if os_name == "bitrig":
-        return "bitrig"
     if os_name == "openbsd":
         return "openbsd"
     return "linux"

branches/try/src/etc/snapshot.py

@@ -598,6 +598,13 @@ impl<T: Default + Sync + Send> Default for Arc<T> {
     fn default() -> Arc<T> { Arc::new(Default::default()) }
 }
 
+#[cfg(stage0)]
+impl<H: Hasher, T: Hash<H>> Hash<H> for Arc<T> {
+    fn hash(&self, state: &mut H) {
+        (**self).hash(state)
+    }
+}
+#[cfg(not(stage0))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Hash> Hash for Arc<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {

branches/try/src/liballoc/arc.rs

@@ -220,6 +220,14 @@ impl<T: ?Sized + Ord> Ord for Box<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized + Eq> Eq for Box<T> {}
 
+#[cfg(stage0)]
+impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        (**self).hash(state);
+    }
+}
+#[cfg(not(stage0))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized + Hash> Hash for Box<T> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {

branches/try/src/liballoc/boxed.rs

@@ -73,7 +73,6 @@
 #![feature(unboxed_closures)]
 #![feature(unsafe_no_drop_flag)]
 #![feature(core)]
-#![cfg_attr(test, feature(test, alloc, rustc_private))]
 #![cfg_attr(all(not(feature = "external_funcs"), not(feature = "external_crate")),
             feature(libc))]