5 files changed, 103 insertions, 111 deletions

diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index b7f1aae8f..dfdb9cf59 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -267,13 +267,14 @@ fn partial_ord_expand(
 #[cfg(test)]
 mod tests {
     use base_db::{fixture::WithFixture, CrateId, SourceDatabase};
+    use expect_test::{expect, Expect};
     use name::{known, Name};
 
     use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc};
 
     use super::*;
 
-    fn expand_builtin_derive(s: &str, name: Name) -> String {
+    fn expand_builtin_derive(ra_fixture: &str, name: Name) -> String {
         let expander = BuiltinDeriveExpander::find_by_name(&name).unwrap();
         let fixture = format!(
             r#"//- /main.rs crate:main deps:core
@@ -282,7 +283,7 @@ $0
 //- /lib.rs crate:core
 // empty
 "#,
-            s
+            ra_fixture
         );
 
         let (db, file_pos) = TestDB::with_position(&fixture);
@@ -314,66 +315,57 @@ $0
         parsed.text().to_string()
     }
 
+    fn check_derive(ra_fixture: &str, name: Name, expected: Expect) {
+        let expanded = expand_builtin_derive(ra_fixture, name);
+        expected.assert_eq(&expanded);
+    }
+
     #[test]
     fn test_copy_expand_simple() {
-        let expanded = expand_builtin_derive(
+        check_derive(
             r#"
-        #[derive(Copy)]
-        struct Foo;
-"#,
+            #[derive(Copy)]
+            struct Foo;
+            "#,
             known::Copy,
+            expect![["impl< >core::marker::CopyforFoo< >{}"]],
         );
-
-        assert_eq!(expanded, "impl< >core::marker::CopyforFoo< >{}");
     }
 
     #[test]
     fn test_copy_expand_with_type_params() {
-        let expanded = expand_builtin_derive(
+        check_derive(
             r#"
-        #[derive(Copy)]
-        struct Foo<A, B>;
-"#,
+            #[derive(Copy)]
+            struct Foo<A, B>;
+            "#,
             known::Copy,
-        );
-
-        assert_eq!(
-            expanded,
-            "impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"
+            expect![["impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"]],
         );
     }
 
     #[test]
     fn test_copy_expand_with_lifetimes() {
-        let expanded = expand_builtin_derive(
+        check_derive(
             r#"
-        #[derive(Copy)]
-        struct Foo<A, B, 'a, 'b>;
-"#,
+            #[derive(Copy)]
+            struct Foo<A, B, 'a, 'b>;
+            "#,
             known::Copy,
-        );
-
-        // We currently just ignore lifetimes
-
-        assert_eq!(
-            expanded,
-            "impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"
+            // We currently just ignore lifetimes
+            expect![["impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"]],
         );
     }
 
     #[test]
     fn test_clone_expand() {
-        let expanded = expand_builtin_derive(
+        check_derive(
             r#"
-        #[derive(Clone)]
-        struct Foo<A, B>;
-"#,
+            #[derive(Clone)]
+            struct Foo<A, B>;
+            "#,
             known::Clone,
-        );
-
-        assert_eq!(
-            expanded,
-            "impl<T0:core::clone::Clone,T1:core::clone::Clone>core::clone::CloneforFoo<T0,T1>{}"
+            expect![["impl<T0:core::clone::Clone,T1:core::clone::Clone>core::clone::CloneforFoo<T0,T1>{}"]],
         );
     }
 }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 57bc6fbd7..2a79c892b 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -5,8 +5,9 @@ use crate::{
 };
 
 use base_db::{AnchoredPath, FileId};
+use cfg::CfgExpr;
 use either::Either;
-use mbe::{parse_to_token_tree, ExpandResult};
+use mbe::{parse_exprs_with_sep, parse_to_token_tree, ExpandResult};
 use parser::FragmentKind;
 use syntax::ast::{self, AstToken};
 
@@ -97,6 +98,7 @@ register_builtin! {
     (format_args_nl, FormatArgsNl) => format_args_expand,
     (llvm_asm, LlvmAsm) => asm_expand,
     (asm, Asm) => asm_expand,
+    (cfg, Cfg) => cfg_expand,
 
     EAGER:
     (compile_error, CompileError) => compile_error_expand,
@@ -182,25 +184,10 @@ fn assert_expand(
     // ```,
     // which is wrong but useful.
 
-    let mut args = Vec::new();
-    let mut current = Vec::new();
-    for tt in tt.token_trees.iter().cloned() {
-        match tt {
-            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
-                args.push(current);
-                current = Vec::new();
-            }
-            _ => {
-                current.push(tt);
-            }
-        }
-    }
-    if !current.is_empty() {
-        args.push(current);
-    }
+    let args = parse_exprs_with_sep(tt, ',');
 
     let arg_tts = args.into_iter().flat_map(|arg| {
-        quote! { &(##arg), }
+        quote! { &(#arg), }
     }.token_trees).collect::<Vec<_>>();
 
     let expanded = quote! {
@@ -238,35 +225,21 @@ fn format_args_expand(
     // ])
     // ```,
     // which is still not really correct, but close enough for now
-    let mut args = Vec::new();
-    let mut current = Vec::new();
-    for tt in tt.token_trees.iter().cloned() {
-        match tt {
-            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
-                args.push(current);
-                current = Vec::new();
-            }
-            _ => {
-                current.push(tt);
-            }
-        }
-    }
-    if !current.is_empty() {
-        args.push(current);
-    }
+    let mut args = parse_exprs_with_sep(tt, ',');
+
     if args.is_empty() {
         return ExpandResult::only_err(mbe::ExpandError::NoMatchingRule);
     }
     for arg in &mut args {
         // Remove `key =`.
-        if matches!(arg.get(1), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=' && p.spacing != tt::Spacing::Joint)
+        if matches!(arg.token_trees.get(1), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=' && p.spacing != tt::Spacing::Joint)
         {
-            arg.drain(..2);
+            arg.token_trees.drain(..2);
         }
     }
     let _format_string = args.remove(0);
     let arg_tts = args.into_iter().flat_map(|arg| {
-        quote! { std::fmt::ArgumentV1::new(&(##arg), std::fmt::Display::fmt), }
+        quote! { std::fmt::ArgumentV1::new(&(#arg), std::fmt::Display::fmt), }
     }.token_trees).collect::<Vec<_>>();
     let expanded = quote! {
         std::fmt::Arguments::new_v1(&[], &[##arg_tts])
@@ -287,6 +260,18 @@ fn asm_expand(
     ExpandResult::ok(expanded)
 }
 
+fn cfg_expand(
+    db: &dyn AstDatabase,
+    id: LazyMacroId,
+    tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+    let loc = db.lookup_intern_macro(id);
+    let expr = CfgExpr::parse(tt);
+    let enabled = db.crate_graph()[loc.krate].cfg_options.check(&expr) != Some(false);
+    let expanded = if enabled { quote!(true) } else { quote!(false) };
+    ExpandResult::ok(expanded)
+}
+
 fn unquote_str(lit: &tt::Literal) -> Option<String> {
     let lit = ast::make::tokens::literal(&lit.to_string());
     let token = ast::String::cast(lit)?;
@@ -506,6 +491,7 @@ mod tests {
         MacroCallLoc,
     };
     use base_db::{fixture::WithFixture, SourceDatabase};
+    use expect_test::{expect, Expect};
     use std::sync::Arc;
     use syntax::ast::NameOwner;
 
@@ -589,87 +575,86 @@ mod tests {
         db.parse_or_expand(file_id).unwrap().to_string()
     }
 
+    fn check_expansion(ra_fixture: &str, expect: Expect) {
+        let expansion = expand_builtin_macro(ra_fixture);
+        expect.assert_eq(&expansion);
+    }
+
     #[test]
     fn test_column_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! column {() => {}}
             column!()
             "#,
+            expect![["0"]],
         );
-
-        assert_eq!(expanded, "0");
     }
 
     #[test]
     fn test_line_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! line {() => {}}
             line!()
             "#,
+            expect![["0"]],
         );
-
-        assert_eq!(expanded, "0");
     }
 
     #[test]
     fn test_stringify_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! stringify {() => {}}
             stringify!(a b c)
             "#,
+            expect![["\"a b c\""]],
         );
-
-        assert_eq!(expanded, "\"a b c\"");
     }
 
     #[test]
     fn test_env_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! env {() => {}}
             env!("TEST_ENV_VAR")
             "#,
+            expect![["\"__RA_UNIMPLEMENTED__\""]],
         );
-
-        assert_eq!(expanded, "\"__RA_UNIMPLEMENTED__\"");
     }
 
     #[test]
     fn test_option_env_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! option_env {() => {}}
             option_env!("TEST_ENV_VAR")
             "#,
+            expect![["std::option::Option::None:: < &str>"]],
         );
-
-        assert_eq!(expanded, "std::option::Option::None:: < &str>");
     }
 
     #[test]
     fn test_file_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! file {() => {}}
             file!()
             "#,
+            expect![[r#""""#]],
         );
-
-        assert_eq!(expanded, "\"\"");
     }
 
     #[test]
     fn test_assert_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! assert {
@@ -678,14 +663,13 @@ mod tests {
             }
             assert!(true, "{} {:?}", arg1(a, b, c), arg2);
             "#,
+            expect![["{{(&(true), &(\"{} {:?}\"), &(arg1(a,b,c)), &(arg2),);}}"]],
         );
-
-        assert_eq!(expanded, "{{(&(true), &(\"{} {:?}\"), &(arg1(a,b,c)), &(arg2),);}}");
     }
 
     #[test]
     fn test_compile_error_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! compile_error {
@@ -694,15 +678,14 @@ mod tests {
             }
             compile_error!("error!");
             "#,
+            // This expands to nothing (since it's in item position), but emits an error.
+            expect![[""]],
         );
-
-        // This expands to nothing (since it's in item position), but emits an error.
-        assert_eq!(expanded, "");
     }
 
     #[test]
     fn test_format_args_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! format_args {
@@ -711,17 +694,32 @@ mod tests {
             }
             format_args!("{} {:?}", arg1(a, b, c), arg2);
             "#,
+            expect![[
+                r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(arg1(a,b,c)),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(arg2),std::fmt::Display::fmt),])"#
+            ]],
         );
+    }
 
-        assert_eq!(
-            expanded,
-            r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(arg1(a,b,c)),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(arg2),std::fmt::Display::fmt),])"#
+    #[test]
+    fn test_format_args_expand_with_comma_exprs() {
+        check_expansion(
+            r#"
+            #[rustc_builtin_macro]
+            macro_rules! format_args {
+                ($fmt:expr) => ({ /* compiler built-in */ });
+                ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
+            }
+            format_args!("{} {:?}", a::<A,B>(), b);
+            "#,
+            expect![[
+                r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(a::<A,B>()),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(b),std::fmt::Display::fmt),])"#
+            ]],
         );
     }
 
     #[test]
     fn test_include_bytes_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r#"
             #[rustc_builtin_macro]
             macro_rules! include_bytes {
@@ -730,21 +728,19 @@ mod tests {
             }
             include_bytes("foo");
             "#,
+            expect![[r#"b"""#]],
         );
-
-        assert_eq!(expanded, r#"b"""#);
     }
 
     #[test]
     fn test_concat_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
             r##"
             #[rustc_builtin_macro]
             macro_rules! concat {}
             concat!("foo", "r", 0, r#"bar"#, false);
             "##,
+            expect![[r#""foor0barfalse""#]],
         );
-
-        assert_eq!(expanded, r#""foor0barfalse""#);
     }
 }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index cb6e23320..9086e6c17 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -340,6 +340,8 @@ fn parse_macro_with_arg(
         None => return ExpandResult { value: None, err: result.err },
     };
 
+    log::debug!("expanded = {}", tt.as_debug_string());
+
     let fragment_kind = to_fragment_kind(db, macro_call_id);
 
     let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index c94fb580a..e833e032c 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -154,6 +154,7 @@ pub mod known {
         macro_rules,
         derive,
         doc,
+        cfg,
         cfg_attr,
         // Components of known path (value or mod name)
         std,
diff --git a/crates/hir_expand/src/quote.rs b/crates/hir_expand/src/quote.rs
index 219bc2097..08bc5aa49 100644
--- a/crates/hir_expand/src/quote.rs
+++ b/crates/hir_expand/src/quote.rs
@@ -188,8 +188,9 @@ macro_rules! impl_to_to_tokentrees {
 
 impl_to_to_tokentrees! {
     u32 => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()} };
-    usize => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()}};
-    i32 => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()}};
+    usize => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()} };
+    i32 => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()} };
+    bool => self { tt::Ident{text: self.to_string().into(), id: tt::TokenId::unspecified()} };
     tt::Leaf => self { self };
     tt::Literal => self { self };
     tt::Ident => self { self };