auto merge of #8921 : huonw/rust/stability, r=brson

Significant progress on #6875, enough that I'll open new bugs and turn that into a metabug when this lands.

Description & example in the commit message.

src/test/auxiliary/lint_stability.rs

@@ -0,0 +1,162 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#[link(name = "lint_stability",
+       vers = "0.1")];
+#[crate_type = "lib"];
+
+#[deprecated]
+pub fn deprecated() {}
+#[deprecated="text"]
+pub fn deprecated_text() {}
+
+#[experimental]
+pub fn experimental() {}
+#[experimental="text"]
+pub fn experimental_text() {}
+
+#[unstable]
+pub fn unstable() {}
+#[unstable="text"]
+pub fn unstable_text() {}
+
+pub fn unmarked() {}
+
+#[stable]
+pub fn stable() {}
+#[stable="text"]
+pub fn stable_text() {}
+
+#[locked]
+pub fn locked() {}
+#[locked="text"]
+pub fn locked_text() {}
+
+#[frozen]
+pub fn frozen() {}
+#[frozen="text"]
+pub fn frozen_text() {}
+
+#[stable]
+pub struct MethodTester;
+
+impl MethodTester {
+    #[deprecated]
+    pub fn method_deprecated(&self) {}
+    #[deprecated="text"]
+    pub fn method_deprecated_text(&self) {}
+
+    #[experimental]
+    pub fn method_experimental(&self) {}
+    #[experimental="text"]
+    pub fn method_experimental_text(&self) {}
+
+    #[unstable]
+    pub fn method_unstable(&self) {}
+    #[unstable="text"]
+    pub fn method_unstable_text(&self) {}
+
+    pub fn method_unmarked(&self) {}
+
+    #[stable]
+    pub fn method_stable(&self) {}
+    #[stable="text"]
+    pub fn method_stable_text(&self) {}
+
+    #[locked]
+    pub fn method_locked(&self) {}
+    #[locked="text"]
+    pub fn method_locked_text(&self) {}
+
+    #[frozen]
+    pub fn method_frozen(&self) {}
+    #[frozen="text"]
+    pub fn method_frozen_text(&self) {}
+}
+
+pub trait Trait {
+    #[deprecated]
+    fn trait_deprecated(&self) {}
+    #[deprecated="text"]
+    fn trait_deprecated_text(&self) {}
+
+    #[experimental]
+    fn trait_experimental(&self) {}
+    #[experimental="text"]
+    fn trait_experimental_text(&self) {}
+
+    #[unstable]
+    fn trait_unstable(&self) {}
+    #[unstable="text"]
+    fn trait_unstable_text(&self) {}
+
+    fn trait_unmarked(&self) {}
+
+    #[stable]
+    fn trait_stable(&self) {}
+    #[stable="text"]
+    fn trait_stable_text(&self) {}
+
+    #[locked]
+    fn trait_locked(&self) {}
+    #[locked="text"]
+    fn trait_locked_text(&self) {}
+
+    #[frozen]
+    fn trait_frozen(&self) {}
+    #[frozen="text"]
+    fn trait_frozen_text(&self) {}
+}
+
+impl Trait for MethodTester {}
+
+#[deprecated]
+pub struct DeprecatedStruct { i: int }
+#[experimental]
+pub struct ExperimentalStruct { i: int }
+#[unstable]
+pub struct UnstableStruct { i: int }
+pub struct UnmarkedStruct { i: int }
+#[stable]
+pub struct StableStruct { i: int }
+#[frozen]
+pub struct FrozenStruct { i: int }
+#[locked]
+pub struct LockedStruct { i: int }
+
+#[deprecated]
+pub struct DeprecatedUnitStruct;
+#[experimental]
+pub struct ExperimentalUnitStruct;
+#[unstable]
+pub struct UnstableUnitStruct;
+pub struct UnmarkedUnitStruct;
+#[stable]
+pub struct StableUnitStruct;
+#[frozen]
+pub struct FrozenUnitStruct;
+#[locked]
+pub struct LockedUnitStruct;
+
+pub enum Enum {
+    #[deprecated]
+    DeprecatedVariant,
+    #[experimental]
+    ExperimentalVariant,
+    #[unstable]
+    UnstableVariant,
+
+    UnmarkedVariant,
+    #[stable]
+    StableVariant,
+    #[frozen]
+    FrozenVariant,
+    #[locked]
+    LockedVariant,
+}

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

