Google Git Google Git
Sign in
rust/rust/fc5a7077ca43894de1ea0d3f9f56ac627ceef5c7/./src/tools/rustfmt/tests/target/macros.rs
blob: 7b4574349df3ec046cb1dd84c595c0bdffd6fce2 [file]
// rustfmt-normalize_comments: true
// rustfmt-format_macro_matchers: true
itemmacro!(this, is.now().formatted(yay));
itemmacro!(
really,
long.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbb()
.is
.formatted()
);
itemmacro! {this, is.brace().formatted()}
fn main() {
foo!();
foo!(,);
bar!(a, b, c);
bar!(a, b, c,);
baz!(1 + 2 + 3, quux.kaas());
quux!(
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA,
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
);
kaas!(
// comments
a, // post macro
b // another
);
trailingcomma!(a, b, c,);
// Preserve trailing comma only when necessary.
ok!(file.seek(SeekFrom::Start(
table.map(|table| fixture.offset(table)).unwrap_or(0),
)));
noexpr!( i am not an expression, OK? );
vec![a, b, c];
vec![
AAAAAA,
AAAAAA,
AAAAAA,
AAAAAA,
AAAAAA,
AAAAAA,
AAAAAA,
AAAAAA,
AAAAAA,
BBBBB,
5,
100 - 30,
1.33,
b,
b,
b,
];
vec![a /* comment */];
// Trailing spaces after a comma
vec![a];
vec![a; b];
vec![a; b];
vec![a; b];
vec![a, b; c];
vec![a; b, c];
vec![
a;
(|x| {
let y = x + 1;
let z = y + 1;
z
})(2)
];
vec![
a;
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
];
vec![a; unsafe { x + 1 }];
unknown_bracket_macro__comma_should_not_be_stripped![a,];
foo(makro!(1, 3));
hamkaas! { () };
macrowithbraces! {dont, format, me}
x!(fn);
some_macro!();
some_macro![];
some_macro! {
// comment
};
some_macro! {
// comment
};
some_macro!(
// comment
not function like
);
// #1712
let image = gray_image!(
00, 01, 02;
10, 11, 12;
20, 21, 22);
// #1092
chain!(input, a:take!(max_size), || []);
// #2727
foo!("bar");
}
impl X {
empty_invoc! {}
empty_invoc! {}
}
fn issue_1279() {
println!("dsfs"); // a comment
}
fn issue_1555() {
let hello = &format!(
"HTTP/1.1 200 OK\r\nServer: {}\r\n\r\n{}",
"65454654654654654654654655464", "4"
);
}
fn issue1178() {
macro_rules! foo {
(#[$attr:meta] $name:ident) => {};
}
foo!(
#[doc = "bar"]
baz
);
}
fn issue1739() {
sql_function!(add_rss_item,
add_rss_item_t,
(a: types::Integer,
b: types::Timestamptz,
c: types::Text,
d: types::Text,
e: types::Text));
w.slice_mut(s![
..,
init_size[1] - extreeeeeeeeeeeeeeeeeeeeeeeem..init_size[1],
..
])
.par_map_inplace(|el| *el = 0.);
}
fn issue_1885() {
let threads = people
.into_iter()
.map(|name| {
chan_select! {
rx.recv() => {}
}
})
.collect::<Vec<_>>();
}
fn issue_1917() {
mod x {
quickcheck! {
fn test(a: String, s: String, b: String) -> TestResult {
if a.find(&s).is_none() {
TestResult::from_bool(true)
} else {
TestResult::discard()
}
}
}
}
}
fn issue_1921() {
// Macro with tabs.
lazy_static! {
static ref ONE: u32 = 1;
static ref TWO: u32 = 2;
static ref THREE: u32 = 3;
static ref FOUR: u32 = {
let mut acc = 1;
acc += 1;
acc += 2;
acc
};
}
}
// #1577
fn issue1577() {
let json = json!({
"foo": "bar",
});
}
// #3174
fn issue_3174() {
let data = if let Some(debug) = error.debug_info() {
json!({
"errorKind": format!("{:?}", error.err_kind()),
"debugMessage": debug.message,
})
} else {
json!({"errorKind": format!("{:?}", error.err_kind())})
};
}
gfx_pipeline!(pipe {
vbuf: gfx::VertexBuffer<Vertex> = (),
out: gfx::RenderTarget<ColorFormat> = "Target0",
});
// #1919
#[test]
fn __bindgen_test_layout_HandleWithDtor_open0_int_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<HandleWithDtor<::std::os::raw::c_int>>(),
8usize,
concat!(
"Size of template specialization: ",
stringify!(HandleWithDtor<::std::os::raw::c_int>)
)
);
assert_eq!(
::std::mem::align_of::<HandleWithDtor<::std::os::raw::c_int>>(),
8usize,
concat!(
"Alignment of template specialization: ",
stringify!(HandleWithDtor<::std::os::raw::c_int>)
)
);
}
// #878
macro_rules! try_opt {
($expr:expr) => {
match $expr {
Some(val) => val,
None => {
return None;
}
}
};
}
// #2214
// macro call whose argument is an array with trailing comma.
fn issue2214() {
make_test!(
str_searcher_ascii_haystack,
"bb",
"abbcbbd",
[
Reject(0, 1),
Match(1, 3),
Reject(3, 4),
Match(4, 6),
Reject(6, 7),
]
);
}
fn special_case_macros() {
let p = eprint!();
let q = eprint!("{}", 1);
let r = eprint!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
let s = eprint!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
let q = eprintln!("{}", 1);
let r = eprintln!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
let s = eprintln!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
let q = format!("{}", 1);
let r = format!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
let s = format!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
let q = format_args!("{}", 1);
let r = format_args!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
let s = format_args!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
let q = print!("{}", 1);
let r = print!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
let s = print!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
let q = println!("{}", 1);
let r = println!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
let s = println!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
let q = unreachable!("{}", 1);
let r = unreachable!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
let s = unreachable!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
debug!("{}", 1);
debug!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
debug!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
error!("{}", 1);
error!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
error!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
info!("{}", 1);
info!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
info!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
panic!("{}", 1);
panic!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
panic!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
warn!("{}", 1);
warn!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
);
warn!(
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
assert!();
assert!(result == 42);
assert!(result == 42, "Ahoy there, {}!", target);
assert!(
result == 42,
"Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
result,
input,
expected
);
assert!(
result == 42,
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
assert_eq!();
assert_eq!(left);
assert_eq!(left, right);
assert_eq!(left, right, "Ahoy there, {}!", target);
assert_eq!(
left, right,
"Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
result, input, expected
);
assert_eq!(
first_realllllllllllly_long_variable_that_doesnt_fit_one_one_line,
second_reallllllllllly_long_variable_that_doesnt_fit_one_one_line,
"Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
result,
input,
expected
);
assert_eq!(
left + 42,
right,
"Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
result,
input,
expected
);
assert_eq!(
left,
right,
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
write!(&mut s, "Ahoy there, {}!", target);
write!(
&mut s,
"Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
result, input, expected
);
write!(
&mut s,
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
writeln!(&mut s, "Ahoy there, {}!", target);
writeln!(
&mut s,
"Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
result, input, expected
);
writeln!(
&mut s,
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26
);
}
// #1209
impl Foo {
/// foo
pub fn foo(&self) -> Bar<foo!()> {}
}
// #819
fn macro_in_pattern_position() {
let x = match y {
foo!() => (),
bar!(a, b, c) => (),
bar!(a, b, c,) => (),
baz!(1 + 2 + 3, quux.kaas()) => (),
quux!(
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA,
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
) => (),
};
}
macro foo() {}
pub macro bar($x:ident + $y:expr;) {
fn foo($x: Foo) {
long_function(
a_long_argument_to_a_long_function_is_what_this_is(AAAAAAAAAAAAAAAAAAAAAAAAAAAA),
$x.bar($y),
);
}
}
macro foo() {
// a comment
fn foo() {
// another comment
bar();
}
}
// #2574
macro_rules! test {
() => {{}};
}
macro lex_err($kind: ident $(, $body: expr)*) {
Err(QlError::LexError(LexError::$kind($($body,)*)))
}
// Preserve trailing comma on item-level macro with `()` or `[]`.
methods![get, post, delete,];
methods!(get, post, delete,);
// #2588
macro_rules! m {
() => {
r#"
test
"#
};
}
fn foo() {
f! {r#"
test
"#};
}
// #2591
fn foo() {
match 0u32 {
0 => (),
_ => unreachable!(/* obviously */),
}
}
fn foo() {
let _ = column!(/* here */);
}
// #2616
// Preserve trailing comma when using mixed layout for macro call.
fn foo() {
foo!(
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
);
foo!(
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
);
}
// #2830
// Preserve trailing comma-less/ness inside nested macro.
named!(
do_parse_gsv<GsvData>,
map_res!(
do_parse!(
number_of_sentences: map_res!(digit, parse_num::<u16>)
>> char!(',')
>> sentence_index: map_res!(digit, parse_num::<u16>)
>> char!(',')
>> total_number_of_sats: map_res!(digit, parse_num::<u16>)
>> char!(',')
>> sat0: opt!(complete!(parse_gsv_sat_info))
>> sat1: opt!(complete!(parse_gsv_sat_info))
>> sat2: opt!(complete!(parse_gsv_sat_info))
>> sat3: opt!(complete!(parse_gsv_sat_info))
>> (
number_of_sentences,
sentence_index,
total_number_of_sats,
sat0,
sat1,
sat2,
sat3
)
),
construct_gsv_data
)
);
// #2857
convert_args!(vec!(1, 2, 3));
// #3031
thread_local!(
/// TLV Holds a set of JSTraceables that need to be rooted
static ROOTED_TRACEABLES: RefCell<RootedTraceableSet> = RefCell::new(RootedTraceableSet::new());
);
thread_local![
/// TLV Holds a set of JSTraceables that need to be rooted
static ROOTED_TRACEABLES: RefCell<RootedTraceableSet> = RefCell::new(RootedTraceableSet::new());
/// TLV Holds a set of JSTraceables that need to be rooted
static ROOTED_TRACEABLES: RefCell<RootedTraceableSet> =
RefCell::new(RootedTraceableSet::new(0));
/// TLV Holds a set of JSTraceables that need to be rooted
static ROOTED_TRACEABLES: RefCell<RootedTraceableSet> =
RefCell::new(RootedTraceableSet::new(), xxx, yyy);
/// TLV Holds a set of JSTraceables that need to be rooted
static ROOTED_TRACEABLES: RefCell<RootedTraceableSet> =
RefCell::new(RootedTraceableSet::new(1234));
];
fn issue3004() {
foo!(|_| { () });
stringify!((foo+));
}
// #3331
pub fn fold_abi<V: Fold + ?Sized>(_visitor: &mut V, _i: Abi) -> Abi {
Abi {
extern_token: Token![extern](tokens_helper(_visitor, &_i.extern_token.span)),
name: (_i.name).map(|it| _visitor.fold_lit_str(it)),
}
}
// #3463
x! {()}
// #3746
f!(match a {
4 => &[
(3, false), // Missing
(4, true) // I-frame
][..],
});
// #3583
foo!(|x = y|);