Implement rustc side of report-future-incompat
This commit is contained in:
Aaron Hill
parent
ffe52882ed
commit
23018a55d9
22 changed files with 332 additions and 114 deletions
484
compiler/rustc_lint_defs/src/lib.rs
Normal file
484
compiler/rustc_lint_defs/src/lib.rs
Normal file
|
|
@ -0,0 +1,484 @@
|
|||
#[macro_use]
|
||||
extern crate rustc_macros;
|
||||
|
||||
pub use self::Level::*;
|
||||
use rustc_ast::node_id::{NodeId, NodeMap};
|
||||
use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
|
||||
use rustc_span::edition::Edition;
|
||||
use rustc_span::{sym, symbol::Ident, MultiSpan, Span, Symbol};
|
||||
|
||||
pub mod builtin;
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! pluralize {
|
||||
($x:expr) => {
|
||||
if $x != 1 { "s" } else { "" }
|
||||
};
|
||||
}
|
||||
|
||||
/// Indicates the confidence in the correctness of a suggestion.
|
||||
///
|
||||
/// All suggestions are marked with an `Applicability`. Tools use the applicability of a suggestion
|
||||
/// to determine whether it should be automatically applied or if the user should be consulted
|
||||
/// before applying the suggestion.
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Hash, Encodable, Decodable)]
|
||||
pub enum Applicability {
|
||||
/// The suggestion is definitely what the user intended. This suggestion should be
|
||||
/// automatically applied.
|
||||
MachineApplicable,
|
||||
|
||||
/// The suggestion may be what the user intended, but it is uncertain. The suggestion should
|
||||
/// result in valid Rust code if it is applied.
|
||||
MaybeIncorrect,
|
||||
|
||||
/// The suggestion contains placeholders like `(...)` or `{ /* fields */ }`. The suggestion
|
||||
/// cannot be applied automatically because it will not result in valid Rust code. The user
|
||||
/// will need to fill in the placeholders.
|
||||
HasPlaceholders,
|
||||
|
||||
/// The applicability of the suggestion is unknown.
|
||||
Unspecified,
|
||||
}
|
||||
|
||||
/// Setting for how to handle a lint.
|
||||
#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
|
||||
pub enum Level {
|
||||
Allow,
|
||||
Warn,
|
||||
Deny,
|
||||
Forbid,
|
||||
}
|
||||
|
||||
rustc_data_structures::impl_stable_hash_via_hash!(Level);
|
||||
|
||||
impl Level {
|
||||
/// Converts a level to a lower-case string.
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Level::Allow => "allow",
|
||||
Level::Warn => "warn",
|
||||
Level::Deny => "deny",
|
||||
Level::Forbid => "forbid",
|
||||
}
|
||||
}
|
||||
|
||||
/// Converts a lower-case string to a level.
|
||||
pub fn from_str(x: &str) -> Option<Level> {
|
||||
match x {
|
||||
"allow" => Some(Level::Allow),
|
||||
"warn" => Some(Level::Warn),
|
||||
"deny" => Some(Level::Deny),
|
||||
"forbid" => Some(Level::Forbid),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Converts a symbol to a level.
|
||||
pub fn from_symbol(x: Symbol) -> Option<Level> {
|
||||
match x {
|
||||
sym::allow => Some(Level::Allow),
|
||||
sym::warn => Some(Level::Warn),
|
||||
sym::deny => Some(Level::Deny),
|
||||
sym::forbid => Some(Level::Forbid),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Specification of a single lint.
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub struct Lint {
|
||||
/// A string identifier for the lint.
|
||||
///
|
||||
/// This identifies the lint in attributes and in command-line arguments.
|
||||
/// In those contexts it is always lowercase, but this field is compared
|
||||
/// in a way which is case-insensitive for ASCII characters. This allows
|
||||
/// `declare_lint!()` invocations to follow the convention of upper-case
|
||||
/// statics without repeating the name.
|
||||
///
|
||||
/// The name is written with underscores, e.g., "unused_imports".
|
||||
/// On the command line, underscores become dashes.
|
||||
///
|
||||
/// See https://rustc-dev-guide.rust-lang.org/diagnostics.html#lint-naming
|
||||
/// for naming guidelines.
|
||||
pub name: &'static str,
|
||||
|
||||
/// Default level for the lint.
|
||||
///
|
||||
/// See https://rustc-dev-guide.rust-lang.org/diagnostics.html#diagnostic-levels
|
||||
/// for guidelines on choosing a default level.
|
||||
pub default_level: Level,
|
||||
|
||||
/// Description of the lint or the issue it detects.
|
||||
///
|
||||
/// e.g., "imports that are never used"
|
||||
pub desc: &'static str,
|
||||
|
||||
/// Starting at the given edition, default to the given lint level. If this is `None`, then use
|
||||
/// `default_level`.
|
||||
pub edition_lint_opts: Option<(Edition, Level)>,
|
||||
|
||||
/// `true` if this lint is reported even inside expansions of external macros.
|
||||
pub report_in_external_macro: bool,
|
||||
|
||||
pub future_incompatible: Option<FutureIncompatibleInfo>,
|
||||
|
||||
pub is_plugin: bool,
|
||||
|
||||
/// `Some` if this lint is feature gated, otherwise `None`.
|
||||
pub feature_gate: Option<Symbol>,
|
||||
|
||||
pub crate_level_only: bool,
|
||||
}
|
||||
|
||||
/// Extra information for a future incompatibility lint.
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub struct FutureIncompatibleInfo {
|
||||
/// e.g., a URL for an issue/PR/RFC or error code
|
||||
pub reference: &'static str,
|
||||
/// If this is an edition fixing lint, the edition in which
|
||||
/// this lint becomes obsolete
|
||||
pub edition: Option<Edition>,
|
||||
/// Information about a future breakage, which will
|
||||
/// be emitted in JSON messages to be displayed by Cargo
|
||||
/// for upstream deps
|
||||
pub future_breakage: Option<FutureBreakage>,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub struct FutureBreakage {
|
||||
pub date: Option<&'static str>,
|
||||
}
|
||||
|
||||
impl FutureIncompatibleInfo {
|
||||
pub const fn default_fields_for_macro() -> Self {
|
||||
FutureIncompatibleInfo { reference: "", edition: None, future_breakage: None }
|
||||
}
|
||||
}
|
||||
|
||||
impl Lint {
|
||||
pub const fn default_fields_for_macro() -> Self {
|
||||
Lint {
|
||||
name: "",
|
||||
default_level: Level::Forbid,
|
||||
desc: "",
|
||||
edition_lint_opts: None,
|
||||
is_plugin: false,
|
||||
report_in_external_macro: false,
|
||||
future_incompatible: None,
|
||||
feature_gate: None,
|
||||
crate_level_only: false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets the lint's name, with ASCII letters converted to lowercase.
|
||||
pub fn name_lower(&self) -> String {
|
||||
self.name.to_ascii_lowercase()
|
||||
}
|
||||
|
||||
pub fn default_level(&self, edition: Edition) -> Level {
|
||||
self.edition_lint_opts
|
||||
.filter(|(e, _)| *e <= edition)
|
||||
.map(|(_, l)| l)
|
||||
.unwrap_or(self.default_level)
|
||||
}
|
||||
}
|
||||
|
||||
/// Identifies a lint known to the compiler.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct LintId {
|
||||
// Identity is based on pointer equality of this field.
|
||||
pub lint: &'static Lint,
|
||||
}
|
||||
|
||||
impl PartialEq for LintId {
|
||||
fn eq(&self, other: &LintId) -> bool {
|
||||
std::ptr::eq(self.lint, other.lint)
|
||||
}
|
||||
}
|
||||
|
||||
impl Eq for LintId {}
|
||||
|
||||
impl std::hash::Hash for LintId {
|
||||
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
||||
let ptr = self.lint as *const Lint;
|
||||
ptr.hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
impl LintId {
|
||||
/// Gets the `LintId` for a `Lint`.
|
||||
pub fn of(lint: &'static Lint) -> LintId {
|
||||
LintId { lint }
|
||||
}
|
||||
|
||||
pub fn lint_name_raw(&self) -> &'static str {
|
||||
self.lint.name
|
||||
}
|
||||
|
||||
/// Gets the name of the lint.
|
||||
pub fn to_string(&self) -> String {
|
||||
self.lint.name_lower()
|
||||
}
|
||||
}
|
||||
|
||||
impl<HCX> HashStable<HCX> for LintId {
|
||||
#[inline]
|
||||
fn hash_stable(&self, hcx: &mut HCX, hasher: &mut StableHasher) {
|
||||
self.lint_name_raw().hash_stable(hcx, hasher);
|
||||
}
|
||||
}
|
||||
|
||||
impl<HCX> ToStableHashKey<HCX> for LintId {
|
||||
type KeyType = &'static str;
|
||||
|
||||
#[inline]
|
||||
fn to_stable_hash_key(&self, _: &HCX) -> &'static str {
|
||||
self.lint_name_raw()
|
||||
}
|
||||
}
|
||||
|
||||
// This could be a closure, but then implementing derive trait
|
||||
// becomes hacky (and it gets allocated).
|
||||
#[derive(PartialEq)]
|
||||
pub enum BuiltinLintDiagnostics {
|
||||
Normal,
|
||||
BareTraitObject(Span, /* is_global */ bool),
|
||||
AbsPathWithModule(Span),
|
||||
ProcMacroDeriveResolutionFallback(Span),
|
||||
MacroExpandedMacroExportsAccessedByAbsolutePaths(Span),
|
||||
ElidedLifetimesInPaths(usize, Span, bool, Span, String),
|
||||
UnknownCrateTypes(Span, String, String),
|
||||
UnusedImports(String, Vec<(Span, String)>),
|
||||
RedundantImport(Vec<(Span, bool)>, Ident),
|
||||
DeprecatedMacro(Option<Symbol>, Span),
|
||||
UnusedDocComment(Span),
|
||||
}
|
||||
|
||||
/// Lints that are buffered up early on in the `Session` before the
|
||||
/// `LintLevels` is calculated.
|
||||
#[derive(PartialEq)]
|
||||
pub struct BufferedEarlyLint {
|
||||
/// The span of code that we are linting on.
|
||||
pub span: MultiSpan,
|
||||
|
||||
/// The lint message.
|
||||
pub msg: String,
|
||||
|
||||
/// The `NodeId` of the AST node that generated the lint.
|
||||
pub node_id: NodeId,
|
||||
|
||||
/// A lint Id that can be passed to
|
||||
/// `rustc_lint::early::EarlyContextAndPass::check_id`.
|
||||
pub lint_id: LintId,
|
||||
|
||||
/// Customization of the `DiagnosticBuilder<'_>` for the lint.
|
||||
pub diagnostic: BuiltinLintDiagnostics,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct LintBuffer {
|
||||
pub map: NodeMap<Vec<BufferedEarlyLint>>,
|
||||
}
|
||||
|
||||
impl LintBuffer {
|
||||
pub fn add_early_lint(&mut self, early_lint: BufferedEarlyLint) {
|
||||
let arr = self.map.entry(early_lint.node_id).or_default();
|
||||
if !arr.contains(&early_lint) {
|
||||
arr.push(early_lint);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn add_lint(
|
||||
&mut self,
|
||||
lint: &'static Lint,
|
||||
node_id: NodeId,
|
||||
span: MultiSpan,
|
||||
msg: &str,
|
||||
diagnostic: BuiltinLintDiagnostics,
|
||||
) {
|
||||
let lint_id = LintId::of(lint);
|
||||
let msg = msg.to_string();
|
||||
self.add_early_lint(BufferedEarlyLint { lint_id, node_id, span, msg, diagnostic });
|
||||
}
|
||||
|
||||
pub fn take(&mut self, id: NodeId) -> Vec<BufferedEarlyLint> {
|
||||
self.map.remove(&id).unwrap_or_default()
|
||||
}
|
||||
|
||||
pub fn buffer_lint(
|
||||
&mut self,
|
||||
lint: &'static Lint,
|
||||
id: NodeId,
|
||||
sp: impl Into<MultiSpan>,
|
||||
msg: &str,
|
||||
) {
|
||||
self.add_lint(lint, id, sp.into(), msg, BuiltinLintDiagnostics::Normal)
|
||||
}
|
||||
|
||||
pub fn buffer_lint_with_diagnostic(
|
||||
&mut self,
|
||||
lint: &'static Lint,
|
||||
id: NodeId,
|
||||
sp: impl Into<MultiSpan>,
|
||||
msg: &str,
|
||||
diagnostic: BuiltinLintDiagnostics,
|
||||
) {
|
||||
self.add_lint(lint, id, sp.into(), msg, diagnostic)
|
||||
}
|
||||
}
|
||||
|
||||
/// Declares a static item of type `&'static Lint`.
|
||||
///
|
||||
/// See https://rustc-dev-guide.rust-lang.org/diagnostics.html for documentation
|
||||
/// and guidelines on writing lints.
|
||||
///
|
||||
/// The macro call should start with a doc comment explaining the lint
|
||||
/// which will be embedded in the rustc user documentation book. It should
|
||||
/// be written in markdown and have a format that looks like this:
|
||||
///
|
||||
/// ```rust,ignore (doc-example)
|
||||
/// /// The `my_lint_name` lint detects [short explanation here].
|
||||
/// ///
|
||||
/// /// ### Example
|
||||
/// ///
|
||||
/// /// ```rust
|
||||
/// /// [insert a concise example that triggers the lint]
|
||||
/// /// ```
|
||||
/// ///
|
||||
/// /// {{produces}}
|
||||
/// ///
|
||||
/// /// ### Explanation
|
||||
/// ///
|
||||
/// /// This should be a detailed explanation of *why* the lint exists,
|
||||
/// /// and also include suggestions on how the user should fix the problem.
|
||||
/// /// Try to keep the text simple enough that a beginner can understand,
|
||||
/// /// and include links to other documentation for terminology that a
|
||||
/// /// beginner may not be familiar with. If this is "allow" by default,
|
||||
/// /// it should explain why (are there false positives or other issues?). If
|
||||
/// /// this is a future-incompatible lint, it should say so, with text that
|
||||
/// /// looks roughly like this:
|
||||
/// ///
|
||||
/// /// This is a [future-incompatible] lint to transition this to a hard
|
||||
/// /// error in the future. See [issue #xxxxx] for more details.
|
||||
/// ///
|
||||
/// /// [issue #xxxxx]: https://github.com/rust-lang/rust/issues/xxxxx
|
||||
/// ```
|
||||
///
|
||||
/// The `{{produces}}` tag will be automatically replaced with the output from
|
||||
/// the example by the build system. You can build and view the rustc book
|
||||
/// with `x.py doc --stage=1 src/doc/rustc --open`. If the lint example is too
|
||||
/// complex to run as a simple example (for example, it needs an extern
|
||||
/// crate), mark it with `ignore` and manually paste the expected output below
|
||||
/// the example.
|
||||
#[macro_export]
|
||||
macro_rules! declare_lint {
|
||||
($(#[$attr:meta])* $vis: vis $NAME: ident, $Level: ident, $desc: expr) => (
|
||||
$crate::declare_lint!(
|
||||
$(#[$attr])* $vis $NAME, $Level, $desc,
|
||||
);
|
||||
);
|
||||
($(#[$attr:meta])* $vis: vis $NAME: ident, $Level: ident, $desc: expr,
|
||||
$(@feature_gate = $gate:expr;)?
|
||||
$(@future_incompatible = FutureIncompatibleInfo { $($field:ident : $val:expr),* $(,)* }; )?
|
||||
$($v:ident),*) => (
|
||||
$(#[$attr])*
|
||||
$vis static $NAME: &$crate::Lint = &$crate::Lint {
|
||||
name: stringify!($NAME),
|
||||
default_level: $crate::$Level,
|
||||
desc: $desc,
|
||||
edition_lint_opts: None,
|
||||
is_plugin: false,
|
||||
$($v: true,)*
|
||||
$(feature_gate: Some($gate),)*
|
||||
$(future_incompatible: Some($crate::FutureIncompatibleInfo {
|
||||
$($field: $val,)*
|
||||
..$crate::FutureIncompatibleInfo::default_fields_for_macro()
|
||||
}),)*
|
||||
..$crate::Lint::default_fields_for_macro()
|
||||
};
|
||||
);
|
||||
($(#[$attr:meta])* $vis: vis $NAME: ident, $Level: ident, $desc: expr,
|
||||
$lint_edition: expr => $edition_level: ident
|
||||
) => (
|
||||
$(#[$attr])*
|
||||
$vis static $NAME: &$crate::Lint = &$crate::Lint {
|
||||
name: stringify!($NAME),
|
||||
default_level: $crate::$Level,
|
||||
desc: $desc,
|
||||
edition_lint_opts: Some(($lint_edition, $crate::Level::$edition_level)),
|
||||
report_in_external_macro: false,
|
||||
is_plugin: false,
|
||||
};
|
||||
);
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! declare_tool_lint {
|
||||
(
|
||||
$(#[$attr:meta])* $vis:vis $tool:ident ::$NAME:ident, $Level: ident, $desc: expr
|
||||
) => (
|
||||
$crate::declare_tool_lint!{$(#[$attr])* $vis $tool::$NAME, $Level, $desc, false}
|
||||
);
|
||||
(
|
||||
$(#[$attr:meta])* $vis:vis $tool:ident ::$NAME:ident, $Level:ident, $desc:expr,
|
||||
report_in_external_macro: $rep:expr
|
||||
) => (
|
||||
$crate::declare_tool_lint!{$(#[$attr])* $vis $tool::$NAME, $Level, $desc, $rep}
|
||||
);
|
||||
(
|
||||
$(#[$attr:meta])* $vis:vis $tool:ident ::$NAME:ident, $Level:ident, $desc:expr,
|
||||
$external:expr
|
||||
) => (
|
||||
$(#[$attr])*
|
||||
$vis static $NAME: &$crate::Lint = &$crate::Lint {
|
||||
name: &concat!(stringify!($tool), "::", stringify!($NAME)),
|
||||
default_level: $crate::$Level,
|
||||
desc: $desc,
|
||||
edition_lint_opts: None,
|
||||
report_in_external_macro: $external,
|
||||
future_incompatible: None,
|
||||
is_plugin: true,
|
||||
feature_gate: None,
|
||||
crate_level_only: false,
|
||||
};
|
||||
);
|
||||
}
|
||||
|
||||
/// Declares a static `LintArray` and return it as an expression.
|
||||
#[macro_export]
|
||||
macro_rules! lint_array {
|
||||
($( $lint:expr ),* ,) => { lint_array!( $($lint),* ) };
|
||||
($( $lint:expr ),*) => {{
|
||||
vec![$($lint),*]
|
||||
}}
|
||||
}
|
||||
|
||||
pub type LintArray = Vec<&'static Lint>;
|
||||
|
||||
pub trait LintPass {
|
||||
fn name(&self) -> &'static str;
|
||||
}
|
||||
|
||||
/// Implements `LintPass for $ty` with the given list of `Lint` statics.
|
||||
#[macro_export]
|
||||
macro_rules! impl_lint_pass {
|
||||
($ty:ty => [$($lint:expr),* $(,)?]) => {
|
||||
impl $crate::LintPass for $ty {
|
||||
fn name(&self) -> &'static str { stringify!($ty) }
|
||||
}
|
||||
impl $ty {
|
||||
pub fn get_lints() -> $crate::LintArray { $crate::lint_array!($($lint),*) }
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Declares a type named `$name` which implements `LintPass`.
|
||||
/// To the right of `=>` a comma separated list of `Lint` statics is given.
|
||||
#[macro_export]
|
||||
macro_rules! declare_lint_pass {
|
||||
($(#[$m:meta])* $name:ident => [$($lint:expr),* $(,)?]) => {
|
||||
$(#[$m])* #[derive(Copy, Clone)] pub struct $name;
|
||||
$crate::impl_lint_pass!($name => [$($lint),*]);
|
||||
};
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue