From 683197975c119e4c03588fa729dee4f87902f534 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Mon, 31 Mar 2014 18:13:44 -0700 Subject: [PATCH 1/2] rustc: Switch tuple structs to have private fields This is a continuation of the work done in #13184 to make struct fields private by default. This commit finishes RFC 4 by making all tuple structs have private fields by default. Note that enum variants are not affected. A tuple struct having a private field means that it cannot be matched on in a pattern match (both refutable and irrefutable), and it also cannot have a value specified to be constructed. Similarly to private fields, switching the type of a private field in a tuple struct should be able to be done in a backwards compatible way. The one snag that I ran into which wasn't mentioned in the RFC is that this commit also forbids taking the value of a tuple struct constructor. For example, this code now fails to compile: mod a { pub struct A(int); } let a: fn(int) -> a::A = a::A; //~ ERROR: first field is private Although no fields are bound in this example, it exposes implementation details through the type itself. For this reason, taking the value of a struct constructor with private fields is forbidden (outside the containing module). RFC: 0004-private-fields --- src/librustc/metadata/csearch.rs | 8 ++ src/librustc/metadata/decoder.rs | 11 +- src/librustc/middle/privacy.rs | 119 ++++++++++++++---- src/libsyntax/ast.rs | 12 +- src/test/auxiliary/privacy-tuple-struct.rs | 14 +++ src/test/compile-fail/privacy5.rs | 137 +++++++++++++++++++++ 6 files changed, 270 insertions(+), 31 deletions(-) create mode 100644 src/test/auxiliary/privacy-tuple-struct.rs create mode 100644 src/test/compile-fail/privacy5.rs diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index d840ca329387d..8845a2acbd614 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -311,3 +311,11 @@ pub fn get_exported_macros(cstore: &cstore::CStore, let cdata = cstore.get_crate_data(crate_num); decoder::get_exported_macros(cdata) } + +pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore, + def_id: ast::DefId) + -> Option +{ + let cdata = cstore.get_crate_data(def_id.krate); + decoder::get_tuple_struct_definition_if_ctor(cdata, def_id.node) +} diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 94941913a8b88..300b8ff2da4c5 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -962,23 +962,26 @@ pub fn get_static_methods_if_impl(intr: Rc, /// If node_id is the constructor of a tuple struct, retrieve the NodeId of /// the actual type definition, otherwise, return None pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd, - node_id: ast::NodeId) -> Option { + node_id: ast::NodeId) + -> Option +{ let item = lookup_item(node_id, cdata.data()); let mut ret = None; reader::tagged_docs(item, tag_items_data_item_is_tuple_struct_ctor, |_| { ret = Some(item_reqd_and_translated_parent_item(cdata.cnum, item)); false }); - ret.map(|x| x.node) + ret } pub fn get_item_attrs(cdata: Cmd, - node_id: ast::NodeId, + orig_node_id: ast::NodeId, f: |Vec<@ast::MetaItem> |) { // The attributes for a tuple struct are attached to the definition, not the ctor; // we assume that someone passing in a tuple struct ctor is actually wanting to // look at the definition - let node_id = get_tuple_struct_definition_if_ctor(cdata, node_id).unwrap_or(node_id); + let node_id = get_tuple_struct_definition_if_ctor(cdata, orig_node_id); + let node_id = node_id.map(|x| x.node).unwrap_or(orig_node_id); let item = lookup_item(node_id, cdata.data()); reader::tagged_docs(item, tag_attributes, |attributes| { reader::tagged_docs(attributes, tag_attribute, |attribute| { diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index e5644dbd246f4..9d9faee36450a 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -14,6 +14,7 @@ use std::mem::replace; +use metadata::csearch; use middle::lint; use middle::resolve; use middle::ty; @@ -358,6 +359,12 @@ enum PrivacyResult { DisallowedBy(ast::NodeId), } +enum FieldName { + UnnamedField(uint), // index + // FIXME #6993: change type (and name) from Ident to Name + NamedField(ast::Ident), +} + impl<'a> PrivacyVisitor<'a> { // used when debugging fn nodestr(&self, id: ast::NodeId) -> ~str { @@ -560,18 +567,23 @@ 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) { - for field in ty::lookup_struct_fields(self.tcx, id).iter() { - if field.name != ident.name { continue; } - if 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", - token::get_ident(ident))) + fn check_field(&mut self, span: Span, id: ast::DefId, + name: FieldName) { + let fields = ty::lookup_struct_fields(self.tcx, id); + let field = match name { + NamedField(ident) => { + fields.iter().find(|f| f.name == ident.name).unwrap() } - break; + UnnamedField(idx) => fields.get(idx) + }; + if field.vis == ast::Public { return } + if !is_local(field.id) || !self.private_accessible(field.id.node) { + let msg = match name { + NamedField(name) => format!("field `{}` is private", + token::get_ident(name)), + UnnamedField(idx) => format!("field \\#{} is private", idx + 1), + }; + self.tcx.sess.span_err(span, msg); } } @@ -634,10 +646,11 @@ impl<'a> PrivacyVisitor<'a> { _ => {}, } } - // If an import is not used in either namespace, we still want to check - // that it could be legal. Therefore we check in both namespaces and only - // report an error if both would be illegal. We only report one error, - // even if it is illegal to import from both namespaces. + // If an import is not used in either namespace, we still + // want to check that it could be legal. Therefore we check + // in both namespaces and only report an error if both would + // be illegal. We only report one error, even if it is + // illegal to import from both namespaces. match (value_priv, check_value, type_priv, check_type) { (Some(p), resolve::Unused, None, _) | (None, _, Some(p), resolve::Unused) => { @@ -701,7 +714,8 @@ impl<'a> PrivacyVisitor<'a> { // is whether the trait itself is accessible or not. MethodParam(MethodParam { trait_id: trait_id, .. }) | MethodObject(MethodObject { trait_id: trait_id, .. }) => { - self.report_error(self.ensure_public(span, trait_id, None, "source trait")); + self.report_error(self.ensure_public(span, trait_id, None, + "source trait")); } } } @@ -726,7 +740,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { match ty::get(ty::expr_ty_adjusted(self.tcx, base, &*self.method_map.borrow())).sty { ty::ty_struct(id, _) => { - self.check_field(expr.span, id, ident); + self.check_field(expr.span, id, NamedField(ident)); } _ => {} } @@ -749,7 +763,8 @@ 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, + NamedField(field.ident.node)); } } ty::ty_enum(_, _) => { @@ -757,7 +772,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { ast::DefVariant(_, variant_id, _) => { for field in fields.iter() { self.check_field(expr.span, variant_id, - field.ident.node); + NamedField(field.ident.node)); } } _ => self.tcx.sess.span_bug(expr.span, @@ -772,6 +787,46 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { struct type?!"), } } + ast::ExprPath(..) => { + let guard = |did: ast::DefId| { + let fields = ty::lookup_struct_fields(self.tcx, did); + let any_priv = fields.iter().any(|f| { + f.vis != ast::Public && ( + !is_local(f.id) || + !self.private_accessible(f.id.node)) + }); + if any_priv { + self.tcx.sess.span_err(expr.span, + "cannot invoke tuple struct constructor \ + with private fields"); + } + }; + match self.tcx.def_map.borrow().find(&expr.id) { + Some(&ast::DefStruct(did)) => { + guard(if is_local(did) { + local_def(self.tcx.map.get_parent(did.node)) + } else { + // "tuple structs" with zero fields (such as + // `pub struct Foo;`) don't have a ctor_id, hence + // the unwrap_or to the same struct id. + let maybe_did = + csearch::get_tuple_struct_definition_if_ctor( + &self.tcx.sess.cstore, did); + maybe_did.unwrap_or(did) + }) + } + // Tuple struct constructors across crates are identified as + // DefFn types, so we explicitly handle that case here. + Some(&ast::DefFn(did, _)) if !is_local(did) => { + match csearch::get_tuple_struct_definition_if_ctor( + &self.tcx.sess.cstore, did) { + Some(did) => guard(did), + None => {} + } + } + _ => {} + } + } _ => {} } @@ -821,7 +876,8 @@ 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, + NamedField(field.ident)); } } ty::ty_enum(_, _) => { @@ -829,7 +885,7 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { Some(&ast::DefVariant(_, variant_id, _)) => { for field in fields.iter() { self.check_field(pattern.span, variant_id, - field.ident); + NamedField(field.ident)); } } _ => self.tcx.sess.span_bug(pattern.span, @@ -844,6 +900,27 @@ impl<'a> Visitor<()> for PrivacyVisitor<'a> { struct type?!"), } } + + // Patterns which bind no fields are allowable (the path is check + // elsewhere). + ast::PatEnum(_, Some(ref fields)) => { + match ty::get(ty::pat_ty(self.tcx, pattern)).sty { + ty::ty_struct(id, _) => { + for (i, field) in fields.iter().enumerate() { + match field.node { + ast::PatWild(..) => continue, + _ => {} + } + self.check_field(field.span, id, UnnamedField(i)); + } + } + ty::ty_enum(..) => { + // enum fields have no privacy at this time + } + _ => {} + } + + } _ => {} } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 3a9cdfb56e32a..0f082c7e2f1f9 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -493,10 +493,10 @@ pub enum Expr_ { ExprVstore(@Expr, ExprVstore), // First expr is the place; second expr is the value. ExprBox(@Expr, @Expr), - ExprVec(Vec<@Expr> , Mutability), - ExprCall(@Expr, Vec<@Expr> ), - ExprMethodCall(Ident, Vec> , Vec<@Expr> ), - ExprTup(Vec<@Expr> ), + ExprVec(Vec<@Expr>, Mutability), + ExprCall(@Expr, Vec<@Expr>), + ExprMethodCall(Ident, Vec>, Vec<@Expr>), + ExprTup(Vec<@Expr>), ExprBinary(BinOp, @Expr, @Expr), ExprUnary(UnOp, @Expr), ExprLit(@Lit), @@ -508,14 +508,14 @@ pub enum Expr_ { // Conditionless loop (can be exited with break, cont, or ret) // FIXME #6993: change to Option ExprLoop(P, Option), - ExprMatch(@Expr, Vec ), + ExprMatch(@Expr, Vec), ExprFnBlock(P, P), ExprProc(P, P), ExprBlock(P), ExprAssign(@Expr, @Expr), ExprAssignOp(BinOp, @Expr, @Expr), - ExprField(@Expr, Ident, Vec> ), + ExprField(@Expr, Ident, Vec>), ExprIndex(@Expr, @Expr), /// Expression that looks like a "name". For example, diff --git a/src/test/auxiliary/privacy-tuple-struct.rs b/src/test/auxiliary/privacy-tuple-struct.rs new file mode 100644 index 0000000000000..2fb9d9923cb76 --- /dev/null +++ b/src/test/auxiliary/privacy-tuple-struct.rs @@ -0,0 +1,14 @@ +// 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. + +pub struct A(()); +pub struct B(int); +pub struct C(pub int, int); +pub struct D(pub int); diff --git a/src/test/compile-fail/privacy5.rs b/src/test/compile-fail/privacy5.rs new file mode 100644 index 0000000000000..c057236265e94 --- /dev/null +++ b/src/test/compile-fail/privacy5.rs @@ -0,0 +1,137 @@ +// 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:privacy-tuple-struct.rs +// ignore-fast + +extern crate other = "privacy-tuple-struct"; + +mod a { + pub struct A(()); + pub struct B(int); + pub struct C(pub int, int); + pub struct D(pub int); + + fn test() { + let a = A(()); + let b = B(2); + let c = C(2, 3); + let d = D(4); + + let A(()) = a; + let A(_) = a; + match a { A(()) => {} } + match a { A(_) => {} } + + let B(_) = b; + let B(_b) = b; + match b { B(_) => {} } + match b { B(_b) => {} } + match b { B(1) => {} B(_) => {} } + + let C(_, _) = c; + let C(_a, _) = c; + let C(_, _b) = c; + let C(_a, _b) = c; + match c { C(_, _) => {} } + match c { C(_a, _) => {} } + match c { C(_, _b) => {} } + match c { C(_a, _b) => {} } + + let D(_) = d; + let D(_d) = d; + match d { D(_) => {} } + match d { D(_d) => {} } + match d { D(1) => {} D(_) => {} } + + let a2 = A; + let b2 = B; + let c2 = C; + let d2 = D; + } +} + +fn this_crate() { + let a = a::A(()); //~ ERROR: cannot invoke tuple struct constructor + let b = a::B(2); //~ ERROR: cannot invoke tuple struct constructor + let c = a::C(2, 3); //~ ERROR: cannot invoke tuple struct constructor + let d = a::D(4); + + let a::A(()) = a; //~ ERROR: field #1 is private + let a::A(_) = a; + match a { a::A(()) => {} } //~ ERROR: field #1 is private + match a { a::A(_) => {} } + + let a::B(_) = b; + let a::B(_b) = b; //~ ERROR: field #1 is private + match b { a::B(_) => {} } + match b { a::B(_b) => {} } //~ ERROR: field #1 is private + match b { a::B(1) => {} a::B(_) => {} } //~ ERROR: field #1 is private + + let a::C(_, _) = c; + let a::C(_a, _) = c; + let a::C(_, _b) = c; //~ ERROR: field #2 is private + let a::C(_a, _b) = c; //~ ERROR: field #2 is private + match c { a::C(_, _) => {} } + match c { a::C(_a, _) => {} } + match c { a::C(_, _b) => {} } //~ ERROR: field #2 is private + match c { a::C(_a, _b) => {} } //~ ERROR: field #2 is private + + let a::D(_) = d; + let a::D(_d) = d; + match d { a::D(_) => {} } + match d { a::D(_d) => {} } + match d { a::D(1) => {} a::D(_) => {} } + + let a2 = a::A; //~ ERROR: cannot invoke tuple struct constructor + let b2 = a::B; //~ ERROR: cannot invoke tuple struct constructor + let c2 = a::C; //~ ERROR: cannot invoke tuple struct constructor + let d2 = a::D; +} + +fn xcrate() { + let a = other::A(()); //~ ERROR: cannot invoke tuple struct constructor + let b = other::B(2); //~ ERROR: cannot invoke tuple struct constructor + let c = other::C(2, 3); //~ ERROR: cannot invoke tuple struct constructor + let d = other::D(4); + + let other::A(()) = a; //~ ERROR: field #1 is private + let other::A(_) = a; + match a { other::A(()) => {} } //~ ERROR: field #1 is private + match a { other::A(_) => {} } + + let other::B(_) = b; + let other::B(_b) = b; //~ ERROR: field #1 is private + match b { other::B(_) => {} } + match b { other::B(_b) => {} } //~ ERROR: field #1 is private + match b { other::B(1) => {} other::B(_) => {} } //~ ERROR: field #1 is private + + let other::C(_, _) = c; + let other::C(_a, _) = c; + let other::C(_, _b) = c; //~ ERROR: field #2 is private + let other::C(_a, _b) = c; //~ ERROR: field #2 is private + match c { other::C(_, _) => {} } + match c { other::C(_a, _) => {} } + match c { other::C(_, _b) => {} } //~ ERROR: field #2 is private + match c { other::C(_a, _b) => {} } //~ ERROR: field #2 is private + + let other::D(_) = d; + let other::D(_d) = d; + match d { other::D(_) => {} } + match d { other::D(_d) => {} } + match d { other::D(1) => {} other::D(_) => {} } + + let a2 = other::A; //~ ERROR: cannot invoke tuple struct constructor + let b2 = other::B; //~ ERROR: cannot invoke tuple struct constructor + let c2 = other::C; //~ ERROR: cannot invoke tuple struct constructor + let d2 = other::D; +} + +fn main() {} From 922dcfdc6950f4d68d3334199de5572eef52b75a Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Mon, 31 Mar 2014 19:01:01 -0700 Subject: [PATCH 2/2] Switch some tuple structs to pub fields This commit deals with the fallout of the previous change by making tuples structs have public fields where necessary (now that the fields are private by default). --- src/librand/distributions/exponential.rs | 2 +- src/librand/distributions/normal.rs | 2 +- src/librand/lib.rs | 4 +-- src/librustc/middle/graph.rs | 4 +-- src/librustc/middle/trans/basic_block.rs | 2 +- src/librustc/middle/trans/value.rs | 2 +- src/librustc/middle/ty.rs | 6 ++--- src/librustc/middle/typeck/infer/coercion.rs | 2 +- src/librustc/middle/typeck/infer/glb.rs | 2 +- src/librustc/middle/typeck/infer/lub.rs | 2 +- src/librustc/middle/typeck/infer/sub.rs | 2 +- src/librustdoc/html/escape.rs | 2 +- src/librustdoc/html/format.rs | 6 ++--- src/librustdoc/html/markdown.rs | 4 +-- src/libstd/rt/task.rs | 2 +- src/libstd/unstable/simd.rs | 28 +++++++++++++------- src/libsyntax/ast_map.rs | 2 +- src/libsyntax/codemap.rs | 4 +-- src/test/auxiliary/issue-11508.rs | 2 +- src/test/auxiliary/issue-11529.rs | 2 +- src/test/auxiliary/issue-7899.rs | 2 +- src/test/auxiliary/issue_10031_aux.rs | 2 +- src/test/auxiliary/issue_2472_b.rs | 2 +- src/test/auxiliary/lint_stability.rs | 14 +++++----- src/test/auxiliary/newtype_struct_xc.rs | 2 +- 25 files changed, 56 insertions(+), 48 deletions(-) diff --git a/src/librand/distributions/exponential.rs b/src/librand/distributions/exponential.rs index 5a6b925c53fdb..8b609875dbd9e 100644 --- a/src/librand/distributions/exponential.rs +++ b/src/librand/distributions/exponential.rs @@ -28,7 +28,7 @@ use distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample}; /// Generate Normal Random /// Samples*](http://www.doornik.com/research/ziggurat.pdf). Nuffield /// College, Oxford -pub struct Exp1(f64); +pub struct Exp1(pub f64); // This could be done via `-rng.gen::().ln()` but that is slower. impl Rand for Exp1 { diff --git a/src/librand/distributions/normal.rs b/src/librand/distributions/normal.rs index 42fb76ad4eb48..85132de41c3cb 100644 --- a/src/librand/distributions/normal.rs +++ b/src/librand/distributions/normal.rs @@ -27,7 +27,7 @@ use distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample}; /// Generate Normal Random /// Samples*](http://www.doornik.com/research/ziggurat.pdf). Nuffield /// College, Oxford -pub struct StandardNormal(f64); +pub struct StandardNormal(pub f64); impl Rand for StandardNormal { fn rand(rng: &mut R) -> StandardNormal { diff --git a/src/librand/lib.rs b/src/librand/lib.rs index d9920501ab071..e75ed1d67a6d0 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -658,7 +658,7 @@ pub fn random() -> T { /// let Open01(val) = random::>(); /// println!("f32 from (0,1): {}", val); /// ``` -pub struct Open01(F); +pub struct Open01(pub F); /// A wrapper for generating floating point numbers uniformly in the /// closed interval `[0,1]` (including both endpoints). @@ -674,7 +674,7 @@ pub struct Open01(F); /// let Closed01(val) = random::>(); /// println!("f32 from [0,1]: {}", val); /// ``` -pub struct Closed01(F); +pub struct Closed01(pub F); #[cfg(test)] mod test { diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index fd27cabaf7fba..88301967a8cca 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -54,11 +54,11 @@ pub struct Edge { } #[deriving(Eq)] -pub struct NodeIndex(uint); +pub struct NodeIndex(pub uint); pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX); #[deriving(Eq)] -pub struct EdgeIndex(uint); +pub struct EdgeIndex(pub uint); pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX); // Use a private field here to guarantee no more instances are created: diff --git a/src/librustc/middle/trans/basic_block.rs b/src/librustc/middle/trans/basic_block.rs index 074c9f4fec515..303ad5fbce2ce 100644 --- a/src/librustc/middle/trans/basic_block.rs +++ b/src/librustc/middle/trans/basic_block.rs @@ -12,7 +12,7 @@ use lib::llvm::{llvm, BasicBlockRef}; use middle::trans::value::{Users, Value}; use std::iter::{Filter, Map}; -pub struct BasicBlock(BasicBlockRef); +pub struct BasicBlock(pub BasicBlockRef); pub type Preds<'a> = Map<'a, Value, BasicBlock, Filter<'a, Value, Users>>; diff --git a/src/librustc/middle/trans/value.rs b/src/librustc/middle/trans/value.rs index f66a393a50f9d..1efb47ad42fb5 100644 --- a/src/librustc/middle/trans/value.rs +++ b/src/librustc/middle/trans/value.rs @@ -13,7 +13,7 @@ use middle::trans::basic_block::BasicBlock; use middle::trans::common::Block; use std::libc::c_uint; -pub struct Value(ValueRef); +pub struct Value(pub ValueRef); macro_rules! opt_val ( ($e:expr) => ( unsafe { diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 8a616496f064d..9a3064268dcb2 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -869,13 +869,13 @@ impl CLike for BuiltinBound { } #[deriving(Clone, Eq, TotalEq, Hash)] -pub struct TyVid(uint); +pub struct TyVid(pub uint); #[deriving(Clone, Eq, TotalEq, Hash)] -pub struct IntVid(uint); +pub struct IntVid(pub uint); #[deriving(Clone, Eq, TotalEq, Hash)] -pub struct FloatVid(uint); +pub struct FloatVid(pub uint); #[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] pub struct RegionVid { diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs index 5dc55ab4b5c07..a9a0e4b7b3736 100644 --- a/src/librustc/middle/typeck/infer/coercion.rs +++ b/src/librustc/middle/typeck/infer/coercion.rs @@ -83,7 +83,7 @@ use syntax::ast; // Note: Coerce is not actually a combiner, in that it does not // conform to the same interface, though it performs a similar // function. -pub struct Coerce<'f>(CombineFields<'f>); +pub struct Coerce<'f>(pub CombineFields<'f>); impl<'f> Coerce<'f> { pub fn get_ref<'a>(&'a self) -> &'a CombineFields<'f> { diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index e846e3621bd46..83fc315bcebc8 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -28,7 +28,7 @@ use collections::HashMap; use util::common::{indenter}; use util::ppaux::mt_to_str; -pub struct Glb<'f>(CombineFields<'f>); // "greatest lower bound" (common subtype) +pub struct Glb<'f>(pub CombineFields<'f>); // "greatest lower bound" (common subtype) impl<'f> Glb<'f> { pub fn get_ref<'a>(&'a self) -> &'a CombineFields<'f> { let Glb(ref v) = *self; v } diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs index e63ad7322b9ae..7c302c7201405 100644 --- a/src/librustc/middle/typeck/infer/lub.rs +++ b/src/librustc/middle/typeck/infer/lub.rs @@ -27,7 +27,7 @@ use syntax::ast::{ExternFn, ImpureFn, UnsafeFn}; use syntax::ast::{Onceness, Purity}; use util::ppaux::mt_to_str; -pub struct Lub<'f>(CombineFields<'f>); // least-upper-bound: common supertype +pub struct Lub<'f>(pub CombineFields<'f>); // least-upper-bound: common supertype impl<'f> Lub<'f> { pub fn get_ref<'a>(&'a self) -> &'a CombineFields<'f> { let Lub(ref v) = *self; v } diff --git a/src/librustc/middle/typeck/infer/sub.rs b/src/librustc/middle/typeck/infer/sub.rs index ef17a59365484..b22e6f4677bd7 100644 --- a/src/librustc/middle/typeck/infer/sub.rs +++ b/src/librustc/middle/typeck/infer/sub.rs @@ -27,7 +27,7 @@ use util::ppaux::bound_region_to_str; use syntax::ast::{Onceness, Purity}; -pub struct Sub<'f>(CombineFields<'f>); // "subtype", "subregion" etc +pub struct Sub<'f>(pub CombineFields<'f>); // "subtype", "subregion" etc impl<'f> Sub<'f> { pub fn get_ref<'a>(&'a self) -> &'a CombineFields<'f> { let Sub(ref v) = *self; v } diff --git a/src/librustdoc/html/escape.rs b/src/librustdoc/html/escape.rs index bb6b1eeaedd5e..60fcbe33a1be9 100644 --- a/src/librustdoc/html/escape.rs +++ b/src/librustdoc/html/escape.rs @@ -17,7 +17,7 @@ use std::fmt; /// Wrapper struct which will emit the HTML-escaped version of the contained /// string when passed to a format string. -pub struct Escape<'a>(&'a str); +pub struct Escape<'a>(pub &'a str); impl<'a> fmt::Show for Escape<'a> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index acf6446a191f1..10c155262c31e 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -28,12 +28,12 @@ use html::render::{cache_key, current_location_key}; /// Helper to render an optional visibility with a space after it (if the /// visibility is preset) -pub struct VisSpace(Option); +pub struct VisSpace(pub Option); /// Similarly to VisSpace, this structure is used to render a purity with a /// space after it. -pub struct PuritySpace(ast::Purity); +pub struct PuritySpace(pub ast::Purity); /// Wrapper struct for properly emitting a method declaration. -pub struct Method<'a>(&'a clean::SelfTy, &'a clean::FnDecl); +pub struct Method<'a>(pub &'a clean::SelfTy, pub &'a clean::FnDecl); impl VisSpace { pub fn get(&self) -> Option { diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index c52a6267657b3..ff2462cfb22ba 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -42,10 +42,10 @@ use html::highlight; /// A unit struct which has the `fmt::Show` trait implemented. When /// formatted, this struct will emit the HTML corresponding to the rendered /// version of the contained markdown string. -pub struct Markdown<'a>(&'a str); +pub struct Markdown<'a>(pub &'a str); /// A unit struct like `Markdown`, that renders the markdown with a /// table of contents. -pub struct MarkdownWithToc<'a>(&'a str); +pub struct MarkdownWithToc<'a>(pub &'a str); static OUTPUT_UNIT: libc::size_t = 64; static MKDEXT_NO_INTRA_EMPHASIS: libc::c_uint = 1 << 0; diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index d9700ea998018..d36452653e396 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -58,7 +58,7 @@ pub struct Task { } pub struct GarbageCollector; -pub struct LocalStorage(Option); +pub struct LocalStorage(pub Option); /// A handle to a blocked task. Usually this means having the ~Task pointer by /// ownership, but if the task is killable, a killer can steal it at any time. diff --git a/src/libstd/unstable/simd.rs b/src/libstd/unstable/simd.rs index 01200833b195d..a7a314d35e736 100644 --- a/src/libstd/unstable/simd.rs +++ b/src/libstd/unstable/simd.rs @@ -14,40 +14,48 @@ #[experimental] #[simd] -pub struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8); +pub struct i8x16(pub i8, pub i8, pub i8, pub i8, + pub i8, pub i8, pub i8, pub i8, + pub i8, pub i8, pub i8, pub i8, + pub i8, pub i8, pub i8, pub i8); #[experimental] #[simd] -pub struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16); +pub struct i16x8(pub i16, pub i16, pub i16, pub i16, + pub i16, pub i16, pub i16, pub i16); #[experimental] #[simd] -pub struct i32x4(i32, i32, i32, i32); +pub struct i32x4(pub i32, pub i32, pub i32, pub i32); #[experimental] #[simd] -pub struct i64x2(i64, i64); +pub struct i64x2(pub i64, pub i64); #[experimental] #[simd] -pub struct u8x16(u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8); +pub struct u8x16(pub u8, pub u8, pub u8, pub u8, + pub u8, pub u8, pub u8, pub u8, + pub u8, pub u8, pub u8, pub u8, + pub u8, pub u8, pub u8, pub u8); #[experimental] #[simd] -pub struct u16x8(u16, u16, u16, u16, u16, u16, u16, u16); +pub struct u16x8(pub u16, pub u16, pub u16, pub u16, + pub u16, pub u16, pub u16, pub u16); #[experimental] #[simd] -pub struct u32x4(u32, u32, u32, u32); +pub struct u32x4(pub u32, pub u32, pub u32, pub u32); #[experimental] #[simd] -pub struct u64x2(u64, u64); +pub struct u64x2(pub u64, pub u64); #[experimental] #[simd] -pub struct f32x4(f32, f32, f32, f32); +pub struct f32x4(pub f32, pub f32, pub f32, pub f32); #[experimental] #[simd] -pub struct f64x2(f64, f64); +pub struct f64x2(pub f64, pub f64); diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index f07b0e71c1ce1..d380c1aca100c 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -66,7 +66,7 @@ impl<'a> Iterator for LinkedPath<'a> { // HACK(eddyb) move this into libstd (value wrapper for slice::Items). #[deriving(Clone)] -pub struct Values<'a, T>(slice::Items<'a, T>); +pub struct Values<'a, T>(pub slice::Items<'a, T>); impl<'a, T: Copy> Iterator for Values<'a, T> { fn next(&mut self) -> Option { diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 0d2492d7fad0f..7cadce5476594 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -33,13 +33,13 @@ pub trait Pos { /// A byte offset. Keep this small (currently 32-bits), as AST contains /// a lot of them. #[deriving(Clone, Eq, TotalEq, Hash, Ord, Show)] -pub struct BytePos(u32); +pub struct BytePos(pub u32); /// A character offset. Because of multibyte utf8 characters, a byte offset /// is not equivalent to a character offset. The CodeMap will convert BytePos /// values to CharPos values as necessary. #[deriving(Eq, Hash, Ord, Show)] -pub struct CharPos(uint); +pub struct CharPos(pub uint); // FIXME: Lots of boilerplate in these impls, but so far my attempts to fix // have been unsuccessful diff --git a/src/test/auxiliary/issue-11508.rs b/src/test/auxiliary/issue-11508.rs index dfdde5e5e4e03..c5dc3439f2f8d 100644 --- a/src/test/auxiliary/issue-11508.rs +++ b/src/test/auxiliary/issue-11508.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub struct Closed01(F); +pub struct Closed01(pub F); pub trait Bar { fn new() -> Self; } diff --git a/src/test/auxiliary/issue-11529.rs b/src/test/auxiliary/issue-11529.rs index 9d5005324010e..a8a4c438e6734 100644 --- a/src/test/auxiliary/issue-11529.rs +++ b/src/test/auxiliary/issue-11529.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub struct A<'a>(&'a int); +pub struct A<'a>(pub &'a int); diff --git a/src/test/auxiliary/issue-7899.rs b/src/test/auxiliary/issue-7899.rs index f1a0fcffd1658..e197e84442b10 100644 --- a/src/test/auxiliary/issue-7899.rs +++ b/src/test/auxiliary/issue-7899.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub struct V2(T, T); +pub struct V2(pub T, pub T); diff --git a/src/test/auxiliary/issue_10031_aux.rs b/src/test/auxiliary/issue_10031_aux.rs index 5724d876ef43d..f0f1af2e3a3da 100644 --- a/src/test/auxiliary/issue_10031_aux.rs +++ b/src/test/auxiliary/issue_10031_aux.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub struct Wrap(A); +pub struct Wrap(pub A); diff --git a/src/test/auxiliary/issue_2472_b.rs b/src/test/auxiliary/issue_2472_b.rs index 1475b1a75a665..5f55476427fe2 100644 --- a/src/test/auxiliary/issue_2472_b.rs +++ b/src/test/auxiliary/issue_2472_b.rs @@ -9,7 +9,7 @@ // except according to those terms. -pub struct S(()); +pub struct S(pub ()); impl S { pub fn foo(&self) { } diff --git a/src/test/auxiliary/lint_stability.rs b/src/test/auxiliary/lint_stability.rs index 30224912d9265..5afbf4492b30d 100644 --- a/src/test/auxiliary/lint_stability.rs +++ b/src/test/auxiliary/lint_stability.rs @@ -161,15 +161,15 @@ pub enum Enum { } #[deprecated] -pub struct DeprecatedTupleStruct(int); +pub struct DeprecatedTupleStruct(pub int); #[experimental] -pub struct ExperimentalTupleStruct(int); +pub struct ExperimentalTupleStruct(pub int); #[unstable] -pub struct UnstableTupleStruct(int); -pub struct UnmarkedTupleStruct(int); +pub struct UnstableTupleStruct(pub int); +pub struct UnmarkedTupleStruct(pub int); #[stable] -pub struct StableTupleStruct(int); +pub struct StableTupleStruct(pub int); #[frozen] -pub struct FrozenTupleStruct(int); +pub struct FrozenTupleStruct(pub int); #[locked] -pub struct LockedTupleStruct(int); +pub struct LockedTupleStruct(pub int); diff --git a/src/test/auxiliary/newtype_struct_xc.rs b/src/test/auxiliary/newtype_struct_xc.rs index 3833b549b5fc0..60c64842c7146 100644 --- a/src/test/auxiliary/newtype_struct_xc.rs +++ b/src/test/auxiliary/newtype_struct_xc.rs @@ -10,4 +10,4 @@ #[crate_type="lib"]; -pub struct Au(int); +pub struct Au(pub int);