---

yaml
---
r: 13598
b: refs/heads/master
c: 0a6943d
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1b642bf02f23d48c93047ae2fca9ebd7c2bdc518
+refs/heads/master: 0a6943dd31e8002b2e0267b7539b55ba9da7490b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/doc/rust.css

@@ -51,3 +51,9 @@ h3 a:link, h3 a:visited { color: black; }
 .cm-s-default span.cm-bracket {color: #cc7;}
 .cm-s-default span.cm-tag {color: #170;}
 .cm-s-default span.cm-attribute {color: #00c;}
+
+h1.title {
+  background-image: url('http://www.rust-lang.org/logos/rust-logo-32x32-blk.png');
+  background-repeat: no-repeat;
+  background-position: right;
+}

trunk/src/libcore/comm.rs

@@ -94,31 +94,27 @@ fn listen<T: send, U>(f: fn(chan<T>) -> U) -> U {
     f(po.chan())
 }
 
-class port_ptr<T:send> {
-  let po: *rust_port;
-  new(po: *rust_port) { self.po = po; }
-  drop unsafe {
+resource port_ptr<T: send>(po: *rust_port) unsafe {
     task::unkillable {||
         // Once the port is detached it's guaranteed not to receive further
         // messages
         let yield = 0u;
         let yieldp = ptr::addr_of(yield);
-        rustrt::rust_port_begin_detach(self.po, yieldp);
+        rustrt::rust_port_begin_detach(po, yieldp);
         if yield != 0u {
             // Need to wait for the port to be detached
             // FIXME: If this fails then we're going to leave our port
             // in a bogus state. (Issue #1988)
             task::yield();
         }
-        rustrt::rust_port_end_detach(self.po);
+        rustrt::rust_port_end_detach(po);
 
         // Drain the port so that all the still-enqueued items get dropped
-        while rustrt::rust_port_size(self.po) > 0u as size_t {
-            recv_::<T>(self.po);
+        while rustrt::rust_port_size(po) > 0u as size_t {
+            recv_::<T>(po);
         }
-        rustrt::del_port(self.po);
+        rustrt::del_port(po);
     }
-  }
 }
 
 #[doc = "
@@ -130,34 +126,29 @@ Fails if the port is detached or dead. Fails if the port
 is owned by a different task.
 "]
 fn as_raw_port<T: send, U>(ch: comm::chan<T>, f: fn(*rust_port) -> U) -> U {
-
-    class portref {
-       let p: *rust_port;
-       new(p: *rust_port) { self.p = p; }
-       drop {
-         if !ptr::is_null(self.p) {
-           rustrt::rust_port_drop(self.p);
-         }
-       }
+    resource portref(p: *rust_port) {
+        if !ptr::is_null(p) {
+            rustrt::rust_port_drop(p);
+        }
     }
 
     let p = portref(rustrt::rust_port_take(*ch));
 
-    if ptr::is_null(p.p) {
+    if ptr::is_null(*p) {
         fail "unable to locate port for channel"
-    } else if rustrt::get_task_id() != rustrt::rust_port_task(p.p) {
+    } else if rustrt::get_task_id() != rustrt::rust_port_task(*p) {
         fail "unable to access unowned port"
     }
 
-    f(p.p)
+    f(*p)
 }
 
 #[doc = "
 Constructs a channel. The channel is bound to the port used to
 construct it.
 "]
 fn chan<T: send>(p: port<T>) -> chan<T> {
-    chan_t(rustrt::get_port_id((**p).po))
+    chan_t(rustrt::get_port_id(***p))
 }
 
 #[doc = "
@@ -179,10 +170,10 @@ fn send<T: send>(ch: chan<T>, -data: T) {
 Receive from a port.  If no data is available on the port then the
 task will block until data becomes available.
 "]
-fn recv<T: send>(p: port<T>) -> T { recv_((**p).po) }
+fn recv<T: send>(p: port<T>) -> T { recv_(***p) }
 
 #[doc = "Returns true if there are messages available"]
-fn peek<T: send>(p: port<T>) -> bool { peek_((**p).po) }
+fn peek<T: send>(p: port<T>) -> bool { peek_(***p) }
 
 #[doc(hidden)]
 fn recv_chan<T: send>(ch: comm::chan<T>) -> T {
@@ -205,7 +196,7 @@ fn recv_<T: send>(p: *rust_port) -> T {
         // Data isn't available yet, so res has not been initialized.
         task::yield();
     } else {
-        // In the absence of compiler-generated preemption points
+        // In the absense of compiler-generated preemption points
         // this is a good place to yield
         task::yield();
     }
@@ -219,7 +210,7 @@ fn peek_(p: *rust_port) -> bool unsafe {
 #[doc = "Receive on one of two ports"]
 fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>)
     -> either<A, B> unsafe {
-    let ports = [(**p_a).po, (**p_b).po];
+    let ports = [***p_a, ***p_b];
     let n_ports = 2 as libc::size_t;
     let yield = 0u, yieldp = ptr::addr_of(yield);
 
@@ -242,9 +233,9 @@ fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>)
     // Now we know the port we're supposed to receive from
     assert resport != ptr::null();
 
-    if resport == (**p_a).po {
+    if resport == ***p_a {
         either::left(recv(p_a))
-    } else if resport == (**p_b).po {
+    } else if resport == ***p_b {
         either::right(recv(p_b))
     } else {
         fail "unexpected result from rust_port_select";
@@ -491,4 +482,4 @@ fn test_port_detach_fail() {
             }
         }
     }
-}
+}

trunk/src/libcore/stackwalk.rs

@@ -23,10 +23,10 @@ fn walk_stack(visit: fn(frame) -> bool) {
             reinterpret_cast(frame_pointer)
         };
         loop {
-            let fr = frame(frame_address);
+            let frame = frame(frame_address);
 
-            #debug("frame: %x", unsafe { reinterpret_cast(fr.fp) });
-            visit(fr);
+            #debug("frame: %x", unsafe { reinterpret_cast(frame.fp) });
+            visit(frame);
 
             unsafe {
                 let next_fp: **word = reinterpret_cast(frame_address);
@@ -44,7 +44,7 @@ fn walk_stack(visit: fn(frame) -> bool) {
 
 #[test]
 fn test_simple() {
-    for walk_stack { |_frame|
+    for walk_stack { |frame|
     }
 }
 
@@ -53,7 +53,7 @@ fn test_simple_deep() {
     fn run(i: int) {
         if i == 0 { ret }
 
-        for walk_stack { |_frame|
+        for walk_stack { |frame|
             unsafe {
                 breakpoint();
             }

trunk/src/libcore/str.rs

@@ -566,7 +566,7 @@ pure fn to_upper(s: str/&) -> str {
 }
 
 #[doc = "
-Replace all occurrences of one string with another
+Replace all occurances of one string with another
 
 # Arguments
 

trunk/src/libstd/par.rs

@@ -7,7 +7,7 @@ import future::future;
 export map, mapi, alli, any, mapi_factory;
 
 #[doc="The maximum number of tasks this module will spawn for a single
-operation."]
+operationg."]
 const max_tasks : uint = 32u;
 
 #[doc="The minimum number of elements each task will process."]

trunk/src/rustc/middle/resolve.rs

@@ -573,6 +573,7 @@ fn visit_item_with_scope(e: @env, i: @ast::item,
       }
       ast::item_class(tps, ifaces, members, ctor, m_dtor, _) {
         v.visit_ty_params(tps, sc, v);
+        // Can maybe skip this now that we require self on class fields
         let class_scope = @cons(scope_item(i), sc);
         /* visit the constructor... */
         let ctor_scope = @cons(scope_method(ctor.node.self_id, tps),
@@ -1060,7 +1061,7 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace,
               }
               ast::item_class(tps, _, members, ctor, _, _) {
                   if ns == ns_type {
-                      ret lookup_in_ty_params(e, name, tps);
+                    ret lookup_in_ty_params(e, name, tps);
                   }
                   if ns == ns_val && name == it.ident {
                       ret some(ast::def_fn(local_def(ctor.node.id),
@@ -1316,14 +1317,13 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option<def> {
     alt i.node {
       ast::item_const(*) {
         if ns == ns_val {
-            ret some(ast::def_const(local_def(i.id)));
-        }
+            ret some(ast::def_const(local_def(i.id))); }
       }
       ast::item_fn(decl, _, _) {
-          if ns == ns_val {
+        if ns == ns_val {
             ret some(ast::def_fn(local_def(i.id), decl.purity));
-           }
-       }
+        }
+      }
       ast::item_mod(_) {
         if ns == ns_module { ret some(ast::def_mod(local_def(i.id))); }
       }
@@ -1342,16 +1342,9 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option<def> {
           _ { }
         }
       }
-      ast::item_class(_, _, _members, ct, _, _) {
-          alt ns {
-             ns_type {
-               ret some(ast::def_class(local_def(i.id)));
-             }
-             ns_val {
-               ret some(ast::def_fn(local_def(ct.node.id),
-                                    ast::impure_fn));
-             }
-             ns_module { }
+      ast::item_class(*) {
+          if ns == ns_type {
+            ret some(ast::def_class(local_def(i.id)));
           }
       }
       ast::item_impl(*) { /* ??? */ }
@@ -1660,6 +1653,14 @@ fn index_mod(md: ast::_mod) -> mod_index {
           ast::item_class(tps, _, items, ctor, _, _) {
               // add the class name itself
               add_to_index(index, it.ident, mie_item(it));
+              // add the constructor decl
+              add_to_index(index, it.ident,
+                           mie_item(@{ident: it.ident, attrs: [],
+                            id: ctor.node.id,
+                            node:
+                              item_fn(ctor.node.dec, tps, ctor.node.body),
+                            vis: ast::public,
+                            span: ctor.node.body.span}));
           }
         }
     }