---

yaml
---
r: 272729
b: refs/heads/beta
c: cf01fb6
h: refs/heads/master
i:
  272727: 4ee644d

Author: xaocon

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 25e42ac10653e4d7178e36201608cc269e3c66c7
+refs/heads/beta: cf01fb68368ec985ffd3bf00e8e885780576da25
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/doc/book/SUMMARY.md

@@ -9,6 +9,7 @@
     * [Comments](comments.md)
     * [if](if.md)
     * [Loops](loops.md)
+    * [Vectors](vectors.md)
     * [Ownership](ownership.md)
     * [References and Borrowing](references-and-borrowing.md)
     * [Lifetimes](lifetimes.md)
@@ -18,7 +19,6 @@
     * [Match](match.md)
     * [Patterns](patterns.md)
     * [Method Syntax](method-syntax.md)
-    * [Vectors](vectors.md)
     * [Strings](strings.md)
     * [Generics](generics.md)
     * [Traits](traits.md)

branches/beta/src/libcollectionstest/str.rs

@@ -1508,19 +1508,6 @@ generate_iterator_test! {
     with str::rsplitn;
 }
 
-#[test]
-fn different_str_pattern_forwarding_lifetimes() {
-    use std::str::pattern::Pattern;
-
-    fn foo<'a, P>(p: P) where for<'b> &'b P: Pattern<'a> {
-        for _ in 0..3 {
-            "asdf".find(&p);
-        }
-    }
-
-    foo::<&str>("x");
-}
-
 mod bench {
     use test::{Bencher, black_box};
 

branches/beta/src/libcore/cell.rs

@@ -241,9 +241,6 @@ impl<T:Copy> Cell<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 unsafe impl<T> Send for Cell<T> where T: Send {}
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> !Sync for Cell<T> {}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T:Copy> Clone for Cell<T> {
     #[inline]
@@ -464,9 +461,6 @@ impl<T: ?Sized> RefCell<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 unsafe impl<T: ?Sized> Send for RefCell<T> where T: Send {}
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> !Sync for RefCell<T> {}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Clone> Clone for RefCell<T> {
     #[inline]

branches/beta/src/libcore/slice.rs

@@ -285,12 +285,12 @@ impl<T> SliceExt for [T] {
 
     #[inline]
     unsafe fn get_unchecked(&self, index: usize) -> &T {
-        &*(self.as_ptr().offset(index as isize))
+        &*(self.repr().data.offset(index as isize))
     }
 
     #[inline]
     fn as_ptr(&self) -> *const T {
-        self as *const [T] as *const T
+        self.repr().data
     }
 
     fn binary_search_by<F>(&self, mut f: F) -> Result<usize, usize> where
@@ -448,12 +448,12 @@ impl<T> SliceExt for [T] {
 
     #[inline]
     unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T {
-        &mut *self.as_mut_ptr().offset(index as isize)
+        &mut *(self.repr().data as *mut T).offset(index as isize)
     }
 
     #[inline]
     fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut [T] as *mut T
+        self.repr().data as *mut T
     }
 
     #[inline]

branches/beta/src/libcore/str/mod.rs

@@ -1894,7 +1894,7 @@ impl StrExt for str {
 
     #[inline]
     fn as_ptr(&self) -> *const u8 {
-        self as *const str as *const u8
+        self.repr().data
     }
 
     #[inline]

branches/beta/src/libcore/str/pattern.rs

@@ -492,7 +492,7 @@ impl<'a, F> Pattern<'a> for F where F: FnMut(char) -> bool {
 /////////////////////////////////////////////////////////////////////////////
 
 /// Delegates to the `&str` impl.
-impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str {
+impl<'a, 'b> Pattern<'a> for &'b &'b str {
     pattern_methods!(StrSearcher<'a, 'b>, |&s| s, |s| s);
 }
 

branches/beta/src/librustc/dep_graph/mod.rs

@@ -198,8 +198,8 @@ pub fn visit_all_items_in_krate<'tcx,V,F>(tcx: &ty::ctxt<'tcx>,
         fn visit_item(&mut self, i: &'tcx hir::Item) {
             let item_def_id = self.tcx.map.local_def_id(i.id);
             let task_id = (self.dep_node_fn)(item_def_id);
+            debug!("About to start task {:?}", task_id);
             let _task = self.tcx.dep_graph.in_task(task_id);
-            debug!("Started task {:?}", task_id);
             self.tcx.dep_graph.read(DepNode::Hir(item_def_id));
             self.visitor.visit_item(i)
         }

branches/beta/src/librustc/front/map/collector.rs

@@ -150,8 +150,8 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
                     for field in v.node.data.fields() {
                         self.create_def_with_parent(
                             Some(variant_def_index),
-                            field.id,
-                            DefPathData::Field(field.name));
+                            field.node.id,
+                            DefPathData::Field(field.node.kind));
                     }
                 }
             }
@@ -166,7 +166,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
                 }
 
                 for field in struct_def.fields() {
-                    self.create_def(field.id, DefPathData::Field(field.name));
+                    self.create_def(field.node.id, DefPathData::Field(field.node.kind));
                 }
             }
             ItemTrait(_, _, ref bounds, _) => {

branches/beta/src/librustc/front/map/definitions.rs

@@ -11,6 +11,7 @@
 use middle::cstore::LOCAL_CRATE;
 use middle::def_id::{DefId, DefIndex};
 use rustc_data_structures::fnv::FnvHashMap;
+use rustc_front::hir;
 use syntax::ast;
 use syntax::parse::token::InternedString;
 use util::nodemap::NodeMap;
@@ -83,7 +84,8 @@ pub enum DefPathData {
     TypeParam(ast::Name),
     LifetimeDef(ast::Name),
     EnumVariant(ast::Name),
-    Field(ast::Name),
+    PositionalField,
+    Field(hir::StructFieldKind),
     StructCtor, // implicit ctor for a tuple-like struct
     Initializer, // initializer for a const
     Binding(ast::Name), // pattern binding
@@ -184,11 +186,19 @@ impl DefPathData {
             LifetimeDef(name) |
             EnumVariant(name) |
             DetachedCrate(name) |
-            Binding(name) |
-            Field(name) => {
+            Binding(name) => {
                 name.as_str()
             }
 
+            Field(hir::StructFieldKind::NamedField(name, _)) => {
+                name.as_str()
+            }
+
+            PositionalField |
+            Field(hir::StructFieldKind::UnnamedField(_)) => {
+                InternedString::new("{{field}}")
+            }
+
             // note that this does not show up in user printouts
             CrateRoot => {
                 InternedString::new("{{root}}")

branches/beta/src/librustc/lint/context.rs

@@ -811,7 +811,7 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {
     }
 
     fn visit_struct_field(&mut self, s: &hir::StructField) {
-        self.with_lint_attrs(&s.attrs, |cx| {
+        self.with_lint_attrs(&s.node.attrs, |cx| {
             run_lints!(cx, check_struct_field, late_passes, s);
             hir_visit::walk_struct_field(cx, s);
         })

branches/beta/src/librustc/middle/dead.rs

@@ -221,9 +221,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {
         let has_extern_repr = self.struct_has_extern_repr;
         let inherited_pub_visibility = self.inherited_pub_visibility;
         let live_fields = def.fields().iter().filter(|f| {
-            has_extern_repr || inherited_pub_visibility || f.vis == hir::Public
+            has_extern_repr || inherited_pub_visibility || match f.node.kind {
+                hir::NamedField(_, hir::Public) => true,
+                _ => false
+            }
         });
-        self.live_symbols.extend(live_fields.map(|f| f.id));
+        self.live_symbols.extend(live_fields.map(|f| f.node.id));
 
         intravisit::walk_struct_def(self, def);
     }
@@ -428,16 +431,17 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
         should_warn && !self.symbol_is_live(item.id, ctor_id)
     }
 
-    fn should_warn_about_field(&mut self, field: &hir::StructField) -> bool {
-        let field_type = self.tcx.node_id_to_type(field.id);
+    fn should_warn_about_field(&mut self, node: &hir::StructField_) -> bool {
+        let is_named = node.name().is_some();
+        let field_type = self.tcx.node_id_to_type(node.id);
         let is_marker_field = match field_type.ty_to_def_id() {
             Some(def_id) => self.tcx.lang_items.items().iter().any(|item| *item == Some(def_id)),
             _ => false
         };
-        !field.is_positional()
-            && !self.symbol_is_live(field.id, None)
+        is_named
+            && !self.symbol_is_live(node.id, None)
             && !is_marker_field
-            && !has_allow_dead_code_or_lang_attr(&field.attrs)
+            && !has_allow_dead_code_or_lang_attr(&node.attrs)
     }
 
     fn should_warn_about_variant(&mut self, variant: &hir::Variant_) -> bool {
@@ -543,9 +547,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for DeadVisitor<'a, 'tcx> {
     }
 
     fn visit_struct_field(&mut self, field: &hir::StructField) {
-        if self.should_warn_about_field(&field) {
-            self.warn_dead_code(field.id, field.span,
-                                field.name, "struct field");
+        if self.should_warn_about_field(&field.node) {
+            self.warn_dead_code(field.node.id, field.span,
+                                field.node.name().unwrap(), "struct field");
         }
 
         intravisit::walk_struct_field(self, field);

branches/beta/src/librustc/middle/stability.rs

@@ -259,7 +259,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> {
     }
 
     fn visit_struct_field(&mut self, s: &StructField) {
-        self.annotate(s.id, &s.attrs, s.span, AnnotationKind::Required, |v| {
+        self.annotate(s.node.id, &s.node.attrs, s.span, AnnotationKind::Required, |v| {
             intravisit::walk_struct_field(v, s);
         });
     }

branches/beta/src/librustc/middle/ty/mod.rs

@@ -1371,6 +1371,8 @@ pub struct FieldDefData<'tcx, 'container: 'tcx> {
     /// The field's DefId. NOTE: the fields of tuple-like enum variants
     /// are not real items, and don't have entries in tcache etc.
     pub did: DefId,
+    /// special_idents::unnamed_field.name
+    /// if this is a tuple-like field
     pub name: Name,
     pub vis: hir::Visibility,
     /// TyIVar is used here to allow for variance (see the doc at

branches/beta/src/librustc_front/fold.rs

@@ -700,13 +700,15 @@ pub fn noop_fold_poly_trait_ref<T: Folder>(p: PolyTraitRef, fld: &mut T) -> Poly
 }
 
 pub fn noop_fold_struct_field<T: Folder>(f: StructField, fld: &mut T) -> StructField {
-    StructField {
-        span: fld.new_span(f.span),
-        id: fld.new_id(f.id),
-        name: f.name,
-        vis: f.vis,
-        ty: fld.fold_ty(f.ty),
-        attrs: fold_attrs(f.attrs, fld),
+    let StructField {node: StructField_ {id, kind, ty, attrs}, span} = f;
+    Spanned {
+        node: StructField_ {
+            id: fld.new_id(id),
+            kind: kind,
+            ty: fld.fold_ty(ty),
+            attrs: fold_attrs(attrs, fld),
+        },
+        span: fld.new_span(span),
     }
 }
 

branches/beta/src/librustc_front/hir.rs

@@ -24,6 +24,7 @@ pub use self::Mutability::*;
 pub use self::PathListItem_::*;
 pub use self::PrimTy::*;
 pub use self::Stmt_::*;
+pub use self::StructFieldKind::*;
 pub use self::TraitItem_::*;
 pub use self::Ty_::*;
 pub use self::TyParamBound::*;
@@ -1241,20 +1242,43 @@ impl Visibility {
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub struct StructField {
-    pub span: Span,
-    pub name: Name,
-    pub vis: Visibility,
+pub struct StructField_ {
+    pub kind: StructFieldKind,
     pub id: NodeId,
     pub ty: P<Ty>,
     pub attrs: HirVec<Attribute>,
 }
 
-impl StructField {
-    // Still necessary in couple of places
-    pub fn is_positional(&self) -> bool {
-        let first = self.name.as_str().as_bytes()[0];
-        first >= b'0' && first <= b'9'
+impl StructField_ {
+    pub fn name(&self) -> Option<Name> {
+        match self.kind {
+            NamedField(name, _) => Some(name),
+            UnnamedField(_) => None,
+        }
+    }
+}
+
+pub type StructField = Spanned<StructField_>;
+
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
+pub enum StructFieldKind {
+    NamedField(Name, Visibility),
+    /// Element of a tuple-like struct
+    UnnamedField(Visibility),
+}
+
+impl StructFieldKind {
+    pub fn is_unnamed(&self) -> bool {
+        match *self {
+            UnnamedField(..) => true,
+            NamedField(..) => false,
+        }
+    }
+
+    pub fn visibility(&self) -> Visibility {
+        match *self {
+            NamedField(_, vis) | UnnamedField(vis) => vis,
+        }
     }
 }
 

branches/beta/src/librustc_front/intravisit.rs

@@ -669,9 +669,9 @@ pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, struct_definition: &
 }
 
 pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V, struct_field: &'v StructField) {
-    visitor.visit_name(struct_field.span, struct_field.name);
-    visitor.visit_ty(&struct_field.ty);
-    walk_list!(visitor, visit_attribute, &struct_field.attrs);
+    walk_opt_name(visitor, struct_field.span, struct_field.node.name());
+    visitor.visit_ty(&struct_field.node.ty);
+    walk_list!(visitor, visit_attribute, &struct_field.node.attrs);
 }
 
 pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block) {