@@ -0,0 +1,338 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast aux-build
+// aux-build:lint_stability.rs
+
+#[deny(unstable)];
+#[deny(deprecated)];
+#[deny(experimental)];
+
+mod cross_crate {
+    extern mod lint_stability;
+    use self::lint_stability::*;
+
+    fn test() {
+        // XXX: attributes on methods are not encoded cross crate.
+        let foo = MethodTester;
+
+        deprecated(); //~ ERROR use of deprecated item
+        foo.method_deprecated(); // ~ ERROR use of deprecated item
+        foo.trait_deprecated(); // ~ ERROR use of deprecated item
+
+        deprecated_text(); //~ ERROR use of deprecated item: text
+        foo.method_deprecated_text(); // ~ ERROR use of deprecated item: text
+        foo.trait_deprecated_text(); // ~ ERROR use of deprecated item: text
+
+        experimental(); //~ ERROR use of experimental item
+        foo.method_experimental(); // ~ ERROR use of experimental item
+        foo.trait_experimental(); // ~ ERROR use of experimental item
+
+        experimental_text(); //~ ERROR use of experimental item: text
+        foo.method_experimental_text(); // ~ ERROR use of experimental item: text
+        foo.trait_experimental_text(); // ~ ERROR use of experimental item: text
+
+        unstable(); //~ ERROR use of unstable item
+        foo.method_unstable(); // ~ ERROR use of unstable item
+        foo.trait_unstable(); // ~ ERROR use of unstable item
+
+        unstable_text(); //~ ERROR use of unstable item: text
+        foo.method_unstable_text(); // ~ ERROR use of unstable item: text
+        foo.trait_unstable_text(); // ~ ERROR use of unstable item: text
+
+        unmarked(); //~ ERROR use of unmarked item
+        foo.method_unmarked(); // ~ ERROR use of unmarked item
+        foo.trait_unmarked(); // ~ ERROR use of unmarked item
+
+        stable();
+        foo.method_stable();
+        foo.trait_stable();
+
+        stable_text();
+        foo.method_stable_text();
+        foo.trait_stable_text();
+
+        frozen();
+        foo.method_frozen();
+        foo.trait_frozen();
+
+        frozen_text();
+        foo.method_frozen_text();
+        foo.trait_frozen_text();
+
+        locked();
+        foo.method_locked();
+        foo.trait_locked();
+
+        locked_text();
+        foo.method_locked_text();
+        foo.trait_locked_text();
+
+
+        let _ = DeprecatedStruct { i: 0 }; //~ ERROR use of deprecated item
+        let _ = ExperimentalStruct { i: 0 }; //~ ERROR use of experimental item
+        let _ = UnstableStruct { i: 0 }; //~ ERROR use of unstable item
+        let _ = UnmarkedStruct { i: 0 }; //~ ERROR use of unmarked item
+        let _ = StableStruct { i: 0 };
+        let _ = FrozenStruct { i: 0 };
+        let _ = LockedStruct { i: 0 };
+
+        let _ = DeprecatedUnitStruct; //~ ERROR use of deprecated item
+        let _ = ExperimentalUnitStruct; //~ ERROR use of experimental item
+        let _ = UnstableUnitStruct; //~ ERROR use of unstable item
+        let _ = UnmarkedUnitStruct; //~ ERROR use of unmarked item
+        let _ = StableUnitStruct;
+        let _ = FrozenUnitStruct;
+        let _ = LockedUnitStruct;
+
+        let _ = DeprecatedVariant; //~ ERROR use of deprecated item
+        let _ = ExperimentalVariant; //~ ERROR use of experimental item
+        let _ = UnstableVariant; //~ ERROR use of unstable item
+        let _ = UnmarkedVariant; //~ ERROR use of unmarked item
+        let _ = StableVariant;
+        let _ = FrozenVariant;
+        let _ = LockedVariant;
+    }
+}
+
+mod this_crate {
+    #[deprecated]
+    pub fn deprecated() {}
+    #[deprecated="text"]
+    pub fn deprecated_text() {}
+
+    #[experimental]
+    pub fn experimental() {}
+    #[experimental="text"]
+    pub fn experimental_text() {}
+
+    #[unstable]
+    pub fn unstable() {}
+    #[unstable="text"]
+    pub fn unstable_text() {}
+
+    pub fn unmarked() {}
+
+    #[stable]
+    pub fn stable() {}
+    #[stable="text"]
+    pub fn stable_text() {}
+
+    #[locked]
+    pub fn locked() {}
+    #[locked="text"]
+    pub fn locked_text() {}
+
+    #[frozen]
+    pub fn frozen() {}
+    #[frozen="text"]
+    pub fn frozen_text() {}
+
+    #[stable]
+    pub struct MethodTester;
+
+    impl MethodTester {
+        #[deprecated]
+        pub fn method_deprecated(&self) {}
+        #[deprecated="text"]
+        pub fn method_deprecated_text(&self) {}
+
+        #[experimental]
+        pub fn method_experimental(&self) {}
+        #[experimental="text"]
+        pub fn method_experimental_text(&self) {}
+
+        #[unstable]
+        pub fn method_unstable(&self) {}
+        #[unstable="text"]
+        pub fn method_unstable_text(&self) {}
+
+        pub fn method_unmarked(&self) {}
+
+        #[stable]
+        pub fn method_stable(&self) {}
+        #[stable="text"]
+        pub fn method_stable_text(&self) {}
+
+        #[locked]
+        pub fn method_locked(&self) {}
+        #[locked="text"]
+        pub fn method_locked_text(&self) {}
+
+        #[frozen]
+        pub fn method_frozen(&self) {}
+        #[frozen="text"]
+        pub fn method_frozen_text(&self) {}
+    }
+
+    pub trait Trait {
+        #[deprecated]
+        fn trait_deprecated(&self) {}
+        #[deprecated="text"]
+        fn trait_deprecated_text(&self) {}
+
+        #[experimental]
+        fn trait_experimental(&self) {}
+        #[experimental="text"]
+        fn trait_experimental_text(&self) {}
+
+        #[unstable]
+        fn trait_unstable(&self) {}
+        #[unstable="text"]
+        fn trait_unstable_text(&self) {}
+
+        fn trait_unmarked(&self) {}
+
+        #[stable]
+        fn trait_stable(&self) {}
+        #[stable="text"]
+        fn trait_stable_text(&self) {}
+
+        #[locked]
+        fn trait_locked(&self) {}
+        #[locked="text"]
+        fn trait_locked_text(&self) {}
+
+        #[frozen]
+        fn trait_frozen(&self) {}
+        #[frozen="text"]
+        fn trait_frozen_text(&self) {}
+    }
+
+    impl Trait for MethodTester {}
+
+    #[deprecated]
+    pub struct DeprecatedStruct { i: int }
+    #[experimental]
+    pub struct ExperimentalStruct { i: int }
+    #[unstable]
+    pub struct UnstableStruct { i: int }
+    pub struct UnmarkedStruct { i: int }
+    #[stable]
+    pub struct StableStruct { i: int }
+    #[frozen]
+    pub struct FrozenStruct { i: int }
+    #[locked]
+    pub struct LockedStruct { i: int }
+
+    #[deprecated]
+    pub struct DeprecatedUnitStruct;
+    #[experimental]
+    pub struct ExperimentalUnitStruct;
+    #[unstable]
+    pub struct UnstableUnitStruct;
+    pub struct UnmarkedUnitStruct;
+    #[stable]
+    pub struct StableUnitStruct;
+    #[frozen]
+    pub struct FrozenUnitStruct;
+    #[locked]
+    pub struct LockedUnitStruct;
+
+    pub enum Enum {
+        #[deprecated]
+        DeprecatedVariant,
+        #[experimental]
+        ExperimentalVariant,
+        #[unstable]
+        UnstableVariant,
+
+        UnmarkedVariant,
+        #[stable]
+        StableVariant,
+        #[frozen]
+        FrozenVariant,
+        #[locked]
+        LockedVariant,
+    }
+
+    fn test() {
+        let foo = MethodTester;
+
+        deprecated(); //~ ERROR use of deprecated item
+        foo.method_deprecated(); // ~ ERROR use of deprecated item
+        foo.trait_deprecated(); // ~ ERROR use of deprecated item
+
+        deprecated_text(); //~ ERROR use of deprecated item: text
+        foo.method_deprecated_text(); // ~ ERROR use of deprecated item: text
+        foo.trait_deprecated_text(); // ~ ERROR use of deprecated item: text
+
+        experimental(); //~ ERROR use of experimental item
+        foo.method_experimental(); // ~ ERROR use of experimental item
+        foo.trait_experimental(); // ~ ERROR use of experimental item
+
+        experimental_text(); //~ ERROR use of experimental item: text
+        foo.method_experimental_text(); // ~ ERROR use of experimental item: text
+        foo.trait_experimental_text(); // ~ ERROR use of experimental item: text
+
+        unstable(); //~ ERROR use of unstable item
+        foo.method_unstable(); // ~ ERROR use of unstable item
+        foo.trait_unstable(); // ~ ERROR use of unstable item
+
+        unstable_text(); //~ ERROR use of unstable item: text
+        foo.method_unstable_text(); // ~ ERROR use of unstable item: text
+        foo.trait_unstable_text(); // ~ ERROR use of unstable item: text
+
+        unmarked(); //~ ERROR use of unmarked item
+        foo.method_unmarked(); // ~ ERROR use of unmarked item
+        foo.trait_unmarked(); // ~ ERROR use of unmarked item
+
+        stable();
+        foo.method_stable();
+        foo.trait_stable();
+
+        stable_text();
+        foo.method_stable_text();
+        foo.trait_stable_text();
+
+        frozen();
+        foo.method_frozen();
+        foo.trait_frozen();
+
+        frozen_text();
+        foo.method_frozen_text();
+        foo.trait_frozen_text();
+
+        locked();
+        foo.method_locked();
+        foo.trait_locked();
+
+        locked_text();
+        foo.method_locked_text();
+        foo.trait_locked_text();
+
+
+        let _ = DeprecatedStruct { i: 0 }; //~ ERROR use of deprecated item
+        let _ = ExperimentalStruct { i: 0 }; //~ ERROR use of experimental item
+        let _ = UnstableStruct { i: 0 }; //~ ERROR use of unstable item
+        let _ = UnmarkedStruct { i: 0 }; //~ ERROR use of unmarked item
+        let _ = StableStruct { i: 0 };
+        let _ = FrozenStruct { i: 0 };
+        let _ = LockedStruct { i: 0 };
+
+        let _ = DeprecatedUnitStruct; //~ ERROR use of deprecated item
+        let _ = ExperimentalUnitStruct; //~ ERROR use of experimental item
+        let _ = UnstableUnitStruct; //~ ERROR use of unstable item
+        let _ = UnmarkedUnitStruct; //~ ERROR use of unmarked item
+        let _ = StableUnitStruct;
+        let _ = FrozenUnitStruct;
+        let _ = LockedUnitStruct;
+
+        let _ = DeprecatedVariant; //~ ERROR use of deprecated item
+        let _ = ExperimentalVariant; //~ ERROR use of experimental item
+        let _ = UnstableVariant; //~ ERROR use of unstable item
+        let _ = UnmarkedVariant; //~ ERROR use of unmarked item
+        let _ = StableVariant;
+        let _ = FrozenVariant;
+        let _ = LockedVariant;
+    }
+}
+
+fn main() {}