]> git.proxmox.com Git - rustc.git/blob - src/test/compile-fail/private-in-public-warn.rs
Imported Upstream version 1.9.0+dfsg1
[rustc.git] / src / test / compile-fail / private-in-public-warn.rs
1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 // Private types and traits are not allowed in public interfaces.
12 // This test also ensures that the checks are performed even inside private modules.
13
14 #![feature(rustc_attrs)]
15 #![feature(associated_consts)]
16 #![feature(associated_type_defaults)]
17 #![allow(dead_code)]
18 #![allow(unused_variables)]
19 #![allow(improper_ctypes)]
20
21 mod types {
22 struct Priv;
23 pub struct Pub;
24 pub trait PubTr {
25 type Alias;
26 }
27
28 pub type Alias = Priv; //~ WARN private type in public interface
29 //~^ WARNING hard error
30 pub enum E {
31 V1(Priv), //~ WARN private type in public interface
32 //~^ WARNING hard error
33 V2 { field: Priv }, //~ WARN private type in public interface
34 //~^ WARNING hard error
35 }
36 pub trait Tr {
37 const C: Priv = Priv; //~ WARN private type in public interface
38 //~^ WARNING hard error
39 type Alias = Priv; //~ WARN private type in public interface
40 //~^ WARNING hard error
41 fn f1(arg: Priv) {} //~ WARN private type in public interface
42 //~^ WARNING hard error
43 fn f2() -> Priv { panic!() } //~ WARN private type in public interface
44 //~^ WARNING hard error
45 }
46 extern {
47 pub static ES: Priv; //~ WARN private type in public interface
48 //~^ WARNING hard error
49 pub fn ef1(arg: Priv); //~ WARN private type in public interface
50 //~^ WARNING hard error
51 pub fn ef2() -> Priv; //~ WARN private type in public interface
52 //~^ WARNING hard error
53 }
54 impl PubTr for Pub {
55 type Alias = Priv; //~ WARN private type in public interface
56 //~^ WARNING hard error
57 }
58 }
59
60 mod traits {
61 trait PrivTr {}
62 pub struct Pub<T>(T);
63 pub trait PubTr {}
64
65 pub type Alias<T: PrivTr> = T; //~ WARN private trait in public interface
66 //~^ WARN trait bounds are not (yet) enforced in type definitions
67 //~| WARNING hard error
68 pub trait Tr1: PrivTr {} //~ WARN private trait in public interface
69 //~^ WARNING hard error
70 pub trait Tr2<T: PrivTr> {} //~ WARN private trait in public interface
71 //~^ WARNING hard error
72 pub trait Tr3 {
73 type Alias: PrivTr; //~ WARN private trait in public interface
74 //~^ WARNING hard error
75 fn f<T: PrivTr>(arg: T) {} //~ WARN private trait in public interface
76 //~^ WARNING hard error
77 }
78 impl<T: PrivTr> Pub<T> {} //~ WARN private trait in public interface
79 //~^ WARNING hard error
80 impl<T: PrivTr> PubTr for Pub<T> {} //~ WARN private trait in public interface
81 //~^ WARNING hard error
82 }
83
84 mod traits_where {
85 trait PrivTr {}
86 pub struct Pub<T>(T);
87 pub trait PubTr {}
88
89 pub type Alias<T> where T: PrivTr = T; //~ WARN private trait in public interface
90 //~^ WARNING hard error
91 pub trait Tr2<T> where T: PrivTr {} //~ WARN private trait in public interface
92 //~^ WARNING hard error
93 pub trait Tr3 {
94 fn f<T>(arg: T) where T: PrivTr {} //~ WARN private trait in public interface
95 //~^ WARNING hard error
96 }
97 impl<T> Pub<T> where T: PrivTr {} //~ WARN private trait in public interface
98 //~^ WARNING hard error
99 impl<T> PubTr for Pub<T> where T: PrivTr {} //~ WARN private trait in public interface
100 //~^ WARNING hard error
101 }
102
103 mod generics {
104 struct Priv<T = u8>(T);
105 pub struct Pub<T = u8>(T);
106 trait PrivTr<T> {}
107 pub trait PubTr<T> {}
108
109 pub trait Tr1: PrivTr<Pub> {} //~ WARN private trait in public interface
110 //~^ WARNING hard error
111 pub trait Tr2: PubTr<Priv> {} //~ WARN private type in public interface
112 //~^ WARNING hard error
113 pub trait Tr3: PubTr<[Priv; 1]> {} //~ WARN private type in public interface
114 //~^ WARNING hard error
115 pub trait Tr4: PubTr<Pub<Priv>> {} //~ WARN private type in public interface
116 //~^ WARNING hard error
117 }
118
119 mod impls {
120 struct Priv;
121 pub struct Pub;
122 trait PrivTr {
123 type Alias;
124 }
125 pub trait PubTr {
126 type Alias;
127 }
128
129 impl Priv {
130 pub fn f(arg: Priv) {} // OK
131 }
132 impl PrivTr for Priv {
133 type Alias = Priv; // OK
134 }
135 impl PubTr for Priv {
136 type Alias = Priv; // OK
137 }
138 impl PrivTr for Pub {
139 type Alias = Priv; // OK
140 }
141 impl PubTr for Pub {
142 type Alias = Priv; //~ WARN private type in public interface
143 //~^ WARNING hard error
144 }
145 }
146
147 mod impls_generics {
148 struct Priv<T = u8>(T);
149 pub struct Pub<T = u8>(T);
150 trait PrivTr<T = u8> {
151 type Alias;
152 }
153 pub trait PubTr<T = u8> {
154 type Alias;
155 }
156
157 impl Priv<Pub> {
158 pub fn f(arg: Priv) {} // OK
159 }
160 impl Pub<Priv> {
161 pub fn f(arg: Priv) {} // OK
162 }
163 impl PrivTr<Pub> for Priv {
164 type Alias = Priv; // OK
165 }
166 impl PubTr<Priv> for Priv {
167 type Alias = Priv; // OK
168 }
169 impl PubTr for Priv<Pub> {
170 type Alias = Priv; // OK
171 }
172 impl PubTr for [Priv; 1] {
173 type Alias = Priv; // OK
174 }
175 impl PubTr for Pub<Priv> {
176 type Alias = Priv; // OK
177 }
178 impl PrivTr<Pub> for Pub {
179 type Alias = Priv; // OK
180 }
181 impl PubTr<Priv> for Pub {
182 type Alias = Priv; // OK
183 }
184 }
185
186 mod aliases_pub {
187 struct Priv;
188 mod m {
189 pub struct Pub1;
190 pub struct Pub2;
191 pub struct Pub3;
192 pub trait PubTr<T = u8> {
193 type Check = u8;
194 }
195 }
196
197 use self::m::Pub1 as PrivUseAlias;
198 use self::m::PubTr as PrivUseAliasTr;
199 type PrivAlias = m::Pub2;
200 trait PrivTr {
201 type AssocAlias;
202 }
203 impl PrivTr for Priv {
204 type AssocAlias = m::Pub3;
205 }
206
207 pub fn f1(arg: PrivUseAlias) {} // OK
208
209 pub trait Tr1: PrivUseAliasTr {} // OK
210 // This should be OK, if type aliases are substituted
211 pub trait Tr2: PrivUseAliasTr<PrivAlias> {} //~ WARN private type in public interface
212 //~^ WARNING hard error
213
214 impl PrivAlias {
215 pub fn f(arg: Priv) {} //~ WARN private type in public interface
216 //~^ WARNING hard error
217 }
218 // This doesn't even parse
219 // impl <Priv as PrivTr>::AssocAlias {
220 // pub fn f(arg: Priv) {} // WARN private type in public interface
221 // }
222 impl PrivUseAliasTr for PrivUseAlias {
223 type Check = Priv; //~ WARN private type in public interface
224 //~^ WARNING hard error
225 }
226 impl PrivUseAliasTr for PrivAlias {
227 type Check = Priv; //~ WARN private type in public interface
228 //~^ WARNING hard error
229 }
230 impl PrivUseAliasTr for <Priv as PrivTr>::AssocAlias {
231 type Check = Priv; //~ WARN private type in public interface
232 //~^ WARNING hard error
233 }
234 }
235
236 mod aliases_priv {
237 struct Priv;
238
239 struct Priv1;
240 struct Priv2;
241 struct Priv3;
242 trait PrivTr1<T = u8> {
243 type Check = u8;
244 }
245
246 use self::Priv1 as PrivUseAlias;
247 use self::PrivTr1 as PrivUseAliasTr;
248 type PrivAlias = Priv2;
249 trait PrivTr {
250 type AssocAlias;
251 }
252 impl PrivTr for Priv {
253 type AssocAlias = Priv3;
254 }
255
256 pub trait Tr1: PrivUseAliasTr {} //~ WARN private trait in public interface
257 //~^ WARNING hard error
258 pub trait Tr2: PrivUseAliasTr<PrivAlias> {} //~ WARN private trait in public interface
259 //~^ WARN private type in public interface
260 //~| WARNING hard error
261 //~| WARNING hard error
262
263 impl PrivUseAlias {
264 pub fn f(arg: Priv) {} // OK
265 }
266 impl PrivAlias {
267 pub fn f(arg: Priv) {} // OK
268 }
269 // This doesn't even parse
270 // impl <Priv as PrivTr>::AssocAlias {
271 // pub fn f(arg: Priv) {} // OK
272 // }
273 impl PrivUseAliasTr for PrivUseAlias {
274 type Check = Priv; // OK
275 }
276 impl PrivUseAliasTr for PrivAlias {
277 type Check = Priv; // OK
278 }
279 impl PrivUseAliasTr for <Priv as PrivTr>::AssocAlias {
280 type Check = Priv; // OK
281 }
282 }
283
284 mod aliases_params {
285 struct Priv;
286 type PrivAliasGeneric<T = Priv> = T;
287 type Result<T> = ::std::result::Result<T, Priv>;
288 }
289
290 #[rustc_error]
291 fn main() {} //~ ERROR compilation successful