Review comments

Author: jackh726

chalk-engine/src/boring_impls.rs

@@ -151,48 +151,11 @@ impl<I: Interner> Visit<I> for Literal<I> {
     }
 }
 
-// FIXME: I can't figure out macro visibility rules
-macro_rules! copy_fold {
-    ($t:ty) => {
-        impl<I: Interner, TI: TargetInterner<I>> chalk_ir::fold::Fold<I, TI> for $t {
-            type Result = Self;
-            fn fold_with<'i>(
-                &self,
-                _folder: &mut dyn (chalk_ir::fold::Folder<'i, I, TI>),
-                _outer_binder: DebruijnIndex,
-            ) -> chalk_base::results::Fallible<Self::Result>
-            where
-                I: 'i,
-                TI: 'i,
-            {
-                Ok(*self)
-            }
-        }
-    };
-}
-
-copy_fold!(crate::TableIndex);
-copy_fold!(crate::TimeStamp);
-
-macro_rules! const_visit {
-    ($t:ty) => {
-        impl<I: Interner> chalk_ir::visit::Visit<I> for $t {
-            fn visit_with<'i, R: VisitResult>(
-                &self,
-                _visitor: &mut dyn (chalk_ir::visit::Visitor<'i, I, Result = R>),
-                _outer_binder: DebruijnIndex,
-            ) -> R
-            where
-                I: 'i,
-            {
-                R::new()
-            }
-        }
-    };
-}
+chalk_ir::copy_fold!(crate::TableIndex);
+chalk_ir::copy_fold!(crate::TimeStamp);
 
-const_visit!(crate::TableIndex);
-const_visit!(crate::TimeStamp);
+chalk_ir::const_visit!(crate::TableIndex);
+chalk_ir::const_visit!(crate::TimeStamp);
 
 impl<I: Interner> HasInterner for ExClause<I> {
     type Interner = I;

chalk-engine/src/logic.rs

@@ -286,14 +286,14 @@ impl<I: Interner, C: Context<I>> Forest<I, C> {
             }
 
             _ => {
-                // `canonical_goal` is an HH goal. We can simplify it
+                // `canonical_goal` is a goal. We can simplify it
                 // into a series of *literals*, all of which must be
                 // true. Thus, in EWFS terms, we are effectively
                 // creating a single child of the `A :- A` goal that
                 // is like `A :- B, C, D` where B, C, and D are the
                 // simplified subgoals. You can think of this as
                 // applying built-in "meta program clauses" that
-                // reduce HH goals into Domain goals.
+                // reduce goals into Domain goals.
                 if let Ok(ex_clause) =
                     Self::simplify_goal(context, &mut infer, subst, environment, goal)
                 {

chalk-engine/src/simplify.rs

@@ -7,15 +7,15 @@ use chalk_ir::interner::Interner;
 use chalk_ir::{Environment, Goal, GoalData, InEnvironment, QuantifierKind, Substitution};
 
 impl<I: Interner, C: Context<I>> Forest<I, C> {
-    /// Simplifies an HH goal into a series of positive domain goals
-    /// and negative HH goals. This operation may fail if the HH goal
+    /// Simplifies a goal into a series of positive domain goals
+    /// and negative goals. This operation may fail if the goal
     /// includes unifications that cannot be completed.
     pub(super) fn simplify_goal(
         context: &impl ContextOps<I, C>,
         infer: &mut dyn InferenceTable<I, C>,
         subst: Substitution<I>,
         initial_environment: Environment<I>,
-        initial_hh_goal: Goal<I>,
+        initial_goal: Goal<I>,
     ) -> Fallible<ExClause<I>> {
         let mut ex_clause = ExClause {
             subst,
@@ -28,10 +28,10 @@ impl<I: Interner, C: Context<I>> Forest<I, C> {
         };
 
         // A stack of higher-level goals to process.
-        let mut pending_goals = vec![(initial_environment, initial_hh_goal)];
+        let mut pending_goals = vec![(initial_environment, initial_goal)];
 
-        while let Some((environment, hh_goal)) = pending_goals.pop() {
-            match hh_goal.data(context.interner()) {
+        while let Some((environment, goal)) = pending_goals.pop() {
+            match goal.data(context.interner()) {
                 GoalData::Quantified(QuantifierKind::ForAll, subgoal) => {
                     let subgoal =
                         infer.instantiate_binders_universally(context.interner(), &subgoal);

chalk-solve/src/solve.rs

@@ -275,7 +275,7 @@ enum SolverImpl<I: Interner> {
         forest: Box<Forest<I, SlgContext<I>>>,
         max_size: usize,
         /// The expected number of answers for a solution.
-        /// Only really sseful for tests, since `make_solution`
+        /// Only really useful for tests, since `make_solution`
         /// will panic if the number of cached answers does not
         /// equal this when a solution is made.
         expected_answers: Option<usize>,