Taint obligations in confirmation

Author: oli-obk

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -634,6 +634,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             };
         let is_method = mode == Mode::MethodCall;
         let unsatisfied_predicates = &no_match_data.unsatisfied_predicates;
+        if let Err(guar) = unsatisfied_predicates.error_reported() {
+            return guar;
+        }
+
         let similar_candidate = no_match_data.similar_candidate;
         let item_kind = if is_method {
             "method"

compiler/rustc_middle/src/ty/generic_args.rs

@@ -15,6 +15,7 @@ use rustc_hir::def_id::DefId;
 use rustc_macros::extension;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
 use rustc_serialize::{Decodable, Encodable};
+use rustc_span::ErrorGuaranteed;
 use rustc_type_ir::WithCachedTypeInfo;
 use smallvec::SmallVec;
 
@@ -303,6 +304,14 @@ impl<'tcx> GenericArg<'tcx> {
             GenericArgKind::Const(ct) => ct.is_ct_infer(),
         }
     }
+
+    pub fn to_error(self, tcx: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Self {
+        match self.unpack() {
+            ty::GenericArgKind::Lifetime(_) => ty::Region::new_error(tcx, guar).into(),
+            ty::GenericArgKind::Type(_) => Ty::new_error(tcx, guar).into(),
+            ty::GenericArgKind::Const(_) => ty::Const::new_error(tcx, guar).into(),
+        }
+    }
 }
 
 impl<'a, 'tcx> Lift<TyCtxt<'tcx>> for GenericArg<'a> {

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

@@ -2755,6 +2755,18 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
         // `$1: Copy`, so we must ensure the obligations are emitted in
         // that order.
         let predicates = tcx.predicates_of(def_id);
+        if let Err(guar) = predicates.errored_due_to_unconstrained_params {
+            self.infcx.set_tainted_by_errors(guar);
+            // Constrain any inference variables to their error variant to ensure unconstrained
+            // generic parameters don't leak as they'll never get constrained.
+            for arg in args {
+                let _ = self.infcx.at(cause, param_env).eq(
+                    DefineOpaqueTypes::Yes,
+                    arg,
+                    arg.to_error(tcx, guar),
+                );
+            }
+        }
         assert_eq!(predicates.parent, None);
         let predicates = predicates.instantiate_own(tcx, args);
         let mut obligations = Vec::with_capacity(predicates.len());

tests/crashes/123141.rs

@@ -0,0 +1,18 @@
+//! This test used to ICE during the normalization of
+//! `I`'s type, because of the mismatch of generic parameters
+//! on the impl with the generic parameters the projection can
+//! fulfill.
+
+struct Thing;
+
+pub trait Every {
+    type Assoc;
+}
+impl<T: ?Sized> Every for Thing {
+    //~^ ERROR: `T` is not constrained
+    type Assoc = T;
+}
+
+static I: <Thing as Every>::Assoc = 3;
+
+fn main() {}

tests/crashes/124350.rs

@@ -0,0 +1,9 @@
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/unconstrained_impl_param.rs:11:6
+   |
+LL | impl<T: ?Sized> Every for Thing {
+   |      ^ unconstrained type parameter
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0207`.

tests/crashes/125874.rs

@@ -0,0 +1,14 @@
+struct Node<const D: usize> {}
+
+impl<const D: usize> Node<{ D }>
+where
+    SmallVec<D>:, //~ ERROR: constant provided when a type was expected
+{
+    fn new() {}
+}
+
+struct SmallVec<T>(T);
+
+fn main() {
+    Node::new();
+}