cool new attribute

Author: lcnr

compiler/rustc_feature/src/builtin_attrs.rs

@@ -605,6 +605,11 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     rustc_attr!(
         rustc_conversion_suggestion, Normal, template!(Word), WarnFollowing, INTERNAL_UNSTABLE
     ),
+
+    rustc_attr!(
+        rustc_select_quick_discard, Normal, template!(Word), ErrorFollowing, INTERNAL_UNSTABLE
+    ),
+
     // Prevents field reads in the marked trait or method to be considered
     // during dead code analysis.
     rustc_attr!(

compiler/rustc_passes/src/check_attr.rs

@@ -121,6 +121,9 @@ impl CheckAttrVisitor<'_> {
                 sym::rustc_lint_diagnostics => {
                     self.check_rustc_lint_diagnostics(&attr, span, target)
                 }
+                sym::rustc_select_quick_discard => {
+                    self.check_rustc_select_quick_discard(&attr, span, target)
+                }
                 sym::rustc_clean
                 | sym::rustc_dirty
                 | sym::rustc_if_this_changed
@@ -1431,6 +1434,24 @@ impl CheckAttrVisitor<'_> {
         self.check_applied_to_fn_or_method(attr, span, target)
     }
 
+    fn check_rustc_select_quick_discard(
+        &self,
+        attr: &Attribute,
+        span: Span,
+        target: Target,
+    ) -> bool {
+        if matches!(target, Target::Impl) {
+            true
+        } else {
+            self.tcx
+                .sess
+                .struct_span_err(attr.span, "attribute should be applied to an impl")
+                .span_label(span, "not an impl")
+                .emit();
+            false
+        }
+    }
+
     /// Checks that the dep-graph debugging attributes are only present when the query-dep-graph
     /// option is passed to the compiler.
     fn check_rustc_dirty_clean(&self, attr: &Attribute) -> bool {

compiler/rustc_span/src/symbol.rs

@@ -1260,6 +1260,7 @@ symbols! {
         rustc_promotable,
         rustc_regions,
         rustc_reservation_impl,
+        rustc_select_quick_discard,
         rustc_serialize,
         rustc_skip_array_during_method_dispatch,
         rustc_specialization_trait,

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -13,6 +13,7 @@ use rustc_infer::traits::{Obligation, SelectionError, TraitObligation};
 use rustc_lint_defs::builtin::DEREF_INTO_DYN_SUPERTRAIT;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, ToPredicate, Ty, TypeVisitable};
+use rustc_span::sym;
 use rustc_target::spec::abi::Abi;
 
 use crate::traits;
@@ -135,8 +136,25 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // candidate which assumes $0 == int, one that assumes `$0 ==
         // usize`, etc. This spells an ambiguity.
 
-        let mut candidates = self.filter_impls(candidates, stack.obligation);
-
+        let candidates = self.filter_impls(candidates, stack.obligation);
+        let mut candidates = candidates
+            .into_iter()
+            .map(|c| match c {
+                ImplCandidate(impl_def)
+                    if self.tcx().has_attr(impl_def, sym::rustc_select_quick_discard) =>
+                {
+                    match self.evaluate_candidate(stack, &c) {
+                        Ok(eval) if eval.may_apply() => Ok(Some(c)),
+                        Ok(_) => Ok(None),
+                        Err(OverflowError::Canonical) => Err(Overflow(OverflowError::Canonical)),
+                        Err(OverflowError::ErrorReporting) => Err(ErrorReporting),
+                        Err(OverflowError::Error(e)) => Err(Overflow(OverflowError::Error(e))),
+                    }
+                }
+                _ => Ok(Some(c)),
+            })
+            .flat_map(Result::transpose)
+            .collect::<Result<Vec<_>, _>>()?;
         // If there is more than one candidate, first winnow them down
         // by considering extra conditions (nested obligations and so
         // forth). We don't winnow if there is exactly one