vvv-lang 0.2.0

Language support for vvv: the ast-grep adapter and one module per language
Documentation
use super::{condition::Condition, navigation::UnsupportedSyntax, pattern::PatternNavigation};
use crate::syntax::navigation::{BindingSite, NavigationCoverage, NavigationFacts};
use crate::syntax::views::syntax_view;
use ast_grep_core::{
    Node,
    tree_sitter::{LanguageExt, StrDoc},
};
use vvv_core::{BindingNamespace, Facts, SymbolKind};

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

syntax_view! {
    impl InfiniteLoop {
        kinds: ["loop_expression"],
        required: {
            body: "body"
        },
        optional: {}
    }
}

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

syntax_view! {
    impl WhileLoop {
        kinds: ["while_expression"],
        required: {
            condition: "condition",
            body: "body"
        },
        optional: {}
    }
}

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

syntax_view! {
    impl ForLoop {
        kinds: ["for_expression"],
        required: {
            pattern: "pattern",
            value: "value",
            body: "body"
        },
        optional: {}
    }
}

pub(super) enum Loop<'tree, L: LanguageExt> {
    Infinite(InfiniteLoop<'tree, L>),
    While(WhileLoop<'tree, L>),
    For(ForLoop<'tree, L>),
}

impl<'tree, L: LanguageExt> Loop<'tree, L> {
    pub fn cast(node: Node<'tree, StrDoc<L>>) -> Option<Self> {
        match node.kind().as_ref() {
            "loop_expression" => InfiniteLoop::cast(node).map(Self::Infinite),
            "while_expression" => WhileLoop::cast(node).map(Self::While),
            "for_expression" => ForLoop::cast(node).map(Self::For),
            _ => None,
        }
    }

    pub fn body(&self) -> Result<Node<'tree, StrDoc<L>>, crate::syntax::views::SyntaxError> {
        match self {
            Self::Infinite(view) => view.body(),
            Self::While(view) => view.body(),
            Self::For(view) => view.body(),
        }
    }
}

pub(super) enum LoopBindings<'tree, L: LanguageExt> {
    Infinite {
        view: InfiniteLoop<'tree, L>,
    },
    While {
        view: WhileLoop<'tree, L>,
        condition: Node<'tree, StrDoc<L>>,
    },
    For {
        view: ForLoop<'tree, L>,
        pattern: Node<'tree, StrDoc<L>>,
        value: Node<'tree, StrDoc<L>>,
    },
}

impl<'tree, L: LanguageExt> LoopBindings<'tree, L> {
    pub fn from_node(node: Node<'tree, StrDoc<L>>) -> Result<Self, UnsupportedSyntax> {
        UnsupportedSyntax::validate(&node)?;
        let expression = Loop::cast(node.clone()).ok_or_else(|| UnsupportedSyntax::at(&node))?;
        let body = expression
            .body()
            .map_err(|_| UnsupportedSyntax::at(&node))?;
        if super::block::Block::cast(body.clone()).is_none() {
            return Err(UnsupportedSyntax::at(&node));
        }
        UnsupportedSyntax::validate(&body)?;
        Ok(match expression {
            Loop::Infinite(view) => Self::Infinite { view },
            Loop::While(view) => {
                let condition = view.condition().map_err(|_| UnsupportedSyntax::at(&node))?;
                Self::While { view, condition }
            }
            Loop::For(view) => {
                let pattern = view.pattern().map_err(|_| UnsupportedSyntax::at(&node))?;
                let value = view.value().map_err(|_| UnsupportedSyntax::at(&node))?;
                Self::For {
                    view,
                    pattern,
                    value,
                }
            }
        })
    }

