add rustc_error(delay_span_bug_from_inside_query) attribute

Author: traxys

src/librustc/query/mod.rs

@@ -29,6 +29,12 @@ use syntax_pos::symbol::InternedString;
 // 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,52 @@ 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), "compilation successful");
+}
+
 /// 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), "compilation successful");
+                    }
+                }
+            }
         }
     }
 }
 
 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

@@ -533,7 +533,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

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