---

yaml
---
r: 96764
b: refs/heads/dist-snap
c: 8b5a317
h: refs/heads/master
v: v3

Author: emberian

[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: d5798b3902c4af50bf0f24e1c4bbf5e4a4dcc6ca
+refs/heads/dist-snap: 8b5a317d48eb26c3af875a409e4a16587aec7544
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -790,7 +790,7 @@ extern mod extra; // equivalent to: extern mod extra = "extra";
 
 extern mod rustextra = "extra"; // linking to 'extra' under another name
 
-extern mod foo = "some/where/rust-foo#foo:1.0"; // a full package ID for rustpkg
+extern mod foo = "some/where/foo#1.0"; // a full package ID for rustpkg
 ~~~~
 
 ##### Use declarations

branches/dist-snap/src/librustc/middle/typeck/astconv.rs

@@ -282,12 +282,6 @@ pub static NO_TPS: uint = 2;
 pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
     this: &AC, rscope: &RS, ast_ty: &ast::Ty) -> ty::t {
 
-    fn ast_ty_to_mt<AC:AstConv, RS:RegionScope>(
-        this: &AC, rscope: &RS, ty: &ast::Ty) -> ty::mt {
-
-        ty::mt {ty: ast_ty_to_ty(this, rscope, ty), mutbl: ast::MutImmutable}
-    }
-
     fn ast_mt_to_mt<AC:AstConv, RS:RegionScope>(
         this: &AC, rscope: &RS, mt: &ast::mt) -> ty::mt {
 
@@ -309,8 +303,8 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
         debug!("mk_pointer(vst={:?})", vst);
 
         match a_seq_ty.ty.node {
-            ast::ty_vec(ty) => {
-                let mut mt = ast_ty_to_mt(this, rscope, ty);
+            ast::ty_vec(ref mt) => {
+                let mut mt = ast_mt_to_mt(this, rscope, mt);
                 if a_seq_ty.mutbl == ast::MutMutable {
                     mt = ty::mt { ty: mt.ty, mutbl: a_seq_ty.mutbl };
                 }
@@ -400,15 +394,14 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
         mk_pointer(this, rscope, mt, ty::vstore_box,
                    |tmt| ty::mk_box(tcx, tmt))
       }
-      ast::ty_uniq(ty) => {
-        let mt = ast::mt { ty: ty, mutbl: ast::MutImmutable };
-        mk_pointer(this, rscope, &mt, ty::vstore_uniq,
+      ast::ty_uniq(ref mt) => {
+        mk_pointer(this, rscope, mt, ty::vstore_uniq,
                    |tmt| ty::mk_uniq(tcx, tmt))
       }
-      ast::ty_vec(ty) => {
+      ast::ty_vec(ref mt) => {
         tcx.sess.span_err(ast_ty.span, "bare `[]` is not a type");
         // return /something/ so they can at least get more errors
-        ty::mk_evec(tcx, ast_ty_to_mt(this, rscope, ty), ty::vstore_uniq)
+        ty::mk_evec(tcx, ast_mt_to_mt(this, rscope, mt), ty::vstore_uniq)
       }
       ast::ty_ptr(ref mt) => {
         ty::mk_ptr(tcx, ast_mt_to_mt(this, rscope, mt))
@@ -539,15 +532,15 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
           }
         }
       }
-      ast::ty_fixed_length_vec(ty, e) => {
+      ast::ty_fixed_length_vec(ref a_mt, e) => {
         match const_eval::eval_const_expr_partial(&tcx, e) {
           Ok(ref r) => {
             match *r {
               const_eval::const_int(i) =>
-                ty::mk_evec(tcx, ast_ty_to_mt(this, rscope, ty),
+                ty::mk_evec(tcx, ast_mt_to_mt(this, rscope, a_mt),
                             ty::vstore_fixed(i as uint)),
               const_eval::const_uint(i) =>
-                ty::mk_evec(tcx, ast_ty_to_mt(this, rscope, ty),
+                ty::mk_evec(tcx, ast_mt_to_mt(this, rscope, a_mt),
                             ty::vstore_fixed(i as uint)),
               _ => {
                 tcx.sess.span_fatal(

branches/dist-snap/src/librustdoc/clean.rs

@@ -621,10 +621,10 @@ impl Clean<Type> for ast::Ty {
                 BorrowedRef {lifetime: l.clean(), mutability: m.mutbl.clean(),
                              type_: ~m.ty.clean()},
             ty_box(ref m) => Managed(m.mutbl.clean(), ~m.ty.clean()),
-            ty_uniq(ty) => Unique(~ty.clean()),
-            ty_vec(ty) => Vector(~ty.clean()),
-            ty_fixed_length_vec(ty, ref e) => FixedVector(~ty.clean(),
-                                                          e.span.to_src()),
+            ty_uniq(ref m) => Unique(~m.ty.clean()),
+            ty_vec(ref m) => Vector(~m.ty.clean()),
+            ty_fixed_length_vec(ref m, ref e) => FixedVector(~m.ty.clean(),
+                                                             e.span.to_src()),
             ty_tup(ref tys) => Tuple(tys.iter().map(|x| x.clean()).collect()),
             ty_path(ref p, ref tpbs, id) =>
                 resolve_type(p.clean(), tpbs.clean(), id),

branches/dist-snap/src/librustdoc/html/render.rs

@@ -648,9 +648,13 @@ impl Context {
         self.root_path.push_str("../");
         self.current.push(s);
 
+        info!("Recursing into {}", self.dst.display());
+
         mkdir(&self.dst);
         let ret = f(self);
 
+        info!("Recursed; leaving {}", self.dst.display());
+
         // Go back to where we were at
         self.dst = prev;
         let len = self.root_path.len();
@@ -674,23 +678,18 @@ impl Context {
         // using a rwarc makes this parallelizable in the future
         local_data::set(cache_key, Arc::new(cache));
 
-        let mut work = ~[item];
-        while work.len() > 0 {
-            let item = work.pop();
-            self.item(item, |_cx, item| {
-                work.push(item);
-            })
-        }
+        self.item(item);
     }
 
     /// Non-parellelized version of rendering an item. This will take the input
     /// item, render its contents, and then invoke the specified closure with
     /// all sub-items which need to be rendered.
     ///
     /// The rendering driver uses this closure to queue up more work.
-    fn item(&mut self, item: clean::Item, f: |&mut Context, clean::Item|) {
+    fn item(&mut self, item: clean::Item) {
         fn render(w: io::File, cx: &mut Context, it: &clean::Item,
                   pushname: bool) {
+            info!("Rendering an item to {}", w.path().display());
             // A little unfortunate that this is done like this, but it sure
             // does make formatting *a lot* nicer.
             local_data::set(current_location_key, cx.current.clone());
@@ -734,7 +733,7 @@ impl Context {
                     };
                     this.sidebar = build_sidebar(&m);
                     for item in m.items.move_iter() {
-                        f(this, item);
+                        this.item(item);
                     }
                 })
             }

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

@@ -2673,9 +2673,11 @@ impl<T> DoubleEndedIterator<T> for MoveIterator<T> {
 #[unsafe_destructor]
 impl<T> Drop for MoveIterator<T> {
     fn drop(&mut self) {
-        // destroy the remaining elements
-        for _x in *self {}
         unsafe {
+            // destroy the remaining elements
+            for x in self.iter {
+                ptr::read_ptr(x);
+            }
             if owns_managed::<T>() {
                 local_free(self.allocation as *u8 as *c_char)
             } else {

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

@@ -875,9 +875,9 @@ pub enum ty_ {
     ty_nil,
     ty_bot, /* bottom type */
     ty_box(mt),
-    ty_uniq(P<Ty>),
-    ty_vec(P<Ty>),
-    ty_fixed_length_vec(P<Ty>, @Expr),
+    ty_uniq(mt),
+    ty_vec(mt),
+    ty_fixed_length_vec(mt, @Expr),
     ty_ptr(mt),
     ty_rptr(Option<Lifetime>, mt),
     ty_closure(@TyClosure),

branches/dist-snap/src/libsyntax/ext/build.rs

@@ -312,7 +312,7 @@ impl AstBuilder for @ExtCtxt {
                 ast::ty_rptr(lifetime, self.ty_mt(ty, mutbl)))
     }
     fn ty_uniq(&self, span: Span, ty: P<ast::Ty>) -> P<ast::Ty> {
-        self.ty(span, ast::ty_uniq(ty))
+        self.ty(span, ast::ty_uniq(self.ty_mt(ty, ast::MutImmutable)))
     }
     fn ty_box(&self, span: Span,
                  ty: P<ast::Ty>, mutbl: ast::Mutability) -> P<ast::Ty> {

branches/dist-snap/src/libsyntax/ext/format.rs

@@ -593,7 +593,7 @@ impl Context {
                 ~[]
             ), None);
         let ty = ast::ty_fixed_length_vec(
-            piece_ty,
+            self.ecx.ty_mt(piece_ty, ast::MutImmutable),
             self.ecx.expr_uint(self.fmtsp, self.pieces.len())
         );
         let ty = self.ecx.ty(self.fmtsp, ty);

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

@@ -241,8 +241,8 @@ pub trait ast_fold {
         let node = match t.node {
             ty_nil | ty_bot | ty_infer => t.node.clone(),
             ty_box(ref mt) => ty_box(fold_mt(mt, self)),
-            ty_uniq(ty) => ty_uniq(self.fold_ty(ty)),
-            ty_vec(ty) => ty_vec(self.fold_ty(ty)),
+            ty_uniq(ref mt) => ty_uniq(fold_mt(mt, self)),
+            ty_vec(ref mt) => ty_vec(fold_mt(mt, self)),
             ty_ptr(ref mt) => ty_ptr(fold_mt(mt, self)),
             ty_rptr(ref region, ref mt) => {
                 ty_rptr(fold_opt_lifetime(region, self), fold_mt(mt, self))
@@ -272,8 +272,8 @@ pub trait ast_fold {
                         fold_opt_bounds(bounds, self),
                         self.new_id(id))
             }
-            ty_fixed_length_vec(ty, e) => {
-                ty_fixed_length_vec(self.fold_ty(ty), self.fold_expr(e))
+            ty_fixed_length_vec(ref mt, e) => {
+                ty_fixed_length_vec(fold_mt(mt, self), self.fold_expr(e))
             }
             ty_typeof(expr) => ty_typeof(self.fold_expr(expr)),
         };

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

@@ -1213,25 +1213,25 @@ impl Parser {
         } else if *self.token == token::AT {
             // MANAGED POINTER
             self.bump();
-            self.parse_box_or_uniq_pointee(ManagedSigil)
+            self.parse_box_or_uniq_pointee(ManagedSigil, ty_box)
         } else if *self.token == token::TILDE {
             // OWNED POINTER
             self.bump();
-            self.parse_box_or_uniq_pointee(OwnedSigil)
+            self.parse_box_or_uniq_pointee(OwnedSigil, ty_uniq)
         } else if *self.token == token::BINOP(token::STAR) {
             // STAR POINTER (bare pointer?)
             self.bump();
             ty_ptr(self.parse_mt())
         } else if *self.token == token::LBRACKET {
             // VECTOR
             self.expect(&token::LBRACKET);
-            let t = self.parse_ty(false);
+            let mt = mt { ty: self.parse_ty(false), mutbl: MutImmutable };
 
             // Parse the `, ..e` in `[ int, ..e ]`
             // where `e` is a const expression
             let t = match self.maybe_parse_fixed_vstore() {
-                None => ty_vec(t),
-                Some(suffix) => ty_fixed_length_vec(t, suffix)
+                None => ty_vec(mt),
+                Some(suffix) => ty_fixed_length_vec(mt, suffix)
             };
             self.expect(&token::RBRACKET);
             t
@@ -1284,7 +1284,8 @@ impl Parser {
 
     // parse the type following a @ or a ~
     pub fn parse_box_or_uniq_pointee(&self,
-                                     sigil: ast::Sigil)
+                                     sigil: ast::Sigil,
+                                     ctor: |v: mt| -> ty_)
                                      -> ty_ {
         // ~'foo fn() or ~fn() are parsed directly as obsolete fn types:
         match *self.token {
@@ -1308,9 +1309,9 @@ impl Parser {
         // rather than boxed ptrs.  But the special casing of str/vec is not
         // reflected in the AST type.
         if sigil == OwnedSigil {
-            ty_uniq(self.parse_ty(false))
+            ctor(mt { ty: self.parse_ty(false), mutbl: MutImmutable })
         } else {
-            ty_box(self.parse_mt())
+            ctor(self.parse_mt())
         }
     }