From 22a9f668af6d1ea6d178130360675979e12d1eaa Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Mon, 13 Apr 2015 18:42:24 -0700
Subject: [PATCH] Make use of the stability attributes issue a deprecation
 warning. #22830

---
 src/librustc/middle/stability.rs              | 69 +++++++++++--------
 .../stability-attribute-non-staged.rs         | 18 +++++
 2 files changed, 58 insertions(+), 29 deletions(-)
 create mode 100644 src/test/compile-fail/stability-attribute-non-staged.rs

diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs
index 7043b261360..9f05423e1eb 100644
--- a/src/librustc/middle/stability.rs
+++ b/src/librustc/middle/stability.rs
@@ -57,36 +57,50 @@ impl<'a> Annotator<'a> {
                    attrs: &Vec<Attribute>, item_sp: Span, f: F, required: bool) where
         F: FnOnce(&mut Annotator),
     {
-        debug!("annotate(id = {:?}, attrs = {:?})", id, attrs);
-        match attr::find_stability(self.sess.diagnostic(), attrs, item_sp) {
-            Some(stab) => {
-                debug!("annotate: found {:?}", stab);
-                self.index.local.insert(id, stab.clone());
+        if self.index.staged_api {
+            debug!("annotate(id = {:?}, attrs = {:?})", id, attrs);
+            match attr::find_stability(self.sess.diagnostic(), attrs, item_sp) {
+                Some(stab) => {
+                    debug!("annotate: found {:?}", stab);
+                    self.index.local.insert(id, stab.clone());
 
-                // Don't inherit #[stable(feature = "rust1", since = "1.0.0")]
-                if stab.level != attr::Stable {
-                    let parent = replace(&mut self.parent, Some(stab));
-                    f(self);
-                    self.parent = parent;
-                } else {
-                    f(self);
-                }
-            }
-            None => {
-                debug!("annotate: not found, use_parent = {:?}, parent = {:?}",
-                       use_parent, self.parent);
-                if use_parent {
-                    if let Some(stab) = self.parent.clone() {
-                        self.index.local.insert(id, stab);
-                    } else if self.index.staged_api && required
-                           && self.export_map.contains(&id)
-                           && !self.sess.opts.test {
-                        self.sess.span_err(item_sp,
-                                           "This node does not have a stability attribute");
+                    // Don't inherit #[stable(feature = "rust1", since = "1.0.0")]
+                    if stab.level != attr::Stable {
+                        let parent = replace(&mut self.parent, Some(stab));
+                        f(self);
+                        self.parent = parent;
+                    } else {
+                        f(self);
                     }
                 }
-                f(self);
+                None => {
+                    debug!("annotate: not found, use_parent = {:?}, parent = {:?}",
+                           use_parent, self.parent);
+                    if use_parent {
+                        if let Some(stab) = self.parent.clone() {
+                            self.index.local.insert(id, stab);
+                        } else if self.index.staged_api && required
+                            && self.export_map.contains(&id)
+                            && !self.sess.opts.test {
+                                self.sess.span_err(item_sp,
+                                                   "This node does not have a stability attribute");
+                            }
+                    }
+                    f(self);
+                }
             }
+        } else {
+            // Emit warnings for non-staged-api crates. These should be errors.
+            for attr in attrs {
+                let tag = attr.name();
+                if tag == "unstable" || tag == "stable" || tag == "deprecated" {
+                    attr::mark_used(attr);
+                    self.sess.span_warn(attr.span(),
+                                        "stability attributes are deprecated and \
+                                         will soon become errors");
+                }
+            }
+            f(self);
         }
     }
 }
@@ -157,9 +171,6 @@ impl<'a, 'v> Visitor<'v> for Annotator<'a> {
 impl Index {
     /// Construct the stability index for a crate being compiled.
     pub fn build(&mut self, sess: &Session, krate: &Crate, export_map: &PublicItems) {
-        if !self.staged_api {
-            return;
-        }
         let mut annotator = Annotator {
             sess: sess,
             index: self,
diff --git a/src/test/compile-fail/stability-attribute-non-staged.rs b/src/test/compile-fail/stability-attribute-non-staged.rs
new file mode 100644
index 00000000000..db16e7c0138
--- /dev/null
+++ b/src/test/compile-fail/stability-attribute-non-staged.rs
@@ -0,0 +1,18 @@
+// Copyright 2015 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.
+
+// These two generate an error to satisfy the compile-fail test
+#![deny(warnings)]
+#![feature(blah)] //~ ERROR
+
+#[unstable] //~ WARNING: stability attributes are deprecated
+#[stable] //~ WARNING: stability attributes are deprecated
+#[deprecated] //~ WARNING: stability attributes are deprecated
+fn main() { }