Add a test

[rust.git] / tests / target / closure.rs

diff --git a/tests/target/closure.rs b/tests/target/closure.rs
index 146d967c8d5b44625855853dc416d0cb2f7a69fa..2005d85bf175fc26f088ba64f7fc64d57045e1de 100644 (file)
--- a/tests/target/closure.rs
+++ b/tests/target/closure.rs
@@ -1,3 +1,4 @@
+// rustfmt-normalize_comments: true
 // Closures
 
 fn main() {
@@ -9,7 +10,10 @@ fn main() {
                      b: WithType, // argument
                      // ignored
                      _| {
-        (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
+        (
+            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+            bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
+        )
     };
 
     let block_body = move |xxxxxxxxxxxxxxxxxxxxxxxxxxxxx,
@@ -18,19 +22,11 @@ fn main() {
     };
 
     let loooooooooooooong_name = |field| {
-             // TODO(#27): format comments.
+        // format comments.
         if field.node.attrs.len() > 0 {
-            field.node.attrs[0].span.lo
+            field.node.attrs[0].span.lo()
         } else {
-            field.span.lo
-        }
-    };
-
-    let block_me = |field| {
-        if true_story() {
-            1
-        } else {
-            2
+            field.span.lo()
         }
     };
 
@@ -38,7 +34,8 @@ fn main() {
 
     let empty = |arg| {};
 
-    let simple = |arg| { /* TODO(#27): comment formatting */
+    let simple = |arg| {
+        // comment formatting
         foo(arg)
     };
 
@@ -47,28 +44,33 @@ fn main() {
         do_something_else();
     };
 
-    let arg_test = |big_argument_name, test123| {
-        looooooooooooooooooong_function_naaaaaaaaaaaaaaaaame()
-    };
+    let arg_test =
+        |big_argument_name, test123| looooooooooooooooooong_function_naaaaaaaaaaaaaaaaame();
 
-    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()
-    };
+    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() {
@@ -76,3 +78,137 @@ fn issue311() {
 
     (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))
+    }
+}