1 files changed, 54 insertions, 136 deletions

diff --git a/crates/ra_ide/src/mock_analysis.rs b/crates/ra_ide/src/mock_analysis.rs
index ad78d2d93..889b84c59 100644
--- a/crates/ra_ide/src/mock_analysis.rs
+++ b/crates/ra_ide/src/mock_analysis.rs
@@ -1,87 +1,22 @@
 //! FIXME: write short doc here
-
-use std::str::FromStr;
 use std::sync::Arc;
 
 use ra_cfg::CfgOptions;
-use ra_db::{CrateName, Env, RelativePathBuf};
-use test_utils::{extract_offset, extract_range, parse_fixture, FixtureEntry, CURSOR_MARKER};
+use ra_db::{CrateName, Env, FileSet, SourceRoot, VfsPath};
+use test_utils::{extract_range_or_offset, Fixture, RangeOrOffset, CURSOR_MARKER};
 
 use crate::{
     Analysis, AnalysisChange, AnalysisHost, CrateGraph, Edition, FileId, FilePosition, FileRange,
-    SourceRootId,
 };
 
-#[derive(Debug)]
-enum MockFileData {
-    Plain { path: String, content: String },
-    Fixture(FixtureEntry),
-}
-
-impl MockFileData {
-    fn new(path: String, content: String) -> Self {
-        // `Self::Plain` causes a false warning: 'variant is never constructed: `Plain` '
-        // see https://github.com/rust-lang/rust/issues/69018
-        MockFileData::Plain { path, content }
-    }
-
-    fn path(&self) -> &str {
-        match self {
-            MockFileData::Plain { path, .. } => path.as_str(),
-            MockFileData::Fixture(f) => f.meta.path().as_str(),
-        }
-    }
-
-    fn content(&self) -> &str {
-        match self {
-            MockFileData::Plain { content, .. } => content,
-            MockFileData::Fixture(f) => f.text.as_str(),
-        }
-    }
-
-    fn cfg_options(&self) -> CfgOptions {
-        match self {
-            MockFileData::Fixture(f) => {
-                f.meta.cfg_options().map_or_else(Default::default, |o| o.clone())
-            }
-            _ => CfgOptions::default(),
-        }
-    }
-
-    fn edition(&self) -> Edition {
-        match self {
-            MockFileData::Fixture(f) => {
-                f.meta.edition().map_or(Edition::Edition2018, |v| Edition::from_str(v).unwrap())
-            }
-            _ => Edition::Edition2018,
-        }
-    }
-
-    fn env(&self) -> Env {
-        match self {
-            MockFileData::Fixture(f) => Env::from(f.meta.env()),
-            _ => Env::default(),
-        }
-    }
-}
-
-impl From<FixtureEntry> for MockFileData {
-    fn from(fixture: FixtureEntry) -> Self {
-        Self::Fixture(fixture)
-    }
-}
-
 /// 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<MockFileData>,
