improve normalization of Pointee::Metadata in next solver

Author: Lukas Markeffsky

compiler/rustc_trait_selection/src/solve/normalizes_to/mod.rs

@@ -379,6 +379,47 @@ impl<'tcx> assembly::GoalKind<'tcx> for NormalizesTo<'tcx> {
     ) -> QueryResult<'tcx> {
         let tcx = ecx.tcx();
         ecx.probe_misc_candidate("builtin pointee").enter(|ecx| {
+            let check_tail = |ecx: &mut EvalCtxt<'_, 'tcx>,
+                              goal: Goal<'tcx, Self>,
+                              tail_ty: Ty<'tcx>|
+             -> QueryResult<'tcx> {
+                // If `Self: Sized`, then `<Self as Pointee>::Metadata == ()`.
+                let sized_probe =
+                    ecx.probe_misc_candidate("builtin pointee via sized").enter(|ecx| {
+                        let sized_predicate = ty::TraitRef::from_lang_item(
+                            tcx,
+                            LangItem::Sized,
+                            DUMMY_SP,
+                            [ty::GenericArg::from(goal.predicate.self_ty())],
+                        );
+                        // FIXME(-Znext-solver=coinductive): Should this be `GoalSource::ImplWhereBound`?
+                        ecx.add_goal(GoalSource::Misc, goal.with(tcx, sized_predicate));
+                        ecx.eq(goal.param_env, goal.predicate.term, tcx.types.unit.into())
+                            .expect("expected goal term to be fully unconstrained");
+                        ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+                    });
+
+                if let Ok(response) = sized_probe {
+                    return Ok(response);
+                }
+
+                // If `Self: ?Sized` and `Self == Tail`, then we can't normalize further.
+                if goal.predicate.self_ty() == tail_ty {
+                    return Err(NoSolution);
+                }
+
+                // If `Self: ?Sized` and `Self != Tail`, then normalize from
+                // `<Self as Pointee>::Metadata` to `<Tail as Pointee>::Metadata`.
+                let metadata_def_id = tcx.require_lang_item(LangItem::Metadata, None);
+                let projection_ty = ty::AliasTy::new(tcx, metadata_def_id, [tail_ty]);
+                let predicate =
+                    ty::ProjectionPredicate { projection_ty, term: goal.predicate.term };
+
+                // FIXME(-Znext-solver=coinductive): Should this be `GoalSource::ImplWhereBound`?
+                ecx.add_goal(GoalSource::Misc, goal.with(tcx, predicate));
+                ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+            };
+
             let metadata_ty = match goal.predicate.self_ty().kind() {
                 ty::Bool
                 | ty::Char
@@ -423,29 +464,15 @@ impl<'tcx> assembly::GoalKind<'tcx> for NormalizesTo<'tcx> {
                 ty::Adt(def, args) if def.is_struct() => match def.non_enum_variant().tail_opt() {
                     None => tcx.types.unit,
                     Some(field_def) => {
-                        let self_ty = field_def.ty(tcx, args);
-                        // FIXME(-Znext-solver=coinductive): Should this be `GoalSource::ImplWhereBound`?
-                        ecx.add_goal(
-                            GoalSource::Misc,
-                            goal.with(tcx, goal.predicate.with_self_ty(tcx, self_ty)),
-                        );
-                        return ecx
-                            .evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
+                        let tail_ty = field_def.ty(tcx, args);
+                        return check_tail(ecx, goal, tail_ty);
                     }
                 },
                 ty::Adt(_, _) => tcx.types.unit,
 
                 ty::Tuple(elements) => match elements.last() {
                     None => tcx.types.unit,
-                    Some(&self_ty) => {
-                        // FIXME(-Znext-solver=coinductive): Should this be `GoalSource::ImplWhereBound`?
-                        ecx.add_goal(
-                            GoalSource::Misc,
-                            goal.with(tcx, goal.predicate.with_self_ty(tcx, self_ty)),
-                        );
-                        return ecx
-                            .evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
-                    }
+                    Some(&tail_ty) => return check_tail(ecx, goal, tail_ty),
                 },
 
                 ty::Infer(

tests/ui/traits/pointee-normalize-equate.rs

@@ -1,4 +1,6 @@
 // check-pass
+// revisions: old next
+//[next] compile-flags: -Znext-solver
 
 #![feature(ptr_metadata)]