---

yaml
---
r: 151199
b: refs/heads/try2
c: de14a73
h: refs/heads/master
i:
  151197: 3fee7d8
  151195: 1bc4e55
  151191: 82bce19
  151183: 13d5b80
  151167: d4ea20f
v: v3

Author: huonw

[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: ad37c0b97c1a5403268e2addbcae28c51d15a924
+refs/heads/try2: de14a739ae27088acaa3c5e21949a39bffd5313b
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/tests.mk

@@ -349,16 +349,6 @@ TESTDEP_$(1)_$(2)_$(3)_$(4) = $$(SREQ$(1)_T_$(2)_H_$(3)) \
 			    $$(foreach crate,$$(TARGET_CRATES),\
 				$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)) \
 				$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4))
-
-# The regex crate depends on the regex_macros crate during testing, but it
-# notably depend on the *host* regex_macros crate, not the target version.
-# Additionally, this is not a dependency in stage1, only in stage2.
-ifeq ($(4),regex)
-ifneq ($(1),1)
-TESTDEP_$(1)_$(2)_$(3)_$(4) += $$(TLIB$(1)_T_$(3)_H_$(3))/stamp.regex_macros
-endif
-endif
-
 else
 TESTDEP_$(1)_$(2)_$(3)_$(4) = $$(RSINPUTS_$(4))
 endif

branches/try2/src/doc/rust.md

@@ -471,7 +471,7 @@ Two examples of paths with type arguments:
 # fn f() {
 # fn id<T>(t: T) -> T { t }
 type T = HashMap<int,~str>;  // Type arguments used in a type expression
-let x = id::<int>(10);       // Type arguments used in a call expression
+let x = id::<int>(10);         // Type arguments used in a call expression
 # }
 ~~~~
 

branches/try2/src/doc/tutorial.md

@@ -982,8 +982,7 @@ The obvious approach is to define `Cons` as containing an element in the list
 along with the next `List` node. However, this will generate a compiler error.
 
 ~~~ {.ignore}
-// error: illegal recursive enum type; wrap the inner value in a box to make it
-// representable
+// error: illegal recursive enum type; wrap the inner value in a box to make it representable
 enum List {
     Cons(u32, List), // an element (`u32`) and the next node in the list
     Nil
@@ -1055,10 +1054,10 @@ immutable, the whole list is immutable. The memory allocation itself is the
 box, while the owner holds onto a pointer to it:
 
 ~~~ {.notrust}
-            List box            List box            List box          List box
-        +--------------+    +--------------+    +--------------+    +----------+
-list -> | Cons | 1 | ~ | -> | Cons | 2 | ~ | -> | Cons | 3 | ~ | -> | Nil      |
-        +--------------+    +--------------+    +--------------+    +----------+
+          List box             List box           List box            List box
+        +--------------+    +--------------+    +--------------+    +--------------+
+list -> | Cons | 1 | ~ | -> | Cons | 2 | ~ | -> | Cons | 3 | ~ | -> | Nil          |
+        +--------------+    +--------------+    +--------------+    +--------------+
 ~~~
 
 > *Note:* the above diagram shows the logical contents of the enum. The actual
@@ -1198,8 +1197,7 @@ fn eq(xs: &List, ys: &List) -> bool {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
         // If the current element in both lists is equal, keep going.
-        (&Cons(x, ~ref next_xs), &Cons(y, ~ref next_ys))
-                if x == y => eq(next_xs, next_ys),
+        (&Cons(x, ~ref next_xs), &Cons(y, ~ref next_ys)) if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
         _ => false
     }
@@ -1258,7 +1256,7 @@ Using the generic `List<T>` works much like before, thanks to type inference:
 #     Cons(value, ~xs)
 # }
 let mut xs = Nil; // Unknown type! This is a `List<T>`, but `T` can be anything.
-xs = prepend(xs, 10); // Here the compiler infers `xs`'s type as `List<int>`.
+xs = prepend(xs, 10); // The compiler infers the type of `xs` as `List<int>` from this.
 xs = prepend(xs, 15);
 xs = prepend(xs, 20);
 ~~~
@@ -1305,8 +1303,7 @@ fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
         // If the current element in both lists is equal, keep going.
-        (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
-                if x == y => eq(next_xs, next_ys),
+        (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys)) if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
         _ => false
     }
@@ -1334,8 +1331,7 @@ impl<T: Eq> Eq for List<T> {
             // If we have reached the end of both lists, they are equal.
             (&Nil, &Nil) => true,
             // If the current element in both lists is equal, keep going.
-            (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
-                    if x == y => next_xs == next_ys,
+            (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys)) if x == y => next_xs == next_ys,
             // If the current elements are not equal, the lists are not equal.
             _ => false
         }

branches/try2/src/liblibc/lib.rs

@@ -231,7 +231,7 @@ pub use funcs::bsd43::{shutdown};
 #[cfg(windows)] pub use types::os::arch::extra::{HANDLE, BOOL, LPSECURITY_ATTRIBUTES};
 #[cfg(windows)] pub use types::os::arch::extra::{LPCSTR, WORD, DWORD, BYTE, FILETIME};
 #[cfg(windows)] pub use types::os::arch::extra::{LARGE_INTEGER, LPVOID, LONG};
-#[cfg(windows)] pub use types::os::arch::extra::{time64_t, OVERLAPPED, LPCWSTR};
+#[cfg(windows)] pub use types::os::arch::extra::{time64_t, OVERLAPPED};
 #[cfg(windows)] pub use types::os::arch::extra::{LPOVERLAPPED, SIZE_T, LPDWORD};
 #[cfg(windows)] pub use funcs::c95::string::{wcslen};
 #[cfg(windows)] pub use funcs::posix88::stat_::{wstat, wutime, wchmod, wrmdir};

