test: add analysis-level proptest regression coverage

Author: hongjr03

crates/ide/src/analysis.rs

@@ -218,3 +218,161 @@ impl Analysis {
         self.with_db(|db| code_action::code_action(db, file_id, range, resolve_strategy))
     }
 }
+
+#[cfg(test)]
+mod robustness_tests {
+    use base_db::{change::Change, source_root::SourceRoot};
+    use proptest::prelude::*;
+    use triomphe::Arc;
+    use utils::{line_index::TextSize, lines::LineEnding};
+    use vfs::{ChangeKind, ChangedFile, FileId, FileSet, VfsPath};
+
+    use super::*;
+    use crate::{
+        analysis_host::AnalysisHost,
+        completion::context::TriggerChar,
+        folding_ranges::FoldingConfig,
+    };
+
+    const FILE_ID: FileId = FileId(0);
+
+    fn ascii_source_strategy() -> impl Strategy<Value = String> {
+        let char_strategy = prop_oneof![
+            Just(' '),
+            Just('\n'),
+            Just('\t'),
+            Just('('),
+            Just(')'),
+            Just('{'),
+            Just('}'),
+            Just(';'),
+            Just(':'),
+            Just(','),
+            Just('.'),
+            Just('#'),
+            Just('`'),
+            Just('_'),
+            (b'a'..=b'z').prop_map(|byte| byte as char),
+            (b'A'..=b'Z').prop_map(|byte| byte as char),
+            (b'0'..=b'9').prop_map(|byte| byte as char),
+        ];
+
+        prop::collection::vec(char_strategy, 0..256).prop_map(|chars| chars.into_iter().collect())
+    }
+
+    fn edit_sequence_strategy() -> impl Strategy<Value = Vec<(u16, u8, char)>> {
+        let char_strategy = prop_oneof![
+            Just(' '),
+            Just('\n'),
+            Just('\t'),
+            Just('('),
+            Just(')'),
+            Just('{'),
+            Just('}'),
+            Just(';'),
+            Just(':'),
+            Just(','),
+            Just('.'),
+            Just('#'),
+            Just('`'),
+            Just('_'),
+            (b'a'..=b'z').prop_map(|byte| byte as char),
+            (b'A'..=b'Z').prop_map(|byte| byte as char),
+            (b'0'..=b'9').prop_map(|byte| byte as char),
+        ];
+
+        prop::collection::vec((any::<u16>(), 0u8..3, char_strategy), 0..48)
+    }
+
+    fn trigger_strategy() -> impl Strategy<Value = Option<TriggerChar>> {
+        prop_oneof![
+            Just(None),
+            Just(Some(TriggerChar::Dot)),
+            Just(Some(TriggerChar::OpenParen)),
+            Just(Some(TriggerChar::Comma)),
+            Just(Some(TriggerChar::At)),
+            Just(Some(TriggerChar::Hash)),
+            Just(Some(TriggerChar::Backtick)),
+        ]
+    }
+
+    fn apply_edit(text: &mut String, position_seed: u16, kind: u8, ch: char) {
+        match kind {
+            0 => {
+                let idx = usize::from(position_seed) % (text.len() + 1);
+                text.insert(idx, ch);
+            }
+            1 => {
+                if !text.is_empty() {
+                    let idx = usize::from(position_seed) % text.len();
+                    text.remove(idx);
+                }
+            }
+            2 => {
+                if text.is_empty() {
+                    text.push(ch);
+                } else {
+                    let idx = usize::from(position_seed) % text.len();
+                    text.remove(idx);
+                    text.insert(idx, ch);
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn setup_host(text: &str) -> AnalysisHost {
+        let path = VfsPath::new_virtual_path("/robustness.sv".to_string());
+        let mut file_set = FileSet::default();
+        file_set.insert(FILE_ID, path);
+
+        let root = SourceRoot::new_local(file_set);
+        let mut change = Change::new();
+        change.set_roots(vec![root]);
+        change.add_changed_file(ChangedFile {
+            file_id: FILE_ID,
+            change_kind: ChangeKind::Create(Arc::from(text), LineEnding::Unix),
+        });
+
+        let mut host = AnalysisHost::default();
+        host.apply_change(change);
+        host
+    }
+
+    fn update_host(host: &mut AnalysisHost, text: &str) {
+        let mut change = Change::new();
+        change.add_changed_file(ChangedFile {
+            file_id: FILE_ID,
+            change_kind: ChangeKind::Modify(Arc::from(text), LineEnding::Unix),
+        });
+        host.apply_change(change);
+    }
+
+    proptest! {
+        #[test]
+        fn analysis_requests_survive_random_ascii_edits(
+            initial_text in ascii_source_strategy(),
+            edits in edit_sequence_strategy(),
+            trigger in trigger_strategy(),
+        ) {
+            let mut text = initial_text;
+            let mut host = setup_host(&text);
+
+            for (position_seed, kind, ch) in edits {
+                apply_edit(&mut text, position_seed, kind, ch);
+                update_host(&mut host, &text);
+
+                let analysis = host.make_analysis();
+                let _ = analysis.parse_diagnostics(FILE_ID)?;
+                let _ = analysis.document_symbol(FILE_ID)?;
+                let _ = analysis.folding_ranges(FILE_ID, &FoldingConfig { line_fold_only: false })?;
+
+                for offset in [0, text.len() / 2, text.len()] {
+                    let position = FilePosition { file_id: FILE_ID, offset: TextSize::from(offset as u32) };
+                    let _ = analysis.completion_context_with_trigger(position, trigger)?;
+                    let _ = analysis.completions_with_trigger(position, trigger)?;
+                }
+            }
+        }
+    }
+}