wowlab_engine_domain/rotation/validate/

mod.rs

//! Pre-compilation validation for rotation definitions.

use wowlab_types::sim::{Condition, FastSet, Rotation, RotationAction as Action, VarOp};

use super::buffer::DescriptorTable;

mod dependency_graph;
mod errors;
mod schema;
#[cfg(test)]
mod tests;

use dependency_graph::{
    action_list_dependency_graph, dependency_postorder, expanded_rotation_action_count,
    variable_dependency_graph,
};
pub use errors::{ValidationError, ValidationResult, ValidationWarning};
pub use schema::{VarPathCategory, VarPathInfo, get_var_path_schema};

pub(super) const MAX_CONDITION_DEPTH: usize = 256;

/// Ceiling on expanded action nodes; bounds compiler work and IR from branching list graphs.
pub(super) const MAX_EXPANDED_ACTIONS: usize = 65_536;

fn condition_depth(root: &Condition) -> usize {
    let mut max_depth = 0;

    root.walk_with_depth(&mut |_condition, depth| max_depth = max_depth.max(depth));

    max_depth
}

struct ValidationCtx<'rotation, 'ctx> {
    variable_names: &'ctx FastSet<String>,
    list_names: &'ctx FastSet<String>,
    table: &'ctx DescriptorTable,
    used_variables: &'ctx mut FastSet<&'rotation str>,
    used_lists: &'ctx mut FastSet<String>,
    errors: &'ctx mut Vec<ValidationError>,
}

/// Runs all structural checks on a parsed [`Rotation`].
// #t(fn: rust_clone_in_loop) building owned errors/warnings from borrowed AST data
#[must_use]
pub fn validate_rotation(rotation: &Rotation) -> ValidationResult {
    fn collect_setvar_names(actions: &[Action], names: &mut FastSet<String>) {
        for action in actions {
            if let Action::SetVar { name, .. } = action {
                names.insert(name.clone());
            }
        }
    }

    let expected_findings = rotation.variables.len() + rotation.lists.len();
    let mut errors = Vec::with_capacity(expected_findings);
    let mut warnings = Vec::with_capacity(expected_findings);

    let table = DescriptorTable::build();

    let mut variable_names: FastSet<_> = rotation.variables.keys().cloned().collect();
    let list_names: FastSet<_> = rotation.lists.keys().cloned().collect();

    collect_setvar_names(&rotation.actions, &mut variable_names);

    for actions in rotation.lists.values() {
        collect_setvar_names(actions, &mut variable_names);
    }

    let mut used_variables = FastSet::default();
    let mut used_lists = FastSet::default();

    if rotation.actions.is_empty() {
        errors.push(ValidationError::EmptyActionList {
            list_name: "actions".to_string(),
        });
    }

    for (name, actions) in &rotation.lists {
        if actions.is_empty() {
            errors.push(ValidationError::EmptyActionList {
                list_name: name.clone(),
            });
        }
    }

    let mut ctx = ValidationCtx {
        variable_names: &variable_names,
        list_names: &list_names,
        table: &table,
        used_variables: &mut used_variables,
        used_lists: &mut used_lists,
        errors: &mut errors,
    };

    for (idx, action) in rotation.actions.iter().enumerate() {
        validate_action(&mut ctx, action, "actions", idx);
    }

    for (list_name, actions) in &rotation.lists {
        for (idx, action) in actions.iter().enumerate() {
            validate_action(&mut ctx, action, list_name, idx);
        }
    }

    for cond in rotation.variables.values() {
        validate_condition(&mut ctx, cond);
    }

    validate_dependency_graphs(rotation, ctx.errors);

    for name in &variable_names {
        if !used_variables.contains(name.as_str()) {
            warnings.push(ValidationWarning::UnusedVariable { name: name.clone() });
        }
    }

    for name in &list_names {
        if !used_lists.contains(name) {
            warnings.push(ValidationWarning::UnusedList { name: name.clone() });
        }
    }

    ValidationResult {
        valid: errors.is_empty(),
        errors,
        warnings,
    }
}

