---

yaml
---
r: 152901
b: refs/heads/try2
c: 64019e7
h: refs/heads/master
i:
  152899: 1890590
v: v3

Author: huonw

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d0983872efeea757600031a081a2eff9676fe895
+refs/heads/try2: 64019e764f1837a4a19297fc9f7a99595e37cf51
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide.md

@@ -411,64 +411,3 @@ rest of your Rust career.
 
 Next, we'll learn more about Rust itself, by starting to write a more complicated
 program. We hope you want to do more with Rust than just print "Hello, world!"
-
-## If
-
-## Functions
-
-return
-
-comments
-
-## Testing
-
-attributes
-
-stability markers
-
-## Crates and Modules
-
-visibility
-
-## Compound Data Types
-
-Tuples
-
-Structs
-
-Enums
-
-## Match
-
-## Looping
-
-for
-
-while
-
-loop
-
-break/continue
-
-iterators
-
-## Lambdas
-
-## Generics
-
-## Traits
-
-## Operators and built-in Traits
-
-## Ownership and Lifetimes
-
-Move vs. Copy
-
-Allocation
-
-## Tasks
-
-## Macros
-
-## Unsafe
-

branches/try2/src/doc/tutorial.md

@@ -493,12 +493,11 @@ by an *action* (expression). Each case is separated by commas. It is
 often convenient to use a block expression for each case, in which case
 the commas are optional as shown below. Literals are valid patterns and
 match only their own value. A single arm may match multiple different
-patterns by combining them with the pipe operator (`|`), so long as
-every pattern binds the same set of variables (see "destructuring"
-below). Ranges of numeric literal patterns can be expressed with two
-dots, as in `M..N`. The underscore (`_`) is a wildcard pattern that
-matches any single value. (`..`) is a different wildcard that can match
-one or more fields in an `enum` variant.
+patterns by combining them with the pipe operator (`|`), so long as every
+pattern binds the same set of variables. Ranges of numeric literal
+patterns can be expressed with two dots, as in `M..N`. The underscore
+(`_`) is a wildcard pattern that matches any single value. (`..`) is a
+different wildcard that can match one or more fields in an `enum` variant.
 
 ~~~
 # let my_number = 1;

branches/try2/src/librustc/lint/builtin.rs

