---

yaml
---
r: 123661
b: refs/heads/try
c: 947942e
h: refs/heads/master
i:
  123659: f9d54c4
v: v3

Author: Jakub Wieczorek

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: da4e4e4e0a7778a85748aa4a303b13f603e96b4b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 8ddd286ea4ba4384a0dc9eae393ed515460a986e
-refs/heads/try: 6f46621b335d398f3c837750d31797014f63578b
+refs/heads/try: 947942e42c3856f4a673fe2e853e8c3f57e0993a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/etc/vim/syntax/rust.vim

@@ -65,7 +65,7 @@ syn keyword   rustTrait       Copy Send Sized Share
 syn keyword   rustTrait       Add Sub Mul Div Rem Neg Not
 syn keyword   rustTrait       BitAnd BitOr BitXor
 syn keyword   rustTrait       Drop Deref DerefMut
-syn keyword   rustTrait       Shl Shr Index IndexMut
+syn keyword   rustTrait       Shl Shr Index
 syn keyword   rustEnum        Option
 syn keyword   rustEnumVariant Some None
 syn keyword   rustEnum        Result

branches/try/src/libcollections/bitv.rs

@@ -16,36 +16,14 @@ use core::cmp;
 use core::default::Default;
 use core::fmt;
 use core::iter::Take;
+use core::ops;
 use core::slice;
 use core::uint;
 use std::hash;
 
 use {Collection, Mutable, Set, MutableSet};
 use vec::Vec;
 
-#[cfg(not(stage0))]
-use core::ops::Index;
-
-#[cfg(not(stage0))]
-static TRUE: bool = true;
-
-#[cfg(not(stage0))]
-static FALSE: bool = false;
-
-#[deriving(Clone)]
-struct SmallBitv {
-    /// only the lowest nbits of this value are used. the rest is undefined.
-    bits: uint
-}
-
-#[deriving(Clone)]
-struct BigBitv {
-    storage: Vec<uint>
-}
-
-#[deriving(Clone)]
-enum BitvVariant { Big(BigBitv), Small(SmallBitv) }
-
 /// The bitvector type
 ///
 /// # Example
@@ -80,18 +58,6 @@ pub struct Bitv {
     nbits: uint
 }
 
-#[cfg(not(stage0))]
-impl Index<uint,bool> for Bitv {
-    #[inline]
-    fn index<'a>(&'a self, i: &uint) -> &'a bool {
-        if self.get(*i) {
-            &TRUE
-        } else {
-            &FALSE
-        }
-    }
-}
-
 struct MaskWords<'a> {
     iter: slice::Items<'a, uint>,
     next_word: Option<&'a uint>,
@@ -302,7 +268,7 @@ impl Bitv {
             if offset >= bitv.nbits {
                 0
             } else {
-                bitv.get(offset) as u8 << (7 - bit)
+                bitv[offset] as u8 << (7 - bit)
             }
         }
 
@@ -320,13 +286,6 @@ impl Bitv {
         )
     }
 
