177 lines
3.6 KiB
Rust
177 lines
3.6 KiB
Rust
#![feature(lang_items, start, no_core)]
|
|
#![no_core] // makes debugging this test *a lot* easier (during resolve)
|
|
|
|
#[lang="sized"]
|
|
pub trait Sized {}
|
|
|
|
#[lang="copy"]
|
|
pub trait Copy {}
|
|
|
|
#[lang="deref"]
|
|
pub trait Deref {
|
|
type Target;
|
|
}
|
|
|
|
#[lang="receiver"]
|
|
pub trait Receiver: Deref {}
|
|
|
|
impl<'a, T> Deref for &'a T {
|
|
type Target = T;
|
|
}
|
|
|
|
impl<'a, T> Receiver for &'a T {}
|
|
|
|
mod bar {
|
|
// shouldn't bring in too much
|
|
pub use self::glob::*;
|
|
|
|
// can't publicly re-export private items
|
|
pub use self::baz::{foo, bar};
|
|
|
|
pub struct A;
|
|
impl A {
|
|
pub fn foo() {}
|
|
fn bar() {}
|
|
|
|
pub fn foo2(&self) {}
|
|
fn bar2(&self) {}
|
|
}
|
|
|
|
trait B {
|
|
fn foo() -> Self;
|
|
}
|
|
|
|
impl B for isize { fn foo() -> isize { 3 } }
|
|
|
|
pub enum Enum {
|
|
Pub
|
|
}
|
|
|
|
mod baz {
|
|
pub struct A;
|
|
impl A {
|
|
pub fn foo() {}
|
|
fn bar() {}
|
|
|
|
pub fn foo2(&self) {}
|
|
fn bar2(&self) {}
|
|
}
|
|
|
|
pub fn foo() {}
|
|
pub fn bar() {}
|
|
}
|
|
|
|
extern {
|
|
fn epriv();
|
|
pub fn epub();
|
|
}
|
|
|
|
fn test() {
|
|
self::Enum::Pub;
|
|
unsafe {
|
|
epriv();
|
|
epub();
|
|
}
|
|
self::baz::A;
|
|
self::baz::A::foo();
|
|
self::baz::A::bar(); //~ ERROR: method `bar` is private
|
|
self::baz::A.foo2();
|
|
|
|
// this used to cause an ICE in privacy traversal.
|
|
super::gpub();
|
|
}
|
|
|
|
mod glob {
|
|
pub fn gpub() {}
|
|
fn gpriv() {}
|
|
}
|
|
}
|
|
|
|
pub fn gpub() {}
|
|
|
|
fn lol() {
|
|
bar::A;
|
|
bar::A::foo();
|
|
bar::A::bar(); //~ ERROR: method `bar` is private
|
|
bar::A.foo2();
|
|
}
|
|
|
|
mod foo {
|
|
fn test() {
|
|
::bar::A::foo();
|
|
::bar::A::bar(); //~ ERROR: method `bar` is private
|
|
::bar::A.foo2();
|
|
::bar::baz::A::foo(); //~ ERROR: module `baz` is private
|
|
::bar::baz::A::bar(); //~ ERROR: module `baz` is private
|
|
//~^ ERROR: method `bar` is private
|
|
::bar::baz::A.foo2(); //~ ERROR: module `baz` is private
|
|
::bar::baz::A.bar2(); //~ ERROR: module `baz` is private
|
|
//~^ ERROR: method `bar2` is private
|
|
|
|
let _: isize =
|
|
::bar::B::foo(); //~ ERROR: trait `B` is private
|
|
::lol();
|
|
|
|
::bar::Enum::Pub;
|
|
|
|
unsafe {
|
|
::bar::epriv(); //~ ERROR: function `epriv` is private
|
|
::bar::epub();
|
|
}
|
|
|
|
::bar::foo();
|
|
::bar::bar();
|
|
|
|
::bar::gpub();
|
|
|
|
::bar::baz::foo(); //~ ERROR: module `baz` is private
|
|
::bar::baz::bar(); //~ ERROR: module `baz` is private
|
|
}
|
|
|
|
fn test2() {
|
|
use bar::baz::{foo, bar};
|
|
//~^ ERROR: module `baz` is private
|
|
//~| ERROR: module `baz` is private
|
|
|
|
foo();
|
|
bar();
|
|
}
|
|
|
|
fn test3() {
|
|
use bar::baz;
|
|
//~^ ERROR: module `baz` is private
|
|
}
|
|
|
|
fn test4() {
|
|
use bar::{foo, bar};
|
|
foo();
|
|
bar();
|
|
}
|
|
|
|
fn test5() {
|
|
use bar;
|
|
bar::foo();
|
|
bar::bar();
|
|
}
|
|
|
|
impl ::bar::B for f32 { fn foo() -> f32 { 1.0 } }
|
|
//~^ ERROR: trait `B` is private
|
|
}
|
|
|
|
pub mod mytest {
|
|
// Even though the inner `A` struct is a publicly exported item (usable from
|
|
// external crates through `foo::foo`, it should not be accessible through
|
|
// its definition path (which has the private `i` module).
|
|
use self::foo::i::A; //~ ERROR: module `i` is private
|
|
|
|
pub mod foo {
|
|
pub use self::i::A as foo;
|
|
|
|
mod i {
|
|
pub struct A;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 }
|