---

yaml
---
r: 140652
b: refs/heads/try2
c: dc2ca9d
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: f547a671dcc64530f0cf07f39698d63174f37733
+refs/heads/try2: dc2ca9d8830a7a34242aa7722f545bc242813af3
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/cast.rs

@@ -24,20 +24,6 @@ pub mod rusti {
 }
 
 /// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(not(stage0))]
-pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = unstable::intrinsics::uninit();
-    {
-        let dest_ptr: *mut u8 = rusti::transmute(&mut dest);
-        let src_ptr: *u8 = rusti::transmute(src);
-        unstable::intrinsics::memmove64(dest_ptr,
-                                        src_ptr,
-                                        sys::size_of::<U>() as u64);
-    }
-    dest
-}
-
-#[cfg(stage0)]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = unstable::intrinsics::init();
     {

branches/try2/src/libcore/core.rc

@@ -60,6 +60,7 @@ they contained the following prologue:
 // Don't link to core. We are core.
 #[no_core];
 
+#[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 #[allow(deprecated_mutable_fields)];
 

branches/try2/src/libcore/unstable/intrinsics.rs

@@ -44,9 +44,6 @@ pub extern "rust-intrinsic" {
 
     pub fn init<T>() -> T;
 
-    #[cfg(not(stage0))]
-    pub unsafe fn uninit<T>() -> T;
-
     pub fn forget<T>(_: T) -> ();
 
     pub fn needs_drop<T>() -> bool;

branches/try2/src/libcore/vec.rs

@@ -584,29 +584,14 @@ pub fn consume_reverse<T>(mut v: ~[T], f: &fn(uint, v: T)) {
 }
 
 /// Remove the last element from a vector and return it
-#[cfg(not(stage0))]
-pub fn pop<T>(v: &mut ~[T]) -> T {
-    let ln = v.len();
-    if ln == 0 {
-        fail!(~"sorry, cannot vec::pop an empty vector")
-    }
-    let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
-    unsafe {
-        let mut val = intrinsics::uninit();
-        val <-> *valptr;
-        raw::set_len(v, ln - 1u);
-        val
-    }
-}
-
-#[cfg(stage0)]
 pub fn pop<T>(v: &mut ~[T]) -> T {
     let ln = v.len();
     if ln == 0 {
         fail!(~"sorry, cannot vec::pop an empty vector")
     }
     let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
     unsafe {
+        // FIXME #4204: Should be uninit() - we don't need this zeroed
         let mut val = intrinsics::init();
         val <-> *valptr;
         raw::set_len(v, ln - 1u);
@@ -675,30 +660,13 @@ pub fn push_all<T:Copy>(v: &mut ~[T], rhs: &const [T]) {
 }
 
 #[inline(always)]
-#[cfg(not(stage0))]
-pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
-    let new_len = v.len() + rhs.len();
-    reserve(&mut *v, new_len);
-    unsafe {
-        do as_mut_buf(rhs) |p, len| {
-            for uint::range(0, len) |i| {
-                let mut x = intrinsics::uninit();
-                x <-> *ptr::mut_offset(p, i);
-                push(&mut *v, x);
-            }
-        }
-        raw::set_len(&mut rhs, 0);
-    }
-}
-
-#[inline(always)]
-#[cfg(stage0)]
 pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
     let new_len = v.len() + rhs.len();
     reserve(&mut *v, new_len);
     unsafe {
         do as_mut_buf(rhs) |p, len| {
             for uint::range(0, len) |i| {
+                // FIXME #4204 Should be uninit() - don't need to zero
                 let mut x = intrinsics::init();
                 x <-> *ptr::mut_offset(p, i);
                 push(&mut *v, x);
@@ -709,29 +677,13 @@ pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
 }
 
 /// Shorten a vector, dropping excess elements.
-#[cfg(not(stage0))]
-pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
-    do as_mut_buf(*v) |p, oldlen| {
-        assert!(newlen <= oldlen);
-        unsafe {
-            // This loop is optimized out for non-drop types.
-            for uint::range(newlen, oldlen) |i| {
-                let mut dropped = intrinsics::uninit();
-                dropped <-> *ptr::mut_offset(p, i);
-            }
-        }
-    }
-    unsafe { raw::set_len(&mut *v, newlen); }
-}
-
-/// Shorten a vector, dropping excess elements.
-#[cfg(stage0)]
 pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
     do as_mut_buf(*v) |p, oldlen| {
         assert!(newlen <= oldlen);
         unsafe {
             // This loop is optimized out for non-drop types.
             for uint::range(newlen, oldlen) |i| {
+                // FIXME #4204 Should be uninit() - don't need to zero
                 let mut dropped = intrinsics::init();
                 dropped <-> *ptr::mut_offset(p, i);
             }
@@ -744,45 +696,6 @@ pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
  * Remove consecutive repeated elements from a vector; if the vector is
  * sorted, this removes all duplicates.
  */
-#[cfg(not(stage0))]
-pub fn dedup<T:Eq>(v: &mut ~[T]) {
-    unsafe {
-        if v.len() < 1 { return; }
-        let mut last_written = 0, next_to_read = 1;
-        do as_const_buf(*v) |p, ln| {
-            // We have a mutable reference to v, so we can make arbitrary
-            // changes. (cf. push and pop)
-            let p = p as *mut T;
-            // last_written < next_to_read <= ln
-            while next_to_read < ln {
-                // last_written < next_to_read < ln
-                if *ptr::mut_offset(p, next_to_read) ==
-                    *ptr::mut_offset(p, last_written) {
-                    let mut dropped = intrinsics::uninit();
-                    dropped <-> *ptr::mut_offset(p, next_to_read);
-                } else {
-                    last_written += 1;
-                    // last_written <= next_to_read < ln
-                    if next_to_read != last_written {
-                        *ptr::mut_offset(p, last_written) <->
-                            *ptr::mut_offset(p, next_to_read);
-                    }
-                }
-                // last_written <= next_to_read < ln
-                next_to_read += 1;
-                // last_written < next_to_read <= ln
-            }
-        }
-        // last_written < next_to_read == ln
-        raw::set_len(v, last_written + 1);
-    }
-}
-
-/**
- * Remove consecutive repeated elements from a vector; if the vector is
- * sorted, this removes all duplicates.
- */
-#[cfg(stage0)]
 pub fn dedup<T:Eq>(v: &mut ~[T]) {
     unsafe {
         if v.len() < 1 { return; }
@@ -796,6 +709,8 @@ pub fn dedup<T:Eq>(v: &mut ~[T]) {
                 // last_written < next_to_read < ln
                 if *ptr::mut_offset(p, next_to_read) ==
                     *ptr::mut_offset(p, last_written) {
+                    // FIXME #4204 Should be uninit() - don't need to
+                    // zero
                     let mut dropped = intrinsics::init();
                     dropped <-> *ptr::mut_offset(p, next_to_read);
                 } else {

branches/try2/src/librustc/driver/session.rs

@@ -237,7 +237,6 @@ pub impl Session_ {
                  msg: &str) {
         let level = lint::get_lint_settings_level(
             self.lint_settings, lint_mode, expr_id, item_id);
-        let msg = fmt!("%s [-W %s]", msg, lint::get_lint_name(lint_mode));
         self.span_lint_level(level, span, msg);
     }
     fn next_node_id(@self) -> ast::node_id {

branches/try2/src/librustc/metadata/tydecode.rs

@@ -555,18 +555,34 @@ fn parse_type_param_def(st: @mut PState, conv: conv_did) -> ty::TypeParameterDef
                           bounds: parse_bounds(st, conv)}
 }
 
-fn parse_bounds(st: @mut PState, conv: conv_did) -> @~[ty::param_bound] {
-    let mut bounds = ~[];
+fn parse_bounds(st: @mut PState, conv: conv_did) -> @ty::ParamBounds {
+    let mut param_bounds = ty::ParamBounds {
+        builtin_bounds: ty::EmptyBuiltinBounds(),
+        trait_bounds: ~[]
+    };
     loop {
-        bounds.push(match next(st) {
-          'S' => ty::bound_owned,
-          'C' => ty::bound_copy,
-          'K' => ty::bound_const,
-          'O' => ty::bound_durable,
-          'I' => ty::bound_trait(@parse_trait_ref(st, conv)),
-          '.' => break,
-          _ => fail!(~"parse_bounds: bad bounds")
-        });
+        match next(st) {
+            'S' => {
+                param_bounds.builtin_bounds.add(ty::BoundOwned);
+            }
+            'C' => {
+                param_bounds.builtin_bounds.add(ty::BoundCopy);
+            }
+            'K' => {
+                param_bounds.builtin_bounds.add(ty::BoundConst);
+            }
+            'O' => {
+                param_bounds.builtin_bounds.add(ty::BoundStatic);
+            }
+            'I' => {
+                param_bounds.trait_bounds.push(@parse_trait_ref(st, conv));
+            }
+            '.' => {
+                return @param_bounds;
+            }
+            _ => {
+                fail!(~"parse_bounds: bad bounds")
+            }
+        }
     }
-    @bounds
 }

branches/try2/src/librustc/metadata/tyencode.rs

@@ -396,19 +396,21 @@ fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) {
     enc_ty(w, cx, fsig.output);
 }
 
-fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @~[ty::param_bound]) {
-    for (*bs).each |bound| {
-        match *bound {
-          ty::bound_owned => w.write_char('S'),
-          ty::bound_copy => w.write_char('C'),
-          ty::bound_const => w.write_char('K'),
-          ty::bound_durable => w.write_char('O'),
-          ty::bound_trait(tp) => {
-              w.write_char('I');
-              enc_trait_ref(w, cx, tp);
-          }
+fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @ty::ParamBounds) {
+    for bs.builtin_bounds.each |bound| {
+        match bound {
+            ty::BoundOwned => w.write_char('S'),
+            ty::BoundCopy => w.write_char('C'),
+            ty::BoundConst => w.write_char('K'),
+            ty::BoundStatic => w.write_char('O'),
         }
     }
+
+    for bs.trait_bounds.each |&tp| {
+        w.write_char('I');
+        enc_trait_ref(w, cx, tp);
+    }
+
     w.write_char('.');
 }
 

branches/try2/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -260,7 +260,7 @@ pub impl GatherLoanCtxt {
                                              r)
                     }
                     ty::AutoBorrowVec(r, m) | ty::AutoBorrowVecRef(r, m) => {
-                        let cmt_index = mcx.cat_index(expr, cmt, autoderefs+1);
+                        let cmt_index = mcx.cat_index(expr, cmt);
                         self.guarantee_valid(expr.id,
                                              expr.span,
                                              cmt_index,
@@ -574,7 +574,7 @@ pub impl GatherLoanCtxt {
                   let (slice_mutbl, slice_r) =
                       self.vec_slice_info(slice_pat, slice_ty);
                   let mcx = self.bccx.mc_ctxt();
-                  let cmt_index = mcx.cat_index(slice_pat, cmt, 0);
+                  let cmt_index = mcx.cat_index(slice_pat, cmt);
                   self.guarantee_valid(pat.id, pat.span,
                                        cmt_index, slice_mutbl, slice_r);
               }

branches/try2/src/librustc/middle/borrowck/mod.rs

@@ -184,16 +184,6 @@ pub type LoanMap = @mut HashMap<ast::node_id, @Loan>;
 //
 // Note that there is no entry with derefs:3---the type of that expression
 // is T, which is not a box.
-//
-// Note that implicit dereferences also occur with indexing of `@[]`,
-// `@str`, etc.  The same rules apply. So, for example, given a
-// variable `x` of type `@[@[...]]`, if I have an instance of the
-// expression `x[0]` which is then auto-slice'd, there would be two
-// potential entries in the root map, both with the id of the `x[0]`
-// expression. The entry with `derefs==0` refers to the deref of `x`
-// used as part of evaluating `x[0]`. The entry with `derefs==1`
-// refers to the deref of the `x[0]` that occurs as part of the
-// auto-slice.
 #[deriving(Eq, IterBytes)]
 pub struct root_map_key {
     id: ast::node_id,
@@ -615,7 +605,7 @@ pub impl BorrowckCtxt {
                 }
             }
 
-            LpExtend(lp_base, _, LpInterior(mc::interior_field(fld))) => {
+            LpExtend(lp_base, _, LpInterior(mc::interior_field(fld, _))) => {
                 self.append_loan_path_to_str_from_interior(lp_base, out);
                 str::push_char(out, '.');
                 str::push_str(out, *self.tcx.sess.intr().get(fld));

branches/try2/src/librustc/middle/kind.rs

@@ -14,6 +14,7 @@ use middle::pat_util;
 use middle::ty;
 use middle::typeck;
 use util::ppaux::{Repr, ty_to_str};
+use util::ppaux::UserString;
 
 use syntax::ast::*;
 use syntax::attr::attrs_contains_name;
@@ -338,46 +339,19 @@ pub fn check_bounds(cx: Context,
                     type_param_def: &ty::TypeParameterDef)
 {
     let kind = ty::type_contents(cx.tcx, ty);
-    let mut missing = ~[];
-    for type_param_def.bounds.each |bound| {
-        match *bound {
-            ty::bound_trait(_) => {
-                /* Not our job, checking in typeck */
-            }
-
-            ty::bound_copy => {
-                if !kind.is_copy(cx.tcx) {
-                    missing.push("Copy");
-                }
-            }
-
-            ty::bound_durable => {
-                if !kind.is_durable(cx.tcx) {
-                    missing.push("'static");
-                }
-            }
-
-            ty::bound_owned => {
-                if !kind.is_owned(cx.tcx) {
-                    missing.push("Owned");
-                }
-            }
-
-            ty::bound_const => {
-                if !kind.is_const(cx.tcx) {
-                    missing.push("Const");
-                }
-            }
+    let mut missing = ty::EmptyBuiltinBounds();
+    for type_param_def.bounds.builtin_bounds.each |bound| {
+        if !kind.meets_bound(cx.tcx, bound) {
+            missing.add(bound);
         }
     }
-
     if !missing.is_empty() {
         cx.tcx.sess.span_err(
             sp,
             fmt!("instantiating a type parameter with an incompatible type \
                   `%s`, which does not fulfill `%s`",
                  ty_to_str(cx.tcx, ty),
-                 str::connect_slices(missing, " ")));
+                 missing.user_string(cx.tcx)));
     }
 }
 
@@ -440,7 +414,7 @@ pub fn check_owned(cx: Context, ty: ty::t, sp: span) -> bool {
 
 // note: also used from middle::typeck::regionck!
 pub fn check_durable(tcx: ty::ctxt, ty: ty::t, sp: span) -> bool {
-    if !ty::type_is_durable(tcx, ty) {
+    if !ty::type_is_static(tcx, ty) {
         match ty::get(ty).sty {
           ty::ty_param(*) => {
             tcx.sess.span_err(sp, "value may contain borrowed \