pub(crate) mod visit {
    macro_rules! validate_then_visit {
        ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident ($($ann:tt)*))*) => {$(
            fn $visit(&mut self $($(,$arg: $argty)*)?) -> Self::Output {
                if let Some(validator) = self.validator.as_mut() {
                    if let Err(e) = validator.visitor(self.position).$visit($($($arg.clone()),*)?) {
                        core::hint::cold_path();
                        return Err(crate::ParseError::ParseError { message: e.to_string(), offset: self.position });
                    }
                }
                self.builder.$visit($($($arg),*)?)
            }
        )*};
    }

    macro_rules! validate_then_visit_simd {
        ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident ($($ann:tt)*))*) => {$(
            fn $visit(&mut self $($(,$arg: $argty)*)?) -> Self::Output {
                if let Some(validator) = self.validator.as_mut() {
                    if let Err(e) = validator.simd_visitor(self.position).$visit($($($arg.clone()),*)?) {
                        core::hint::cold_path();
                        return Err(crate::ParseError::ParseError { message: e.to_string(), offset: self.position });
                    }
                }
                self.builder.$visit($($($arg),*)?)
            }
        )*};
    }

    macro_rules! lowering_ops {
        () => {};
        ($kind:ident $inputs:tt => $outputs:tt {
            $($visit:ident $(($($arg:ident: $ty:ty),+))? => $instr:ident),* $(,)?
        } $($rest:tt)*) => {
            $(lowering_ops!(@$kind $inputs => $outputs $visit $(($($arg: $ty),+))? => $instr);)*
            lowering_ops!($($rest)*);
        };
        (effect $inputs:tt => $outputs:tt { $($visit:ident),* $(,)? } $($rest:tt)*) => {
            $(lowering_ops!(@effect $inputs => $outputs $visit);)*
            lowering_ops!($($rest)*);
        };

        (@fixed [$($input:ident),*] => [$($output:ident),*]
            $visit:ident $(($($arg:ident: $ty:ty),+))? => $instr:ident
        ) => {
            fn $visit(&mut self $(, $($arg: $ty),+)?) -> Self::Output {
                lowering_ops!(@emit self fixed [$($input),*] => [$($output),*]
                    Instruction::$instr $(($($arg),+))?.into())
            }
        };
        (@memory [$($input:ident),*] => [$($output:ident),*]
            $visit:ident $(($lane:ident: $ty:ty))? => $instr:ident
        ) => {
            fn $visit(&mut self, memarg: wasmparser::MemArg $(, $lane: $ty)?) -> Self::Output {
                let address = self.metadata.memory_size(memarg.memory)?;
                lowering_ops!(@emit self address(address) [$($input),*] => [$($output),*]
                    Instruction::$instr(MemoryArg::new(memarg.offset, memarg.memory) $(, $lane)?).into())
            }
        };
        (@global $inputs:tt => $outputs:tt $($operator:tt)*) => {
            lowering_ops!(@resolved global_size $inputs => $outputs $($operator)*);
        };
        (@memory_index $inputs:tt => $outputs:tt $($operator:tt)*) => {
            lowering_ops!(@resolved memory_size $inputs => $outputs $($operator)*);
        };
        (@table $inputs:tt => $outputs:tt $($operator:tt)*) => {
            lowering_ops!(@resolved table_size $inputs => $outputs $($operator)*);
        };
        (@resolved $resolver:ident [$($input:ident),*] => [$($output:ident),*]
            $visit:ident($index:ident: $ty:ty) => $instr:ident
        ) => {
            fn $visit(&mut self, $index: $ty) -> Self::Output {
                let address = self.metadata.$resolver($index)?;
                lowering_ops!(@emit self address(address) [$($input),*] => [$($output),*]
                    Instruction::$instr($index).into())
            }
        };
        (@resolved $resolver:ident [$($input:ident),*] => [$($output:ident),*]
            $visit:ident($arg:ident: $arg_ty:ty, $index:ident: $index_ty:ty) => $instr:ident
        ) => {
            fn $visit(&mut self, $arg: $arg_ty, $index: $index_ty) -> Self::Output {
                let address = self.metadata.$resolver($index)?;
                lowering_ops!(@emit self address(address) [$($input),*] => [$($output),*]
                    Instruction::$instr($arg, $index).into())
            }
        };
        (@effect [$($input:ident),*] => [$($output:ident),*] $visit:ident) => {
            fn $visit(&mut self) -> Self::Output {
                self.apply_effect(&[$(lowering_ops!(@size $input)),*], &[$(lowering_ops!(@size $output)),*])
            }
        };
        (@terminating [$($input:ident),*] => [$($output:ident),*] $visit:ident => $instr:ident) => {
            fn $visit(&mut self) -> Self::Output {
                self.mark_unreachable();
                lowering_ops!(@emit self fixed [$($input),*] => [$($output),*] Instruction::$instr)
            }
        };

        (@emit $self:ident fixed [$($input:ident),*] => [$($output:ident),*] $instruction:expr) => {
            $self.emit(
                &[$(lowering_ops!(@size $input)),*],
                &[$(lowering_ops!(@size $output)),*],
                $instruction,
            )
        };
        (@emit $self:ident address($address:ident) [$($input:ident),*] => [$($output:ident),*] $instruction:expr) => {
            $self.emit(
                &[$(lowering_ops!(@size $input, $address)),*],
                &[$(lowering_ops!(@size $output, $address)),*],
                $instruction,
            )
        };

        (@size Addr, $address:ident) => { $address };
        (@size $size:ident $(, $address:ident)?) => { OperandSize::$size };
    }

    macro_rules! impl_visit_operator {
        ($(@$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident ($($ann:tt)*))*) => {
            $(impl_visit_operator!(@@$proposal $op $({ $($arg: $argty),* })? => $visit ($($ann:tt)*));)*
        };

        (@@mvp $($rest:tt)* ) => {};
        (@@reference_types $($rest:tt)* ) => {};
        (@@sign_extension $($rest:tt)* ) => {};
        (@@saturating_float_to_int $($rest:tt)* ) => {};
        (@@bulk_memory $($rest:tt)* ) => {};
        (@@simd $($rest:tt)* ) => {};
        (@@wide_arithmetic $($rest:tt)* ) => {};
        (@@relaxed_simd $($rest:tt)* ) => {};
        (@@tail_call $($rest:tt)* ) => {};

        (@@$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident ($($ann:tt)*)) => {
            fn $visit(&mut self $($(,_: $argty)*)?) -> Self::Output {
                Err(crate::ParseError::UnsupportedOperator(stringify!($visit).to_string()))
            }
        };
    }

    pub(crate) use {impl_visit_operator, lowering_ops, validate_then_visit, validate_then_visit_simd};
}

