//! Property tests: parsing untrusted text never panics, and an incremental //! reparse gives the same tree, outline and folding as a fresh parse. //! //! tree-sitter recovers from syntax errors heuristically, and the recovery //! may differ between an incremental and a fresh parse of the same broken //! text. Equality is therefore asserted whenever the edited text parses //! without errors, and an undo round trip must always end at the fresh //! result of the (error-free) original. //! //! Equality means the same outline, the same folding ranges and the same //! sequence of leaf node kinds, not the same S-expression: an incremental //! reparse may reuse a node where a fresh parse picks another wrapper for //! the same tokens (tree-sitter-php 0.25.1 keeps `(union_type //! (primitive_type))` for `array &$cache` after an undo, a fresh parse gives //! `(primitive_type)`). Every structural feature Lutra builds on the tree //! reads outline, folding or leaves, so wrapper nodes may differ. #![allow( clippy::unwrap_used, clippy::indexing_slicing, clippy::string_slice, reason = "tests may panic" )] use std::path::Path; use lutra_syntax::{Parser, SyntaxError, folding, outline}; use lutra_text::Edit; use proptest::prelude::*; /// PHP fragments edits insert, chosen to open and close constructs. const FRAGMENTS: &[&str] = &[ "", "{", "}", "(", ")", ";", "\n", " ", "class X {", "function f() {", "$a = [", "]", "/*", "*/", "//", "'", "\"", "", "namespace N;", "public int $p;", "enum E { case A; }", "#[A]", "=> ", "ü", "🦦", "\r\n", "<< Vec { let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures"); let mut texts: Vec = std::fs::read_dir(dir) .unwrap() .map(|entry| entry.unwrap().path()) .filter(|path| path.extension().is_some_and(|ext| ext == "php")) .map(|path| std::fs::read_to_string(path).unwrap()) .collect(); texts.sort(); texts } /// Moves `offset` down to the nearest char boundary of `text`. fn floor_boundary(text: &str, offset: usize) -> usize { let mut offset = offset.min(text.len()); while !text.is_char_boundary(offset) { offset -= 1; } offset } /// A strategy for one edit as (start seed, length seed, fragment index). fn edit_seed() -> impl Strategy { (any::(), 0usize..40, 0..FRAGMENTS.len()) } /// Turns seeds into a valid edit on `text`. fn edit_for(text: &str, (start, len, fragment): (usize, usize, usize)) -> Edit { let start = floor_boundary(text, start % (text.len() + 1)); let end = floor_boundary(text, start + len); Edit::replace(start..end.max(start), FRAGMENTS[fragment]) } /// The kinds of the named leaf nodes of `tree`, in document order, read /// from its S-expression: a leaf is a node that closes right after its kind. fn leaf_kinds(tree: &lutra_syntax::Tree) -> Vec { let sexp = tree.to_sexp().replace('(', " ( ").replace(')', " ) "); let tokens: Vec<&str> = sexp.split_whitespace().collect(); tokens .windows(3) .filter(|window| window[0] == "(" && window[2] == ")") .map(|window| window[1].to_owned()) .collect() } proptest! { #![proptest_config(ProptestConfig::with_cases(256))] #[test] fn random_bytes_never_panic(bytes in proptest::collection::vec(any::(), 0..2048)) { let text = String::from_utf8_lossy(&bytes); let mut parser = Parser::new().unwrap(); let tree = parser.parse(&text); let _ = outline(&tree); let _ = folding(&tree); } #[test] fn random_php_tokens_never_panic(parts in proptest::collection::vec(0..FRAGMENTS.len(), 0..200)) { let text: String = parts.into_iter().map(|index| FRAGMENTS[index]).collect(); let mut parser = Parser::new().unwrap(); let tree = parser.parse(&text); let _ = outline(&tree); let _ = folding(&tree); } #[test] fn reparse_equals_fresh_parse( fixture in any::(), steps in proptest::collection::vec(proptest::collection::vec(edit_seed(), 1..4), 1..6), ) { let texts = fixtures(); let mut text = fixture.get(&texts).clone(); let mut parser = Parser::new().unwrap(); let mut tree = parser.parse(&text); for step in steps { let mut edits: Vec = Vec::new(); for seed in step { let edit = edit_for(&text, seed); if edits.iter().all(|other| other.range.end <= edit.range.start || edit.range.end <= other.range.start) { edits.push(edit); } } tree = parser.reparse(&tree, &edits).unwrap(); let mut buffer = lutra_text::Buffer::new(&text); buffer.apply(&edits).unwrap(); text = buffer.text(); let fresh = parser.parse(&text); prop_assert_eq!(tree.text().text(), text.clone()); let _ = outline(&tree); let _ = folding(&tree); if !fresh.has_errors() { prop_assert_eq!(leaf_kinds(&tree), leaf_kinds(&fresh)); prop_assert_eq!(outline(&tree), outline(&fresh)); prop_assert_eq!(folding(&tree), folding(&fresh)); } } } #[test] fn undo_round_trip_restores_the_tree( fixture in any::(), seeds in proptest::collection::vec(edit_seed(), 1..12), ) { let texts = fixtures(); let original = fixture.get(&texts).clone(); let mut parser = Parser::new().unwrap(); let expected = parser.parse(&original); let mut tree = expected.clone(); let mut text = original.clone(); let mut undo = Vec::new(); for seed in seeds { let edit = edit_for(&text, seed); let removed = text[edit.range.clone()].to_owned(); let start = edit.range.start; undo.push(Edit::replace(start..start + edit.text.len(), removed)); tree = parser.reparse(&tree, std::slice::from_ref(&edit)).unwrap(); text.replace_range(edit.range.clone(), &edit.text); } for edit in undo.into_iter().rev() { tree = parser.reparse(&tree, std::slice::from_ref(&edit)).unwrap(); } prop_assert_eq!(tree.text().text(), original); if !expected.has_errors() { prop_assert_eq!(leaf_kinds(&tree), leaf_kinds(&expected)); prop_assert_eq!(outline(&tree), outline(&expected)); prop_assert_eq!(folding(&tree), folding(&expected)); } } #[test] fn invalid_edits_are_errors(start in 0usize..200, end in 0usize..200) { let text = " prop_assert!(valid), Err(SyntaxError::Edit(_)) => prop_assert!(!valid), Err(other) => prop_assert!(false, "unexpected error {other}"), } } } /// Deeply nested brackets must not exhaust the stack in the outline or /// folding walk. #[test] fn deep_nesting_does_not_overflow() { let depth = 100_000; let text = format!("