-    /**
-     * Transform `self` into a `Vec<bool>` by turning each bit into a `bool`.
-     */
-    pub fn to_bools(&self) -> Vec<bool> {
-        Vec::from_fn(self.nbits, |i| self.get(i))
-    }
-
     /**
      * Compare a bitvector to a vector of `bool`.
      *
@@ -545,6 +504,13 @@ impl Clone for Bitv {
     }
 }
 
+impl ops::Index<uint,bool> for Bitv {
+    #[inline]
+    fn index(&self, i: &uint) -> bool {
+        self.get(*i)
+    }
+}
+
 impl fmt::Show for Bitv {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         for bit in self.iter() {
@@ -1403,9 +1369,9 @@ mod tests {
         b2.set(1, true);
         b2.set(2, true);
         assert!(b1.difference(&b2));
-        assert!(b1.get(0));
-        assert!(!b1.get(1));
-        assert!(!b1.get(2));
+        assert!(b1[0]);
+        assert!(!b1[1]);
+        assert!(!b1[2]);
     }
 
     #[test]
@@ -1417,9 +1383,9 @@ mod tests {
         b2.set(40, true);
         b2.set(80, true);
         assert!(b1.difference(&b2));
-        assert!(b1.get(0));
-        assert!(!b1.get(40));
-        assert!(!b1.get(80));
+        assert!(b1[0]);
+        assert!(!b1[40]);
+        assert!(!b1[80]);
     }
 
     #[test]

branches/try/src/libcollections/vec.rs

@@ -27,10 +27,6 @@ use {Collection, Mutable};
 use slice::{MutableOrdVector, MutableVectorAllocating, CloneableVector};
 use slice::{Items, MutItems};
 
-
-#[doc(hidden)]
-pub static PTR_MARKER: u8 = 0;
-
 /// An owned, growable vector.
 ///
 /// # Examples
@@ -75,11 +71,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     pub fn new() -> Vec<T> {
-        // We want ptr to never be NULL so instead we set it to some arbitrary
-        // non-null value which is fine since we never call deallocate on the ptr
-        // if cap is 0. The reason for this is because the pointer of a slice
-        // being NULL would break the null pointer optimization for enums.
-        Vec { len: 0, cap: 0, ptr: &PTR_MARKER as *const _ as *mut T }
+        Vec { len: 0, cap: 0, ptr: 0 as *mut T }
     }
 
     /// Constructs a new, empty `Vec` with the specified capacity.
@@ -96,7 +88,7 @@ impl<T> Vec<T> {
     #[inline]
     pub fn with_capacity(capacity: uint) -> Vec<T> {
         if mem::size_of::<T>() == 0 {
-            Vec { len: 0, cap: uint::MAX, ptr: &PTR_MARKER as *const _ as *mut T }
+            Vec { len: 0, cap: uint::MAX, ptr: 0 as *mut T }
         } else if capacity == 0 {
             Vec::new()
         } else {
@@ -1214,7 +1206,15 @@ impl<T> Vec<T> {
     /// would also make any pointers to it invalid.
     #[inline]
     pub fn as_ptr(&self) -> *const T {
-        self.ptr as *const T
+        // If we have a 0-sized vector, then the base pointer should not be NULL
+        // because an iterator over the slice will attempt to yield the base
+        // pointer as the first element in the vector, but this will end up
+        // being Some(NULL) which is optimized to None.
+        if mem::size_of::<T>() == 0 {
+            1 as *const T
+        } else {
+            self.ptr as *const T
+        }
     }
 
     /// Returns a mutable unsafe pointer to the vector's buffer.
@@ -1226,7 +1226,12 @@ impl<T> Vec<T> {
     /// would also make any pointers to it invalid.
     #[inline]
     pub fn as_mut_ptr(&mut self) -> *mut T {
-        self.ptr
+        // see above for the 0-size check
+        if mem::size_of::<T>() == 0 {
+            1 as *mut T
+        } else {
+            self.ptr
+        }
     }
 
     /// Retains only the elements specified by the predicate.

branches/try/src/libcore/ops.rs

@@ -613,7 +613,7 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
 /**
  *
  * The `Index` trait is used to specify the functionality of indexing operations
- * like `arr[idx]` when used in an immutable context.
+ * like `arr[idx]`.
  *
  * # Example
  *
@@ -624,9 +624,9 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
  * struct Foo;
  *
  * impl Index<Foo, Foo> for Foo {
- *     fn index<'a>(&'a self, _rhs: &Foo) -> &'a Foo {
+ *     fn index(&self, _rhs: &Foo) -> Foo {
  *         println!("Indexing!");
- *         self
+ *         *self
  *     }
  * }
  *
@@ -636,42 +636,9 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
  * ```
  */
 #[lang="index"]
