revert previous two commits

aliemjay · aliemjay · commit 7d787644efce · 2023-08-24T13:36:21.000Z
diff --git a/compiler/rustc_borrowck/src/type_check/free_region_relations.rs b/compiler/rustc_borrowck/src/type_check/free_region_relations.rs
@@ -7,7 +7,7 @@ use rustc_infer::infer::region_constraints::GenericKind;
 use rustc_infer::infer::InferCtxt;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::query::OutlivesBound;
-use rustc_middle::ty::{self, RegionVid, ToPredicate, Ty};
+use rustc_middle::ty::{self, RegionVid, Ty};
 use rustc_span::{Span, DUMMY_SP};
 use rustc_trait_selection::traits::query::type_op::{self, TypeOp};
 use std::rc::Rc;
@@ -232,21 +232,14 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
         let mut normalized_inputs_and_output =
             Vec::with_capacity(self.universal_regions.unnormalized_input_tys.len() + 1);
         let mut constraints = vec![];
-        for (i, ty) in unnormalized_input_output_tys.enumerate() {
+        for ty in unnormalized_input_output_tys {
             debug!("build: input_or_output={:?}", ty);
-
-            let use_implied_bounds = i < self.universal_regions.unnormalized_input_tys.len()
-                || self.universal_regions.defining_ty.is_fn_def();
-
             // We add implied bounds from both the unnormalized and normalized ty.
             // See issue #87748
-            if use_implied_bounds {
-                let constraints_unnorm = self.add_implied_bounds(ty);
-                if let Some(c) = constraints_unnorm {
-                    constraints.push(c)
-                }
+            let constraints_unnorm = self.add_implied_bounds(ty);
+            if let Some(c) = constraints_unnorm {
+                constraints.push(c)
             }
-
             let TypeOpOutput { output: norm_ty, constraints: constraints_normalize, .. } = self
                 .param_env
                 .and(type_op::normalize::Normalize::new(ty))
@@ -272,7 +265,7 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
             // }
             // ```
             // Both &Self::Bar and &() are WF
-            if use_implied_bounds && ty != norm_ty {
+            if ty != norm_ty {
                 let constraints_norm = self.add_implied_bounds(norm_ty);
                 if let Some(c) = constraints_norm {
                     constraints.push(c)
@@ -282,22 +275,6 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
             normalized_inputs_and_output.push(norm_ty);
         }
 
-        let TypeOpOutput { constraints: constraints_wf, .. } = self
-            .param_env
-            .and(type_op::ProvePredicate::new(
-                ty::ClauseKind::WellFormed((*normalized_inputs_and_output.last().unwrap()).into())
-                    .to_predicate(self.infcx.tcx),
-            ))
-            .fully_perform(self.infcx, span)
-            .unwrap_or_else(|_: rustc_span::ErrorGuaranteed| TypeOpOutput {
-                output: (),
-                constraints: None,
-                error_info: None,
-            });
-        if let Some(c) = constraints_wf {
-            constraints.push(c)
-        }
-
         for c in constraints {
             self.push_region_constraints(c, span);
         }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -681,9 +681,23 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
 
                 ty::GeneratorWitness(..) | ty::GeneratorWitnessMIR(..) => {
                     // Unspecified in RFC 1214.
+                    // They are always WF when the gnereator passes typeck/borrowck.
+                    walker.skip_current_subtree();
                 }
 
-                ty::Closure(did, args) | ty::Generator(did, args, ..) => {
+                ty::Generator(did, args, ..) => {
+                    // Walk ALL the types in the generator: this will
+                    // include the upvar types as well as the yield
+                    // type. Note that this is mildly distinct from
+                    // the closure case, where we have to be careful
+                    // about the signature of the closure. We don't
+                    // have the problem of implied bounds here since
+                    // generators don't take arguments.
+                    let obligations = self.nominal_obligations(did, args);
+                    self.out.extend(obligations);
+                }
+
+                ty::Closure(did, args) => {
                     // Only check the upvar types for WF, not the rest
                     // of the types within. This is needed because we
                     // capture the signature and it may not be WF
@@ -705,15 +719,8 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
                     // shorthand for something like `where(T: 'a) {
                     // fn(&'a T) }`, as discussed in #25860.
                     walker.skip_current_subtree(); // subtree handled below
-
-                    let upvars = match ty.kind() {
-                        ty::Closure(..) => args.as_closure().tupled_upvars_ty(),
-                        ty::Generator(..) => args.as_generator().tupled_upvars_ty(),
-                        _ => unreachable!(),
-                    };
                     // FIXME(eddyb) add the type to `walker` instead of recursing.
-                    self.compute(upvars.into());
-
+                    self.compute(args.as_closure().tupled_upvars_ty().into());
                     // Note that we cannot skip the generic types
                     // types. Normally, within the fn
                     // body where they are created, the generics will
diff --git a/tests/ui/async-await/generator-wf-check.output.stderr b/tests/ui/async-await/generator-wf-check.output.stderr
diff --git a/tests/ui/async-await/generator-wf-check.output_wf.stderr b/tests/ui/async-await/generator-wf-check.output_wf.stderr
@@ -1,12 +1,11 @@
 error[E0310]: the parameter type `T` may not live long enough
-  --> $DIR/generator-wf-check.rs:25:8
+  --> $DIR/generator-wf-check.rs:24:5
    |
-LL |       wf(async {
-   |  ________^
+LL | /     wf(async {
 LL | |
 LL | |         None::<Static<T>>
 LL | |     });
-   | |_____^ ...so that the type `T` will meet its required lifetime bounds
+   | |______^ ...so that the type `T` will meet its required lifetime bounds
    |
 help: consider adding an explicit lifetime bound...
    |
diff --git a/tests/ui/async-await/generator-wf-check.rs b/tests/ui/async-await/generator-wf-check.rs
@@ -3,7 +3,7 @@
 
 // edition: 2021
 // revisions: output output_wf witness witness_wf
-//[output] check-fail
+//[output] check-pass
 //[output_wf] check-fail
 //[witness] check-fail
 //[witness_wf] check-fail
@@ -15,7 +15,6 @@ fn wf<T>(_: T) {}
 #[cfg(output)]
 fn test_output<T>() {
     async {
-    //[output]~^ ERROR `T` may not live long enough
         None::<Static<T>>
     };
 }
diff --git a/tests/ui/async-await/generator-wf-check.witness.stderr b/tests/ui/async-await/generator-wf-check.witness.stderr
@@ -1,5 +1,5 @@
 error[E0310]: the parameter type `T` may not live long enough
-  --> $DIR/generator-wf-check.rs:34:22
+  --> $DIR/generator-wf-check.rs:33:22
    |
 LL |         let witness: Option<Static<T>> = None;
    |                      ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
@@ -10,7 +10,7 @@ LL | fn test_witness<T: 'static>() {
    |                  +++++++++
 
 error[E0310]: the parameter type `T` may not live long enough
-  --> $DIR/generator-wf-check.rs:37:9
+  --> $DIR/generator-wf-check.rs:36:9
    |
 LL |         drop(witness);
    |         ^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
diff --git a/tests/ui/async-await/generator-wf-check.witness_wf.stderr b/tests/ui/async-await/generator-wf-check.witness_wf.stderr
@@ -1,5 +1,5 @@
 error[E0310]: the parameter type `T` may not live long enough
-  --> $DIR/generator-wf-check.rs:45:22
+  --> $DIR/generator-wf-check.rs:44:22
    |
 LL |         let witness: Option<Static<T>> = None;
    |                      ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
@@ -10,7 +10,7 @@ LL | fn test_witness_wf<T: 'static>() {
    |                     +++++++++
 
 error[E0310]: the parameter type `T` may not live long enough
-  --> $DIR/generator-wf-check.rs:48:9
+  --> $DIR/generator-wf-check.rs:47:9
    |
 LL |         drop(witness);
    |         ^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
diff --git a/tests/ui/borrowck/erase-error-in-mir-drop-tracking.rs b/tests/ui/borrowck/erase-error-in-mir-drop-tracking.rs
@@ -18,13 +18,6 @@ where
 {
     async move { c.connect().await }
     //~^ ERROR `C` does not live long enough
-    //~| ERROR `C` may not live long enough
-    //~| ERROR `C` may not live long enough
-    //~| ERROR `C` may not live long enough
-    //~| ERROR `C` may not live long enough
-    //~| ERROR `C` may not live long enough
-    //~| ERROR `C` may not live long enough
-
 }
 
 fn main() {}
diff --git a/tests/ui/borrowck/erase-error-in-mir-drop-tracking.stderr b/tests/ui/borrowck/erase-error-in-mir-drop-tracking.stderr
@@ -19,73 +19,6 @@ error: `C` does not live long enough
 LL |     async move { c.connect().await }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0310]: the parameter type `C` may not live long enough
-  --> $DIR/erase-error-in-mir-drop-tracking.rs:19:5
-   |
-LL |     async move { c.connect().await }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `C` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound...
-   |
-LL |     C: Client + Send + Sync + 'static,
-   |                             +++++++++
-
-error[E0310]: the parameter type `C` may not live long enough
-  --> $DIR/erase-error-in-mir-drop-tracking.rs:19:5
-   |
-LL |     async move { c.connect().await }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `C` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound...
-   |
-LL |     C: Client + Send + Sync + 'static,
-   |                             +++++++++
-
-error[E0310]: the parameter type `C` may not live long enough
-  --> $DIR/erase-error-in-mir-drop-tracking.rs:19:18
-   |
-LL |     async move { c.connect().await }
-   |                  ^^^^^^^^^^^ ...so that the type `C` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound...
-   |
-LL |     C: Client + Send + Sync + 'static,
-   |                             +++++++++
-
-error[E0310]: the parameter type `C` may not live long enough
-  --> $DIR/erase-error-in-mir-drop-tracking.rs:19:18
-   |
-LL |     async move { c.connect().await }
-   |                  ^^^^^^^^^^^ ...so that the type `C` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound...
-   |
-LL |     C: Client + Send + Sync + 'static,
-   |                             +++++++++
-
-error[E0310]: the parameter type `C` may not live long enough
-  --> $DIR/erase-error-in-mir-drop-tracking.rs:19:30
-   |
-LL |     async move { c.connect().await }
-   |                              ^^^^^ ...so that the type `C` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound...
-   |
-LL |     C: Client + Send + Sync + 'static,
-   |                             +++++++++
-
-error[E0310]: the parameter type `C` may not live long enough
-  --> $DIR/erase-error-in-mir-drop-tracking.rs:19:30
-   |
-LL |     async move { c.connect().await }
-   |                              ^^^^^ ...so that the type `C` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound...
-   |
-LL |     C: Client + Send + Sync + 'static,
-   |                             +++++++++
-
-error: aborting due to 8 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0261, E0310.
-For more information about an error, try `rustc --explain E0261`.
+For more information about this error, try `rustc --explain E0261`.

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,11 @@`
`1`	`1`	error[E0310]: the parameter type `T` may not live long enough
`2`		`- --> $DIR/generator-wf-check.rs:25:8`
	`2`	`+ --> $DIR/generator-wf-check.rs:24:5`
`3`	`3`	`\|`
`4`		`-LL \| wf(async {`
`5`		`- \| ________^`
	`4`	`+LL \| / wf(async {`
`6`	`5`	`LL \| \|`
`7`	`6`	`LL \| \| None::<Static<T>>`
`8`	`7`	`LL \| \| });`
`9`		- \| \|_____^ ...so that the type `T` will meet its required lifetime bounds
	`8`	+ \| \|______^ ...so that the type `T` will meet its required lifetime bounds
`10`	`9`	`\|`
`11`	`10`	`help: consider adding an explicit lifetime bound...`
`12`	`11`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error[E0310]: the parameter type `T` may not live long enough
`2`		`- --> $DIR/generator-wf-check.rs:34:22`
	`2`	`+ --> $DIR/generator-wf-check.rs:33:22`
`3`	`3`	`\|`
`4`	`4`	`LL \| let witness: Option<Static<T>> = None;`
`5`	`5`	\| ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
`@@ -10,7 +10,7 @@ LL \| fn test_witness<T: 'static>() {`
`10`	`10`	`\| +++++++++`
`11`	`11`
`12`	`12`	error[E0310]: the parameter type `T` may not live long enough
`13`		`- --> $DIR/generator-wf-check.rs:37:9`
	`13`	`+ --> $DIR/generator-wf-check.rs:36:9`
`14`	`14`	`\|`
`15`	`15`	`LL \| drop(witness);`
`16`	`16`	\| ^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error[E0310]: the parameter type `T` may not live long enough
`2`		`- --> $DIR/generator-wf-check.rs:45:22`
	`2`	`+ --> $DIR/generator-wf-check.rs:44:22`
`3`	`3`	`\|`
`4`	`4`	`LL \| let witness: Option<Static<T>> = None;`
`5`	`5`	\| ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
`@@ -10,7 +10,7 @@ LL \| fn test_witness_wf<T: 'static>() {`
`10`	`10`	`\| +++++++++`
`11`	`11`
`12`	`12`	error[E0310]: the parameter type `T` may not live long enough
`13`		`- --> $DIR/generator-wf-check.rs:48:9`
	`13`	`+ --> $DIR/generator-wf-check.rs:47:9`
`14`	`14`	`\|`
`15`	`15`	`LL \| drop(witness);`
`16`	`16`	\| ^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
Original file line number	Diff line number	Diff line change
`@@ -18,13 +18,6 @@ where`
`18`	`18`	`{`
`19`	`19`	`async move { c.connect().await }`
`20`	`20`	//~^ ERROR `C` does not live long enough
`21`		- //~\| ERROR `C` may not live long enough
`22`		- //~\| ERROR `C` may not live long enough
`23`		- //~\| ERROR `C` may not live long enough
`24`		- //~\| ERROR `C` may not live long enough
`25`		- //~\| ERROR `C` may not live long enough
`26`		- //~\| ERROR `C` may not live long enough
`27`		`-`
`28`	`21`	`}`
`29`	`22`
`30`	`23`	`fn main() {}`