Improve tests

src/test/compile-fail/struct-field-privacy.rs

@@ -25,9 +25,10 @@ mod inner {
  pub a: isize,
  b: isize,
  }
+ pub struct Z(pub isize, isize);
 }
 
-fn test(a: A, b: inner::A, c: inner::B, d: xc::A, e: xc::B) {
+fn test(a: A, b: inner::A, c: inner::B, d: xc::A, e: xc::B, z: inner::Z) {
  a.a;
  b.a; //~ ERROR: field `a` of struct `inner::A` is private
  b.b;
@@ -39,6 +40,9 @@ fn test(a: A, b: inner::A, c: inner::B, d: xc::A, e: xc::B) {
 
  e.a;
  e.b; //~ ERROR: field `b` of struct `xc::B` is private
+
+ z.0;
+ z.1; //~ ERROR: field `1` of struct `inner::Z` is private
 }
 
 fn main() {}

src/test/compile-fail/autoderef-privacy.rs → src/test/run-pass/autoderef-privacy.rs

@@ -10,40 +10,51 @@
 
 // Check we do not select a private method or field when computing autoderefs
 
-#![feature(rustc_attrs)]
 #![allow(unused)]
 
+#[derive(Default)]
 pub struct Bar2 { i: i32 }
+#[derive(Default)]
 pub struct Baz2(i32);
 
 impl Bar2 {
- fn f(&self) {}
+ fn f(&self) -> bool { true }
 }
 
 mod foo {
- pub struct Bar { i: i32 }
- pub struct Baz(i32);
+ #[derive(Default)]
+ pub struct Bar { i: ::Bar2 }
+ #[derive(Default)]
+ pub struct Baz(::Baz2);
 
  impl Bar {
- fn f(&self) {}
+ fn f(&self) -> bool { false }
  }
 
  impl ::std::ops::Deref for Bar {
  type Target = ::Bar2;
- fn deref(&self) -> &::Bar2 { unimplemented!() }
+ fn deref(&self) -> &::Bar2 { &self.i }
  }
 
  impl ::std::ops::Deref for Baz {
  type Target = ::Baz2;
- fn deref(&self) -> &::Baz2 { unimplemented!() }
+ fn deref(&self) -> &::Baz2 { &self.0 }
  }
-}
 
-fn f(bar: foo::Bar, baz: foo::Baz) {
- let _ = bar.i;
- let _ = baz.0;
- let _ = bar.f();
+ pub fn f(bar: &Bar, baz: &Baz) {
+ // Since the private fields and methods are visible here, there should be no autoderefs.
+ let _: &::Bar2 = &bar.i;
+ let _: &::Baz2 = &baz.0;
+ assert!(!bar.f());
+ }
 }
 
-#[rustc_error]
-fn main() {} //~ ERROR compilation successful
+fn main() {
+ let bar = foo::Bar::default();
+ let baz = foo::Baz::default();
+ foo::f(&bar, &baz);
+
+ let _: i32 = bar.i;
+ let _: i32 = baz.0;
+ assert!(bar.f());
+}