pub(crate) mod optimize {
    macro_rules! replace {
        ($instructions:ident, $read:ident, $consumed:expr => [$($out:expr),+ $(,)?]) => {{
            const {
                assert!($consumed >= 1 && $consumed <= 3);
                assert!([$(stringify!($out)),+].len() <= $consumed + 1);
            }
            let replacements = [$($out),+];
            let start = $read - $consumed;
            $instructions[start..start + replacements.len()].copy_from_slice(&replacements);
            $instructions.truncate(start + replacements.len());
            #[allow(unused_assignments)]
            { $read = $instructions.len() - 1; }
        }};
        ($instructions:ident, $read:ident, $consumed:expr => $out:expr) => {
            replace!($instructions, $read, $consumed => [$out]);
        };
    }

    macro_rules! rewrite {
        ($instructions:ident, $read:ident, [$($pattern:pat),+] $(if ($($guard:tt)+))? => [$($out:expr),+ $(,)?]) => {
            rewrite!($instructions, $read, [$($pattern),+] $(if ($($guard)+))? => {
                replace!($instructions, $read, [$(stringify!($pattern)),+].len() => [$($out),+]);
            })
        };
        ($instructions:ident, $read:ident, [$($pattern:pat),+] $(if ($($guard:tt)+))? => $body:block $(,)?) => {{
            const CONSUMED: usize = [$(stringify!($pattern)),+].len();
            if !$instructions.tail_rewritten
                && $read < $instructions.len()
                && $read >= $instructions.block_start + CONSUMED
            {
                let previous: [Instruction; CONSUMED] = $instructions[$read - CONSUMED..$read].try_into().unwrap();
                if let [$($pattern),+] = previous $(
                    && $($guard)+
                )? {
                    $instructions.tail_rewritten = true;
                    $body
                }
            }
        }};
        ($instructions:ident, $read:ident, [$($pattern:pat),+] $(if ($($guard:tt)+))? => $out:expr $(,)?) => {
            rewrite!($instructions, $read, [$($pattern),+] $(if ($($guard)+))? => {
                replace!($instructions, $read, [$(stringify!($pattern)),+].len() => $out);
            })
        };
    }

    macro_rules! define_local_source_resolver {
        (
            $name:ident,
            get = $get:ident,
            tee = $tee:ident,
            set = $set:ident,
            binop_local_local_tee = $lltee:ident,
            binop_local_local_set = $llset:ident,
            binop_local_const_tee = $lctee:ident,
            binop_local_const_set = $lcset:ident
            $(, load_local_tee = $loadtee:ident, load_local_set = $loadset:ident)?
        ) => {
            fn $name(instr: Instruction) -> Option<(Option<Instruction>, u16)> {
                Some(match instr {
                    Instruction::$get(local) => (None, local),
                    Instruction::$tee(local) => (Some(Instruction::$set(local)), local),
                    Instruction::$lltee(op, a, b, local) => (Some(Instruction::$llset(op, a, b, local)), local),
                    Instruction::$lctee(op, src, c, local) => (Some(Instruction::$lcset(op, src, c, local)), local),
                    $(Instruction::$loadtee(memarg, addr, local) => (Some(Instruction::$loadset(memarg, addr, local)), local.into()),)?
                    _ => return None,
                })
            }
        };
    }

