Rollup of 5 pull requests

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -7,13 +7,16 @@
 //! `RETURN_PLACE` the MIR arguments) are always fully normalized (and
 //! contain revealed `impl Trait` values).
 
+use crate::type_check::constraint_conversion::ConstraintConversion;
 use rustc_index::vec::Idx;
 use rustc_infer::infer::LateBoundRegionConversionTime;
 use rustc_middle::mir::*;
-use rustc_middle::traits::ObligationCause;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::Ty;
 use rustc_span::Span;
-use rustc_trait_selection::traits::query::normalize::AtExt;
+use rustc_span::DUMMY_SP;
+use rustc_trait_selection::traits::query::type_op::{self, TypeOp};
+use rustc_trait_selection::traits::query::Fallible;
+use type_op::TypeOpOutput;
 
 use crate::universal_regions::UniversalRegions;
 
@@ -30,6 +33,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         let (&normalized_output_ty, normalized_input_tys) =
             normalized_inputs_and_output.split_last().unwrap();
 
+        debug!(?normalized_output_ty);
+        debug!(?normalized_input_tys);
+
         let mir_def_id = body.source.def_id().expect_local();
 
         // If the user explicitly annotated the input types, extract
@@ -75,10 +81,12 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                     .delay_span_bug(body.span, "found more normalized_input_ty than local_decls");
                 break;
             }
+
             // In MIR, argument N is stored in local N+1.
             let local = Local::new(argument_index + 1);
 
             let mir_input_ty = body.local_decls[local].ty;
+
             let mir_input_span = body.local_decls[local].source_info.span;
             self.equate_normalized_input_or_output(
                 normalized_input_ty,
@@ -100,6 +108,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 // If the user explicitly annotated the input types, enforce those.
                 let user_provided_input_ty =
                     self.normalize(user_provided_input_ty, Locations::All(mir_input_span));
+
                 self.equate_normalized_input_or_output(
                     user_provided_input_ty,
                     mir_input_ty,
@@ -167,30 +176,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             // `rustc_traits::normalize_after_erasing_regions`. Ideally, we'd
             // like to normalize *before* inserting into `local_decls`, but
             // doing so ends up causing some other trouble.
-            let b = match self
-                .infcx
-                .at(&ObligationCause::dummy(), ty::ParamEnv::empty())
-                .normalize(b)
-            {
-                Ok(n) => {
-                    debug!("equate_inputs_and_outputs: {:?}", n);
-                    if n.obligations.iter().all(|o| {
-                        matches!(
-                            o.predicate.kind().skip_binder(),
-                            ty::PredicateKind::RegionOutlives(_)
-                                | ty::PredicateKind::TypeOutlives(_)
-                        )
-                    }) {
-                        n.value
-                    } else {
-                        b
-                    }
-                }
+            let b = match self.normalize_and_add_constraints(b) {
+                Ok(n) => n,
                 Err(_) => {
                     debug!("equate_inputs_and_outputs: NoSolution");
                     b
                 }
             };
+
             // Note: if we have to introduce new placeholders during normalization above, then we won't have
             // added those universes to the universe info, which we would want in `relate_tys`.
             if let Err(terr) =
@@ -207,4 +200,27 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             }
         }
     }
+
+    pub(crate) fn normalize_and_add_constraints(&mut self, t: Ty<'tcx>) -> Fallible<Ty<'tcx>> {
+        let TypeOpOutput { output: norm_ty, constraints, .. } =
+            self.param_env.and(type_op::normalize::Normalize::new(t)).fully_perform(self.infcx)?;
+
+        debug!("{:?} normalized to {:?}", t, norm_ty);
+
+        for data in constraints.into_iter().collect::<Vec<_>>() {
+            ConstraintConversion::new(
+                self.infcx,
+                &self.borrowck_context.universal_regions,
+                &self.region_bound_pairs,
+                Some(self.implicit_region_bound),
+                self.param_env,
+                Locations::All(DUMMY_SP),
+                ConstraintCategory::Internal,
+                &mut self.borrowck_context.constraints,
+            )
+            .convert_all(&*data);
+        }
+
+        Ok(norm_ty)
+    }
 }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -893,11 +893,11 @@ struct TypeChecker<'a, 'tcx> {
 }
 
 struct BorrowCheckContext<'a, 'tcx> {
-    universal_regions: &'a UniversalRegions<'tcx>,
+    pub(crate) universal_regions: &'a UniversalRegions<'tcx>,
     location_table: &'a LocationTable,
     all_facts: &'a mut Option<AllFacts>,
     borrow_set: &'a BorrowSet<'tcx>,
-    constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
+    pub(crate) constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
     upvars: &'a [Upvar<'tcx>],
 }
 
