---

yaml
---
r: 40318
b: refs/heads/dist-snap
c: 92e3a8c
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: d42cf97bcc6110be8a8b2ec02669230b265332dd
+refs/heads/dist-snap: 92e3a8c17e9b7cb61b18791aea0544794a315bbb
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/condition.rs

@@ -96,18 +96,16 @@ struct Guard<T, U:Copy> {
 mod test {
 
     fn sadness_key(_x: @Handler<int,int>) { }
+    const sadness_condition : Condition<int,int> =
+        Condition { key: sadness_key };
+
     fn trouble(i: int) {
-        // Condition should work as a const, just limitations in consts.
-        let sadness_condition : Condition<int,int> =
-            Condition { key: sadness_key };
         debug!("trouble: raising conition");
         let j = sadness_condition.raise(&i);
         debug!("trouble: handler recovered with %d", j);
     }
 
     fn nested_trap_test_inner() {
-        let sadness_condition : Condition<int,int> =
-            Condition { key: sadness_key };
 
         let mut inner_trapped = false;
 
@@ -126,9 +124,6 @@ mod test {
     #[test]
     fn nested_trap_test_outer() {
 
-        let sadness_condition : Condition<int,int> =
-            Condition { key: sadness_key };
-
         let mut outer_trapped = false;
 
         do sadness_condition.trap(|_j| {
@@ -144,8 +139,6 @@ mod test {
     }
 
     fn nested_reraise_trap_test_inner() {
-        let sadness_condition : Condition<int,int> =
-            Condition { key: sadness_key };
 
         let mut inner_trapped = false;
 
@@ -166,9 +159,6 @@ mod test {
     #[test]
     fn nested_reraise_trap_test_outer() {
 
-        let sadness_condition : Condition<int,int> =
-            Condition { key: sadness_key };
-
         let mut outer_trapped = false;
 
         do sadness_condition.trap(|_j| {
@@ -184,8 +174,6 @@ mod test {
 
     #[test]
     fn test_default() {
-        let sadness_condition : Condition<int,int> =
-            Condition { key: sadness_key };
 
         let mut trapped = false;
 

branches/dist-snap/src/libstd/net_tcp.rs

@@ -48,13 +48,11 @@ pub fn TcpSocket(socket_data: @TcpSocketData) -> TcpSocket {
  */
 struct TcpSocketBuf {
     data: @TcpBufferedSocketData,
-    mut end_of_stream: bool,
 }
 
 pub fn TcpSocketBuf(data: @TcpBufferedSocketData) -> TcpSocketBuf {
     TcpSocketBuf {
-        data: data,
-        end_of_stream: false
+        data: data
     }
 }
 
@@ -784,7 +782,6 @@ impl TcpSocketBuf: io::Reader {
                 let err_data = read_result.get_err();
 
                 if err_data.err_name == ~"EOF" {
-                    self.end_of_stream = true;
                     break;
                 } else {
                     debug!("ERROR sock_buf as io::reader.read err %? %?",
@@ -811,21 +808,13 @@ impl TcpSocketBuf: io::Reader {
     }
     fn read_byte() -> int {
         let mut bytes = ~[0];
-        if self.read(bytes, 1u) == 0 { 
-            if self.end_of_stream {
-                -1
-            } else {
-                fail
-            }
-        } else {
-            bytes[0] as int
-        }
+        if self.read(bytes, 1u) == 0 { fail } else { bytes[0] as int }
     }
     fn unread_byte(amt: int) {
         self.data.buf.unshift(amt as u8);
     }
     fn eof() -> bool {
-        self.end_of_stream
+        false // noop
     }
     fn seek(dist: int, seek: io::SeekStyle) {
         log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
@@ -882,8 +871,7 @@ fn tear_down_socket_data(socket_data: @TcpSocketData) unsafe {
         uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb);
     };
     core::comm::recv(closed_po);
-    //the line below will most likely crash
-    //log(debug, fmt!("about to free socket_data at %?", socket_data));
+    log(debug, fmt!("about to free socket_data at %?", socket_data));
     rustrt::rust_uv_current_kernel_free(stream_handle_ptr
                                        as *libc::c_void);
     log(debug, ~"exiting dtor for tcp_socket");

branches/dist-snap/src/libsyntax/ast.rs

@@ -410,18 +410,24 @@ impl mutability : cmp::Eq {
 
 #[auto_serialize]
 #[auto_deserialize]
-enum proto {
-    proto_bare,    // foreign fn
-    proto_uniq,    // fn~
-    proto_box,     // fn@
-    proto_block,   // fn&
+pub enum Proto {
+    ProtoBare,     // bare functions (deprecated)
+    ProtoUniq,     // ~fn
+    ProtoBox,      // @fn
+    ProtoBorrowed, // &fn
 }
 
-impl proto : cmp::Eq {
-    pure fn eq(other: &proto) -> bool {
+impl Proto : cmp::Eq {
+    pure fn eq(other: &Proto) -> bool {
         (self as uint) == ((*other) as uint)
     }
-    pure fn ne(other: &proto) -> bool { !self.eq(other) }
+    pure fn ne(other: &Proto) -> bool { !self.eq(other) }
+}
+
+impl Proto : to_bytes::IterBytes {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
+        (self as uint).iter_bytes(lsb0, f);
+    }
 }
 
 #[auto_serialize]
@@ -444,10 +450,10 @@ enum expr_vstore {
     expr_vstore_slice                  // &[1,2,3,4]
 }
 
-pure fn is_blockish(p: ast::proto) -> bool {
+pure fn is_blockish(p: ast::Proto) -> bool {
     match p {
-      proto_block => true,
-      proto_bare | proto_uniq | proto_box => false
+        ProtoBorrowed => true,
+        ProtoBare | ProtoUniq | ProtoBox => false
     }
 }
 
@@ -678,7 +684,7 @@ enum expr_ {
        (implicit) condition is always true. */
     expr_loop(blk, Option<ident>),
     expr_match(@expr, ~[arm]),
-    expr_fn(proto, fn_decl, blk, capture_clause),
+    expr_fn(Proto, fn_decl, blk, capture_clause),
     expr_fn_block(fn_decl, blk, capture_clause),
     // Inner expr is always an expr_fn_block. We need the wrapping node to
     // easily type this (a function returning nil on the inside but bool on
@@ -1078,6 +1084,17 @@ impl Onceness : cmp::Eq {
     }
 }
 
+#[auto_serialize]
+#[auto_deserialize]
+struct TyFn {
+    proto: Proto,
+    region: Option<@region>,
+    purity: purity,
+    onceness: Onceness,
+    bounds: @~[ty_param_bound],
+    decl: fn_decl
+}
+
 #[auto_serialize]
 #[auto_deserialize]
 enum ty_ {
@@ -1086,13 +1103,13 @@ enum ty_ {
     ty_box(mt),
     ty_uniq(mt),
     ty_vec(mt),
+    ty_fixed_length_vec(mt, uint),
     ty_ptr(mt),
     ty_rptr(@region, mt),
     ty_rec(~[ty_field]),
-    ty_fn(proto, purity, Onceness, @~[ty_param_bound], fn_decl),
+    ty_fn(@TyFn),
     ty_tup(~[@Ty]),
     ty_path(@path, node_id),
-    ty_fixed_length(@Ty, Option<uint>),
     ty_mac(mac),
     // ty_infer means the type should be inferred instead of it having been
     // specified. This should only appear at the "top level" of a type and not

branches/dist-snap/src/libsyntax/fold.rs

@@ -524,15 +524,19 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
       ty_ptr(mt) => ty_ptr(fold_mt(mt, fld)),
       ty_rptr(region, mt) => ty_rptr(region, fold_mt(mt, fld)),
       ty_rec(fields) => ty_rec(vec::map(fields, |f| fold_field(*f, fld))),
-      ty_fn(proto, purity, onceness, bounds, decl) =>
-        ty_fn(proto,
-              purity,
-              onceness,
-              @vec::map(*bounds, |x| fold_ty_param_bound(*x, fld)),
-              fold_fn_decl(decl, fld)),
+      ty_fn(f) =>
+        ty_fn(@TyFn {
+            proto: f.proto,
+            purity: f.purity,
+            region: f.region,
+            onceness: f.onceness,
+            bounds: @vec::map(*f.bounds, |x| fold_ty_param_bound(*x, fld)),
+            decl: fold_fn_decl(f.decl, fld)
+        }),
       ty_tup(tys) => ty_tup(vec::map(tys, |ty| fld.fold_ty(*ty))),
       ty_path(path, id) => ty_path(fld.fold_path(path), fld.new_id(id)),
-      ty_fixed_length(t, vs) => ty_fixed_length(fld.fold_ty(t), vs),
+      ty_fixed_length_vec(mt, vs) =>
+        ty_fixed_length_vec(fold_mt(mt, fld), vs),
       ty_mac(mac) => ty_mac(fold_mac(mac))
     }
 }

branches/dist-snap/src/libsyntax/parse/obsolete.rs

@@ -24,7 +24,6 @@ pub enum ObsoleteSyntax {
     ObsoletePrivSection,
     ObsoleteModeInFnType,
     ObsoleteByMutRefMode,
-    ObsoleteFixedLengthVec,
     ObsoleteMoveInit,
     ObsoleteBinaryMove
 }
@@ -102,11 +101,6 @@ impl Parser : ObsoleteReporter {
                 "by-mutable-reference mode",
                 "Declare an argument of type &mut T instead"
             ),
-            ObsoleteFixedLengthVec => (
-                "fixed-length vector",
-                "Fixed-length types are now written `[T * N]`, and instances \
-                 are type-inferred"
-            ),
             ObsoleteMoveInit => (
                 "initializer-by-move",
                 "Write `let foo = move bar` instead"
@@ -200,65 +194,5 @@ impl Parser : ObsoleteReporter {
         }
     }
 
-    fn try_parse_obsolete_fixed_vstore() -> Option<Option<uint>> {
-        if self.token == token::BINOP(token::SLASH) {
-            self.bump();
-            match copy self.token {
-                token::UNDERSCORE => {
-                    self.obsolete(copy self.last_span,
-                                  ObsoleteFixedLengthVec);
-                    self.bump(); Some(None)
-                }
-                token::LIT_INT_UNSUFFIXED(i) if i >= 0i64 => {
-                    self.obsolete(copy self.last_span,
-                                  ObsoleteFixedLengthVec);
-                    self.bump(); Some(Some(i as uint))
-                }
-                _ => None
-            }
-        } else {
-            None
-        }
-    }
-
-    fn try_convert_ty_to_obsolete_fixed_length_vstore(sp: span, t: ast::ty_)
-        -> ast::ty_ {
-        match self.try_parse_obsolete_fixed_vstore() {
-            // Consider a fixed length vstore suffix (/N or /_)
-            None => t,
-            Some(v) => {
-                ast::ty_fixed_length(
-                    @{id: self.get_id(), node: t, span: sp}, v)
-            }
-        }
-    }
-
-    fn try_convert_expr_to_obsolete_fixed_length_vstore(
-        lo: uint, hi: uint, ex: ast::expr_
-    ) -> (uint, ast::expr_) {
-
-        let mut hi = hi;
-        let mut ex = ex;
-
-        // Vstore is legal following expr_lit(lit_str(...)) and expr_vec(...)
-        // only.
-        match ex {
-            ast::expr_lit(@{node: ast::lit_str(_), span: _}) |
-            ast::expr_vec(_, _)  => {
-                match self.try_parse_obsolete_fixed_vstore() {
-                    None => (),
-                    Some(v) => {
-                        hi = self.span.hi;
-                        ex = ast::expr_vstore(self.mk_expr(lo, hi, ex),
-                                              ast::expr_vstore_fixed(v));
-                    }
-                }
-            }
-            _ => ()
-        }
-
-        return (hi, ex);
-    }
-
 }