fn validate_dependency_graphs(rotation: &Rotation, errors: &mut Vec<ValidationError>) {
    let variable_graph = variable_dependency_graph(&rotation.variables);

    if let Err(path) = dependency_postorder(&variable_graph) {
        errors.push(ValidationError::CircularReference { path });
    }

    let list_graph = action_list_dependency_graph(&rotation.lists);

    match dependency_postorder(&list_graph) {
        Err(path) => errors.push(ValidationError::CircularReference { path }),
        Ok(postorder) => {
            let actions = expanded_rotation_action_count(rotation, &postorder);

            if actions > MAX_EXPANDED_ACTIONS {
                errors.push(ValidationError::ActionExpansionLimitExceeded {
                    actions,
                    max: MAX_EXPANDED_ACTIONS,
                });
            }
        }
    }
}

fn is_supported_action(action: &Action) -> bool {
    matches!(
        action,
        Action::Cast { .. }
            | Action::Call { .. }
            | Action::Run { .. }
            | Action::SetVar { .. }
            | Action::ModifyVar { .. }
            | Action::Wait { .. }
            | Action::WaitUntil { .. }
            | Action::Pool { .. }
            | Action::UseTrinket { .. }
            | Action::UseItem { .. }
    )
}

fn is_supported_var_op(op: VarOp) -> bool {
    matches!(
        op,
        VarOp::Add
            | VarOp::Sub
            | VarOp::Mul
            | VarOp::Div
            | VarOp::Mod
            | VarOp::Max
            | VarOp::Min
            | VarOp::Floor
            | VarOp::Ceil
            | VarOp::Reset
    )
}

fn validate_empower_rank(
    errors: &mut Vec<ValidationError>,
    action: &Action,
    list_name: &str,
    action_index: usize,
) {
    let invalid_slug = match action {
        Action::Cast {
            spell,
            empower_rank: Some(0),
            ..
        } => Some(spell.clone()),
        Action::UseItem {
            name,
            empower_rank: Some(0),
            ..
        } => Some(name.clone()),
        Action::UseTrinket {
            slot,
            empower_rank: Some(0),
            ..
        } => Some(format!("trinket{slot}")),
        _ => None,
    };

    if let Some(slug) = invalid_slug {
        errors.push(ValidationError::InvalidExpression {
            message: "empower_rank must be one-based".to_string(),
            list_name: Some(list_name.to_string()),
            action_index: Some(action_index),
            slug: Some(slug),
        });
    }
}

fn validate_action_list_reference(ctx: &mut ValidationCtx<'_, '_>, action: &Action) {
    let (Action::Call { list, .. } | Action::Run { list, .. }) = action else {
        return;
    };

    if ctx.list_names.contains(list) {
        ctx.used_lists.insert(list.clone());
    } else {
        ctx.errors
            .push(ValidationError::UndefinedList { name: list.clone() });
    }
}

fn validate_modify_var<'rotation>(
    ctx: &mut ValidationCtx<'rotation, '_>,
    action: &'rotation Action,
    list_name: &str,
    action_index: usize,
) {
    let Action::ModifyVar {
        name, op, value, ..
    } = action
    else {
        return;
    };

    if !is_supported_var_op(*op) {
        ctx.errors.push(ValidationError::UnsupportedSyntax {
            construct: format!("variable operator {op:?}"),
        });

        return;
    }

    if ctx.variable_names.contains(name) {
        ctx.used_variables.insert(name);
    } else {
        ctx.errors
            .push(ValidationError::UndefinedVariable { name: name.clone() });
    }

    let requires_numeric = matches!(
        op,
        VarOp::Add | VarOp::Sub | VarOp::Mul | VarOp::Div | VarOp::Min | VarOp::Max
    );

    if requires_numeric && matches!(value, Condition::Bool { .. }) {
        ctx.errors.push(ValidationError::TypeMismatch {
            name: name.clone(),
            op: op.name().to_string(),
            expected: "int or float".to_string(),
            got: "bool".to_string(),
            list_name: Some(list_name.to_string()),
            action_index: Some(action_index),
        });
    }
}

