use super::structural_visit::{
DefRegionKind, StructuralVisitEngine, StructuralVisitorView, VisitInterrupt,
};
use crate::{Any, AnyView, Dispatcher, IntoDispatcher, Result};
use std::borrow::BorrowMut;
pub enum WalkResult {
Advance,
Skip,
Interrupt,
InterruptWith(Any),
}
pub trait IntoWalkResult {
fn into_walk_result(self) -> Result<WalkResult>;
}
impl IntoWalkResult for WalkResult {
#[inline(always)]
fn into_walk_result(self) -> Result<WalkResult> {
Ok(self)
}
}
impl IntoWalkResult for Result<WalkResult> {
#[inline(always)]
fn into_walk_result(self) -> Result<WalkResult> {
self
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum WalkOrder {
#[default]
PreOrder,
PostOrder,
}
impl<O: IntoWalkResult> super::dispatch::CallbackResult<Result<WalkResult>> for O {
#[inline(always)]
fn callback_result(self) -> Result<WalkResult> {
self.into_walk_result()
}
}
struct WalkVisitor<'a, D, const PRE_ORDER: bool> {
observer: &'a mut D,
}
impl<'v, 'c, 'r, 'a, D, const PRE_ORDER: bool>
Dispatcher<
(
AnyView<'v>,
&'c mut StructuralVisitorView<'r, WalkVisitor<'a, D, PRE_ORDER>>,
),
Option<Result<Option<VisitInterrupt>>>,
> for &mut WalkVisitor<'a, D, PRE_ORDER>
where
for<'d, 'b> &'d mut D: Dispatcher<(AnyView<'b>, DefRegionKind), Option<Result<WalkResult>>>,
{
#[inline(always)]
fn dispatch_tuple(
self,
(value, visitor): (
AnyView<'v>,
&'c mut StructuralVisitorView<'r, WalkVisitor<'a, D, PRE_ORDER>>,
),
) -> Option<Result<Option<VisitInterrupt>>> {
Some(self.visit(value, visitor))
}
}
impl<'a, D, const PRE_ORDER: bool> WalkVisitor<'a, D, PRE_ORDER>
where
for<'s, 'v> &'s mut D: Dispatcher<(AnyView<'v>, DefRegionKind), Option<Result<WalkResult>>>,
{
#[inline(always)]
fn visit(
&mut self,
value: AnyView<'_>,
visitor: &mut StructuralVisitorView<'_, Self>,
) -> Result<Option<VisitInterrupt>> {
let kind = visitor.def_region_kind();
if !PRE_ORDER && let Some(interrupt) = visitor.default_visit(self, value)? {
core::hint::cold_path();
return Ok(Some(interrupt));
}
match (&mut *self.observer)
.dispatch_tuple((value, kind))
.unwrap_or_else(|| Ok(WalkResult::Advance))?
{
WalkResult::Advance if PRE_ORDER => visitor.default_visit(self, value),
WalkResult::Advance => Ok(None),
WalkResult::Skip => {
core::hint::cold_path();
Ok(None)
}
WalkResult::Interrupt => {
core::hint::cold_path();
Ok(Some(VisitInterrupt::new(Any::new())))
}
WalkResult::InterruptWith(payload) => {
core::hint::cold_path();
Ok(Some(VisitInterrupt::new(payload)))
}
}
}
}
#[inline(always)]
fn run_walker<D>(
root: AnyView<'_>,
observer: &mut D,
order: WalkOrder,
) -> Result<Option<VisitInterrupt>>
where
for<'s, 'v> &'s mut D: Dispatcher<(AnyView<'v>, DefRegionKind), Option<Result<WalkResult>>>,
{
let root = *root.as_raw_ffi_any();
match order {
WalkOrder::PreOrder => {
StructuralVisitEngine::run_visitor(root, &mut WalkVisitor::<D, true> { observer })
}
WalkOrder::PostOrder => {
StructuralVisitEngine::run_visitor(root, &mut WalkVisitor::<D, false> { observer })
}
}
}
pub fn structural_walk<'input, R, M, H, D, O>(
root: R,
walker: H,
order: WalkOrder,
) -> Result<Option<VisitInterrupt>>
where
for<'v> H: IntoDispatcher<
(AnyView<'v>, DefRegionKind),
Option<Result<WalkResult>>,
M,
Target = D,
Output = O,
>,
for<'s, 'v> &'s mut D: Dispatcher<(AnyView<'v>, DefRegionKind), Option<Result<WalkResult>>>,
R: Into<AnyView<'input>>,
O: BorrowMut<D>,
{
let mut storage = walker.into_dispatcher();
run_walker(root.into(), storage.borrow_mut(), order)
}