nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-02 07:22:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: refactor to derive for some lints.

Browse Source
This commit is contained in:
Rejyr 2022-11-10 19:32:30 -05:00
parent ca7df9a2a9
commit 78fce795d8
6 changed files with 100 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_error_messages/locales/en-US/lint.ftl
View File

@ -15,6 +15,7 @@ lint_enum_intrinsics_mem_variant =
lint_expectation = this lint expectation is unfulfilled
.note = the `unfulfilled_lint_expectations` lint can't be expected and will always produce this message
.rationale = {$rationale}
lint_for_loops_over_fallibles =
for loop over {$article} `{$ty}`. This is more readably written as an `if let` statement
@ -39,7 +40,8 @@ lint_deprecated_lint_name =
lint name `{$name}` is deprecated and may not have an effect in the future.
.suggestion = change it to
lint_renamed_or_removed_lint_suggestion = use the new name
lint_renamed_or_removed_lint = {$msg}
.suggestion = use the new name
lint_unknown_lint =
unknown lint: `{$name}`

16
compiler/rustc_lint/src/builtin.rs
View File

@ -26,7 +26,8 @@ use crate::{
BuiltinAnonymousParams, BuiltinBoxPointers, BuiltinConstNoMangle,
BuiltinDeprecatedAttrUsed, BuiltinDerefNullptr, BuiltinEllipsisInclusiveRangePatternsLint,
BuiltinExplicitOutlives, BuiltinExplicitOutlivesSuggestion, BuiltinIncompleteFeatures,
BuiltinKeywordIdents, BuiltinMissingCopyImpl, BuiltinMissingDebugImpl, BuiltinMissingDoc,
BuiltinIncompleteFeaturesHelp, BuiltinIncompleteFeaturesNote, BuiltinKeywordIdents,
BuiltinMissingCopyImpl, BuiltinMissingDebugImpl, BuiltinMissingDoc,
BuiltinMutablesTransmutes, BuiltinNoMangleGeneric, BuiltinNonShorthandFieldPatterns,
BuiltinSpecialModuleNameUsed, BuiltinTrivialBounds, BuiltinUnexpectedCliConfigName,
BuiltinUnexpectedCliConfigValue, BuiltinUnnameableTestItems, BuiltinUnreachablePub,
@ -2379,14 +2380,17 @@ impl EarlyLintPass for IncompleteFeatures {
.chain(features.declared_lib_features.iter().map(|(name, span)| (name, span)))
.filter(|(&name, _)| features.incomplete(name))
.for_each(|(&name, &span)| {
let note = rustc_feature::find_feature_issue(name, GateIssue::Language)
.map(|n| BuiltinIncompleteFeaturesNote { n });
let help = if HAS_MIN_FEATURES.contains(&name) {
Some(BuiltinIncompleteFeaturesHelp)
} else {
None
};
cx.emit_spanned_lint(
INCOMPLETE_FEATURES,
span,
BuiltinIncompleteFeatures {
name,
note: rustc_feature::find_feature_issue(name, GateIssue::Language),
help: HAS_MIN_FEATURES.contains(&name).then_some(()),
},
BuiltinIncompleteFeatures { name, note, help },
);
});
}

6
compiler/rustc_lint/src/expect.rs
View File

@ -1,6 +1,6 @@
#![deny(rustc::untranslatable_diagnostic)]
#![deny(rustc::diagnostic_outside_of_impl)]
use crate::lints::Expectation;
use crate::lints::{Expectation, ExpectationNote};
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::TyCtxt;
use rustc_session::lint::builtin::UNFULFILLED_LINT_EXPECTATIONS;
@ -29,11 +29,13 @@ fn check_expectations(tcx: TyCtxt<'_>, tool_filter: Option<Symbol>) {
if !fulfilled_expectations.contains(&id)
&& tool_filter.map_or(true, |filter| expectation.lint_tool == Some(filter))
{
let rationale = expectation.reason.map(|rationale| ExpectationNote { rationale });
let note = expectation.is_unfulfilled_lint_expectations.then_some(());
tcx.emit_spanned_lint(
UNFULFILLED_LINT_EXPECTATIONS,
*hir_id,
expectation.emission_span,
Expectation { expectation },
Expectation { rationale, note },
);
}
} else {

13
compiler/rustc_lint/src/levels.rs
View File

@ -4,7 +4,7 @@ use crate::context::{CheckLintNameResult, LintStore};
use crate::late::unerased_lint_store;
use crate::lints::{
DeprecatedLintName, IgnoredUnlessCrateSpecified, OverruledAtributeLint, RenamedOrRemovedLint,
UnknownLint,
RenamedOrRemovedLintSuggestion, UnknownLint, UnknownLintSuggestion,
};
use rustc_ast as ast;
use rustc_ast_pretty::pprust;
@ -887,10 +887,15 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
_ if !self.warn_about_weird_lints => {}
CheckLintNameResult::Warning(msg, renamed) => {
let suggestion =
renamed.as_ref().map(|replace| RenamedOrRemovedLintSuggestion {
suggestion: sp,
replace: replace.as_str(),
});
self.emit_spanned_lint(
RENAMED_AND_REMOVED_LINTS,
sp.into(),
RenamedOrRemovedLint { msg, suggestion: sp, renamed },
RenamedOrRemovedLint { msg, suggestion },
);
}
CheckLintNameResult::NoLint(suggestion) => {
@ -899,10 +904,12 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
} else {
name.to_string()
};
let suggestion = suggestion
.map(|replace| UnknownLintSuggestion { suggestion: sp, replace });
self.emit_spanned_lint(
UNKNOWN_LINTS,
sp.into(),
UnknownLint { name, suggestion: sp, replace: suggestion },
UnknownLint { name, suggestion },
);
}
}