    macro_rules! fold_local_binop {
        (
            $instrs:ident, $read:expr, $dst:expr,
            source = $source:ident,
            op = $op:ident,
            const = $const:ident,
            local_local = $local_local:ident,
            local_const = $local_const:expr
        ) => {{
            if !$instrs.tail_rewritten
                && $read < $instrs.len()
                && $read >= $instrs.block_start + 3
                && let [lhs_src, rhs_src, raw_op] = [$instrs[$read - 3], $instrs[$read - 2], $instrs[$read - 1]]
                && let Some((lhs_instr, lhs)) = $source(lhs_src)
                && let Some(op) = $op(raw_op)
            {
                if let Some((rhs_instr, rhs)) = $source(rhs_src) {
                    if rhs_instr.is_none() || rhs != lhs {
                        $instrs.tail_rewritten = true;
                        $instrs.truncate($read - 3);
                        $instrs.extend(lhs_instr);
                        $instrs.extend(rhs_instr);
                        $instrs.push(Instruction::$local_local(op, lhs, rhs, $dst));
                        $read = $instrs.len() - 1;
                    }
                } else if let Some(imm) = $const(rhs_src, raw_op) {
                    $instrs.tail_rewritten = true;
                    $instrs.truncate($read - 3);
                    $instrs.extend(lhs_instr);
                    $instrs.push($local_const($dst, lhs, op, imm));
                    $read = $instrs.len() - 1;
                }
            }
        }};
    }

    macro_rules! rewrite_local_set_direct {
        (
            $instrs:ident, $read:ident, $dst:expr,
            get = $get:ident,
            copy = $copy:ident,
            binop_local_local = $ll:ident,
            binop_local_local_set = $llset:ident,
            binop_local_const = $lc:ident,
            binop_local_const_set = $lcset:expr
            $(, const_instr = $const_instr:ident, set_local_const = $set_local_const:ident)?
        ) => {{
            rewrite!($instrs, $read, [$get(src)] if (src != $dst) => Instruction::$copy(src, $dst));
            if !$instrs.tail_rewritten
                && $read < $instrs.len()
                && $read > $instrs.block_start
                && let Instruction::$get(src) = $instrs[$read - 1]
                && src == $dst
            {
                $instrs.tail_rewritten = true;
                $instrs.truncate($read - 1);
                $read = $instrs.len();
            }
            $(rewrite!($instrs, $read, [$const_instr(c)] => Instruction::$set_local_const($dst, c));)?
            rewrite!($instrs, $read, [$ll(op, a, b)] => Instruction::$llset(op, a, b, $dst));
            rewrite!($instrs, $read, [$lc(op, src, c)] => { replace!($instrs, $read, 1 => $lcset($dst, src, op, c)); });
        }};
    }

    macro_rules! rewrite_local_tee_direct {
        (
            $instrs:ident, $read:ident, $dst:expr,
            get = $get:ident,
            binop_local_local = $ll:ident,
            binop_local_local_tee = $lltee:ident,
            binop_local_const = $lc:ident,
            binop_local_const_tee = $lctee:ident
        ) => {{
            rewrite!($instrs, $read, [$get(src)] if (src == $dst) => Instruction::$get(src));
            rewrite!($instrs, $read, [$ll(op, a, b)] => Instruction::$lltee(op, a, b, $dst));
            rewrite!($instrs, $read, [$lc(op, src, c)] => Instruction::$lctee(op, src, c, $dst));
        }};
    }

    macro_rules! rewrite_drop_tee_direct {
        (
            $instrs:ident, $read:ident,
            tee = $tee:ident,
            set = $set:ident,
            binop_local_local_tee = $lltee:ident,
            binop_local_local_set = $llset:ident,
            binop_local_const_tee = $lctee:ident,
            binop_local_const_set = $lcset:ident
        ) => {{
            rewrite!($instrs, $read, [$tee(local)] => Instruction::$set(local));
            rewrite!($instrs, $read, [$lltee(op, a, b, dst)] => Instruction::$llset(op, a, b, dst));
            rewrite!($instrs, $read, [$lctee(op, src, c, dst)] => Instruction::$lcset(op, src, c, dst));
        }};
    }

    pub(crate) use {
        define_local_source_resolver, fold_local_binop, replace, rewrite, rewrite_drop_tee_direct,
        rewrite_local_set_direct, rewrite_local_tee_direct,
    };
}