mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use expect-test for builtin macro/derive tests

Browse Source
This commit is contained in:
Jonas Schievink 2021-03-10 21:05:02 +01:00
parent 6c32e2d8a0
commit bc4ecb199b
4 changed files with 66 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -526,6 +526,7 @@ dependencies = [
"base_db",
"cfg",
"either",
"expect-test",
"la-arena",
"log",
"mbe",

1
crates/hir_expand/Cargo.toml
View File

@ -25,3 +25,4 @@ mbe = { path = "../mbe", version = "0.0.0" }
[dev-dependencies]
test_utils = { path = "../test_utils" }
expect-test = "1.1"

66
crates/hir_expand/src/builtin_derive.rs
View File

@ -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 @@ fn expand_builtin_derive(s: &str, name: Name) -> String {
//- /lib.rs crate:core
// empty
"#,
s
ra_fixture
);
let (db, file_pos) = TestDB::with_position(&fixture);
@ -314,66 +315,57 @@ fn expand_builtin_derive(s: &str, name: Name) -> String {
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>{}"]],
);
}
}

78
crates/hir_expand/src/builtin_macro.rs
View File

@ -491,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;
@ -574,87 +575,86 @@ fn expand_builtin_macro(ra_fixture: &str) -> String {
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 {
@ -663,14 +663,13 @@ macro_rules! assert {
}
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 {
@ -679,15 +678,14 @@ macro_rules! compile_error {
}
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 {
@ -696,17 +694,15 @@ macro_rules! format_args {
}
format_args!("{} {:?}", arg1(a, b, c), arg2);
"#,
);
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),])"#
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),])"#
]],
);
}
#[test]
fn test_format_args_expand_with_comma_exprs() {
let expanded = expand_builtin_macro(
check_expansion(
r#"
#[rustc_builtin_macro]
macro_rules! format_args {
@ -715,17 +711,15 @@ macro_rules! format_args {
}
format_args!("{} {:?}", a::<A,B>(), b);
"#,
);
assert_eq!(
expanded,
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),])"#
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 {
@ -734,21 +728,19 @@ macro_rules! include_bytes {
}
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""#);
}
}