diff --git a/compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs b/compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs index 577baec21f064..2253007ce3027 100644 --- a/compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs +++ b/compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs @@ -145,8 +145,9 @@ impl AnnotateSnippetEmitterWriter { title: Some(Annotation { label: Some(&message), id: code.as_ref().map(|c| match c { - DiagnosticId::Error(val) - | DiagnosticId::Lint { name: val, has_future_breakage: _ } => val.as_str(), + DiagnosticId::Error(val) | DiagnosticId::Lint { name: val, .. } => { + val.as_str() + } }), annotation_type: annotation_type_for_level(*level), }), diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs index 14ccced2c6a56..45661ac15623f 100644 --- a/compiler/rustc_errors/src/diagnostic.rs +++ b/compiler/rustc_errors/src/diagnostic.rs @@ -29,7 +29,7 @@ pub struct Diagnostic { #[derive(Clone, Debug, PartialEq, Eq, Hash, Encodable, Decodable)] pub enum DiagnosticId { Error(String), - Lint { name: String, has_future_breakage: bool }, + Lint { name: String, has_future_breakage: bool, is_force_warn: bool }, } /// A "sub"-diagnostic attached to a parent diagnostic. @@ -109,6 +109,13 @@ impl Diagnostic { } } + pub fn is_force_warn(&self) -> bool { + match self.code { + Some(DiagnosticId::Lint { is_force_warn, .. }) => is_force_warn, + _ => false, + } + } + /// Cancel the diagnostic (a structured diagnostic must either be emitted or /// canceled or it will panic when dropped). pub fn cancel(&mut self) { diff --git a/compiler/rustc_errors/src/json.rs b/compiler/rustc_errors/src/json.rs index 72395bd31eca5..485e7564587ea 100644 --- a/compiler/rustc_errors/src/json.rs +++ b/compiler/rustc_errors/src/json.rs @@ -559,7 +559,7 @@ impl DiagnosticCode { s.map(|s| { let s = match s { DiagnosticId::Error(s) => s, - DiagnosticId::Lint { name, has_future_breakage: _ } => name, + DiagnosticId::Lint { name, .. } => name, }; let je_result = je.registry.as_ref().map(|registry| registry.try_find_description(&s)).unwrap(); diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index 979f2d3b3005d..323415f3300b2 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -521,12 +521,28 @@ impl Handler { } /// Construct a builder at the `Warning` level at the given `span` and with the `msg`. + /// + /// The builder will be canceled if warnings cannot be emitted. pub fn struct_span_warn(&self, span: impl Into, msg: &str) -> DiagnosticBuilder<'_> { let mut result = self.struct_warn(msg); result.set_span(span); result } + /// Construct a builder at the `Warning` level at the given `span` and with the `msg`. + /// + /// This will "force" the warning meaning it will not be canceled even + /// if warnings cannot be emitted. + pub fn struct_span_force_warn( + &self, + span: impl Into, + msg: &str, + ) -> DiagnosticBuilder<'_> { + let mut result = self.struct_force_warn(msg); + result.set_span(span); + result + } + /// Construct a builder at the `Allow` level at the given `span` and with the `msg`. pub fn struct_span_allow( &self, @@ -552,6 +568,8 @@ impl Handler { } /// Construct a builder at the `Warning` level with the `msg`. + /// + /// The builder will be canceled if warnings cannot be emitted. pub fn struct_warn(&self, msg: &str) -> DiagnosticBuilder<'_> { let mut result = DiagnosticBuilder::new(self, Level::Warning, msg); if !self.flags.can_emit_warnings { @@ -560,6 +578,14 @@ impl Handler { result } + /// Construct a builder at the `Warning` level with the `msg`. + /// + /// This will "force" a warning meaning it will not be canceled even + /// if warnings cannot be emitted. + pub fn struct_force_warn(&self, msg: &str) -> DiagnosticBuilder<'_> { + DiagnosticBuilder::new(self, Level::Warning, msg) + } + /// Construct a builder at the `Allow` level with the `msg`. pub fn struct_allow(&self, msg: &str) -> DiagnosticBuilder<'_> { DiagnosticBuilder::new(self, Level::Allow, msg) @@ -802,7 +828,10 @@ impl HandlerInner { self.future_breakage_diagnostics.push(diagnostic.clone()); } - if diagnostic.level == Warning && !self.flags.can_emit_warnings { + if diagnostic.level == Warning + && !self.flags.can_emit_warnings + && !diagnostic.is_force_warn() + { if diagnostic.has_future_breakage() { (*TRACK_DIAGNOSTICS)(diagnostic); } @@ -874,7 +903,7 @@ impl HandlerInner { match (errors.len(), warnings.len()) { (0, 0) => return, - (0, _) => self.emit_diagnostic(&Diagnostic::new(Level::Warning, &warnings)), + (0, _) => self.emitter.emit_diagnostic(&Diagnostic::new(Level::Warning, &warnings)), (_, 0) => { let _ = self.fatal(&errors); } diff --git a/compiler/rustc_middle/src/lint.rs b/compiler/rustc_middle/src/lint.rs index 7ac7720a7c563..efd8d56fd6fdd 100644 --- a/compiler/rustc_middle/src/lint.rs +++ b/compiler/rustc_middle/src/lint.rs @@ -108,8 +108,13 @@ impl LintLevelSets { } } - // Ensure that we never exceed the `--cap-lints` argument. - level = cmp::min(level, self.lint_cap); + // Ensure that we never exceed the `--cap-lints` argument + // unless the source is a --force-warn + level = if let LintLevelSource::CommandLine(_, Level::ForceWarn) = src { + level + } else { + cmp::min(level, self.lint_cap) + }; if let Some(driver_level) = sess.driver_lint_caps.get(&LintId::of(lint)) { // Ensure that we never exceed driver level. @@ -258,8 +263,10 @@ pub fn struct_lint_level<'s, 'd>( return; } } - (Level::Warn | Level::ForceWarn, Some(span)) => sess.struct_span_warn(span, ""), - (Level::Warn | Level::ForceWarn, None) => sess.struct_warn(""), + (Level::Warn, Some(span)) => sess.struct_span_warn(span, ""), + (Level::Warn, None) => sess.struct_warn(""), + (Level::ForceWarn, Some(span)) => sess.struct_span_force_warn(span, ""), + (Level::ForceWarn, None) => sess.struct_force_warn(""), (Level::Deny | Level::Forbid, Some(span)) => sess.struct_span_err(span, ""), (Level::Deny | Level::Forbid, None) => sess.struct_err(""), }; @@ -349,7 +356,8 @@ pub fn struct_lint_level<'s, 'd>( } } - err.code(DiagnosticId::Lint { name, has_future_breakage }); + let is_force_warn = matches!(level, Level::ForceWarn); + err.code(DiagnosticId::Lint { name, has_future_breakage, is_force_warn }); if let Some(future_incompatible) = future_incompatible { let explanation = if lint_id == LintId::of(builtin::UNSTABLE_NAME_COLLISIONS) { diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs index d8a58ee18cd8e..f6b7797c2e3b1 100644 --- a/compiler/rustc_session/src/session.rs +++ b/compiler/rustc_session/src/session.rs @@ -323,7 +323,7 @@ impl Session { .into_iter() .map(|diag| { let lint_name = match &diag.code { - Some(DiagnosticId::Lint { name, has_future_breakage: true }) => name, + Some(DiagnosticId::Lint { name, has_future_breakage: true, .. }) => name, _ => panic!("Unexpected code in diagnostic {:?}", diag), }; let lint = lint_store.name_to_lint(&lint_name); @@ -369,6 +369,13 @@ impl Session { pub fn struct_span_warn>(&self, sp: S, msg: &str) -> DiagnosticBuilder<'_> { self.diagnostic().struct_span_warn(sp, msg) } + pub fn struct_span_force_warn>( + &self, + sp: S, + msg: &str, + ) -> DiagnosticBuilder<'_> { + self.diagnostic().struct_span_force_warn(sp, msg) + } pub fn struct_span_warn_with_code>( &self, sp: S, @@ -380,6 +387,9 @@ impl Session { pub fn struct_warn(&self, msg: &str) -> DiagnosticBuilder<'_> { self.diagnostic().struct_warn(msg) } + pub fn struct_force_warn(&self, msg: &str) -> DiagnosticBuilder<'_> { + self.diagnostic().struct_force_warn(msg) + } pub fn struct_span_allow>(&self, sp: S, msg: &str) -> DiagnosticBuilder<'_> { self.diagnostic().struct_span_allow(sp, msg) } diff --git a/src/test/ui/lint/force-warn/force-warn-cap-lints-warn.rs b/src/test/ui/lint/force-warn/force-warn-cap-lints-warn.rs new file mode 100644 index 0000000000000..bcfe6e5a5bd6e --- /dev/null +++ b/src/test/ui/lint/force-warn/force-warn-cap-lints-warn.rs @@ -0,0 +1,15 @@ +// compile-flags: --cap-lints warn --force-warns rust-2021-compatibility -Zunstable-options +// check-pass +#![allow(ellipsis_inclusive_range_patterns)] + +pub fn f() -> bool { + let x = 123; + match x { + 0...100 => true, + //~^ WARN range patterns are deprecated + //~| WARN this is accepted in the current edition + _ => false, + } +} + +fn main() {} diff --git a/src/test/ui/lint/force-warn/force-warn-cap-lints-warn.stderr b/src/test/ui/lint/force-warn/force-warn-cap-lints-warn.stderr new file mode 100644 index 0000000000000..07e786ce7d266 --- /dev/null +++ b/src/test/ui/lint/force-warn/force-warn-cap-lints-warn.stderr @@ -0,0 +1,12 @@ +warning: `...` range patterns are deprecated + --> $DIR/force-warn-cap-lints-warn.rs:8:10 + | +LL | 0...100 => true, + | ^^^ help: use `..=` for an inclusive range + | + = note: `--force-warns ellipsis-inclusive-range-patterns` implied by `--force-warns rust-2021-compatibility` + = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! + = note: for more information, see issue #80165 + +warning: 1 warning emitted + diff --git a/src/test/ui/lint/force-warn/force-warns-cap-lints-allow.rs b/src/test/ui/lint/force-warn/force-warns-cap-lints-allow.rs new file mode 100644 index 0000000000000..e364897ec4ecb --- /dev/null +++ b/src/test/ui/lint/force-warn/force-warns-cap-lints-allow.rs @@ -0,0 +1,10 @@ +// compile-flags: --cap-lints allow --force-warns bare_trait_objects -Zunstable-options +// check-pass + +pub trait SomeTrait {} + +pub fn function(_x: Box) {} +//~^ WARN trait objects without an explicit `dyn` are deprecated +//~| WARN this is accepted in the current edition + +fn main() {} diff --git a/src/test/ui/lint/force-warn/force-warns-cap-lints-allow.stderr b/src/test/ui/lint/force-warn/force-warns-cap-lints-allow.stderr new file mode 100644 index 0000000000000..21532024f1c4a --- /dev/null +++ b/src/test/ui/lint/force-warn/force-warns-cap-lints-allow.stderr @@ -0,0 +1,12 @@ +warning: trait objects without an explicit `dyn` are deprecated + --> $DIR/force-warns-cap-lints-allow.rs:6:25 + | +LL | pub fn function(_x: Box) {} + | ^^^^^^^^^ help: use `dyn`: `dyn SomeTrait` + | + = note: requested on the command line with `--force-warns bare-trait-objects` + = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! + = note: for more information, see issue #80165 + +warning: 1 warning emitted +