---

yaml
---
r: 28075
b: refs/heads/try
c: d77acf7
h: refs/heads/master
i:
  28073: 3ee6217
  28071: 9b70e5a
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
-refs/heads/try: 4f326dd6504b6848e7b9cc831940d5452d873f56
+refs/heads/try: d77acf7d076fdd7c0b5cf7fae880728c0f6f80e1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df

branches/try/src/libstd/md4.rs

@@ -1,14 +1,11 @@
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
-
-fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
+fn md4(msg: ~[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
     // subtle: if orig_len is merely uint, then the code below
     // which performs shifts by 32 bits or more has undefined
     // results.
     let orig_len: u64 = (vec::len(msg) * 8u) as u64;
 
     // pad message
-    let mut msg = vec::append(vec::from_slice(msg), ~[0x80u8]);
+    let mut msg = vec::append(msg, ~[0x80u8]);
     let mut bitlen = orig_len + 8u64;
     while (bitlen + 64u64) % 512u64 > 0u64 {
         vec::push(msg, 0u8);
@@ -85,7 +82,7 @@ fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
     return {a: a, b: b, c: c, d: d};
 }
 
-fn md4_str(msg: &[u8]) -> ~str {
+fn md4_str(msg: ~[u8]) -> ~str {
     let {a, b, c, d} = md4(msg);
     fn app(a: u32, b: u32, c: u32, d: u32, f: fn(u32)) {
         f(a); f(b); f(c); f(d);
@@ -103,7 +100,7 @@ fn md4_str(msg: &[u8]) -> ~str {
     result
 }
 
-fn md4_text(msg: &str) -> ~str { md4_str(str::to_bytes(msg)) }
+fn md4_text(msg: ~str) -> ~str { md4_str(str::to_bytes(msg)) }
 
 #[test]
 fn test_md4() {

branches/try/src/libstd/sha1.rs

@@ -12,9 +12,6 @@
  * the `reset` method.
  */
 
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
-
 /*
  * A SHA-1 implementation derived from Paul E. Jones's reference
  * implementation, which is written for clarity, not speed. At some
@@ -25,9 +22,9 @@ export sha1;
 /// The SHA-1 interface
 trait sha1 {
     /// Provide message input as bytes
-    fn input((&[u8]));
+    fn input(~[u8]);
     /// Provide message input as string
-    fn input_str((&str));
+    fn input_str(~str);
     /**
      * Read the digest as a vector of 20 bytes. After calling this no further
      * input may be provided until reset is called.
@@ -63,7 +60,7 @@ fn sha1() -> sha1 {
          mut computed: bool,
          work_buf: @~[mut u32]};
 
-    fn add_input(st: &sha1state, msg: &[u8]) {
+    fn add_input(st: sha1state, msg: ~[u8]) {
         assert (!st.computed);
         for vec::each(msg) |element| {
             st.msg_block[st.msg_block_idx] = element;
@@ -79,7 +76,7 @@ fn sha1() -> sha1 {
             if st.msg_block_idx == msg_block_len { process_msg_block(st); }
         }
     }
-    fn process_msg_block(st: &sha1state) {
+    fn process_msg_block(st: sha1state) {
         assert (vec::len(st.h) == digest_buf_len);
         assert (vec::len(*st.work_buf) == work_buf_len);
         let mut t: int; // Loop counter
@@ -158,10 +155,10 @@ fn sha1() -> sha1 {
     fn circular_shift(bits: u32, word: u32) -> u32 {
         return word << bits | word >> 32u32 - bits;
     }
-    fn mk_result(st: &sha1state) -> ~[u8] {
-        if !(*st).computed { pad_msg(st); (*st).computed = true; }
+    fn mk_result(st: sha1state) -> ~[u8] {
+        if !st.computed { pad_msg(st); st.computed = true; }
         let mut rs: ~[u8] = ~[];
-        for vec::each_mut((*st).h) |ptr_hpart| {
+        for vec::each_mut(st.h) |ptr_hpart| {
             let hpart = *ptr_hpart;
             let a = (hpart >> 24u32 & 0xFFu32) as u8;
             let b = (hpart >> 16u32 & 0xFFu32) as u8;
@@ -181,40 +178,40 @@ fn sha1() -> sha1 {
      * call process_msg_block() appropriately.  When it returns, it
      * can be assumed that the message digest has been computed.
      */
-    fn pad_msg(st: &sha1state) {
-        assert (vec::len((*st).msg_block) == msg_block_len);
+    fn pad_msg(st: sha1state) {
+        assert (vec::len(st.msg_block) == msg_block_len);
 
         /*
          * Check to see if the current message block is too small to hold
          * the initial padding bits and length.  If so, we will pad the
          * block, process it, and then continue padding into a second block.
          */
-        if (*st).msg_block_idx > 55u {
-            (*st).msg_block[(*st).msg_block_idx] = 0x80u8;
-            (*st).msg_block_idx += 1u;
-            while (*st).msg_block_idx < msg_block_len {
-                (*st).msg_block[(*st).msg_block_idx] = 0u8;
-                (*st).msg_block_idx += 1u;
+        if st.msg_block_idx > 55u {
+            st.msg_block[st.msg_block_idx] = 0x80u8;
+            st.msg_block_idx += 1u;
+            while st.msg_block_idx < msg_block_len {
+                st.msg_block[st.msg_block_idx] = 0u8;
+                st.msg_block_idx += 1u;
             }
             process_msg_block(st);
         } else {
-            (*st).msg_block[(*st).msg_block_idx] = 0x80u8;
-            (*st).msg_block_idx += 1u;
+            st.msg_block[st.msg_block_idx] = 0x80u8;
+            st.msg_block_idx += 1u;
         }
-        while (*st).msg_block_idx < 56u {
-            (*st).msg_block[(*st).msg_block_idx] = 0u8;
-            (*st).msg_block_idx += 1u;
+        while st.msg_block_idx < 56u {
+            st.msg_block[st.msg_block_idx] = 0u8;
+            st.msg_block_idx += 1u;
         }
 
         // Store the message length as the last 8 octets
-        (*st).msg_block[56] = ((*st).len_high >> 24u32 & 0xFFu32) as u8;
-        (*st).msg_block[57] = ((*st).len_high >> 16u32 & 0xFFu32) as u8;
-        (*st).msg_block[58] = ((*st).len_high >> 8u32 & 0xFFu32) as u8;
-        (*st).msg_block[59] = ((*st).len_high & 0xFFu32) as u8;
-        (*st).msg_block[60] = ((*st).len_low >> 24u32 & 0xFFu32) as u8;
-        (*st).msg_block[61] = ((*st).len_low >> 16u32 & 0xFFu32) as u8;
-        (*st).msg_block[62] = ((*st).len_low >> 8u32 & 0xFFu32) as u8;
-        (*st).msg_block[63] = ((*st).len_low & 0xFFu32) as u8;
+        st.msg_block[56] = (st.len_high >> 24u32 & 0xFFu32) as u8;
+        st.msg_block[57] = (st.len_high >> 16u32 & 0xFFu32) as u8;
+        st.msg_block[58] = (st.len_high >> 8u32 & 0xFFu32) as u8;
+        st.msg_block[59] = (st.len_high & 0xFFu32) as u8;
+        st.msg_block[60] = (st.len_low >> 24u32 & 0xFFu32) as u8;
+        st.msg_block[61] = (st.len_low >> 16u32 & 0xFFu32) as u8;
+        st.msg_block[62] = (st.len_low >> 8u32 & 0xFFu32) as u8;
+        st.msg_block[63] = (st.len_low & 0xFFu32) as u8;
         process_msg_block(st);
     }
 
@@ -231,16 +228,13 @@ fn sha1() -> sha1 {
             self.h[4] = 0xC3D2E1F0u32;
             self.computed = false;
         }
-        fn input(msg: &[u8]) { add_input(&self, msg); }
-        fn input_str(msg: &str) {
-            let bs = str::to_bytes(msg);
-            add_input(&self, bs);
-        }
-        fn result() -> ~[u8] { return mk_result(&self); }
+        fn input(msg: ~[u8]) { add_input(self, msg); }
+        fn input_str(msg: ~str) { add_input(self, str::to_bytes(msg)); }
+        fn result() -> ~[u8] { return mk_result(self); }
         fn result_str() -> ~str {
-            let rr = mk_result(&self);
+            let r = mk_result(self);
             let mut s = ~"";
-            for vec::each(rr) |b| { s += uint::to_str(b as uint, 16u); }
+            for vec::each(r) |b| { s += uint::to_str(b as uint, 16u); }
             return s;
         }
     }

branches/try/src/libstd/timer.rs

@@ -1,8 +1,5 @@
 //! Utilities that leverage libuv's `uv_timer_*` API
 
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
-
 import uv = uv;
 import uv::iotask;
 import iotask::iotask;
@@ -27,7 +24,7 @@ export delayed_send, sleep, recv_timeout;
  * * val - a value of type T to send over the provided `ch`
  */
 fn delayed_send<T: copy send>(iotask: iotask,
-                              msecs: uint, ch: comm::Chan<T>, +val: T) {
+                              msecs: uint, ch: comm::Chan<T>, val: T) {
         unsafe {
             let timer_done_po = core::comm::port::<()>();
             let timer_done_ch = core::comm::chan(timer_done_po);

branches/try/src/libsyntax/parse/parser.rs

@@ -2698,7 +2698,19 @@ struct parser {
                 !self.is_any_keyword(copy self.token)) &&
                 !self.token_is_pound_or_doc_comment(self.token) {
             let a_var = self.parse_instance_var(vis);
-            self.expect(token::SEMI);
+            match self.token {
+                token::SEMI | token::COMMA => {
+                    self.bump();
+                }
+                token::RBRACE => {}
+                _ => {
+                    self.span_fatal(copy self.span,
+                                    fmt!("expected `;`, `,`, or '}' but \
+                                          found `%s`",
+                                         token_to_str(self.reader,
+                                                      self.token)));
+                }
+            }
             return a_var;
         } else {
             let m = self.parse_method(vis);

branches/try/src/libsyntax/print/pprust.rs

@@ -646,7 +646,7 @@ fn print_struct(s: ps, struct_def: @ast::struct_def, tps: ~[ast::ty_param],
                 print_ident(s, ident);
                 word_nbsp(s, ~":");
                 print_type(s, field.node.ty);
-                word(s.s, ~";");
+                word(s.s, ~",");
             }
         }
     }