src/librustc/lint/mod.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Lints, aka compiler warnings.
  12 //!
  13 //! A 'lint' check is a kind of miscellaneous constraint that a user _might_
  14 //! want to enforce, but might reasonably want to permit as well, on a
  15 //! module-by-module basis. They contrast with static constraints enforced by
  16 //! other phases of the compiler, which are generally required to hold in order
  17 //! to compile the program at all.
  18 //!
  19 //! Most lints can be written as `LintPass` instances. These run just before
  20 //! translation to LLVM bytecode. The `LintPass`es built into rustc are defined
  21 //! within `builtin.rs`, which has further comments on how to add such a lint.
  22 //! rustc can also load user-defined lint plugins via the plugin mechanism.
  23 //!
  24 //! Some of rustc's lints are defined elsewhere in the compiler and work by
  25 //! calling `add_lint()` on the overall `Session` object. This works when
  26 //! it happens before the main lint pass, which emits the lints stored by
  27 //! `add_lint()`. To emit lints after the main lint pass (from trans, for
  28 //! example) requires more effort. See `emit_lint` and `GatherNodeLevels`
  29 //! in `context.rs`.
  30
  31 pub use self::Level::*;
  32 pub use self::LintSource::*;
  33
  34 use rustc_data_structures::sync::Lrc;
  35
  36 use errors::{DiagnosticBuilder, DiagnosticId};
  37 use hir::def_id::{CrateNum, LOCAL_CRATE};
  38 use hir::intravisit::{self, FnKind};
  39 use hir;
  40 use lint::builtin::BuiltinLintDiagnostics;
  41 use session::{Session, DiagnosticMessageId};
  42 use std::hash;
  43 use syntax::ast;
  44 use syntax::codemap::MultiSpan;
  45 use syntax::edition::Edition;
  46 use syntax::symbol::Symbol;
  47 use syntax::visit as ast_visit;
  48 use syntax_pos::Span;
  49 use ty::TyCtxt;
  50 use ty::maps::Providers;
  51 use util::nodemap::NodeMap;
  52
  53 pub use lint::context::{LateContext, EarlyContext, LintContext, LintStore,
  54                         check_crate, check_ast_crate,
  55                         FutureIncompatibleInfo, BufferedEarlyLint};
  56
  57 /// Specification of a single lint.
  58 #[derive(Copy, Clone, Debug)]
  59 pub struct Lint {
  60     /// A string identifier for the lint.
  61     ///
  62     /// This identifies the lint in attributes and in command-line arguments.
  63     /// In those contexts it is always lowercase, but this field is compared
  64     /// in a way which is case-insensitive for ASCII characters. This allows
  65     /// `declare_lint!()` invocations to follow the convention of upper-case
  66     /// statics without repeating the name.
  67     ///
  68     /// The name is written with underscores, e.g. "unused_imports".
  69     /// On the command line, underscores become dashes.
  70     pub name: &'static str,
  71
  72     /// Default level for the lint.
  73     pub default_level: Level,
  74
  75     /// Description of the lint or the issue it detects.
  76     ///
  77     /// e.g. "imports that are never used"
  78     pub desc: &'static str,
  79
  80     /// Deny lint after this edition
  81     pub edition_deny: Option<Edition>,
  82 }
  83
  84 impl Lint {
  85     /// Get the lint's name, with ASCII letters converted to lowercase.
  86     pub fn name_lower(&self) -> String {
  87         self.name.to_ascii_lowercase()
  88     }
  89
  90     pub fn default_level(&self, session: &Session) -> Level {
  91         if let Some(edition_deny) = self.edition_deny {
  92             if session.edition() >= edition_deny {
  93                 return Level::Deny
  94             }
  95         }
  96         self.default_level
  97     }
  98 }
  99
 100 /// Declare a static item of type `&'static Lint`.
 101 #[macro_export]
 102 macro_rules! declare_lint {
 103     ($vis: vis $NAME: ident, $Level: ident, $desc: expr, $edition: expr) => (
 104         $vis static $NAME: &$crate::lint::Lint = &$crate::lint::Lint {
 105             name: stringify!($NAME),
 106             default_level: $crate::lint::$Level,
 107             desc: $desc,
 108             edition_deny: Some($edition)
 109         };
 110     );
 111     ($vis: vis $NAME: ident, $Level: ident, $desc: expr) => (
 112         $vis static $NAME: &$crate::lint::Lint = &$crate::lint::Lint {
 113             name: stringify!($NAME),
 114             default_level: $crate::lint::$Level,
 115             desc: $desc,
 116             edition_deny: None,
 117         };
 118     );
 119 }
 120
 121 /// Declare a static `LintArray` and return it as an expression.
 122 #[macro_export]
 123 macro_rules! lint_array {
 124     ($( $lint:expr ),*,) => { lint_array!( $( $lint ),* ) };
 125     ($( $lint:expr ),*) => {{
 126          static ARRAY: LintArray = &[ $( &$lint ),* ];
 127          ARRAY
 128     }}
 129 }
 130
 131 pub type LintArray = &'static [&'static &'static Lint];
 132
 133 pub trait LintPass {
 134     /// Get descriptions of the lints this `LintPass` object can emit.
 135     ///
 136     /// NB: there is no enforcement that the object only emits lints it registered.
 137     /// And some `rustc` internal `LintPass`es register lints to be emitted by other
 138     /// parts of the compiler. If you want enforced access restrictions for your
 139     /// `Lint`, make it a private `static` item in its own module.
 140     fn get_lints(&self) -> LintArray;
 141 }
 142
 143
 144 /// Trait for types providing lint checks.
 145 ///
 146 /// Each `check` method checks a single syntax node, and should not
 147 /// invoke methods recursively (unlike `Visitor`). By default they
 148 /// do nothing.
 149 //
 150 // FIXME: eliminate the duplication with `Visitor`. But this also
 151 // contains a few lint-specific methods with no equivalent in `Visitor`.
 152 pub trait LateLintPass<'a, 'tcx>: LintPass {
 153     fn check_body(&mut self, _: &LateContext, _: &'tcx hir::Body) { }
 154     fn check_body_post(&mut self, _: &LateContext, _: &'tcx hir::Body) { }
 155     fn check_name(&mut self, _: &LateContext, _: Span, _: ast::Name) { }
 156     fn check_crate(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Crate) { }
 157     fn check_crate_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Crate) { }
 158     fn check_mod(&mut self,
 159                  _: &LateContext<'a, 'tcx>,
 160                  _: &'tcx hir::Mod,
 161                  _: Span,
 162                  _: ast::NodeId) { }
 163     fn check_mod_post(&mut self,
 164                       _: &LateContext<'a, 'tcx>,
 165                       _: &'tcx hir::Mod,
 166                       _: Span,
 167                       _: ast::NodeId) { }
 168     fn check_foreign_item(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::ForeignItem) { }
 169     fn check_foreign_item_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::ForeignItem) { }
 170     fn check_item(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Item) { }
 171     fn check_item_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Item) { }
 172     fn check_local(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Local) { }
 173     fn check_block(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Block) { }
 174     fn check_block_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Block) { }
 175     fn check_stmt(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Stmt) { }
 176     fn check_arm(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Arm) { }
 177     fn check_pat(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Pat) { }
 178     fn check_decl(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Decl) { }
 179     fn check_expr(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Expr) { }
 180     fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Expr) { }
 181     fn check_ty(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Ty) { }
 182     fn check_generic_param(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::GenericParam) { }
 183     fn check_generics(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Generics) { }
 184     fn check_where_predicate(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::WherePredicate) { }
 185     fn check_poly_trait_ref(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::PolyTraitRef,
 186                             _: hir::TraitBoundModifier) { }
 187     fn check_fn(&mut self,
 188                 _: &LateContext<'a, 'tcx>,
 189                 _: FnKind<'tcx>,
 190                 _: &'tcx hir::FnDecl,
 191                 _: &'tcx hir::Body,
 192                 _: Span,
 193                 _: ast::NodeId) { }
 194     fn check_fn_post(&mut self,
 195                      _: &LateContext<'a, 'tcx>,
 196                      _: FnKind<'tcx>,
 197                      _: &'tcx hir::FnDecl,
 198                      _: &'tcx hir::Body,
 199                      _: Span,
 200                      _: ast::NodeId) { }
 201     fn check_trait_item(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::TraitItem) { }
 202     fn check_trait_item_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::TraitItem) { }
 203     fn check_impl_item(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::ImplItem) { }
 204     fn check_impl_item_post(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::ImplItem) { }
 205     fn check_struct_def(&mut self,
 206                         _: &LateContext<'a, 'tcx>,
 207                         _: &'tcx hir::VariantData,
 208                         _: ast::Name,
 209                         _: &'tcx hir::Generics,
 210                         _: ast::NodeId) { }
 211     fn check_struct_def_post(&mut self,
 212                              _: &LateContext<'a, 'tcx>,
 213                              _: &'tcx hir::VariantData,
 214                              _: ast::Name,
 215                              _: &'tcx hir::Generics,
 216                              _: ast::NodeId) { }
 217     fn check_struct_field(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::StructField) { }
 218     fn check_variant(&mut self,
 219                      _: &LateContext<'a, 'tcx>,
 220                      _: &'tcx hir::Variant,
 221                      _: &'tcx hir::Generics) { }
 222     fn check_variant_post(&mut self,
 223                           _: &LateContext<'a, 'tcx>,
 224                           _: &'tcx hir::Variant,
 225                           _: &'tcx hir::Generics) { }
 226     fn check_lifetime(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Lifetime) { }
 227     fn check_path(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx hir::Path, _: ast::NodeId) { }
 228     fn check_attribute(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx ast::Attribute) { }
 229
 230     /// Called when entering a syntax node that can have lint attributes such
 231     /// as `#[allow(...)]`. Called with *all* the attributes of that node.
 232     fn enter_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx [ast::Attribute]) { }
 233
 234     /// Counterpart to `enter_lint_attrs`.
 235     fn exit_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx [ast::Attribute]) { }
 236 }
 237
 238 pub trait EarlyLintPass: LintPass {
 239     fn check_ident(&mut self, _: &EarlyContext, _: Span, _: ast::Ident) { }
 240     fn check_crate(&mut self, _: &EarlyContext, _: &ast::Crate) { }
 241     fn check_crate_post(&mut self, _: &EarlyContext, _: &ast::Crate) { }
 242     fn check_mod(&mut self, _: &EarlyContext, _: &ast::Mod, _: Span, _: ast::NodeId) { }
 243     fn check_mod_post(&mut self, _: &EarlyContext, _: &ast::Mod, _: Span, _: ast::NodeId) { }
 244     fn check_foreign_item(&mut self, _: &EarlyContext, _: &ast::ForeignItem) { }
 245     fn check_foreign_item_post(&mut self, _: &EarlyContext, _: &ast::ForeignItem) { }
 246     fn check_item(&mut self, _: &EarlyContext, _: &ast::Item) { }
 247     fn check_item_post(&mut self, _: &EarlyContext, _: &ast::Item) { }
 248     fn check_local(&mut self, _: &EarlyContext, _: &ast::Local) { }
 249     fn check_block(&mut self, _: &EarlyContext, _: &ast::Block) { }
 250     fn check_block_post(&mut self, _: &EarlyContext, _: &ast::Block) { }
 251     fn check_stmt(&mut self, _: &EarlyContext, _: &ast::Stmt) { }
 252     fn check_arm(&mut self, _: &EarlyContext, _: &ast::Arm) { }
 253     fn check_pat(&mut self, _: &EarlyContext, _: &ast::Pat) { }
 254     fn check_expr(&mut self, _: &EarlyContext, _: &ast::Expr) { }
 255     fn check_expr_post(&mut self, _: &EarlyContext, _: &ast::Expr) { }
 256     fn check_ty(&mut self, _: &EarlyContext, _: &ast::Ty) { }
 257     fn check_generic_param(&mut self, _: &EarlyContext, _: &ast::GenericParam) { }
 258     fn check_generics(&mut self, _: &EarlyContext, _: &ast::Generics) { }
 259     fn check_where_predicate(&mut self, _: &EarlyContext, _: &ast::WherePredicate) { }
 260     fn check_poly_trait_ref(&mut self, _: &EarlyContext, _: &ast::PolyTraitRef,
 261                             _: &ast::TraitBoundModifier) { }
 262     fn check_fn(&mut self, _: &EarlyContext,
 263         _: ast_visit::FnKind, _: &ast::FnDecl, _: Span, _: ast::NodeId) { }
 264     fn check_fn_post(&mut self, _: &EarlyContext,
 265         _: ast_visit::FnKind, _: &ast::FnDecl, _: Span, _: ast::NodeId) { }
 266     fn check_trait_item(&mut self, _: &EarlyContext, _: &ast::TraitItem) { }
 267     fn check_trait_item_post(&mut self, _: &EarlyContext, _: &ast::TraitItem) { }
 268     fn check_impl_item(&mut self, _: &EarlyContext, _: &ast::ImplItem) { }
 269     fn check_impl_item_post(&mut self, _: &EarlyContext, _: &ast::ImplItem) { }
 270     fn check_struct_def(&mut self, _: &EarlyContext,
 271         _: &ast::VariantData, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { }
 272     fn check_struct_def_post(&mut self, _: &EarlyContext,
 273         _: &ast::VariantData, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { }
 274     fn check_struct_field(&mut self, _: &EarlyContext, _: &ast::StructField) { }
 275     fn check_variant(&mut self, _: &EarlyContext, _: &ast::Variant, _: &ast::Generics) { }
 276     fn check_variant_post(&mut self, _: &EarlyContext, _: &ast::Variant, _: &ast::Generics) { }
 277     fn check_lifetime(&mut self, _: &EarlyContext, _: &ast::Lifetime) { }
 278     fn check_path(&mut self, _: &EarlyContext, _: &ast::Path, _: ast::NodeId) { }
 279     fn check_attribute(&mut self, _: &EarlyContext, _: &ast::Attribute) { }
 280
 281     /// Called when entering a syntax node that can have lint attributes such
 282     /// as `#[allow(...)]`. Called with *all* the attributes of that node.
 283     fn enter_lint_attrs(&mut self, _: &EarlyContext, _: &[ast::Attribute]) { }
 284
 285     /// Counterpart to `enter_lint_attrs`.
 286     fn exit_lint_attrs(&mut self, _: &EarlyContext, _: &[ast::Attribute]) { }
 287 }
 288
 289 /// A lint pass boxed up as a trait object.
 290 pub type EarlyLintPassObject = Box<dyn EarlyLintPass + 'static>;
 291 pub type LateLintPassObject = Box<dyn for<'a, 'tcx> LateLintPass<'a, 'tcx> + 'static>;
 292
 293 /// Identifies a lint known to the compiler.
 294 #[derive(Clone, Copy, Debug)]
 295 pub struct LintId {
 296     // Identity is based on pointer equality of this field.
 297     lint: &'static Lint,
 298 }
 299
 300 impl PartialEq for LintId {
 301     fn eq(&self, other: &LintId) -> bool {
 302         (self.lint as *const Lint) == (other.lint as *const Lint)
 303     }
 304 }
 305
 306 impl Eq for LintId { }
 307
 308 impl hash::Hash for LintId {
 309     fn hash<H: hash::Hasher>(&self, state: &mut H) {
 310         let ptr = self.lint as *const Lint;
 311         ptr.hash(state);
 312     }
 313 }
 314
 315 impl LintId {
 316     /// Get the `LintId` for a `Lint`.
 317     pub fn of(lint: &'static Lint) -> LintId {
 318         LintId {
 319             lint,
 320         }
 321     }
 322
 323     pub fn lint_name_raw(&self) -> &'static str {
 324         self.lint.name
 325     }
 326
 327     /// Get the name of the lint.
 328     pub fn to_string(&self) -> String {
 329         self.lint.name_lower()
 330     }
 331 }
 332
 333 /// Setting for how to handle a lint.
 334 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
 335 pub enum Level {
 336     Allow, Warn, Deny, Forbid,
 337 }
 338
 339 impl_stable_hash_for!(enum self::Level {
 340     Allow,
 341     Warn,
 342     Deny,
 343     Forbid
 344 });
 345
 346 impl Level {
 347     /// Convert a level to a lower-case string.
 348     pub fn as_str(self) -> &'static str {
 349         match self {
 350             Allow => "allow",
 351             Warn => "warn",
 352             Deny => "deny",
 353             Forbid => "forbid",
 354         }
 355     }
 356
 357     /// Convert a lower-case string to a level.
 358     pub fn from_str(x: &str) -> Option<Level> {
 359         match x {
 360             "allow" => Some(Allow),
 361             "warn" => Some(Warn),
 362             "deny" => Some(Deny),
 363             "forbid" => Some(Forbid),
 364             _ => None,
 365         }
 366     }
 367 }
 368
 369 /// How a lint level was set.
 370 #[derive(Clone, Copy, PartialEq, Eq)]
 371 pub enum LintSource {
 372     /// Lint is at the default level as declared
 373     /// in rustc or a plugin.
 374     Default,
 375
 376     /// Lint level was set by an attribute.
 377     Node(ast::Name, Span),
 378
 379     /// Lint level was set by a command-line flag.
 380     CommandLine(Symbol),
 381 }
 382
 383 impl_stable_hash_for!(enum self::LintSource {
 384     Default,
 385     Node(name, span),
 386     CommandLine(text)
 387 });
 388
 389 pub type LevelSource = (Level, LintSource);
 390
 391 pub mod builtin;
 392 mod context;
 393 mod levels;
 394
 395 pub use self::levels::{LintLevelSets, LintLevelMap};
 396
 397 pub struct LintBuffer {
 398     map: NodeMap<Vec<BufferedEarlyLint>>,
 399 }
 400
 401 impl LintBuffer {
 402     pub fn new() -> LintBuffer {
 403         LintBuffer { map: NodeMap() }
 404     }
 405
 406     pub fn add_lint(&mut self,
 407                     lint: &'static Lint,
 408                     id: ast::NodeId,
 409                     sp: MultiSpan,
 410                     msg: &str,
 411                     diagnostic: BuiltinLintDiagnostics) {
 412         let early_lint = BufferedEarlyLint {
 413             lint_id: LintId::of(lint),
 414             ast_id: id,
 415             span: sp,
 416             msg: msg.to_string(),
 417             diagnostic
 418         };
 419         let arr = self.map.entry(id).or_insert(Vec::new());
 420         if !arr.contains(&early_lint) {
 421             arr.push(early_lint);
 422         }
 423     }
 424
 425     pub fn take(&mut self, id: ast::NodeId) -> Vec<BufferedEarlyLint> {
 426         self.map.remove(&id).unwrap_or(Vec::new())
 427     }
 428
 429     pub fn get_any(&self) -> Option<&[BufferedEarlyLint]> {
 430         let key = self.map.keys().next().map(|k| *k);
 431         key.map(|k| &self.map[&k][..])
 432     }
 433 }
 434
 435 pub fn struct_lint_level<'a>(sess: &'a Session,
 436                              lint: &'static Lint,
 437                              level: Level,
 438                              src: LintSource,
 439                              span: Option<MultiSpan>,
 440                              msg: &str)
 441     -> DiagnosticBuilder<'a>
 442 {
 443     let mut err = match (level, span) {
 444         (Level::Allow, _) => return sess.diagnostic().struct_dummy(),
 445         (Level::Warn, Some(span)) => sess.struct_span_warn(span, msg),
 446         (Level::Warn, None) => sess.struct_warn(msg),
 447         (Level::Deny, Some(span)) |
 448         (Level::Forbid, Some(span)) => sess.struct_span_err(span, msg),
 449         (Level::Deny, None) |
 450         (Level::Forbid, None) => sess.struct_err(msg),
 451     };
 452
 453     let name = lint.name_lower();
 454     match src {
 455         LintSource::Default => {
 456             sess.diag_note_once(
 457                 &mut err,
 458                 DiagnosticMessageId::from(lint),
 459                 &format!("#[{}({})] on by default", level.as_str(), name));
 460         }
 461         LintSource::CommandLine(lint_flag_val) => {
 462             let flag = match level {
 463                 Level::Warn => "-W",
 464                 Level::Deny => "-D",
 465                 Level::Forbid => "-F",
 466                 Level::Allow => panic!(),
 467             };
 468             let hyphen_case_lint_name = name.replace("_", "-");
 469             if lint_flag_val.as_str() == name {
 470                 sess.diag_note_once(
 471                     &mut err,
 472                     DiagnosticMessageId::from(lint),
 473                     &format!("requested on the command line with `{} {}`",
 474                              flag, hyphen_case_lint_name));
 475             } else {
 476                 let hyphen_case_flag_val = lint_flag_val.as_str().replace("_", "-");
 477                 sess.diag_note_once(
 478                     &mut err,
 479                     DiagnosticMessageId::from(lint),
 480                     &format!("`{} {}` implied by `{} {}`",
 481                              flag, hyphen_case_lint_name, flag,
 482                              hyphen_case_flag_val));
 483             }
 484         }
 485         LintSource::Node(lint_attr_name, src) => {
 486             sess.diag_span_note_once(&mut err, DiagnosticMessageId::from(lint),
 487                                      src, "lint level defined here");
 488             if lint_attr_name.as_str() != name {
 489                 let level_str = level.as_str();
 490                 sess.diag_note_once(&mut err, DiagnosticMessageId::from(lint),
 491                                     &format!("#[{}({})] implied by #[{}({})]",
 492                                              level_str, name, level_str, lint_attr_name));
 493             }
 494         }
 495     }
 496
 497     err.code(DiagnosticId::Lint(name));
 498
 499     // Check for future incompatibility lints and issue a stronger warning.
 500     let lints = sess.lint_store.borrow();
 501     if let Some(future_incompatible) = lints.future_incompatible(LintId::of(lint)) {
 502         let future = if let Some(edition) = future_incompatible.edition {
 503             format!("the {} edition", edition)
 504         } else {
 505             "a future release".to_owned()
 506         };
 507         let explanation = format!("this was previously accepted by the compiler \
 508                                    but is being phased out; \
 509                                    it will become a hard error in {}!", future);
 510         let citation = format!("for more information, see {}",
 511                                future_incompatible.reference);
 512         err.warn(&explanation);
 513         err.note(&citation);
 514     }
 515
 516     return err
 517 }
 518
 519 fn lint_levels<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, cnum: CrateNum)
 520     -> Lrc<LintLevelMap>
 521 {
 522     assert_eq!(cnum, LOCAL_CRATE);
 523     let mut builder = LintLevelMapBuilder {
 524         levels: LintLevelSets::builder(tcx.sess),
 525         tcx: tcx,
 526     };
 527     let krate = tcx.hir.krate();
 528
 529     builder.with_lint_attrs(ast::CRATE_NODE_ID, &krate.attrs, |builder| {
 530         intravisit::walk_crate(builder, krate);
 531     });
 532
 533     Lrc::new(builder.levels.build_map())
 534 }
 535
 536 struct LintLevelMapBuilder<'a, 'tcx: 'a> {
 537     levels: levels::LintLevelsBuilder<'tcx>,
 538     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 539 }
 540
 541 impl<'a, 'tcx> LintLevelMapBuilder<'a, 'tcx> {
 542     fn with_lint_attrs<F>(&mut self,
 543                           id: ast::NodeId,
 544                           attrs: &[ast::Attribute],
 545                           f: F)
 546         where F: FnOnce(&mut Self)
 547     {
 548         let push = self.levels.push(attrs);
 549         self.levels.register_id(self.tcx.hir.definitions().node_to_hir_id(id));
 550         f(self);
 551         self.levels.pop(push);
 552     }
 553 }
 554
 555 impl<'a, 'tcx> intravisit::Visitor<'tcx> for LintLevelMapBuilder<'a, 'tcx> {
 556     fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'tcx> {
 557         intravisit::NestedVisitorMap::All(&self.tcx.hir)
 558     }
 559
 560     fn visit_item(&mut self, it: &'tcx hir::Item) {
 561         self.with_lint_attrs(it.id, &it.attrs, |builder| {
 562             intravisit::walk_item(builder, it);
 563         });
 564     }
 565
 566     fn visit_foreign_item(&mut self, it: &'tcx hir::ForeignItem) {
 567         self.with_lint_attrs(it.id, &it.attrs, |builder| {
 568             intravisit::walk_foreign_item(builder, it);
 569         })
 570     }
 571
 572     fn visit_expr(&mut self, e: &'tcx hir::Expr) {
 573         self.with_lint_attrs(e.id, &e.attrs, |builder| {
 574             intravisit::walk_expr(builder, e);
 575         })
 576     }
 577
 578     fn visit_struct_field(&mut self, s: &'tcx hir::StructField) {
 579         self.with_lint_attrs(s.id, &s.attrs, |builder| {
 580             intravisit::walk_struct_field(builder, s);
 581         })
 582     }
 583
 584     fn visit_variant(&mut self,
 585                      v: &'tcx hir::Variant,
 586                      g: &'tcx hir::Generics,
 587                      item_id: ast::NodeId) {
 588         self.with_lint_attrs(v.node.data.id(), &v.node.attrs, |builder| {
 589             intravisit::walk_variant(builder, v, g, item_id);
 590         })
 591     }
 592
 593     fn visit_local(&mut self, l: &'tcx hir::Local) {
 594         self.with_lint_attrs(l.id, &l.attrs, |builder| {
 595             intravisit::walk_local(builder, l);
 596         })
 597     }
 598
 599     fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem) {
 600         self.with_lint_attrs(trait_item.id, &trait_item.attrs, |builder| {
 601             intravisit::walk_trait_item(builder, trait_item);
 602         });
 603     }
 604
 605     fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem) {
 606         self.with_lint_attrs(impl_item.id, &impl_item.attrs, |builder| {
 607             intravisit::walk_impl_item(builder, impl_item);
 608         });
 609     }
 610 }
 611
 612 pub fn provide(providers: &mut Providers) {
 613     providers.lint_levels = lint_levels;
 614 }