wowlab_parsers/parsers/spell_desc/

analyzer.rs

use wowlab_types::spell_desc::SpellDescDependencies;

use super::types::{
    ConditionalPredicateNode, ExpressionNode, ParsedSpellDescription, SingleConditionNode,
    SpellDescriptionNode, VariableNode,
};

/// Extract render dependencies; `self_spell_id` resolves self-references like `$s2`.
#[must_use]
pub fn analyze_dependencies(
    ast: &ParsedSpellDescription,
    self_spell_id: u32,
) -> SpellDescDependencies {
    let mut deps = SpellDescDependencies::new();

    deps.add_spell_id(self_spell_id);

    for node in &ast.nodes {
        analyze_node(node, self_spell_id, &mut deps);
    }

    deps
}

// #t(fn: rust_recursive_fn) bounded AST walk over parsed spell description nodes
fn analyze_node(node: &SpellDescriptionNode, self_spell_id: u32, deps: &mut SpellDescDependencies) {
    match node {
        SpellDescriptionNode::Variable(var) => {
            analyze_variable(var, self_spell_id, deps);
        }

        SpellDescriptionNode::ExpressionBlock(block) => {
            analyze_expression(&block.expression, self_spell_id, deps);
        }

        SpellDescriptionNode::Conditional(cond) => {
            for branch in &cond.conditions {
                analyze_predicate(&branch.predicate, deps);

                for node in &branch.content {
                    analyze_node(node, self_spell_id, deps);
                }
            }

            if let Some(else_branch) = &cond.else_branch {
                for node in else_branch {
                    analyze_node(node, self_spell_id, deps);
                }
            }
        }

        SpellDescriptionNode::Text(_)
        | SpellDescriptionNode::ColorCode(_)
        | SpellDescriptionNode::Pluralization(_) => {}

        SpellDescriptionNode::Gender(_) => {
            deps.needs_gender = true;
        }
    }
}

fn analyze_variable(var: &VariableNode, self_spell_id: u32, deps: &mut SpellDescDependencies) {
    match var {
        VariableNode::Effect(effect) => {
            deps.add_effect(self_spell_id, effect.effect_index, effect.var_type.clone());
        }

        VariableNode::SpellLevel(spell_level) => {
            deps.add_spell_value(self_spell_id, spell_level.var_type.clone());
        }

        VariableNode::Player(player) => {
            deps.add_player_stat(player.var_name().to_owned());
        }

        VariableNode::CrossSpell(cross) => {
            if let Some(idx) = cross.effect_index {
                deps.add_effect(cross.spell_id, idx, cross.var_type.clone());
            } else {
                deps.add_spell_value(cross.spell_id, cross.var_type.clone());
            }
        }

        VariableNode::Custom(custom) => {
            deps.add_custom_var(custom.var_name().to_owned());
        }

        VariableNode::At(at) => match at.var_type.as_str() {
            "spelldesc" | "spellname" | "spellicon" => {
                if let Some(spell_id) = at.spell_id {
                    deps.add_embedded_spell(spell_id);
                }
            }
            _ => {
                deps.add_player_stat(at.var_type.clone());
            }
        },

        VariableNode::Enchant(_) => {}

        VariableNode::Misc(misc) => match misc.var_name.as_str() {
            "maxcast" | "pctD" | "W" | "B" => {
                deps.add_player_stat(misc.var_name.clone());
            }
            _ => {}
        },
    }
}

// #t(fn: rust_recursive_fn) bounded AST walk over expression tree nodes
fn analyze_expression(expr: &ExpressionNode, self_spell_id: u32, deps: &mut SpellDescDependencies) {
    match expr {
        ExpressionNode::Variable(var) => {
            analyze_variable(var, self_spell_id, deps);
        }

        ExpressionNode::Binary(binary) => {
            analyze_expression(&binary.left, self_spell_id, deps);
            analyze_expression(&binary.right, self_spell_id, deps);
        }

        ExpressionNode::Unary(unary) => {
            analyze_expression(&unary.operand, self_spell_id, deps);
        }

        ExpressionNode::FunctionCall(call) => {
            for arg in &call.args {
                analyze_expression(arg, self_spell_id, deps);
            }
        }

        ExpressionNode::Number(_) => {}

        ExpressionNode::Paren(paren) => {
            analyze_expression(&paren.expression, self_spell_id, deps);
        }
    }
}

