Merge pull request #602 from detrumi/simplify-lowering

Simplify lowering

Author: detrumi

chalk-integration/src/db.rs

@@ -1,7 +1,7 @@
 use crate::{
     error::ChalkError,
     interner::ChalkIr,
-    lowering::LowerGoal,
+    lowering::lower_goal,
     program::Program,
     query::{Lowering, LoweringDatabase},
     tls, SolverChoice,
@@ -43,7 +43,7 @@ impl ChalkDatabase {
 
     pub fn parse_and_lower_goal(&self, text: &str) -> Result<Goal<ChalkIr>, ChalkError> {
         let program = self.checked_program()?;
-        Ok(chalk_parse::parse_goal(text)?.lower(&*program)?)
+        Ok(lower_goal(&*chalk_parse::parse_goal(text)?, &*program)?)
     }
 
     pub fn solve(

chalk-integration/src/lowering.rs

@@ -3,7 +3,7 @@
 
 use crate::error::ChalkError;
 use crate::interner::ChalkIr;
-use crate::lowering::LowerProgram;
+use crate::lowering::Lower;
 use crate::program::Program;
 use crate::program_environment::ProgramEnvironment;
 use crate::tls;

chalk-integration/src/query.rs

@@ -151,7 +151,7 @@ pub struct AssocTyDefn {
 pub struct OpaqueTyDefn {
     pub ty: Ty,
     pub variable_kinds: Vec<VariableKind>,
-    pub identifier: Identifier,
+    pub name: Identifier,
     pub bounds: Vec<QuantifiedInlineBound>,
     pub where_clauses: Vec<QuantifiedWhereClause>,
 }

chalk-parse/src/ast.rs

@@ -231,12 +231,12 @@ AssocTyDefn: AssocTyDefn = {
 };
 
 OpaqueTyDefn: OpaqueTyDefn = {
-    "opaque" "type" <identifier:Id> <p:Angle<VariableKind>> ":" <b:Plus<QuantifiedInlineBound>>
+    "opaque" "type" <name:Id> <p:Angle<VariableKind>> ":" <b:Plus<QuantifiedInlineBound>>
         <w:QuantifiedWhereClauses> "=" <ty:Ty> ";" => {
         OpaqueTyDefn {
             ty,
             variable_kinds: p,
-            identifier,
+            name,
             bounds: b,
             where_clauses: w,
         }

chalk-parse/src/parser.lalrpop

@@ -66,7 +66,7 @@ impl LoadedProgram {
         multiple_answers: bool,
     ) -> Result<()> {
         let program = self.db.checked_program()?;
-        let goal = chalk_parse::parse_goal(text)?.lower(&*program)?;
+        let goal = lower_goal(&*chalk_parse::parse_goal(text)?, &*program)?;
         let peeled_goal = goal.into_peeled_goal(self.db.interner());
         if multiple_answers {
             if self.db.solve_multiple(&peeled_goal, &mut |v, has_next| {

src/main.rs

@@ -5,7 +5,8 @@
 //! to `test/`. We can't compile without access to `test/`, so we can't be under
 //! of `test_util.rs`.
 use chalk_integration::{
-    db::ChalkDatabase, lowering::LowerGoal, program::Program, query::LoweringDatabase, SolverChoice,
+    db::ChalkDatabase, lowering::lower_goal, program::Program, query::LoweringDatabase,
+    SolverChoice,
 };
 use chalk_solve::ext::*;
 use chalk_solve::logging_db::LoggingRustIrDatabase;
@@ -47,10 +48,11 @@ pub fn logging_db_output_sufficient(
                 println!("goal {}", goal_text);
                 assert!(goal_text.starts_with("{"));
                 assert!(goal_text.ends_with("}"));
-                let goal = chalk_parse::parse_goal(&goal_text[1..goal_text.len() - 1])
-                    .unwrap()
-                    .lower(&*program)
-                    .unwrap();
+                let goal = lower_goal(
+                    &*chalk_parse::parse_goal(&goal_text[1..goal_text.len() - 1]).unwrap(),
+                    &*program,
+                )
+                .unwrap();
 
                 println!("using solver: {:?}", solver_choice);
                 let peeled_goal = goal.into_peeled_goal(db.interner());
@@ -88,10 +90,11 @@ pub fn logging_db_output_sufficient(
             println!("goal {}", goal_text);
             assert!(goal_text.starts_with("{"));
             assert!(goal_text.ends_with("}"));
-            let goal = chalk_parse::parse_goal(&goal_text[1..goal_text.len() - 1])
-                .unwrap()
-                .lower(&*new_program)
-                .unwrap();
+            let goal = lower_goal(
+                &*chalk_parse::parse_goal(&goal_text[1..goal_text.len() - 1]).unwrap(),
+                &*new_program,
+            )
+            .unwrap();
 
             println!("using solver: {:?}", solver_choice);
             let peeled_goal = goal.into_peeled_goal(db.interner());

tests/logging_db/util.rs

@@ -3,7 +3,7 @@
 use crate::test_util::assert_same;
 use chalk_integration::db::ChalkDatabase;
 use chalk_integration::interner::ChalkIr;
-use chalk_integration::lowering::LowerGoal;
+use chalk_integration::lowering::lower_goal;
 use chalk_integration::query::LoweringDatabase;
 use chalk_integration::SolverChoice;
 use chalk_ir::Constraints;
@@ -254,10 +254,11 @@ fn solve_goal(program_text: &str, goals: Vec<(&str, SolverChoice, TestGoal)>, co
                 println!("goal {}", goal_text);
                 assert!(goal_text.starts_with("{"));
                 assert!(goal_text.ends_with("}"));
-                let goal = chalk_parse::parse_goal(&goal_text[1..goal_text.len() - 1])
-                    .unwrap()
-                    .lower(&*program)
-                    .unwrap();
+                let goal = lower_goal(
+                    &*chalk_parse::parse_goal(&goal_text[1..goal_text.len() - 1]).unwrap(),
+                    &*program,
+                )
+                .unwrap();
 
                 println!("using solver: {:?}", solver_choice);
                 let peeled_goal = goal.into_peeled_goal(db.interner());