1 //! Defines `Fixture` -- a convenient way to describe the initial state of
2 //! rust-analyzer database from a single string.
4 //! Fixtures are strings containing rust source code with optional metadata.
5 //! A fixture without metadata is parsed into a single source file.
6 //! Use this to test functionality local to one file.
12 //! println!("Hello World")
17 //! Metadata can be added to a fixture after a `//-` comment.
18 //! The basic form is specifying filenames,
19 //! which is also how to define multiple files in a single test fixture
21 //! Example using two files in the same crate:
35 //! Example using two crates with one file each, with one crate depending on the other:
38 //! //- /main.rs crate:a deps:b
42 //! //- /lib.rs crate:b
44 //! println!("Hello World")
49 //! Metadata allows specifying all settings and variables
50 //! that are available in a real rust project:
51 //! - crate names via `crate:cratename`
52 //! - dependencies via `deps:dep1,dep2`
53 //! - configuration settings via `cfg:dbg=false,opt_level=2`
54 //! - environment variables via `env:PATH=/bin,RUST_LOG=debug`
56 //! Example using all available metadata:
59 //! //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
60 //! fn insert_source_code_here() {}
64 use rustc_hash::FxHashMap;
65 use stdx::trim_indent;
67 #[derive(Debug, Eq, PartialEq)]
71 pub krate: Option<String>,
72 pub deps: Vec<String>,
73 pub cfg_atoms: Vec<String>,
74 pub cfg_key_values: Vec<(String, String)>,
75 pub edition: Option<String>,
76 pub env: FxHashMap<String, String>,
77 pub introduce_new_source_root: bool,
81 activated_flags: Vec<String>,
82 valid_flags: Vec<String>,
86 /// Parses text which looks like this:
95 /// Fixture can also start with a minicore declaration:
98 /// //- minicore: sized
101 /// That will include a subset of `libcore` into the fixture, see
102 /// `minicore.rs` for what's available.
103 pub fn parse(ra_fixture: &str) -> (Option<MiniCore>, Vec<Fixture>) {
104 let fixture = trim_indent(ra_fixture);
105 let mut fixture = fixture.as_str();
106 let mut mini_core = None;
107 let mut res: Vec<Fixture> = Vec::new();
109 if fixture.starts_with("//- minicore:") {
110 let first_line = fixture.split_inclusive('\n').next().unwrap();
111 mini_core = Some(MiniCore::parse(first_line));
112 fixture = &fixture[first_line.len()..];
115 let default = if fixture.contains("//-") { None } else { Some("//- /main.rs") };
117 for (ix, line) in default.into_iter().chain(fixture.split_inclusive('\n')).enumerate() {
118 if line.contains("//-") {
120 line.starts_with("//-"),
121 "Metadata line {} has invalid indentation. \
122 All metadata lines need to have the same indentation.\n\
123 The offending line: {:?}",
129 if line.starts_with("//-") {
130 let meta = Fixture::parse_meta_line(line);
132 } else if let Some(entry) = res.last_mut() {
133 entry.text.push_str(line);
140 //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
141 fn parse_meta_line(meta: &str) -> Fixture {
142 assert!(meta.starts_with("//-"));
143 let meta = meta["//-".len()..].trim();
144 let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
146 let path = components[0].to_string();
147 assert!(path.starts_with('/'));
149 let mut krate = None;
150 let mut deps = Vec::new();
151 let mut edition = None;
152 let mut cfg_atoms = Vec::new();
153 let mut cfg_key_values = Vec::new();
154 let mut env = FxHashMap::default();
155 let mut introduce_new_source_root = false;
156 for component in components[1..].iter() {
157 let (key, value) = component.split_once(':').unwrap();
159 "crate" => krate = Some(value.to_string()),
160 "deps" => deps = value.split(',').map(|it| it.to_string()).collect(),
161 "edition" => edition = Some(value.to_string()),
163 for entry in value.split(',') {
164 match entry.split_once('=') {
165 Some((k, v)) => cfg_key_values.push((k.to_string(), v.to_string())),
166 None => cfg_atoms.push(entry.to_string()),
171 for key in value.split(',') {
172 if let Some((k, v)) = key.split_once('=') {
173 env.insert(k.into(), v.into());
177 "new_source_root" => introduce_new_source_root = true,
178 _ => panic!("bad component: {:?}", component),
191 introduce_new_source_root,
197 fn has_flag(&self, flag: &str) -> bool {
198 self.activated_flags.iter().any(|it| it == flag)
201 fn assert_valid_flag(&self, flag: &str) {
202 if !self.valid_flags.iter().any(|it| it == flag) {
203 panic!("invalid flag: {:?}, valid flags: {:?}", flag, self.valid_flags);
207 fn parse(line: &str) -> MiniCore {
208 let mut res = MiniCore { activated_flags: Vec::new(), valid_flags: Vec::new() };
210 let line = line.strip_prefix("//- minicore:").unwrap().trim();
211 for entry in line.split(", ") {
212 if res.has_flag(entry) {
213 panic!("duplicate minicore flag: {:?}", entry)
215 res.activated_flags.push(entry.to_string())
221 /// Strips parts of minicore.rs which are flagged by inactive flags.
223 /// This is probably over-engineered to support flags dependencies.
224 pub fn source_code(mut self) -> String {
225 let mut buf = String::new();
226 let raw_mini_core = include_str!("./minicore.rs");
227 let mut lines = raw_mini_core.split_inclusive('\n');
229 let mut parsing_flags = false;
230 let mut implications = Vec::new();
232 // Parse `//!` preamble and extract flags and dependencies.
233 for line in lines.by_ref() {
234 let line = match line.strip_prefix("//!") {
237 assert!(line.trim().is_empty());
243 let (flag, deps) = line.split_once(':').unwrap();
244 let flag = flag.trim();
245 self.valid_flags.push(flag.to_string());
246 for dep in deps.split(", ") {
247 let dep = dep.trim();
249 self.assert_valid_flag(dep);
250 implications.push((flag, dep));
255 if line.contains("Available flags:") {
256 parsing_flags = true;
260 for flag in &self.activated_flags {
261 self.assert_valid_flag(flag);
264 // Fixed point loop to compute transitive closure of flags.
266 let mut changed = false;
267 for &(u, v) in implications.iter() {
268 if self.has_flag(u) && !self.has_flag(v) {
269 self.activated_flags.push(v.to_string());
278 let mut curr_region = "";
279 let mut seen_regions = Vec::new();
281 let trimmed = line.trim();
282 if let Some(region) = trimmed.strip_prefix("// region:") {
283 assert_eq!(curr_region, "");
284 curr_region = region;
287 if let Some(region) = trimmed.strip_prefix("// endregion:") {
288 assert_eq!(curr_region, region);
292 seen_regions.push(curr_region);
294 let mut flag = curr_region;
295 if let Some(idx) = trimmed.find("// :") {
296 flag = &trimmed[idx + "// :".len()..];
299 let skip = if flag == "" {
302 self.assert_valid_flag(flag);
311 for flag in &self.valid_flags {
312 if !seen_regions.iter().any(|it| it == flag) {
313 panic!("unused minicore flag: {:?}", flag);
323 fn parse_fixture_checks_further_indented_metadata() {
337 fn parse_fixture_gets_full_meta() {
338 let (mini_core, parsed) = Fixture::parse(
340 //- minicore: coerce_unsized
341 //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
345 assert_eq!(mini_core.unwrap().activated_flags, vec!["coerce_unsized".to_string()]);
346 assert_eq!(1, parsed.len());
348 let meta = &parsed[0];
349 assert_eq!("mod m;\n", meta.text);
351 assert_eq!("foo", meta.krate.as_ref().unwrap());
352 assert_eq!("/lib.rs", meta.path);
353 assert_eq!(2, meta.env.len());