---

yaml
---
r: 156607
b: refs/heads/try
c: ee985a5
h: refs/heads/master
i:
  156605: 8bf954a
  156603: 099f4ec
  156599: ce92bd9
  156591: 88e986b
  156575: c4673a8
  156543: 7247d12
v: v3

Author: dotdash

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a34b8dec697014f15e725215e17ea8d956c0ab1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d44ea720fa9dfe062ef06d0eb49a58d4e7e92344
-refs/heads/try: c46812f6593eb8d9b294d082a487270d7c7be6ef
+refs/heads/try: ee985a5a517a3cbdcfbbeff43c6bd57170f47c5d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75

branches/try/mk/install.mk

@@ -14,34 +14,16 @@ else
 MAYBE_DISABLE_VERIFY=
 endif
 
-install:
-ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
-# Build the dist as the original user
-	$(Q)sudo -u "$$SUDO_USER" $(MAKE) prepare_install
-else
-	$(Q)$(MAKE) prepare_install
-endif
+install: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
 	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
-# Remove tmp files because it's a decent amount of disk space
+# Remove tmp files while we can because they may have been created under sudo
 	$(Q)rm -R tmp/dist
 
-prepare_install: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
-
-uninstall:
-ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
-# Build the dist as the original user
-	$(Q)sudo -u "$$SUDO_USER" $(MAKE) prepare_uninstall
-else
-	$(Q)$(MAKE) prepare_uninstall
-endif
+uninstall: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
 	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --uninstall --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
-# Remove tmp files because it's a decent amount of disk space
+# Remove tmp files while we can because they may have been created under sudo
 	$(Q)rm -R tmp/dist
 
-prepare_uninstall: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
-
-.PHONY: install prepare_install uninstall prepare_uninstall
-
 tmp/empty_dir:
 	mkdir -p $@
 

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

@@ -41,7 +41,7 @@ concurrency: particularly, ownership. The language leaves the implementation
 details to the standard library.
 
 The `spawn` function has a very simple type signature: `fn spawn(f: proc():
-Send)`. Because it accepts only procs, and procs contain only owned data,
+Send)`.  Because it accepts only procs, and procs contain only owned data,
 `spawn` can safely move the entire proc and all its associated state into an
 entirely different task for execution. Like any closure, the function passed to
 `spawn` may capture an environment that it carries across tasks.
@@ -213,7 +213,7 @@ println!("fib(50) = {}", delayed_fib.get())
 # }
 ```
 
-The call to `future::spawn` immediately returns a `future` object regardless of
+The call to `future::spawn` returns immediately a `future` object regardless of
 how long it takes to run `fib(50)`. You can then make yourself a sandwich while
 the computation of `fib` is running. The result of the execution of the method
 is obtained by calling `get` on the future. This call will block until the
@@ -297,7 +297,7 @@ let numbers_arc = Arc::new(numbers);
 ```
 
 and a clone is captured for each task via a procedure. This only copies
-the wrapper and not its contents. Within the task's procedure, the captured
+the wrapper and not it's contents. Within the task's procedure, the captured
 Arc reference can be used as a shared reference to the underlying vector as
 if it were local.
 
@@ -323,20 +323,20 @@ Rust has a built-in mechanism for raising exceptions. The `fail!()` macro
 (which can also be written with an error string as an argument: `fail!(
 ~reason)`) and the `assert!` construct (which effectively calls `fail!()` if a
 boolean expression is false) are both ways to raise exceptions. When a task
-raises an exception, the task unwinds its stack—running destructors and
-freeing memory along the way—and then exits. Unlike exceptions in C++,
+raises an exception the task unwinds its stack---running destructors and
+freeing memory along the way---and then exits. Unlike exceptions in C++,
 exceptions in Rust are unrecoverable within a single task: once a task fails,
 there is no way to "catch" the exception.
 
 While it isn't possible for a task to recover from failure, tasks may notify
 each other of failure. The simplest way of handling task failure is with the
-`try` function, which is similar to `spawn`, but immediately blocks and waits
-for the child task to finish. `try` returns a value of type
-`Result<T, Box<Any + Send>>`. `Result` is an `enum` type with two variants:
-`Ok` and `Err`. In this case, because the type arguments to `Result` are `int`
-and `()`, callers can pattern-match on a result to check whether it's an `Ok`
-result with an `int` field (representing a successful result) or an `Err` result
-(representing termination with an error).
+`try` function, which is similar to `spawn`, but immediately blocks waiting for
+the child task to finish. `try` returns a value of type `Result<T, Box<Any +
+Send>>`.  `Result` is an `enum` type with two variants: `Ok` and `Err`. In this
+case, because the type arguments to `Result` are `int` and `()`, callers can
+pattern-match on a result to check whether it's an `Ok` result with an `int`
+field (representing a successful result) or an `Err` result (representing
+termination with an error).
 
 ```{rust}
 # use std::task;
