---

yaml
---
r: 125677
b: refs/heads/try
c: c8b8444
h: refs/heads/master
i:
  125675: 8daaa00
v: v3

Author: steveklabnik

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: f2fa55903e378368ed9173560f03a0ef16e371c2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9fc8394d3bce22ab483f98842434c84c396212ae
-refs/heads/try: 8672a235dd5b4677a6ff0ede1e3ce39b076b5414
+refs/heads/try: c8b8444ce131798b94e759138bb307144ed0994f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/man/rustc.1

@@ -68,7 +68,7 @@ AST nodes and blocks with IDs), or flowgraph=<nodeid> (graphviz
 formatted flowgraph for node)
 .TP
 \fB\-\-dep-info\fR [FILENAME]
-Output dependency info to <filename> after compiling, in a format suitable
+Output dependency info to <filename> after compiling, in o format suitable
 for use by Makefiles.
 .TP
 \fB\-\-sysroot\fR PATH

branches/try/mk/docs.mk

@@ -30,7 +30,7 @@ DOCS := index intro tutorial guide guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-runtime complement-bugreport \
 	complement-lang-faq complement-design-faq complement-project-faq rust \
-    rustdoc guide-unsafe guide-strings
+    rustdoc guide-unsafe
 
 PDF_DOCS := tutorial rust
 

branches/try/mk/main.mk

@@ -377,7 +377,7 @@ define SREQ_CMDS
 ifeq ($$(OSTYPE_$(3)),apple-darwin)
   LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := DYLD_LIBRARY_PATH
 else
-ifeq ($$(CFG_WINDOWSY_$(3)),1)
+ifeq ($$(CFG_WINDOWSY_$(2)),1)
   LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := PATH
 else
   LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := LD_LIBRARY_PATH

branches/try/src/doc/complement-lang-faq.md

