Convert builtin lints to uppercase names for style consistency

src/librustc/driver/driver.rs

@@ -786,7 +786,7 @@ pub fn collect_crate_types(session: &Session,
                 }
                 Some(ref n) if n.equiv(&("bin")) => Some(config::CrateTypeExecutable),
                 Some(_) => {
-                    session.add_lint(lint::builtin::unknown_crate_type,
+                    session.add_lint(lint::builtin::UNKNOWN_CRATE_TYPE,
                                      ast::CRATE_NODE_ID,
                                      a.span,
                                      "invalid `crate_type` \
@@ -794,7 +794,7 @@ pub fn collect_crate_types(session: &Session,
                     None
                 }
                 _ => {
-                    session.add_lint(lint::builtin::unknown_crate_type,
+                    session.add_lint(lint::builtin::UNKNOWN_CRATE_TYPE,
                                      ast::CRATE_NODE_ID,
                                      a.span,
                                      "`crate_type` requires a \

src/librustc/front/feature_gate.rs

@@ -409,7 +409,7 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) {
                                                      directive not necessary");
                         }
                         None => {
-                            sess.add_lint(lint::builtin::unknown_features,
+                            sess.add_lint(lint::builtin::UNKNOWN_FEATURES,
                                           ast::CRATE_NODE_ID,
                                           mi.span,
                                           "unknown feature".to_string());

src/librustc/lint/context.rs

@@ -264,7 +264,7 @@ fn lookup_and_emit(&self, lint: &'static Lint, span: Option<Span>, msg: &str) {
         let (level, src) = match self.lints.levels.find(&LintId::of(lint)) {
             None => return,
             Some(&(Warn, src)) => {
-                let lint_id = LintId::of(builtin::warnings);
+                let lint_id = LintId::of(builtin::WARNINGS);
                 (self.lints.get_level_source(lint_id).val0(), src)
             }
             Some(&pair) => pair,
@@ -359,7 +359,7 @@ fn gather_lint_attrs(&mut self, attrs: &[ast::Attribute]) -> Vec<(LintId, Level,
                         match self.lints.by_name.find_equiv(&lint_name.get()) {
                             Some(lint_id) => out.push((*lint_id, level, meta.span)),
 
-                            None => self.span_lint(builtin::unrecognized_lint,
+                            None => self.span_lint(builtin::UNRECOGNIZED_LINT,
                                 meta.span,
                                 format!("unknown `{}` attribute: `{}`",
                                     level.as_str(), lint_name).as_slice()),
@@ -588,7 +588,7 @@ fn get_lints(&self) -> LintArray {
     fn check_item(&mut self, cx: &Context, it: &ast::Item) {
         match it.node {
             ast::ItemEnum(..) => {
-                let lint_id = LintId::of(builtin::variant_size_difference);
+                let lint_id = LintId::of(builtin::VARIANT_SIZE_DIFFERENCE);
                 match cx.lints.get_level_source(lint_id) {
                     lvlsrc @ (lvl, _) if lvl != Allow => {
                         cx.node_levels.borrow_mut()

src/librustc/middle/dead.rs

@@ -461,7 +461,7 @@ fn warn_dead_code(&mut self,
                       ident: ast::Ident) {
         self.tcx
             .sess
-            .add_lint(lint::builtin::dead_code,
+            .add_lint(lint::builtin::DEAD_CODE,
                       id,
                       span,
                       format!("code is never used: `{}`",

src/librustc/middle/liveness.rs

@@ -1560,11 +1560,11 @@ fn warn_about_unused(&self,
                 };
 
                 if is_assigned {
-                    self.ir.tcx.sess.add_lint(lint::builtin::unused_variable, id, sp,
+                    self.ir.tcx.sess.add_lint(lint::builtin::UNUSED_VARIABLE, id, sp,
                         format!("variable `{}` is assigned to, but never used",
                                 *name));
                 } else {
-                    self.ir.tcx.sess.add_lint(lint::builtin::unused_variable, id, sp,
+                    self.ir.tcx.sess.add_lint(lint::builtin::UNUSED_VARIABLE, id, sp,
                         format!("unused variable: `{}`", *name));
                 }
             }
@@ -1582,7 +1582,7 @@ fn warn_about_dead_assign(&self,
         if self.live_on_exit(ln, var).is_none() {
             let r = self.should_warn(var);
             for name in r.iter() {
-                self.ir.tcx.sess.add_lint(lint::builtin::dead_assignment, id, sp,
+                self.ir.tcx.sess.add_lint(lint::builtin::DEAD_ASSIGNMENT, id, sp,
                     format!("value assigned to `{}` is never read", *name));
             }
         }

src/librustc/middle/privacy.rs

@@ -1394,7 +1394,7 @@ fn visit_ty(&mut self, t: &ast::Ty, _: ()) {
             ast::TyPath(ref p, _, path_id) => {
                 if self.path_is_private_type(path_id) {
                     self.tcx.sess.add_lint(
-                        lint::builtin::visible_private_types,
+                        lint::builtin::VISIBLE_PRIVATE_TYPES,
                         path_id, p.span,
                         "private type in exported type \
                          signature".to_string());

src/librustc/middle/resolve.rs

@@ -4632,7 +4632,7 @@ fn resolve_path(&mut self,
             match (def, unqualified_def) {
                 (Some((d, _)), Some((ud, _))) if d == ud => {
                     self.session
-                        .add_lint(lint::builtin::unnecessary_qualification,
+                        .add_lint(lint::builtin::UNNECESSARY_QUALIFICATION,
                                   id,
                                   path.span,
                                   "unnecessary qualification".to_string());
@@ -5487,7 +5487,7 @@ fn check_for_item_unused_imports(&mut self, vi: &ViewItem) {
                         if !self.used_imports.contains(&(id, TypeNS)) &&
                            !self.used_imports.contains(&(id, ValueNS)) {
                             self.session
-                                .add_lint(lint::builtin::unused_imports,
+                                .add_lint(lint::builtin::UNUSED_IMPORTS,
                                           id,
                                           p.span,
                                           "unused import".to_string());
@@ -5511,7 +5511,7 @@ fn finalize_import(&mut self, id: NodeId, span: Span) {
 
         if !self.used_imports.contains(&(id, TypeNS)) &&
            !self.used_imports.contains(&(id, ValueNS)) {
-            self.session.add_lint(lint::builtin::unused_imports,
+            self.session.add_lint(lint::builtin::UNUSED_IMPORTS,
                                   id,
                                   span,
                                   "unused import".to_string());

src/librustc/middle/trans/base.rs

@@ -1553,7 +1553,7 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span,
     let mut sizes = Vec::new(); // does no allocation if no pushes, thankfully
 
     let levels = ccx.tcx.node_lint_levels.borrow();
-    let lint_id = lint::LintId::of(lint::builtin::variant_size_difference);
+    let lint_id = lint::LintId::of(lint::builtin::VARIANT_SIZE_DIFFERENCE);
     let lvlsrc = match levels.find(&(id, lint_id)) {
         None | Some(&(lint::Allow, _)) => return,
         Some(&lvlsrc) => lvlsrc,
@@ -1590,7 +1590,7 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span,
     if largest > slargest * 3 && slargest > 0 {
         // Use lint::raw_emit_lint rather than sess.add_lint because the lint-printing
         // pass for the latter already ran.
-        lint::raw_emit_lint(&ccx.tcx().sess, lint::builtin::variant_size_difference,
+        lint::raw_emit_lint(&ccx.tcx().sess, lint::builtin::VARIANT_SIZE_DIFFERENCE,
             lvlsrc, Some(sp),
             format!("enum variant is more than three times larger \
                      ({} bytes) than the next largest (ignoring padding)",

src/librustc/middle/typeck/check/mod.rs

@@ -3416,7 +3416,7 @@ pub fn check_block_with_expected(fcx: &FnCtxt,
                 fcx.ccx
                    .tcx
                    .sess
-                   .add_lint(lint::builtin::unreachable_code,
+                   .add_lint(lint::builtin::UNREACHABLE_CODE,
                              s_id,
                              s.span,
                              "unreachable statement".to_string());
@@ -3443,7 +3443,7 @@ pub fn check_block_with_expected(fcx: &FnCtxt,
                 fcx.ccx
                    .tcx
                    .sess
-                   .add_lint(lint::builtin::unreachable_code,
+                   .add_lint(lint::builtin::UNREACHABLE_CODE,
                              e.id,
                              e.span,
                              "unreachable expression".to_string());

src/librustdoc/core.rs

@@ -75,7 +75,7 @@ fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<String>)
 
     let input = FileInput(cpath.clone());
 
-    let warning_lint = lint::builtin::warnings.name.to_string();
+    let warning_lint = lint::builtin::WARNINGS.name_lower();
 
     let sessopts = driver::config::Options {
         maybe_sysroot: Some(os::self_exe_path().unwrap().dir_path()),