Merge pull request #244 from nikomatsakis/impls-for-trait

extend `impls_for_trait` callback to take `[Parameter]` values

Author: nikomatsakis

chalk-ir/src/could_match.rs

@@ -2,11 +2,11 @@ use crate::zip::{Zip, Zipper};
 use crate::*;
 
 /// A fast check to see whether two things could ever possibly match.
-pub trait CouldMatch<T> {
+pub trait CouldMatch<T: ?Sized> {
     fn could_match(&self, other: &T) -> bool;
 }
 
-impl<T: Zip> CouldMatch<T> for T {
+impl<T: Zip + ?Sized> CouldMatch<T> for T {
     fn could_match(&self, other: &T) -> bool {
         return Zip::zip_with(&mut MatchZipper, self, other).is_ok();
 
@@ -53,6 +53,7 @@ impl CouldMatch<DomainGoal> for ProgramClause {
     fn could_match(&self, other: &DomainGoal) -> bool {
         match self {
             ProgramClause::Implies(implication) => implication.consequence.could_match(other),
+
             ProgramClause::ForAll(clause) => clause.value.consequence.could_match(other),
         }
     }

chalk-solve/src/clauses.rs

@@ -146,7 +146,7 @@ fn program_clauses_that_could_match(
             // as for the `Implemented(Foo) :- FromEnv(Foo)` rule.
             db.trait_datum(trait_id).to_program_clauses(db, clauses);
 
-            for impl_id in db.impls_for_trait(trait_id) {
+            for impl_id in db.impls_for_trait(trait_ref.trait_id, &trait_ref.parameters) {
                 db.impl_datum(impl_id).to_program_clauses(db, clauses);
             }
 
@@ -198,7 +198,13 @@ fn program_clauses_that_could_match(
             // ```
             let associated_ty_datum = db.associated_ty_data(projection.associated_ty_id);
             let trait_id = associated_ty_datum.trait_id;
-            push_program_clauses_for_associated_type_values_in_impls_of(db, trait_id, clauses);
+            let (_, trait_parameters, _) = db.split_projection(projection);
+            push_program_clauses_for_associated_type_values_in_impls_of(
+                db,
+                trait_id,
+                trait_parameters,
+                clauses,
+            );
         }
         DomainGoal::InScope(type_kind_id) => match_type_kind(db, *type_kind_id, clauses),
         DomainGoal::LocalImplAllowed(trait_ref) => db
@@ -225,9 +231,10 @@ fn program_clauses_that_could_match(
 fn push_program_clauses_for_associated_type_values_in_impls_of(
     db: &dyn RustIrDatabase,
     trait_id: TraitId,
+    trait_parameters: &[Parameter],
     clauses: &mut Vec<ProgramClause>,
 ) {
-    for impl_id in db.impls_for_trait(trait_id) {
+    for impl_id in db.impls_for_trait(trait_id, trait_parameters) {
         let impl_datum = db.impl_datum(impl_id);
         if !impl_datum.is_positive() {
             continue;

chalk-solve/src/lib.rs

@@ -31,12 +31,16 @@ pub trait RustIrDatabase: Debug {
     /// Returns the datum for the impl with the given id.
     fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum>;
 
-    /// Returns all the impls for a given trait.
-    ///
-    /// FIXME: We should really be using some kind of "simplified self
-    /// type" to help the impl use a hashing strategy and avoid
-    /// returning a ton of entries here.
-    fn impls_for_trait(&self, trait_id: TraitId) -> Vec<ImplId>;
+    /// Returns a list of potentially relevant impls for a given
+    /// trait-id; we also supply the type parameters that we are
+    /// trying to match (if known: these parameters may contain
+    /// inference variables, for example). The implementor is
+    /// permitted to return any superset of the applicable impls;
+    /// chalk will narrow down the list to only those that truly
+    /// apply. The parameters are provided as a "hint" to help the
+    /// implementor do less work, but can be completely ignored if
+    /// desired.
+    fn impls_for_trait(&self, trait_id: TraitId, parameters: &[Parameter]) -> Vec<ImplId>;
 
     /// Returns the impls that require coherence checking. This is not the
     /// full set of impls that exist:

src/db.rs

@@ -2,6 +2,7 @@ use crate::error::ChalkError;
 use crate::lowering::LowerGoal;
 use crate::program::Program;
 use crate::query::{Lowering, LoweringDatabase};
+use chalk_ir::could_match::CouldMatch;
 use chalk_ir::tls;
 use chalk_ir::Goal;
 use chalk_ir::Identifier;
@@ -86,14 +87,17 @@ impl RustIrDatabase for ChalkDatabase {
         self.program_ir().unwrap().struct_data[&id].clone()
     }
 
-    fn impls_for_trait(&self, trait_id: TraitId) -> Vec<ImplId> {
+    fn impls_for_trait(&self, trait_id: TraitId, parameters: &[Parameter]) -> Vec<ImplId> {
         self.program_ir()
             .unwrap()
             .impl_data
             .iter()
             .filter(|(_, impl_datum)| {
-                let impl_trait_id = impl_datum.binders.value.trait_ref.trait_ref().trait_id;
-                impl_trait_id == trait_id
+                let trait_ref = impl_datum.binders.value.trait_ref.trait_ref();
+                trait_id == trait_ref.trait_id && {
+                    assert_eq!(trait_ref.parameters.len(), parameters.len());
+                    <[_] as CouldMatch<[_]>>::could_match(&parameters, &trait_ref.parameters)
+                }
             })
             .map(|(&impl_id, _)| impl_id)
             .collect()