@@ -31,7 +31,7 @@ You may also be interested in browsing [GitHub's Rust][github-rust] page.
 
 ## Does it run on Windows?
 
-Yes. All development happens in lock-step on all 3 target platforms. Using MinGW, not Cygwin. Note that the windows implementation currently has some limitations: in particular 64-bit build is [not fully supported yet][win64], and all executables created by rustc [depend on libgcc DLL at runtime][libgcc].
+Yes. All development happens in lock-step on all 3 target platforms. Using MinGW, not Cygwin. Note that the windows implementation currently has some limitations: in particular 64-bit build is [not fully supported yet][win64], and all executables created by rustc [depends on libgcc DLL at runtime][libgcc].
 
 [win64]: https://github.com/rust-lang/rust/issues/1237
 [libgcc]: https://github.com/rust-lang/rust/issues/11782
@@ -68,7 +68,7 @@ Cleanup through RAII-style destructors is more likely to work than in catch bloc
 
 ## Why aren't modules type-parametric?
 
-We want to maintain the option to parametrize at runtime. We may eventually change this limitation, but initially this is how type parameters were implemented.
+We want to maintain the option to parametrize at runtime. We may make eventually change this limitation, but initially this is how type parameters were implemented.
 
 ## Why aren't values type-parametric? Why only items?
 

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

@@ -67,7 +67,7 @@ Now we can call `compute_distance()`:
 # let on_the_stack :     Point  =     Point{x: 3.0, y: 4.0};
 # let on_the_heap  : Box<Point> = box Point{x: 7.0, y: 9.0};
 # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
-compute_distance(&on_the_stack, &*on_the_heap);
+compute_distance(&on_the_stack, on_the_heap);
 ~~~
 
 Here, the `&` operator takes the address of the variable
@@ -77,9 +77,10 @@ value. We also call this _borrowing_ the local variable
 `on_the_stack`, because we have created an alias: that is, another
 name for the same data.
 
-Likewise, in the case of `owned_box`,
-the `&` operator is used in conjunction with the `*` operator
-to take a reference to the contents of the box.
+In the case of `on_the_heap`, however, no explicit action is necessary. 
+The compiler will automatically convert a box point to a reference like &point. 
+This is another form of borrowing; in this case, the contents of the owned box 
+are being lent out.
 
 Whenever a caller lends data to a callee, there are some limitations on what
 the caller can do with the original. For example, if the contents of a

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

@@ -279,7 +279,7 @@ fn main() {
     let origin =    &Point { x: 0.0, y: 0.0 };
     let p1     = box Point { x: 5.0, y: 3.0 };
 
-    println!("{}", compute_distance(origin, &*p1));
+    println!("{}", compute_distance(origin, p1));
 }
 ~~~
 

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

@@ -13,7 +13,6 @@ li {list-style-type: none; }
 
 # Guides
 
-* [Strings](guide-strings.html)
 * [Pointers](guide-pointers.html)
 * [References and Lifetimes](guide-lifetimes.html)
 * [Containers and Iterators](guide-container.html)

branches/try/src/doc/index.md

@@ -3243,7 +3243,7 @@ enum List { Nil, Cons(uint, Box<List>) }
 fn is_sorted(list: &List) -> bool {
     match *list {
         Nil | Cons(_, box Nil) => true,
-        Cons(x, ref r @ box Cons(y, _)) => (x <= y) && is_sorted(&**r)
+        Cons(x, ref r @ box Cons(y, _)) => (x <= y) && is_sorted(*r)
     }
 }
 

branches/try/src/doc/rust.md

@@ -1470,7 +1470,7 @@ Now we can call `compute_distance()` in various ways:
 # let on_the_stack :     Point  =     Point { x: 3.0, y: 4.0 };
 # let on_the_heap  : Box<Point> = box Point { x: 7.0, y: 9.0 };
 # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
-compute_distance(&on_the_stack, &*on_the_heap);
+compute_distance(&on_the_stack, on_the_heap);
 ~~~
 
 Here the `&` operator is used to take the address of the variable
@@ -1480,9 +1480,11 @@ reference. We also call this _borrowing_ the local variable
 `on_the_stack`, because we are creating an alias: that is, another
 route to the same data.
 
-Likewise, in the case of `owned_box`,
-the `&` operator is used in conjunction with the `*` operator
-to take a reference to the contents of the box.
+In the case of `owned_box`, however, no
+explicit action is necessary. The compiler will automatically convert
+a box `box point` to a reference like
+`&point`. This is another form of borrowing; in this case, the
+contents of the owned box are being lent out.
 
 Whenever a value is borrowed, there are some limitations on what you
 can do with the original. For example, if the contents of a variable

branches/try/src/doc/tutorial.md

@@ -67,7 +67,7 @@ impl<T:PartialEq> PartialEq for Box<T> {
 impl<T:PartialOrd> PartialOrd for Box<T> {
     #[inline]
     fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
-        (**self).partial_cmp(&**other)
+        (**self).partial_cmp(*other)
     }
     #[inline]
     fn lt(&self, other: &Box<T>) -> bool { *(*self) < *(*other) }
@@ -80,9 +80,7 @@ impl<T:PartialOrd> PartialOrd for Box<T> {
 }
 impl<T: Ord> Ord for Box<T> {
     #[inline]
-    fn cmp(&self, other: &Box<T>) -> Ordering {
-        (**self).cmp(&**other)
-    }
+    fn cmp(&self, other: &Box<T>) -> Ordering { (**self).cmp(*other) }
 }
 impl<T: Eq> Eq for Box<T> {}
 

branches/try/src/liballoc/boxed.rs

@@ -365,12 +365,12 @@ impl<K: Clone + Ord, V: Clone> Leaf<K, V> {
                 return (Node::new_leaf(self.clone().elts), false);
             }
             //If there is an index, insert at that index.
-            Some(i) => {
-                if i >= self.elts.len() {
+            _ => {
+                if index.unwrap() >= self.elts.len() {
                     self.elts.push(to_insert.clone());
                 }
                 else {
-                    self.elts.insert(i, to_insert.clone());
+                    self.elts.insert(index.unwrap(), to_insert.clone());
                 }
             }
         }
@@ -526,16 +526,16 @@ impl<K: Clone + Ord, V: Clone> Branch<K, V> {
                                          self.clone().rightmost_child),
                         outcome);
             }
-            Some(i) => {
-                if i == self.elts.len() {
+            _ => {
+                if index.unwrap() == self.elts.len() {
                     let new_outcome = self.clone().rightmost_child.insert(k.clone(),
                                                                        v.clone(),
                                                                        ub.clone());
                     new_branch = new_outcome.clone().val0();
                     outcome = new_outcome.val1();
                 }
                 else {
-                    let new_outcome = self.elts.get(i).left.clone().insert(k.clone(),
+                    let new_outcome = self.elts.get(index.unwrap()).left.clone().insert(k.clone(),
                                                                                  v.clone(),
                                                                                  ub.clone());
                     new_branch = new_outcome.clone().val0();
@@ -547,11 +547,11 @@ impl<K: Clone + Ord, V: Clone> Branch<K, V> {
                     //If we have a leaf, we do not need to resize the tree,
                     //so we can return false.
                     LeafNode(..) => {
-                        if i == self.elts.len() {
+                        if index.unwrap() == self.elts.len() {
                             self.rightmost_child = box new_branch.clone();
                         }
                         else {
-                            self.elts.get_mut(i).left = box new_branch.clone();
+                            self.elts.get_mut(index.unwrap()).left = box new_branch.clone();
                         }
                         return (Node::new_branch(self.clone().elts,
                                                  self.clone().rightmost_child),
@@ -589,13 +589,13 @@ impl<K: Clone + Ord, V: Clone> Branch<K, V> {
                                                      self.clone().rightmost_child),
                                     false);
                             }
-                        Some(i) => {
-                            self.elts.insert(i, new_elt);
-                            if i + 1 >= self.elts.len() {
+                        _ => {
+                            self.elts.insert(new_elt_index.unwrap(), new_elt);
+                            if new_elt_index.unwrap() + 1 >= self.elts.len() {
                                 self.rightmost_child = branch.clone().rightmost_child;
                             }
                             else {
-                                self.elts.get_mut(i + 1).left =
+                                self.elts.get_mut(new_elt_index.unwrap() + 1).left =
                                     branch.clone().rightmost_child;
                             }
                         }