Remove WF checks for struct fields

Author: scalexm

src/lower/mod.rs

@@ -913,13 +913,11 @@ impl ir::StructDatum {
     fn to_program_clauses(&self, program: &ir::Program) -> Vec<ir::ProgramClause> {
         // Given:
         //
-        //    struct Foo<T: Eq> {
-        //        field: Bar
-        //    }
+        //    struct Foo<T: Eq> { }
         //
         // we generate the following clause:
         //
-        //    for<?T> WF(Foo<?T>) :- WF(?T), WF(Bar), (?T: Eq), WF(?T: Eq).
+        //    for<?T> WF(Foo<?T>) :- WF(?T), (?T: Eq), WF(?T: Eq).
 
         let wf = ir::ProgramClause {
             implication: self.binders.map_ref(|bound_datum| {
@@ -934,17 +932,12 @@ impl ir::StructDatum {
                                              .cloned()
                                              .map(|ty| ir::WellFormed::Ty(ty).cast());
 
-                        let fields = bound_datum.fields
-                                                .iter()
-                                                .cloned()
-                                                .map(|ty| ir::WellFormed::Ty(ty).cast());
-
                         let where_clauses = bound_datum.where_clauses.iter()
                                                        .cloned()
                                                        .flat_map(|wc| wc.expanded(program))
                                                        .map(|wc| wc.cast());
 
-                        tys.chain(fields).chain(where_clauses).collect()
+                        tys.chain(where_clauses).collect()
                     }
                 }
             }),

src/solve/test.rs

@@ -700,47 +700,6 @@ fn struct_wf() {
     }
 }
 
-#[test]
-fn struct_with_fields_wf() {
-    test! {
-        program {
-            struct Foo { }
-
-            struct Bar {
-                f: Foo
-            }
-
-            trait Clone { }
-            struct Dummy<T> where T: Clone { }
-            impl Clone for Foo { }
-
-            struct Baz<T> {
-                f: Dummy<T>
-            }
-        }
-
-        goal {
-            WellFormed(Bar)
-        } yields {
-            "Unique"
-        }
-
-        // `Bar` does not implement `Clone` so `Dummy<Bar>` is ill-formed
-        goal {
-            WellFormed(Baz<Bar>)
-        } yields {
-            "No possible solution"
-        }
-
-        // This time `Foo` does implement `Clone`
-        goal {
-            WellFormed(Baz<Foo>)
-        } yields {
-            "Unique"
-        }
-    }
-}
-
 #[test]
 fn generic_trait() {
     test! {