fn validate_action<'rotation>(
    ctx: &mut ValidationCtx<'rotation, '_>,
    action: &'rotation Action,
    list_name: &str,
    action_index: usize,
) {
    if !is_supported_action(action) {
        ctx.errors.push(ValidationError::UnsupportedSyntax {
            construct: format!("action variant {action:?}"),
        });

        return;
    }

    validate_empower_rank(ctx.errors, action, list_name, action_index);
    validate_action_list_reference(ctx, action);

    for cond in action.conditions() {
        validate_condition(ctx, cond);
    }

    validate_modify_var(ctx, action, list_name, action_index);
}

fn validate_condition<'rotation>(
    ctx: &mut ValidationCtx<'rotation, '_>,
    root: &'rotation Condition,
) {
    let depth = condition_depth(root);

    if depth > MAX_CONDITION_DEPTH {
        ctx.errors.push(ValidationError::MaxDepthExceeded {
            depth,
            max: MAX_CONDITION_DEPTH,
        });
        // Don't walk the tree further; downstream recursion is exactly what the bound protects.

        return;
    }

    let mut undefined_variables = Vec::new();

    root.walk(&mut |cond| match cond {
        Condition::Var { name } => {
            if ctx.variable_names.contains(name) {
                ctx.used_variables.insert(name);
            } else {
                undefined_variables.push(name.as_str());
            }
        }
        Condition::Read { field } if ctx.table.lookup(&field.domain, &field.name).is_none() => {
            ctx.errors.push(ValidationError::UnknownField {
                domain: field.domain.clone(),
                name: field.name.clone(),
            });
        }
        Condition::Compare { op, .. } => match op {
            wowlab_types::sim::CompareOp::Gt
            | wowlab_types::sim::CompareOp::Gte
            | wowlab_types::sim::CompareOp::Lt
            | wowlab_types::sim::CompareOp::Lte
            | wowlab_types::sim::CompareOp::Eq
            | wowlab_types::sim::CompareOp::Ne => {}
            _ => ctx.errors.push(ValidationError::UnsupportedSyntax {
                construct: format!("comparison operator {op:?}"),
            }),
        },
        Condition::Arith { op, .. } => match op {
            wowlab_types::sim::ArithOp::Add
            | wowlab_types::sim::ArithOp::Sub
            | wowlab_types::sim::ArithOp::Mul
            | wowlab_types::sim::ArithOp::Div
            | wowlab_types::sim::ArithOp::Mod => {}
            _ => ctx.errors.push(ValidationError::UnsupportedSyntax {
                construct: format!("arithmetic operator {op:?}"),
            }),
        },
        Condition::UnaryMath { op, .. } => match op {
            wowlab_types::sim::UnaryMathOp::Floor
            | wowlab_types::sim::UnaryMathOp::Ceil
            | wowlab_types::sim::UnaryMathOp::Abs => {}
            _ => ctx.errors.push(ValidationError::UnsupportedSyntax {
                construct: format!("unary math operator {op:?}"),
            }),
        },
        Condition::MinMax { op, .. } => match op {
            wowlab_types::sim::MinMaxOp::Min | wowlab_types::sim::MinMaxOp::Max => {}
            _ => ctx.errors.push(ValidationError::UnsupportedSyntax {
                construct: format!("min/max operator {op:?}"),
            }),
        },
        Condition::Read { .. }
        | Condition::Bool { .. }
        | Condition::Int { .. }
        | Condition::Float { .. }
        | Condition::And { .. }
        | Condition::Or { .. }
        | Condition::Not { .. }
        | Condition::IfThenElse { .. } => {}
        _ => ctx.errors.push(ValidationError::UnsupportedSyntax {
            construct: format!("condition variant {cond:?}"),
        }),
    });

    ctx.errors
        .extend(
            undefined_variables
                .into_iter()
                .map(|name| ValidationError::UndefinedVariable {
                    name: name.to_owned(),
                }),
        );
}