Manually create goal

Author: jackh726

tests/integration/panic.rs

@@ -1,17 +1,12 @@
-use chalk_integration::db::ChalkDatabase;
-use chalk_integration::query::LoweringDatabase;
 use chalk_ir::interner::ChalkIr;
 use chalk_ir::AssocTypeId;
-use chalk_ir::Goal;
 use chalk_ir::ImplId;
-use chalk_ir::InEnvironment;
 use chalk_ir::OpaqueTyId;
 use chalk_ir::Parameter;
 use chalk_ir::ProgramClause;
 use chalk_ir::StructId;
 use chalk_ir::TraitId;
 use chalk_ir::TypeName;
-use chalk_ir::UCanonical;
 use chalk_rust_ir::AssociatedTyDatum;
 use chalk_rust_ir::AssociatedTyValue;
 use chalk_rust_ir::AssociatedTyValueId;
@@ -21,96 +16,96 @@ use chalk_rust_ir::StructDatum;
 use chalk_rust_ir::TraitDatum;
 use chalk_rust_ir::WellKnownTrait;
 use chalk_solve::RustIrDatabase;
-use chalk_solve::Solution;
 use chalk_solve::SolverChoice;
 use std::sync::Arc;
 
 #[derive(Debug, Default)]
 struct MockDatabase {
-    chalk_db: ChalkDatabase,
     panic: bool,
 }
 
