From 56c90774a94e521283030caa12c1bf8d9bc16be4 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Thu, 19 Jul 2018 17:53:44 +0200 Subject: [PATCH 1/4] Make sure the compiler actually panics on `delay_span_bug` Even if that is just happening because of `abort_if_errors` --- src/librustc/session/config.rs | 6 +++++ src/librustc/session/mod.rs | 2 ++ src/librustc_errors/diagnostic_builder.rs | 2 +- src/librustc_errors/lib.rs | 32 ++++++++++++++++++----- src/librustdoc/core.rs | 1 + 5 files changed, 36 insertions(+), 7 deletions(-) diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 55752141e30eb..293b5c63cf06a 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1193,6 +1193,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options, "run all passes except codegen; no output"), treat_err_as_bug: bool = (false, parse_bool, [TRACKED], "treat all errors that occur as bugs"), + report_delayed_bugs: bool = (false, parse_bool, [TRACKED], + "immediately print bugs registered with `delay_span_bug`"), external_macro_backtrace: bool = (false, parse_bool, [UNTRACKED], "show macro backtraces even for non-local macros"), teach: bool = (false, parse_bool, [TRACKED], @@ -3133,6 +3135,10 @@ mod tests { opts.debugging_opts.treat_err_as_bug = true; assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash()); + opts = reference.clone(); + opts.debugging_opts.report_delayed_bugs = true; + assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash()); + opts = reference.clone(); opts.debugging_opts.continue_parse_after_error = true; assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash()); diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index ad1df0a1348c5..77a1129f66d27 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -1000,6 +1000,7 @@ pub fn build_session_with_codemap( let can_emit_warnings = !(warnings_allow || cap_lints_allow); let treat_err_as_bug = sopts.debugging_opts.treat_err_as_bug; + let report_delayed_bugs = sopts.debugging_opts.report_delayed_bugs; let external_macro_backtrace = sopts.debugging_opts.external_macro_backtrace; @@ -1045,6 +1046,7 @@ pub fn build_session_with_codemap( errors::HandlerFlags { can_emit_warnings, treat_err_as_bug, + report_delayed_bugs, external_macro_backtrace, ..Default::default() }, diff --git a/src/librustc_errors/diagnostic_builder.rs b/src/librustc_errors/diagnostic_builder.rs index 9c7b7ea339540..24ece514a47b5 100644 --- a/src/librustc_errors/diagnostic_builder.rs +++ b/src/librustc_errors/diagnostic_builder.rs @@ -132,7 +132,7 @@ impl<'a> DiagnosticBuilder<'a> { /// locally in whichever way makes the most sense. pub fn delay_as_bug(&mut self) { self.level = Level::Bug; - *self.handler.delayed_span_bug.borrow_mut() = Some(self.diagnostic.clone()); + self.handler.delay_as_bug(self.diagnostic.clone()); self.cancel(); } diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs index f18a7bd9136a2..06c49b3a103d7 100644 --- a/src/librustc_errors/lib.rs +++ b/src/librustc_errors/lib.rs @@ -274,7 +274,7 @@ pub struct Handler { err_count: AtomicUsize, emitter: Lock>, continue_after_error: LockCell, - delayed_span_bug: Lock>, + delayed_span_bug: Lock>, // This set contains the `DiagnosticId` of all emitted diagnostics to avoid // emitting the same diagnostic with extended help (`--teach`) twice, which @@ -299,9 +299,25 @@ thread_local!(pub static TRACK_DIAGNOSTICS: Cell = pub struct HandlerFlags { pub can_emit_warnings: bool, pub treat_err_as_bug: bool, + pub report_delayed_bugs: bool, pub external_macro_backtrace: bool, } +impl Drop for Handler { + fn drop(&mut self) { + if self.err_count() == 0 { + let mut bugs = self.delayed_span_bug.borrow_mut(); + let has_bugs = !bugs.is_empty(); + for bug in bugs.drain(..) { + DiagnosticBuilder::new_diagnostic(self, bug).emit(); + } + if has_bugs { + panic!("no errors encountered even though `delay_span_bug` issued"); + } + } + } +} + impl Handler { pub fn with_tty_emitter(color_config: ColorConfig, can_emit_warnings: bool, @@ -346,7 +362,7 @@ impl Handler { err_count: AtomicUsize::new(0), emitter: Lock::new(e), continue_after_error: LockCell::new(true), - delayed_span_bug: Lock::new(None), + delayed_span_bug: Lock::new(Vec::new()), taught_diagnostics: Lock::new(FxHashSet()), emitted_diagnostic_codes: Lock::new(FxHashSet()), emitted_diagnostics: Lock::new(FxHashSet()), @@ -503,11 +519,18 @@ impl Handler { } pub fn delay_span_bug>(&self, sp: S, msg: &str) { if self.flags.treat_err_as_bug { + // FIXME: don't abort here if report_delayed_bugs is off self.span_bug(sp, msg); } let mut diagnostic = Diagnostic::new(Level::Bug, msg); diagnostic.set_span(sp.into()); - *self.delayed_span_bug.borrow_mut() = Some(diagnostic); + self.delay_as_bug(diagnostic); + } + fn delay_as_bug(&self, diagnostic: Diagnostic) { + if self.flags.report_delayed_bugs { + DiagnosticBuilder::new_diagnostic(self, diagnostic.clone()).emit(); + } + self.delayed_span_bug.borrow_mut().push(diagnostic); } pub fn span_bug_no_panic>(&self, sp: S, msg: &str) { self.emit(&sp.into(), msg, Bug); @@ -615,9 +638,6 @@ impl Handler { pub fn abort_if_errors(&self) { if self.err_count() == 0 { - if let Some(bug) = self.delayed_span_bug.borrow_mut().take() { - DiagnosticBuilder::new_diagnostic(self, bug).emit(); - } return; } FatalError.raise(); diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 0a56c639220b4..a31357349a4b6 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -161,6 +161,7 @@ pub fn new_handler(error_format: ErrorOutputType, codemap: Option Date: Fri, 20 Jul 2018 12:01:10 +0200 Subject: [PATCH 2/4] Remove outdated comment --- src/librustc_typeck/check/mod.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 6e09b83a7b059..afafa6fa43780 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -857,9 +857,6 @@ fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized); // Gather locals in statics (because of block expressions). - // This is technically unnecessary because locals in static items are forbidden, - // but prevents type checking from blowing up before const checking can properly - // emit an error. GatherLocalsVisitor { fcx: &fcx }.visit_body(body); fcx.check_expr_coercable_to_type(&body.value, expected_type); From e93635325b52eb79b5c279d2fad4b325dd44876a Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Fri, 20 Jul 2018 15:59:00 +0200 Subject: [PATCH 3/4] Properly scope label resolution --- src/librustc/hir/lowering.rs | 58 +++++++++-------------- src/librustc_resolve/lib.rs | 2 + src/test/ui/const-eval/issue-52442.rs | 13 +++++ src/test/ui/const-eval/issue-52442.stderr | 9 ++++ src/test/ui/const-eval/issue-52443.rs | 18 +++++++ src/test/ui/const-eval/issue-52443.stderr | 51 ++++++++++++++++++++ 6 files changed, 115 insertions(+), 36 deletions(-) create mode 100644 src/test/ui/const-eval/issue-52442.rs create mode 100644 src/test/ui/const-eval/issue-52442.stderr create mode 100644 src/test/ui/const-eval/issue-52443.rs create mode 100644 src/test/ui/const-eval/issue-52443.stderr diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 93fb282546bb0..313f4af762f4a 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -103,7 +103,6 @@ pub struct LoweringContext<'a> { loop_scopes: Vec, is_in_loop_condition: bool, is_in_trait_impl: bool, - is_in_anon_const: bool, /// What to do when we encounter either an "anonymous lifetime /// reference". The term "anonymous" is meant to encompass both @@ -231,7 +230,6 @@ pub fn lower_crate( node_id_to_hir_id: IndexVec::new(), is_generator: false, is_in_trait_impl: false, - is_in_anon_const: false, lifetimes_to_define: Vec::new(), is_collecting_in_band_lifetimes: false, in_scope_lifetimes: Vec::new(), @@ -970,26 +968,22 @@ impl<'a> LoweringContext<'a> { } fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination { - let target_id = if self.is_in_anon_const { - Err(hir::LoopIdError::OutsideLoopScope) - } else { - match destination { - Some((id, _)) => { - if let Def::Label(loop_id) = self.expect_full_def(id) { - Ok(self.lower_node_id(loop_id).node_id) - } else { - Err(hir::LoopIdError::UnresolvedLabel) - } - } - None => { - self.loop_scopes - .last() - .map(|innermost_loop_id| *innermost_loop_id) - .map(|id| Ok(self.lower_node_id(id).node_id)) - .unwrap_or(Err(hir::LoopIdError::OutsideLoopScope)) - .into() + let target_id = match destination { + Some((id, _)) => { + if let Def::Label(loop_id) = self.expect_full_def(id) { + Ok(self.lower_node_id(loop_id).node_id) + } else { + Err(hir::LoopIdError::UnresolvedLabel) } } + None => { + self.loop_scopes + .last() + .map(|innermost_loop_id| *innermost_loop_id) + .map(|id| Ok(self.lower_node_id(id).node_id)) + .unwrap_or(Err(hir::LoopIdError::OutsideLoopScope)) + .into() + } }; hir::Destination { label: self.lower_label(destination.map(|(_, label)| label)), @@ -3448,22 +3442,14 @@ impl<'a> LoweringContext<'a> { } fn lower_anon_const(&mut self, c: &AnonConst) -> hir::AnonConst { - let was_in_loop_condition = self.is_in_loop_condition; - self.is_in_loop_condition = false; - let was_in_anon_const = self.is_in_anon_const; - self.is_in_anon_const = true; - - let LoweredNodeId { node_id, hir_id } = self.lower_node_id(c.id); - let anon_const = hir::AnonConst { - id: node_id, - hir_id, - body: self.lower_body(None, |this| this.lower_expr(&c.value)), - }; - - self.is_in_anon_const = was_in_anon_const; - self.is_in_loop_condition = was_in_loop_condition; - - anon_const + self.with_new_scopes(|this| { + let LoweredNodeId { node_id, hir_id } = this.lower_node_id(c.id); + hir::AnonConst { + id: node_id, + hir_id, + body: this.lower_body(None, |this| this.lower_expr(&c.value)), + } + }) } fn lower_expr(&mut self, e: &Expr) -> hir::Expr { diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 177e4ed8cf376..f3e8a04e2ee35 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -2358,7 +2358,9 @@ impl<'a> Resolver<'a> { where F: FnOnce(&mut Resolver) { self.ribs[ValueNS].push(Rib::new(ConstantItemRibKind)); + self.label_ribs.push(Rib::new(ConstantItemRibKind)); f(self); + self.label_ribs.pop(); self.ribs[ValueNS].pop(); } diff --git a/src/test/ui/const-eval/issue-52442.rs b/src/test/ui/const-eval/issue-52442.rs new file mode 100644 index 0000000000000..755dc153d4052 --- /dev/null +++ b/src/test/ui/const-eval/issue-52442.rs @@ -0,0 +1,13 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + [(); { &loop { break } as *const _ as usize } ]; //~ ERROR unimplemented expression type +} diff --git a/src/test/ui/const-eval/issue-52442.stderr b/src/test/ui/const-eval/issue-52442.stderr new file mode 100644 index 0000000000000..586c9fa22cecd --- /dev/null +++ b/src/test/ui/const-eval/issue-52442.stderr @@ -0,0 +1,9 @@ +error[E0019]: constant contains unimplemented expression type + --> $DIR/issue-52442.rs:12:14 + | +LL | [(); { &loop { break } as *const _ as usize } ]; //~ ERROR unimplemented expression type + | ^^^^^^^^^^^^^^ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0019`. diff --git a/src/test/ui/const-eval/issue-52443.rs b/src/test/ui/const-eval/issue-52443.rs new file mode 100644 index 0000000000000..2ae94f6d6420a --- /dev/null +++ b/src/test/ui/const-eval/issue-52443.rs @@ -0,0 +1,18 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + [(); & { loop { continue } } ]; //~ ERROR mismatched types + [(); loop { break }]; //~ ERROR mismatched types + [(); {while true {break}; 0}]; //~ ERROR constant contains unimplemented expression type + [(); { for _ in 0usize.. {}; 0}]; //~ ERROR calls in constants are limited to constant functions + //~^ ERROR constant contains unimplemented expression type + //~| ERROR could not evaluate repeat length +} diff --git a/src/test/ui/const-eval/issue-52443.stderr b/src/test/ui/const-eval/issue-52443.stderr new file mode 100644 index 0000000000000..3a145ba78d9b1 --- /dev/null +++ b/src/test/ui/const-eval/issue-52443.stderr @@ -0,0 +1,51 @@ +error[E0308]: mismatched types + --> $DIR/issue-52443.rs:12:10 + | +LL | [(); & { loop { continue } } ]; //~ ERROR mismatched types + | ^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected usize, found reference + | help: consider removing the borrow: `{ loop { continue } }` + | + = note: expected type `usize` + found type `&_` + +error[E0308]: mismatched types + --> $DIR/issue-52443.rs:13:17 + | +LL | [(); loop { break }]; //~ ERROR mismatched types + | ^^^^^ expected (), found usize + | + = note: expected type `()` + found type `usize` + +error[E0019]: constant contains unimplemented expression type + --> $DIR/issue-52443.rs:14:11 + | +LL | [(); {while true {break}; 0}]; //~ ERROR constant contains unimplemented expression type + | ^^^^^^^^^^^^^^^^^^ + +error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants + --> $DIR/issue-52443.rs:15:21 + | +LL | [(); { for _ in 0usize.. {}; 0}]; //~ ERROR calls in constants are limited to constant functions + | ^^^^^^^^ + +error[E0019]: constant contains unimplemented expression type + --> $DIR/issue-52443.rs:15:21 + | +LL | [(); { for _ in 0usize.. {}; 0}]; //~ ERROR calls in constants are limited to constant functions + | ^^^^^^^^ + +error[E0080]: could not evaluate repeat length + --> $DIR/issue-52443.rs:15:10 + | +LL | [(); { for _ in 0usize.. {}; 0}]; //~ ERROR calls in constants are limited to constant functions + | ^^^^^^^^^^^--------^^^^^^^ + | | + | calling non-const fn `>::into_iter` + +error: aborting due to 6 previous errors + +Some errors occurred: E0015, E0019, E0080, E0308. +For more information about an error, try `rustc --explain E0015`. From bab5eb41a7f3f755708527d97a1f8bf09b15d570 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Sat, 21 Jul 2018 16:09:10 +0200 Subject: [PATCH 4/4] Sequence-field should have plural name --- src/librustc_errors/lib.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs index 06c49b3a103d7..c0f07645f496a 100644 --- a/src/librustc_errors/lib.rs +++ b/src/librustc_errors/lib.rs @@ -274,7 +274,7 @@ pub struct Handler { err_count: AtomicUsize, emitter: Lock>, continue_after_error: LockCell, - delayed_span_bug: Lock>, + delayed_span_bugs: Lock>, // This set contains the `DiagnosticId` of all emitted diagnostics to avoid // emitting the same diagnostic with extended help (`--teach`) twice, which @@ -306,7 +306,7 @@ pub struct HandlerFlags { impl Drop for Handler { fn drop(&mut self) { if self.err_count() == 0 { - let mut bugs = self.delayed_span_bug.borrow_mut(); + let mut bugs = self.delayed_span_bugs.borrow_mut(); let has_bugs = !bugs.is_empty(); for bug in bugs.drain(..) { DiagnosticBuilder::new_diagnostic(self, bug).emit(); @@ -362,7 +362,7 @@ impl Handler { err_count: AtomicUsize::new(0), emitter: Lock::new(e), continue_after_error: LockCell::new(true), - delayed_span_bug: Lock::new(Vec::new()), + delayed_span_bugs: Lock::new(Vec::new()), taught_diagnostics: Lock::new(FxHashSet()), emitted_diagnostic_codes: Lock::new(FxHashSet()), emitted_diagnostics: Lock::new(FxHashSet()), @@ -530,7 +530,7 @@ impl Handler { if self.flags.report_delayed_bugs { DiagnosticBuilder::new_diagnostic(self, diagnostic.clone()).emit(); } - self.delayed_span_bug.borrow_mut().push(diagnostic); + self.delayed_span_bugs.borrow_mut().push(diagnostic); } pub fn span_bug_no_panic>(&self, sp: S, msg: &str) { self.emit(&sp.into(), msg, Bug);