+    files: Vec<Fixture>,
 }
 
 impl MockAnalysis {
-    pub fn new() -> MockAnalysis {
-        MockAnalysis::default()
-    }
     /// Creates `MockAnalysis` using a fixture data in the following format:
     ///
     /// ```not_rust
@@ -92,106 +27,93 @@ impl MockAnalysis {
     /// //- /foo.rs
     /// struct Baz;
     /// ```
-    pub fn with_files(fixture: &str) -> MockAnalysis {
-        let mut res = MockAnalysis::new();
-        for entry in parse_fixture(fixture) {
-            res.add_file_fixture(entry);
-        }
+    pub fn with_files(ra_fixture: &str) -> MockAnalysis {
+        let (res, pos) = MockAnalysis::with_fixture(ra_fixture);
+        assert!(pos.is_none());
         res
     }
 
     /// Same as `with_files`, but requires that a single file contains a `<|>` marker,
     /// whose position is also returned.
     pub fn with_files_and_position(fixture: &str) -> (MockAnalysis, FilePosition) {
+        let (res, position) = MockAnalysis::with_fixture(fixture);
+        let (file_id, range_or_offset) = position.expect("expected a marker (<|>)");
+        let offset = match range_or_offset {
+            RangeOrOffset::Range(_) => panic!(),
+            RangeOrOffset::Offset(it) => it,
+        };
+        (res, FilePosition { file_id, offset })
+    }
+
+    fn with_fixture(fixture: &str) -> (MockAnalysis, Option<(FileId, RangeOrOffset)>) {
         let mut position = None;
-        let mut res = MockAnalysis::new();
-        for entry in parse_fixture(fixture) {
+        let mut res = MockAnalysis::default();
+        for mut entry in Fixture::parse(fixture) {
             if entry.text.contains(CURSOR_MARKER) {
                 assert!(position.is_none(), "only one marker (<|>) per fixture is allowed");
-                position = Some(res.add_file_fixture_with_position(entry));
+                let (range_or_offset, text) = extract_range_or_offset(&entry.text);
+                entry.text = text;
+                let file_id = res.add_file_fixture(entry);
+                position = Some((file_id, range_or_offset));
             } else {
                 res.add_file_fixture(entry);
             }
         }
-        let position = position.expect("expected a marker (<|>)");
         (res, position)
     }
 
-    pub fn add_file_fixture(&mut self, fixture: FixtureEntry) -> FileId {
-        let file_id = self.next_id();
-        self.files.push(MockFileData::from(fixture));
+    fn add_file_fixture(&mut self, fixture: Fixture) -> FileId {
+        let file_id = FileId((self.files.len() + 1) as u32);
+        self.files.push(fixture);
         file_id
     }
 
-    pub fn add_file_fixture_with_position(&mut self, mut fixture: FixtureEntry) -> FilePosition {
-        let (offset, text) = extract_offset(&fixture.text);
-        fixture.text = text;
-        let file_id = self.next_id();
-        self.files.push(MockFileData::from(fixture));
-        FilePosition { file_id, offset }
-    }
-
-    pub fn add_file(&mut self, path: &str, text: &str) -> FileId {
-        let file_id = self.next_id();
-        self.files.push(MockFileData::new(path.to_string(), text.to_string()));
-        file_id
-    }
-    pub fn add_file_with_position(&mut self, path: &str, text: &str) -> FilePosition {
-        let (offset, text) = extract_offset(text);
-        let file_id = self.next_id();
-        self.files.push(MockFileData::new(path.to_string(), text));
-        FilePosition { file_id, offset }
-    }
-    pub fn add_file_with_range(&mut self, path: &str, text: &str) -> FileRange {
-        let (range, text) = extract_range(text);
-        let file_id = self.next_id();
-        self.files.push(MockFileData::new(path.to_string(), text));
-        FileRange { file_id, range }
-    }
     pub fn id_of(&self, path: &str) -> FileId {
         let (idx, _) = self
             .files
             .iter()
             .enumerate()
-            .find(|(_, data)| path == data.path())
+            .find(|(_, data)| path == data.path)
             .expect("no file in this mock");
         FileId(idx as u32 + 1)
     }
     pub fn analysis_host(self) -> AnalysisHost {
         let mut host = AnalysisHost::default();
-        let source_root = SourceRootId(0);
         let mut change = AnalysisChange::new();
-        change.add_root(source_root, true);
+        let mut file_set = FileSet::default();
         let mut crate_graph = CrateGraph::default();
         let mut root_crate = None;
         for (i, data) in self.files.into_iter().enumerate() {
-            let path = data.path();
+            let path = data.path;
             assert!(path.starts_with('/'));
-            let path = RelativePathBuf::from_path(&path[1..]).unwrap();
-            let cfg_options = data.cfg_options();
+
+            let mut cfg = CfgOptions::default();
+            data.cfg_atoms.iter().for_each(|it| cfg.insert_atom(it.into()));
+            data.cfg_key_values.iter().for_each(|(k, v)| cfg.insert_key_value(k.into(), v.into()));
+            let edition: Edition =
+                data.edition.and_then(|it| it.parse().ok()).unwrap_or(Edition::Edition2018);
+
             let file_id = FileId(i as u32 + 1);
-            let edition = data.edition();
-            let env = data.env();
+            let env = Env::from(data.env.iter());
             if path == "/lib.rs" || path == "/main.rs" {
                 root_crate = Some(crate_graph.add_crate_root(
                     file_id,
                     edition,
                     None,
-                    cfg_options,
+                    cfg,
                     env,
                     Default::default(),
-                    Default::default(),
                 ));
             } else if path.ends_with("/lib.rs") {
-                let crate_name = path.parent().unwrap().file_name().unwrap();
+                let base = &path[..path.len() - "/lib.rs".len()];
+                let crate_name = &base[base.rfind('/').unwrap() + '/'.len_utf8()..];
                 let other_crate = crate_graph.add_crate_root(
                     file_id,
                     edition,
                     Some(CrateName::new(crate_name).unwrap()),
-                    cfg_options,
+                    cfg,
                     env,
                     Default::default(),
-                    Default::default(),
                 );
                 if let Some(root_crate) = root_crate {
                     crate_graph
@@ -199,19 +121,18 @@ impl MockAnalysis {
                         .unwrap();
                 }
             }
-            change.add_file(source_root, file_id, path, Arc::new(data.content().to_owned()));
+            let path = VfsPath::new_virtual_path(path.to_string());
+            file_set.insert(file_id, path);
+            change.change_file(file_id, Some(Arc::new(data.text).to_owned()));
         }
         change.set_crate_graph(crate_graph);
+        change.set_roots(vec![SourceRoot::new_local(file_set)]);
         host.apply_change(change);
         host
     }
     pub fn analysis(self) -> Analysis {
         self.analysis_host().analysis()
     }
-
-    fn next_id(&self) -> FileId {
-        FileId((self.files.len() + 1) as u32)
-    }
 }
 
 /// Creates analysis from a multi-file fixture, returns positions marked with <|>.
@@ -222,21 +143,18 @@ pub fn analysis_and_position(ra_fixture: &str) -> (Analysis, FilePosition) {
 
 /// Creates analysis for a single file.
 pub fn single_file(ra_fixture: &str) -> (Analysis, FileId) {
-    let mut mock = MockAnalysis::new();
-    let file_id = mock.add_file("/main.rs", ra_fixture);
+    let mock = MockAnalysis::with_files(ra_fixture);
+    let file_id = mock.id_of("/main.rs");
     (mock.analysis(), file_id)
 }
 
-/// Creates analysis for a single file, returns position marked with <|>.
-pub fn single_file_with_position(ra_fixture: &str) -> (Analysis, FilePosition) {
-    let mut mock = MockAnalysis::new();
-    let pos = mock.add_file_with_position("/main.rs", ra_fixture);
-    (mock.analysis(), pos)
-}
-
 /// Creates analysis for a single file, returns range marked with a pair of <|>.
-pub fn single_file_with_range(ra_fixture: &str) -> (Analysis, FileRange) {
-    let mut mock = MockAnalysis::new();
-    let pos = mock.add_file_with_range("/main.rs", ra_fixture);
-    (mock.analysis(), pos)
+pub fn analysis_and_range(ra_fixture: &str) -> (Analysis, FileRange) {
+    let (res, position) = MockAnalysis::with_fixture(ra_fixture);
+    let (file_id, range_or_offset) = position.expect("expected a marker (<|>)");
+    let range = match range_or_offset {
+        RangeOrOffset::Range(it) => it,
+        RangeOrOffset::Offset(_) => panic!(),
+    };
+    (res.analysis(), FileRange { file_id, range })
 }