1 files changed, 17 insertions, 9 deletions

diff --git a/crates/ra_cfg/src/lib.rs b/crates/ra_cfg/src/lib.rs
index fa5822d8a..dd81a73f4 100644
--- a/crates/ra_cfg/src/lib.rs
+++ b/crates/ra_cfg/src/lib.rs
@@ -1,24 +1,32 @@
 //! ra_cfg defines conditional compiling options, `cfg` attibute parser and evaluator
 use ra_syntax::SmolStr;
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashSet;
 
 mod cfg_expr;
 
 pub use cfg_expr::{parse_cfg, 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
+/// key-value options like `target_arch="x86"`.
+///
+/// Note that for key-value options, one key can have multiple values (but not none).
+/// `feature` is an example. We have both `feature="foo"` and `feature="bar"` if features
+/// `foo` and `bar` are both enabled. And here, we store key-value options as a set of tuple
+/// of key and value in `key_values`.
+///
+/// See: https://doc.rust-lang.org/reference/conditional-compilation.html#set-configuration-options
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct CfgOptions {
     atoms: FxHashSet<SmolStr>,
-    features: FxHashSet<SmolStr>,
-    options: FxHashMap<SmolStr, SmolStr>,
+    key_values: FxHashSet<(SmolStr, SmolStr)>,
 }
 
 impl CfgOptions {
     pub fn check(&self, cfg: &CfgExpr) -> Option<bool> {
         cfg.fold(&|key, value| match value {
             None => self.atoms.contains(key),
-            Some(value) if key == "feature" => self.features.contains(value),
-            Some(value) => self.options.get(key).map_or(false, |v| v == value),
+            Some(value) => self.key_values.contains(&(key.clone(), value.clone())),
         })
     }
 
@@ -31,13 +39,13 @@ impl CfgOptions {
         self
     }
 
-    pub fn feature(mut self, name: SmolStr) -> CfgOptions {
-        self.features.insert(name);
+    pub fn key_value(mut self, key: SmolStr, value: SmolStr) -> CfgOptions {
+        self.key_values.insert((key, value));
         self
     }
 
-    pub fn option(mut self, key: SmolStr, value: SmolStr) -> CfgOptions {
-        self.options.insert(key, value);
+    pub fn remove_atom(mut self, name: &SmolStr) -> CfgOptions {
+        self.atoms.remove(name);
         self
     }
 }