fix previous failures and address review

compiler/rustc_infer/src/infer/mod.rs

@@ -20,8 +20,7 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::infer::canonical::{Canonical, CanonicalVarValues};
 use rustc_middle::infer::unify_key::{ConstVarValue, ConstVariableValue};
 use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind, ToType};
-use rustc_middle::mir::interpret::ErrorHandled;
+use rustc_middle::mir::interpret::{ErrorHandled, EvalToConstValueResult};
-use rustc_middle::mir::interpret::EvalToConstValueResult;
 use rustc_middle::traits::select;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::fold::{TypeFoldable, TypeFolder};
@@ -695,9 +694,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         param_env: ty::ParamEnv<'tcx>,
     ) -> bool {
         // Reject any attempt to unify two unevaluated constants that contain inference
-        // variables.
+        // variables, since inference variables in queries lead to ICEs.
-        // FIXME `TyCtxt::const_eval_resolve` already rejects the resolution of those
-        // constants early, but the canonicalization below messes with that mechanism.
         if a.substs.has_infer_types_or_consts() || b.substs.has_infer_types_or_consts() {
             debug!("a or b contain infer vars in its substs -> cannot unify");
             return false;
@@ -1621,9 +1618,11 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         // Postpone the evaluation of constants whose substs depend on inference
         // variables
         if substs.has_infer_types_or_consts() {
-            debug!("has infer types or consts");
+            debug!("substs have infer types or consts: {:?}", substs);
+            if substs.has_infer_types_or_consts() {
                 return Err(ErrorHandled::TooGeneric);
             }
+        }
 
         let param_env_erased = self.tcx.erase_regions(param_env);
         let substs_erased = self.tcx.erase_regions(substs);

compiler/rustc_middle/src/mir/interpret/queries.rs

@@ -43,7 +43,7 @@ impl<'tcx> TyCtxt<'tcx> {
         // variables. We reject those here since `resolve_opt_const_arg`
         // would fail otherwise
         if ct.substs.has_infer_types_or_consts() {
-            return Err(ErrorHandled::TooGeneric);
+            bug!("did not expect inference variables here");
         }
 
         match ty::Instance::resolve_opt_const_arg(self, param_env, ct.def, ct.substs) {

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

@@ -569,6 +569,18 @@ pub(super) fn thir_abstract_const<'tcx>(
     }
 }
 
+/// Tries to unify two abstract constants using structural equality.
+#[instrument(skip(tcx), level = "debug")]
+pub(super) fn try_unify<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    a: AbstractConst<'tcx>,
+    b: AbstractConst<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+) -> bool {
+    let const_unify_ctxt = ConstUnifyCtxt::new(tcx, param_env);
+    const_unify_ctxt.try_unify_inner(a, b)
+}
+
 pub(super) fn try_unify_abstract_consts<'tcx>(
     tcx: TyCtxt<'tcx>,
     (a, b): (ty::Unevaluated<'tcx, ()>, ty::Unevaluated<'tcx, ()>),
@@ -622,17 +634,27 @@ where
     recurse(tcx, ct, &mut f)
 }
 
-// Substitutes generics repeatedly to allow AbstractConsts to unify where a
+pub(super) struct ConstUnifyCtxt<'tcx> {
-// ConstKind::Unevalated could be turned into an AbstractConst that would unify e.g.
-// Param(N) should unify with Param(T), substs: [Unevaluated("T2", [Unevaluated("T3", [Param(N)])])]
-#[inline]
-#[instrument(skip(tcx), level = "debug")]
-fn try_replace_substs_in_root<'tcx>(
     tcx: TyCtxt<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+}
