vvv-lang 0.2.0

Language support for vvv: the ast-grep adapter and one module per language
Documentation
use super::{
    match_arm::{ArmNavigation, MatchArm},
    navigation::UnsupportedSyntax,
};
use crate::syntax::navigation::{NavigationCoverage, NavigationFacts};
use crate::syntax::views::syntax_view;
use ast_grep_core::{
    Node,
    tree_sitter::{LanguageExt, StrDoc},
};
use vvv_core::Facts;

pub(super) struct Match<'tree, L: LanguageExt> {
    node: Node<'tree, StrDoc<L>>,
}

syntax_view! {
    impl Match {
        kinds: ["match_expression"],
        required: {
            value: "value",
            body: "body"
        },
        optional: {}
    }
}

pub(super) struct MatchBody<'tree, L: LanguageExt> {
    node: Node<'tree, StrDoc<L>>,
}

syntax_view! { impl MatchBody { kinds: ["match_block"], required: {}, optional: {}, children: {items: []} } }
impl<'tree, L: LanguageExt> MatchBody<'tree, L> {
    pub fn arms(&self) -> impl Iterator<Item = MatchArm<'tree, L>> {
        self.items().filter_map(MatchArm::cast)
    }
}

pub(super) struct MatchNavigation<'tree, L: LanguageExt> {
    view: Match<'tree, L>,
    body: MatchBody<'tree, L>,
}

impl<'tree, L: LanguageExt> MatchNavigation<'tree, L> {
    pub fn from_node(node: Node<'tree, StrDoc<L>>) -> Result<Self, UnsupportedSyntax> {
        UnsupportedSyntax::validate(&node)?;
        let view = Match::cast(node.clone()).ok_or_else(|| UnsupportedSyntax::at(&node))?;
        let value = view.value().map_err(|_| UnsupportedSyntax::at(&node))?;
        if value
            .dfs()
            .any(|child| child.is_error() || child.is_missing())
        {
            return Err(UnsupportedSyntax::at(&value));
        }
        let body = view.body().map_err(|_| UnsupportedSyntax::at(&node))?;
        let body = MatchBody::cast(body).ok_or_else(|| UnsupportedSyntax::at(&node))?;
        UnsupportedSyntax::validate(body.syntax())?;
        Ok(Self { view, body })
    }

    pub fn extract(
        &self,
        shared: &NavigationFacts<'_>,
        facts: &mut Facts,
        coverage: &mut NavigationCoverage,
    ) {
        coverage.model(self.view.syntax().range().into());
        for arm in self.body.arms() {
            let span = arm.syntax().range().into();
            match ArmNavigation::new(arm) {
                Ok(arm) => arm.extract(shared, facts, coverage),
                Err(_) => coverage.block(span),
            }
        }
    }
}

#[cfg(test)]
mod view_tests {
    use super::*;
    use ast_grep_language::Rust;

    #[test]
    fn match_body_iterates_direct_arms_without_flattening_nested_matches() {
        let tree = Rust.ast_grep(
            "fn f() { match input { // comment\n Some(x) => match x { _ => 1 }, _ => 0 } }",
        );
        let view = tree.root().dfs().find_map(Match::cast).unwrap();
        assert_eq!(view.value().unwrap().text(), "input");
        let body = MatchBody::cast(view.body().unwrap()).unwrap();
        let arms: Vec<_> = body.arms().collect();
        assert_eq!(arms.len(), 2);
        assert!(arms[0].syntax().text().contains("match x"));
    }
}