Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 256 insertions, 0 deletions

diff --git a/src/tools/rustfmt/tests/target/closure.rs b/src/tools/rustfmt/tests/target/closure.rs
new file mode 100644
index 000000000..e8b4ff7a9
--- /dev/null
+++ b/src/tools/rustfmt/tests/target/closure.rs
@@ -0,0 +1,256 @@
+// 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
+        }
+    });
+
+    for<> || -> () {};
+    for<> || -> () {};
+    for<> || -> () {};
+
+    for<'a, 'b, 'c> |_: &'a (), _: &'b (), _: &'c ()| -> () {};
+}
+
+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()
+    })
+}
+
+fn issue2262() {
+    result
+        .init(&mut result.slave.borrow_mut(), &mut (result.strategy)())
+        .map_err(|factory| Error {
+            factory,
+            slave: None,
+        })?;
+}