+
+impl<'tcx> ConstUnifyCtxt<'tcx> {
+    pub(super) fn new(tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Self {
+        ConstUnifyCtxt { tcx, param_env }
+    }
+
+    // Substitutes generics repeatedly to allow AbstractConsts to unify where a
+    // ConstKind::Unevalated could be turned into an AbstractConst that would unify e.g.
+    // Param(N) should unify with Param(T), substs: [Unevaluated("T2", [Unevaluated("T3", [Param(N)])])]
+    #[inline]
+    #[instrument(skip(self), level = "debug")]
+    pub(super) fn try_replace_substs_in_root(
+        &self,
         mut abstr_const: AbstractConst<'tcx>,
-) -> Option<AbstractConst<'tcx>> {
+    ) -> Option<AbstractConst<'tcx>> {
-    while let Node::Leaf(ct) = abstr_const.root(tcx) {
+        while let Node::Leaf(ct) = abstr_const.root(self.tcx) {
-        match AbstractConst::from_const(tcx, ct) {
+            match AbstractConst::from_const(self.tcx, ct) {
                 Ok(Some(act)) => abstr_const = act,
                 Ok(None) => break,
                 Err(_) => return None,
@@ -640,39 +662,32 @@ fn try_replace_substs_in_root<'tcx>(
         }
 
         Some(abstr_const)
-}
-
-/// Tries to unify two abstract constants using structural equality.
-#[instrument(skip(tcx), level = "debug")]
-pub(super) fn try_unify<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    a: AbstractConst<'tcx>,
-    b: AbstractConst<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-) -> bool {
-    let a = match try_replace_substs_in_root(tcx, a) {
-        Some(a) => a,
-        None => {
-            return true;
     }
+
+    /// Tries to unify two abstract constants using structural equality.
+    #[instrument(skip(self), level = "debug")]
+    fn try_unify_inner(&self, a: AbstractConst<'tcx>, b: AbstractConst<'tcx>) -> bool {
+        let a = if let Some(a) = self.try_replace_substs_in_root(a) {
+            a
+        } else {
+            return true;
         };
 
-    let b = match try_replace_substs_in_root(tcx, b) {
+        let b = if let Some(b) = self.try_replace_substs_in_root(b) {
-        Some(b) => b,
+            b
-        None => {
+        } else {
             return true;
-        }
         };
 
-    let a_root = a.root(tcx);
+        let a_root = a.root(self.tcx);
-    let b_root = b.root(tcx);
+        let b_root = b.root(self.tcx);
         debug!(?a_root, ?b_root);
 
         match (a_root, b_root) {
             (Node::Leaf(a_ct), Node::Leaf(b_ct)) => {
-            let a_ct = a_ct.eval(tcx, param_env);
+                let a_ct = a_ct.eval(self.tcx, self.param_env);
                 debug!("a_ct evaluated: {:?}", a_ct);
-            let b_ct = b_ct.eval(tcx, param_env);
+                let b_ct = b_ct.eval(self.tcx, self.param_env);
                 debug!("b_ct evaluated: {:?}", b_ct);
 
                 if a_ct.ty() != b_ct.ty() {
@@ -708,23 +723,23 @@ pub(super) fn try_unify<'tcx>(
                 }
             }
             (Node::Binop(a_op, al, ar), Node::Binop(b_op, bl, br)) if a_op == b_op => {
-            try_unify(tcx, a.subtree(al), b.subtree(bl), param_env)
+                self.try_unify_inner(a.subtree(al), b.subtree(bl))
-                && try_unify(tcx, a.subtree(ar), b.subtree(br), param_env)
+                    && self.try_unify_inner(a.subtree(ar), b.subtree(br))
             }
             (Node::UnaryOp(a_op, av), Node::UnaryOp(b_op, bv)) if a_op == b_op => {
-            try_unify(tcx, a.subtree(av), b.subtree(bv), param_env)
+                self.try_unify_inner(a.subtree(av), b.subtree(bv))
             }
             (Node::FunctionCall(a_f, a_args), Node::FunctionCall(b_f, b_args))
                 if a_args.len() == b_args.len() =>
             {
-            try_unify(tcx, a.subtree(a_f), b.subtree(b_f), param_env)
+                self.try_unify_inner(a.subtree(a_f), b.subtree(b_f))
                     && iter::zip(a_args, b_args)
-                    .all(|(&an, &bn)| try_unify(tcx, a.subtree(an), b.subtree(bn), param_env))
+                        .all(|(&an, &bn)| self.try_unify_inner(a.subtree(an), b.subtree(bn)))
             }
             (Node::Cast(a_kind, a_operand, a_ty), Node::Cast(b_kind, b_operand, b_ty))
                 if (a_ty == b_ty) && (a_kind == b_kind) =>
             {
-            try_unify(tcx, a.subtree(a_operand), b.subtree(b_operand), param_env)
+                self.try_unify_inner(a.subtree(a_operand), b.subtree(b_operand))
             }
             // use this over `_ => false` to make adding variants to `Node` less error prone
             (Node::Cast(..), _)
@@ -733,4 +748,5 @@ pub(super) fn try_unify<'tcx>(
             | (Node::Binop(..), _)
             | (Node::Leaf(..), _) => false,
         }
+    }
 }

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -581,7 +581,11 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
                         if let (ty::ConstKind::Unevaluated(a), ty::ConstKind::Unevaluated(b)) =
                             (c1.val(), c2.val())
                         {
-                            if infcx.try_unify_abstract_consts(a.shrink(), b.shrink()) {
+                            if infcx.try_unify_abstract_consts(
+                                a.shrink(),
+                                b.shrink(),
+                                obligation.param_env,
+                            ) {
                                 return ProcessResult::Changed(vec![]);
                             }
                         }

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -860,7 +860,10 @@ pub fn provide(providers: &mut ty::query::Providers) {
                 ty::WithOptConstParam { did, const_param_did: Some(param_did) },
             )
         },
-        try_unify_abstract_consts: const_evaluatable::try_unify_abstract_consts,
+        try_unify_abstract_consts: |tcx, param_env_and| {
+            let (param_env, (a, b)) = param_env_and.into_parts();
+            const_evaluatable::try_unify_abstract_consts(tcx, (a, b), param_env)
+        },
         ..*providers
     };
 }

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -643,7 +643,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         if let (ty::ConstKind::Unevaluated(a), ty::ConstKind::Unevaluated(b)) =
                             (c1.val(), c2.val())
                         {
-                            if self.infcx.try_unify_abstract_consts(a.shrink(), b.shrink()) {
+                            if self.infcx.try_unify_abstract_consts(
+                                a.shrink(),
+                                b.shrink(),
+                                obligation.param_env,
+                            ) {
                                 return Ok(EvaluatedToOk);
                             }
                         }

compiler/rustc_typeck/src/check/dropck.rs

@@ -243,7 +243,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
                 (
                     ty::PredicateKind::ConstEvaluatable(a),
                     ty::PredicateKind::ConstEvaluatable(b),
-                ) => tcx.try_unify_abstract_consts((a, b)),
+                ) => tcx.try_unify_abstract_consts(self_param_env.and((a, b))),
                 (
                     ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ty_a, lt_a)),
                     ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ty_b, lt_b)),

