Add binders to OpaqueTyDatumBound bounds

Author: detrumi

chalk-integration/src/lowering.rs

@@ -1,13 +1,14 @@
 use chalk_ir::cast::{Cast, Caster};
 use chalk_ir::interner::ChalkIr;
 use chalk_ir::{
-    self, AssocTypeId, Binders, BoundVar, ClausePriority, DebruijnIndex, ImplId, OpaqueTyId,
+    self, AssocTypeId, BoundVar, ClausePriority, DebruijnIndex, ImplId, OpaqueTyId,
     QuantifiedWhereClauses, StructId, Substitution, TraitId,
 };
 use chalk_parse::ast::*;
 use chalk_rust_ir as rust_ir;
 use chalk_rust_ir::{
-    Anonymize, AssociatedTyValueId, IntoWhereClauses, OpaqueTyBound, OpaqueTyDatum, ToParameter,
+    Anonymize, AssociatedTyValueId, IntoWhereClauses, OpaqueTyDatum, OpaqueTyDatumBound,
+    ToParameter,
 };
 use lalrpop_intern::intern;
 use std::collections::BTreeMap;
@@ -390,25 +391,30 @@ impl LowerProgram for Program {
                         let binders = empty_env.in_binders(parameter_kinds, |env| {
                             let hidden_ty = opaque_ty.ty.lower(&env)?;
 
-                            let hidden_ty_bounds: Binders<Vec<Binders<_>>> = env.in_binders(
-                                Some(chalk_ir::ParameterKind::Ty(intern(FIXME_SELF))),
-                                |env1| {
-                                    let interner = env1.interner();
-                                    Ok(opaque_ty
-                                        .bounds
-                                        .lower(&env1)?
-                                        .iter()
-                                        .flat_map(|qil| {
-                                            qil.into_where_clauses(interner, hidden_ty.clone())
-                                        })
-                                        .collect())
-                                },
-                            )?;
-
-                            Ok(OpaqueTyBound {
-                                hidden_ty,
-                                bounds: hidden_ty_bounds.skip_binders().clone(),
-                            })
+                            let bounds: chalk_ir::Binders<Vec<chalk_ir::Binders<_>>> = env
+                                .in_binders(
+                                    Some(chalk_ir::ParameterKind::Ty(intern(FIXME_SELF))),
+                                    |env1| {
+                                        let interner = env1.interner();
+                                        Ok(opaque_ty
+                                            .bounds
+                                            .lower(&env1)?
+                                            .iter()
+                                            .flat_map(|qil| {
+                                                qil.into_where_clauses(
+                                                    interner,
+                                                    chalk_ir::TyData::BoundVar(BoundVar::new(
+                                                        DebruijnIndex::INNERMOST,
+                                                        0,
+                                                    ))
+                                                    .intern(interner),
+                                                )
+                                            })
+                                            .collect())
+                                    },
+                                )?;
+
+                            Ok(OpaqueTyDatumBound { hidden_ty, bounds })
                         })?;
 
                         opaque_ty_data.insert(

chalk-rust-ir/src/lib.rs

@@ -517,16 +517,16 @@ pub struct OpaqueTyDatum<I: Interner> {
     pub opaque_ty_id: OpaqueTyId<I>,
 
     /// The type bound to when revealed.
-    pub bound: Binders<OpaqueTyBound<I>>,
+    pub bound: Binders<OpaqueTyDatumBound<I>>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, HasInterner)]
-pub struct OpaqueTyBound<I: Interner> {
+pub struct OpaqueTyDatumBound<I: Interner> {
     /// The value for the "hidden type" for `opaque type Foo = ...`
     pub hidden_ty: Ty<I>,
 
     /// Trait bounds for the opaque type.
-    pub bounds: Vec<QuantifiedWhereClause<I>>,
+    pub bounds: Binders<Vec<QuantifiedWhereClause<I>>>,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]

chalk-solve/src/clauses/program_clauses.rs

@@ -166,27 +166,33 @@ impl<I: Interner> ToProgramClauses<I> for OpaqueTyDatum<I> {
                 }
                 .cast(interner),
             ));
-        });
 
-        let opaque_ty_bound = &self.bound.skip_binders();
-        for bound in &opaque_ty_bound.bounds {
-            // Implemented(!T<..>: Bound).
-            builder.push_fact(bound.skip_binders().clone().into_well_formed_goal(interner));
-        }
+            for bound in &opaque_ty_bound.bounds {
+                // Implemented(!T<..>: Bound).
+                builder.push_binders(&bound, |builder, bound| {
+                    builder.push_binders(&bound, |builder, bound| {
+                        builder.push_fact(bound.into_well_formed_goal(interner));
+                    });
+                });
+            }
 
-        for auto_trait_id in builder.db.auto_traits() {
-            // Implemented(!T<..>: AutoTrait) :- Implemented(HiddenTy: AutoTrait).
-            builder.push_clause(
-                TraitRef {
-                    trait_id: auto_trait_id,
-                    substitution: Substitution::from1(interner, alias_ty.clone()),
-                },
-                iter::once(TraitRef {
-                    trait_id: auto_trait_id,
-                    substitution: Substitution::from1(interner, opaque_ty_bound.hidden_ty.clone()),
-                }),
-            );
-        }
+            for auto_trait_id in builder.db.auto_traits() {
+                // Implemented(!T<..>: AutoTrait) :- Implemented(HiddenTy: AutoTrait).
+                builder.push_clause(
+                    TraitRef {
+                        trait_id: auto_trait_id,
+                        substitution: Substitution::from1(interner, alias_ty.clone()),
+                    },
+                    iter::once(TraitRef {
+                        trait_id: auto_trait_id,
+                        substitution: Substitution::from1(
+                            interner,
+                            opaque_ty_bound.hidden_ty.clone(),
+                        ),
+                    }),
+                );
+            }
+        });
     }
 }