@@ -369,4 +369,4 @@ the entire program (perhaps you're writing an assert which, if it trips,
 indicates an unrecoverable logic error); in other cases you might want to
 contain the failure at a certain boundary (perhaps a small piece of input from
 the outside world, which you happen to be processing in parallel, is malformed
-such that the processing task cannot proceed).
+and its processing task can't proceed).

branches/try/src/doc/guide.md

@@ -1255,9 +1255,8 @@ version, if we had forgotten the `Greater` case, for example, our program would
 have happily compiled. If we forget in the `match`, it will not. Rust helps us
 make sure to cover all of our bases.
 
-`match` is also an expression, which means we can use it on the right
-hand side of a `let` binding or directly where an expression is
-used. We could also implement the previous line like this:
+`match` is also an expression, which means we can use it on the right hand side
+of a `let` binding. We could also implement the previous line like this:
 
 ```{rust}
 fn cmp(a: int, b: int) -> Ordering {
@@ -1270,15 +1269,18 @@ fn main() {
     let x = 5i;
     let y = 10i;
 
-    println!("{}", match cmp(x, y) {
+    let result = match cmp(x, y) {
         Less    => "less",
         Greater => "greater",
         Equal   => "equal",
-    });
+    };
+
+    println!("{}", result);
 }
 ```
 
-Sometimes, it's a nice pattern.
+In this case, it doesn't make a lot of sense, as we are just making a temporary
+string where we don't need to, but sometimes, it's a nice pattern.
 
 # Looping
 

branches/try/src/libcollections/lib.rs

@@ -10,7 +10,7 @@
 
 //! Collection types.
 //!
-//! See [std::collections](../std/collections) for a detailed discussion of collections in Rust.
+//! See [../std/collections](std::collections) for a detailed discussion of collections in Rust.
 
 
 #![crate_name = "collections"]

branches/try/src/libcore/ops.rs

@@ -626,7 +626,7 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
  * struct Foo;
  *
  * impl Index<Foo, Foo> for Foo {
- *     fn index<'a>(&'a self, _index: &Foo) -> &'a Foo {
+ *     fn index<'a>(&'a self, _rhs: &Foo) -> &'a Foo {
  *         println!("Indexing!");
  *         self
  *     }
@@ -657,7 +657,7 @@ pub trait Index<Index, Result> {
  * struct Foo;
  *
  * impl IndexMut<Foo, Foo> for Foo {
- *     fn index_mut<'a>(&'a mut self, _index: &Foo) -> &'a mut Foo {
+ *     fn index_mut<'a>(&'a mut self, _rhs: &Foo) -> &'a mut Foo {
  *         println!("Indexing!");
  *         self
  *     }
@@ -687,20 +687,20 @@ pub trait IndexMut<Index, Result> {
  * ```ignore
  * struct Foo;
  *
- * impl Slice<Foo, Foo> for Foo {
+ * impl ::core::ops::Slice<Foo, Foo> for Foo {
  *     fn as_slice_<'a>(&'a self) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_from_or_fail<'a>(&'a self, _from: &Foo) -> &'a Foo {
+ *     fn slice_from_or_fail<'a>(&'a self, from: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_to_or_fail<'a>(&'a self, _to: &Foo) -> &'a Foo {
+ *     fn slice_to_or_fail<'a>(&'a self, to: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_or_fail<'a>(&'a self, _from: &Foo, _to: &Foo) -> &'a Foo {
+ *     fn slice_or_fail<'a>(&'a self, from: &Foo, to: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
@@ -736,20 +736,20 @@ pub trait Slice<Idx, Sized? Result> for Sized? {
  * ```ignore
  * struct Foo;
  *
- * impl SliceMut<Foo, Foo> for Foo {
+ * impl ::core::ops::SliceMut<Foo, Foo> for Foo {
  *     fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_from_or_fail_mut<'a>(&'a mut self, _from: &Foo) -> &'a mut Foo {
+ *     fn slice_from_or_fail_mut<'a>(&'a mut self, from: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_to_or_fail_mut<'a>(&'a mut self, _to: &Foo) -> &'a mut Foo {
+ *     fn slice_to_or_fail_mut<'a>(&'a mut self, to: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_or_fail_mut<'a>(&'a mut self, _from: &Foo, _to: &Foo) -> &'a mut Foo {
+ *     fn slice_or_fail_mut<'a>(&'a mut self, from: &Foo, to: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
@@ -901,3 +901,4 @@ def_fn_mut!(A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12)
 def_fn_mut!(A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13)
 def_fn_mut!(A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14)
 def_fn_mut!(A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15)
