Merge branch 'master' into assists_extract_enum

1 files changed, 150 insertions, 6 deletions

diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index be2cfbaa2..2141bfc20 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -14,6 +14,11 @@ use std::{
     path::{Path, PathBuf},
 };
 
+pub use ra_cfg::CfgOptions;
+use stdx::split1;
+
+pub use relative_path::{RelativePath, RelativePathBuf};
+pub use rustc_hash::FxHashMap;
 use serde_json::Value;
 use text_size::{TextRange, TextSize};
 
@@ -157,10 +162,82 @@ pub fn add_cursor(text: &str, offset: TextSize) -> String {
 
 #[derive(Debug, Eq, PartialEq)]
 pub struct FixtureEntry {
-    pub meta: String,
+    pub meta: FixtureMeta,
     pub text: String,
 }
 
+#[derive(Debug, Eq, PartialEq)]
+pub enum FixtureMeta {
+    Root { path: RelativePathBuf },
+    File(FileMeta),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct FileMeta {
+    pub path: RelativePathBuf,
+    pub crate_name: Option<String>,
+    pub deps: Vec<String>,
+    pub cfg: CfgOptions,
+    pub edition: Option<String>,
+    pub env: FxHashMap<String, String>,
+}
+
+impl FixtureMeta {
+    pub fn path(&self) -> &RelativePath {
+        match self {
+            FixtureMeta::Root { path } => &path,
+            FixtureMeta::File(f) => &f.path,
+        }
+    }
+
+    pub fn crate_name(&self) -> Option<&String> {
+        match self {
+            FixtureMeta::File(f) => f.crate_name.as_ref(),
+            _ => None,
+        }
+    }
+
+    pub fn cfg_options(&self) -> Option<&CfgOptions> {
+        match self {
+            FixtureMeta::File(f) => Some(&f.cfg),
+            _ => None,
+        }
+    }
+
+    pub fn edition(&self) -> Option<&String> {
+        match self {
+            FixtureMeta::File(f) => f.edition.as_ref(),
+            _ => None,
+        }
+    }
+
+    pub fn env(&self) -> impl Iterator<Item = (&String, &String)> {
+        struct EnvIter<'a> {
+            iter: Option<std::collections::hash_map::Iter<'a, String, String>>,
+        }
+
+        impl<'a> EnvIter<'a> {
+            fn new(meta: &'a FixtureMeta) -> Self {
+                Self {
+                    iter: match meta {
+                        FixtureMeta::File(f) => Some(f.env.iter()),
+                        _ => None,
+                    },
+                }
+            }
+        }
+
+        impl<'a> Iterator for EnvIter<'a> {
+            type Item = (&'a String, &'a String);
+            fn next(&mut self) -> Option<Self::Item> {
+                self.iter.as_mut().and_then(|i| i.next())
+            }
+        }
+
+        EnvIter::new(self)
+    }
+}
+
 /// Parses text which looks like this:
 ///
 ///  ```not_rust
@@ -169,8 +246,8 @@ pub struct FixtureEntry {
 ///  line 2
 ///  // - other meta
 ///  ```
-pub fn parse_fixture(fixture: &str) -> Vec<FixtureEntry> {
-    let fixture = indent_first_line(fixture);
+pub fn parse_fixture(ra_fixture: &str) -> Vec<FixtureEntry> {
+    let fixture = indent_first_line(ra_fixture);
     let margin = fixture_margin(&fixture);
 
     let mut lines = fixture
@@ -200,6 +277,7 @@ The offending line: {:?}"#,
     for line in lines.by_ref() {
         if line.starts_with("//-") {
             let meta = line["//-".len()..].trim().to_string();
+            let meta = parse_meta(&meta);
             res.push(FixtureEntry { meta, text: String::new() })
         } else if let Some(entry) = res.last_mut() {
             entry.text.push_str(line);
@@ -209,6 +287,52 @@ The offending line: {:?}"#,
     res
 }
 
+//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
+fn parse_meta(meta: &str) -> FixtureMeta {
+    let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
+
+    if components[0] == "root" {
+        let path: RelativePathBuf = components[1].into();
+        assert!(path.starts_with("/") && path.ends_with("/"));
+        return FixtureMeta::Root { path };
+    }
+
+    let path: RelativePathBuf = components[0].into();
+    assert!(path.starts_with("/"));
+
+    let mut krate = None;
+    let mut deps = Vec::new();
+    let mut edition = None;
+    let mut cfg = CfgOptions::default();
+    let mut env = FxHashMap::default();
+    for component in components[1..].iter() {
+        let (key, value) = split1(component, ':').unwrap();
+        match key {
+            "crate" => krate = Some(value.to_string()),
+            "deps" => deps = value.split(',').map(|it| it.to_string()).collect(),
+            "edition" => edition = Some(value.to_string()),
+            "cfg" => {
+                for key in value.split(',') {
+                    match split1(key, '=') {
+                        None => cfg.insert_atom(key.into()),
+                        Some((k, v)) => cfg.insert_key_value(k.into(), v.into()),
+                    }
+                }
+            }
+            "env" => {
+                for key in value.split(',') {
+                    if let Some((k, v)) = split1(key, '=') {
+                        env.insert(k.into(), v.into());
+                    }
+                }
+            }
+            _ => panic!("bad component: {:?}", component),
+        }
+    }
+
+    FixtureMeta::File(FileMeta { path, crate_name: krate, deps, edition, cfg, env })
+}
+
 /// Adjusts the indentation of the first line to the minimum indentation of the rest of the lines.
 /// This allows fixtures to start off in a different indentation, e.g. to align the first line with
 /// the other lines visually:
@@ -288,13 +412,33 @@ struct Bar;
     )
 }
 
+#[test]
+fn parse_fixture_gets_full_meta() {
+    let parsed = parse_fixture(
+        r"
+    //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
+    mod m;
+    ",
+    );
+    assert_eq!(1, parsed.len());
+
+    let parsed = &parsed[0];
+    assert_eq!("mod m;\n\n", parsed.text);
+
+    let meta = &parsed.meta;
+    assert_eq!("foo", meta.crate_name().unwrap());
+    assert_eq!("/lib.rs", meta.path());
+    assert!(meta.cfg_options().is_some());
+    assert_eq!(2, meta.env().count());
+}
+
 /// Same as `parse_fixture`, except it allow empty fixture
-pub fn parse_single_fixture(fixture: &str) -> Option<FixtureEntry> {
-    if !fixture.lines().any(|it| it.trim_start().starts_with("//-")) {
+pub fn parse_single_fixture(ra_fixture: &str) -> Option<FixtureEntry> {
+    if !ra_fixture.lines().any(|it| it.trim_start().starts_with("//-")) {
         return None;
     }
 
-    let fixtures = parse_fixture(fixture);
+    let fixtures = parse_fixture(ra_fixture);
     if fixtures.len() > 1 {
         panic!("too many fixtures");
     }