address review

Author: jdonszelmann

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -613,26 +613,30 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                             // of each other. This is currently only used for diagnostics.
                             // To see why, see the docs in the `type_variables` module.
                             inner.type_variables().sub_unify(vid, new_var_id);
-                            // If we're in the new solver and create a new inference
-                            // variable inside of an alias we eagerly constrain that
-                            // inference variable to prevent unexpected ambiguity errors.
-                            //
-                            // This is incomplete as it pulls down the universe of the
-                            // original inference variable, even though the alias could
-                            // normalize to a type which does not refer to that type at
-                            // all. I don't expect this to cause unexpected errors in
-                            // practice.
-                            //
-                            // We only need to do so for type and const variables, as
-                            // region variables do not impact normalization, and will get
-                            // correctly constrained by `AliasRelate` later on.
-                            //
-                            // cc trait-system-refactor-initiative#108
-                            if self.infcx.next_trait_solver()
-                                && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
-                            {
-                                match self.state {
-                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+
+                            match self.state {
+                                GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                                    if self.infcx.next_trait_solver()
+                                        && !matches!(
+                                            self.infcx.typing_mode(),
+                                            TypingMode::Coherence
+                                        )
+                                    {
+                                        // If we're in the new solver and create a new inference
+                                        // variable inside of an alias we eagerly constrain that
+                                        // inference variable to prevent unexpected ambiguity errors.
+                                        //
+                                        // This is incomplete as it pulls down the universe of the
+                                        // original inference variable, even though the alias could
+                                        // normalize to a type which does not refer to that type at
+                                        // all. I don't expect this to cause unexpected errors in
+                                        // practice.
+                                        //
+                                        // We only need to do so for type and const variables, as
+                                        // region variables do not impact normalization, and will get
+                                        // correctly constrained by `AliasRelate` later on.
+                                        //
+                                        // cc trait-system-refactor-initiative#108
                                         inner.type_variables().equate(vid, new_var_id);
                                     }
                                 }
@@ -759,13 +763,16 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                                 })
                                 .vid;
 
-                            // See the comment for type inference variables
-                            // for more details.
-                            if self.infcx.next_trait_solver()
-                                && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
-                            {
-                                match self.state {
-                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                            match self.state {
+                                GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                                    // See the comment for type inference variables
+                                    // for more details.
+                                    if self.infcx.next_trait_solver()
+                                        && !matches!(
+                                            self.infcx.typing_mode(),
+                                            TypingMode::Coherence
+                                        )
+                                    {
                                         variable_table.union(vid, new_var_id);
                                     }
                                 }

compiler/rustc_middle/src/hooks/mod.rs

@@ -132,7 +132,12 @@ declare_hooks! {
     ) -> Ty<'tcx>;
 }
 
-// `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
+/// The `try_eagerly_normalize_alias` hook passes an `Infcx` from where it's called (in `rustc_infer`)
+/// to where it's provided (in `rustc_trait_selection`).
+/// Both of those crates have that type available, but `rustc_middle` does not.
+/// Instead we pass this type-erased `Infcx` and transmute on both sides.
+///
+/// Has to be `repr(transparent)` so we can transmute a `&'a Infcx<'tcx>` to this struct.
 #[repr(transparent)]
 pub struct TypeErasedInfcx<'a, 'tcx> {
     _infcx: *const (),

compiler/rustc_trait_selection/src/solve.rs

@@ -56,8 +56,7 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
     let cause = ObligationCause::dummy_with_span(span);
     let obligation = Obligation::new(
         tcx,
-        // we ignore the error anyway
-        ObligationCause::dummy_with_span(span),
+        cause,
         param_env,
         ty::PredicateKind::AliasRelate(
             alias.to_ty(tcx).into(),
@@ -68,7 +67,8 @@ fn try_eagerly_normalize_alias<'a, 'tcx>(
 
     ocx.register_obligation(obligation);
 
-    // This only tries to eagerly resolve, if it errors we don't care.
+    // We only use this to constrain inference variables.
+    // We don't care if it errors.
     let _ = ocx.try_evaluate_obligations();
 
     infcx.resolve_vars_if_possible(infer_term)

tests/ui/impl-trait/unsized_coercion.rs

@@ -3,8 +3,7 @@
 
 //@ revisions: next old
 //@[next] compile-flags: -Znext-solver
-//@[old] check-pass
-//@[next] check-pass
+//@ check-pass
 
 trait Trait {}