+

branches/try/src/librustc/driver/session.rs

@@ -96,18 +96,12 @@ impl Session {
     pub fn span_end_note(&self, sp: Span, msg: &str) {
         self.diagnostic().span_end_note(sp, msg)
     }
-    pub fn span_help(&self, sp: Span, msg: &str) {
-        self.diagnostic().span_help(sp, msg)
-    }
     pub fn fileline_note(&self, sp: Span, msg: &str) {
         self.diagnostic().fileline_note(sp, msg)
     }
     pub fn note(&self, msg: &str) {
         self.diagnostic().handler().note(msg)
     }
-    pub fn help(&self, msg: &str) {
-        self.diagnostic().handler().note(msg)
-    }
     pub fn span_bug(&self, sp: Span, msg: &str) -> ! {
         self.diagnostic().span_bug(sp, msg)
     }

branches/try/src/librustc/middle/borrowck/mod.rs

@@ -618,10 +618,6 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
         self.tcx.sess.span_end_note(s, m);
     }
 
-    pub fn span_help(&self, s: Span, m: &str) {
-        self.tcx.sess.span_help(s, m);
-    }
-
     pub fn bckerr_to_string(&self, err: &BckError) -> String {
         match err.code {
             err_mutbl => {

branches/try/src/librustc/middle/traits/select.rs

@@ -608,17 +608,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
          * unified during the confirmation step.
          */
 
-        let tcx = self.tcx();
-        let kind = if Some(obligation.trait_ref.def_id) == tcx.lang_items.fn_trait() {
-            ty::FnUnboxedClosureKind
-        } else if Some(obligation.trait_ref.def_id) == tcx.lang_items.fn_mut_trait() {
-            ty::FnMutUnboxedClosureKind
-        } else if Some(obligation.trait_ref.def_id) == tcx.lang_items.fn_once_trait() {
-            ty::FnOnceUnboxedClosureKind
-        } else {
-            return Ok(()); // not a fn trait, ignore
-        };
-
         let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
         let closure_def_id = match ty::get(self_ty).sty {
             ty::ty_unboxed_closure(id, _) => id,
@@ -633,17 +622,37 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                self_ty.repr(self.tcx()),
                obligation.repr(self.tcx()));
 
-        let closure_kind = match self.typer.unboxed_closures().borrow().find(&closure_def_id) {
-            Some(closure) => closure.kind,
-            None => {
-                self.tcx().sess.span_bug(
-                    obligation.cause.span,
-                    format!("No entry for unboxed closure: {}",
-                            closure_def_id.repr(self.tcx())).as_slice());
+        let tcx = self.tcx();
+        let fn_traits = [
+            (ty::FnUnboxedClosureKind, tcx.lang_items.fn_trait()),
+            (ty::FnMutUnboxedClosureKind, tcx.lang_items.fn_mut_trait()),
+            (ty::FnOnceUnboxedClosureKind, tcx.lang_items.fn_once_trait()),
+            ];
+        for tuple in fn_traits.iter() {
+            let kind = match tuple {
+                &(kind, Some(ref fn_trait))
+                    if *fn_trait == obligation.trait_ref.def_id =>
+                {
+                    kind
+                }
+                _ => continue,
+            };
+
+            // Check to see whether the argument and return types match.
+            let closure_kind = match self.typer.unboxed_closures().borrow().find(&closure_def_id) {
+                Some(closure) => closure.kind,
+                None => {
+                    self.tcx().sess.span_bug(
+                        obligation.cause.span,
+                        format!("No entry for unboxed closure: {}",
+                                closure_def_id.repr(self.tcx())).as_slice());
+                }
+            };
+
+            if closure_kind != kind {
+                continue;
             }
-        };
 
-        if closure_kind == kind {
             candidates.vec.push(UnboxedClosureCandidate(closure_def_id));
         }
 

branches/try/src/librustc/middle/trans/_match.rs

@@ -1090,7 +1090,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     let sw = if kind == Switch {
         build::Switch(bcx, test_val, else_cx.llbb, opts.len())
     } else {
-        C_int(ccx, 0i) // Placeholder for when not using a switch
+        C_int(ccx, 0) // Placeholder for when not using a switch
     };
 
     let defaults = enter_default(else_cx, dm, m, col, val);