]> git.lizzy.rs Git - rust.git/blob - src/test/ui/privacy/private-in-public-warn.rs
Rollup merge of #100861 - RalfJung:const-ice, r=oli-obk
[rust.git] / src / test / ui / privacy / private-in-public-warn.rs
1 // Private types and traits are not allowed in public interfaces.
2 // This test also ensures that the checks are performed even inside private modules.
3
4 #![feature(associated_type_defaults)]
5 #![deny(private_in_public)]
6 #![allow(improper_ctypes)]
7
8 mod types {
9     struct Priv;
10     pub struct Pub;
11     pub trait PubTr {
12         type Alias;
13     }
14
15     pub type Alias = Priv; //~ ERROR private type `types::Priv` in public interface
16     //~^ WARNING hard error
17     pub enum E {
18         V1(Priv), //~ ERROR private type `types::Priv` in public interface
19         //~^ WARNING hard error
20         V2 { field: Priv }, //~ ERROR private type `types::Priv` in public interface
21         //~^ WARNING hard error
22     }
23     pub trait Tr {
24         const C: Priv = Priv; //~ ERROR private type `types::Priv` in public interface
25         //~^ WARNING hard error
26         type Alias = Priv; //~ ERROR private type `types::Priv` in public interface
27         fn f1(arg: Priv) {} //~ ERROR private type `types::Priv` in public interface
28         //~^ WARNING hard error
29         fn f2() -> Priv { panic!() } //~ ERROR private type `types::Priv` in public interface
30         //~^ WARNING hard error
31     }
32     extern "C" {
33         pub static ES: Priv; //~ ERROR private type `types::Priv` in public interface
34         //~^ WARNING hard error
35         pub fn ef1(arg: Priv); //~ ERROR private type `types::Priv` in public interface
36         //~^ WARNING hard error
37         pub fn ef2() -> Priv; //~ ERROR private type `types::Priv` in public interface
38         //~^ WARNING hard error
39     }
40     impl PubTr for Pub {
41         type Alias = Priv; //~ ERROR private type `types::Priv` in public interface
42     }
43 }
44
45 mod traits {
46     trait PrivTr {}
47     pub struct Pub<T>(T);
48     pub trait PubTr {}
49
50     pub type Alias<T: PrivTr> = T; //~ ERROR private trait `traits::PrivTr` in public interface
51     //~| WARNING hard error
52     //~| WARNING bounds on generic parameters are not enforced in type aliases
53     pub trait Tr1: PrivTr {} //~ ERROR private trait `traits::PrivTr` in public interface
54     //~^ WARNING hard error
55     pub trait Tr2<T: PrivTr> {} //~ ERROR private trait `traits::PrivTr` in public interface
56         //~^ WARNING hard error
57     pub trait Tr3 {
58         type Alias: PrivTr;
59         //~^ ERROR private trait `traits::PrivTr` in public interface
60         //~| WARNING hard error
61         fn f<T: PrivTr>(arg: T) {} //~ ERROR private trait `traits::PrivTr` in public interface
62         //~^ WARNING hard error
63     }
64     impl<T: PrivTr> Pub<T> {} //~ ERROR private trait `traits::PrivTr` in public interface
65         //~^ WARNING hard error
66     impl<T: PrivTr> PubTr for Pub<T> {} // OK, trait impl predicates
67 }
68
69 mod traits_where {
70     trait PrivTr {}
71     pub struct Pub<T>(T);
72     pub trait PubTr {}
73
74     pub type Alias<T> where T: PrivTr = T;
75         //~^ ERROR private trait `traits_where::PrivTr` in public interface
76         //~| WARNING hard error
77         //~| WARNING where clauses are not enforced in type aliases
78     pub trait Tr2<T> where T: PrivTr {}
79         //~^ ERROR private trait `traits_where::PrivTr` in public interface
80         //~| WARNING hard error
81     pub trait Tr3 {
82         fn f<T>(arg: T) where T: PrivTr {}
83         //~^ ERROR private trait `traits_where::PrivTr` in public interface
84         //~| WARNING hard error
85     }
86     impl<T> Pub<T> where T: PrivTr {}
87         //~^ ERROR private trait `traits_where::PrivTr` in public interface
88         //~| WARNING hard error
89     impl<T> PubTr for Pub<T> where T: PrivTr {} // OK, trait impl predicates
90 }
91
92 mod generics {
93     struct Priv<T = u8>(T);
94     pub struct Pub<T = u8>(T);
95     trait PrivTr<T> {}
96     pub trait PubTr<T> {}
97
98     pub trait Tr1: PrivTr<Pub> {}
99         //~^ ERROR private trait `generics::PrivTr<generics::Pub>` in public interface
100         //~| WARNING hard error
101     pub trait Tr2: PubTr<Priv> {} //~ ERROR private type `generics::Priv` in public interface
102         //~^ WARNING hard error
103     pub trait Tr3: PubTr<[Priv; 1]> {} //~ ERROR private type `generics::Priv` in public interface
104         //~^ WARNING hard error
105     pub trait Tr4: PubTr<Pub<Priv>> {} //~ ERROR private type `generics::Priv` in public interface
106         //~^ WARNING hard error
107 }
108
109 mod impls {
110     struct Priv;
111     pub struct Pub;
112     trait PrivTr {
113         type Alias;
114     }
115     pub trait PubTr {
116         type Alias;
117     }
118
119     impl Priv {
120         pub fn f(arg: Priv) {} // OK
121     }
122     impl PrivTr for Priv {
123         type Alias = Priv; // OK
124     }
125     impl PubTr for Priv {
126         type Alias = Priv; // OK
127     }
128     impl PrivTr for Pub {
129         type Alias = Priv; // OK
130     }
131     impl PubTr for Pub {
132         type Alias = Priv; //~ ERROR private type `impls::Priv` in public interface
133     }
134 }
135
136 mod impls_generics {
137     struct Priv<T = u8>(T);
138     pub struct Pub<T = u8>(T);
139     trait PrivTr<T = u8> {
140         type Alias;
141     }
142     pub trait PubTr<T = u8> {
143         type Alias;
144     }
145
146     impl Priv<Pub> {
147         pub fn f(arg: Priv) {} // OK
148     }
149     impl Pub<Priv> {
150         pub fn f(arg: Priv) {} // OK
151     }
152     impl PrivTr<Pub> for Priv {
153         type Alias = Priv; // OK
154     }
155     impl PubTr<Priv> for Priv {
156         type Alias = Priv; // OK
157     }
158     impl PubTr for Priv<Pub> {
159         type Alias = Priv; // OK
160     }
161     impl PubTr for [Priv; 1] {
162         type Alias = Priv; // OK
163     }
164     impl PubTr for Pub<Priv> {
165         type Alias = Priv; // OK
166     }
167     impl PrivTr<Pub> for Pub {
168         type Alias = Priv; // OK
169     }
170     impl PubTr<Priv> for Pub {
171         type Alias = Priv; // OK
172     }
173 }
174
175 mod aliases_pub {
176     struct Priv;
177     mod m {
178         pub struct Pub1;
179         pub struct Pub2;
180         pub struct Pub3;
181         pub trait PubTr<T = u8> {
182             type Check = u8;
183         }
184     }
185
186     use self::m::Pub1 as PrivUseAlias;
187     use self::m::PubTr as PrivUseAliasTr;
188     type PrivAlias = m::Pub2;
189     trait PrivTr {
190         type AssocAlias;
191     }
192     impl PrivTr for Priv {
193         type AssocAlias = m::Pub3;
194     }
195
196     pub fn f1(arg: PrivUseAlias) {} // OK
197     pub fn f2(arg: PrivAlias) {} // OK
198
199     pub trait Tr1: PrivUseAliasTr {} // OK
200     pub trait Tr2: PrivUseAliasTr<PrivAlias> {} // OK
201
202     impl PrivAlias {
203         pub fn f(arg: Priv) {} //~ ERROR private type `aliases_pub::Priv` in public interface
204         //~^ WARNING hard error
205     }
206     impl PrivUseAliasTr for PrivUseAlias {
207         type Check = Priv; //~ ERROR private type `aliases_pub::Priv` in public interface
208     }
209     impl PrivUseAliasTr for PrivAlias {
210         type Check = Priv; //~ ERROR private type `aliases_pub::Priv` in public interface
211     }
212     impl PrivUseAliasTr for <Priv as PrivTr>::AssocAlias {
213         type Check = Priv; //~ ERROR private type `aliases_pub::Priv` in public interface
214     }
215     impl PrivUseAliasTr for Option<<Priv as PrivTr>::AssocAlias> {
216         type Check = Priv; //~ ERROR private type `aliases_pub::Priv` in public interface
217     }
218     impl PrivUseAliasTr for (<Priv as PrivTr>::AssocAlias, Priv) {
219         type Check = Priv; // OK
220     }
221     impl PrivUseAliasTr for Option<(<Priv as PrivTr>::AssocAlias, Priv)> {
222         type Check = Priv; // OK
223     }
224 }
225
226 mod aliases_priv {
227     struct Priv;
228
229     struct Priv1;
230     struct Priv2;
231     struct Priv3;
232     trait PrivTr1<T = u8> {
233         type Check = u8;
234     }
235
236     use self::Priv1 as PrivUseAlias;
237     use self::PrivTr1 as PrivUseAliasTr;
238     type PrivAlias = Priv2;
239     trait PrivTr {
240         type AssocAlias;
241     }
242     impl PrivTr for Priv {
243         type AssocAlias = Priv3;
244     }
245
246     pub trait Tr1: PrivUseAliasTr {}
247         //~^ ERROR private trait `PrivTr1` in public interface
248         //~| WARNING hard error
249     pub trait Tr2: PrivUseAliasTr<PrivAlias> {}
250         //~^ ERROR private trait `PrivTr1<Priv2>` in public interface
251         //~| WARNING hard error
252         //~| ERROR private type `Priv2` in public interface
253         //~| WARNING hard error
254
255     impl PrivUseAlias {
256         pub fn f(arg: Priv) {} // OK
257     }
258     impl PrivAlias {
259         pub fn f(arg: Priv) {} // OK
260     }
261     impl PrivUseAliasTr for PrivUseAlias {
262         type Check = Priv; // OK
263     }
264     impl PrivUseAliasTr for PrivAlias {
265         type Check = Priv; // OK
266     }
267     impl PrivUseAliasTr for <Priv as PrivTr>::AssocAlias {
268         type Check = Priv; // OK
269     }
270 }
271
272 mod aliases_params {
273     struct Priv;
274     type PrivAliasGeneric<T = Priv> = T;
275     type Result<T> = ::std::result::Result<T, Priv>;
276
277     pub fn f1(arg: PrivAliasGeneric<u8>) {} // OK, not an error
278 }
279
280 fn main() {}