@@ -1157,6 +1157,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         self.relate_types(sup, ty::Variance::Contravariant, sub, locations, category)
     }
 
+    #[instrument(skip(self, category), level = "debug")]
     fn eq_types(
         &mut self,
         expected: Ty<'tcx>,

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/named_anon_conflict.rs

@@ -123,6 +123,11 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                 new_ty.to_string(),
                 Applicability::Unspecified,
             );
+        } else {
+            diag.span_label(
+                new_ty_span,
+                &format!("{} does not have lifetime `'static'`", span_label_var),
+            );
         }
 
         Some(diag)

compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

@@ -952,7 +952,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let mut err = rustc_errors::struct_span_err!(
                         self.sess(),
                         self_ty.span,
-                        E0783,
+                        E0782,
                         "{}",
                         msg,
                     );

src/librustdoc/html/render/cache.rs

@@ -398,13 +398,9 @@ crate fn get_all_types<'tcx>(
         if arg.type_.is_self_type() {
             continue;
         }
-        // FIXME: performance wise, it'd be much better to move `args` declaration outside of the
-        // loop and replace this line with `args.clear()`.
         let mut args = Vec::new();
         get_real_types(generics, &arg.type_, tcx, 0, &mut args);
         if !args.is_empty() {
-            // FIXME: once back to performance improvements, replace this line with:
-            // `all_types.extend(args.drain(..));`.
             all_types.extend(args);
         } else {
             if let Some(kind) = arg.type_.def_id_no_primitives().map(|did| tcx.def_kind(did).into())

src/test/rustdoc-ui/commandline-argfile-badutf8.rs → src/test/rustdoc-ui/commandline-argfile/commandline-argfile-badutf8.rs

@@ -1,6 +1,6 @@
 // Check to see if we can get parameters from an @argsfile file
 //
-// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile-badutf8.args
+// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile/commandline-argfile-badutf8.args
 
 #[cfg(not(cmdline_set))]
 compile_error!("cmdline_set not set");

src/test/ui/commandline-argfile-missing.rs → src/test/rustdoc-ui/commandline-argfile/commandline-argfile-missing.rs

@@ -2,7 +2,7 @@
 //
 // normalize-stderr-test: "os error \d+" -> "os error $$ERR"
 // normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
-// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile-missing.args
+// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile/commandline-argfile-missing.args
 
 #[cfg(not(cmdline_set))]
 compile_error!("cmdline_set not set");

src/test/rustdoc-ui/commandline-argfile.rs → src/test/rustdoc-ui/commandline-argfile/commandline-argfile.rs

@@ -1,7 +1,7 @@
 // Check to see if we can get parameters from an @argsfile file
 //
 // check-pass
-// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile.args
+// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile/commandline-argfile.args
 
 #[cfg(not(cmdline_set))]
 compile_error!("cmdline_set not set");

src/test/ui/closures/closure-bounds-static-cant-capture-borrowed.stderr

@@ -1,6 +1,8 @@
 error[E0621]: explicit lifetime required in the type of `x`
   --> $DIR/closure-bounds-static-cant-capture-borrowed.rs:5:5
    |
+LL | fn foo(x: &()) {
+   |           --- the type of `x` does not have lifetime `'static'`
 LL |     bar(|| {
    |     ^^^ lifetime `'static` required
 

src/test/ui/commandline-argfile-badutf8.rs → src/test/ui/command/argfile/commandline-argfile-badutf8.rs

@@ -1,6 +1,6 @@
 // Check to see if we can get parameters from an @argsfile file
 //
-// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile-badutf8.args
+// compile-flags: --cfg cmdline_set @{{src-base}}/command/argfile/commandline-argfile-badutf8.args
 
 #[cfg(not(cmdline_set))]
 compile_error!("cmdline_set not set");

src/test/rustdoc-ui/commandline-argfile-missing.rs → src/test/ui/command/argfile/commandline-argfile-missing.rs

@@ -2,7 +2,7 @@
 //
 // normalize-stderr-test: "os error \d+" -> "os error $$ERR"
 // normalize-stderr-test: "commandline-argfile-missing.args:[^(]*" -> "commandline-argfile-missing.args: $$FILE_MISSING "
-// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile-missing.args
+// compile-flags: --cfg cmdline_set @{{src-base}}/command/argfile/commandline-argfile-missing.args
 
 #[cfg(not(cmdline_set))]
 compile_error!("cmdline_set not set");

src/test/ui/commandline-argfile.rs → src/test/ui/command/argfile/commandline-argfile.rs

@@ -1,7 +1,7 @@
 // Check to see if we can get parameters from an @argsfile file
 //
 // build-pass
-// compile-flags: --cfg cmdline_set @{{src-base}}/commandline-argfile.args
+// compile-flags: --cfg cmdline_set @{{src-base}}/command/argfile/commandline-argfile.args
 
 #[cfg(not(cmdline_set))]
 compile_error!("cmdline_set not set");

src/test/ui/editions/dyn-trait-sugg-2021.stderr

@@ -1,9 +1,9 @@
-error[E0783]: trait objects without an explicit `dyn` are deprecated
+error[E0782]: trait objects without an explicit `dyn` are deprecated
   --> $DIR/dyn-trait-sugg-2021.rs:10:5
    |
 LL |     Foo::hi(123);
    |     ^^^ help: use `dyn`: `<dyn Foo>`
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0783`.
+For more information about this error, try `rustc --explain E0782`.

src/test/ui/generator/generator-region-requirements.stderr

@@ -1,6 +1,9 @@
 error[E0621]: explicit lifetime required in the type of `x`
   --> $DIR/generator-region-requirements.rs:12:51
    |
+LL | fn dangle(x: &mut i32) -> &'static mut i32 {
+   |              -------- the type of `x` does not have lifetime `'static'`
+...
 LL |             GeneratorState::Complete(c) => return c,
    |                                                   ^ lifetime `'static` required
 

src/test/ui/generic-associated-types/projection-type-lifetime-mismatch.stderr

@@ -1,18 +1,24 @@
 error[E0621]: explicit lifetime required in the type of `x`
   --> $DIR/projection-type-lifetime-mismatch.rs:17:5
    |
+LL | fn f(x: &impl for<'a> X<Y<'a> = &'a ()>) -> &'static () {
+   |         ------------------------------- the type of `x` does not have lifetime `'static'`
 LL |     x.m()
    |     ^^^^^ lifetime `'static` required
 
 error[E0621]: explicit lifetime required in the type of `x`
   --> $DIR/projection-type-lifetime-mismatch.rs:22:5
    |
+LL | fn g<T: for<'a> X<Y<'a> = &'a ()>>(x: &T) -> &'static () {
+   |                                       -- the type of `x` does not have lifetime `'static'`
 LL |     x.m()
    |     ^^^^^ lifetime `'static` required
 
 error[E0621]: explicit lifetime required in the type of `x`
   --> $DIR/projection-type-lifetime-mismatch.rs:27:5
    |
+LL | fn h(x: &()) -> &'static () {
+   |         --- the type of `x` does not have lifetime `'static'`
 LL |     x.m()
    |     ^^^^^ lifetime `'static` required
 

src/test/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90612.rs

@@ -0,0 +1,43 @@
+// check-pass
+
+#![feature(generic_associated_types)]
+
+use std::marker::PhantomData;
+
+trait Family: Sized {
+    type Item<'a>;
+
+    fn apply_all<F>(&self, f: F)
+    where
+        F: FamilyItemFn<Self> { }
+}
+
+struct Array<T>(PhantomData<T>);
+
+impl<T: 'static> Family for Array<T> {
+    type Item<'a> = &'a T;
+}
+
+trait FamilyItemFn<T: Family> {
+    fn apply(&self, item: T::Item<'_>);
+}
+
+impl<T, F> FamilyItemFn<T> for F
+where
+    T: Family,
+    for<'a> F: Fn(T::Item<'a>)
+{
+    fn apply(&self, item: T::Item<'_>) {
+        (*self)(item);
+    }
+}
+
+fn process<T: 'static>(array: Array<T>) {
+    // Works
+    array.apply_all(|x: &T| { });
+
+    // ICE: NoSolution
+    array.apply_all(|x: <Array<T> as Family>::Item<'_>| { });
+}
+
+fn main() {}

src/test/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90638.rs

@@ -0,0 +1,37 @@
+//check-pass
+
+#![feature(generic_associated_types)]
+
+trait Yokeable<'a>: 'static {
+    type Output: 'a;
+}
+
+trait IsCovariant<'a> {}
+
+struct Yoke<Y: for<'a> Yokeable<'a>> {
+    data: Y,
+}
+
+impl<Y: for<'a> Yokeable<'a>> Yoke<Y> {
+    fn project<Y2: for<'a> Yokeable<'a>>(&self, _f: for<'a> fn(<Y as Yokeable<'a>>::Output, &'a ())
+      -> <Y2 as Yokeable<'a>>::Output) -> Yoke<Y2> {
+
+        unimplemented!()
+    }
+}
+
+fn _upcast<Y>(x: Yoke<Y>) -> Yoke<Box<dyn IsCovariant<'static> + 'static>> where
+    Y: for<'a> Yokeable<'a>,
+    for<'a> <Y as Yokeable<'a>>::Output: IsCovariant<'a>
+    {
+    x.project(|data, _| {
+        Box::new(data)
+    })
+}
+
+
+impl<'a> Yokeable<'a> for Box<dyn IsCovariant<'static> + 'static> {
+    type Output = Box<dyn IsCovariant<'a> + 'a>;
+}
+
+fn main() {}

src/test/ui/issues/issue-46983.stderr → src/test/ui/lifetimes/issue-46983-expected-return-static.stderr

@@ -1,6 +1,8 @@
 error[E0621]: explicit lifetime required in the type of `x`
-  --> $DIR/issue-46983.rs:2:5
+  --> $DIR/issue-46983-expected-return-static.rs:2:5
    |
+LL | fn foo(x: &u32) -> &'static u32 {
+   |           ---- the type of `x` does not have lifetime `'static'`
 LL |     &*x
    |     ^^^ lifetime `'static` required
 

src/test/ui/lifetimes/issue-90600-expected-return-static-indirect.rs

@@ -0,0 +1,14 @@
+use std::cell::RefCell;
+use std::io::Read;
+
+fn main() {}
+
+fn inner(mut foo: &[u8]) {
+    let refcell = RefCell::new(&mut foo);
+    let read = &refcell as &RefCell<dyn Read>;
+
+    read_thing(read);
+    //~^ ERROR explicit lifetime required in the type of `foo` [E0621]
+}
+
+fn read_thing(refcell: &RefCell<dyn Read>) {}

src/test/ui/lifetimes/issue-90600-expected-return-static-indirect.stderr

@@ -0,0 +1,12 @@
+error[E0621]: explicit lifetime required in the type of `foo`
+  --> $DIR/issue-90600-expected-return-static-indirect.rs:10:16
+   |
+LL | fn inner(mut foo: &[u8]) {
+   |                   ----- the type of `foo` does not have lifetime `'static'`
+...
+LL |     read_thing(read);
+   |                ^^^^ lifetime `'static` required
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0621`.