summaryrefslogtreecommitdiffstats
path: root/src/test/ui/lint/lint-stability.rs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 12:02:58 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 12:02:58 +0000
commit698f8c2f01ea549d77d7dc3338a12e04c11057b9 (patch)
tree173a775858bd501c378080a10dca74132f05bc50 /src/test/ui/lint/lint-stability.rs
parentInitial commit. (diff)
downloadrustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.tar.xz
rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.zip
Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/test/ui/lint/lint-stability.rs')
-rw-r--r--src/test/ui/lint/lint-stability.rs454
1 files changed, 454 insertions, 0 deletions
diff --git a/src/test/ui/lint/lint-stability.rs b/src/test/ui/lint/lint-stability.rs
new file mode 100644
index 000000000..d0f0e9f80
--- /dev/null
+++ b/src/test/ui/lint/lint-stability.rs
@@ -0,0 +1,454 @@
+// aux-build:lint_stability.rs
+// aux-build:inherited_stability.rs
+// aux-build:stability_cfg1.rs
+// aux-build:stability-cfg2.rs
+
+#![allow(deprecated)]
+#![allow(dead_code)]
+#![feature(staged_api)]
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+#[macro_use]
+extern crate lint_stability;
+
+mod cross_crate {
+ extern crate stability_cfg1;
+ extern crate stability_cfg2; //~ ERROR use of unstable library feature
+
+ use lint_stability::*;
+
+ fn test() {
+ type Foo = MethodTester;
+ let foo = MethodTester;
+
+ deprecated();
+ foo.method_deprecated();
+ Foo::method_deprecated(&foo);
+ <Foo>::method_deprecated(&foo);
+ foo.trait_deprecated();
+ Trait::trait_deprecated(&foo);
+ <Foo>::trait_deprecated(&foo);
+ <Foo as Trait>::trait_deprecated(&foo);
+
+ deprecated_text();
+ foo.method_deprecated_text();
+ Foo::method_deprecated_text(&foo);
+ <Foo>::method_deprecated_text(&foo);
+ foo.trait_deprecated_text();
+ Trait::trait_deprecated_text(&foo);
+ <Foo>::trait_deprecated_text(&foo);
+ <Foo as Trait>::trait_deprecated_text(&foo);
+
+ deprecated_future(); // Fine; no error.
+
+ deprecated_unstable();
+ //~^ ERROR use of unstable library feature
+ Trait::trait_deprecated_unstable(&foo);
+ //~^ ERROR use of unstable library feature
+ <Foo as Trait>::trait_deprecated_unstable(&foo);
+ //~^ ERROR use of unstable library feature
+
+ deprecated_unstable_text();
+ //~^ ERROR use of unstable library feature
+ Trait::trait_deprecated_unstable_text(&foo);
+ //~^ ERROR use of unstable library feature
+ <Foo as Trait>::trait_deprecated_unstable_text(&foo);
+ //~^ ERROR use of unstable library feature
+
+ unstable(); //~ ERROR use of unstable library feature
+ Trait::trait_unstable(&foo); //~ ERROR use of unstable library feature
+ <Foo as Trait>::trait_unstable(&foo); //~ ERROR use of unstable library feature
+
+ unstable_text();
+ //~^ ERROR use of unstable library feature 'unstable_test_feature': text
+ Trait::trait_unstable_text(&foo);
+ //~^ ERROR use of unstable library feature 'unstable_test_feature': text
+ <Foo as Trait>::trait_unstable_text(&foo);
+ //~^ ERROR use of unstable library feature 'unstable_test_feature': text
+
+ stable();
+ foo.method_stable();
+ Foo::method_stable(&foo);
+ <Foo>::method_stable(&foo);
+ foo.trait_stable();
+ Trait::trait_stable(&foo);
+ <Foo>::trait_stable(&foo);
+ <Foo as Trait>::trait_stable(&foo);
+
+ stable_text();
+ foo.method_stable_text();
+ Foo::method_stable_text(&foo);
+ <Foo>::method_stable_text(&foo);
+ foo.trait_stable_text();
+ Trait::trait_stable_text(&foo);
+ <Foo>::trait_stable_text(&foo);
+ <Foo as Trait>::trait_stable_text(&foo);
+
+ struct S1<T: TraitWithAssociatedTypes>(T::TypeUnstable);
+ //~^ ERROR use of unstable library feature
+ struct S2<T: TraitWithAssociatedTypes>(T::TypeDeprecated);
+ type A = dyn TraitWithAssociatedTypes<
+ TypeUnstable = u8, //~ ERROR use of unstable library feature
+ TypeDeprecated = u16,
+ >;
+
+ let _ = DeprecatedStruct {
+ i: 0
+ };
+ let _ = DeprecatedUnstableStruct {
+ //~^ ERROR use of unstable library feature
+ i: 0
+ };
+ let _ = UnstableStruct { i: 0 }; //~ ERROR use of unstable library feature
+ let _ = StableStruct { i: 0 };
+
+ let _ = DeprecatedUnitStruct;
+ let _ = DeprecatedUnstableUnitStruct;
+ //~^ ERROR use of unstable library feature
+ let _ = UnstableUnitStruct; //~ ERROR use of unstable library feature
+ let _ = StableUnitStruct;
+
+ let _ = Enum::DeprecatedVariant;
+ let _ = Enum::DeprecatedUnstableVariant;
+ //~^ ERROR use of unstable library feature
+ let _ = Enum::UnstableVariant; //~ ERROR use of unstable library feature
+ let _ = Enum::StableVariant;
+
+ let _ = DeprecatedTupleStruct (1);
+ let _ = DeprecatedUnstableTupleStruct (1);
+ //~^ ERROR use of unstable library feature
+ let _ = UnstableTupleStruct (1); //~ ERROR use of unstable library feature
+ let _ = StableTupleStruct (1);
+
+ // At the moment, the lint checker only checks stability in
+ // in the arguments of macros.
+ // Eventually, we will want to lint the contents of the
+ // macro in the module *defining* it. Also, stability levels
+ // on macros themselves are not yet linted.
+ macro_test_arg!(deprecated_text());
+ macro_test_arg!(deprecated_unstable_text());
+ //~^ ERROR use of unstable library feature
+ macro_test_arg!(macro_test_arg!(deprecated_text()));
+ }
+
+ fn test_method_param<Foo: Trait>(foo: Foo) {
+ foo.trait_deprecated();
+ Trait::trait_deprecated(&foo);
+ <Foo>::trait_deprecated(&foo);
+ <Foo as Trait>::trait_deprecated(&foo);
+ foo.trait_deprecated_text();
+ Trait::trait_deprecated_text(&foo);
+ <Foo>::trait_deprecated_text(&foo);
+ <Foo as Trait>::trait_deprecated_text(&foo);
+ Trait::trait_deprecated_unstable(&foo);
+ //~^ ERROR use of unstable library feature
+ <Foo as Trait>::trait_deprecated_unstable(&foo);
+ //~^ ERROR use of unstable library feature
+ Trait::trait_deprecated_unstable_text(&foo);
+ //~^ ERROR use of unstable library feature
+ <Foo as Trait>::trait_deprecated_unstable_text(&foo);
+ //~^ ERROR use of unstable library feature
+ Trait::trait_unstable(&foo); //~ ERROR use of unstable library feature
+ <Foo as Trait>::trait_unstable(&foo); //~ ERROR use of unstable library feature
+ Trait::trait_unstable_text(&foo);
+ //~^ ERROR use of unstable library feature 'unstable_test_feature': text
+ <Foo as Trait>::trait_unstable_text(&foo);
+ //~^ ERROR use of unstable library feature 'unstable_test_feature': text
+ foo.trait_stable();
+ Trait::trait_stable(&foo);
+ <Foo>::trait_stable(&foo);
+ <Foo as Trait>::trait_stable(&foo);
+ }
+
+ fn test_method_object(foo: &dyn Trait) {
+ foo.trait_deprecated();
+ foo.trait_deprecated_text();
+ foo.trait_stable();
+ }
+
+ struct S;
+
+ impl UnstableTrait for S { } //~ ERROR use of unstable library feature
+ impl DeprecatedTrait for S {}
+ trait LocalTrait : UnstableTrait { } //~ ERROR use of unstable library feature
+ trait LocalTrait2 : DeprecatedTrait { }
+
+ impl Trait for S {
+ fn trait_stable(&self) {}
+ fn trait_unstable(&self) {} //~ ERROR use of unstable library feature
+ }
+}
+
+mod inheritance {
+ extern crate inherited_stability; //~ ERROR use of unstable library feature
+ use self::inherited_stability::*; //~ ERROR use of unstable library feature
+
+ fn test_inheritance() {
+ unstable(); //~ ERROR use of unstable library feature
+ stable();
+
+ stable_mod::unstable(); //~ ERROR use of unstable library feature
+ stable_mod::stable();
+
+ unstable_mod::deprecated(); //~ ERROR use of unstable library feature
+ unstable_mod::unstable(); //~ ERROR use of unstable library feature
+
+ let _ = Unstable::UnstableVariant; //~ ERROR use of unstable library feature
+ let _ = Unstable::StableVariant; //~ ERROR use of unstable library feature
+
+ let x: usize = 0;
+ x.stable();
+ }
+}
+
+mod this_crate {
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ pub fn deprecated() {}
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ pub fn deprecated_text() {}
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "99.99.99", note = "text")]
+ pub fn deprecated_future() {}
+
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ pub fn unstable() {}
+ #[unstable(feature = "unstable_test_feature", reason = "text", issue = "none")]
+ pub fn unstable_text() {}
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn stable() {}
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn stable_text() {}
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub struct MethodTester;
+
+ impl MethodTester {
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ pub fn method_deprecated(&self) {}
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ pub fn method_deprecated_text(&self) {}
+
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ pub fn method_unstable(&self) {}
+ #[unstable(feature = "unstable_test_feature", reason = "text", issue = "none")]
+ pub fn method_unstable_text(&self) {}
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn method_stable(&self) {}
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn method_stable_text(&self) {}
+ }
+
+ pub trait Trait {
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ fn trait_deprecated(&self) {}
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ fn trait_deprecated_text(&self) {}
+
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ fn trait_unstable(&self) {}
+ #[unstable(feature = "unstable_test_feature", reason = "text", issue = "none")]
+ fn trait_unstable_text(&self) {}
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn trait_stable(&self) {}
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn trait_stable_text(&self) {}
+ }
+
+ impl Trait for MethodTester {}
+
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ pub struct DeprecatedStruct {
+ #[stable(feature = "stable_test_feature", since = "1.0.0")] i: isize
+ }
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ pub struct UnstableStruct {
+ #[stable(feature = "stable_test_feature", since = "1.0.0")] i: isize
+ }
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub struct StableStruct {
+ #[stable(feature = "stable_test_feature", since = "1.0.0")] i: isize
+ }
+
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ pub struct DeprecatedUnitStruct;
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ pub struct UnstableUnitStruct;
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub struct StableUnitStruct;
+
+ pub enum Enum {
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ DeprecatedVariant,
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ UnstableVariant,
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ StableVariant,
+ }
+
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ pub struct DeprecatedTupleStruct(isize);
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ pub struct UnstableTupleStruct(isize);
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub struct StableTupleStruct(isize);
+
+ fn test() {
+ // Only the deprecated cases of the following should generate
+ // errors, because other stability attributes now have meaning
+ // only *across* crates, not within a single crate.
+
+ type Foo = MethodTester;
+ let foo = MethodTester;
+
+ deprecated();
+ foo.method_deprecated();
+ Foo::method_deprecated(&foo);
+ <Foo>::method_deprecated(&foo);
+ foo.trait_deprecated();
+ Trait::trait_deprecated(&foo);
+ <Foo>::trait_deprecated(&foo);
+ <Foo as Trait>::trait_deprecated(&foo);
+
+ deprecated_text();
+ foo.method_deprecated_text();
+ Foo::method_deprecated_text(&foo);
+ <Foo>::method_deprecated_text(&foo);
+ foo.trait_deprecated_text();
+ Trait::trait_deprecated_text(&foo);
+ <Foo>::trait_deprecated_text(&foo);
+ <Foo as Trait>::trait_deprecated_text(&foo);
+
+ deprecated_future();
+
+ unstable();
+ foo.method_unstable();
+ Foo::method_unstable(&foo);
+ <Foo>::method_unstable(&foo);
+ foo.trait_unstable();
+ Trait::trait_unstable(&foo);
+ <Foo>::trait_unstable(&foo);
+ <Foo as Trait>::trait_unstable(&foo);
+
+ unstable_text();
+ foo.method_unstable_text();
+ Foo::method_unstable_text(&foo);
+ <Foo>::method_unstable_text(&foo);
+ foo.trait_unstable_text();
+ Trait::trait_unstable_text(&foo);
+ <Foo>::trait_unstable_text(&foo);
+ <Foo as Trait>::trait_unstable_text(&foo);
+
+ stable();
+ foo.method_stable();
+ Foo::method_stable(&foo);
+ <Foo>::method_stable(&foo);
+ foo.trait_stable();
+ Trait::trait_stable(&foo);
+ <Foo>::trait_stable(&foo);
+ <Foo as Trait>::trait_stable(&foo);
+
+ stable_text();
+ foo.method_stable_text();
+ Foo::method_stable_text(&foo);
+ <Foo>::method_stable_text(&foo);
+ foo.trait_stable_text();
+ Trait::trait_stable_text(&foo);
+ <Foo>::trait_stable_text(&foo);
+ <Foo as Trait>::trait_stable_text(&foo);
+
+ let _ = DeprecatedStruct {
+ i: 0
+ };
+ let _ = UnstableStruct { i: 0 };
+ let _ = StableStruct { i: 0 };
+
+ let _ = DeprecatedUnitStruct;
+ let _ = UnstableUnitStruct;
+ let _ = StableUnitStruct;
+
+ let _ = Enum::DeprecatedVariant;
+ let _ = Enum::UnstableVariant;
+ let _ = Enum::StableVariant;
+
+ let _ = DeprecatedTupleStruct (1);
+ let _ = UnstableTupleStruct (1);
+ let _ = StableTupleStruct (1);
+ }
+
+ fn test_method_param<Foo: Trait>(foo: Foo) {
+ foo.trait_deprecated();
+ Trait::trait_deprecated(&foo);
+ <Foo>::trait_deprecated(&foo);
+ <Foo as Trait>::trait_deprecated(&foo);
+ foo.trait_deprecated_text();
+ Trait::trait_deprecated_text(&foo);
+ <Foo>::trait_deprecated_text(&foo);
+ <Foo as Trait>::trait_deprecated_text(&foo);
+ foo.trait_unstable();
+ Trait::trait_unstable(&foo);
+ <Foo>::trait_unstable(&foo);
+ <Foo as Trait>::trait_unstable(&foo);
+ foo.trait_unstable_text();
+ Trait::trait_unstable_text(&foo);
+ <Foo>::trait_unstable_text(&foo);
+ <Foo as Trait>::trait_unstable_text(&foo);
+ foo.trait_stable();
+ Trait::trait_stable(&foo);
+ <Foo>::trait_stable(&foo);
+ <Foo as Trait>::trait_stable(&foo);
+ }
+
+ fn test_method_object(foo: &dyn Trait) {
+ foo.trait_deprecated();
+ foo.trait_deprecated_text();
+ foo.trait_unstable();
+ foo.trait_unstable_text();
+ foo.trait_stable();
+ }
+
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ fn test_fn_body() {
+ fn fn_in_body() {}
+ fn_in_body();
+ }
+
+ impl MethodTester {
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ fn test_method_body(&self) {
+ fn fn_in_body() {}
+ fn_in_body();
+ }
+ }
+
+ #[unstable(feature = "unstable_test_feature", issue = "none")]
+ #[deprecated(since = "1.0.0", note = "text")]
+ pub trait DeprecatedTrait {
+ fn dummy(&self) { }
+ }
+
+ struct S;
+
+ impl DeprecatedTrait for S { }
+
+ trait LocalTrait : DeprecatedTrait { }
+}
+
+fn main() {}