@@ -975,14 +975,52 @@ declare_lint!(UNNECESSARY_PARENS, Warn,
 pub struct UnnecessaryParens;
 
 impl UnnecessaryParens {
-    fn check_unnecessary_parens_core(&self, cx: &Context, value: &ast::Expr, msg: &str) {
+    fn check_unnecessary_parens_core(&self, cx: &Context, value: &ast::Expr, msg: &str,
+                                     struct_lit_needs_parens: bool) {
         match value.node {
-            ast::ExprParen(_) => {
-                cx.span_lint(UNNECESSARY_PARENS, value.span,
-                    format!("unnecessary parentheses around {}", msg).as_slice())
+            ast::ExprParen(ref inner) => {
+                let necessary = struct_lit_needs_parens && contains_exterior_struct_lit(&**inner);
+                if !necessary {
+                    cx.span_lint(UNNECESSARY_PARENS, value.span,
+                                 format!("unnecessary parentheses around {}",
+                                         msg).as_slice())
+                }
             }
             _ => {}
         }
+
+        /// Expressions that syntatically contain an "exterior" struct
+        /// literal i.e. not surrounded by any parens or other
+        /// delimiters, e.g. `X { y: 1 }`, `X { y: 1 }.method()`, `foo
+        /// == X { y: 1 }` and `X { y: 1 } == foo` all do, but `(X {
+        /// y: 1 }) == foo` does not.
+        fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
+            match value.node {
+                ast::ExprStruct(..) => true,
+
+                ast::ExprAssign(ref lhs, ref rhs) |
+                ast::ExprAssignOp(_, ref lhs, ref rhs) |
+                ast::ExprBinary(_, ref lhs, ref rhs) => {
+                    // X { y: 1 } + X { y: 2 }
+                    contains_exterior_struct_lit(&**lhs) ||
+                        contains_exterior_struct_lit(&**rhs)
+                }
+                ast::ExprUnary(_, ref x) |
+                ast::ExprCast(ref x, _) |
+                ast::ExprField(ref x, _, _) |
+                ast::ExprIndex(ref x, _) => {
+                    // &X { y: 1 }, X { y: 1 }.y
+                    contains_exterior_struct_lit(&**x)
+                }
+
+                ast::ExprMethodCall(_, _, ref exprs) => {
+                    // X { y: 1 }.bar(...)
+                    contains_exterior_struct_lit(&**exprs.get(0))
+                }
+
+                _ => false
+            }
+        }
     }
 }
 
@@ -992,16 +1030,16 @@ impl LintPass for UnnecessaryParens {
     }
 
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
-        let (value, msg) = match e.node {
-            ast::ExprIf(cond, _, _) => (cond, "`if` condition"),
-            ast::ExprWhile(cond, _) => (cond, "`while` condition"),
-            ast::ExprMatch(head, _) => (head, "`match` head expression"),
-            ast::ExprRet(Some(value)) => (value, "`return` value"),
-            ast::ExprAssign(_, value) => (value, "assigned value"),
-            ast::ExprAssignOp(_, _, value) => (value, "assigned value"),
+        let (value, msg, struct_lit_needs_parens) = match e.node {
+            ast::ExprIf(cond, _, _) => (cond, "`if` condition", true),
+            ast::ExprWhile(cond, _) => (cond, "`while` condition", true),
+            ast::ExprMatch(head, _) => (head, "`match` head expression", true),
+            ast::ExprRet(Some(value)) => (value, "`return` value", false),
+            ast::ExprAssign(_, value) => (value, "assigned value", false),
+            ast::ExprAssignOp(_, _, value) => (value, "assigned value", false),
             _ => return
         };
-        self.check_unnecessary_parens_core(cx, &*value, msg);
+        self.check_unnecessary_parens_core(cx, &*value, msg, struct_lit_needs_parens);
     }
 
     fn check_stmt(&mut self, cx: &Context, s: &ast::Stmt) {
@@ -1015,7 +1053,7 @@ impl LintPass for UnnecessaryParens {
             },
             _ => return
         };
-        self.check_unnecessary_parens_core(cx, &*value, msg);
+        self.check_unnecessary_parens_core(cx, &*value, msg, false);
     }
 }
 

branches/try2/src/test/compile-fail/lint-unnecessary-parens.rs

@@ -10,18 +10,41 @@
 
 #![deny(unnecessary_parens)]
 
+#[deriving(Eq, PartialEq)]
+struct X { y: bool }
+impl X {
+    fn foo(&self) -> bool { self.y }
+}
+
 fn foo() -> int {
     return (1); //~ ERROR unnecessary parentheses around `return` value
 }
+fn bar() -> X {
+    return (X { y: true }); //~ ERROR unnecessary parentheses around `return` value
+}
 
 fn main() {
     foo();
+    bar();
 
     if (true) {} //~ ERROR unnecessary parentheses around `if` condition
     while (true) {} //~ ERROR unnecessary parentheses around `while` condition
     match (true) { //~ ERROR unnecessary parentheses around `match` head expression
         _ => {}
     }
+    let v = X { y: false };
+    // struct lits needs parens, so these shouldn't warn.
+    if (v == X { y: true }) {}
+    if (X { y: true } == v) {}
+    if (X { y: false }.y) {}
+
+    while (X { y: false }.foo()) {}
+    while (true | X { y: false }.y) {}
+
+    match (X { y: false }) {
+        _ => {}
+    }
+
     let mut _a = (0); //~ ERROR unnecessary parentheses around assigned value
     _a = (0); //~ ERROR unnecessary parentheses around assigned value
     _a += (1); //~ ERROR unnecessary parentheses around assigned value