fn analyze_predicate(predicate: &ConditionalPredicateNode, deps: &mut SpellDescDependencies) {
    for condition in &predicate.conditions {
        match condition {
            SingleConditionNode::SpellKnown(spell_known) => {
                deps.add_spell_known_check(spell_known.spell_id());
            }

            SingleConditionNode::Aura(aura) => {
                deps.add_aura_check(aura.aura_id());
            }

            SingleConditionNode::Specialization(spec) => {
                deps.add_specialization_check(spec.spec_index());
            }

            SingleConditionNode::PlayerCondition(_) => {}

            SingleConditionNode::Expression(expr_cond) => {
                for arg in &expr_cond.args {
                    analyze_expression(arg, 0, deps);
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use insta::assert_debug_snapshot;
    use wowlab_types::spell_desc::{EffectDependency, SpellValueDependency};

    use super::*;
    use crate::parsers::spell_desc::parse;

    fn deps(input: &str, self_spell_id: u32) -> SpellDescDependencies {
        analyze_dependencies(&parse(input).ast, self_spell_id)
    }

    #[gtest]
    fn self_ref_adds_self_spell_and_effect() -> Result<()> {
        let d = deps("$s1", 100);

        verify_that!(d.spell_ids, contains(eq(&100u32)))?;
        verify_that!(
            d.effects,
            contains(eq(&EffectDependency {
                spell_id: 100,
                effect_index: 1,
                var_type: "s".to_string(),
            }))
        )?;

        Ok(())
    }

    #[gtest]
    fn cross_spell_with_effect_index() -> Result<()> {
        let d = deps("$12345s2", 100);

        verify_that!(d.spell_ids, contains(eq(&12345u32)))?;
        verify_that!(d.spell_ids, contains(eq(&100u32)))?;
        verify_that!(
            d.effects,
            contains(eq(&EffectDependency {
                spell_id: 12345,
                effect_index: 2,
                var_type: "s".to_string(),
            }))
        )?;

        Ok(())
    }

    #[gtest]
    fn cross_spell_value_form() -> Result<()> {
        let d = deps("$12345d", 100);

        verify_that!(d.spell_ids, contains(eq(&12345u32)))?;
        verify_that!(
            d.spell_values,
            contains(eq(&SpellValueDependency {
                spell_id: 12345,
                var_type: "d".to_string(),
            }))
        )?;

        Ok(())
    }

    #[gtest]
    fn gender_node_sets_needs_gender() -> Result<()> {
        verify_that!(deps("$ghis:her;", 100).needs_gender, eq(true))?;
        verify_that!(deps("$s1", 100).needs_gender, eq(false))?;

        Ok(())
    }

    #[gtest]
    fn conditional_predicates_collected() -> Result<()> {
        verify_that!(
            deps("$?s99[a][b]", 100).spell_known_checks,
            contains(eq(&99u32))
        )?;
        verify_that!(deps("$?a88[a][b]", 100).aura_checks, contains(eq(&88u32)))?;
        verify_that!(
            deps("$?c1[a][b]", 100).specialization_checks,
            contains(eq(&1u8))
        )?;

        Ok(())
    }

    #[gtest]
    fn embedded_and_player_stat_at_vars() -> Result<()> {
        verify_that!(
            deps("$@spelldesc12345", 100).embedded_spell_ids,
            contains(eq(&12345u32))
        )?;
        verify_that!(
            deps("$@spellname12345", 100).embedded_spell_ids,
            contains(eq(&12345u32))
        )?;
        verify_that!(
            deps("$@spellicon12345", 100).embedded_spell_ids,
            contains(eq(&12345u32))
        )?;
        verify_that!(
            deps("$@somestat", 100).player_stats,
            contains(eq("somestat"))
        )?;

        Ok(())
    }

    #[gtest]
    fn self_id_always_present() -> Result<()> {
        verify_that!(deps("plain text", 777).spell_ids, contains(eq(&777u32)))?;

        Ok(())
    }

    #[gtest]
    fn complex_description_deps_snapshot() {
        let d = deps(
            "$s1 $12345s2 $?s99[known][unknown] $ghis:her; $@spelldesc500",
            100,
        );

        assert_debug_snapshot!(d);
    }
}