Rollup merge of #66060 - traxys:test_65401, r=michaelwoerister

Making ICEs and test them in incremental

This adds:
 - A way to make the compiler ICE
 - A way to check for ICE in `cfail` tests with `should-ice`
 - A regression test for issue #65401

I am not sure the attribute added `should-ice` is the best for this job

Author: Centril

src/librustc/query/mod.rs

@@ -29,6 +29,12 @@ use syntax_pos::symbol::Symbol;
 // Queries marked with `fatal_cycle` do not need the latter implementation,
 // as they will raise an fatal error on query cycles instead.
 rustc_queries! {
+    Other {
+        query trigger_delay_span_bug(key: DefId) -> () {
+            desc { "trigger a delay span bug" }
+        }
+    }
+
     Other {
         /// Records the type of every item.
         query type_of(key: DefId) -> Ty<'tcx> {

src/librustc_codegen_utils/lib.rs

@@ -19,26 +19,58 @@ extern crate rustc;
 
 use rustc::ty::TyCtxt;
 use rustc::ty::query::Providers;
-use rustc::hir::def_id::LOCAL_CRATE;
+use rustc::hir::def_id::{LOCAL_CRATE, DefId};
 use syntax::symbol::sym;
 
 pub mod link;
 pub mod codegen_backend;
 pub mod symbol_names;
 pub mod symbol_names_test;
 
+
+pub fn trigger_delay_span_bug(tcx: TyCtxt<'_>, key: DefId) {
+    tcx.sess.delay_span_bug(
+        tcx.def_span(key),
+        "delayed span bug triggered by #[rustc_error(delay_span_bug_from_inside_query)]"
+    );
+}
+
 /// check for the #[rustc_error] annotation, which forces an
 /// error in codegen. This is used to write compile-fail tests
 /// that actually test that compilation succeeds without
 /// reporting an error.
 pub fn check_for_rustc_errors_attr(tcx: TyCtxt<'_>) {
     if let Some((def_id, _)) = tcx.entry_fn(LOCAL_CRATE) {
-        if tcx.has_attr(def_id, sym::rustc_error) {
-            tcx.sess.span_fatal(tcx.def_span(def_id), "compilation successful");
+        let attrs = &*tcx.get_attrs(def_id);
+        for attr in attrs {
+            if attr.check_name(sym::rustc_error) {
+                match attr.meta_item_list() {
+                    // check if there is a #[rustc_error(delayed)]
+                    Some(list) => {
+                        if list.iter().any(|list_item| {
+                            list_item.ident().map(|i| i.name) ==
+                                Some(sym::delay_span_bug_from_inside_query)
+                        }) {
+                            tcx.ensure().trigger_delay_span_bug(def_id);
+                        }
+                    }
+                    // bare #[rustc_error]
+                    None => {
+                        tcx.sess.span_fatal(
+                            tcx.def_span(def_id),
+                            "fatal error triggered by #[rustc_error]"
+                        );
+                    }
+                }
+            }
         }
     }
 }
 
 pub fn provide(providers: &mut Providers<'_>) {
     crate::symbol_names::provide(providers);
+    *providers = Providers {
+        trigger_delay_span_bug,
+        ..*providers
+    };
 }

src/libsyntax/feature_gate/builtin_attrs.rs

@@ -543,7 +543,10 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     rustc_attr!(TEST, rustc_variance, Normal, template!(Word)),
     rustc_attr!(TEST, rustc_layout, Normal, template!(List: "field1, field2, ...")),
     rustc_attr!(TEST, rustc_regions, Normal, template!(Word)),
-    rustc_attr!(TEST, rustc_error, Whitelisted, template!(Word)),
+    rustc_attr!(
+        TEST, rustc_error, Whitelisted,
+        template!(Word, List: "delay_span_bug_from_inside_query")
+    ),
     rustc_attr!(TEST, rustc_dump_user_substs, Whitelisted, template!(Word)),
     rustc_attr!(TEST, rustc_if_this_changed, Whitelisted, template!(Word, List: "DepNode")),
     rustc_attr!(TEST, rustc_then_this_would_need, Whitelisted, template!(List: "DepNode")),

src/libsyntax_pos/symbol.rs

@@ -236,6 +236,7 @@ symbols! {
         default_lib_allocator,
         default_type_parameter_fallback,
         default_type_params,
+        delay_span_bug_from_inside_query,
         deny,
         deprecated,
         deref,

src/test/incremental/delayed_span_bug.rs

@@ -0,0 +1,8 @@
+// revisions: cfail1 cfail2
+// should-ice
+// error-pattern: delayed span bug triggered by #[rustc_error(delay_span_bug_from_inside_query)]
+
+#![feature(rustc_attrs)]
+
+#[rustc_error(delay_span_bug_from_inside_query)]
+fn main() {}

src/test/ui/associated-types/bound-lifetime-constrained.rs

@@ -45,4 +45,4 @@ fn clause2<T>() where T: for<'a> Fn() -> <() as Foo<'a>>::Item {
 }
 
 #[rustc_error]
-fn main() { } //[ok]~ ERROR compilation successful
+fn main() { } //[ok]~ ERROR fatal error triggered by #[rustc_error]

src/test/ui/associated-types/bound-lifetime-in-binding-only.ok.stderr

@@ -1,4 +1,4 @@
-error: compilation successful
+error: fatal error triggered by #[rustc_error]
   --> $DIR/bound-lifetime-in-binding-only.rs:71:1
    |
 LL | fn main() { }

src/test/ui/associated-types/bound-lifetime-in-binding-only.rs

@@ -68,4 +68,4 @@ fn ok3<T>() where for<'a> Parameterized<'a>: Foo<Item=&'a i32> {
 }
 
 #[rustc_error]
-fn main() { } //[ok]~ ERROR compilation successful
+fn main() { } //[ok]~ ERROR fatal error triggered by #[rustc_error]

src/test/ui/associated-types/bound-lifetime-in-return-only.ok.stderr

@@ -1,4 +1,4 @@
-error: compilation successful
+error: fatal error triggered by #[rustc_error]
   --> $DIR/bound-lifetime-in-return-only.rs:49:1
    |
 LL | fn main() { }

src/test/ui/associated-types/bound-lifetime-in-return-only.rs

@@ -46,4 +46,4 @@ fn ok2(_: &dyn for<'a,'b> Fn<(&'b Parameterized<'a>,), Output=&'a i32>) {
 }
 
 #[rustc_error]
-fn main() { } //[ok]~ ERROR compilation successful
+fn main() { } //[ok]~ ERROR fatal error triggered by #[rustc_error]