    pub fn extract(
        &self,
        shared: &NavigationFacts<'_>,
        facts: &mut Facts,
        coverage: &mut NavigationCoverage,
    ) {
        let node = match self {
            Self::Infinite { view } => view.syntax(),
            Self::While { view, .. } => view.syntax(),
            Self::For { view, .. } => view.syntax(),
        };
        let bindings = match self {
            Self::Infinite { .. } => Ok(Vec::new()),
            Self::While { condition, .. } => Condition::new(condition.clone()).bindings(
                node,
                node.range().into(),
                shared,
                coverage,
            ),
            Self::For { pattern, value, .. } => {
                if value.dfs().any(|node| node.is_error() || node.is_missing()) {
                    Err(UnsupportedSyntax::at(value))
                } else {
                    PatternNavigation::new(pattern.clone(), node.clone(), shared.grammar)
                        .bindings()
                        .map(|names| {
                            vec![(
                                BindingSite {
                                    declaration: pattern.range().into(),
                                    scope: node.range().into(),
                                    excluded: shared.exclusions(node, coverage),
                                    visible_from: value.range().end,
                                    namespace: BindingNamespace::Value,
                                    kind: SymbolKind::Variable,
                                },
                                names,
                            )]
                        })
                }
            }
        };
        match bindings {
            Ok(bindings) => {
                for (site, names) in bindings {
                    names.emit(site, facts);
                }
                coverage.model(node.range().into());
            }
            Err(_) => coverage.block(node.range().into()),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::rust::Rust;
    use vvv_core::{BindingNamespace, Language, Span, SymbolKind};

    #[test]
    fn for_binding_starts_after_iterator_and_stays_in_its_loop() {
        let source = "fn f(value: usize) { for value in values(value) { value; fn nested() { value; } } value; }";
        let facts = Rust::default().facts(source).unwrap();
        let binding = facts
            .lexical
            .iter()
            .find(|binding| binding.symbol.kind == SymbolKind::Variable)
            .unwrap();
        for (needle, expected) in [("value)", false), ("value; fn", true), ("value; }", false)] {
            let start = if expected {
                source.find(needle)
            } else {
                source.rfind(needle)
            }
            .unwrap();
            assert_eq!(
                binding.visible(
                    "value",
                    Span::new(start, start + 5),
                    BindingNamespace::Value
                ),
                expected
            );
        }
        let nested = source.find("fn nested").unwrap();
        assert!(binding.excluded.iter().any(|span| span.start == nested));
    }

    #[test]
    fn while_chain_preserves_order_and_unsupported_patterns_publish_nothing() {
        let source =
            "fn f() { while let Some(value) = input && let Some(value) = next(value) { value; } }";
        let facts = Rust::default().facts(source).unwrap();
        let bindings: Vec<_> = facts
            .lexical
            .iter()
            .filter(|binding| binding.symbol.name == "value")
            .collect();
        assert_eq!(bindings.len(), 2);
        let initializer = source.find("next(value)").unwrap() + 5;
        assert!(bindings[0].visible(
            "value",
            Span::new(initializer, initializer + 5),
            BindingNamespace::Value
        ));
        assert!(!bindings[1].visible(
            "value",
            Span::new(initializer, initializer + 5),
            BindingNamespace::Value
        ));
        let source = "fn f(value: usize) { for (prefix, Point { field: pattern!() }) in input { value; } value; }";
        let facts = Rust::default().facts(source).unwrap();
        assert!(
            !facts
                .lexical
                .iter()
                .any(|binding| binding.symbol.name == "prefix")
        );
        let inside = source.find("value;").unwrap();
        let after = source.rfind("value;").unwrap();
        assert!(
            !facts
                .lexical_tokens
                .contains(&Span::new(inside, inside + 5))
        );
        assert!(facts.lexical_tokens.contains(&Span::new(after, after + 5)));
    }

    #[test]
    fn rust_loop_visibility_matches_the_fact_contract() {
        let value = 10;
        let mut sum = 0;
        for value in [1, 2] {
            sum += value;
        }
        let mut input = Some(3);
        while let Some(value) = input.take() {
            sum += value;
        }
        assert_eq!(sum, 6);
        assert_eq!(value, 10);
    }
}

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

    #[test]
    fn loop_forms_retain_their_distinct_headers_and_bodies() {
        let tree = Rust.ast_grep(
            "fn f() { loop { break; } while ready { work(); } for (x, y) in input { x; } }",
        );
        let root = tree.root();
        let mut forms = root.dfs().filter_map(Loop::cast);
        let infinite = forms.next().unwrap();
        assert!(matches!(infinite, Loop::Infinite(_)));
        assert_eq!(infinite.body().unwrap().kind(), "block");
        let Loop::While(condition) = forms.next().unwrap() else {
            panic!("expected while");
        };
        assert_eq!(condition.condition().unwrap().text(), "ready");
        let Loop::For(iterator) = forms.next().unwrap() else {
            panic!("expected for");
        };
        assert_eq!(iterator.pattern().unwrap().text(), "(x, y)");
        assert_eq!(iterator.value().unwrap().text(), "input");
        assert_eq!(iterator.body().unwrap().kind(), "block");
        assert!(forms.next().is_none());
    }
}