---

yaml
---
r: 156141
b: refs/heads/try
c: 31b7d64
h: refs/heads/master
i:
  156139: 4fd6d3b
v: v3

Author: aturon

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
-refs/heads/try: 3c0d2a7c90a381fa0df977300f267bb96760b566
+refs/heads/try: 31b7d64fdc11090b18666c190cf136549158644f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75

branches/try/src/librustc/lint/context.rs

@@ -63,7 +63,7 @@ pub struct LintStore {
     passes: Option<Vec<LintPassObject>>,
 
     /// Lints indexed by name.
-    by_name: HashMap<String, LintId>,
+    by_name: HashMap<String, TargetLint>,
 
     /// Current levels of each lint, and where they were set.
     levels: HashMap<LintId, LevelSource>,
@@ -73,6 +73,15 @@ pub struct LintStore {
     lint_groups: HashMap<&'static str, (Vec<LintId>, bool)>,
 }
 
+/// The targed of the `by_name` map, which accounts for renaming/deprecation.
+enum TargetLint {
+    /// A direct lint target
+    Id(LintId),
+
+    /// Temporary renaming, used for easing migration pain; see #16545
+    Renamed(String, LintId),
+}
+
 impl LintStore {
     fn get_level_source(&self, lint: LintId) -> LevelSource {
         match self.levels.find(&lint) {
@@ -115,7 +124,7 @@ impl LintStore {
             self.lints.push((*lint, from_plugin));
 
             let id = LintId::of(*lint);
-            if !self.by_name.insert(lint.name_lower(), id) {
+            if !self.by_name.insert(lint.name_lower(), Id(id)) {
                 let msg = format!("duplicate specification of lint {}", lint.name_lower());
                 match (sess, from_plugin) {
                     // We load builtin lints first, so a duplicate is a compiler bug.
@@ -154,6 +163,14 @@ impl LintStore {
         }
     }
 
+    fn register_renamed(&mut self, old_name: &str, new_name: &str) {
+        let target = match self.by_name.find_equiv(&new_name) {
+            Some(&Id(lint_id)) => lint_id.clone(),
+            _ => fail!("invalid lint renaming of {} to {}", old_name, new_name)
+        };
+        self.by_name.insert(old_name.to_string(), Renamed(new_name.to_string(), target));
+    }
+
     pub fn register_builtin(&mut self, sess: Option<&Session>) {
         macro_rules! add_builtin ( ( $sess:ident, $($name:ident),*, ) => (
             {$(
@@ -208,12 +225,59 @@ impl LintStore {
 
         // We have one lint pass defined in this module.
         self.register_pass(sess, false, box GatherNodeLevels as LintPassObject);
+
+        // Insert temporary renamings for a one-time deprecation (#16545)
+        self.register_renamed("unnecessary_typecast", "unused_typecasts");
+        self.register_renamed("unsigned_negate", "unsigned_negation");
+        self.register_renamed("type_limits", "unused_comparisons");
+        self.register_renamed("type_overflow", "overflowing_literals");
+        self.register_renamed("ctypes", "improper_ctypes");
+        self.register_renamed("owned_heap_memory", "box_pointers");
+        self.register_renamed("unused_attribute", "unused_attributes");
+        self.register_renamed("path_statement", "path_statements");
+        self.register_renamed("unused_result", "unused_results");
+        self.register_renamed("non_uppercase_statics", "non_upper_case_globals");
+        self.register_renamed("unnecessary_parens", "unused_parens");
+        self.register_renamed("unnecessary_import_braces", "unused_import_braces");
+        self.register_renamed("unsafe_block", "unsafe_blocks");
+        self.register_renamed("unnecessary_allocation", "unused_allocation");
+        self.register_renamed("missing_doc", "missing_docs");
+        self.register_renamed("unused_extern_crate", "unused_extern_crates");
+        self.register_renamed("unnecessary_qualification", "unused_qualifications");
+        self.register_renamed("unrecognized_lint", "unknown_lints");
+        self.register_renamed("unused_variable", "unused_variables");
+        self.register_renamed("dead_assignment", "unused_assignments");
+        self.register_renamed("unknown_crate_type", "unknown_crate_types");
+        self.register_renamed("variant_size_difference", "variant_size_differences");
+        self.register_renamed("transmute_fat_ptr", "fat_ptr_transmutes");
+
+    }
+
+    #[allow(unused_variable)]
+    fn find_lint(&self, lint_name: &str, sess: &Session, span: Option<Span>)
+                 -> Option<LintId>
+    {
+        match self.by_name.find_equiv(&lint_name) {
+            Some(&Id(lint_id)) => Some(lint_id),
+            Some(&Renamed(ref new_name, lint_id)) => {
+                // NOTE(stage0): add the following code after the next snapshot
+
+                // let warning = format!("lint {} has been renamed to {}",
+                //                       lint_name, new_name);
+                // match span {
+                //     Some(span) => sess.span_warn(span, warning.as_slice()),
+                //     None => sess.warn(warning.as_slice()),
+                // };
+                Some(lint_id)
+            }
+            None => None
+        }
     }
 
     pub fn process_command_line(&mut self, sess: &Session) {
         for &(ref lint_name, level) in sess.opts.lint_opts.iter() {
-            match self.by_name.find_equiv(&lint_name.as_slice()) {
-                Some(&lint_id) => self.set_level(lint_id, (level, CommandLine)),
+            match self.find_lint(lint_name.as_slice(), sess, None) {
+                Some(lint_id) => self.set_level(lint_id, (level, CommandLine)),
                 None => {
                     match self.lint_groups.iter().map(|(&x, pair)| (x, pair.ref0().clone()))
                                                  .collect::<HashMap<&'static str, Vec<LintId>>>()
@@ -421,8 +485,8 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
                     continue;
                 }
                 Ok((lint_name, level, span)) => {
-                    match self.lints.by_name.find_equiv(&lint_name.get()) {
-                        Some(&lint_id) => vec![(lint_id, level, span)],
+                    match self.lints.find_lint(lint_name.get(), &self.tcx.sess, Some(span)) {
+                        Some(lint_id) => vec![(lint_id, level, span)],
                         None => {
                             match self.lints.lint_groups.find_equiv(&lint_name.get()) {
                                 Some(&(ref v, _)) => v.iter()