fix: column!() and line!() built-in macros return u32

lowr · lowr · commit 34a912933323 · 2023-05-11T21:13:05.000+09:00
diff --git a/crates/hir-def/src/macro_expansion_tests/builtin_fn_macro.rs b/crates/hir-def/src/macro_expansion_tests/builtin_fn_macro.rs
@@ -13,12 +13,12 @@ macro_rules! column {() => {}}
 
 fn main() { column!(); }
 "#,
-        expect![[r##"
+        expect![[r#"
 #[rustc_builtin_macro]
 macro_rules! column {() => {}}
 
-fn main() { 0; }
-"##]],
+fn main() { 0 as u32; }
+"#]],
     );
 }
 
@@ -31,12 +31,12 @@ macro_rules! line {() => {}}
 
 fn main() { line!() }
 "#,
-        expect![[r##"
+        expect![[r#"
 #[rustc_builtin_macro]
 macro_rules! line {() => {}}
 
-fn main() { 0 }
-"##]],
+fn main() { 0 as u32 }
+"#]],
     );
 }
 
diff --git a/crates/hir-def/src/macro_expansion_tests/mbe.rs b/crates/hir-def/src/macro_expansion_tests/mbe.rs
@@ -922,7 +922,7 @@ macro_rules! m {
 
 fn bar() -> &'a Baz<u8> {}
 
-fn bar() -> extern "Rust"fn() -> Ret {}
+fn bar() -> extern "Rust" fn() -> Ret {}
 "#]],
     );
 }
@@ -1333,7 +1333,7 @@ macro_rules! matches {
 }
 fn main() {
     match 0 {
-        0|1if true =>true , _=>false
+        0|1 if true =>true , _=>false
     };
 }
  "#]],
diff --git a/crates/hir-def/src/macro_expansion_tests/mbe/matching.rs b/crates/hir-def/src/macro_expansion_tests/mbe/matching.rs
@@ -73,7 +73,7 @@ fn main() {
 macro_rules! asi { ($($stmt:stmt)*) => ($($stmt)*); }
 
 fn main() {
-    let a = 2let b = 5drop(b-a)println!("{}", a+b)
+    let a = 2 let b = 5 drop(b-a)println!("{}", a+b)
 }
 "#]],
     )
diff --git a/crates/hir-def/src/macro_expansion_tests/mbe/regression.rs b/crates/hir-def/src/macro_expansion_tests/mbe/regression.rs
@@ -297,55 +297,55 @@ macro_rules! impl_fn_for_zst  {
 
 #[derive(Clone)] struct CharEscapeDebugContinue;
 impl Fn<(char, )> for CharEscapeDebugContinue {
-    #[inline] extern "rust-call"fn call(&self , (c, ): (char, )) -> char::EscapeDebug { {
+    #[inline] extern "rust-call" fn call(&self , (c, ): (char, )) -> char::EscapeDebug { {
             c.escape_debug_ext(false )
         }
     }
 }
 impl FnMut<(char, )> for CharEscapeDebugContinue {
-    #[inline] extern "rust-call"fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeDebug {
+    #[inline] extern "rust-call" fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeDebug {
         Fn::call(&*self , (c, ))
     }
 }
 impl FnOnce<(char, )> for CharEscapeDebugContinue {
     type Output = char::EscapeDebug;
-    #[inline] extern "rust-call"fn call_once(self , (c, ): (char, )) -> char::EscapeDebug {
+    #[inline] extern "rust-call" fn call_once(self , (c, ): (char, )) -> char::EscapeDebug {
         Fn::call(&self , (c, ))
     }
 }
 #[derive(Clone)] struct CharEscapeUnicode;
 impl Fn<(char, )> for CharEscapeUnicode {
-    #[inline] extern "rust-call"fn call(&self , (c, ): (char, )) -> char::EscapeUnicode { {
+    #[inline] extern "rust-call" fn call(&self , (c, ): (char, )) -> char::EscapeUnicode { {
             c.escape_unicode()
         }
     }
 }
 impl FnMut<(char, )> for CharEscapeUnicode {
-    #[inline] extern "rust-call"fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeUnicode {
+    #[inline] extern "rust-call" fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeUnicode {
         Fn::call(&*self , (c, ))
     }
 }
 impl FnOnce<(char, )> for CharEscapeUnicode {
     type Output = char::EscapeUnicode;
-    #[inline] extern "rust-call"fn call_once(self , (c, ): (char, )) -> char::EscapeUnicode {
+    #[inline] extern "rust-call" fn call_once(self , (c, ): (char, )) -> char::EscapeUnicode {
         Fn::call(&self , (c, ))
     }
 }
 #[derive(Clone)] struct CharEscapeDefault;
 impl Fn<(char, )> for CharEscapeDefault {
-    #[inline] extern "rust-call"fn call(&self , (c, ): (char, )) -> char::EscapeDefault { {
+    #[inline] extern "rust-call" fn call(&self , (c, ): (char, )) -> char::EscapeDefault { {
             c.escape_default()
         }
     }
 }
 impl FnMut<(char, )> for CharEscapeDefault {
-    #[inline] extern "rust-call"fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeDefault {
+    #[inline] extern "rust-call" fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeDefault {
         Fn::call(&*self , (c, ))
     }
 }
 impl FnOnce<(char, )> for CharEscapeDefault {
     type Output = char::EscapeDefault;
-    #[inline] extern "rust-call"fn call_once(self , (c, ): (char, )) -> char::EscapeDefault {
+    #[inline] extern "rust-call" fn call_once(self , (c, ): (char, )) -> char::EscapeDefault {
         Fn::call(&self , (c, ))
     }
 }
