From f3fb59d7077801a3a68d2d03eef17d59c2925ae8 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 31 Oct 2018 20:59:17 +0300
Subject: Move completion to ra_analysis

While we should handle completion for isolated file, it's better
achieved by using empty Analysis, rather than working only with &File:
we need memoization for type inference even inside a single file.
---
 crates/ra_analysis/src/mock_analysis.rs | 71 +++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 crates/ra_analysis/src/mock_analysis.rs

(limited to 'crates/ra_analysis/src/mock_analysis.rs')

diff --git a/crates/ra_analysis/src/mock_analysis.rs b/crates/ra_analysis/src/mock_analysis.rs
new file mode 100644
index 000000000..1c1dbee7c
--- /dev/null
+++ b/crates/ra_analysis/src/mock_analysis.rs
@@ -0,0 +1,71 @@
+
+use std::sync::Arc;
+
+use relative_path::{RelativePath, RelativePathBuf};
+
+use crate::{
+    AnalysisChange, Analysis, AnalysisHost, FileId, FileResolver,
+};
+
+/// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
+/// from a set of in-memory files.
+#[derive(Debug, Default)]
+pub struct MockAnalysis {
+    files: Vec<(String, String)>,
+}
+
+impl MockAnalysis {
+    pub fn new() -> MockAnalysis {
+        MockAnalysis::default()
+    }
+    pub fn with_files(files: &[(&str, &str)]) -> MockAnalysis {
+        let files = files.iter()
+            .map(|it| (it.0.to_string(), it.1.to_string()))
+            .collect();
+        MockAnalysis { files }
+    }
+    pub fn analysis_host(self) -> AnalysisHost {
+        let mut host = AnalysisHost::new();
+        let mut file_map = Vec::new();
+        let mut change = AnalysisChange::new();
+        for (id, (path, contents)) in self.files.into_iter().enumerate() {
+            let file_id = FileId((id + 1) as u32);
+            assert!(path.starts_with('/'));
+            let path = RelativePathBuf::from_path(&path[1..]).unwrap();
+            change.add_file(file_id, contents);
+            file_map.push((file_id, path));
+        }
+        change.set_file_resolver(Arc::new(FileMap(file_map)));
+        host.apply_change(change);
+        host
+    }
+    pub fn analysis(self) -> Analysis {
+        self.analysis_host().analysis()
+    }
+}
+
+#[derive(Debug)]
+struct FileMap(Vec<(FileId, RelativePathBuf)>);
+
+impl FileMap {
+    fn iter<'a>(&'a self) -> impl Iterator<Item = (FileId, &'a RelativePath)> + 'a {
+        self.0
+            .iter()
+            .map(|(id, path)| (*id, path.as_relative_path()))
+    }
+
+    fn path(&self, id: FileId) -> &RelativePath {
+        self.iter().find(|&(it, _)| it == id).unwrap().1
+    }
+}
+
+impl FileResolver for FileMap {
+    fn file_stem(&self, id: FileId) -> String {
+        self.path(id).file_stem().unwrap().to_string()
+    }
+    fn resolve(&self, id: FileId, rel: &RelativePath) -> Option<FileId> {
+        let path = self.path(id).join(rel).normalize();
+        let id = self.iter().find(|&(_, p)| path == p)?.0;
+        Some(id)
+    }
+}
-- 
cgit v1.2.3