rust/tests/target/closure.rs
Seiichi Uchida 9ea3e65df6 Update tests
2017-11-30 06:10:59 +09:00

243 lines
5.7 KiB
Rust

// rustfmt-normalize_comments: true
// Closures
fn main() {
let square = (|i: i32| i * i);
let commented = |// first
a, // argument
// second
b: WithType, // argument
// ignored
_| {
(
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
)
};
let block_body = move |xxxxxxxxxxxxxxxxxxxxxxxxxxxxx,
ref yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy| {
xxxxxxxxxxxxxxxxxxxxxxxxxxxxx + yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy
};
let loooooooooooooong_name = |field| {
// format comments.
if field.node.attrs.len() > 0 {
field.node.attrs[0].span.lo()
} else {
field.span.lo()
}
};
let unblock_me = |trivial| closure();
let empty = |arg| {};
let simple = |arg| {
// comment formatting
foo(arg)
};
let test = || {
do_something();
do_something_else();
};
let arg_test =
|big_argument_name, test123| looooooooooooooooooong_function_naaaaaaaaaaaaaaaaame();
let arg_test =
|big_argument_name, test123| looooooooooooooooooong_function_naaaaaaaaaaaaaaaaame();
let simple_closure = move || -> () {};
let closure = |input: Ty| -> Option<String> { foo() };
let closure_with_return_type =
|aaaaaaaaaaaaaaaaaaaaaaarg1, aaaaaaaaaaaaaaaaaaaaaaarg2| -> Strong { "sup".to_owned() };
|arg1, arg2, _, _, arg3, arg4| {
let temp = arg4 + arg3;
arg2 * arg1 - temp
};
let block_body_with_comment = args.iter().map(|a| {
// Emitting only dep-info is possible only for final crate type, as
// as others may emit required metadata for dependent crate types
if a.starts_with("--emit") && is_final_crate_type && !self.workspace_mode {
"--emit=dep-info"
} else {
a
}
});
}
fn issue311() {
let func = |x| println!("{}", x);
(func)(0.0);
}
fn issue863() {
let closure = |x| match x {
0 => true,
_ => false,
} == true;
}
fn issue934() {
let hash: &Fn(&&Block) -> u64 = &|block| -> u64 {
let mut h = SpanlessHash::new(cx);
h.hash_block(block);
h.finish()
};
let hash: &Fn(&&Block) -> u64 = &|block| -> u64 {
let mut h = SpanlessHash::new(cx);
h.hash_block(block);
h.finish();
};
}
impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
pub fn eq_expr(&self, left: &Expr, right: &Expr) -> bool {
match (&left.node, &right.node) {
(&ExprBinary(l_op, ref ll, ref lr), &ExprBinary(r_op, ref rl, ref rr)) => {
l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
|| swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| {
l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
})
}
}
}
}
fn foo() {
lifetimes_iter___map(|lasdfasfd| {
let hi = if l.bounds.is_empty() {
l.lifetime.span.hi()
};
});
}
fn issue1405() {
open_raw_fd(fd, b'r').and_then(|file| {
Capture::new_raw(None, |_, err| unsafe {
raw::pcap_fopen_offline(file, err)
})
});
}
fn issue1466() {
let vertex_buffer = frame.scope(|ctx| {
let buffer = ctx.create_host_visible_buffer::<VertexBuffer<Vertex>>(&vertices);
ctx.create_device_local_buffer(buffer)
});
}
fn issue470() {
{
{
{
let explicit_arg_decls = explicit_arguments.into_iter().enumerate().map(
|(index, (ty, pattern))| {
let lvalue = Lvalue::Arg(index as u32);
block = this.pattern(
block,
argument_extent,
hair::PatternRef::Hair(pattern),
&lvalue,
);
ArgDecl { ty: ty }
},
);
}
}
}
}
// #1509
impl Foo {
pub fn bar(&self) {
Some(SomeType {
push_closure_out_to_100_chars: iter(otherwise_it_works_ok.into_iter().map(|f| Ok(f))),
})
}
}
fn issue1329() {
aaaaaaaaaaaaaaaa
.map(|x| {
x += 1;
x
})
.filter
}
fn issue325() {
let f = || unsafe {
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
};
}
fn issue1697() {
Test.func_a(
A_VERY_LONG_CONST_VARIABLE_NAME,
move |arg1, arg2, arg3, arg4| arg1 + arg2 + arg3 + arg4,
)
}
fn issue1694() {
foooooo(
|_referencefffffffff: _, _target_reference: _, _oid: _, _target_oid: _| {
format!("refs/pull/{}/merge", pr_id)
},
)
}
fn issue1713() {
rayon::join(
|| recurse(left, is_less, pred, limit),
|| recurse(right, is_less, Some(pivot), limit),
);
rayon::join(
1,
|| recurse(left, is_less, pred, limit),
2,
|| recurse(right, is_less, Some(pivot), limit),
);
}
fn issue2063() {
|ctx: Ctx<(String, String)>| -> io::Result<Response> {
Ok(Response::new().with_body(ctx.params.0))
}
}
fn issue1524() {
let f = |x| x;
let f = |x| x;
let f = |x| x;
let f = |x| x;
let f = |x| x;
}
fn issue2171() {
foo(|| unsafe {
if PERIPHERALS {
loop {}
} else {
PERIPHERALS = true;
}
})
}
fn issue2207() {
a.map(|_| {
unsafe { a_very_very_very_very_very_very_very_long_function_name_or_anything_else() }
.to_string()
})
}