---

yaml
---
r: 97192
b: refs/heads/dist-snap
c: 200c52a
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 2a4f9d69afd19603ed3354fa8e64ab0e67c6a915
+refs/heads/dist-snap: 200c52a34e7673ab4186f86394c52874c98b4ffa
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/etc/vim/syntax/rust.vim

@@ -78,7 +78,7 @@ syn keyword rustTrait Default
 syn keyword rustTrait Hash
 syn keyword rustTrait FromStr
 syn keyword rustTrait FromIterator Extendable
-syn keyword rustTrait Iterator DoubleEndedIterator RandomAccessIterator ClonableIterator
+syn keyword rustTrait Iterator DoubleEndedIterator RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator ExactSize
 syn keyword rustTrait Times
 

branches/dist-snap/src/libextra/enum_set.rs

@@ -13,7 +13,7 @@
 //! This module defines a container which uses an efficient bit mask
 //! representation to hold C-like enum variants.
 
-#[deriving(Clone, Eq, IterBytes, ToStr)]
+#[deriving(Clone, Eq, IterBytes, ToStr, Encodable, Decodable)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set

branches/dist-snap/src/libgreen/lib.rs

@@ -214,11 +214,7 @@ impl SchedPool {
             pool.handles.push(sched.make_handle());
             let sched = sched;
             pool.threads.push(do Thread::start {
-                let mut sched = sched;
-                let task = do GreenTask::new(&mut sched.stack_pool, None) {
-                    rtdebug!("boostraping a non-primary scheduler");
-                };
-                sched.bootstrap(task);
+                sched.bootstrap();
             });
         }
 
@@ -270,13 +266,7 @@ impl SchedPool {
         let ret = sched.make_handle();
         self.handles.push(sched.make_handle());
         let sched = sched;
-        self.threads.push(do Thread::start {
-            let mut sched = sched;
-            let task = do GreenTask::new(&mut sched.stack_pool, None) {
-                rtdebug!("boostraping a non-primary scheduler");
-            };
-            sched.bootstrap(task);
-        });
+        self.threads.push(do Thread::start { sched.bootstrap() });
 
         return ret;
     }

branches/dist-snap/src/libgreen/sched.rs

