From 2bc4c1ff31b6ef0ca1848a7ce12f981b93dcded0 Mon Sep 17 00:00:00 2001 From: Jonas Schievink Date: Wed, 21 Oct 2020 13:57:12 +0200 Subject: Simplify cfg representation --- crates/cfg/src/cfg_expr.rs | 44 ++++++++++++++++++++++++++++++-------------- crates/cfg/src/lib.rs | 22 +++++++--------------- 2 files changed, 37 insertions(+), 29 deletions(-) (limited to 'crates/cfg') diff --git a/crates/cfg/src/cfg_expr.rs b/crates/cfg/src/cfg_expr.rs index 336fe25bc..db3655b74 100644 --- a/crates/cfg/src/cfg_expr.rs +++ b/crates/cfg/src/cfg_expr.rs @@ -6,26 +6,42 @@ use std::slice::Iter as SliceIter; use tt::SmolStr; +/// A simple configuration value passed in from the outside. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum CfgAtom { + /// eg. `#[cfg(test)]` + Flag(SmolStr), + /// eg. `#[cfg(target_os = "linux")]` + /// + /// Note that a key can have multiple values that are all considered "active" at the same time. + /// For example, `#[cfg(target_feature = "sse")]` and `#[cfg(target_feature = "sse2")]`. + KeyValue { key: SmolStr, value: SmolStr }, +} + #[derive(Debug, Clone, PartialEq, Eq)] pub enum CfgExpr { Invalid, - Atom(SmolStr), - KeyValue { key: SmolStr, value: SmolStr }, + Atom(CfgAtom), All(Vec), Any(Vec), Not(Box), } +impl From for CfgExpr { + fn from(atom: CfgAtom) -> Self { + CfgExpr::Atom(atom) + } +} + impl CfgExpr { pub fn parse(tt: &tt::Subtree) -> CfgExpr { next_cfg_expr(&mut tt.token_trees.iter()).unwrap_or(CfgExpr::Invalid) } /// Fold the cfg by querying all basic `Atom` and `KeyValue` predicates. - pub fn fold(&self, query: &dyn Fn(&SmolStr, Option<&SmolStr>) -> bool) -> Option { + pub fn fold(&self, query: &dyn Fn(&CfgAtom) -> bool) -> Option { match self { CfgExpr::Invalid => None, - CfgExpr::Atom(name) => Some(query(name, None)), - CfgExpr::KeyValue { key, value } => Some(query(key, Some(value))), + CfgExpr::Atom(atom) => Some(query(atom)), CfgExpr::All(preds) => { preds.iter().try_fold(true, |s, pred| Some(s && pred.fold(query)?)) } @@ -54,7 +70,7 @@ fn next_cfg_expr(it: &mut SliceIter) -> Option { // FIXME: escape? raw string? let value = SmolStr::new(literal.text.trim_start_matches('"').trim_end_matches('"')); - CfgExpr::KeyValue { key: name, value } + CfgAtom::KeyValue { key: name, value }.into() } _ => return Some(CfgExpr::Invalid), } @@ -70,7 +86,7 @@ fn next_cfg_expr(it: &mut SliceIter) -> Option { _ => CfgExpr::Invalid, } } - _ => CfgExpr::Atom(name), + _ => CfgAtom::Flag(name).into(), }; // Eat comma separator @@ -101,22 +117,22 @@ mod tests { #[test] fn test_cfg_expr_parser() { - assert_parse_result("#![cfg(foo)]", CfgExpr::Atom("foo".into())); - assert_parse_result("#![cfg(foo,)]", CfgExpr::Atom("foo".into())); + assert_parse_result("#![cfg(foo)]", CfgAtom::Flag("foo".into()).into()); + assert_parse_result("#![cfg(foo,)]", CfgAtom::Flag("foo".into()).into()); assert_parse_result( "#![cfg(not(foo))]", - CfgExpr::Not(Box::new(CfgExpr::Atom("foo".into()))), + CfgExpr::Not(Box::new(CfgAtom::Flag("foo".into()).into())), ); assert_parse_result("#![cfg(foo(bar))]", CfgExpr::Invalid); // Only take the first - assert_parse_result(r#"#![cfg(foo, bar = "baz")]"#, CfgExpr::Atom("foo".into())); + assert_parse_result(r#"#![cfg(foo, bar = "baz")]"#, CfgAtom::Flag("foo".into()).into()); assert_parse_result( r#"#![cfg(all(foo, bar = "baz"))]"#, CfgExpr::All(vec![ - CfgExpr::Atom("foo".into()), - CfgExpr::KeyValue { key: "bar".into(), value: "baz".into() }, + CfgAtom::Flag("foo".into()).into(), + CfgAtom::KeyValue { key: "bar".into(), value: "baz".into() }.into(), ]), ); @@ -126,7 +142,7 @@ mod tests { CfgExpr::Not(Box::new(CfgExpr::Invalid)), CfgExpr::All(vec![]), CfgExpr::Invalid, - CfgExpr::KeyValue { key: "bar".into(), value: "baz".into() }, + CfgAtom::KeyValue { key: "bar".into(), value: "baz".into() }.into(), ]), ); } diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs index a9d50e698..35f540ac3 100644 --- a/crates/cfg/src/lib.rs +++ b/crates/cfg/src/lib.rs @@ -5,7 +5,7 @@ mod cfg_expr; use rustc_hash::FxHashSet; use tt::SmolStr; -pub use cfg_expr::CfgExpr; +pub use cfg_expr::{CfgAtom, CfgExpr}; /// Configuration options used for conditional compilition on items with `cfg` attributes. /// We have two kind of options in different namespaces: atomic options like `unix`, and @@ -19,33 +19,25 @@ pub use cfg_expr::CfgExpr; /// See: https://doc.rust-lang.org/reference/conditional-compilation.html#set-configuration-options #[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct CfgOptions { - atoms: FxHashSet, - key_values: FxHashSet<(SmolStr, SmolStr)>, + enabled: FxHashSet, } impl CfgOptions { pub fn check(&self, cfg: &CfgExpr) -> Option { - cfg.fold(&|key, value| match value { - None => self.atoms.contains(key), - Some(value) => self.key_values.contains(&(key.clone(), value.clone())), - }) + cfg.fold(&|atom| self.enabled.contains(atom)) } pub fn insert_atom(&mut self, key: SmolStr) { - self.atoms.insert(key); + self.enabled.insert(CfgAtom::Flag(key)); } pub fn insert_key_value(&mut self, key: SmolStr, value: SmolStr) { - self.key_values.insert((key, value)); + self.enabled.insert(CfgAtom::KeyValue { key, value }); } pub fn append(&mut self, other: &CfgOptions) { - for atom in &other.atoms { - self.atoms.insert(atom.clone()); - } - - for (key, value) in &other.key_values { - self.key_values.insert((key.clone(), value.clone())); + for atom in &other.enabled { + self.enabled.insert(atom.clone()); } } } -- cgit v1.2.3