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/125874.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/126942.rs

@@ -22,73 +22,7 @@ help: consider adding an explicit lifetime bound
 LL |   type Output<'a> = FooRef<'a, U> where Self: 'a, U: 'a;
    |                                                 +++++++
 
-error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/issue-87735.rs:31:15
-   |
-LL | impl<'b, T, U> AsRef2 for Foo<T>
-   |      -- the parameter type `T` must be valid for the lifetime `'b` as defined here...
-...
-LL |     T: AsRef2<Output<'b> = &'b [U]>,
-   |               ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
-   |
-note: ...that is required by this bound
-  --> $DIR/issue-87735.rs:7:31
-   |
-LL |   type Output<'a> where Self: 'a;
-   |                               ^^
-help: consider adding an explicit lifetime bound
-   |
-LL |     T: AsRef2<Output<'b> = &'b [U]> + 'b,
-   |                                     ++++
-
-error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/issue-87735.rs:36:31
-   |
-LL | impl<'b, T, U> AsRef2 for Foo<T>
-   |      -- the parameter type `T` must be valid for the lifetime `'b` as defined here...
-...
-LL |   fn as_ref2<'a>(&'a self) -> Self::Output<'a> {
-   |                               ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
-   |
-note: ...that is required by this bound
-  --> $DIR/issue-87735.rs:7:31
-   |
-LL |   type Output<'a> where Self: 'a;
-   |                               ^^
-help: consider adding an explicit lifetime bound
-   |
-LL |     T: AsRef2<Output<'b> = &'b [U]> + 'b,
-   |                                     ++++
-
-error: lifetime may not live long enough
-  --> $DIR/issue-87735.rs:37:5
-   |
-LL | impl<'b, T, U> AsRef2 for Foo<T>
-   |      -- lifetime `'b` defined here
-...
-LL |   fn as_ref2<'a>(&'a self) -> Self::Output<'a> {
-   |              -- lifetime `'a` defined here
-LL |     FooRef(self.0.as_ref2())
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ method was supposed to return data with lifetime `'a` but it is returning data with lifetime `'b`
-   |
-   = help: consider adding the following bound: `'b: 'a`
-
-error: lifetime may not live long enough
-  --> $DIR/issue-87735.rs:37:12
-   |
-LL | impl<'b, T, U> AsRef2 for Foo<T>
-   |      -- lifetime `'b` defined here
-...
-LL |   fn as_ref2<'a>(&'a self) -> Self::Output<'a> {
-   |              -- lifetime `'a` defined here
-LL |     FooRef(self.0.as_ref2())
-   |            ^^^^^^^^^^^^^^^^ argument requires that `'a` must outlive `'b`
-   |
-   = help: consider adding the following bound: `'a: 'b`
-
-help: `'b` and `'a` must be the same: replace one with the other
-
-error: aborting due to 6 previous errors
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0207, E0309.
 For more information about an error, try `rustc --explain E0207`.

tests/ui/associated-item/unconstrained_impl_param.rs

@@ -13,11 +13,11 @@ impl<T: ?Sized> Mirror for () {
 
 pub trait First {
     async fn first() -> <() as Mirror>::Assoc;
-    //~^ ERROR type annotations needed
 }
 
 impl First for () {
     async fn first() {}
+    //~^ WARN does not match trait method signature
 }
 
 fn main() {}