Merge pull request #385 from Areredify/copy2

add `Copy`, `Clone` and `Drop` traits support

Author: nikomatsakis

chalk-integration/src/db.rs

@@ -138,7 +138,7 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
             .impl_provided_for(auto_trait_id, struct_id)
     }
 
-    fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> TraitId<ChalkIr> {
+    fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> Option<TraitId<ChalkIr>> {
         self.program_ir()
             .unwrap()
             .well_known_trait_id(well_known_trait)

chalk-integration/src/lowering.rs

@@ -1367,6 +1367,9 @@ impl LowerWellKnownTrait for WellKnownTrait {
     fn lower(&self) -> rust_ir::WellKnownTrait {
         match self {
             Self::SizedTrait => rust_ir::WellKnownTrait::SizedTrait,
+            Self::CopyTrait => rust_ir::WellKnownTrait::CopyTrait,
+            Self::CloneTrait => rust_ir::WellKnownTrait::CloneTrait,
+            Self::DropTrait => rust_ir::WellKnownTrait::DropTrait,
         }
     }
 }

chalk-integration/src/program.rs

@@ -321,11 +321,8 @@ impl RustIrDatabase<ChalkIr> for Program {
         })
     }
 
-    fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> TraitId<ChalkIr> {
-        *self
-            .well_known_traits
-            .get(&well_known_trait)
-            .unwrap_or_else(|| panic!("No lang item found for {:?}", well_known_trait))
+    fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> Option<TraitId<ChalkIr>> {
+        self.well_known_traits.get(&well_known_trait).map(|x| *x)
     }
 
     fn interner(&self) -> &ChalkIr {

chalk-parse/src/ast.rs

@@ -54,6 +54,9 @@ pub struct TraitDefn {
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum WellKnownTrait {
     SizedTrait,
+    CopyTrait,
+    CloneTrait,
+    DropTrait,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -45,6 +45,9 @@ CoinductiveKeyword: () = "#" "[" "coinductive" "]";
 
 WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "sized" ")" "]" => WellKnownTrait::SizedTrait,
+     "#" "[" "lang" "(" "copy" ")" "]" => WellKnownTrait::CopyTrait,
+     "#" "[" "lang" "(" "clone" ")" "]" => WellKnownTrait::CloneTrait,
+     "#" "[" "lang" "(" "drop" ")" "]" => WellKnownTrait::DropTrait,
 };
 
 StructDefn: StructDefn = {

chalk-rust-ir/src/lib.rs

@@ -136,6 +136,7 @@ pub enum WellKnownTrait {
     SizedTrait,
     CopyTrait,
     CloneTrait,
+    DropTrait,
 }
 
 impl<I: Interner> TraitDatum<I> {

chalk-solve/src/clauses/builtin_traits.rs

@@ -2,6 +2,8 @@ use super::builder::ClauseBuilder;
 use crate::{Interner, RustIrDatabase, TraitRef, WellKnownTrait};
 use chalk_ir::TyData;
 
+mod clone;
+mod copy;
 mod sized;
 
 /// For well known traits we have special hard-coded impls, either as an
@@ -22,7 +24,9 @@ pub fn add_builtin_program_clauses<I: Interner>(
 
     match well_known {
         WellKnownTrait::SizedTrait => sized::add_sized_program_clauses(db, builder, trait_ref, ty),
-        WellKnownTrait::CopyTrait => { /* TODO */ }
-        WellKnownTrait::CloneTrait => { /* TODO */ }
+        WellKnownTrait::CopyTrait => copy::add_copy_program_clauses(db, builder, trait_ref, ty),
+        WellKnownTrait::CloneTrait => clone::add_clone_program_clauses(db, builder, trait_ref, ty),
+        // Drop impls are provided explicitly
+        WellKnownTrait::DropTrait => (),
     }
 }

chalk-solve/src/clauses/builtin_traits/clone.rs

@@ -0,0 +1,17 @@
+use crate::clauses::ClauseBuilder;
+use crate::{Interner, RustIrDatabase, TraitRef};
+use chalk_ir::TyData;
+
+use super::copy::add_copy_program_clauses;
+
+pub fn add_clone_program_clauses<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
+    trait_ref: &TraitRef<I>,
+    ty: &TyData<I>,
+) {
+    let _interner = db.interner();
+
+    // Implement Clone for types that automaticly implement Copy
+    add_copy_program_clauses(db, builder, trait_ref, ty);
+}

chalk-solve/src/clauses/builtin_traits/copy.rs

@@ -0,0 +1,19 @@
+use crate::clauses::ClauseBuilder;
+use crate::{Interner, RustIrDatabase, TraitRef};
+use chalk_ir::TyData;
+
+pub fn add_copy_program_clauses<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
+    trait_ref: &TraitRef<I>,
+    ty: &TyData<I>,
+) {
+    let _interner = db.interner();
+
+    match ty {
+        TyData::Function(_) => builder.push_fact(trait_ref.clone()),
+        // TODO(areredify)
+        // when #368 lands, extend this to handle everything accordingly
+        _ => return,
+    };
+}

chalk-solve/src/clauses/program_clauses.rs

@@ -415,23 +415,32 @@ impl<I: Interner> ToProgramClauses<I> for TraitDatum<I> {
             // conditions.
             let type_parameters: Vec<_> = trait_ref.type_parameters(interner).collect();
 
-            // Add all cases for potential downstream impls that could exist
-            for i in 0..type_parameters.len() {
-                builder.push_clause(
-                    trait_ref.clone(),
-                    where_clauses
-                        .iter()
-                        .cloned()
-                        .casted(interner)
-                        .chain(iter::once(DomainGoal::Compatible(()).cast(interner)))
-                        .chain((0..i).map(|j| {
-                            DomainGoal::IsFullyVisible(type_parameters[j].clone()).cast(interner)
-                        }))
-                        .chain(iter::once(
-                            DomainGoal::DownstreamType(type_parameters[i].clone()).cast(interner),
-                        ))
-                        .chain(iter::once(GoalData::CannotProve(()).intern(interner))),
-                );
+            // Drop trait can't have downstream implementation because it can only
+            // be implemented with the same genericity as the struct definition,
+            // i.e. Drop implementation for `struct S<T: Eq> {}` is forced to be
+            // `impl Drop<T: Eq> for S<T> { ... }`. That means that orphan rules
+            // prevent Drop from being implemented in downstream crates.
+            if self.well_known != Some(WellKnownTrait::DropTrait) {
+                // Add all cases for potential downstream impls that could exist
+                for i in 0..type_parameters.len() {
+                    builder.push_clause(
+                        trait_ref.clone(),
+                        where_clauses
+                            .iter()
+                            .cloned()
+                            .casted(interner)
+                            .chain(iter::once(DomainGoal::Compatible(()).cast(interner)))
+                            .chain((0..i).map(|j| {
+                                DomainGoal::IsFullyVisible(type_parameters[j].clone())
+                                    .cast(interner)
+                            }))
+                            .chain(iter::once(
+                                DomainGoal::DownstreamType(type_parameters[i].clone())
+                                    .cast(interner),
+                            ))
+                            .chain(iter::once(GoalData::CannotProve(()).intern(interner))),
+                    );
+                }
             }
 
             // Orphan rules: