From 31ac9c4288f32c2afdce11e616668b251e6164ef Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 24 Jan 2014 11:00:08 -0800 Subject: [PATCH 1/2] Change private structs to have private fields by default This was the original intention of the privacy of structs, and it was erroneously implemented before. A pub struct will now have default-pub fields, and a non-pub struct will have default-priv fields. This essentially brings struct fields in line with enum variants in terms of inheriting visibility. As usual, extraneous modifiers to visibility are disallowed depend on the case that you're dealing with. Closes #11522 --- src/librustc/middle/privacy.rs | 98 +++++++++++++------ src/test/auxiliary/struct-field-privacy.rs | 19 ++++ src/test/compile-fail/struct-field-privacy.rs | 51 ++++++++++ 3 files changed, 136 insertions(+), 32 deletions(-) create mode 100644 src/test/auxiliary/struct-field-privacy.rs create mode 100644 src/test/compile-fail/struct-field-privacy.rs diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 526fb9e8d866..052a6ad898fd 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -15,6 +15,7 @@ use std::hashmap::{HashSet, HashMap}; use std::util; +use metadata::csearch; use middle::resolve; use middle::ty; use middle::typeck::{method_map, method_origin, method_param}; @@ -123,22 +124,7 @@ impl Visitor<()> for ParentVisitor { // While we have the id of the struct definition, go ahead and parent // all the fields. for field in s.fields.iter() { - let vis = match field.node.kind { - ast::NamedField(_, vis) => vis, - ast::UnnamedField => continue - }; - - // Private fields are scoped to this module, so parent them directly - // to the module instead of the struct. This is similar to the case - // of private enum variants. - if vis == ast::Private { - self.parents.insert(field.node.id, self.curparent); - - // Otherwise public fields are scoped to the visibility of the - // struct itself - } else { - self.parents.insert(field.node.id, n); - } + self.parents.insert(field.node.id, self.curparent); } visit::walk_struct_def(self, s, i, g, n, ()) } @@ -558,12 +544,48 @@ impl<'a> PrivacyVisitor<'a> { // Checks that a field is in scope. // FIXME #6993: change type (and name) from Ident to Name - fn check_field(&mut self, span: Span, id: ast::DefId, ident: ast::Ident) { + fn check_field(&mut self, span: Span, id: ast::DefId, ident: ast::Ident, + enum_id: Option) { let fields = ty::lookup_struct_fields(self.tcx, id); + let struct_vis = if is_local(id) { + match self.tcx.items.get(id.node) { + ast_map::NodeItem(ref it, _) => it.vis, + ast_map::NodeVariant(ref v, ref it, _) => { + if v.node.vis == ast::Inherited {it.vis} else {v.node.vis} + } + _ => { + self.tcx.sess.span_bug(span, + format!("not an item or variant def")); + } + } + } else { + let cstore = self.tcx.sess.cstore; + match enum_id { + Some(enum_id) => { + let v = csearch::get_enum_variants(self.tcx, enum_id); + match v.iter().find(|v| v.id == id) { + Some(variant) => { + if variant.vis == ast::Inherited { + csearch::get_item_visibility(cstore, enum_id) + } else { + variant.vis + } + } + None => { + self.tcx.sess.span_bug(span, "no xcrate variant"); + } + } + } + None => csearch::get_item_visibility(cstore, id) + } + }; + for field in fields.iter() { if field.name != ident.name { continue; } - // public fields are public everywhere - if field.vis != ast::Private { break } + // public structs have public fields by default, and private structs + // have private fields by default. + if struct_vis == ast::Public && field.vis != ast::Private { break } + if struct_vis != ast::Public && field.vis == ast::Public { break } if !is_local(field.id) || !self.private_accessible(field.id.node) { self.tcx.sess.span_err(span, format!("field `{}` is private", @@ -661,7 +683,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { let t = ty::type_autoderef(ty::expr_ty(self.tcx, base)); match ty::get(t).sty { ty::ty_struct(id, _) => { - self.check_field(expr.span, id, ident); + self.check_field(expr.span, id, ident, None); } _ => {} } @@ -690,16 +712,18 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { match ty::get(ty::expr_ty(self.tcx, expr)).sty { ty::ty_struct(id, _) => { for field in (*fields).iter() { - self.check_field(expr.span, id, field.ident.node); + self.check_field(expr.span, id, field.ident.node, + None); } } ty::ty_enum(_, _) => { let def_map = self.tcx.def_map.borrow(); match def_map.get().get_copy(&expr.id) { - ast::DefVariant(_, variant_id, _) => { + ast::DefVariant(enum_id, variant_id, _) => { for field in fields.iter() { self.check_field(expr.span, variant_id, - field.ident.node); + field.ident.node, + Some(enum_id)); } } _ => self.tcx.sess.span_bug(expr.span, @@ -763,16 +787,17 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { match ty::get(ty::pat_ty(self.tcx, pattern)).sty { ty::ty_struct(id, _) => { for field in fields.iter() { - self.check_field(pattern.span, id, field.ident); + self.check_field(pattern.span, id, field.ident, + None); } } ty::ty_enum(_, _) => { let def_map = self.tcx.def_map.borrow(); match def_map.get().find(&pattern.id) { - Some(&ast::DefVariant(_, variant_id, _)) => { + Some(&ast::DefVariant(enum_id, variant_id, _)) => { for field in fields.iter() { self.check_field(pattern.span, variant_id, - field.ident); + field.ident, Some(enum_id)); } } _ => self.tcx.sess.span_bug(pattern.span, @@ -888,15 +913,22 @@ impl SanePrivacyVisitor { } } }; - let check_struct = |def: &@ast::StructDef| { + let check_struct = |def: &@ast::StructDef, + vis: ast::Visibility, + parent_vis: Option| { + let public_def = match vis { + ast::Public => true, + ast::Inherited | ast::Private => parent_vis == Some(ast::Public), + }; for f in def.fields.iter() { match f.node.kind { - ast::NamedField(_, ast::Public) => { + ast::NamedField(_, ast::Public) if public_def => { tcx.sess.span_err(f.span, "unnecessary `pub` \ visibility"); } - ast::NamedField(_, ast::Private) => { - // Fields should really be private by default... + ast::NamedField(_, ast::Private) if !public_def => { + tcx.sess.span_err(f.span, "unnecessary `priv` \ + visibility"); } ast::NamedField(..) | ast::UnnamedField => {} } @@ -951,13 +983,15 @@ impl SanePrivacyVisitor { } match v.node.kind { - ast::StructVariantKind(ref s) => check_struct(s), + ast::StructVariantKind(ref s) => { + check_struct(s, v.node.vis, Some(item.vis)); + } ast::TupleVariantKind(..) => {} } } } - ast::ItemStruct(ref def, _) => check_struct(def), + ast::ItemStruct(ref def, _) => check_struct(def, item.vis, None), ast::ItemTrait(_, _, ref methods) => { for m in methods.iter() { diff --git a/src/test/auxiliary/struct-field-privacy.rs b/src/test/auxiliary/struct-field-privacy.rs new file mode 100644 index 000000000000..497d50a23903 --- /dev/null +++ b/src/test/auxiliary/struct-field-privacy.rs @@ -0,0 +1,19 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +struct A { + a: int, + pub b: int, +} + +pub struct B { + a: int, + priv b: int, +} diff --git a/src/test/compile-fail/struct-field-privacy.rs b/src/test/compile-fail/struct-field-privacy.rs new file mode 100644 index 000000000000..f31690047854 --- /dev/null +++ b/src/test/compile-fail/struct-field-privacy.rs @@ -0,0 +1,51 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// aux-build:struct-field-privacy.rs + +extern mod xc = "struct-field-privacy"; + +struct A { + a: int, +} + +mod inner { + struct A { + a: int, + pub b: int, + priv c: int, //~ ERROR: unnecessary `priv` visibility + } + pub struct B { + a: int, + priv b: int, + pub c: int, //~ ERROR: unnecessary `pub` visibility + } +} + +fn test(a: A, b: inner::A, c: inner::B, d: xc::A, e: xc::B) { + //~^ ERROR: type `A` is private + //~^^ ERROR: struct `A` is private + + a.a; + b.a; //~ ERROR: field `a` is private + b.b; + b.c; //~ ERROR: field `c` is private + c.a; + c.b; //~ ERROR: field `b` is private + c.c; + + d.a; //~ ERROR: field `a` is private + d.b; + + e.a; + e.b; //~ ERROR: field `b` is private +} + +fn main() {} From 4d6836f418e35de76ca072092372cbd55b01867a Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 24 Jan 2014 11:02:03 -0800 Subject: [PATCH 2/2] Fix privacy fallout from previous change --- doc/guide-container.md | 4 ++-- src/libextra/arc.rs | 4 ++-- src/libextra/dlist.rs | 8 ++++---- src/libextra/lru_cache.rs | 10 +++++----- src/libextra/sync.rs | 4 ++-- src/librustc/middle/ty.rs | 2 +- src/librustc/util/sha2.rs | 4 ++-- src/librustpkg/package_source.rs | 4 ++-- src/librustuv/homing.rs | 2 +- src/libstd/comm/select.rs | 2 +- src/libsyntax/parse/parser.rs | 2 +- src/test/auxiliary/iss.rs | 2 +- src/test/bench/shootout-meteor.rs | 6 +++--- src/test/compile-fail/lint-missing-doc.rs | 4 ++-- src/test/compile-fail/mutable-class-fields-2.rs | 2 +- src/test/compile-fail/mutable-class-fields.rs | 2 +- src/test/compile-fail/useless-priv.rs | 4 ++-- .../run-pass/class-cast-to-trait-multiple-types.rs | 4 ++-- src/test/run-pass/class-cast-to-trait.rs | 2 +- .../run-pass/class-impl-very-parameterized-trait.rs | 2 +- src/test/run-pass/class-implement-trait-cross-crate.rs | 2 +- src/test/run-pass/class-implement-traits.rs | 2 +- src/test/run-pass/class-methods.rs | 2 +- src/test/run-pass/class-poly-methods.rs | 4 ++-- src/test/run-pass/class-separate-impl.rs | 2 +- src/test/run-pass/class-typarams.rs | 2 +- src/test/run-pass/classes-simple-method.rs | 2 +- src/test/run-pass/classes-simple.rs | 2 +- src/test/run-pass/classes.rs | 2 +- src/test/run-pass/issue-3563-3.rs | 4 ++-- src/test/run-pass/private-class-field.rs | 2 +- src/test/run-pass/private-method.rs | 2 +- 32 files changed, 51 insertions(+), 51 deletions(-) diff --git a/doc/guide-container.md b/doc/guide-container.md index 628e4f223b44..a586cfcf0d76 100644 --- a/doc/guide-container.md +++ b/doc/guide-container.md @@ -90,7 +90,7 @@ Reaching the end of the iterator is signalled by returning `None` instead of # fn main() {} /// A stream of N zeroes struct ZeroStream { - priv remaining: uint + remaining: uint } impl ZeroStream { @@ -305,7 +305,7 @@ The `ZeroStream` from earlier can provide an exact lower and upper bound: # fn main() {} /// A stream of N zeroes struct ZeroStream { - priv remaining: uint + remaining: uint } impl ZeroStream { diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs index a411c4e9185b..f914fa1ac093 100644 --- a/src/libextra/arc.rs +++ b/src/libextra/arc.rs @@ -148,7 +148,7 @@ impl Clone for Arc { ****************************************************************************/ #[doc(hidden)] -struct MutexArcInner { priv lock: Mutex, priv failed: bool, priv data: T } +struct MutexArcInner { lock: Mutex, failed: bool, data: T } /// An Arc with mutable data protected by a blocking mutex. #[no_freeze] @@ -312,7 +312,7 @@ impl PoisonOnFail { ****************************************************************************/ #[doc(hidden)] -struct RWArcInner { priv lock: RWLock, priv failed: bool, priv data: T } +struct RWArcInner { lock: RWLock, failed: bool, data: T } /** * A dual-mode Arc protected by a reader-writer lock. The data can be accessed * mutably or immutably, and immutably-accessing tasks may run concurrently. diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs index fa6e7c15ee01..320797889422 100644 --- a/src/libextra/dlist.rs +++ b/src/libextra/dlist.rs @@ -38,12 +38,12 @@ pub struct DList { } type Link = Option<~Node>; -struct Rawlink { priv p: *mut T } +struct Rawlink { p: *mut T } struct Node { - priv next: Link, - priv prev: Rawlink>, - priv value: T, + next: Link, + prev: Rawlink>, + value: T, } /// Double-ended DList iterator diff --git a/src/libextra/lru_cache.rs b/src/libextra/lru_cache.rs index e1cb54ae4529..f602db2e54d0 100644 --- a/src/libextra/lru_cache.rs +++ b/src/libextra/lru_cache.rs @@ -43,13 +43,13 @@ use std::to_bytes::Cb; use std::ptr; use std::cast; -struct KeyRef { priv k: *K } +struct KeyRef { k: *K } struct LruEntry { - priv key: Option, - priv value: Option, - priv next: *mut LruEntry, - priv prev: *mut LruEntry, + key: Option, + value: Option, + next: *mut LruEntry, + prev: *mut LruEntry, } /// An LRU Cache. diff --git a/src/libextra/sync.rs b/src/libextra/sync.rs index c4277bddac71..9aefb6eaf764 100644 --- a/src/libextra/sync.rs +++ b/src/libextra/sync.rs @@ -709,8 +709,8 @@ pub struct Barrier { // The inner state of a double barrier struct BarrierState { - priv count: uint, - priv generation_id: uint, + count: uint, + generation_id: uint, } impl Barrier { diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 01fb18d73c26..ba9cc153531f 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -257,7 +257,7 @@ pub type ctxt = @ctxt_; /// The data structure to keep track of all the information that typechecker /// generates so that so that it can be reused and doesn't have to be redone /// later on. -struct ctxt_ { +pub struct ctxt_ { diag: @syntax::diagnostic::SpanHandler, interner: RefCell>, next_id: Cell, diff --git a/src/librustc/util/sha2.rs b/src/librustc/util/sha2.rs index ee2f7638be98..ab7c62ccf16a 100644 --- a/src/librustc/util/sha2.rs +++ b/src/librustc/util/sha2.rs @@ -109,8 +109,8 @@ trait FixedBuffer { /// A FixedBuffer of 64 bytes useful for implementing Sha256 which has a 64 byte blocksize. struct FixedBuffer64 { - priv buffer: [u8, ..64], - priv buffer_idx: uint, + buffer: [u8, ..64], + buffer_idx: uint, } impl FixedBuffer64 { diff --git a/src/librustpkg/package_source.rs b/src/librustpkg/package_source.rs index 5ac62c5284e0..02c6294f236e 100644 --- a/src/librustpkg/package_source.rs +++ b/src/librustpkg/package_source.rs @@ -78,8 +78,8 @@ fn prefixes(p: &Path) -> Prefixes { } struct Prefixes { - priv components: ~[~str], - priv remaining: ~[~str] + components: ~[~str], + remaining: ~[~str] } impl Iterator<(Path, Path)> for Prefixes { diff --git a/src/librustuv/homing.rs b/src/librustuv/homing.rs index 16534b7b38ba..d6061088469d 100644 --- a/src/librustuv/homing.rs +++ b/src/librustuv/homing.rs @@ -126,7 +126,7 @@ pub trait HomingIO { /// task back to its appropriate home (if applicable). The field is used to /// assert that we are where we think we are. struct HomingMissile { - priv io_home: uint, + io_home: uint, } impl HomingMissile { diff --git a/src/libstd/comm/select.rs b/src/libstd/comm/select.rs index fe3fc5737888..57ea205134a7 100644 --- a/src/libstd/comm/select.rs +++ b/src/libstd/comm/select.rs @@ -95,7 +95,7 @@ pub struct Handle<'port, T> { priv port: &'port mut Port, } -struct Packets { priv cur: *mut Packet } +struct Packets { cur: *mut Packet } impl Select { /// Creates a new selection structure. This set is initially empty and diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 557e7e04ebfc..7d36d3da5613 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -122,7 +122,7 @@ struct PathSegmentAndBoundSet { } /// A path paired with optional type bounds. -struct PathAndBounds { +pub struct PathAndBounds { path: ast::Path, bounds: Option>, } diff --git a/src/test/auxiliary/iss.rs b/src/test/auxiliary/iss.rs index 85847a6fdeb2..28437c4585d8 100644 --- a/src/test/auxiliary/iss.rs +++ b/src/test/auxiliary/iss.rs @@ -13,7 +13,7 @@ // part of issue-6919.rs struct C<'a> { - k: 'a ||, + pub k: 'a ||, } fn no_op() { } diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs index 53d188962e84..c06f338f0186 100644 --- a/src/test/bench/shootout-meteor.rs +++ b/src/test/bench/shootout-meteor.rs @@ -18,8 +18,8 @@ fn iterate<'a, T>(x: T, f: 'a |&T| -> T) -> Iterate<'a, T> { Iterate {f: f, next: x} } struct Iterate<'a, T> { - priv f: 'a |&T| -> T, - priv next: T + f: 'a |&T| -> T, + next: T } impl<'a, T> Iterator for Iterate<'a, T> { fn next(&mut self) -> Option { @@ -35,7 +35,7 @@ enum List<'a, T> { Cons(T, &'a List<'a, T>) } struct ListIterator<'a, T> { - priv cur: &'a List<'a, T> + cur: &'a List<'a, T> } impl<'a, T> List<'a, T> { fn iter(&'a self) -> ListIterator<'a, T> { diff --git a/src/test/compile-fail/lint-missing-doc.rs b/src/test/compile-fail/lint-missing-doc.rs index a6440e67f9be..9d640647fe08 100644 --- a/src/test/compile-fail/lint-missing-doc.rs +++ b/src/test/compile-fail/lint-missing-doc.rs @@ -20,7 +20,7 @@ struct Foo { a: int, - priv b: int, + b: int, } pub struct PubFoo { //~ ERROR: missing documentation @@ -99,7 +99,7 @@ mod a { enum Baz { BazA { a: int, - priv b: int + b: int }, BarB } diff --git a/src/test/compile-fail/mutable-class-fields-2.rs b/src/test/compile-fail/mutable-class-fields-2.rs index 30c2b9eef8ca..377c745acf32 100644 --- a/src/test/compile-fail/mutable-class-fields-2.rs +++ b/src/test/compile-fail/mutable-class-fields-2.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, } diff --git a/src/test/compile-fail/mutable-class-fields.rs b/src/test/compile-fail/mutable-class-fields.rs index a88156a4b477..4d77d1824ab8 100644 --- a/src/test/compile-fail/mutable-class-fields.rs +++ b/src/test/compile-fail/mutable-class-fields.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, } diff --git a/src/test/compile-fail/useless-priv.rs b/src/test/compile-fail/useless-priv.rs index 3d6841c919a4..5a4dd42f49d3 100644 --- a/src/test/compile-fail/useless-priv.rs +++ b/src/test/compile-fail/useless-priv.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -struct A { pub i: int } //~ ERROR: unnecessary `pub` -struct B { priv i: int } // don't warn b/c B can still be returned +struct A { pub i: int } +struct B { priv i: int } //~ ERROR: unnecessary `priv` pub enum C { pub Variant } //~ ERROR: unnecessary `pub` enum D { priv Variant2 } //~ ERROR: unnecessary `priv` diff --git a/src/test/run-pass/class-cast-to-trait-multiple-types.rs b/src/test/run-pass/class-cast-to-trait-multiple-types.rs index 8c1427689447..10b0ac375a95 100644 --- a/src/test/run-pass/class-cast-to-trait-multiple-types.rs +++ b/src/test/run-pass/class-cast-to-trait-multiple-types.rs @@ -15,7 +15,7 @@ trait noisy { } struct dog { - priv barks: uint, + barks: uint, volume: int, } @@ -50,7 +50,7 @@ fn dog() -> dog { #[deriving(Clone)] struct cat { - priv meows: uint, + meows: uint, how_hungry: int, name: ~str, diff --git a/src/test/run-pass/class-cast-to-trait.rs b/src/test/run-pass/class-cast-to-trait.rs index 86764df6ae07..56b61dc5691d 100644 --- a/src/test/run-pass/class-cast-to-trait.rs +++ b/src/test/run-pass/class-cast-to-trait.rs @@ -15,7 +15,7 @@ trait noisy { } struct cat { - priv meows: uint, + meows: uint, how_hungry: int, name: ~str, } diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs index 918547a3a2ba..e8b35c9882f9 100644 --- a/src/test/run-pass/class-impl-very-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs @@ -27,7 +27,7 @@ impl cmp::Eq for cat_type { // ok: T should be in scope when resolving the trait ref for map struct cat { // Yes, you can have negative meows - priv meows : int, + meows : int, how_hungry : int, name : T, diff --git a/src/test/run-pass/class-implement-trait-cross-crate.rs b/src/test/run-pass/class-implement-trait-cross-crate.rs index 88051e18c30f..4c492eecd956 100644 --- a/src/test/run-pass/class-implement-trait-cross-crate.rs +++ b/src/test/run-pass/class-implement-trait-cross-crate.rs @@ -14,7 +14,7 @@ extern mod cci_class_trait; use cci_class_trait::animals::noisy; struct cat { - priv meows: uint, + meows: uint, how_hungry : int, name : ~str, diff --git a/src/test/run-pass/class-implement-traits.rs b/src/test/run-pass/class-implement-traits.rs index 433d7f7a22ff..6d5b9a9329e6 100644 --- a/src/test/run-pass/class-implement-traits.rs +++ b/src/test/run-pass/class-implement-traits.rs @@ -16,7 +16,7 @@ trait noisy { #[deriving(Clone)] struct cat { - priv meows : uint, + meows : uint, how_hungry : int, name : ~str, diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs index f5fa72e4ce51..25a2009bb9a6 100644 --- a/src/test/run-pass/class-methods.rs +++ b/src/test/run-pass/class-methods.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, } diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs index 0201501bc7c6..f4d3a115ef13 100644 --- a/src/test/run-pass/class-poly-methods.rs +++ b/src/test/run-pass/class-poly-methods.rs @@ -9,8 +9,8 @@ // except according to those terms. struct cat { - priv info : ~[U], - priv meows : uint, + info : ~[U], + meows : uint, how_hungry : int, } diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs index eb7e608a9f12..3e9765f0b2b2 100644 --- a/src/test/run-pass/class-separate-impl.rs +++ b/src/test/run-pass/class-separate-impl.rs @@ -12,7 +12,7 @@ // xfail-fast struct cat { - priv meows : uint, + meows : uint, how_hungry : int, name : ~str, diff --git a/src/test/run-pass/class-typarams.rs b/src/test/run-pass/class-typarams.rs index ab6a8b1597bf..9d4e73da8130 100644 --- a/src/test/run-pass/class-typarams.rs +++ b/src/test/run-pass/class-typarams.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, } diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs index 6e08a4db14e9..6f21afff1200 100644 --- a/src/test/run-pass/classes-simple-method.rs +++ b/src/test/run-pass/classes-simple-method.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, } diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs index 49e8f5c04e36..496efc2172e4 100644 --- a/src/test/run-pass/classes-simple.rs +++ b/src/test/run-pass/classes-simple.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, } diff --git a/src/test/run-pass/classes.rs b/src/test/run-pass/classes.rs index e5220b15520a..f65bf329823c 100644 --- a/src/test/run-pass/classes.rs +++ b/src/test/run-pass/classes.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, name : ~str, diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index 57ae7ad015f5..db1032a71375 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -47,8 +47,8 @@ struct Rect { struct AsciiArt { width: uint, height: uint, - priv fill: char, - priv lines: ~[~[char]], + fill: char, + lines: ~[~[char]], // This struct can be quite large so we'll disable copying: developers need // to either pass these structs around via references or move them. diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs index 868cbbfa8021..93872bebec98 100644 --- a/src/test/run-pass/private-class-field.rs +++ b/src/test/run-pass/private-class-field.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, } diff --git a/src/test/run-pass/private-method.rs b/src/test/run-pass/private-method.rs index 8b2b5bfa00bf..b64ca955cde6 100644 --- a/src/test/run-pass/private-method.rs +++ b/src/test/run-pass/private-method.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv meows : uint, + meows : uint, how_hungry : int, }