//! ```
use rustc_hash::FxHashMap;
-use stdx::{lines_with_ends, split_once, trim_indent};
+use stdx::trim_indent;
#[derive(Debug, Eq, PartialEq)]
pub struct Fixture {
pub text: String,
pub krate: Option<String>,
pub deps: Vec<String>,
+ pub extern_prelude: Option<Vec<String>>,
pub cfg_atoms: Vec<String>,
pub cfg_key_values: Vec<(String, String)>,
pub edition: Option<String>,
pub env: FxHashMap<String, String>,
- pub introduce_new_source_root: bool,
+ pub introduce_new_source_root: Option<String>,
+}
+
+pub struct MiniCore {
+ activated_flags: Vec<String>,
+ valid_flags: Vec<String>,
}
impl Fixture {
/// line 2
/// //- other meta
/// ```
- pub fn parse(ra_fixture: &str) -> Vec<Fixture> {
+ ///
+ /// Fixture can also start with a proc_macros and minicore declaration(in that order):
+ ///
+ /// ```
+ /// //- proc_macros: identity
+ /// //- minicore: sized
+ /// ```
+ ///
+ /// That will include predefined proc macros and a subset of `libcore` into the fixture, see
+ /// `minicore.rs` for what's available.
+ pub fn parse(ra_fixture: &str) -> (Option<MiniCore>, Vec<String>, Vec<Fixture>) {
let fixture = trim_indent(ra_fixture);
-
+ let mut fixture = fixture.as_str();
+ let mut mini_core = None;
let mut res: Vec<Fixture> = Vec::new();
+ let mut test_proc_macros = vec![];
+
+ if fixture.starts_with("//- proc_macros:") {
+ let first_line = fixture.split_inclusive('\n').next().unwrap();
+ test_proc_macros = first_line
+ .strip_prefix("//- proc_macros:")
+ .unwrap()
+ .split(',')
+ .map(|it| it.trim().to_string())
+ .collect();
+ fixture = &fixture[first_line.len()..];
+ }
- let default = if ra_fixture.contains("//-") { None } else { Some("//- /main.rs") };
+ if fixture.starts_with("//- minicore:") {
+ let first_line = fixture.split_inclusive('\n').next().unwrap();
+ mini_core = Some(MiniCore::parse(first_line));
+ fixture = &fixture[first_line.len()..];
+ }
- for (ix, line) in default.into_iter().chain(lines_with_ends(&fixture)).enumerate() {
+ let default = if fixture.contains("//-") { None } else { Some("//- /main.rs") };
+
+ for (ix, line) in default.into_iter().chain(fixture.split_inclusive('\n')).enumerate() {
if line.contains("//-") {
assert!(
line.starts_with("//-"),
if line.starts_with("//-") {
let meta = Fixture::parse_meta_line(line);
- res.push(meta)
- } else if let Some(entry) = res.last_mut() {
- entry.text.push_str(line);
+ res.push(meta);
+ } else {
+ if line.starts_with("// ")
+ && line.contains(':')
+ && !line.contains("::")
+ && !line.contains('.')
+ && line.chars().all(|it| !it.is_uppercase())
+ {
+ panic!("looks like invalid metadata line: {:?}", line);
+ }
+
+ if let Some(entry) = res.last_mut() {
+ entry.text.push_str(line);
+ }
}
}
- res
+ (mini_core, test_proc_macros, res)
}
//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
let path = components[0].to_string();
- assert!(path.starts_with('/'));
+ assert!(path.starts_with('/'), "fixture path does not start with `/`: {:?}", path);
let mut krate = None;
let mut deps = Vec::new();
+ let mut extern_prelude = None;
let mut edition = None;
let mut cfg_atoms = Vec::new();
let mut cfg_key_values = Vec::new();
let mut env = FxHashMap::default();
- let mut introduce_new_source_root = false;
+ let mut introduce_new_source_root = None;
for component in components[1..].iter() {
- let (key, value) = split_once(component, ':').unwrap();
+ let (key, value) = component
+ .split_once(':')
+ .unwrap_or_else(|| panic!("invalid meta line: {:?}", meta));
match key {
"crate" => krate = Some(value.to_string()),
"deps" => deps = value.split(',').map(|it| it.to_string()).collect(),
+ "extern-prelude" => {
+ if value.is_empty() {
+ extern_prelude = Some(Vec::new());
+ } else {
+ extern_prelude =
+ Some(value.split(',').map(|it| it.to_string()).collect::<Vec<_>>());
+ }
+ }
"edition" => edition = Some(value.to_string()),
"cfg" => {
for entry in value.split(',') {
- match split_once(entry, '=') {
+ match entry.split_once('=') {
Some((k, v)) => cfg_key_values.push((k.to_string(), v.to_string())),
None => cfg_atoms.push(entry.to_string()),
}
}
"env" => {
for key in value.split(',') {
- if let Some((k, v)) = split_once(key, '=') {
+ if let Some((k, v)) = key.split_once('=') {
env.insert(k.into(), v.into());
}
}
}
- "new_source_root" => introduce_new_source_root = true,
+ "new_source_root" => introduce_new_source_root = Some(value.to_string()),
_ => panic!("bad component: {:?}", component),
}
}
+ for prelude_dep in extern_prelude.iter().flatten() {
+ assert!(
+ deps.contains(prelude_dep),
+ "extern-prelude {:?} must be a subset of deps {:?}",
+ extern_prelude,
+ deps
+ );
+ }
+
Fixture {
path,
text: String::new(),
krate,
deps,
+ extern_prelude,
cfg_atoms,
cfg_key_values,
edition,
}
}
+impl MiniCore {
+ fn has_flag(&self, flag: &str) -> bool {
+ self.activated_flags.iter().any(|it| it == flag)
+ }
+
+ #[track_caller]
+ fn assert_valid_flag(&self, flag: &str) {
+ if !self.valid_flags.iter().any(|it| it == flag) {
+ panic!("invalid flag: {:?}, valid flags: {:?}", flag, self.valid_flags);
+ }
+ }
+
+ fn parse(line: &str) -> MiniCore {
+ let mut res = MiniCore { activated_flags: Vec::new(), valid_flags: Vec::new() };
+
+ let line = line.strip_prefix("//- minicore:").unwrap().trim();
+ for entry in line.split(", ") {
+ if res.has_flag(entry) {
+ panic!("duplicate minicore flag: {:?}", entry);
+ }
+ res.activated_flags.push(entry.to_string());
+ }
+
+ res
+ }
+
+ /// Strips parts of minicore.rs which are flagged by inactive flags.
+ ///
+ /// This is probably over-engineered to support flags dependencies.
+ pub fn source_code(mut self) -> String {
+ let mut buf = String::new();
+ let raw_mini_core = include_str!("./minicore.rs");
+ let mut lines = raw_mini_core.split_inclusive('\n');
+
+ let mut parsing_flags = false;
+ let mut implications = Vec::new();
+
+ // Parse `//!` preamble and extract flags and dependencies.
+ for line in lines.by_ref() {
+ let line = match line.strip_prefix("//!") {
+ Some(it) => it,
+ None => {
+ assert!(line.trim().is_empty());
+ break;
+ }
+ };
+
+ if parsing_flags {
+ let (flag, deps) = line.split_once(':').unwrap();
+ let flag = flag.trim();
+ self.valid_flags.push(flag.to_string());
+ for dep in deps.split(", ") {
+ let dep = dep.trim();
+ if !dep.is_empty() {
+ self.assert_valid_flag(dep);
+ implications.push((flag, dep));
+ }
+ }
+ }
+
+ if line.contains("Available flags:") {
+ parsing_flags = true;
+ }
+ }
+
+ for flag in &self.activated_flags {
+ self.assert_valid_flag(flag);
+ }
+
+ // Fixed point loop to compute transitive closure of flags.
+ loop {
+ let mut changed = false;
+ for &(u, v) in &implications {
+ if self.has_flag(u) && !self.has_flag(v) {
+ self.activated_flags.push(v.to_string());
+ changed = true;
+ }
+ }
+ if !changed {
+ break;
+ }
+ }
+
+ let mut active_regions = Vec::new();
+ let mut seen_regions = Vec::new();
+ for line in lines {
+ let trimmed = line.trim();
+ if let Some(region) = trimmed.strip_prefix("// region:") {
+ active_regions.push(region);
+ continue;
+ }
+ if let Some(region) = trimmed.strip_prefix("// endregion:") {
+ let prev = active_regions.pop().unwrap();
+ assert_eq!(prev, region);
+ continue;
+ }
+
+ let mut line_region = false;
+ if let Some(idx) = trimmed.find("// :") {
+ line_region = true;
+ active_regions.push(&trimmed[idx + "// :".len()..]);
+ }
+
+ let mut keep = true;
+ for ®ion in &active_regions {
+ assert!(
+ !region.starts_with(' '),
+ "region marker starts with a space: {:?}",
+ region
+ );
+ self.assert_valid_flag(region);
+ seen_regions.push(region);
+ keep &= self.has_flag(region);
+ }
+
+ if keep {
+ buf.push_str(line);
+ }
+ if line_region {
+ active_regions.pop().unwrap();
+ }
+ }
+
+ for flag in &self.valid_flags {
+ if !seen_regions.iter().any(|it| it == flag) {
+ panic!("unused minicore flag: {:?}", flag);
+ }
+ }
+ buf
+ }
+}
+
#[test]
#[should_panic]
fn parse_fixture_checks_further_indented_metadata() {
#[test]
fn parse_fixture_gets_full_meta() {
- let parsed = Fixture::parse(
- r"
- //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
- mod m;
- ",
+ let (mini_core, proc_macros, parsed) = Fixture::parse(
+ r#"
+//- proc_macros: identity
+//- minicore: coerce_unsized
+//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
+mod m;
+"#,
);
+ assert_eq!(proc_macros, vec!["identity".to_string()]);
+ assert_eq!(mini_core.unwrap().activated_flags, vec!["coerce_unsized".to_string()]);
assert_eq!(1, parsed.len());
let meta = &parsed[0];
projects / rust.git / blobdiff