-impl MockDatabase {
-    pub fn with(program_text: &str, solver_choice: SolverChoice) -> Self {
-        Self {
-            chalk_db: ChalkDatabase::with(program_text, solver_choice),
-            panic: false,
-        }
-    }
-
-    pub fn solve(
-        &self,
-        goal: &UCanonical<InEnvironment<Goal<ChalkIr>>>,
-    ) -> Option<Solution<ChalkIr>> {
-        let solver = self.chalk_db.solver();
-        let solution = solver.lock().unwrap().solve(self, goal);
-        solution
-    }
-}
-
+#[allow(unused_variables)]
 impl RustIrDatabase<ChalkIr> for MockDatabase {
     fn custom_clauses(&self) -> Vec<ProgramClause<ChalkIr>> {
         if self.panic {
-            unimplemented!()
+            panic!("test panic");
         } else {
-            self.chalk_db.custom_clauses()
+            vec![]
         }
     }
 
     fn associated_ty_data(&self, ty: AssocTypeId<ChalkIr>) -> Arc<AssociatedTyDatum<ChalkIr>> {
-        self.chalk_db.associated_ty_data(ty)
+        unimplemented!()
     }
 
     fn trait_datum(&self, id: TraitId<ChalkIr>) -> Arc<TraitDatum<ChalkIr>> {
-        self.chalk_db.trait_datum(id)
+        assert_eq!(id.0.index, 0);
+        return Arc::new(chalk_rust_ir::TraitDatum {
+            id,
+            binders: chalk_ir::Binders::new(
+                chalk_ir::ParameterKinds::new(&ChalkIr),
+                chalk_rust_ir::TraitDatumBound {
+                    where_clauses: vec![],
+                },
+            ),
+            flags: chalk_rust_ir::TraitFlags {
+                auto: false,
+                marker: false,
+                upstream: false,
+                fundamental: false,
+                non_enumerable: false,
+                coinductive: false,
+            },
+            associated_ty_ids: vec![],
+            well_known: None,
+        });
     }
 
     fn impl_datum(&self, id: ImplId<ChalkIr>) -> Arc<ImplDatum<ChalkIr>> {
-        self.chalk_db.impl_datum(id)
+        unimplemented!()
     }
 
     fn associated_ty_value(
         &self,
         id: AssociatedTyValueId<ChalkIr>,
     ) -> Arc<AssociatedTyValue<ChalkIr>> {
-        self.chalk_db.associated_ty_value(id)
+        unimplemented!()
     }
 
     fn opaque_ty_data(&self, id: OpaqueTyId<ChalkIr>) -> Arc<OpaqueTyDatum<ChalkIr>> {
-        self.chalk_db.opaque_ty_data(id)
+        unimplemented!()
     }
 
     fn struct_datum(&self, id: StructId<ChalkIr>) -> Arc<StructDatum<ChalkIr>> {
-        self.chalk_db.struct_datum(id)
+        unimplemented!()
     }
 
     fn as_struct_id(&self, type_name: &TypeName<ChalkIr>) -> Option<StructId<ChalkIr>> {
-        self.chalk_db.as_struct_id(type_name)
+        unimplemented!()
     }
 
     fn impls_for_trait(
         &self,
         trait_id: TraitId<ChalkIr>,
         parameters: &[Parameter<ChalkIr>],
     ) -> Vec<ImplId<ChalkIr>> {
-        self.chalk_db.impls_for_trait(trait_id, parameters)
+        unimplemented!()
     }
 
     fn local_impls_to_coherence_check(&self, trait_id: TraitId<ChalkIr>) -> Vec<ImplId<ChalkIr>> {
-        self.chalk_db.local_impls_to_coherence_check(trait_id)
+        unimplemented!()
     }
 
     fn impl_provided_for(
         &self,
         auto_trait_id: TraitId<ChalkIr>,
         struct_id: StructId<ChalkIr>,
     ) -> bool {
-        self.chalk_db.impl_provided_for(auto_trait_id, struct_id)
+        unimplemented!()
     }
 
     fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> Option<TraitId<ChalkIr>> {
-        self.chalk_db.well_known_trait_id(well_known_trait)
+        unimplemented!()
     }
 
     fn interner(&self) -> &ChalkIr {
@@ -121,12 +116,11 @@ impl RustIrDatabase<ChalkIr> for MockDatabase {
 #[test]
 fn unwind_safety() {
     use self::MockDatabase;
-    use chalk_integration::lowering::LowerGoal;
-    use chalk_integration::query::LoweringDatabase;
-    use chalk_solve::ext::GoalExt;
+    use chalk_ir::*;
     use std::panic;
 
     // lower program
+    /*
     let mut db = lower_program_with_db! {
         program {
             struct Foo { }
@@ -137,24 +131,43 @@ fn unwind_safety() {
     };
 
     let program = db.chalk_db.checked_program().unwrap();
-
-    // lower goal
-    let goal = lower_goal! {
-        goal {
-            Foo: Bar
-        }
-        program &*program
+    */
+    let mut db = MockDatabase { panic: false };
+
+    let peeled_goal: UCanonical<InEnvironment<Goal<ChalkIr>>> = UCanonical {
+        canonical: Canonical {
+            binders: CanonicalVarKinds::new(&ChalkIr),
+            value: InEnvironment {
+                environment: Environment::new(&ChalkIr),
+                goal: GoalData::DomainGoal(DomainGoal::Holds(WhereClause::Implemented(TraitRef {
+                    trait_id: TraitId(interner::RawId { index: 0 }),
+                    substitution: Substitution::from1(
+                        &ChalkIr,
+                        ParameterKind::Ty(
+                            TyData::Apply(ApplicationTy {
+                                name: TypeName::Struct(StructId(interner::RawId { index: 1 })),
+                                substitution: Substitution::empty(&ChalkIr),
+                            })
+                            .intern(&ChalkIr),
+                        )
+                        .intern(&ChalkIr),
+                    ),
+                })))
+                .intern(&ChalkIr),
+            },
+        },
+        universes: 1,
     };
-    let peeled_goal = goal.into_peeled_goal(db.interner());
 
+    let mut solver = SolverChoice::slg_default().into_solver();
     // solve goal but this will panic
     db.panic = true;
-    let result = panic::catch_unwind(|| {
-        db.solve(&peeled_goal);
-    });
+    let result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        solver.solve(&db, &peeled_goal);
+    }));
     assert!(result.is_err() == true);
 
     // solve again but without panicking this time
     db.panic = false;
-    assert!(db.solve(&peeled_goal).is_some());
+    assert!(solver.solve(&db, &peeled_goal).is_some());
 }

tests/test_util.rs

@@ -1,35 +1,15 @@
 #![allow(unused_macros)]
 
-macro_rules! lower_program_with_db {
-    (program $program:tt database $database:ty) => {{
+macro_rules! lowering_success {
+    (program $program:tt) => {
         let program_text = stringify!($program);
         assert!(program_text.starts_with("{"));
         assert!(program_text.ends_with("}"));
-        <$database>::with(
+        let result = chalk_integration::db::ChalkDatabase::with(
             &program_text[1..program_text.len() - 1],
             chalk_solve::SolverChoice::default(),
         )
-    }};
-}
-
-macro_rules! lower_goal {
-    (goal $goal:tt program $program:expr) => {{
-        let goal_text = stringify!($goal);
-        assert!(goal_text.starts_with("{"));
-        assert!(goal_text.ends_with("}"));
-        chalk_parse::parse_goal(&goal_text[1..goal_text.len() - 1])
-            .unwrap()
-            .lower($program)
-            .unwrap()
-    }};
-}
-
-macro_rules! lowering_success {
-    (program $program:tt) => {
-        let result = lower_program_with_db!(
-            program $program
-            database chalk_integration::db::ChalkDatabase
-        ).checked_program();
+        .checked_program();
         if let Err(ref e) = result {
             println!("lowering error: {}", e);
         }