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