Enable privacy check for enum methods.

michaelwoerister · michaelwoerister · commit 2c9922aa491f · 2013-08-07T14:30:00.000+02:00
diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
@@ -403,6 +403,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                     // Ditto
                     match ty::get(ty::type_autoderef(tcx, ty::expr_ty(tcx,
                                                           base))).sty {
+                        ty_enum(id, _) |
                         ty_struct(id, _)
                         if id.crate != LOCAL_CRATE ||
                            !privileged_items.iter().any(|x| x == &(id.node)) => {
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
@@ -417,12 +417,12 @@ pub enum MapChain<K,V> {
 // get the map from an env frame
 impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
     // Constructor. I don't think we need a zero-arg one.
-    fn new(init: ~HashMap<K,@V>) -> @mut MapChain<K,V> {
+    pub fn new(init: ~HashMap<K,@V>) -> @mut MapChain<K,V> {
         @mut BaseMapChain(init)
     }
 
     // add a new frame to the environment (functionally)
-    fn push_frame (@mut self) -> @mut MapChain<K,V> {
+    pub fn push_frame (@mut self) -> @mut MapChain<K,V> {
         @mut ConsMapChain(~HashMap::new() ,self)
     }
 
@@ -432,7 +432,7 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
 
     // ugh: can't get this to compile with mut because of the
     // lack of flow sensitivity.
-    fn get_map<'a>(&'a self) -> &'a HashMap<K,@V> {
+    pub fn get_map<'a>(&'a self) -> &'a HashMap<K,@V> {
         match *self {
             BaseMapChain (~ref map) => map,
             ConsMapChain (~ref map,_) => map
@@ -442,7 +442,7 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
 // traits just don't work anywhere...?
 //impl Map<Name,SyntaxExtension> for MapChain {
 
-    fn contains_key (&self, key: &K) -> bool {
+    pub fn contains_key (&self, key: &K) -> bool {
         match *self {
             BaseMapChain (ref map) => map.contains_key(key),
             ConsMapChain (ref map,ref rest) =>
@@ -453,17 +453,17 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
     // should each_key and each_value operate on shadowed
     // names? I think not.
     // delaying implementing this....
-    fn each_key (&self, _f: &fn (&K)->bool) {
+    pub fn each_key (&self, _f: &fn (&K)->bool) {
         fail!("unimplemented 2013-02-15T10:01");
     }
 
-    fn each_value (&self, _f: &fn (&V) -> bool) {
+    pub fn each_value (&self, _f: &fn (&V) -> bool) {
         fail!("unimplemented 2013-02-15T10:02");
     }
 
     // Returns a copy of the value that the name maps to.
     // Goes down the chain 'til it finds one (or bottom out).
-    fn find (&self, key: &K) -> Option<@V> {
+    pub fn find (&self, key: &K) -> Option<@V> {
         match self.get_map().find (key) {
             Some(ref v) => Some(**v),
             None => match *self {
@@ -473,7 +473,7 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
         }
     }
 
-    fn find_in_topmost_frame(&self, key: &K) -> Option<@V> {
+    pub fn find_in_topmost_frame(&self, key: &K) -> Option<@V> {
         let map = match *self {
             BaseMapChain(ref map) => map,
             ConsMapChain(ref map,_) => map
@@ -483,7 +483,7 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
     }
 
     // insert the binding into the top-level map
-    fn insert (&mut self, key: K, ext: @V) -> bool {
+    pub fn insert (&mut self, key: K, ext: @V) -> bool {
         // can't abstract over get_map because of flow sensitivity...
         match *self {
             BaseMapChain (~ref mut map) => map.insert(key, ext),
@@ -495,7 +495,7 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
     // ... there are definitely some opportunities for abstraction
     // here that I'm ignoring. (e.g., manufacturing a predicate on
     // the maps in the chain, and using an abstract "find".
-    fn insert_into_frame(&mut self, key: K, ext: @V, n: K, pred: &fn(&@V)->bool) {
+    pub fn insert_into_frame(&mut self, key: K, ext: @V, n: K, pred: &fn(&@V)->bool) {
         match *self {
             BaseMapChain (~ref mut map) => {
                 if satisfies_pred(map,&n,pred) {
diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs
@@ -36,7 +36,7 @@ pub fn from<T>(t: ~[T]) -> OptVec<T> {
 }
 
 impl<T> OptVec<T> {
-    fn push(&mut self, t: T) {
+    pub fn push(&mut self, t: T) {
         match *self {
             Vec(ref mut v) => {
                 v.push(t);
@@ -50,52 +50,52 @@ impl<T> OptVec<T> {
         *self = Vec(~[t]);
     }
 
-    fn map<U>(&self, op: &fn(&T) -> U) -> OptVec<U> {
+    pub fn map<U>(&self, op: &fn(&T) -> U) -> OptVec<U> {
         match *self {
             Empty => Empty,
             Vec(ref v) => Vec(v.map(op))
         }
     }
 
-    fn map_consume<U>(self, op: &fn(T) -> U) -> OptVec<U> {
+    pub fn map_consume<U>(self, op: &fn(T) -> U) -> OptVec<U> {
         match self {
             Empty => Empty,
             Vec(v) => Vec(v.consume_iter().transform(op).collect())
         }
     }
 
-    fn get<'a>(&'a self, i: uint) -> &'a T {
+    pub fn get<'a>(&'a self, i: uint) -> &'a T {
         match *self {
             Empty => fail!("Invalid index %u", i),
             Vec(ref v) => &v[i]
         }
     }
 
-    fn is_empty(&self) -> bool {
+    pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
-    fn len(&self) -> uint {
+    pub fn len(&self) -> uint {
         match *self {
             Empty => 0,
             Vec(ref v) => v.len()
         }
     }
 
     #[inline]
-    fn iter<'r>(&'r self) -> OptVecIterator<'r, T> {
+    pub fn iter<'r>(&'r self) -> OptVecIterator<'r, T> {
         match *self {
             Empty => OptVecIterator{iter: None},
             Vec(ref v) => OptVecIterator{iter: Some(v.iter())}
         }
     }
 
     #[inline]
-    fn map_to_vec<B>(&self, op: &fn(&T) -> B) -> ~[B] {
+    pub fn map_to_vec<B>(&self, op: &fn(&T) -> B) -> ~[B] {
         self.iter().transform(op).collect()
     }
 
-    fn mapi_to_vec<B>(&self, op: &fn(uint, &T) -> B) -> ~[B] {
+    pub fn mapi_to_vec<B>(&self, op: &fn(uint, &T) -> B) -> ~[B] {
         let mut index = 0;
         self.map_to_vec(|a| {
             let i = index;
@@ -113,7 +113,7 @@ pub fn take_vec<T>(v: OptVec<T>) -> ~[T] {
 }
 
 impl<T:Clone> OptVec<T> {
-    fn prepend(&self, t: T) -> OptVec<T> {
+    pub fn prepend(&self, t: T) -> OptVec<T> {
         let mut v0 = ~[t];
         match *self {
             Empty => {}
@@ -124,7 +124,7 @@ impl<T:Clone> OptVec<T> {
 }
 
 impl<A:Eq> Eq for OptVec<A> {
-    fn eq(&self, other: &OptVec<A>) -> bool {
+    pub fn eq(&self, other: &OptVec<A>) -> bool {
         // Note: cannot use #[deriving(Eq)] here because
         // (Empty, Vec(~[])) ought to be equal.
         match (self, other) {
@@ -135,7 +135,7 @@ impl<A:Eq> Eq for OptVec<A> {
         }
     }
 
-    fn ne(&self, other: &OptVec<A>) -> bool {
+    pub fn ne(&self, other: &OptVec<A>) -> bool {
         !self.eq(other)
     }
 }
diff --git a/src/test/auxiliary/xc_private_method_lib.rs b/src/test/auxiliary/xc_private_method_lib.rs
@@ -1,9 +1,33 @@
 #[crate_type="lib"];
 
-pub struct Foo {
+pub struct Struct {
     x: int
 }
 
-impl Foo {
-    fn new() -> Foo { Foo { x: 1 } }
+impl Struct {
+    fn static_meth_struct() -> Struct {
+        Struct { x: 1 }
+    }
+
+    fn meth_struct(&self) -> int {
+        self.x
+    }
+}
+
+pub enum Enum {
+    Variant1(int),
+    Variant2(int)
+}
+
+impl Enum {
+    fn static_meth_enum() -> Enum {
+        Variant2(10)
+    }
+
+    fn meth_enum(&self) -> int {
+        match *self {
+            Variant1(x) |
+            Variant2(x) => x
+        }
+    }
 }
diff --git a/src/test/compile-fail/xc-private-method.rs b/src/test/compile-fail/xc-private-method.rs
@@ -4,5 +4,13 @@
 extern mod xc_private_method_lib;
 
 fn main() {
-    let _ = xc_private_method_lib::Foo::new();  //~ ERROR function `new` is private
+    // normal method on struct
+    let _ = xc_private_method_lib::Struct{ x: 10 }.meth_struct();  //~ ERROR method `meth_struct` is private
+    // static method on struct
+    let _ = xc_private_method_lib::Struct::static_meth_struct();  //~ ERROR function `static_meth_struct` is private
+
+    // normal method on enum
+    let _ = xc_private_method_lib::Variant1(20).meth_enum();  //~ ERROR method `meth_enum` is private
+    // static method on enum
+    let _ = xc_private_method_lib::Enum::static_meth_enum();  //~ ERROR function `static_meth_enum` is private
 }

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ pub fn from<T>(t: ~[T]) -> OptVec<T> {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`impl<T> OptVec<T> {`
`39`		`- fn push(&mut self, t: T) {`
	`39`	`+ pub fn push(&mut self, t: T) {`
`40`	`40`	`match *self {`
`41`	`41`	`Vec(ref mut v) => {`
`42`	`42`	`v.push(t);`
`@@ -50,52 +50,52 @@ impl<T> OptVec<T> {`
`50`	`50`	`*self = Vec(~[t]);`
`51`	`51`	`}`
`52`	`52`
`53`		`- fn map<U>(&self, op: &fn(&T) -> U) -> OptVec<U> {`
	`53`	`+ pub fn map<U>(&self, op: &fn(&T) -> U) -> OptVec<U> {`
`54`	`54`	`match *self {`
`55`	`55`	`Empty => Empty,`
`56`	`56`	`Vec(ref v) => Vec(v.map(op))`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`- fn map_consume<U>(self, op: &fn(T) -> U) -> OptVec<U> {`
	`60`	`+ pub fn map_consume<U>(self, op: &fn(T) -> U) -> OptVec<U> {`
`61`	`61`	`match self {`
`62`	`62`	`Empty => Empty,`
`63`	`63`	`Vec(v) => Vec(v.consume_iter().transform(op).collect())`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`		`- fn get<'a>(&'a self, i: uint) -> &'a T {`
	`67`	`+ pub fn get<'a>(&'a self, i: uint) -> &'a T {`
`68`	`68`	`match *self {`
`69`	`69`	`Empty => fail!("Invalid index %u", i),`
`70`	`70`	`Vec(ref v) => &v[i]`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`- fn is_empty(&self) -> bool {`
	`74`	`+ pub fn is_empty(&self) -> bool {`
`75`	`75`	`self.len() == 0`
`76`	`76`	`}`
`77`	`77`
`78`		`- fn len(&self) -> uint {`
	`78`	`+ pub fn len(&self) -> uint {`
`79`	`79`	`match *self {`
`80`	`80`	`Empty => 0,`
`81`	`81`	`Vec(ref v) => v.len()`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`#[inline]`
`86`		`- fn iter<'r>(&'r self) -> OptVecIterator<'r, T> {`
	`86`	`+ pub fn iter<'r>(&'r self) -> OptVecIterator<'r, T> {`
`87`	`87`	`match *self {`
`88`	`88`	`Empty => OptVecIterator{iter: None},`
`89`	`89`	`Vec(ref v) => OptVecIterator{iter: Some(v.iter())}`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`#[inline]`
`94`		`- fn map_to_vec<B>(&self, op: &fn(&T) -> B) -> ~[B] {`
	`94`	`+ pub fn map_to_vec<B>(&self, op: &fn(&T) -> B) -> ~[B] {`
`95`	`95`	`self.iter().transform(op).collect()`
`96`	`96`	`}`
`97`	`97`
`98`		`- fn mapi_to_vec<B>(&self, op: &fn(uint, &T) -> B) -> ~[B] {`
	`98`	`+ pub fn mapi_to_vec<B>(&self, op: &fn(uint, &T) -> B) -> ~[B] {`
`99`	`99`	`let mut index = 0;`
`100`	`100`	`self.map_to_vec(\|a\| {`
`101`	`101`	`let i = index;`
`@@ -113,7 +113,7 @@ pub fn take_vec<T>(v: OptVec<T>) -> ~[T] {`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`impl<T:Clone> OptVec<T> {`
`116`		`- fn prepend(&self, t: T) -> OptVec<T> {`
	`116`	`+ pub fn prepend(&self, t: T) -> OptVec<T> {`
`117`	`117`	`let mut v0 = ~[t];`
`118`	`118`	`match *self {`
`119`	`119`	`Empty => {}`
`@@ -124,7 +124,7 @@ impl<T:Clone> OptVec<T> {`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`impl<A:Eq> Eq for OptVec<A> {`
`127`		`- fn eq(&self, other: &OptVec<A>) -> bool {`
	`127`	`+ pub fn eq(&self, other: &OptVec<A>) -> bool {`
`128`	`128`	`// Note: cannot use #[deriving(Eq)] here because`
`129`	`129`	`// (Empty, Vec(~[])) ought to be equal.`
`130`	`130`	`match (self, other) {`
`@@ -135,7 +135,7 @@ impl<A:Eq> Eq for OptVec<A> {`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`138`		`- fn ne(&self, other: &OptVec<A>) -> bool {`
	`138`	`+ pub fn ne(&self, other: &OptVec<A>) -> bool {`
`139`	`139`	`!self.eq(other)`
`140`	`140`	`}`
`141`	`141`	`}`