src/test/compile-fail/lint-stability.rs

   1 // Copyright 2013-2014 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 // aux-build:lint_stability.rs
  12 // aux-build:inherited_stability.rs
  13 // aux-build:stability_cfg1.rs
  14 // aux-build:stability_cfg2.rs
  15
  16 #![feature(globs)]
  17 #![deny(unstable)]
  18 #![deny(deprecated)]
  19 #![deny(experimental)]
  20 #![allow(dead_code)]
  21
  22 #[macro_use]
  23 extern crate lint_stability; //~ ERROR: use of unmarked item
  24
  25 mod cross_crate {
  26     extern crate stability_cfg1;
  27     extern crate stability_cfg2; //~ ERROR: use of experimental item
  28
  29     use lint_stability::*;
  30
  31     fn test() {
  32         let foo = MethodTester;
  33
  34         deprecated(); //~ ERROR use of deprecated item
  35         foo.method_deprecated(); //~ ERROR use of deprecated item
  36         foo.trait_deprecated(); //~ ERROR use of deprecated item
  37
  38         deprecated_text(); //~ ERROR use of deprecated item: text
  39         foo.method_deprecated_text(); //~ ERROR use of deprecated item: text
  40         foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
  41
  42         experimental(); //~ ERROR use of experimental item
  43         foo.method_experimental(); //~ ERROR use of experimental item
  44         foo.trait_experimental(); //~ ERROR use of experimental item
  45
  46         experimental_text(); //~ ERROR use of experimental item: text
  47         foo.method_experimental_text(); //~ ERROR use of experimental item: text
  48         foo.trait_experimental_text(); //~ ERROR use of experimental item: text
  49
  50         unstable(); //~ ERROR use of unstable item
  51         foo.method_unstable(); //~ ERROR use of unstable item
  52         foo.trait_unstable(); //~ ERROR use of unstable item
  53
  54         unstable_text(); //~ ERROR use of unstable item: text
  55         foo.method_unstable_text(); //~ ERROR use of unstable item: text
  56         foo.trait_unstable_text(); //~ ERROR use of unstable item: text
  57
  58         unmarked(); //~ ERROR use of unmarked item
  59         foo.method_unmarked(); //~ ERROR use of unmarked item
  60         foo.trait_unmarked(); //~ ERROR use of unmarked item
  61
  62         stable();
  63         foo.method_stable();
  64         foo.trait_stable();
  65
  66         stable_text();
  67         foo.method_stable_text();
  68         foo.trait_stable_text();
  69
  70         frozen();
  71         foo.method_frozen();
  72         foo.trait_frozen();
  73
  74         frozen_text();
  75         foo.method_frozen_text();
  76         foo.trait_frozen_text();
  77
  78         locked();
  79         foo.method_locked();
  80         foo.trait_locked();
  81
  82         locked_text();
  83         foo.method_locked_text();
  84         foo.trait_locked_text();
  85
  86         let _ = DeprecatedStruct { i: 0 }; //~ ERROR use of deprecated item
  87         let _ = ExperimentalStruct { i: 0 }; //~ ERROR use of experimental item
  88         let _ = UnstableStruct { i: 0 }; //~ ERROR use of unstable item
  89         let _ = UnmarkedStruct { i: 0 }; //~ ERROR use of unmarked item
  90         let _ = StableStruct { i: 0 };
  91         let _ = FrozenStruct { i: 0 };
  92         let _ = LockedStruct { i: 0 };
  93
  94         let _ = DeprecatedUnitStruct; //~ ERROR use of deprecated item
  95         let _ = ExperimentalUnitStruct; //~ ERROR use of experimental item
  96         let _ = UnstableUnitStruct; //~ ERROR use of unstable item
  97         let _ = UnmarkedUnitStruct; //~ ERROR use of unmarked item
  98         let _ = StableUnitStruct;
  99         let _ = FrozenUnitStruct;
 100         let _ = LockedUnitStruct;
 101
 102         let _ = Enum::DeprecatedVariant; //~ ERROR use of deprecated item
 103         let _ = Enum::ExperimentalVariant; //~ ERROR use of experimental item
 104         let _ = Enum::UnstableVariant; //~ ERROR use of unstable item
 105         let _ = Enum::UnmarkedVariant; //~ ERROR use of unmarked item
 106         let _ = Enum::StableVariant;
 107         let _ = Enum::FrozenVariant;
 108         let _ = Enum::LockedVariant;
 109
 110         let _ = DeprecatedTupleStruct (1); //~ ERROR use of deprecated item
 111         let _ = ExperimentalTupleStruct (1); //~ ERROR use of experimental item
 112         let _ = UnstableTupleStruct (1); //~ ERROR use of unstable item
 113         let _ = UnmarkedTupleStruct (1); //~ ERROR use of unmarked item
 114         let _ = StableTupleStruct (1);
 115         let _ = FrozenTupleStruct (1);
 116         let _ = LockedTupleStruct (1);
 117
 118         // At the moment, the lint checker only checks stability in
 119         // in the arguments of macros.
 120         // Eventually, we will want to lint the contents of the
 121         // macro in the module *defining* it. Also, stability levels
 122         // on macros themselves are not yet linted.
 123         macro_test!();
 124         macro_test_arg!(deprecated_text()); //~ ERROR use of deprecated item: text
 125         macro_test_arg!(macro_test_arg!(deprecated_text())); //~ ERROR use of deprecated item: text
 126         macro_test_arg_nested!(deprecated_text);
 127     }
 128
 129     fn test_method_param<F: Trait>(foo: F) {
 130         foo.trait_deprecated(); //~ ERROR use of deprecated item
 131         foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
 132         foo.trait_experimental(); //~ ERROR use of experimental item
 133         foo.trait_experimental_text(); //~ ERROR use of experimental item: text
 134         foo.trait_unstable(); //~ ERROR use of unstable item
 135         foo.trait_unstable_text(); //~ ERROR use of unstable item: text
 136         foo.trait_unmarked(); //~ ERROR use of unmarked item
 137         foo.trait_stable();
 138     }
 139
 140     fn test_method_object(foo: &Trait) {
 141         foo.trait_deprecated(); //~ ERROR use of deprecated item
 142         foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
 143         foo.trait_experimental(); //~ ERROR use of experimental item
 144         foo.trait_experimental_text(); //~ ERROR use of experimental item: text
 145         foo.trait_unstable(); //~ ERROR use of unstable item
 146         foo.trait_unstable_text(); //~ ERROR use of unstable item: text
 147         foo.trait_unmarked(); //~ ERROR use of unmarked item
 148         foo.trait_stable();
 149     }
 150
 151     struct S;
 152
 153     impl ExperimentalTrait for S { } //~ ERROR use of experimental item
 154
 155     trait LocalTrait : ExperimentalTrait { } //~ ERROR use of experimental item
 156 }
 157
 158 mod inheritance {
 159     extern crate inherited_stability; //~ ERROR: use of experimental item
 160     use self::inherited_stability::*;
 161
 162     fn test_inheritance() {
 163         experimental(); //~ ERROR use of experimental item
 164         stable();
 165
 166         stable_mod::experimental(); //~ ERROR use of experimental item
 167         stable_mod::stable();
 168
 169         unstable_mod::experimental(); //~ ERROR use of experimental item
 170         unstable_mod::unstable(); //~ ERROR use of unstable item
 171
 172         experimental_mod::experimental(); //~ ERROR use of experimental item
 173         experimental_mod::stable();
 174
 175         let _ = Experimental::ExperimentalVariant; //~ ERROR use of experimental item
 176         let _ = Experimental::StableVariant;
 177
 178         let x: uint = 0;
 179         x.experimental(); //~ ERROR use of experimental item
 180         x.stable();
 181     }
 182 }
 183
 184 mod this_crate {
 185     #[deprecated]
 186     pub fn deprecated() {}
 187     #[deprecated="text"]
 188     pub fn deprecated_text() {}
 189
 190     #[experimental]
 191     pub fn experimental() {}
 192     #[experimental="text"]
 193     pub fn experimental_text() {}
 194
 195     #[unstable]
 196     pub fn unstable() {}
 197     #[unstable="text"]
 198     pub fn unstable_text() {}
 199
 200     pub fn unmarked() {}
 201
 202     #[stable]
 203     pub fn stable() {}
 204     #[stable="text"]
 205     pub fn stable_text() {}
 206
 207     #[locked]
 208     pub fn locked() {}
 209     #[locked="text"]
 210     pub fn locked_text() {}
 211
 212     #[frozen]
 213     pub fn frozen() {}
 214     #[frozen="text"]
 215     pub fn frozen_text() {}
 216
 217     #[stable]
 218     pub struct MethodTester;
 219
 220     impl MethodTester {
 221         #[deprecated]
 222         pub fn method_deprecated(&self) {}
 223         #[deprecated="text"]
 224         pub fn method_deprecated_text(&self) {}
 225
 226         #[experimental]
 227         pub fn method_experimental(&self) {}
 228         #[experimental="text"]
 229         pub fn method_experimental_text(&self) {}
 230
 231         #[unstable]
 232         pub fn method_unstable(&self) {}
 233         #[unstable="text"]
 234         pub fn method_unstable_text(&self) {}
 235
 236         pub fn method_unmarked(&self) {}
 237
 238         #[stable]
 239         pub fn method_stable(&self) {}
 240         #[stable="text"]
 241         pub fn method_stable_text(&self) {}
 242
 243         #[locked]
 244         pub fn method_locked(&self) {}
 245         #[locked="text"]
 246         pub fn method_locked_text(&self) {}
 247
 248         #[frozen]
 249         pub fn method_frozen(&self) {}
 250         #[frozen="text"]
 251         pub fn method_frozen_text(&self) {}
 252     }
 253
 254     pub trait Trait {
 255         #[deprecated]
 256         fn trait_deprecated(&self) {}
 257         #[deprecated="text"]
 258         fn trait_deprecated_text(&self) {}
 259
 260         #[experimental]
 261         fn trait_experimental(&self) {}
 262         #[experimental="text"]
 263         fn trait_experimental_text(&self) {}
 264
 265         #[unstable]
 266         fn trait_unstable(&self) {}
 267         #[unstable="text"]
 268         fn trait_unstable_text(&self) {}
 269
 270         fn trait_unmarked(&self) {}
 271
 272         #[stable]
 273         fn trait_stable(&self) {}
 274         #[stable="text"]
 275         fn trait_stable_text(&self) {}
 276
 277         #[locked]
 278         fn trait_locked(&self) {}
 279         #[locked="text"]
 280         fn trait_locked_text(&self) {}
 281
 282         #[frozen]
 283         fn trait_frozen(&self) {}
 284         #[frozen="text"]
 285         fn trait_frozen_text(&self) {}
 286     }
 287
 288     impl Trait for MethodTester {}
 289
 290     #[deprecated]
 291     pub struct DeprecatedStruct { i: int }
 292     #[experimental]
 293     pub struct ExperimentalStruct { i: int }
 294     #[unstable]
 295     pub struct UnstableStruct { i: int }
 296     pub struct UnmarkedStruct { i: int }
 297     #[stable]
 298     pub struct StableStruct { i: int }
 299     #[frozen]
 300     pub struct FrozenStruct { i: int }
 301     #[locked]
 302     pub struct LockedStruct { i: int }
 303
 304     #[deprecated]
 305     pub struct DeprecatedUnitStruct;
 306     #[experimental]
 307     pub struct ExperimentalUnitStruct;
 308     #[unstable]
 309     pub struct UnstableUnitStruct;
 310     pub struct UnmarkedUnitStruct;
 311     #[stable]
 312     pub struct StableUnitStruct;
 313     #[frozen]
 314     pub struct FrozenUnitStruct;
 315     #[locked]
 316     pub struct LockedUnitStruct;
 317
 318     pub enum Enum {
 319         #[deprecated]
 320         DeprecatedVariant,
 321         #[experimental]
 322         ExperimentalVariant,
 323         #[unstable]
 324         UnstableVariant,
 325
 326         UnmarkedVariant,
 327         #[stable]
 328         StableVariant,
 329         #[frozen]
 330         FrozenVariant,
 331         #[locked]
 332         LockedVariant,
 333     }
 334
 335     #[deprecated]
 336     pub struct DeprecatedTupleStruct(int);
 337     #[experimental]
 338     pub struct ExperimentalTupleStruct(int);
 339     #[unstable]
 340     pub struct UnstableTupleStruct(int);
 341     pub struct UnmarkedTupleStruct(int);
 342     #[stable]
 343     pub struct StableTupleStruct(int);
 344     #[frozen]
 345     pub struct FrozenTupleStruct(int);
 346     #[locked]
 347     pub struct LockedTupleStruct(int);
 348
 349     fn test() {
 350         // Only the deprecated cases of the following should generate
 351         // errors, because other stability attributes now have meaning
 352         // only *across* crates, not within a single crate.
 353
 354         let foo = MethodTester;
 355
 356         deprecated(); //~ ERROR use of deprecated item
 357         foo.method_deprecated(); //~ ERROR use of deprecated item
 358         foo.trait_deprecated(); //~ ERROR use of deprecated item
 359
 360         deprecated_text(); //~ ERROR use of deprecated item: text
 361         foo.method_deprecated_text(); //~ ERROR use of deprecated item: text
 362         foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
 363
 364         experimental();
 365         foo.method_experimental();
 366         foo.trait_experimental();
 367
 368         experimental_text();
 369         foo.method_experimental_text();
 370         foo.trait_experimental_text();
 371
 372         unstable();
 373         foo.method_unstable();
 374         foo.trait_unstable();
 375
 376         unstable_text();
 377         foo.method_unstable_text();
 378         foo.trait_unstable_text();
 379
 380         unmarked();
 381         foo.method_unmarked();
 382         foo.trait_unmarked();
 383
 384         stable();
 385         foo.method_stable();
 386         foo.trait_stable();
 387
 388         stable_text();
 389         foo.method_stable_text();
 390         foo.trait_stable_text();
 391
 392         frozen();
 393         foo.method_frozen();
 394         foo.trait_frozen();
 395
 396         frozen_text();
 397         foo.method_frozen_text();
 398         foo.trait_frozen_text();
 399
 400         locked();
 401         foo.method_locked();
 402         foo.trait_locked();
 403
 404         locked_text();
 405         foo.method_locked_text();
 406         foo.trait_locked_text();
 407
 408         let _ = DeprecatedStruct { i: 0 }; //~ ERROR use of deprecated item
 409         let _ = ExperimentalStruct { i: 0 };
 410         let _ = UnstableStruct { i: 0 };
 411         let _ = UnmarkedStruct { i: 0 };
 412         let _ = StableStruct { i: 0 };
 413         let _ = FrozenStruct { i: 0 };
 414         let _ = LockedStruct { i: 0 };
 415
 416         let _ = DeprecatedUnitStruct; //~ ERROR use of deprecated item
 417         let _ = ExperimentalUnitStruct;
 418         let _ = UnstableUnitStruct;
 419         let _ = UnmarkedUnitStruct;
 420         let _ = StableUnitStruct;
 421         let _ = FrozenUnitStruct;
 422         let _ = LockedUnitStruct;
 423
 424         let _ = Enum::DeprecatedVariant; //~ ERROR use of deprecated item
 425         let _ = Enum::ExperimentalVariant;
 426         let _ = Enum::UnstableVariant;
 427         let _ = Enum::UnmarkedVariant;
 428         let _ = Enum::StableVariant;
 429         let _ = Enum::FrozenVariant;
 430         let _ = Enum::LockedVariant;
 431
 432         let _ = DeprecatedTupleStruct (1); //~ ERROR use of deprecated item
 433         let _ = ExperimentalTupleStruct (1);
 434         let _ = UnstableTupleStruct (1);
 435         let _ = UnmarkedTupleStruct (1);
 436         let _ = StableTupleStruct (1);
 437         let _ = FrozenTupleStruct (1);
 438         let _ = LockedTupleStruct (1);
 439     }
 440
 441     fn test_method_param<F: Trait>(foo: F) {
 442         foo.trait_deprecated(); //~ ERROR use of deprecated item
 443         foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
 444         foo.trait_experimental();
 445         foo.trait_experimental_text();
 446         foo.trait_unstable();
 447         foo.trait_unstable_text();
 448         foo.trait_unmarked();
 449         foo.trait_stable();
 450     }
 451
 452     fn test_method_object(foo: &Trait) {
 453         foo.trait_deprecated(); //~ ERROR use of deprecated item
 454         foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
 455         foo.trait_experimental();
 456         foo.trait_experimental_text();
 457         foo.trait_unstable();
 458         foo.trait_unstable_text();
 459         foo.trait_unmarked();
 460         foo.trait_stable();
 461     }
 462
 463     #[deprecated]
 464     fn test_fn_body() {
 465         fn fn_in_body() {}
 466         fn_in_body();
 467     }
 468
 469     impl MethodTester {
 470         #[deprecated]
 471         fn test_method_body(&self) {
 472             fn fn_in_body() {}
 473             fn_in_body();
 474         }
 475     }
 476
 477     #[deprecated]
 478     pub trait DeprecatedTrait {}
 479
 480     struct S;
 481
 482     impl DeprecatedTrait for S { } //~ ERROR use of deprecated item
 483
 484     trait LocalTrait : DeprecatedTrait { } //~ ERROR use of deprecated item
 485 }
 486
 487 fn main() {}