@@ -833,7 +833,7 @@ macro_rules! rgb_color {
 /* parse error: expected SEMICOLON */
 /* parse error: expected expression, item or let statement */
 pub fn new() {
-    let _ = 0as u32<<(8+8);
+    let _ = 0 as u32<<(8+8);
 }
 // MACRO_ITEMS@0..31
 //   FN@0..31
diff --git a/crates/hir-def/src/macro_expansion_tests/mod.rs b/crates/hir-def/src/macro_expansion_tests/mod.rs
@@ -280,6 +280,7 @@ fn pretty_print_macro_expansion(expn: SyntaxNode, map: Option<&TokenMap>) -> Str
         let curr_kind = token.kind();
         let space = match (prev_kind, curr_kind) {
             _ if prev_kind.is_trivia() || curr_kind.is_trivia() => "",
+            _ if prev_kind.is_literal() && !curr_kind.is_punct() => " ",
             (T!['{'], T!['}']) => "",
             (T![=], _) | (_, T![=]) => " ",
             (_, T!['{']) => " ",
diff --git a/crates/hir-expand/src/builtin_fn_macro.rs b/crates/hir-expand/src/builtin_fn_macro.rs
@@ -135,9 +135,8 @@ fn line_expand(
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // dummy implementation for type-checking purposes
-    let line_num = 0;
     let expanded = quote! {
-        #line_num
+        0 as u32
     };
 
     ExpandResult::ok(expanded)
@@ -179,9 +178,8 @@ fn column_expand(
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // dummy implementation for type-checking purposes
-    let col_num = 0;
     let expanded = quote! {
-        #col_num
+        0 as u32
     };
 
     ExpandResult::ok(expanded)
diff --git a/crates/hir-ty/src/tests/macros.rs b/crates/hir-ty/src/tests/macros.rs
@@ -661,8 +661,9 @@ fn infer_builtin_macros_line() {
         "#,
         expect![[r#"
             !0..1 '0': i32
+            !0..6 '0asu32': u32
             63..87 '{     ...!(); }': ()
-            73..74 'x': i32
+            73..74 'x': u32
         "#]],
     );
 }
@@ -699,8 +700,9 @@ fn infer_builtin_macros_column() {
         "#,
         expect![[r#"
             !0..1 '0': i32
+            !0..6 '0asu32': u32
             65..91 '{     ...!(); }': ()
-            75..76 'x': i32
+            75..76 'x': u32
         "#]],
     );
 }

Original file line number	Diff line number	Diff line change
`@@ -922,7 +922,7 @@ macro_rules! m {`
`922`	`922`
`923`	`923`	`fn bar() -> &'a Baz<u8> {}`
`924`	`924`
`925`		`-fn bar() -> extern "Rust"fn() -> Ret {}`
	`925`	`+fn bar() -> extern "Rust" fn() -> Ret {}`
`926`	`926`	`"#]],`
`927`	`927`	`);`
`928`	`928`	`}`
`@@ -1333,7 +1333,7 @@ macro_rules! matches {`
`1333`	`1333`	`}`
`1334`	`1334`	`fn main() {`
`1335`	`1335`	`match 0 {`
`1336`		`- 0\|1if true =>true , _=>false`
	`1336`	`+ 0\|1 if true =>true , _=>false`
`1337`	`1337`	`};`
`1338`	`1338`	`}`
`1339`	`1339`	`"#]],`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ fn main() {`
`73`	`73`	`macro_rules! asi { ($($stmt:stmt)) => ($($stmt)); }`
`74`	`74`
`75`	`75`	`fn main() {`
`76`		`- let a = 2let b = 5drop(b-a)println!("{}", a+b)`
	`76`	`+ let a = 2 let b = 5 drop(b-a)println!("{}", a+b)`
`77`	`77`	`}`
`78`	`78`	`"#]],`
`79`	`79`	`)`
Original file line number	Diff line number	Diff line change
`@@ -297,55 +297,55 @@ macro_rules! impl_fn_for_zst {`
`297`	`297`
`298`	`298`	`#[derive(Clone)] struct CharEscapeDebugContinue;`
`299`	`299`	`impl Fn<(char, )> for CharEscapeDebugContinue {`
`300`		`- #[inline] extern "rust-call"fn call(&self , (c, ): (char, )) -> char::EscapeDebug { {`
	`300`	`+ #[inline] extern "rust-call" fn call(&self , (c, ): (char, )) -> char::EscapeDebug { {`
`301`	`301`	`c.escape_debug_ext(false )`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`	`}`
`305`	`305`	`impl FnMut<(char, )> for CharEscapeDebugContinue {`
`306`		`- #[inline] extern "rust-call"fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeDebug {`
	`306`	`+ #[inline] extern "rust-call" fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeDebug {`
`307`	`307`	`Fn::call(&*self , (c, ))`
`308`	`308`	`}`
`309`	`309`	`}`
`310`	`310`	`impl FnOnce<(char, )> for CharEscapeDebugContinue {`
`311`	`311`	`type Output = char::EscapeDebug;`
`312`		`- #[inline] extern "rust-call"fn call_once(self , (c, ): (char, )) -> char::EscapeDebug {`
	`312`	`+ #[inline] extern "rust-call" fn call_once(self , (c, ): (char, )) -> char::EscapeDebug {`
`313`	`313`	`Fn::call(&self , (c, ))`
`314`	`314`	`}`
`315`	`315`	`}`
`316`	`316`	`#[derive(Clone)] struct CharEscapeUnicode;`
`317`	`317`	`impl Fn<(char, )> for CharEscapeUnicode {`
`318`		`- #[inline] extern "rust-call"fn call(&self , (c, ): (char, )) -> char::EscapeUnicode { {`
	`318`	`+ #[inline] extern "rust-call" fn call(&self , (c, ): (char, )) -> char::EscapeUnicode { {`
`319`	`319`	`c.escape_unicode()`
`320`	`320`	`}`
`321`	`321`	`}`
`322`	`322`	`}`
`323`	`323`	`impl FnMut<(char, )> for CharEscapeUnicode {`
`324`		`- #[inline] extern "rust-call"fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeUnicode {`
	`324`	`+ #[inline] extern "rust-call" fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeUnicode {`
`325`	`325`	`Fn::call(&*self , (c, ))`
`326`	`326`	`}`
`327`	`327`	`}`
`328`	`328`	`impl FnOnce<(char, )> for CharEscapeUnicode {`
`329`	`329`	`type Output = char::EscapeUnicode;`
`330`		`- #[inline] extern "rust-call"fn call_once(self , (c, ): (char, )) -> char::EscapeUnicode {`
	`330`	`+ #[inline] extern "rust-call" fn call_once(self , (c, ): (char, )) -> char::EscapeUnicode {`
`331`	`331`	`Fn::call(&self , (c, ))`
`332`	`332`	`}`
`333`	`333`	`}`
`334`	`334`	`#[derive(Clone)] struct CharEscapeDefault;`
`335`	`335`	`impl Fn<(char, )> for CharEscapeDefault {`
`336`		`- #[inline] extern "rust-call"fn call(&self , (c, ): (char, )) -> char::EscapeDefault { {`
	`336`	`+ #[inline] extern "rust-call" fn call(&self , (c, ): (char, )) -> char::EscapeDefault { {`
`337`	`337`	`c.escape_default()`
`338`	`338`	`}`
`339`	`339`	`}`
`340`	`340`	`}`
`341`	`341`	`impl FnMut<(char, )> for CharEscapeDefault {`
`342`		`- #[inline] extern "rust-call"fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeDefault {`
	`342`	`+ #[inline] extern "rust-call" fn call_mut(&mut self , (c, ): (char, )) -> char::EscapeDefault {`
`343`	`343`	`Fn::call(&*self , (c, ))`
`344`	`344`	`}`
`345`	`345`	`}`
`346`	`346`	`impl FnOnce<(char, )> for CharEscapeDefault {`
`347`	`347`	`type Output = char::EscapeDefault;`
`348`		`- #[inline] extern "rust-call"fn call_once(self , (c, ): (char, )) -> char::EscapeDefault {`
	`348`	`+ #[inline] extern "rust-call" fn call_once(self , (c, ): (char, )) -> char::EscapeDefault {`
`349`	`349`	`Fn::call(&self , (c, ))`
`350`	`350`	`}`
`351`	`351`	`}`
`@@ -833,7 +833,7 @@ macro_rules! rgb_color {`
`833`	`833`	`/* parse error: expected SEMICOLON */`
`834`	`834`	`/* parse error: expected expression, item or let statement */`
`835`	`835`	`pub fn new() {`
`836`		`- let _ = 0as u32<<(8+8);`
	`836`	`+ let _ = 0 as u32<<(8+8);`
`837`	`837`	`}`
`838`	`838`	`// [email protected]`
`839`	`839`	`// [email protected]`