---

yaml
---
r: 7016
b: refs/heads/master
c: 43a9d50
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: de383bcfedc5ac67c6a27c51f1a8226f5a9bdcd0
+refs/heads/master: 43a9d50a74096c73f268f0600f6b1287a1cee880

trunk/src/test/run-pass/block-arg-as-stmt.rs

@@ -0,0 +1,25 @@
+
+fn compute1() -> float {
+    let v = [0f, 1f, 2f, 3f];
+
+    // Here the "-10f" parses as a second
+    // statement in tail position:
+    vec::foldl(0f, v) { |x, y| x + y } - 10f
+}
+
+fn compute2() -> float {
+    let v = [0f, 1f, 2f, 3f];
+
+    // Here the ret makes this explicit:
+    ret vec::foldl(0f, v) { |x, y| x + y } - 10f;
+}
+
+fn main() {
+    let x = compute1();
+    log(debug, x);
+    assert(x == -10f);
+
+    let y = compute2();
+    log(debug, y);
+    assert(y == -4f);
+}

trunk/src/test/run-pass/block-arg-can-be-followed-by-binop.rs

@@ -0,0 +1,8 @@
+fn main() {
+    let v = [-1f, 0f, 1f, 2f, 3f];
+
+    // Trailing expressions require parentheses:
+    let y = vec::foldl(0f, v) { |x, y| x + y } + 10f;
+
+    assert y == 15f;
+}

trunk/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs

@@ -0,0 +1,6 @@
+fn main() {
+    fn f(i: block() -> uint) -> uint { i() }
+    let v = [-1f, 0f, 1f, 2f, 3f];
+    let z = vec::foldl(f, v) { |x, _y| x } { || 22u };
+    assert z == 22u;
+}

trunk/src/test/run-pass/block-arg-can-be-followed-by-call.rs

@@ -0,0 +1,6 @@
+fn main() {
+    fn f(i: uint) -> uint { i }
+    let v = [-1f, 0f, 1f, 2f, 3f];
+    let z = vec::foldl(f, v) { |x, _y| x } (22u);
+    assert z == 22u;
+}

trunk/src/test/run-pass/block-arg-in-parentheses.rs

@@ -0,0 +1,23 @@
+// xfail-test
+
+// FIXME: Parser doesn't distinguish expression in parentheses (as in
+// this example) from one that is not!  It is somewhat of a pain to
+// fix this though there are no theoretical difficulties.  We could
+// either add paren to the AST (better for pretty-print, I suppose) or
+// modify the parser to track whether the expression in question is
+// parenthesized.  I did the latter once and it was a bit of pain but
+// not terribly difficult.  We could also the decision as to whether
+// something is an "expression with a value" down into the
+// parse_expr() codepath, where we *know* if there are parentheses or
+// not, but we'd probably have to be a bit more careful then with
+// clearing the top-level restrction flag (which we ought to do
+// anyhow!)
+
+fn main() {
+    let v = [1f, 2f, 3f];
+    let w =
+        if true { (vec::any(v) { |e| float::nonnegative(e) }) }
+        else { false };
+    assert w;
+}
+

trunk/src/test/run-pass/block-arg-in-ternary.rs

@@ -0,0 +1,6 @@
+// Allow block arguments with ternary... why not, no chance of ambig.
+fn main() {
+    let v = [-1f, 1f];
+    let foo = vec::any(v) { |e| float::negative(e) } ? true : false;
+    assert foo;
+}

trunk/src/test/run-pass/block-arg.rs

@@ -0,0 +1,52 @@
+// Check usage and precedence of block arguments in expressions:
+fn main() {
+    let v = [-1f, 0f, 1f, 2f, 3f];
+
+    // Statement form does not require parentheses:
+    vec::iter(v) { |i|
+        log(info, i);
+    }
+
+    // Usable at all:
+    let any_negative = vec::any(v) { |e| float::negative(e) };
+    assert any_negative;
+
+    // Higher precedence than assignments:
+    any_negative = vec::any(v) { |e| float::negative(e) };
+    assert any_negative;
+
+    // Higher precedence than unary operations:
+    let abs_v = vec::map(v) { |e| float::abs(e) };
+    assert vec::all(abs_v) { |e| float::nonnegative(e) };
+    assert !vec::any(abs_v) { |e| float::negative(e) };
+
+    // Usable in funny statement-like forms:
+    if !vec::any(v) { |e| float::positive(e) } {
+        assert false;
+    }
+    alt vec::all(v) { |e| float::negative(e) } {
+        true { fail "incorrect answer."; }
+        false { }
+    }
+    alt 3 {
+      _ when vec::any(v) { |e| float::negative(e) } {
+      }
+      _ {
+        fail "wrong answer.";
+      }
+    }
+
+
+    // Lower precedence than binary operations:
+    let w = vec::foldl(0f, v, { |x, y| x + y }) + 10f;
+    let y = vec::foldl(0f, v) { |x, y| x + y } + 10f;
+    let z = 10f + vec::foldl(0f, v) { |x, y| x + y };
+    assert w == y;
+    assert y == z;
+
+    // They are not allowed as the tail of a block without parentheses:
+    let w =
+      if true { vec::any(abs_v, { |e| float::nonnegative(e) }) }
+      else { false };
+    assert w;
+}