use std::fmt::Debug;
use crate::{
BoundVar, Const, ConstValue, DebruijnIndex, DomainGoal, Goal, InferenceVar, Interner, Lifetime,
LifetimeData, PlaceholderIndex, ProgramClause, Ty, TyKind, WhereClause,
};
mod binder_impls;
mod boring_impls;
pub mod visitors;
pub use visitors::VisitExt;
pub enum ControlFlow<B, C = ()> {
Continue(C),
Break(B),
}
impl<B, C> ControlFlow<B, C> {
#[inline]
pub fn is_break(&self) -> bool {
matches!(*self, ControlFlow::Break(_))
}
#[inline]
pub fn is_continue(&self) -> bool {
matches!(*self, ControlFlow::Continue(_))
}
#[inline]
pub fn break_value(self) -> Option<B> {
match self {
ControlFlow::Continue(..) => None,
ControlFlow::Break(x) => Some(x),
}
}
}
impl<B> ControlFlow<B, ()> {
pub const CONTINUE: Self = ControlFlow::Continue(());
}
impl<C> ControlFlow<(), C> {
pub const BREAK: Self = ControlFlow::Break(());
}
#[macro_export]
macro_rules! try_break {
($expr:expr) => {
match $expr {
$crate::visit::ControlFlow::Continue(c) => c,
$crate::visit::ControlFlow::Break(b) => return $crate::visit::ControlFlow::Break(b),
}
};
}
pub trait Visitor<'i, I: Interner>
where
I: 'i,
{
type BreakTy;
fn as_dyn(&mut self) -> &mut dyn Visitor<'i, I, BreakTy = Self::BreakTy>;
fn visit_ty(&mut self, ty: &Ty<I>, outer_binder: DebruijnIndex) -> ControlFlow<Self::BreakTy> {
ty.super_visit_with(self.as_dyn(), outer_binder)
}
fn visit_lifetime(
&mut self,
lifetime: &Lifetime<I>,
outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
lifetime.super_visit_with(self.as_dyn(), outer_binder)
}
fn visit_const(
&mut self,
constant: &Const<I>,
outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
constant.super_visit_with(self.as_dyn(), outer_binder)
}
fn visit_program_clause(
&mut self,
clause: &ProgramClause<I>,
outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
clause.super_visit_with(self.as_dyn(), outer_binder)
}
fn visit_goal(
&mut self,
goal: &Goal<I>,
outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
goal.super_visit_with(self.as_dyn(), outer_binder)
}
fn visit_domain_goal(
&mut self,
domain_goal: &DomainGoal<I>,
outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
domain_goal.super_visit_with(self.as_dyn(), outer_binder)
}
fn forbid_free_vars(&self) -> bool {
false
}
fn visit_free_var(
&mut self,
bound_var: BoundVar,
outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
if self.forbid_free_vars() {
panic!(
"unexpected free variable `{:?}` with outer binder {:?}",
bound_var, outer_binder
)
} else {
ControlFlow::CONTINUE
}
}
fn forbid_free_placeholders(&self) -> bool {
false
}
fn visit_free_placeholder(
&mut self,
universe: PlaceholderIndex,
_outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
if self.forbid_free_placeholders() {
panic!("unexpected placeholder type `{:?}`", universe)
} else {
ControlFlow::CONTINUE
}
}
fn visit_where_clause(
&mut self,
where_clause: &WhereClause<I>,
outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
where_clause.super_visit_with(self.as_dyn(), outer_binder)
}
fn forbid_inference_vars(&self) -> bool {
false
}
fn visit_inference_var(
&mut self,
var: InferenceVar,
_outer_binder: DebruijnIndex,
) -> ControlFlow<Self::BreakTy> {
if self.forbid_inference_vars() {
panic!("unexpected inference type `{:?}`", var)
} else {
ControlFlow::CONTINUE
}
}
fn interner(&self) -> &'i I;
}
pub trait Visit<I: Interner>: Debug {
fn visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i;
}
pub trait SuperVisit<I: Interner>: Visit<I> {
fn super_visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i;
}
impl<I: Interner> Visit<I> for Ty<I> {
fn visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
visitor.visit_ty(self, outer_binder)
}
}
impl<I> SuperVisit<I> for Ty<I>
where
I: Interner,
{
fn super_visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
let interner = visitor.interner();
match self.kind(interner) {
TyKind::BoundVar(bound_var) => {
if let Some(_) = bound_var.shifted_out_to(outer_binder) {
visitor.visit_free_var(*bound_var, outer_binder)
} else {
ControlFlow::CONTINUE
}
}
TyKind::Dyn(clauses) => clauses.visit_with(visitor, outer_binder),
TyKind::InferenceVar(var, _) => visitor.visit_inference_var(*var, outer_binder),
TyKind::Placeholder(ui) => visitor.visit_free_placeholder(*ui, outer_binder),
TyKind::Alias(proj) => proj.visit_with(visitor, outer_binder),
TyKind::Function(fun) => fun.visit_with(visitor, outer_binder),
TyKind::Adt(_id, substitution) => substitution.visit_with(visitor, outer_binder),
TyKind::AssociatedType(_assoc_ty, substitution) => {
substitution.visit_with(visitor, outer_binder)
}
TyKind::Scalar(scalar) => scalar.visit_with(visitor, outer_binder),
TyKind::Str => ControlFlow::CONTINUE,
TyKind::Tuple(arity, substitution) => {
try_break!(arity.visit_with(visitor, outer_binder));
substitution.visit_with(visitor, outer_binder)
}
TyKind::OpaqueType(opaque_ty, substitution) => {
try_break!(opaque_ty.visit_with(visitor, outer_binder));
substitution.visit_with(visitor, outer_binder)
}
TyKind::Slice(substitution) => substitution.visit_with(visitor, outer_binder),
TyKind::FnDef(fn_def, substitution) => {
try_break!(fn_def.visit_with(visitor, outer_binder));
substitution.visit_with(visitor, outer_binder)
}
TyKind::Ref(mutability, lifetime, ty) => {
try_break!(mutability.visit_with(visitor, outer_binder));
try_break!(lifetime.visit_with(visitor, outer_binder));
ty.visit_with(visitor, outer_binder)
}
TyKind::Raw(mutability, ty) => {
try_break!(mutability.visit_with(visitor, outer_binder));
ty.visit_with(visitor, outer_binder)
}
TyKind::Never => ControlFlow::CONTINUE,
TyKind::Array(ty, const_) => {
try_break!(ty.visit_with(visitor, outer_binder));
const_.visit_with(visitor, outer_binder)
}
TyKind::Closure(id, substitution) => {
try_break!(id.visit_with(visitor, outer_binder));
substitution.visit_with(visitor, outer_binder)
}
TyKind::Generator(generator, substitution) => {
try_break!(generator.visit_with(visitor, outer_binder));
substitution.visit_with(visitor, outer_binder)
}
TyKind::GeneratorWitness(witness, substitution) => {
try_break!(witness.visit_with(visitor, outer_binder));
substitution.visit_with(visitor, outer_binder)
}
TyKind::Foreign(foreign_ty) => foreign_ty.visit_with(visitor, outer_binder),
TyKind::Error => ControlFlow::CONTINUE,
}
}
}
impl<I: Interner> Visit<I> for Lifetime<I> {
fn visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
visitor.visit_lifetime(self, outer_binder)
}
}
impl<I: Interner> SuperVisit<I> for Lifetime<I> {
fn super_visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
let interner = visitor.interner();
match self.data(interner) {
LifetimeData::BoundVar(bound_var) => {
if let Some(_) = bound_var.shifted_out_to(outer_binder) {
visitor.visit_free_var(*bound_var, outer_binder)
} else {
ControlFlow::CONTINUE
}
}
LifetimeData::InferenceVar(var) => visitor.visit_inference_var(*var, outer_binder),
LifetimeData::Placeholder(universe) => {
visitor.visit_free_placeholder(*universe, outer_binder)
}
LifetimeData::Static | LifetimeData::Empty(_) | LifetimeData::Erased => {
ControlFlow::CONTINUE
}
LifetimeData::Phantom(void, ..) => match *void {},
}
}
}
impl<I: Interner> Visit<I> for Const<I> {
fn visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
visitor.visit_const(self, outer_binder)
}
}
impl<I: Interner> SuperVisit<I> for Const<I> {
fn super_visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
let interner = visitor.interner();
match &self.data(interner).value {
ConstValue::BoundVar(bound_var) => {
if let Some(_) = bound_var.shifted_out_to(outer_binder) {
visitor.visit_free_var(*bound_var, outer_binder)
} else {
ControlFlow::CONTINUE
}
}
ConstValue::InferenceVar(var) => visitor.visit_inference_var(*var, outer_binder),
ConstValue::Placeholder(universe) => {
visitor.visit_free_placeholder(*universe, outer_binder)
}
ConstValue::Concrete(_) => ControlFlow::CONTINUE,
}
}
}
impl<I: Interner> Visit<I> for Goal<I> {
fn visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
visitor.visit_goal(self, outer_binder)
}
}
impl<I: Interner> SuperVisit<I> for Goal<I> {
fn super_visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
let interner = visitor.interner();
self.data(interner).visit_with(visitor, outer_binder)
}
}
impl<I: Interner> Visit<I> for ProgramClause<I> {
fn visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
visitor.visit_program_clause(self, outer_binder)
}
}
impl<I: Interner> Visit<I> for WhereClause<I> {
fn visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
visitor.visit_where_clause(self, outer_binder)
}
}
impl<I: Interner> Visit<I> for DomainGoal<I> {
fn visit_with<'i, B>(
&self,
visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
outer_binder: DebruijnIndex,
) -> ControlFlow<B>
where
I: 'i,
{
visitor.visit_domain_goal(self, outer_binder)
}
}