Merge remote-tracking branch 'mozilla/incoming' into incoming

Author: catamorphism

src/libcore/comm.rs

@@ -94,27 +94,31 @@ fn listen<T: send, U>(f: fn(chan<T>) -> U) -> U {
     f(po.chan())
 }
 
-resource port_ptr<T: send>(po: *rust_port) unsafe {
+class port_ptr<T:send> {
+  let po: *rust_port;
+  new(po: *rust_port) { self.po = po; }
+  drop 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(po, yieldp);
+        rustrt::rust_port_begin_detach(self.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(po);
+        rustrt::rust_port_end_detach(self.po);
 
         // Drain the port so that all the still-enqueued items get dropped
-        while rustrt::rust_port_size(po) > 0u as size_t {
-            recv_::<T>(po);
+        while rustrt::rust_port_size(self.po) > 0u as size_t {
+            recv_::<T>(self.po);
         }
-        rustrt::del_port(po);
+        rustrt::del_port(self.po);
     }
+  }
 }
 
 #[doc = "
@@ -126,29 +130,34 @@ 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 {
-    resource portref(p: *rust_port) {
-        if !ptr::is_null(p) {
-            rustrt::rust_port_drop(p);
-        }
+
+    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);
+         }
+       }
     }
 
     let p = portref(rustrt::rust_port_take(*ch));
 
-    if ptr::is_null(*p) {
+    if ptr::is_null(p.p) {
         fail "unable to locate port for channel"
-    } else if rustrt::get_task_id() != rustrt::rust_port_task(*p) {
+    } else if rustrt::get_task_id() != rustrt::rust_port_task(p.p) {
         fail "unable to access unowned port"
     }
 
-    f(*p)
+    f(p.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))
+    chan_t(rustrt::get_port_id((**p).po))
 }
 
 #[doc = "
@@ -170,10 +179,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) }
+fn recv<T: send>(p: port<T>) -> T { recv_((**p).po) }
 
 #[doc = "Returns true if there are messages available"]
-fn peek<T: send>(p: port<T>) -> bool { peek_(***p) }
+fn peek<T: send>(p: port<T>) -> bool { peek_((**p).po) }
 
 #[doc(hidden)]
 fn recv_chan<T: send>(ch: comm::chan<T>) -> T {
@@ -196,7 +205,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 absense of compiler-generated preemption points
+        // In the absence of compiler-generated preemption points
         // this is a good place to yield
         task::yield();
     }
@@ -210,7 +219,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, ***p_b];
+    let ports = [(**p_a).po, (**p_b).po];
     let n_ports = 2 as libc::size_t;
     let yield = 0u, yieldp = ptr::addr_of(yield);
 
@@ -233,9 +242,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 {
+    if resport == (**p_a).po {
         either::left(recv(p_a))
-    } else if resport == ***p_b {
+    } else if resport == (**p_b).po {
         either::right(recv(p_b))
     } else {
         fail "unexpected result from rust_port_select";
@@ -482,4 +491,4 @@ fn test_port_detach_fail() {
             }
         }
     }
-}
+}

src/libcore/stackwalk.rs

@@ -23,10 +23,10 @@ fn walk_stack(visit: fn(frame) -> bool) {
             reinterpret_cast(frame_pointer)
         };
         loop {
-            let frame = frame(frame_address);
+            let fr = frame(frame_address);
 
-            #debug("frame: %x", unsafe { reinterpret_cast(frame.fp) });
-            visit(frame);
+            #debug("frame: %x", unsafe { reinterpret_cast(fr.fp) });
+            visit(fr);
 
             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();
             }

src/libcore/str.rs

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

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
-operationg."]
+operation."]
 const max_tasks : uint = 32u;
 
 #[doc="The minimum number of elements each task will process."]

src/rustc/middle/borrowck/check_loans.rs

@@ -47,6 +47,7 @@ fn check_loans(bccx: borrowck_ctxt,
                                  mut declared_purity: ast::impure_fn,
                                  mut fn_args: @[]});
     let vt = visit::mk_vt(@{visit_expr: check_loans_in_expr,
+                            visit_local: check_loans_in_local,
                             visit_block: check_loans_in_block,
                             visit_fn: check_loans_in_fn
                             with *visit::default_visitor()});
@@ -419,6 +420,9 @@ impl methods for check_loan_ctxt {
           // rvalues, I guess.
           cat_special(sk_static_item) { }
 
+          cat_deref(_, _, unsafe_ptr) {
+          }
+
           // Nothing else.
           _ {
             self.bccx.span_err(
@@ -542,6 +546,18 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
     #debug["purity on exit=%?", copy self.declared_purity];
 }
 
+fn check_loans_in_local(local: @ast::local,
+                        &&self: check_loan_ctxt,
+                        vt: visit::vt<check_loan_ctxt>) {
+    alt local.node.init {
+      some({op: ast::init_move, expr: expr}) {
+        self.check_move_out(expr);
+      }
+      some({op: ast::init_assign, _}) | none {}
+    }
+    visit::visit_local(local, self, vt);
+}
+
 fn check_loans_in_expr(expr: @ast::expr,
                        &&self: check_loan_ctxt,
                        vt: visit::vt<check_loan_ctxt>) {

src/rustc/middle/resolve.rs

@@ -573,7 +573,6 @@ 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),
@@ -1061,7 +1060,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),
@@ -1317,13 +1316,14 @@ 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,9 +1342,16 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option<def> {
           _ { }
         }
       }
-      ast::item_class(*) {
-          if ns == ns_type {
-            ret some(ast::def_class(local_def(i.id)));
+      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_impl(*) { /* ??? */ }
@@ -1653,14 +1660,6 @@ 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}));
           }
         }
     }