Auto merge of #52568 - oli-obk:span_bug_error, r=varkor

Fix loop label resolution around constants

And make `delay_span_bug` a little more helpful

r? @varkor

fixes #52442
fixes #52443

Author: bors

src/librustc/hir/lowering.rs

@@ -104,7 +104,6 @@ pub struct LoweringContext<'a> {
     loop_scopes: Vec<NodeId>,
     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
@@ -232,7 +231,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(),
@@ -972,26 +970,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)),
@@ -3490,22 +3484,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 {

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());

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()
         },

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();
     }
 

src/librustc_errors/lib.rs

@@ -274,7 +274,7 @@ pub struct Handler {
     err_count: AtomicUsize,
     emitter: Lock<Box<dyn Emitter + sync::Send>>,
     continue_after_error: LockCell<bool>,
-    delayed_span_bug: Lock<Option<Diagnostic>>,
+    delayed_span_bugs: Lock<Vec<Diagnostic>>,
 
     // 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<fn(&Diagnostic)> =
 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_bugs.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_bugs: 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<S: Into<MultiSpan>>(&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_bugs.borrow_mut().push(diagnostic);
     }
     pub fn span_bug_no_panic<S: Into<MultiSpan>>(&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();

src/librustc_resolve/lib.rs

@@ -2359,7 +2359,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();
     }
 

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);

src/librustdoc/core.rs

@@ -162,6 +162,7 @@ pub fn new_handler(error_format: ErrorOutputType, codemap: Option<Lrc<codemap::C
         errors::HandlerFlags {
             can_emit_warnings: true,
             treat_err_as_bug: false,
+            report_delayed_bugs: false,
             external_macro_backtrace: false,
             ..Default::default()
         },

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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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
+}

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`.