-#[cfg(not(stage0))]
 pub trait Index<Index,Result> {
     /// The method for the indexing (`Foo[Bar]`) operation
-    fn index<'a>(&'a self, index: &Index) -> &'a Result;
-}
-
-/**
- *
- * The `IndexMut` trait is used to specify the functionality of indexing
- * operations like `arr[idx]`, when used in a mutable context.
- *
- * # Example
- *
- * A trivial implementation of `IndexMut`. When `Foo[Foo]` happens, it ends up
- * calling `index`, and therefore, `main` prints `Indexing!`.
- *
- * ```
- * struct Foo;
- *
- * impl IndexMut<Foo, Foo> for Foo {
- *     fn index_mut<'a>(&'a mut self, _rhs: &Foo) -> &'a mut Foo {
- *         println!("Indexing!");
- *         self
- *     }
- * }
- *
- * fn main() {
- *     &mut Foo[Foo];
- * }
- * ```
- */
-#[lang="index_mut"]
-#[cfg(not(stage0))]
-pub trait IndexMut<Index,Result> {
-    /// The method for the indexing (`Foo[Bar]`) operation
-    fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Result;
+    fn index(&self, index: &Index) -> Result;
 }
 
 /**

branches/try/src/libcore/prelude.rs

@@ -33,9 +33,7 @@ pub use kinds::{Copy, Send, Sized, Share};
 pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Drop, Deref, DerefMut};
-pub use ops::{Shl, Shr};
-#[cfg(not(stage0))]
-pub use ops::{Index, IndexMut};
+pub use ops::{Shl, Shr, Index};
 pub use option::{Option, Some, None};
 pub use result::{Result, Ok, Err};
 

branches/try/src/libcore/slice.rs

@@ -884,20 +884,17 @@ macro_rules! iterator {
                     if self.ptr == self.end {
                         None
                     } else {
-                        if mem::size_of::<T>() == 0 {
+                        let old = self.ptr;
+                        self.ptr = if mem::size_of::<T>() == 0 {
                             // purposefully don't use 'ptr.offset' because for
                             // vectors with 0-size elements this would return the
                             // same pointer.
-                            self.ptr = transmute(self.ptr as uint + 1);
-
-                            // Use a non-null pointer value
-                            Some(transmute(1u))
+                            transmute(self.ptr as uint + 1)
                         } else {
-                            let old = self.ptr;
-                            self.ptr = self.ptr.offset(1);
+                            self.ptr.offset(1)
+                        };
 
-                            Some(transmute(old))
-                        }
+                        Some(transmute(old))
                     }
                 }
             }
@@ -919,17 +916,13 @@ macro_rules! iterator {
                     if self.end == self.ptr {
                         None
                     } else {
-                        if mem::size_of::<T>() == 0 {
+                        self.end = if mem::size_of::<T>() == 0 {
                             // See above for why 'ptr.offset' isn't used
-                            self.end = transmute(self.end as uint - 1);
-
-                            // Use a non-null pointer value
-                            Some(transmute(1u))
+                            transmute(self.end as uint - 1)
                         } else {
-                            self.end = self.end.offset(-1);
-
-                            Some(transmute(self.end))
-                        }
+                            self.end.offset(-1)
+                        };
+                        Some(transmute(self.end))
                     }
                 }
             }
@@ -963,12 +956,7 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
     fn idx(&mut self, index: uint) -> Option<&'a T> {
         unsafe {
             if index < self.indexable() {
-                if mem::size_of::<T>() == 0 {
-                    // Use a non-null pointer value
-                    Some(transmute(1u))
-                } else {
-                    Some(transmute(self.ptr.offset(index as int)))
-                }
+                transmute(self.ptr.offset(index as int))
             } else {
                 None
             }

branches/try/src/librustc/metadata/cstore.rs

@@ -196,7 +196,7 @@ impl CStore {
     }
 
     pub fn add_used_link_args(&self, args: &str) {
-        for s in args.split(' ').filter(|s| !s.is_empty()) {
+        for s in args.split(' ') {
             self.used_link_args.borrow_mut().push(s.to_string());
         }
     }

branches/try/src/librustc/middle/check_match.rs

@@ -283,13 +283,15 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
             };
             if is_structure {
                 let fields = ty::lookup_struct_fields(cx.tcx, vid);
-                let field_pats = fields.move_iter()
+                let field_pats: Vec<FieldPat> = fields.move_iter()
                     .zip(pats.iter())
+                    .filter(|&(_, pat)| pat.node != PatWild)
                     .map(|(field, pat)| FieldPat {
                         ident: Ident::new(field.name),
                         pat: pat.clone()
                     }).collect();
-                PatStruct(def_to_path(cx.tcx, vid), field_pats, false)
+                let has_more_fields = field_pats.len() < pats.len();
+                PatStruct(def_to_path(cx.tcx, vid), field_pats, has_more_fields)
             } else {
                 PatEnum(def_to_path(cx.tcx, vid), Some(pats))
             }
@@ -671,17 +673,8 @@ pub fn specialize(cx: &MatchCheckCtxt, r: &[Gc<Pat>],
                 } else {
                     None
                 },
-                _ => {
-                    // Assume this is a struct.
-                    match ty::ty_to_def_id(node_id_to_type(cx.tcx, pat_id)) {
-                        None => {
-                            cx.tcx.sess.span_bug(pat_span,
-                                                 "struct pattern wasn't of a \
-                                                  type with a def ID?!")
-                        }
-                        Some(def_id) => Some(def_id),
-                    }
-                }
+                DefStruct(struct_id) => Some(struct_id),
+                _ => None
             };
             class_id.map(|variant_id| {
                 let struct_fields = ty::lookup_struct_fields(cx.tcx, variant_id);