vvv-lang 0.2.0

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

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

syntax_view! {
    impl MacroInvocation {
        kinds: ["macro_invocation"],
        required: {},
        optional: {}
    }
}

impl<'tree, L: LanguageExt> MacroInvocation<'tree, L> {
    pub fn parent(&self) -> Option<Node<'tree, StrDoc<L>>> {
        self.syntax().parent()
    }

    pub fn occupies_field(&self, parent: &Node<'tree, StrDoc<L>>, field: &str) -> bool {
        parent
            .field(field)
            .is_some_and(|child| child.range() == self.syntax().range())
    }

    pub fn extract(&self, shared: &NavigationFacts<'_>, facts: &mut Facts) {
        let Some(rule) = shared.grammar.macro_scopes else {
            return;
        };
        let expression = self.parent().is_some_and(|parent| {
            rule.expression_containers.contains(&parent.kind().as_ref())
                || rule.expression_fields.iter().any(|(kind, field)| {
                    parent.kind() == *kind && self.occupies_field(&parent, field)
                })
        });
        if expression {
            return;
        }
        if let Some(scope) = self
            .syntax()
            .ancestors()
            .take_while(|ancestor| {
                !shared
                    .grammar
                    .lexical_boundaries
                    .contains(&ancestor.kind().as_ref())
                    && ancestor.kind() != rule.node
            })
            .find(|ancestor| rule.scopes.contains(&ancestor.kind().as_ref()))
        {
            facts.scope_uncertainties.push(ScopeUncertainty {
                scope: scope.range().into(),
                invocation: self.syntax().range().into(),
            });
        }
    }
}

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

    #[test]
    fn placement_distinguishes_initializer_fields_from_statement_invocations() {
        let tree = Rust.ast_grep("fn f() { let value = compute!(); generate!(); }");
        let root = tree.root();
        let mut calls = root.dfs().filter_map(MacroInvocation::cast);
        let initializer = calls.next().unwrap();
        let parent = initializer.parent().unwrap();
        assert_eq!(parent.kind(), "let_declaration");
        assert!(initializer.occupies_field(&parent, "value"));
        assert!(!initializer.occupies_field(&parent, "pattern"));
        assert_eq!(
            calls.next().unwrap().parent().unwrap().kind(),
            "expression_statement"
        );
    }
}