---

yaml
---
r: 123663
b: refs/heads/try
c: 8121c39
h: refs/heads/master
i:
  123661: 1d69674
  123659: f9d54c4
  123655: a8a558a
  123647: 92b8802
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: da4e4e4e0a7778a85748aa4a303b13f603e96b4b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 8ddd286ea4ba4384a0dc9eae393ed515460a986e
-refs/heads/try: 6959931498820b2b784168164b53a79dceafc4da
+refs/heads/try: 8121c39a3ef6225c8500cdd9f4f14e6e4cc1456f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/mk/tests.mk

@@ -171,7 +171,7 @@ endif
 # Main test targets
 ######################################################################
 
-check: cleantmptestlogs cleantestlibs tidy check-notidy
+check: cleantmptestlogs cleantestlibs check-notidy tidy
 
 check-notidy: cleantmptestlogs cleantestlibs all check-stage2
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log

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/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/middle/check_match.rs

@@ -283,15 +283,13 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
             };
             if is_structure {
                 let fields = ty::lookup_struct_fields(cx.tcx, vid);
-                let field_pats: Vec<FieldPat> = fields.move_iter()
+                let field_pats = fields.move_iter()
                     .zip(pats.iter())
-                    .filter(|&(_, pat)| pat.node != PatWild)
                     .map(|(field, pat)| FieldPat {
                         ident: Ident::new(field.name),
                         pat: pat.clone()
                     }).collect();
-                let has_more_fields = field_pats.len() < pats.len();
-                PatStruct(def_to_path(cx.tcx, vid), field_pats, has_more_fields)
+                PatStruct(def_to_path(cx.tcx, vid), field_pats, false)
             } else {
                 PatEnum(def_to_path(cx.tcx, vid), Some(pats))
             }

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

@@ -307,7 +307,7 @@ enum BareIdentifierPatternResolution {
 #[deriving(PartialEq)]
 enum DuplicateCheckingMode {
     ForbidDuplicateModules,
-    ForbidDuplicateTypesAndModules,
+    ForbidDuplicateTypes,
     ForbidDuplicateValues,
     ForbidDuplicateTypesAndValues,
     OverwriteDuplicates
@@ -792,9 +792,10 @@ impl PrimitiveTypeTable {
 
 fn namespace_error_to_str(ns: NamespaceError) -> &'static str {
     match ns {
-        NoError                 => "",
-        ModuleError | TypeError => "type or module",
-        ValueError              => "value",
+        NoError     => "",
+        ModuleError => "module",
+        TypeError   => "type",
+        ValueError  => "value",
     }
 }
 
@@ -1032,12 +1033,9 @@ impl<'a> Resolver<'a> {
                         }
                         Some(TypeNS)
                     }
-                    ForbidDuplicateTypesAndModules => {
+                    ForbidDuplicateTypes => {
                         match child.def_for_namespace(TypeNS) {
-                            None => {}
-                            Some(_) if child.get_module_if_available()
-                                            .map(|m| m.kind.get()) ==
-                                       Some(ImplModuleKind) => {}
+                            Some(DefMod(_)) | None => {}
                             Some(_) => duplicate_type = TypeError
                         }
                         Some(TypeNS)
@@ -1179,10 +1177,7 @@ impl<'a> Resolver<'a> {
             // These items live in the type namespace.
             ItemTy(..) => {
                 let name_bindings =
-                    self.add_child(ident,
-                                   parent.clone(),
-                                   ForbidDuplicateTypesAndModules,
-                                   sp);
+                    self.add_child(ident, parent.clone(), ForbidDuplicateTypes, sp);
 
                 name_bindings.define_type
                     (DefTy(local_def(item.id)), sp, is_public);
@@ -1191,10 +1186,7 @@ impl<'a> Resolver<'a> {
 
             ItemEnum(ref enum_definition, _) => {
                 let name_bindings =
-                    self.add_child(ident,
-                                   parent.clone(),
-                                   ForbidDuplicateTypesAndModules,
-                                   sp);
+                    self.add_child(ident, parent.clone(), ForbidDuplicateTypes, sp);
 
                 name_bindings.define_type
                     (DefTy(local_def(item.id)), sp, is_public);
@@ -1214,7 +1206,7 @@ impl<'a> Resolver<'a> {
                 // Adding to both Type and Value namespaces or just Type?
                 let (forbid, ctor_id) = match struct_def.ctor_id {
                     Some(ctor_id)   => (ForbidDuplicateTypesAndValues, Some(ctor_id)),
-                    None            => (ForbidDuplicateTypesAndModules, None)
+                    None            => (ForbidDuplicateTypes, None)
                 };
 
                 let name_bindings = self.add_child(ident, parent.clone(), forbid, sp);
@@ -1335,10 +1327,7 @@ impl<'a> Resolver<'a> {
 
             ItemTrait(_, _, _, ref methods) => {
                 let name_bindings =
-                    self.add_child(ident,
-                                   parent.clone(),
-                                   ForbidDuplicateTypesAndModules,
-                                   sp);
+                    self.add_child(ident, parent.clone(), ForbidDuplicateTypes, sp);
 
                 // Add all the methods within to a new module.
                 let parent_link = self.get_parent_link(parent.clone(), ident);