@@ -171,7 +171,7 @@ impl Scheduler {
 
     // Take a main task to run, and a scheduler to run it in. Create a
     // scheduler task and bootstrap into it.
-    pub fn bootstrap(mut ~self, task: ~GreenTask) {
+    pub fn bootstrap(mut ~self) {
 
         // Build an Idle callback.
         let cb = ~SchedRunner as ~Callback;
@@ -187,18 +187,11 @@ impl Scheduler {
         self.idle_callback.get_mut_ref().resume();
 
         // Now, as far as all the scheduler state is concerned, we are inside
-        // the "scheduler" context. So we can act like the scheduler and resume
-        // the provided task. Let it think that the currently running task is
-        // actually the sched_task so it knows where to squirrel it away.
-        let mut sched_task = self.resume_task_immediately(sched_task, task);
-
-        // Now we are back in the scheduler context, having
-        // successfully run the input task. Start by running the
-        // scheduler. Grab it out of TLS - performing the scheduler
-        // action will have given it away.
-        let sched = sched_task.sched.take_unwrap();
-        rtdebug!("starting scheduler {}", sched.sched_id());
-        let mut sched_task = sched.run(sched_task);
+        // the "scheduler" context. The scheduler immediately hands over control
+        // to the event loop, and this will only exit once the event loop no
+        // longer has any references (handles or I/O objects).
+        rtdebug!("starting scheduler {}", self.sched_id());
+        let mut sched_task = self.run(sched_task);
 
         // Close the idle callback.
         let mut sched = sched_task.sched.take_unwrap();
@@ -548,7 +541,10 @@ impl Scheduler {
         // We push the task onto our local queue clone.
         assert!(!task.is_sched());
         self.work_queue.push(task);
-        self.idle_callback.get_mut_ref().resume();
+        match self.idle_callback {
+            Some(ref mut idle) => idle.resume(),
+            None => {} // allow enqueuing before the scheduler starts
+        }
 
         // We've made work available. Notify a
         // sleeping scheduler.
@@ -1176,25 +1172,21 @@ mod test {
                 let mut sh = special_handle;
                 sh.send(Shutdown);
             };
-
+            normal_sched.enqueue_task(normal_task);
 
             let special_task = do GreenTask::new(&mut special_sched.stack_pool,
                                                  None) {
                 run(task1);
                 run(task3);
                 chan.send(());
             };
-
+            special_sched.enqueue_task(special_task);
 
             let normal_sched = normal_sched;
-            let normal_thread = do Thread::start {
-                normal_sched.bootstrap(normal_task);
-            };
+            let normal_thread = do Thread::start { normal_sched.bootstrap() };
 
             let special_sched = special_sched;
-            let special_thread = do Thread::start {
-                special_sched.bootstrap(special_task);
-            };
+            let special_thread = do Thread::start { special_sched.bootstrap() };
 
             normal_thread.join();
             special_thread.join();

branches/dist-snap/src/librustc/back/link.rs

@@ -111,38 +111,14 @@ pub mod write {
         let llmod = trans.module;
         let llcx = trans.context;
         unsafe {
-            llvm::LLVMInitializePasses();
-
-            // Only initialize the platforms supported by Rust here, because
-            // using --llvm-root will have multiple platforms that rustllvm
-            // doesn't actually link to and it's pointless to put target info
-            // into the registry that Rust can not generate machine code for.
-            llvm::LLVMInitializeX86TargetInfo();
-            llvm::LLVMInitializeX86Target();
-            llvm::LLVMInitializeX86TargetMC();
-            llvm::LLVMInitializeX86AsmPrinter();
-            llvm::LLVMInitializeX86AsmParser();
-
-            llvm::LLVMInitializeARMTargetInfo();
-            llvm::LLVMInitializeARMTarget();
-            llvm::LLVMInitializeARMTargetMC();
-            llvm::LLVMInitializeARMAsmPrinter();
-            llvm::LLVMInitializeARMAsmParser();
-
-            llvm::LLVMInitializeMipsTargetInfo();
-            llvm::LLVMInitializeMipsTarget();
-            llvm::LLVMInitializeMipsTargetMC();
-            llvm::LLVMInitializeMipsAsmPrinter();
-            llvm::LLVMInitializeMipsAsmParser();
+            configure_llvm(sess);
 
             if sess.opts.save_temps {
                 output.with_extension("no-opt.bc").with_c_str(|buf| {
                     llvm::LLVMWriteBitcodeToFile(llmod, buf);
                 })
             }
 
-            configure_llvm(sess);
-
             let OptLevel = match sess.opts.optimize {
               session::No => lib::llvm::CodeGenLevelNone,
               session::Less => lib::llvm::CodeGenLevelLess,
@@ -367,6 +343,30 @@ pub mod write {
 
         LOCK.lock();
         if !CONFIGURED {
+            llvm::LLVMInitializePasses();
+
+            // Only initialize the platforms supported by Rust here, because
+            // using --llvm-root will have multiple platforms that rustllvm
+            // doesn't actually link to and it's pointless to put target info
+            // into the registry that Rust can not generate machine code for.
+            llvm::LLVMInitializeX86TargetInfo();
+            llvm::LLVMInitializeX86Target();
+            llvm::LLVMInitializeX86TargetMC();
+            llvm::LLVMInitializeX86AsmPrinter();
+            llvm::LLVMInitializeX86AsmParser();
+
+            llvm::LLVMInitializeARMTargetInfo();
+            llvm::LLVMInitializeARMTarget();
+            llvm::LLVMInitializeARMTargetMC();
+            llvm::LLVMInitializeARMAsmPrinter();
+            llvm::LLVMInitializeARMAsmParser();
+
+            llvm::LLVMInitializeMipsTargetInfo();
+            llvm::LLVMInitializeMipsTarget();
+            llvm::LLVMInitializeMipsTargetMC();
+            llvm::LLVMInitializeMipsAsmPrinter();
+            llvm::LLVMInitializeMipsAsmParser();
+
             llvm::LLVMRustSetLLVMOptions(llvm_args.len() as c_int,
                                          llvm_args.as_ptr());
             CONFIGURED = true;

branches/dist-snap/src/librustc/metadata/tydecode.rs

@@ -129,6 +129,12 @@ pub fn parse_trait_ref_data(data: &[u8], crate_num: ast::CrateNum, pos: uint, tc
     parse_trait_ref(&mut st, conv)
 }
 
+pub fn parse_substs_data(data: &[u8], crate_num: ast::CrateNum, pos: uint, tcx: ty::ctxt,
+                         conv: conv_did) -> ty::substs {
+    let mut st = parse_state_from_data(data, crate_num, pos, tcx);
+    parse_substs(&mut st, conv)
+}
+
 fn parse_sigil(st: &mut PState) -> ast::Sigil {
     match next(st) {
         '@' => ast::ManagedSigil,

branches/dist-snap/src/librustc/metadata/tyencode.rs

@@ -140,7 +140,7 @@ fn enc_opt<T>(w: &mut MemWriter, t: Option<T>, enc_f: |&mut MemWriter, T|) {
     }
 }
 
-fn enc_substs(w: &mut MemWriter, cx: @ctxt, substs: &ty::substs) {
+pub fn enc_substs(w: &mut MemWriter, cx: @ctxt, substs: &ty::substs) {
     enc_region_substs(w, cx, &substs.regions);
     enc_opt(w, substs.self_ty, |w, t| enc_ty(w, cx, t));
     mywrite!(w, "[");

branches/dist-snap/src/librustc/middle/astencode.rs

@@ -450,15 +450,13 @@ impl tr for ast::Def {
 // ______________________________________________________________________
 // Encoding and decoding of adjustment information
 
-impl tr for ty::AutoAdjustment {
-    fn tr(&self, xcx: @ExtendedDecodeContext) -> ty::AutoAdjustment {
-        match *self {
-            ty::AutoAddEnv(r, s) => ty::AutoAddEnv(r.tr(xcx), s),
-            ty::AutoDerefRef(ref adr) => {
-                ty::AutoDerefRef(ty::AutoDerefRef {
-                    autoderefs: adr.autoderefs,
-                    autoref: adr.autoref.map(|ar| ar.tr(xcx)),
-                })
+impl tr for ty::AutoDerefRef {
+    fn tr(&self, xcx: @ExtendedDecodeContext) -> ty::AutoDerefRef {
+        ty::AutoDerefRef {
+            autoderefs: self.autoderefs,
+            autoref: match self.autoref {
+                Some(ref autoref) => Some(autoref.tr(xcx)),
+                None => None
             }
         }
     }
@@ -786,6 +784,8 @@ trait ebml_writer_helpers {
     fn emit_tpbt(&mut self,
                  ecx: &e::EncodeContext,
                  tpbt: ty::ty_param_bounds_and_ty);
+    fn emit_substs(&mut self, ecx: &e::EncodeContext, substs: &ty::substs);
+    fn emit_auto_adjustment(&mut self, ecx: &e::EncodeContext, adj: &ty::AutoAdjustment);
 }
 
 impl<'a> ebml_writer_helpers for writer::Encoder<'a> {
@@ -833,6 +833,40 @@ impl<'a> ebml_writer_helpers for writer::Encoder<'a> {
             })
         })
     }
+
+    fn emit_substs(&mut self, ecx: &e::EncodeContext, substs: &ty::substs) {
+        self.emit_opaque(|this| tyencode::enc_substs(this.writer, ecx.ty_str_ctxt(), substs))
+    }
+
+    fn emit_auto_adjustment(&mut self, ecx: &e::EncodeContext, adj: &ty::AutoAdjustment) {
+        self.emit_enum("AutoAdjustment", |this| {
+            match *adj {
+                ty::AutoAddEnv(region, sigil) => {
+                    this.emit_enum_variant("AutoAddEnv", 0, 2, |this| {
+                        this.emit_enum_variant_arg(0, |this| region.encode(this));
+                        this.emit_enum_variant_arg(1, |this| sigil.encode(this));
+                    });
+                }
+
+                ty::AutoDerefRef(ref auto_deref_ref) => {
+                    this.emit_enum_variant("AutoDerefRef", 1, 1, |this| {
+                        this.emit_enum_variant_arg(0, |this| auto_deref_ref.encode(this));
+                    });
+                }
+
+                ty::AutoObject(sigil, region, m, b, def_id, ref substs) => {
+                    this.emit_enum_variant("AutoObject", 2, 6, |this| {
+                        this.emit_enum_variant_arg(0, |this| sigil.encode(this));
+                        this.emit_enum_variant_arg(1, |this| region.encode(this));
+                        this.emit_enum_variant_arg(2, |this| m.encode(this));
+                        this.emit_enum_variant_arg(3, |this| b.encode(this));
+                        this.emit_enum_variant_arg(4, |this| def_id.encode(this));
+                        this.emit_enum_variant_arg(5, |this| this.emit_substs(ecx, substs));
+                    });
+                }
+            }
+        });
+    }
 }
 
 trait write_tag_and_id {
@@ -1023,7 +1057,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
             ebml_w.tag(c::tag_table_adjustments, |ebml_w| {
                 ebml_w.id(id);
                 ebml_w.tag(c::tag_table_val, |ebml_w| {
-                    (**adj).encode(ebml_w)
+                    ebml_w.emit_auto_adjustment(ecx, **adj);
                 })
             })
         }
@@ -1064,6 +1098,8 @@ trait ebml_decoder_decoder_helpers {
                            -> ty::TypeParameterDef;
     fn read_ty_param_bounds_and_ty(&mut self, xcx: @ExtendedDecodeContext)
                                 -> ty::ty_param_bounds_and_ty;
+    fn read_substs(&mut self, xcx: @ExtendedDecodeContext) -> ty::substs;
+    fn read_auto_adjustment(&mut self, xcx: @ExtendedDecodeContext) -> ty::AutoAdjustment;
     fn convert_def_id(&mut self,
                       xcx: @ExtendedDecodeContext,
                       source: DefIdSource,
@@ -1172,6 +1208,61 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> {
         })
     }
 
+    fn read_substs(&mut self, xcx: @ExtendedDecodeContext) -> ty::substs {
+        self.read_opaque(|this, doc| {
+            tydecode::parse_substs_data(doc.data,
+                                        xcx.dcx.cdata.cnum,
+                                        doc.start,
+                                        xcx.dcx.tcx,
+                                        |s, a| this.convert_def_id(xcx, s, a))
+        })
+    }
+
+    fn read_auto_adjustment(&mut self, xcx: @ExtendedDecodeContext) -> ty::AutoAdjustment {
+        self.read_enum("AutoAdjustment", |this| {
+            let variants = ["AutoAddEnv", "AutoDerefRef", "AutoObject"];
+            this.read_enum_variant(variants, |this, i| {
+                match i {
+                    0 => {
+                        let region: ty::Region =
+                            this.read_enum_variant_arg(0, |this| Decodable::decode(this));
+                        let sigil: ast::Sigil =
+                            this.read_enum_variant_arg(1, |this| Decodable::decode(this));
+
+                        ty:: AutoAddEnv(region.tr(xcx), sigil)
+                    }
+                    1 => {
+                        let auto_deref_ref: ty::AutoDerefRef =
+                            this.read_enum_variant_arg(0, |this| Decodable::decode(this));
+
+                        ty::AutoDerefRef(auto_deref_ref.tr(xcx))
+                    }
+                    2 => {
+                        let sigil: ast::Sigil =
+                            this.read_enum_variant_arg(0, |this| Decodable::decode(this));
+                        let region: Option<ty::Region> =
+                            this.read_enum_variant_arg(1, |this| Decodable::decode(this));
+                        let m: ast::Mutability =
+                            this.read_enum_variant_arg(2, |this| Decodable::decode(this));
+                        let b: ty::BuiltinBounds =
+                            this.read_enum_variant_arg(3, |this| Decodable::decode(this));
+                        let def_id: ast::DefId =
+                            this.read_enum_variant_arg(4, |this| Decodable::decode(this));
+                        let substs = this.read_enum_variant_arg(5, |this| this.read_substs(xcx));
+
+                        let region = match region {
+                            Some(r) => Some(r.tr(xcx)),
+                            None => None
+                        };
+
+                        ty::AutoObject(sigil, region, m, b, def_id.tr(xcx), substs)
+                    }
+                    _ => fail!("bad enum variant for ty::AutoAdjustment")
+                }
+            })
+        })
+    }
+
     fn convert_def_id(&mut self,
                       xcx: @ExtendedDecodeContext,
                       source: tydecode::DefIdSource,
@@ -1289,8 +1380,7 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
                         vtable_map.get().insert(id, vtable_res);
                     }
                     c::tag_table_adjustments => {
-                        let adj: @ty::AutoAdjustment = @Decodable::decode(val_dsr);
-                        adj.tr(xcx);
+                        let adj: @ty::AutoAdjustment = @val_dsr.read_auto_adjustment(xcx);
                         let mut adjustments = dcx.tcx
                                                  .adjustments
                                                  .borrow_mut();

branches/dist-snap/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -419,6 +419,10 @@ impl<'a> GatherLoanCtxt<'a> {
                     ty::AutoUnsafe(_) => {}
                 }
             }
+
+            ty::AutoObject(..) => {
+                // XXX: Handle @Trait to &Trait casts here?
+            }
         }
     }