use Visitor in EnvElaborator and change some callbacks

basil-cow · basil-cow · commit 88614f6bc2a0 · 2020-04-08T00:29:09.000+03:00
diff --git a/chalk-derive/src/lib.rs b/chalk-derive/src/lib.rs
@@ -1,6 +1,7 @@
 extern crate proc_macro;
 
 use proc_macro::TokenStream;
+use proc_macro2::Span;
 use quote::{format_ident, quote};
 use syn::{parse_macro_input, Data, DeriveInput, GenericParam, Ident, TypeParamBound};
 
@@ -346,6 +347,20 @@ fn bounded_by_trait<'p>(param: &'p GenericParam, name: &str) -> Option<&'p Ident
 /// - There is a single parameter `I: Interner` (does not have to be named `I`)
 #[proc_macro_derive(Visit, attributes(has_interner))]
 pub fn derive_visit(item: TokenStream) -> TokenStream {
+    let trait_name = Ident::new("Visit", Span::call_site());
+    let method_name = Ident::new("visit_with", Span::call_site());
+    derive_any_visit(item, trait_name, method_name)
+}
+
+/// Same as Visit, but derives SuperVisit instead
+#[proc_macro_derive(SuperVisit, attributes(has_interner))]
+pub fn derive_super_visit(item: TokenStream) -> TokenStream {
+    let trait_name = Ident::new("SuperVisit", Span::call_site());
+    let method_name = Ident::new("super_visit_with", Span::call_site());
+    derive_any_visit(item, trait_name, method_name)
+}
+
+fn derive_any_visit(item: TokenStream, trait_name: Ident, method_name: Ident) -> TokenStream {
     let input = parse_macro_input!(item as DeriveInput);
     let (impl_generics, ty_generics, where_clause_ref) = input.generics.split_for_impl();
 
@@ -363,8 +378,8 @@ pub fn derive_visit(item: TokenStream) -> TokenStream {
             .expect("Expected has_interner argument");
 
         return TokenStream::from(quote! {
-            impl #impl_generics Visit < #arg > for #type_name #ty_generics #where_clause_ref {
-                fn visit_with<'i, R: VisitResult>(
+            impl #impl_generics #trait_name < #arg > for #type_name #ty_generics #where_clause_ref {
+                fn #method_name <'i, R: VisitResult>(
                     &self,
                     visitor: &mut dyn Visitor < 'i, #arg, Result = R >,
                     outer_binder: DebruijnIndex,
@@ -419,10 +434,10 @@ pub fn derive_visit(item: TokenStream) -> TokenStream {
             .push(syn::parse2(quote! { #param: Visit<_I> }).unwrap());
 
         return TokenStream::from(quote! {
-            impl #impl_generics Visit < _I > for #type_name < #param >
+            impl #impl_generics #trait_name < _I > for #type_name < #param >
                 #where_clause
             {
-                fn visit_with<'i, R: VisitResult>(
+                fn #method_name <'i, R: VisitResult>(
                     &self,
                     visitor: &mut dyn Visitor < 'i, _I, Result = R >,
                     outer_binder: DebruijnIndex,
@@ -450,10 +465,10 @@ pub fn derive_visit(item: TokenStream) -> TokenStream {
         let impl_generics = &input.generics;
 
         return TokenStream::from(quote! {
-            impl #impl_generics Visit < #i > for #type_name < #i >
+            impl #impl_generics #trait_name < #i > for #type_name < #i >
                 #where_clause_ref
             {
-                fn visit_with<'i, R: VisitResult>(
+                fn #method_name <'i, R: VisitResult>(
                     &self,
                     visitor: &mut dyn Visitor < 'i, #i, Result = R >,
                     outer_binder: DebruijnIndex,
@@ -467,7 +482,10 @@ pub fn derive_visit(item: TokenStream) -> TokenStream {
         });
     }
 
-    panic!("derive(Visit) requires a parameter that implements HasInterner or Interner");
+    panic!(
+        "derive({}) requires a parameter that implements HasInterner or Interner",
+        trait_name
+    );
 }
 
 /// Generates the body of the Visit impl
diff --git a/chalk-ir/src/lib.rs b/chalk-ir/src/lib.rs
@@ -4,7 +4,7 @@ use crate::cast::{Cast, CastTo};
 use crate::fold::shift::Shift;
 use crate::fold::{Fold, Folder, Subst, SuperFold};
 use crate::visit::{SuperVisit, Visit, VisitExt, VisitResult, Visitor};
-use chalk_derive::{Fold, HasInterner, Visit};
+use chalk_derive::{Fold, HasInterner, SuperVisit, Visit};
 use chalk_engine::fallible::*;
 use std::iter;
 use std::marker::PhantomData;
@@ -864,7 +864,7 @@ impl<I: Interner> TraitRef<I> {
 }
 
 /// Where clauses that can be written by a Rust programmer.
-#[derive(Clone, PartialEq, Eq, Hash, Fold, Visit, HasInterner)]
+#[derive(Clone, PartialEq, Eq, Hash, Fold, SuperVisit, HasInterner)]
 pub enum WhereClause<I: Interner> {
     Implemented(TraitRef<I>),
     AliasEq(AliasEq<I>),
@@ -932,7 +932,7 @@ pub enum FromEnv<I: Interner> {
 /// A "domain goal" is a goal that is directly about Rust, rather than a pure
 /// logical statement. As much as possible, the Chalk solver should avoid
 /// decomposing this enum, and instead treat its values opaquely.
-#[derive(Clone, PartialEq, Eq, Hash, Fold, Visit, HasInterner)]
+#[derive(Clone, PartialEq, Eq, Hash, Fold, SuperVisit, HasInterner)]
 pub enum DomainGoal<I: Interner> {
     Holds(WhereClause<I>),
 
@@ -1122,7 +1122,7 @@ pub struct Normalize<I: Interner> {
 /// Proves **equality** between a projection `T::Foo` and a type
 /// `U`. Equality can be proven via normalization, but we can also
 /// prove that `T::Foo = V::Foo` if `T = V` without normalizing.
-#[derive(Clone, PartialEq, Eq, Hash, Fold)]
+#[derive(Clone, PartialEq, Eq, Hash, Fold, Visit)]
 pub struct AliasEq<I: Interner> {
     pub alias: AliasTy<I>,
     pub ty: Ty<I>,
diff --git a/chalk-ir/src/visit.rs b/chalk-ir/src/visit.rs
@@ -2,8 +2,8 @@
 use std::fmt::Debug;
 
 use crate::{
-    AliasEq, BoundVar, DebruijnIndex, Goal, InferenceVar, Interner, Lifetime, LifetimeData,
-    PlaceholderIndex, ProgramClause, Ty, TyData,
+    BoundVar, DebruijnIndex, DomainGoal, Goal, InferenceVar, Interner, Lifetime, LifetimeData,
+    PlaceholderIndex, ProgramClause, Ty, TyData, WhereClause,
 };
 
 mod binder_impls;
@@ -83,6 +83,14 @@ where
         goal.super_visit_with(self.as_dyn(), outer_binder)
     }
 
+    fn visit_domain_goal(
+        &mut self,
+        domain_goal: &DomainGoal<I>,
+        outer_binder: DebruijnIndex,
+    ) -> Self::Result {
+        domain_goal.super_visit_with(self.as_dyn(), outer_binder)
+    }
+
     /// If overridden to return true, then visiting will panic if a
     /// free variable is encountered. This should be done if free
     /// type/lifetime variables are not expected.
@@ -159,12 +167,12 @@ where
         }
     }
 
-    fn visit_alias_eq(
+    fn visit_where_clause(
         &mut self,
-        alias_eq: &AliasEq<I>,
+        where_clause: &WhereClause<I>,
         outer_binder: DebruijnIndex,
     ) -> Self::Result {
-        alias_eq.super_visit_with(self.as_dyn(), outer_binder)
+        where_clause.super_visit_with(self.as_dyn(), outer_binder)
     }
 
     /// As with `visit_free_placeholder_ty`, but for lifetimes.
@@ -375,7 +383,7 @@ impl<I: Interner> Visit<I> for ProgramClause<I> {
     }
 }
 
-impl<I: Interner> Visit<I> for AliasEq<I> {
+impl<I: Interner> Visit<I> for WhereClause<I> {
     fn visit_with<'i, R: VisitResult>(
         &self,
         visitor: &mut dyn Visitor<'i, I, Result = R>,
@@ -384,21 +392,19 @@ impl<I: Interner> Visit<I> for AliasEq<I> {
     where
         I: 'i,
     {
-        visitor.visit_alias_eq(self, outer_binder)
+        visitor.visit_where_clause(self, outer_binder)
     }
 }
 
-impl<I: Interner> SuperVisit<I> for AliasEq<I> {
-    fn super_visit_with<'i, R: VisitResult>(
+impl<I: Interner> Visit<I> for DomainGoal<I> {
+    fn visit_with<'i, R: VisitResult>(
         &self,
         visitor: &mut dyn Visitor<'i, I, Result = R>,
         outer_binder: DebruijnIndex,
     ) -> R
     where
         I: 'i,
     {
-        R::new()
-            .and_then(|| self.alias.visit_with(visitor, outer_binder))
-            .and_then(|| self.ty.visit_with(visitor, outer_binder))
+        visitor.visit_domain_goal(self, outer_binder)
     }
 }
diff --git a/chalk-solve/src/clauses/env_elaborator.rs b/chalk-solve/src/clauses/env_elaborator.rs
@@ -9,7 +9,8 @@ use crate::RustIrDatabase;
 use crate::Ty;
 use crate::TyData;
 use chalk_ir::interner::Interner;
-use chalk_ir::AliasTy;
+use chalk_ir::visit::{Visit, Visitor};
+use chalk_ir::DebruijnIndex;
 use rustc_hash::FxHashSet;
 
 /// When proving a `FromEnv` goal, we elaborate all `FromEnv` goals
@@ -24,10 +25,10 @@ pub(super) fn elaborate_env_clauses<I: Interner>(
     out: &mut FxHashSet<ProgramClause<I>>,
 ) {
     let mut this_round = vec![];
-    let mut visitor = EnvElaborator::new(db, &mut this_round);
-    for clause in in_clauses {
-        visitor.visit_program_clause(&clause);
-    }
+    in_clauses.visit_with(
+        &mut EnvElaborator::new(db, &mut this_round),
+        DebruijnIndex::INNERMOST,
+    );
     out.extend(this_round);
 }
 
@@ -43,15 +44,20 @@ impl<'me, I: Interner> EnvElaborator<'me, I> {
             builder: ClauseBuilder::new(db, out),
         }
     }
+}
+
+impl<'me, I: Interner> Visitor<'me, I> for EnvElaborator<'me, I> {
+    type Result = ();
+
+    fn as_dyn(&mut self) -> &mut dyn Visitor<'me, I, Result = Self::Result> {
+        self
+    }
 
-    fn visit_alias_ty(&mut self, alias_ty: &AliasTy<I>) {
-        debug!("EnvElaborator::visit_alias_ty(alias_ty={:?})", alias_ty);
-        self.db
-            .associated_ty_data(alias_ty.associated_ty_id)
-            .to_program_clauses(&mut self.builder);
+    fn interner(&self) -> &'me I {
+        self.db.interner()
     }
 
-    fn visit_ty(&mut self, ty: &Ty<I>) {
+    fn visit_ty(&mut self, ty: &Ty<I>, _outer_binder: DebruijnIndex) {
         debug!("EnvElaborator::visit_ty(ty={:?})", ty);
         let interner = self.db.interner();
         match ty.data(interner) {
@@ -61,7 +67,9 @@ impl<'me, I: Interner> EnvElaborator<'me, I> {
             TyData::Placeholder(_) => {}
 
             TyData::Alias(alias_ty) => {
-                self.visit_alias_ty(alias_ty);
+                self.db
+                    .associated_ty_data(alias_ty.associated_ty_id)
+                    .to_program_clauses(&mut self.builder);
             }
 
             // FIXME(#203) -- We haven't fully figured out the implied
@@ -72,44 +80,26 @@ impl<'me, I: Interner> EnvElaborator<'me, I> {
         }
     }
 
-    fn visit_from_env(&mut self, from_env: &FromEnv<I>) {
-        debug!("EnvElaborator::visit_from_env(from_env={:?})", from_env);
-        match from_env {
-            FromEnv::Trait(trait_ref) => {
-                let trait_datum = self.db.trait_datum(trait_ref.trait_id);
+    fn visit_domain_goal(&mut self, domain_goal: &DomainGoal<I>, outer_binder: DebruijnIndex) {
+        if let DomainGoal::FromEnv(from_env) = domain_goal {
+            debug!("EnvElaborator::visit_domain_goal(from_env={:?})", from_env);
+            match from_env {
+                FromEnv::Trait(trait_ref) => {
+                    let trait_datum = self.db.trait_datum(trait_ref.trait_id);
 
-                trait_datum.to_program_clauses(&mut self.builder);
+                    trait_datum.to_program_clauses(&mut self.builder);
 
-                // If we know that `T: Iterator`, then we also know
-                // things about `<T as Iterator>::Item`, so push those
-                // implied bounds too:
-                for &associated_ty_id in &trait_datum.associated_ty_ids {
-                    self.db
-                        .associated_ty_data(associated_ty_id)
-                        .to_program_clauses(&mut self.builder);
+                    // If we know that `T: Iterator`, then we also know
+                    // things about `<T as Iterator>::Item`, so push those
+                    // implied bounds too:
+                    for &associated_ty_id in &trait_datum.associated_ty_ids {
+                        self.db
+                            .associated_ty_data(associated_ty_id)
+                            .to_program_clauses(&mut self.builder);
+                    }
                 }
+                FromEnv::Ty(ty) => ty.visit_with(self, outer_binder),
             }
-            FromEnv::Ty(ty) => self.visit_ty(ty),
-        }
-    }
-
-    fn visit_domain_goal(&mut self, domain_goal: &DomainGoal<I>) {
-        debug!(
-            "EnvElaborator::visit_domain_goal(domain_goal={:?})",
-            domain_goal
-        );
-        match domain_goal {
-            DomainGoal::FromEnv(from_env) => self.visit_from_env(from_env),
-            _ => {}
-        }
-    }
-
-    fn visit_program_clause(&mut self, clause: &ProgramClause<I>) {
-        debug!("visit_program_clause(clause={:?})", clause);
-        let interner = self.db.interner();
-        match clause.data(interner) {
-            ProgramClauseData::Implies(clause) => self.visit_domain_goal(&clause.consequence),
-            ProgramClauseData::ForAll(clause) => self.visit_domain_goal(&clause.value.consequence),
         }
     }
 }
diff --git a/chalk-solve/src/wf.rs b/chalk-solve/src/wf.rs
@@ -67,11 +67,18 @@ impl<'i, 't, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {
         self.interner
     }
 
-    fn visit_alias_eq(&mut self, alias_eq: &AliasEq<I>, outer_binder: DebruijnIndex) {
-        TyData::Alias(alias_eq.alias.clone())
-            .intern(self.interner)
-            .visit_with(self, outer_binder);
-        alias_eq.ty.visit_with(self, outer_binder);
+    fn visit_where_clause(&mut self, where_clause: &WhereClause<I>, outer_binder: DebruijnIndex) {
+        match where_clause {
+            WhereClause::AliasEq(alias_eq) => {
+                TyData::Alias(alias_eq.alias.clone())
+                    .intern(self.interner)
+                    .visit_with(self, outer_binder);
+                alias_eq.ty.visit_with(self, outer_binder);
+            }
+            WhereClause::Implemented(trait_ref) => {
+                trait_ref.visit_with(self, outer_binder);
+            }
+        }
     }
 
     fn visit_ty(&mut self, ty: &Ty<I>, outer_binder: DebruijnIndex) {