branches/try2/src/libregex/compile.rs

@@ -13,7 +13,6 @@
 #![allow(visible_private_types)]
 
 use std::cmp;
-use std::iter;
 use parse;
 use parse::{
     Flags, FLAG_EMPTY,
@@ -89,7 +88,7 @@ pub struct Program {
 
 impl Program {
     /// Compiles a Regex given its AST.
-    pub fn new(ast: ~parse::Ast) -> (Program, ~[Option<~str>]) {
+    pub fn new(ast: parse::Ast) -> (Program, Vec<Option<~str>>) {
         let mut c = Compiler {
             insts: Vec::with_capacity(100),
             names: Vec::with_capacity(10),
@@ -104,16 +103,16 @@ impl Program {
         // This is a bit hacky since we have to skip over the initial
         // 'Save' instruction.
         let mut pre = StrBuf::with_capacity(5);
-        for i in iter::range(1, c.insts.len()) {
-            match *c.insts.get(i) {
+        for inst in c.insts.slice_from(1).iter() {
+            match *inst {
                 OneChar(c, FLAG_EMPTY) => pre.push_char(c),
                 _ => break
             }
         }
 
-        let names = c.names.as_slice().into_owned();
+        let Compiler { insts, names } = c;
         let prog = Program {
-            insts: c.insts,
+            insts: insts,
             prefix: pre.into_owned(),
         };
         (prog, names)
@@ -144,48 +143,48 @@ struct Compiler<'r> {
 // The only tricky thing here is patching jump/split instructions to point to
 // the right instruction.
 impl<'r> Compiler<'r> {
-    fn compile(&mut self, ast: ~parse::Ast) {
+    fn compile(&mut self, ast: parse::Ast) {
         match ast {
-            ~Nothing => {},
-            ~Literal(c, flags) => self.push(OneChar(c, flags)),
-            ~Dot(nl) => self.push(Any(nl)),
-            ~Class(ranges, flags) =>
+            Nothing => {},
+            Literal(c, flags) => self.push(OneChar(c, flags)),
+            Dot(nl) => self.push(Any(nl)),
+            Class(ranges, flags) =>
                 self.push(CharClass(ranges, flags)),
-            ~Begin(flags) => self.push(EmptyBegin(flags)),
-            ~End(flags) => self.push(EmptyEnd(flags)),
-            ~WordBoundary(flags) => self.push(EmptyWordBoundary(flags)),
-            ~Capture(cap, name, x) => {
+            Begin(flags) => self.push(EmptyBegin(flags)),
+            End(flags) => self.push(EmptyEnd(flags)),
+            WordBoundary(flags) => self.push(EmptyWordBoundary(flags)),
+            Capture(cap, name, x) => {
                 let len = self.names.len();
                 if cap >= len {
                     self.names.grow(10 + cap - len, &None)
                 }
                 *self.names.get_mut(cap) = name;
 
                 self.push(Save(2 * cap));
-                self.compile(x);
+                self.compile(*x);
                 self.push(Save(2 * cap + 1));
             }
-            ~Cat(xs) => {
+            Cat(xs) => {
                 for x in xs.move_iter() {
                     self.compile(x)
                 }
             }
-            ~Alt(x, y) => {
+            Alt(x, y) => {
                 let split = self.empty_split(); // push: split 0, 0
                 let j1 = self.insts.len();
-                self.compile(x);                // push: insts for x
+                self.compile(*x);                // push: insts for x
                 let jmp = self.empty_jump();    // push: jmp 0
                 let j2 = self.insts.len();
-                self.compile(y);                // push: insts for y
+                self.compile(*y);                // push: insts for y
                 let j3 = self.insts.len();
 
                 self.set_split(split, j1, j2);  // split 0, 0 -> split j1, j2
                 self.set_jump(jmp, j3);         // jmp 0      -> jmp j3
             }
-            ~Rep(x, ZeroOne, g) => {
+            Rep(x, ZeroOne, g) => {
                 let split = self.empty_split();
                 let j1 = self.insts.len();
-                self.compile(x);
+                self.compile(*x);
                 let j2 = self.insts.len();
 
                 if g.is_greedy() {
@@ -194,11 +193,11 @@ impl<'r> Compiler<'r> {
                     self.set_split(split, j2, j1);
                 }
             }
-            ~Rep(x, ZeroMore, g) => {
+            Rep(x, ZeroMore, g) => {
                 let j1 = self.insts.len();
                 let split = self.empty_split();
                 let j2 = self.insts.len();
-                self.compile(x);
+                self.compile(*x);
                 let jmp = self.empty_jump();
                 let j3 = self.insts.len();
 
@@ -209,9 +208,9 @@ impl<'r> Compiler<'r> {
                     self.set_split(split, j3, j2);
                 }
             }
-            ~Rep(x, OneMore, g) => {
+            Rep(x, OneMore, g) => {
                 let j1 = self.insts.len();
-                self.compile(x);
+                self.compile(*x);
                 let split = self.empty_split();
                 let j2 = self.insts.len();
 

branches/try2/src/libregex/lib.rs

@@ -362,7 +362,7 @@
        html_root_url = "http://static.rust-lang.org/doc/master")]
 
 #![feature(macro_rules, phase)]
-#![deny(missing_doc)]
+#![deny(missing_doc, deprecated_owned_vector)]
 
 extern crate collections;
 #[cfg(test)]