auto merge of #13145 : alexcrichton/rust/flip-some-defaults, r=brson

bors · bors · commit c83994e0f492 · 2014-03-26T16:37:03.000-07:00
This change prepares `rustc` to accept private fields by default. These changes will have to go through a snapshot before the rest of the changes can happen.
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
@@ -1019,10 +1019,11 @@ pub fn get_struct_fields(intr: @IdentInterner, cdata: Cmd, id: ast::NodeId)
     });
     reader::tagged_docs(item, tag_item_unnamed_field, |an_item| {
         let did = item_def_id(an_item, cdata);
+        let f = item_family(an_item);
         result.push(ty::field_ty {
             name: special_idents::unnamed_field.name,
             id: did,
-            vis: ast::Inherited,
+            vis: struct_field_family_to_visibility(f),
         });
         true
     });
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
@@ -310,8 +310,9 @@ fn encode_struct_fields(ebml_w: &mut writer::Encoder,
                encode_def_id(ebml_w, local_def(f.node.id));
                ebml_w.end_tag();
             }
-            UnnamedField => {
+            UnnamedField(vis) => {
                 ebml_w.start_tag(tag_item_unnamed_field);
+                encode_struct_field_family(ebml_w, vis);
                 encode_def_id(ebml_w, local_def(f.node.id));
                 ebml_w.end_tag();
             }
@@ -513,8 +514,7 @@ fn each_auxiliary_node_id(item: @Item, callback: |NodeId| -> bool) -> bool {
             // If this is a newtype struct, return the constructor.
             match struct_def.ctor_id {
                 Some(ctor_id) if struct_def.fields.len() > 0 &&
-                        struct_def.fields.get(0).node.kind ==
-                        ast::UnnamedField => {
+                        struct_def.fields.get(0).node.kind.is_unnamed() => {
                     continue_ = callback(ctor_id);
                 }
                 _ => {}
@@ -690,7 +690,7 @@ fn encode_info_for_struct(ecx: &EncodeContext,
     for field in fields.iter() {
         let (nm, vis) = match field.node.kind {
             NamedField(nm, vis) => (nm, vis),
-            UnnamedField => (special_idents::unnamed_field, Inherited)
+            UnnamedField(vis) => (special_idents::unnamed_field, vis)
         };
 
         let id = field.node.id;
diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
@@ -1001,15 +1001,11 @@ impl<'a> SanePrivacyVisitor<'a> {
             };
             for f in def.fields.iter() {
                match f.node.kind {
-                    ast::NamedField(_, ast::Public) if public_def => {
-                        tcx.sess.span_err(f.span, "unnecessary `pub` \
-                                                   visibility");
-                    }
                     ast::NamedField(_, ast::Private) if !public_def => {
                         tcx.sess.span_err(f.span, "unnecessary `priv` \
                                                    visibility");
                     }
-                    ast::NamedField(..) | ast::UnnamedField => {}
+                    ast::NamedField(..) | ast::UnnamedField(..) => {}
                 }
             }
         };
@@ -1106,7 +1102,7 @@ impl<'a> SanePrivacyVisitor<'a> {
             for f in def.fields.iter() {
                match f.node.kind {
                     ast::NamedField(_, p) => check_inherited(f.span, p),
-                    ast::UnnamedField => {}
+                    ast::UnnamedField(..) => {}
                 }
             }
         };
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -3900,7 +3900,7 @@ impl VariantInfo {
                 let arg_names = fields.iter().map(|field| {
                     match field.node.kind {
                         NamedField(ident, _) => ident,
-                        UnnamedField => cx.sess.bug(
+                        UnnamedField(..) => cx.sess.bug(
                             "enum_variants: all fields in struct must have a name")
                     }
                 }).collect();
@@ -4264,11 +4264,11 @@ fn struct_field_tys(fields: &[StructField]) -> Vec<field_ty> {
                     vis: visibility,
                 }
             }
-            UnnamedField => {
+            UnnamedField(visibility) => {
                 field_ty {
                     name: syntax::parse::token::special_idents::unnamed_field.name,
                     id: ast_util::local_def(field.node.id),
-                    vis: ast::Public,
+                    vis: visibility,
                 }
             }
         }
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
@@ -695,8 +695,7 @@ pub fn convert_struct(ccx: &CrateCtxt,
                 write_ty_to_tcx(tcx, ctor_id, selfty);
 
                 tcx.tcache.borrow_mut().insert(local_def(ctor_id), tpt);
-            } else if struct_def.fields.get(0).node.kind ==
-                    ast::UnnamedField {
+            } else if struct_def.fields.get(0).node.kind.is_unnamed() {
                 // Tuple-like.
                 let inputs = struct_def.fields.map(
                         |field| tcx.tcache.borrow().get(
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -1080,7 +1080,16 @@ pub type StructField = Spanned<StructField_>;
 #[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)]
 pub enum StructFieldKind {
     NamedField(Ident, Visibility),
-    UnnamedField // element of a tuple-like struct
+    UnnamedField(Visibility), // element of a tuple-like struct
+}
+
+impl StructFieldKind {
+    pub fn is_unnamed(&self) -> bool {
+        match *self {
+            UnnamedField(..) => true,
+            NamedField(..) => false,
+        }
+    }
 }
 
 #[deriving(Eq, TotalEq, Encodable, Decodable, Hash)]
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
@@ -290,8 +290,7 @@ pub fn split_trait_methods(trait_methods: &[TraitMethod])
 
 pub fn struct_field_visibility(field: ast::StructField) -> Visibility {
     match field.node.kind {
-        ast::NamedField(_, visibility) => visibility,
-        ast::UnnamedField => ast::Public
+        ast::NamedField(_, v) | ast::UnnamedField(v) => v
     }
 }
 
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
@@ -1007,7 +1007,7 @@ impl<'a> TraitDef<'a> {
             let sp = self.set_expn_info(cx, field.span);
             match field.node.kind {
                 ast::NamedField(ident, _) => named_idents.push((ident, sp)),
-                ast::UnnamedField => just_spans.push(sp),
+                ast::UnnamedField(..) => just_spans.push(sp),
             }
         }
 
@@ -1061,8 +1061,8 @@ impl<'a> TraitDef<'a> {
                     struct_type = Record;
                     Some(ident)
                 }
-                ast::UnnamedField if (struct_type == Unknown ||
-                                      struct_type == Tuple) => {
+                ast::UnnamedField(..) if (struct_type == Unknown ||
+                                          struct_type == Tuple) => {
                     struct_type = Tuple;
                     None
                 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -3985,7 +3985,7 @@ impl<'a> Parser<'a> {
                 let attrs = p.parse_outer_attributes();
                 let lo = p.span.lo;
                 let struct_field_ = ast::StructField_ {
-                    kind: UnnamedField,
+                    kind: UnnamedField(p.parse_visibility()),
                     id: ast::DUMMY_NODE_ID,
                     ty: p.parse_ty(false),
                     attrs: attrs,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -743,7 +743,8 @@ impl<'a> State<'a> {
                     |s, field| {
                         match field.node.kind {
                             ast::NamedField(..) => fail!("unexpected named field"),
-                            ast::UnnamedField => {
+                            ast::UnnamedField(vis) => {
+                                try!(s.print_visibility(vis));
                                 try!(s.maybe_print_comment(field.span.lo));
                                 s.print_type(field.node.ty)
                             }
@@ -762,7 +763,7 @@ impl<'a> State<'a> {
 
             for field in struct_def.fields.iter() {
                 match field.node.kind {
-                    ast::UnnamedField => fail!("unexpected unnamed field"),
+                    ast::UnnamedField(..) => fail!("unexpected unnamed field"),
                     ast::NamedField(ident, visibility) => {
                         try!(self.hardbreak_if_not_bol());
                         try!(self.maybe_print_comment(field.span.lo));
diff --git a/src/test/compile-fail/struct-field-privacy.rs b/src/test/compile-fail/struct-field-privacy.rs
@@ -25,7 +25,7 @@ mod inner {
     pub struct B {
         a: int,
         priv b: int,
-        pub c: int, //~ ERROR: unnecessary `pub` visibility
+        pub c: int,
     }
 }
 
diff --git a/src/test/compile-fail/struct-variant-privacy.rs b/src/test/compile-fail/struct-variant-privacy.rs

Original file line number	Diff line number	Diff line change
`@@ -1001,15 +1001,11 @@ impl<'a> SanePrivacyVisitor<'a> {`
`1001`	`1001`	`};`
`1002`	`1002`	`for f in def.fields.iter() {`
`1003`	`1003`	`match f.node.kind {`
`1004`		`- ast::NamedField(_, ast::Public) if public_def => {`
`1005`		- tcx.sess.span_err(f.span, "unnecessary `pub` \
`1006`		`- visibility");`
`1007`		`- }`
`1008`	`1004`	`ast::NamedField(_, ast::Private) if !public_def => {`
`1009`	`1005`	tcx.sess.span_err(f.span, "unnecessary `priv` \
`1010`	`1006`	`visibility");`
`1011`	`1007`	`}`
`1012`		`- ast::NamedField(..) \| ast::UnnamedField => {}`
	`1008`	`+ ast::NamedField(..) \| ast::UnnamedField(..) => {}`
`1013`	`1009`	`}`
`1014`	`1010`	`}`
`1015`	`1011`	`};`
`@@ -1106,7 +1102,7 @@ impl<'a> SanePrivacyVisitor<'a> {`
`1106`	`1102`	`for f in def.fields.iter() {`
`1107`	`1103`	`match f.node.kind {`
`1108`	`1104`	`ast::NamedField(_, p) => check_inherited(f.span, p),`
`1109`		`- ast::UnnamedField => {}`
	`1105`	`+ ast::UnnamedField(..) => {}`
`1110`	`1106`	`}`
`1111`	`1107`	`}`
`1112`	`1108`	`};`
Original file line number	Diff line number	Diff line change
`@@ -3900,7 +3900,7 @@ impl VariantInfo {`
`3900`	`3900`	`let arg_names = fields.iter().map(\|field\| {`
`3901`	`3901`	`match field.node.kind {`
`3902`	`3902`	`NamedField(ident, _) => ident,`
`3903`		`- UnnamedField => cx.sess.bug(`
	`3903`	`+ UnnamedField(..) => cx.sess.bug(`
`3904`	`3904`	`"enum_variants: all fields in struct must have a name")`
`3905`	`3905`	`}`
`3906`	`3906`	`}).collect();`
`@@ -4264,11 +4264,11 @@ fn struct_field_tys(fields: &[StructField]) -> Vec<field_ty> {`
`4264`	`4264`	`vis: visibility,`
`4265`	`4265`	`}`
`4266`	`4266`	`}`
`4267`		`- UnnamedField => {`
	`4267`	`+ UnnamedField(visibility) => {`
`4268`	`4268`	`field_ty {`
`4269`	`4269`	`name: syntax::parse::token::special_idents::unnamed_field.name,`
`4270`	`4270`	`id: ast_util::local_def(field.node.id),`
`4271`		`- vis: ast::Public,`
	`4271`	`+ vis: visibility,`
`4272`	`4272`	`}`
`4273`	`4273`	`}`
`4274`	`4274`	`}`
Original file line number	Diff line number	Diff line change
`@@ -290,8 +290,7 @@ pub fn split_trait_methods(trait_methods: &[TraitMethod])`
`290`	`290`
`291`	`291`	`pub fn struct_field_visibility(field: ast::StructField) -> Visibility {`
`292`	`292`	`match field.node.kind {`
`293`		`- ast::NamedField(_, visibility) => visibility,`
`294`		`- ast::UnnamedField => ast::Public`
	`293`	`+ ast::NamedField(_, v) \| ast::UnnamedField(v) => v`
`295`	`294`	`}`
`296`	`295`	`}`
`297`	`296`
Original file line number	Diff line number	Diff line change
`@@ -1007,7 +1007,7 @@ impl<'a> TraitDef<'a> {`
`1007`	`1007`	`let sp = self.set_expn_info(cx, field.span);`
`1008`	`1008`	`match field.node.kind {`
`1009`	`1009`	`ast::NamedField(ident, _) => named_idents.push((ident, sp)),`
`1010`		`- ast::UnnamedField => just_spans.push(sp),`
	`1010`	`+ ast::UnnamedField(..) => just_spans.push(sp),`
`1011`	`1011`	`}`
`1012`	`1012`	`}`
`1013`	`1013`
`@@ -1061,8 +1061,8 @@ impl<'a> TraitDef<'a> {`
`1061`	`1061`	`struct_type = Record;`
`1062`	`1062`	`Some(ident)`
`1063`	`1063`	`}`
`1064`		`- ast::UnnamedField if (struct_type == Unknown \|\|`
`1065`		`- struct_type == Tuple) => {`
	`1064`	`+ ast::UnnamedField(..) if (struct_type == Unknown \|\|`
	`1065`	`+ struct_type == Tuple) => {`
`1066`	`1066`	`struct_type = Tuple;`
`1067`	`1067`	`None`
`1068`	`1068`	`}`