Auto merge of #684 - detrumi:impl-trait-cleanup, r=nikomatsakis

Opaque type cleanup

Just a small PR to fill in some obvious todo's, remove dead code and deduplicate some pattern matching.

Author: bors

chalk-ir/src/lib.rs

@@ -1622,14 +1622,6 @@ impl<I: Interner> AliasTy<I> {
         Ty::new(interner, self)
     }
 
-    /// Gets the type parameters of the `Self` type in this alias type.
-    pub fn self_type_parameter(&self, interner: &I) -> Ty<I> {
-        match self {
-            AliasTy::Projection(projection_ty) => projection_ty.self_type_parameter(interner),
-            _ => todo!(),
-        }
-    }
-
     /// Compute type flags for aliases
     fn compute_flags(&self, interner: &I) -> TypeFlags {
         match self {

chalk-solve/src/clauses.rs

@@ -592,7 +592,7 @@ pub fn program_clauses_that_could_match<I: Interner>(
 
                 let trait_datum = db.trait_datum(trait_id);
 
-                let self_ty = alias.self_type_parameter(interner);
+                let self_ty = proj.self_type_parameter(interner);
                 if let TyKind::InferenceVar(_, _) = self_ty.kind(interner) {
                     panic!("Inference vars not allowed when getting program clauses");
                 }

chalk-solve/src/display.rs

@@ -163,7 +163,7 @@ fn display_self_where_clauses_as_bounds<'a, I: Interner>(
                                     )
                                     .fmt(f)
                                 }
-                                AliasTy::Opaque(_opaque) => todo!("opaque type AliasTy"),
+                                AliasTy::Opaque(opaque) => opaque.display(s).fmt(f),
                             },
                             WhereClause::LifetimeOutlives(lifetime) => lifetime.display(s).fmt(f),
                             WhereClause::TypeOutlives(ty) => ty.display(s).fmt(f),

chalk-solve/src/display/bounds.rs

@@ -148,7 +148,7 @@ impl<I: Interner> RenderAsRust<I> for AliasEq<I> {
                     ),
                 )
             }
-            AliasTy::Opaque(_) => todo!("opaque types"),
+            AliasTy::Opaque(opaque) => write!(f, "{}", opaque.display(s)),
         }
     }
 }

chalk-solve/src/logging_db/id_collector.rs

@@ -102,6 +102,16 @@ impl<'i, I: Interner, DB: RustIrDatabase<I>> IdCollector<'i, I, DB> {
     fn record(&mut self, id: impl Into<RecordedItemId<I>>) {
         self.found_identifiers.insert(id.into());
     }
+
+    fn visit_alias(&mut self, alias: &AliasTy<I>) {
+        match alias {
+            AliasTy::Projection(projection_ty) => {
+                let assoc_ty_datum = self.db.associated_ty_data(projection_ty.associated_ty_id);
+                self.record(assoc_ty_datum.trait_id)
+            }
+            AliasTy::Opaque(opaque_ty) => self.record(opaque_ty.opaque_ty_id),
+        }
+    }
 }
 
 impl<'i, I: Interner, DB: RustIrDatabase<I>> Visitor<'i, I> for IdCollector<'i, I, DB>
@@ -126,15 +136,7 @@ where
             TyKind::Adt(adt, _) => self.record(*adt),
             TyKind::FnDef(fn_def, _) => self.record(*fn_def),
             TyKind::OpaqueType(opaque, _) => self.record(*opaque),
-            TyKind::Alias(alias) => match alias {
-                AliasTy::Projection(projection_ty) => {
-                    let assoc_ty_datum = self.db.associated_ty_data(projection_ty.associated_ty_id);
-                    self.record(assoc_ty_datum.trait_id)
-                }
-                AliasTy::Opaque(opaque_ty) => {
-                    self.record(opaque_ty.opaque_ty_id);
-                }
-            },
+            TyKind::Alias(alias) => self.visit_alias(&alias),
             TyKind::BoundVar(..) => (),
             TyKind::Dyn(..) => (),
             TyKind::Function(..) => (),
@@ -152,15 +154,7 @@ where
     ) -> ControlFlow<()> {
         match where_clause {
             WhereClause::Implemented(trait_ref) => self.record(trait_ref.trait_id),
-            WhereClause::AliasEq(alias_eq) => match &alias_eq.alias {
-                AliasTy::Projection(projection_ty) => {
-                    let assoc_ty_datum = self.db.associated_ty_data(projection_ty.associated_ty_id);
-                    self.record(assoc_ty_datum.trait_id)
-                }
-                AliasTy::Opaque(opaque_ty) => {
-                    self.record(opaque_ty.opaque_ty_id);
-                }
-            },
+            WhereClause::AliasEq(alias_eq) => self.visit_alias(&alias_eq.alias),
             WhereClause::LifetimeOutlives(_lifetime_outlives) => (),
             WhereClause::TypeOutlives(_type_outlives) => (),
         }