use std::fs; use insta::assert_snapshot; use ra_db::fixture::WithFixture; use test_utils::project_dir; use crate::test_db::TestDB; use super::{infer, type_at, type_at_pos}; #[test] fn cfg_impl_def() { let (db, pos) = TestDB::with_position( r#" //- /main.rs crate:main deps:foo cfg:test use foo::S as T; struct S; #[cfg(test)] impl S { fn foo1(&self) -> i32 { 0 } } #[cfg(not(test))] impl S { fn foo2(&self) -> i32 { 0 } } fn test() { let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4()); t<|>; } //- /foo.rs crate:foo struct S; #[cfg(not(test))] impl S { fn foo3(&self) -> i32 { 0 } } #[cfg(test)] impl S { fn foo4(&self) -> i32 { 0 } } "#, ); assert_eq!("(i32, {unknown}, i32, {unknown})", type_at_pos(&db, pos)); } #[test] fn infer_macros_expanded() { assert_snapshot!( infer(r#" struct Foo(Vec); macro_rules! foo { ($($item:expr),*) => { { Foo(vec![$($item,)*]) } }; } fn main() { let x = foo!(1,2); } "#), @r###" !0..17 '{Foo(v...,2,])}': Foo !1..4 'Foo': Foo({unknown}) -> Foo !1..16 'Foo(vec![1,2,])': Foo !5..15 'vec![1,2,]': {unknown} 156..182 '{ ...,2); }': () 166..167 'x': Foo "### ); } #[test] fn infer_legacy_textual_scoped_macros_expanded() { assert_snapshot!( infer(r#" struct Foo(Vec); #[macro_use] mod m { macro_rules! foo { ($($item:expr),*) => { { Foo(vec![$($item,)*]) } }; } } fn main() { let x = foo!(1,2); let y = crate::foo!(1,2); } "#), @r###" !0..17 '{Foo(v...,2,])}': Foo !1..4 'Foo': Foo({unknown}) -> Foo !1..16 'Foo(vec![1,2,])': Foo !5..15 'vec![1,2,]': {unknown} 195..251 '{ ...,2); }': () 205..206 'x': Foo 228..229 'y': {unknown} 232..248 'crate:...!(1,2)': {unknown} "### ); } #[test] fn infer_path_qualified_macros_expanded() { assert_snapshot!( infer(r#" #[macro_export] macro_rules! foo { () => { 42i32 } } mod m { pub use super::foo as bar; } fn main() { let x = crate::foo!(); let y = m::bar!(); } "#), @r###" !0..5 '42i32': i32 !0..5 '42i32': i32 111..164 '{ ...!(); }': () 121..122 'x': i32 148..149 'y': i32 "### ); } #[test] fn expr_macro_expanded_in_various_places() { assert_snapshot!( infer(r#" macro_rules! spam { () => (1isize); } fn spam() { spam!(); (spam!()); spam!().spam(spam!()); for _ in spam!() {} || spam!(); while spam!() {} break spam!(); return spam!(); match spam!() { _ if spam!() => spam!(), } spam!()(spam!()); Spam { spam: spam!() }; spam!()[spam!()]; await spam!(); spam!() as usize; &spam!(); -spam!(); spam!()..spam!(); spam!() + spam!(); } "#), @r###" !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize !0..6 '1isize': isize 54..457 '{ ...!(); }': ! 88..109 'spam!(...am!())': {unknown} 115..134 'for _ ...!() {}': () 119..120 '_': {unknown} 132..134 '{}': () 139..149 '|| spam!()': || -> isize 155..171 'while ...!() {}': () 169..171 '{}': () 176..189 'break spam!()': ! 195..209 'return spam!()': ! 215..269 'match ... }': isize 239..240 '_': isize 274..290 'spam!(...am!())': {unknown} 296..318 'Spam {...m!() }': {unknown} 324..340 'spam!(...am!()]': {unknown} 365..381 'spam!(... usize': usize 387..395 '&spam!()': &isize 401..409 '-spam!()': isize 415..431 'spam!(...pam!()': {unknown} 437..454 'spam!(...pam!()': isize "### ); } #[test] fn infer_type_value_macro_having_same_name() { assert_snapshot!( infer(r#" #[macro_export] macro_rules! foo { () => { mod foo { pub use super::foo; } }; ($x:tt) => { $x }; } foo!(); fn foo() { let foo = foo::foo!(42i32); } "#), @r###" !0..5 '42i32': i32 171..206 '{ ...32); }': () 181..184 'foo': i32 "### ); } #[test] fn processes_impls_generated_by_macros() { let t = type_at( r#" //- /main.rs macro_rules! m { ($ident:ident) => (impl Trait for $ident {}) } trait Trait { fn foo(self) -> u128 {} } struct S; m!(S); fn test() { S.foo()<|>; } "#, ); assert_eq!(t, "u128"); } #[test] fn infer_impl_items_generated_by_macros() { let t = type_at( r#" //- /main.rs macro_rules! m { () => (fn foo(&self) -> u128 {0}) } struct S; impl S { m!(); } fn test() { S.foo()<|>; } "#, ); assert_eq!(t, "u128"); } #[test] fn infer_impl_items_generated_by_macros_chain() { let t = type_at( r#" //- /main.rs macro_rules! m_inner { () => {fn foo(&self) -> u128 {0}} } macro_rules! m { () => {m_inner!();} } struct S; impl S { m!(); } fn test() { S.foo()<|>; } "#, ); assert_eq!(t, "u128"); } #[test] fn infer_macro_with_dollar_crate_is_correct_in_expr() { let (db, pos) = TestDB::with_position( r#" //- /main.rs crate:main deps:foo fn test() { let x = (foo::foo!(1), foo::foo!(2)); x<|>; } //- /lib.rs crate:foo #[macro_export] macro_rules! foo { (1) => { $crate::bar!() }; (2) => { 1 + $crate::baz() }; } #[macro_export] macro_rules! bar { () => { 42 } } pub fn baz() -> usize { 31usize } "#, ); assert_eq!("(i32, usize)", type_at_pos(&db, pos)); } #[test] fn infer_macro_with_dollar_crate_is_correct_in_trait_associate_type() { let (db, pos) = TestDB::with_position( r#" //- /main.rs crate:main deps:foo use foo::Trait; fn test() { let msg = foo::Message(foo::MessageRef); let r = msg.deref(); r<|>; } //- /lib.rs crate:foo pub struct MessageRef; pub struct Message(MessageRef); pub trait Trait { type Target; fn deref(&self) -> &Self::Target; } #[macro_export] macro_rules! expand { () => { impl Trait for Message { type Target = $crate::MessageRef; fn deref(&self) -> &Self::Target { &self.0 } } } } expand!(); "#, ); assert_eq!("&MessageRef", type_at_pos(&db, pos)); } #[test] fn infer_type_value_non_legacy_macro_use_as() { assert_snapshot!( infer(r#" mod m { macro_rules! _foo { ($x:ident) => { type $x = u64; } } pub(crate) use _foo as foo; } m::foo!(foo); use foo as bar; fn f() -> bar { 0 } fn main() { let _a = f(); } "#), @r###" 159..164 '{ 0 }': u64 161..162 '0': u64 175..197 '{ ...f(); }': () 185..187 '_a': u64 191..192 'f': fn f() -> u64 191..194 'f()': u64 "### ); } #[test] fn infer_local_macro() { assert_snapshot!( infer(r#" fn main() { macro_rules! foo { () => { 1usize } } let _a = foo!(); } "#), @r###" !0..6 '1usize': usize 11..90 '{ ...!(); }': () 17..66 'macro_... }': {unknown} 75..77 '_a': usize "### ); } #[test] fn infer_builtin_macros_line() { assert_snapshot!( infer(r#" #[rustc_builtin_macro] macro_rules! line {() => {}} fn main() { let x = line!(); } "#), @r###" !0..1 '0': i32 64..88 '{ ...!(); }': () 74..75 'x': i32 "### ); } #[test] fn infer_builtin_macros_file() { assert_snapshot!( infer(r#" #[rustc_builtin_macro] macro_rules! file {() => {}} fn main() { let x = file!(); } "#), @r###" !0..2 '""': &str 64..88 '{ ...!(); }': () 74..75 'x': &str "### ); } #[test] fn infer_builtin_macros_column() { assert_snapshot!( infer(r#" #[rustc_builtin_macro] macro_rules! column {() => {}} fn main() { let x = column!(); } "#), @r###" !0..1 '0': i32 66..92 '{ ...!(); }': () 76..77 'x': i32 "### ); } #[test] fn infer_builtin_macros_concat() { assert_snapshot!( infer(r#" #[rustc_builtin_macro] macro_rules! concat {() => {}} fn main() { let x = concat!("hello", concat!("world", "!")); } "#), @r###" !0..13 '"helloworld!"': &str 66..122 '{ ...")); }': () 76..77 'x': &str "### ); } #[test] fn infer_builtin_macros_include() { let (db, pos) = TestDB::with_position( r#" //- /main.rs #[rustc_builtin_macro] macro_rules! include {() => {}} include!("foo.rs"); fn main() { bar()<|>; } //- /foo.rs fn bar() -> u32 {0} "#, ); assert_eq!("u32", type_at_pos(&db, pos)); } #[test] #[ignore] fn include_accidentally_quadratic() { let file = project_dir().join("crates/ra_syntax/test_data/accidentally_quadratic"); let big_file = fs::read_to_string(file).unwrap(); let big_file = vec![big_file; 10].join("\n"); let fixture = r#" //- /main.rs #[rustc_builtin_macro] macro_rules! include {() => {}} include!("foo.rs"); fn main() { RegisterBlock { }<|>; } "#; let fixture = format!("{}\n//- /foo.rs\n{}", fixture, big_file); let (db, pos) = TestDB::with_position(&fixture); assert_eq!("RegisterBlock", type_at_pos(&db, pos)); } #[test] fn infer_builtin_macros_include_concat() { let (db, pos) = TestDB::with_position( r#" //- /main.rs #[rustc_builtin_macro] macro_rules! include {() => {}} #[rustc_builtin_macro] macro_rules! concat {() => {}} include!(concat!("f", "oo.rs")); fn main() { bar()<|>; } //- /foo.rs fn bar() -> u32 {0} "#, ); assert_eq!("u32", type_at_pos(&db, pos)); } #[test] fn infer_builtin_macros_include_concat_with_bad_env_should_failed() { let (db, pos) = TestDB::with_position( r#" //- /main.rs #[rustc_builtin_macro] macro_rules! include {() => {}} #[rustc_builtin_macro] macro_rules! concat {() => {}} #[rustc_builtin_macro] macro_rules! env {() => {}} include!(concat!(env!("OUT_DIR"), "/foo.rs")); fn main() { bar()<|>; } //- /foo.rs fn bar() -> u32 {0} "#, ); assert_eq!("{unknown}", type_at_pos(&db, pos)); } #[test] fn infer_builtin_macros_include_itself_should_failed() { let (db, pos) = TestDB::with_position( r#" //- /main.rs #[rustc_builtin_macro] macro_rules! include {() => {}} include!("main.rs"); fn main() { 0<|> } "#, ); assert_eq!("i32", type_at_pos(&db, pos)); } #[test] fn infer_builtin_macros_concat_with_lazy() { assert_snapshot!( infer(r#" macro_rules! hello {() => {"hello"}} #[rustc_builtin_macro] macro_rules! concat {() => {}} fn main() { let x = concat!(hello!(), concat!("world", "!")); } "#), @r###" !0..13 '"helloworld!"': &str 104..161 '{ ...")); }': () 114..115 'x': &str "### ); } #[test] fn infer_builtin_macros_env() { assert_snapshot!( infer(r#" //- /main.rs env:foo=bar #[rustc_builtin_macro] macro_rules! env {() => {}} fn main() { let x = env!("foo"); } "#), @r###" !0..5 '"bar"': &str 88..116 '{ ...o"); }': () 98..99 'x': &str "### ); } #[test] fn infer_derive_clone_simple() { let (db, pos) = TestDB::with_position( r#" //- /main.rs crate:main deps:core #[derive(Clone)] struct S; fn test() { S.clone()<|>; } //- /lib.rs crate:core #[prelude_import] use clone::*; mod clone { trait Clone { fn clone(&self) -> Self; } } "#, ); assert_eq!("S", type_at_pos(&db, pos)); } #[test] fn infer_derive_clone_in_core() { let (db, pos) = TestDB::with_position( r#" //- /lib.rs crate:core #[prelude_import] use clone::*; mod clone { trait Clone { fn clone(&self) -> Self; } } #[derive(Clone)] pub struct S; //- /main.rs crate:main deps:core use core::S; fn test() { S.clone()<|>; } "#, ); assert_eq!("S", type_at_pos(&db, pos)); } #[test] fn infer_derive_clone_with_params() { let (db, pos) = TestDB::with_position( r#" //- /main.rs crate:main deps:core #[derive(Clone)] struct S; #[derive(Clone)] struct Wrapper(T); struct NonClone; fn test() { (Wrapper(S).clone(), Wrapper(NonClone).clone())<|>; } //- /lib.rs crate:core #[prelude_import] use clone::*; mod clone { trait Clone { fn clone(&self) -> Self; } } "#, ); assert_eq!("(Wrapper, {unknown})", type_at_pos(&db, pos)); } #[test] fn infer_custom_derive_simple() { // FIXME: this test current now do nothing let (db, pos) = TestDB::with_position( r#" //- /main.rs crate:main use foo::Foo; #[derive(Foo)] struct S{} fn test() { S{}<|>; } "#, ); assert_eq!("S", type_at_pos(&db, pos)); } #[test] fn macro_in_arm() { assert_snapshot!( infer(r#" macro_rules! unit { () => { () }; } fn main() { let x = match () { unit!() => 92u32, }; } "#), @r###" 52..111 '{ ... }; }': () 62..63 'x': u32 66..108 'match ... }': u32 72..74 '()': () 85..92 'unit!()': () 96..101 '92u32': u32 "### ); }