Merge pull request #367 from jackh726/builtin_stopgap

Stopgap solution for builtin traits

Author: nikomatsakis

chalk-rust-ir/src/lib.rs

@@ -135,6 +135,8 @@ pub struct TraitDatum<I: Interner> {
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum WellKnownTrait {
     SizedTrait,
+    CopyTrait,
+    CloneTrait,
 }
 
 impl<I: Interner> TraitDatum<I> {

chalk-solve/src/clauses.rs

@@ -238,7 +238,13 @@ fn program_clauses_that_could_match<I: Interner>(
             }
 
             if let Some(well_known) = trait_datum.well_known {
-                builtin_traits::add_builtin_program_clauses(well_known, trait_ref, builder);
+                builtin_traits::add_builtin_program_clauses(
+                    db,
+                    builder,
+                    well_known,
+                    trait_ref,
+                    self_ty.data(interner),
+                );
             }
         }
         DomainGoal::Holds(WhereClause::AliasEq(alias_predicate)) => {
@@ -346,16 +352,21 @@ fn match_ty<I: Interner>(
     let interner = builder.interner();
     match ty.data(interner) {
         TyData::Apply(application_ty) => match_type_name(builder, application_ty.name),
-        TyData::Placeholder(_) => {}
+        TyData::Placeholder(_) => {
+            builder.push_clause(WellFormed::Ty(ty.clone()), Some(FromEnv::Ty(ty.clone())));
+        }
         TyData::Alias(alias_ty) => builder
             .db
             .associated_ty_data(alias_ty.associated_ty_id)
             .to_program_clauses(builder),
-        TyData::Function(quantified_ty) => quantified_ty
-            .parameters
-            .iter()
-            .map(|p| p.assert_ty_ref(interner))
-            .for_each(|ty| match_ty(builder, environment, &ty)),
+        TyData::Function(quantified_ty) => {
+            builder.push_fact(WellFormed::Ty(ty.clone()));
+            quantified_ty
+                .parameters
+                .iter()
+                .map(|p| p.assert_ty_ref(interner))
+                .for_each(|ty| match_ty(builder, environment, &ty))
+        }
         TyData::BoundVar(_) => {}
         TyData::InferenceVar(_) => panic!("should have floundered"),
         TyData::Dyn(_) => {}

chalk-solve/src/clauses/builtin_traits.rs

@@ -1,15 +1,23 @@
 use super::builder::ClauseBuilder;
-use crate::Interner;
-use crate::{TraitRef, WellKnownTrait};
+use crate::{Interner, RustIrDatabase, TraitRef, WellKnownTrait};
+use chalk_ir::TyData;
 
 /// For well known traits we have special hard-coded impls, either as an
 /// optimization or to enforce special rules for correctness.
 pub fn add_builtin_program_clauses<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
     well_known: WellKnownTrait,
-    _trait_ref: &TraitRef<I>,
-    _builder: &mut ClauseBuilder<'_, I>,
+    trait_ref: &TraitRef<I>,
+    ty: &TyData<I>,
 ) {
+    if db.force_impl_for(well_known, ty) {
+        builder.push_fact(trait_ref.clone());
+    }
+
     match well_known {
         WellKnownTrait::SizedTrait => { /* TODO */ }
+        WellKnownTrait::CopyTrait => { /* TODO */ }
+        WellKnownTrait::CloneTrait => { /* TODO */ }
     }
 }

chalk-solve/src/lib.rs

@@ -68,6 +68,13 @@ pub trait RustIrDatabase<I: Interner>: Debug {
     /// user gave).
     fn impl_provided_for(&self, auto_trait_id: TraitId<I>, struct_id: StructId<I>) -> bool;
 
+    /// A stop-gap solution to force an impl for a given well-known trait.
+    /// Useful when the logic for a given trait is absent or incomplete.
+    #[allow(unused_variables)]
+    fn force_impl_for(&self, well_known: WellKnownTrait, ty: &TyData<I>) -> bool {
+        false
+    }
+
     fn interner(&self) -> &I;
 }