From b7f043eeb785abefe472d34b7934bfda029aef5c Mon Sep 17 00:00:00 2001
From: Graydon Hoare <graydon@mozilla.com>
Date: Tue, 14 Jun 2011 17:07:22 -0700
Subject: [PATCH] Add new testcase to show the nature of our exciting
 block-expr / trailing unop interaction.

---
 src/test/run-pass/block-expr-precedence.rs | 51 ++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 src/test/run-pass/block-expr-precedence.rs

diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs
new file mode 100644
index 00000000000..9e9a01c6e66
--- /dev/null
+++ b/src/test/run-pass/block-expr-precedence.rs
@@ -0,0 +1,51 @@
+/*
+ *
+ *  When you write a block-expression thing followed by
+ *  a lone unary operator, you can get a surprising parse:
+ *
+ *  if (...) { ... }
+ *  -num;
+ *
+ * for example, or:
+ *
+ *  if (...) { ... }
+ *  *box;
+ *
+ * These will parse as subtraction and multiplication binops.
+ * To get them to parse "the way you want" you need to brace
+ * the leading unops:
+
+ *  if (...) { ... }
+ *  {-num};
+ *
+ * or alternatively, semi-separate them:
+ *
+ *  if (...) { ... };
+ *  -num;
+ *
+ * This seems a little wonky, but the alternative is to lower
+ * precedence of such block-like exprs to the point where
+ * you have to parenthesize them to get them to occur in the
+ * RHS of a binop. For example, you'd have to write:
+ *
+ *   12 + (if (foo) { 13 } else { 14 });
+ *
+ * rather than:
+ *
+ *   12 + if (foo) { 13 } else { 14 };
+ *
+ * Since we want to maintain the ability to write the latter,
+ * we leave the parens-burden on the trailing unop case.
+ *
+ */
+
+fn main() {
+
+  auto num = 12;
+
+  assert if (true) { 12 } else { 12 } - num == 0;
+  assert 12 - if (true) { 12 } else { 12 } == 0;
+  if (true) { 12 } {-num};
+  if (true) { 12 }; {-num};
+  if (true) { 12 };;; -num;
+}