---

yaml
---
r: 153839
b: refs/heads/try2
c: 531a3c6
h: refs/heads/master
i:
  153837: 8ac57cf
  153835: 5b6d20b
  153831: a4bff7e
  153823: 23990de
v: v3

Author: emberian

[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: f4ef36ee4269644ca97907a06c924b5d8be36b89
+refs/heads/try2: 531a3c680d31b52fab99b50fe9a52c55505b9ac9
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -227,3 +227,7 @@ pub static tag_region_param_def_index: uint = 0x94;
 pub static tag_unboxed_closures: uint = 0x95;
 pub static tag_unboxed_closure: uint = 0x96;
 pub static tag_unboxed_closure_type: uint = 0x97;
+
+pub static tag_struct_fields: uint = 0x98;
+pub static tag_struct_field: uint = 0x99;
+pub static tag_struct_field_id: uint = 0x9a;

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

@@ -29,6 +29,8 @@ use syntax::attr;
 use syntax::diagnostic::expect;
 use syntax::parse::token;
 
+use std::collections::hashmap::HashMap;
+
 pub struct StaticMethodInfo {
     pub ident: ast::Ident,
     pub def_id: ast::DefId,
@@ -192,6 +194,12 @@ pub fn get_struct_fields(cstore: &cstore::CStore,
     decoder::get_struct_fields(cstore.intr.clone(), &*cdata, def.node)
 }
 
+pub fn get_struct_field_attrs(cstore: &cstore::CStore, def: ast::DefId) -> HashMap<ast::NodeId,
+        Vec<ast::Attribute>> {
+    let cdata = cstore.get_crate_data(def.krate);
+    decoder::get_struct_field_attrs(&*cdata)
+}
+
 pub fn get_type(tcx: &ty::ctxt,
                 def: ast::DefId)
              -> ty::Polytype {

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

@@ -34,6 +34,7 @@ use std::hash::Hash;
 use std::hash;
 use std::io::extensions::u64_from_be_bytes;
 use std::io;
+use std::collections::hashmap::HashMap;
 use std::rc::Rc;
 use std::u64;
 use serialize::ebml::reader;
@@ -963,6 +964,19 @@ pub fn get_item_attrs(cdata: Cmd,
     f(get_attributes(item));
 }
 
+pub fn get_struct_field_attrs(cdata: Cmd) -> HashMap<ast::NodeId, Vec<ast::Attribute>> {
+    let data = ebml::Doc::new(cdata.data());
+    let fields = reader::get_doc(data, tag_struct_fields);
+    let mut map = HashMap::new();
+    reader::tagged_docs(fields, tag_struct_field, |field| {
+        let id = reader::doc_as_u32(reader::get_doc(field, tag_struct_field_id));
+        let attrs = get_attributes(field);
+        map.insert(id, attrs);
+        true
+    });
+    map
+}
+
 fn struct_field_family_to_visibility(family: Family) -> ast::Visibility {
     match family {
       PublicField => ast::Public,

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

@@ -1644,6 +1644,29 @@ fn encode_unboxed_closures<'a>(
     ebml_w.end_tag();
 }
 
+fn encode_struct_field_attrs(ebml_w: &mut Encoder, krate: &Crate) {
+    struct StructFieldVisitor<'a, 'b> {
+        ebml_w: &'a mut Encoder<'b>,
+    }
+
+    impl<'a, 'b> Visitor<()> for StructFieldVisitor<'a, 'b> {
+        fn visit_struct_field(&mut self, field: &ast::StructField, _: ()) {
+            self.ebml_w.start_tag(tag_struct_field);
+            self.ebml_w.wr_tagged_u32(tag_struct_field_id, field.node.id);
+            encode_attributes(self.ebml_w, field.node.attrs.as_slice());
+            self.ebml_w.end_tag();
+        }
+    }
+
+    ebml_w.start_tag(tag_struct_fields);
+    visit::walk_crate(&mut StructFieldVisitor {
+        ebml_w: ebml_w
+    }, krate, ());
+    ebml_w.end_tag();
+}
+
+
+
 struct ImplVisitor<'a,'b,'c> {
     ecx: &'a EncodeContext<'b>,
     ebml_w: &'a mut Encoder<'c>,
@@ -1928,6 +1951,8 @@ fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, krate: &Crate)
     stats.index_bytes = ebml_w.writer.tell().unwrap() - i;
     ebml_w.end_tag();
 
+    encode_struct_field_attrs(&mut ebml_w, krate);
+
     stats.total_bytes = ebml_w.writer.tell().unwrap();
 
     if tcx.sess.meta_stats() {

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

@@ -4071,7 +4071,7 @@ pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec<field_ty> {
 
         let len = results.as_slice().iter().map(|x| x.len()).sum();
         let mut result: Vec<field_ty> = Vec::with_capacity(len);
-        result.extend(results.as_slice().iter().flat_map(|rs| rs.iter().map(|&f| f)));
+        result.extend(results.as_slice().iter().flat_map(|rs| rs.iter().map(|f| f.clone())));
         assert!(result.len() == len);
         result
     } else {
@@ -4085,7 +4085,7 @@ pub fn lookup_struct_field(cx: &ctxt,
                         -> field_ty {
     let r = lookup_struct_fields(cx, parent);
     match r.iter().find(|f| f.id.node == field_id.node) {
-        Some(t) => *t,
+        Some(t) => t.clone(),
         None => cx.sess.bug("struct ID not found in parent's fields")
     }
 }

branches/try2/src/librustc/middle/typeck/check/_match.rs

@@ -322,7 +322,7 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
             }
             Some(&(index, ref mut used)) => {
                 *used = true;
-                let class_field = *class_fields.get(index);
+                let class_field = class_fields.get(index).clone();
                 let field_type = ty::lookup_field_type(tcx,
                                                        class_id,
                                                        class_field.id,

branches/try2/src/librustc/middle/typeck/coherence.rs

@@ -60,25 +60,29 @@ fn get_base_type(inference_context: &InferCtxt,
                  span: Span,
                  original_type: t)
                  -> Option<t> {
-    let resolved_type = match resolve_type(inference_context,
-                                           Some(span),
-                                           original_type,
-                                           resolve_ivar) {
-        Ok(resulting_type) if !type_is_ty_var(resulting_type) => resulting_type,
+    let resolved_type;
+    match resolve_type(inference_context,
+                       Some(span),
+                       original_type,
+                       resolve_ivar) {
+        Ok(resulting_type) if !type_is_ty_var(resulting_type) => {
+            resolved_type = resulting_type;
+        }
         _ => {
             inference_context.tcx.sess.span_fatal(span,
                                                   "the type of this value must be known in order \
                                                    to determine the base type");
         }
-    };
+    }
 
     match get(resolved_type).sty {
         ty_enum(..) | ty_struct(..) | ty_unboxed_closure(..) => {
             debug!("(getting base type) found base type");
             Some(resolved_type)
         }
-
-        _ if ty::type_is_trait(resolved_type) => {
+        // FIXME(14865) I would prefere to use `_` here, but that causes a
+        // compiler error.
+        ty_uniq(_) | ty_rptr(_, _) | ty_trait(..) if ty::type_is_trait(resolved_type) => {
             debug!("(getting base type) found base type (trait)");
             Some(resolved_type)
         }

branches/try2/src/librustdoc/clean/inline.rs

@@ -209,7 +209,7 @@ fn build_struct(tcx: &ty::ctxt, did: ast::DefId) -> clean::Struct {
             _ => doctree::Plain,
         },
         generics: (&t.generics, subst::TypeSpace).clean(),
-        fields: fields.iter().map(|f| f.clean()).collect(),
+        fields: fields.clean(),
         fields_stripped: false,
     }
 }

branches/try2/src/librustdoc/clean/mod.rs

@@ -1320,16 +1320,26 @@ impl Clean<Item> for ast::StructField {
 impl Clean<Item> for ty::field_ty {
     fn clean(&self) -> Item {
         use syntax::parse::token::special_idents::unnamed_field;
+        use rustc::metadata::csearch;
+
+        let cx = get_cx();
+        let attrs;
+
+        let attr_map = csearch::get_struct_field_attrs(&cx.tcx().sess.cstore, self.id);
+
         let name = if self.name == unnamed_field.name {
+            attrs = None;
             None
         } else {
+            attrs = Some(attr_map.find(&self.id.node).unwrap());
             Some(self.name)
         };
-        let cx = get_cx();
+
         let ty = ty::lookup_item_type(cx.tcx(), self.id);
+
         Item {
             name: name.clean(),
-            attrs: inline::load_attrs(cx.tcx(), self.id),
+            attrs: attrs.unwrap_or(&Vec::new()).clean(),
             source: Span::empty(),
             visibility: Some(self.vis),
             stability: get_stability(self.id),