src/test/ui/const-generics/issues/issue-83765.rs

@@ -2,103 +2,115 @@
 #![allow(incomplete_features)]
 
 trait TensorDimension {
-    const DIM : usize;
+    const DIM: usize;
-    //~^ ERROR cycle detected when resolving instance `<LazyUpdim<T, {T::DIM}, DIM>
+    //~^ ERROR cycle detected when resolving instance
-    const ISSCALAR : bool = Self::DIM == 0;
+    // FIXME Given the current state of the compiler its expected that we cycle here,
-    fn is_scalar(&self) -> bool {Self::ISSCALAR}
+    // but the cycle is still wrong.
-}
+    const ISSCALAR: bool = Self::DIM == 0;
-
+    fn is_scalar(&self) -> bool {
-trait TensorSize : TensorDimension {
+        Self::ISSCALAR
-    fn size(&self) -> [usize;Self::DIM];
-    fn inbounds(&self,index : [usize;Self::DIM]) -> bool {
-        index.iter().zip(self.size().iter()).all(|(i,s)| i < s)
     }
 }
 
+trait TensorSize: TensorDimension {
+    fn size(&self) -> [usize; Self::DIM];
+    fn inbounds(&self, index: [usize; Self::DIM]) -> bool {
+        index.iter().zip(self.size().iter()).all(|(i, s)| i < s)
+    }
+}
 
 trait Broadcastable: TensorSize + Sized {
     type Element;
-    fn bget(&self, index:[usize;Self::DIM]) -> Option<Self::Element>;
+    fn bget(&self, index: [usize; Self::DIM]) -> Option<Self::Element>;
-    fn lazy_updim<const NEWDIM : usize>(&self, size : [usize;NEWDIM] ) ->
+    fn lazy_updim<const NEWDIM: usize>(
-       LazyUpdim<Self,{Self::DIM},NEWDIM>
+        &self,
-    {
+        size: [usize; NEWDIM],
-        assert!(NEWDIM >= Self::DIM,
+    ) -> LazyUpdim<Self, { Self::DIM }, NEWDIM> {
-            "Updimmed tensor cannot have fewer indices than the initial one.");
+        assert!(
-        LazyUpdim {size,reference:&self}
+            NEWDIM >= Self::DIM,
+            "Updimmed tensor cannot have fewer indices than the initial one."
+        );
+        LazyUpdim { size, reference: &self }
     }
-    fn bmap<T,F :Fn(Self::Element) -> T>(&self,foo : F) -> BMap<T,Self,F,{Self::DIM}>{
+    fn bmap<T, F: Fn(Self::Element) -> T>(&self, foo: F) -> BMap<T, Self, F, { Self::DIM }> {
-        BMap {reference:self,closure : foo}
+        BMap { reference: self, closure: foo }
     }
 }
 
-
+struct LazyUpdim<'a, T: Broadcastable, const OLDDIM: usize, const DIM: usize> {
-struct LazyUpdim<'a,T : Broadcastable,const OLDDIM : usize, const DIM : usize> {
+    size: [usize; DIM],
-    size : [usize;DIM],
+    reference: &'a T,
-    reference : &'a T
 }
 
-impl<'a,T : Broadcastable,const DIM : usize> TensorDimension for LazyUpdim<'a,T,{T::DIM},DIM> {
+impl<'a, T: Broadcastable, const DIM: usize> TensorDimension for LazyUpdim<'a, T, { T::DIM }, DIM> {
-    const DIM : usize = DIM;
+    const DIM: usize = DIM;
 }
 
-impl<'a,T : Broadcastable,const DIM : usize> TensorSize for LazyUpdim<'a,T,{T::DIM},DIM> {
+impl<'a, T: Broadcastable, const DIM: usize> TensorSize for LazyUpdim<'a, T, { T::DIM }, DIM> {
-    fn size(&self) -> [usize;DIM] {self.size}
+    fn size(&self) -> [usize; DIM] {
+        self.size
+    }
 }
 
-impl<'a,T : Broadcastable,const DIM : usize>  Broadcastable for LazyUpdim<'a,T,{T::DIM},DIM>
+impl<'a, T: Broadcastable, const DIM: usize> Broadcastable for LazyUpdim<'a, T, { T::DIM }, DIM> {
-{
     type Element = T::Element;
-    fn bget(&self,index:[usize;DIM]) -> Option<Self::Element> {
+    fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> {
         assert!(DIM >= T::DIM);
-        if !self.inbounds(index) {return None}
+        if !self.inbounds(index) {
+            return None;
+        }
         let size = self.size();
-        let newindex : [usize;T::DIM] = Default::default();
+        let newindex: [usize; T::DIM] = Default::default();
         self.reference.bget(newindex)
     }
 }
 
-struct BMap<'a,R, T : Broadcastable, F :  Fn(T::Element) -> R  , const DIM: usize> {
+struct BMap<'a, R, T: Broadcastable, F: Fn(T::Element) -> R, const DIM: usize> {
-    reference : &'a T,
+    reference: &'a T,
-    closure : F
+    closure: F,
 }
 
-impl<'a,R, T : Broadcastable, F :  Fn(T::Element) -> R,
+impl<'a, R, T: Broadcastable, F: Fn(T::Element) -> R, const DIM: usize> TensorDimension
-     const DIM: usize> TensorDimension for BMap<'a,R,T,F,DIM> {
+    for BMap<'a, R, T, F, DIM>
-
+{
-    const DIM : usize = DIM;
+    const DIM: usize = DIM;
 }
-impl<'a,R, T : Broadcastable, F :  Fn(T::Element) -> R  ,
+impl<'a, R, T: Broadcastable, F: Fn(T::Element) -> R, const DIM: usize> TensorSize
-      const DIM: usize> TensorSize for BMap<'a,R,T,F,DIM> {
+    for BMap<'a, R, T, F, DIM>
-
+{
-    fn size(&self) -> [usize;DIM] {self.reference.size()}
+    fn size(&self) -> [usize; DIM] {
+        self.reference.size()
+    }
 }
 
-impl<'a,R, T : Broadcastable, F :  Fn(T::Element) -> R  ,
+impl<'a, R, T: Broadcastable, F: Fn(T::Element) -> R, const DIM: usize> Broadcastable
-  const DIM: usize> Broadcastable for BMap<'a,R,T,F,DIM> {
+    for BMap<'a, R, T, F, DIM>
-
+{
     type Element = R;
-    fn bget(&self,index:[usize;DIM]) -> Option<Self::Element> {
+    fn bget(&self, index: [usize; DIM]) -> Option<Self::Element> {
         self.reference.bget(index).map(&self.closure)
     }
 }
 
 impl<T> TensorDimension for Vec<T> {
-    const DIM : usize = 1;
+    const DIM: usize = 1;
 }
 impl<T> TensorSize for Vec<T> {
-    fn size(&self) -> [usize;1] {[self.len()]}
+    fn size(&self) -> [usize; 1] {
+        [self.len()]
+    }
 }
 impl<T: Clone> Broadcastable for Vec<T> {
     type Element = T;
-    fn bget(& self,index : [usize;1]) -> Option<T> {
+    fn bget(&self, index: [usize; 1]) -> Option<T> {
         self.get(index[0]).cloned()
     }
 }
 
 fn main() {
-    let v = vec![1,2,3];
+    let v = vec![1, 2, 3];
-    let bv = v.lazy_updim([3,4]);
+    let bv = v.lazy_updim([3, 4]);
-    let bbv = bv.bmap(|x| x*x);
+    let bbv = bv.bmap(|x| x * x);
 
-    println!("The size of v is {:?}",bbv.bget([0,2]).expect("Out of bounds."));
+    println!("The size of v is {:?}", bbv.bget([0, 2]).expect("Out of bounds."));
 }

src/test/ui/const-generics/issues/issue-83765.stderr

@@ -1,16 +1,16 @@
-error[E0391]: cycle detected when resolving instance `<LazyUpdim<T, {T::DIM}, DIM> as TensorDimension>::DIM`
+error[E0391]: cycle detected when resolving instance `<LazyUpdim<T, { T::DIM }, DIM> as TensorDimension>::DIM`
   --> $DIR/issue-83765.rs:5:5
    |
-LL |     const DIM : usize;
+LL |     const DIM: usize;
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^
    |
 note: ...which requires checking if `TensorDimension` fulfills its obligations...
   --> $DIR/issue-83765.rs:4:1
    |
 LL | trait TensorDimension {
    | ^^^^^^^^^^^^^^^^^^^^^
-   = note: ...which again requires resolving instance `<LazyUpdim<T, {T::DIM}, DIM> as TensorDimension>::DIM`, completing the cycle
+   = note: ...which again requires resolving instance `<LazyUpdim<T, { T::DIM }, DIM> as TensorDimension>::DIM`, completing the cycle
-   = note: cycle used when normalizing `<LazyUpdim<T, {T::DIM}, DIM> as TensorDimension>::DIM`
+   = note: cycle used when normalizing `<LazyUpdim<T, { T::DIM }, DIM> as TensorDimension>::DIM`
 
 error: aborting due to previous error