176
compiler/rustc_lint/src/lints.rs
View File

@ -3,10 +3,7 @@ use std::num::NonZeroU32;
use rustc_errors::{fluent, AddToDiagnostic, Applicability, DecorateLint, DiagnosticMessage};
use rustc_hir::def_id::DefId;
use rustc_macros::{LintDiagnostic, Subdiagnostic};
use rustc_middle::{
lint::LintExpectation,
ty::{Predicate, Ty, TyCtxt},
};
use rustc_middle::ty::{Predicate, Ty, TyCtxt};
use rustc_span::{edition::Edition, symbol::Ident, Span, Symbol};
use crate::{errors::OverruledAttributeSub, LateContext};
@ -80,6 +77,7 @@ pub struct BuiltinMissingDebugImpl<'a> {
pub def_id: DefId,
}
// Needed for def_path_str
impl<'a> DecorateLint<'a, ()> for BuiltinMissingDebugImpl<'_> {
fn decorate_lint<'b>(
self,
@ -225,31 +223,24 @@ pub struct BuiltinExplicitOutlivesSuggestion {
pub applicability: Applicability,
}
#[derive(LintDiagnostic)]
#[diag(lint_builtin_incomplete_features)]
pub struct BuiltinIncompleteFeatures {
pub name: Symbol,
pub note: Option<NonZeroU32>,
pub help: Option<()>,
#[subdiagnostic]
pub note: Option<BuiltinIncompleteFeaturesNote>,
#[subdiagnostic]
pub help: Option<BuiltinIncompleteFeaturesHelp>,
}
impl<'a> DecorateLint<'a, ()> for BuiltinIncompleteFeatures {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
diag.set_arg("name", self.name);
if let Some(n) = self.note {
diag.set_arg("n", n);
diag.note(fluent::note);
}
if let Some(_) = self.help {
diag.help(fluent::help);
}
diag
}
#[derive(Subdiagnostic)]
#[help(help)]
pub struct BuiltinIncompleteFeaturesHelp;
fn msg(&self) -> DiagnosticMessage {
fluent::lint_builtin_incomplete_features
}
#[derive(Subdiagnostic)]
#[note(note)]
pub struct BuiltinIncompleteFeaturesNote {
pub n: NonZeroU32,
}
// FIXME: migrate "the type `{}` does not permit {}"
@ -308,29 +299,19 @@ pub struct EnumIntrinsicsMemVariant<'a> {
}
// expect.rs
pub struct Expectation<'a> {
pub expectation: &'a LintExpectation,
#[derive(LintDiagnostic)]
#[diag(lint_expectation)]
pub struct Expectation {
#[subdiagnostic]
pub rationale: Option<ExpectationNote>,
#[note]
pub note: Option<()>,
}
impl<'a> DecorateLint<'a, ()> for Expectation<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
if let Some(rationale) = self.expectation.reason {
diag.note(rationale.as_str());
}
if self.expectation.is_unfulfilled_lint_expectations {
diag.note(fluent::note);
}
diag
}
fn msg(&self) -> DiagnosticMessage {
fluent::lint_expectation
}
#[derive(Subdiagnostic)]
#[note(rationale)]
pub struct ExpectationNote {
pub rationale: Symbol,
}
// for_loops_over_fallibles.rs
@ -511,59 +492,37 @@ pub struct DeprecatedLintName<'a> {
pub replace: &'a str,
}
// FIXME: Non-translatable msg
#[derive(LintDiagnostic)]
#[diag(lint_renamed_or_removed_lint)]
pub struct RenamedOrRemovedLint<'a> {
pub msg: &'a str,
#[subdiagnostic]
pub suggestion: Option<RenamedOrRemovedLintSuggestion<'a>>,
}
#[derive(Subdiagnostic)]
#[suggestion(suggestion, code = "{replace}", applicability = "machine-applicable")]
pub struct RenamedOrRemovedLintSuggestion<'a> {
#[primary_span]
pub suggestion: Span,
pub renamed: &'a Option<String>,
pub replace: &'a str,
}
impl<'a> DecorateLint<'a, ()> for RenamedOrRemovedLint<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
if let Some(new_name) = self.renamed {
diag.span_suggestion(
self.suggestion,
fluent::lint_renamed_or_removed_lint_suggestion,
new_name,
Applicability::MachineApplicable,
);
};
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
rustc_errors::DiagnosticMessage::Str(self.msg.to_string())
}
}
pub struct UnknownLint<'a> {
#[derive(LintDiagnostic)]
#[diag(lint_unknown_lint)]
pub struct UnknownLint {
pub name: String,
pub suggestion: Span,
pub replace: &'a Option<Symbol>,
#[subdiagnostic]
pub suggestion: Option<UnknownLintSuggestion>,
}
impl<'a> DecorateLint<'a, ()> for UnknownLint<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
diag.set_arg("name", self.name);
if let Some(replace) = self.replace {
diag.span_suggestion(
self.suggestion,
fluent::suggestion,
replace,
Applicability::MaybeIncorrect,
);
};
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
fluent::lint_unknown_lint
}
#[derive(Subdiagnostic)]
#[suggestion(suggestion, code = "{replace}", applicability = "maybe-incorrect")]
pub struct UnknownLintSuggestion {
#[primary_span]
pub suggestion: Span,
pub replace: Symbol,
}
#[derive(LintDiagnostic)]
@ -618,6 +577,7 @@ pub struct NonFmtPanicUnused {
pub suggestion: Option<Span>,
}
// Used because of two suggestions based on one Option<Span>
impl<'a> DecorateLint<'a, ()> for NonFmtPanicUnused {
fn decorate_lint<'b>(
self,
@ -803,6 +763,7 @@ pub struct DropTraitConstraintsDiag<'a> {
pub def_id: DefId,
}
// Needed for def_path_str
impl<'a> DecorateLint<'a, ()> for DropTraitConstraintsDiag<'_> {
fn decorate_lint<'b>(
self,
@ -822,6 +783,7 @@ pub struct DropGlue<'a> {
pub def_id: DefId,
}
// Needed for def_path_str
impl<'a> DecorateLint<'a, ()> for DropGlue<'_> {
fn decorate_lint<'b>(
self,
@ -902,35 +864,22 @@ pub enum OverflowingBinHexSub<'a> {
Help { suggestion_ty: &'a str },
}
#[derive(LintDiagnostic)]
#[diag(lint_overflowing_int)]
#[note]
pub struct OverflowingInt<'a> {
pub ty: &'a str,
pub lit: String,
pub min: i128,
pub max: u128,
pub suggestion_ty: Option<&'a str>,
#[subdiagnostic]
pub help: Option<OverflowingIntHelp<'a>>,
}
// FIXME: refactor with `Option<&'a str>` in macro
impl<'a> DecorateLint<'a, ()> for OverflowingInt<'_> {
fn decorate_lint<'b>(
self,
diag: &'b mut rustc_errors::DiagnosticBuilder<'a, ()>,
) -> &'b mut rustc_errors::DiagnosticBuilder<'a, ()> {
diag.set_arg("ty", self.ty);
diag.set_arg("lit", self.lit);
diag.set_arg("min", self.min);
diag.set_arg("max", self.max);
diag.note(fluent::note);
if let Some(suggestion_ty) = self.suggestion_ty {
diag.set_arg("suggestion_ty", suggestion_ty);
diag.help(fluent::help);
}
diag
}
fn msg(&self) -> rustc_errors::DiagnosticMessage {
fluent::lint_overflowing_int
}
#[derive(Subdiagnostic)]
#[help(help)]
pub struct OverflowingIntHelp<'a> {
pub suggestion_ty: &'a str,
}
#[derive(LintDiagnostic)]
@ -972,6 +921,7 @@ pub struct ImproperCTypes<'a> {
pub span_note: Option<Span>,
}
// Used because of the complexity of Option<DiagnosticMessage>, DiagnosticMessage, and Option<Span>
impl<'a> DecorateLint<'a, ()> for ImproperCTypes<'_> {
fn decorate_lint<'b>(
self,
@ -1074,7 +1024,7 @@ pub struct UnusedDef<'a, 'b> {
pub note: Option<Symbol>,
}
// FIXME: refactor with `Option<String>` in macro
// Needed because of def_path_str
impl<'a> DecorateLint<'a, ()> for UnusedDef<'_, '_> {
fn decorate_lint<'b>(
self,

26
compiler/rustc_lint/src/types.rs
View File

@ -3,7 +3,7 @@
use crate::lints::{
AtomicOrderingFence, AtomicOrderingLoad, AtomicOrderingStore, ImproperCTypes,
InvalidAtomicOrderingDiag, OnlyCastu8ToChar, OverflowingBinHex, OverflowingBinHexSign,
OverflowingBinHexSub, OverflowingInt, OverflowingLiteral, OverflowingUInt,
OverflowingBinHexSub, OverflowingInt, OverflowingIntHelp, OverflowingLiteral, OverflowingUInt,
RangeEndpointOutOfRange, UnusedComparisons, VariantSizeDifferencesDiag,
};
use crate::{LateContext, LateLintPass, LintContext};
@ -339,24 +339,18 @@ fn lint_int_literal<'tcx>(
return;
}
let lit = cx
.sess()
.source_map()
.span_to_snippet(lit.span)
.expect("must get snippet from literal");
let help = get_type_suggestion(cx.typeck_results().node_type(e.hir_id), v, negative)
.map(|suggestion_ty| OverflowingIntHelp { suggestion_ty });
cx.emit_spanned_lint(
OVERFLOWING_LITERALS,
e.span,
OverflowingInt {
ty: t.name_str(),
lit: cx
.sess()
.source_map()
.span_to_snippet(lit.span)
.expect("must get snippet from literal"),
min,
max,
suggestion_ty: get_type_suggestion(
cx.typeck_results().node_type(e.hir_id),
v,
negative,
),
},
OverflowingInt { ty: t.name_str(), lit, min, max, help },
);
}
}