Introduce OpaqueTyBound

Author: detrumi

chalk-integration/src/lowering.rs

@@ -6,7 +6,9 @@ use chalk_ir::{
 };
 use chalk_parse::ast::*;
 use chalk_rust_ir as rust_ir;
-use chalk_rust_ir::{Anonymize, AssociatedTyValueId, IntoWhereClauses, OpaqueTyDatum, ToParameter};
+use chalk_rust_ir::{
+    Anonymize, AssociatedTyValueId, IntoWhereClauses, OpaqueTyBound, OpaqueTyDatum, ToParameter,
+};
 use lalrpop_intern::intern;
 use std::collections::BTreeMap;
 use std::sync::Arc;
@@ -378,36 +380,50 @@ impl LowerProgram for Program {
                     custom_clauses.extend(clause.lower_clause(&empty_env)?);
                 }
                 Item::OpaqueTyDefn(ref opaque_ty) => {
-                    if let Some(&value) = opaque_ty_ids.get(&opaque_ty.identifier.str) {
+                    if let Some(&opaque_ty_id) = opaque_ty_ids.get(&opaque_ty.identifier.str) {
                         let parameter_kinds = opaque_ty
                             .parameter_kinds
                             .iter()
                             .map(|k| k.lower())
                             .collect::<Vec<_>>();
 
-                        let binders = empty_env
-                            .in_binders(parameter_kinds, |env| opaque_ty.ty.lower(&env))?;
+                        let binders = empty_env.in_binders(parameter_kinds, |env| {
+                            let hidden_ty = opaque_ty.ty.lower(&env)?;
+
+                            let hidden_ty_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,
+                                                        todo!(),
+                                                    ))
+                                                    .intern(interner),
+                                                )
+                                            })
+                                            .collect())
+                                    },
+                                )?;
+
+                            Ok(OpaqueTyBound {
+                                hidden_ty,
+                                bounds: hidden_ty_bounds.skip_binders().clone(),
+                            })
+                        })?;
 
                         opaque_ty_data.insert(
-                            value,
+                            opaque_ty_id,
                             Arc::new(OpaqueTyDatum {
-                                opaque_ty_id: value,
-                                bounds: opaque_ty
-                                    .bounds
-                                    .lower(&empty_env)?
-                                    .iter()
-                                    .flat_map(|qil| {
-                                        qil.into_where_clauses(
-                                            empty_env.interner(),
-                                            chalk_ir::TyData::BoundVar(BoundVar::new(
-                                                DebruijnIndex::INNERMOST,
-                                                todo!(),
-                                            ))
-                                            .intern(empty_env.interner()),
-                                        )
-                                    })
-                                    .collect(),
-                                ty: binders,
+                                opaque_ty_id,
+                                bound: binders,
                             }),
                         );
                     }

chalk-integration/src/program.rs

@@ -121,7 +121,7 @@ impl tls::DebugContext for Program {
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
         if let Some(d) = self.opaque_ty_data.get(&opaque_ty_id) {
-            write!(fmt, "{:?}", d.bounds)
+            write!(fmt, "{:?}", d.bound)
         } else {
             fmt.debug_struct("InvalidItemId")
                 .field("index", &opaque_ty_id.0)

chalk-rust-ir/src/lib.rs

@@ -516,11 +516,17 @@ pub struct OpaqueTyDatum<I: Interner> {
     /// The placeholder `!T` that corresponds to the opaque type `T`.
     pub opaque_ty_id: OpaqueTyId<I>,
 
+    /// The type bound to when revealed.
+    pub bound: Binders<OpaqueTyBound<I>>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, HasInterner)]
+pub struct OpaqueTyBound<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>>,
-
-    /// The "hidden type" that the opaque type is equal to when revealed.
-    pub ty: Binders<Ty<I>>,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]

chalk-solve/src/clauses/program_clauses.rs

@@ -138,13 +138,13 @@ impl<I: Interner> ToProgramClauses<I> for OpaqueTyDatum<I> {
 
         let alias_ty = Ty::new(interner, alias.clone());
 
-        builder.push_binders(&self.ty, |builder, opaque_ty_datum| {
+        builder.push_binders(&self.bound, |builder, opaque_ty_bound| {
             // AliasEq(T<..> = HiddenTy) :- Reveal.
             builder.push_clause(
                 DomainGoal::Holds(
                     AliasEq {
                         alias: alias.clone(),
-                        ty: opaque_ty_datum.clone(),
+                        ty: opaque_ty_bound.hidden_ty.clone(),
                     }
                     .cast(interner),
                 ),
@@ -161,7 +161,8 @@ impl<I: Interner> ToProgramClauses<I> for OpaqueTyDatum<I> {
             ));
         });
 
-        for bound in &self.bounds {
+        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));
         }
@@ -175,7 +176,7 @@ impl<I: Interner> ToProgramClauses<I> for OpaqueTyDatum<I> {
                 },
                 iter::once(TraitRef {
                     trait_id: auto_trait_id,
-                    substitution: Substitution::from1(interner, self.ty.skip_binders().clone()),
+                    substitution: Substitution::from1(interner, opaque_ty_bound.hidden_ty.clone()),
                 }),
             );
         }