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