Emit specific error for struct literal in conditions

src/librustc_borrowck/borrowck/mod.rs

@@ -897,8 +897,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                         self.cannot_borrow_path_as_mutable(error_span, &descr, Origin::Ast)
                     }
                     BorrowViolation(euv::ClosureInvocation) => {
-                        span_bug!(err.span,
-                            "err_mutbl with a closure invocation");
+                        span_bug!(err.span, "err_mutbl with a closure invocation");
                     }
                 };
 
@@ -1096,7 +1095,6 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
             BorrowViolation(euv::MatchDiscriminant) => {
                 "cannot borrow data mutably"
             }
-
             BorrowViolation(euv::ClosureInvocation) => {
                 is_closure = true;
                 "closure invocation"

src/librustc_resolve/diagnostics.rs

@@ -240,6 +240,56 @@ impl<'a> Resolver<'a> {
         (err, candidates)
     }
 
+    fn followed_by_brace(&self, span: Span) -> (bool, Option<(Span, String)>) {
+        // HACK(estebank): find a better way to figure out that this was a
+        // parser issue where a struct literal is being used on an expression
+        // where a brace being opened means a block is being started. Look
+        // ahead for the next text to see if `span` is followed by a `{`.
+        let sm = self.session.source_map();
+        let mut sp = span;
+        loop {
+            sp = sm.next_point(sp);
+            match sm.span_to_snippet(sp) {
+                Ok(ref snippet) => {
+                    if snippet.chars().any(|c| { !c.is_whitespace() }) {
+                        break;
+                    }
+                }
+                _ => break,
+            }
+        }
+        let followed_by_brace = match sm.span_to_snippet(sp) {
+            Ok(ref snippet) if snippet == "{" => true,
+            _ => false,
+        };
+        // In case this could be a struct literal that needs to be surrounded
+        // by parenthesis, find the appropriate span.
+        let mut i = 0;
+        let mut closing_brace = None;
+        loop {
+            sp = sm.next_point(sp);
+            match sm.span_to_snippet(sp) {
+                Ok(ref snippet) => {
+                    if snippet == "}" {
+                        let sp = span.to(sp);
+                        if let Ok(snippet) = sm.span_to_snippet(sp) {
+                            closing_brace = Some((sp, snippet));
+                        }
+                        break;
+                    }
+                }
+                _ => break,
+            }
+            i += 1;
+            // The bigger the span, the more likely we're incorrect --
+            // bound it to 100 chars long.
+            if i > 100 {
+                break;
+            }
+        }
+        return (followed_by_brace, closing_brace)
+    }
+
     /// Provides context-dependent help for errors reported by the `smart_resolve_path_fragment`
     /// function.
     /// Returns `true` if able to provide context-dependent help.
@@ -278,6 +328,39 @@ impl<'a> Resolver<'a> {
             _ => false,
         };
 
+        let mut bad_struct_syntax_suggestion = || {
+            let (followed_by_brace, closing_brace) = self.followed_by_brace(span);
+            let mut suggested = false;
+            match source {
+                PathSource::Expr(Some(parent)) => {
+                    suggested = path_sep(err, &parent);
+                }
+                PathSource::Expr(None) if followed_by_brace == true => {
+                    if let Some((sp, snippet)) = closing_brace {
+                        err.span_suggestion(
+                            sp,
+                            "surround the struct literal with parenthesis",
+                            format!("({})", snippet),
+                            Applicability::MaybeIncorrect,
+                        );
+                    } else {
+                        err.span_label(
+                            span,  // Note the parenthesis surrounding the suggestion below
+                            format!("did you mean `({} {{ /* fields */ }})`?", path_str),
+                        );
+                    }
+                    suggested = true;
+                },
+                _ => {}
+            }
+            if !suggested {
+                err.span_label(
+                    span,
+                    format!("did you mean `{} {{ /* fields */ }}`?", path_str),
+                );
+            }
+        };
+
         match (def, source) {
             (Def::Macro(..), _) => {
                 err.span_suggestion(
@@ -331,87 +414,13 @@ impl<'a> Resolver<'a> {
                         );
                     }
                 } else {
-                    // HACK(estebank): find a better way to figure out that this was a
-                    // parser issue where a struct literal is being used on an expression
-                    // where a brace being opened means a block is being started. Look
-                    // ahead for the next text to see if `span` is followed by a `{`.
-                    let sm = self.session.source_map();
-                    let mut sp = span;
-                    loop {
-                        sp = sm.next_point(sp);
-                        match sm.span_to_snippet(sp) {
-                            Ok(ref snippet) => {
-                                if snippet.chars().any(|c| { !c.is_whitespace() }) {
-                                    break;
-                                }
-                            }
-                            _ => break,
-                        }
-                    }
-                    let followed_by_brace = match sm.span_to_snippet(sp) {
-                        Ok(ref snippet) if snippet == "{" => true,
-                        _ => false,
-                    };
-                    // In case this could be a struct literal that needs to be surrounded
-                    // by parenthesis, find the appropriate span.
-                    let mut i = 0;
-                    let mut closing_brace = None;
-                    loop {
-                        sp = sm.next_point(sp);
-                        match sm.span_to_snippet(sp) {
-                            Ok(ref snippet) => {
-                                if snippet == "}" {
-                                    let sp = span.to(sp);
-                                    if let Ok(snippet) = sm.span_to_snippet(sp) {
-                                        closing_brace = Some((sp, snippet));
-                                    }
-                                    break;
-                                }
-                            }
-                            _ => break,
-                        }
-                        i += 1;
-                        // The bigger the span, the more likely we're incorrect --
-                        // bound it to 100 chars long.
-                        if i > 100 {
-                            break;
-                        }
-                    }
-                    match source {
-                        PathSource::Expr(Some(parent)) => if !path_sep(err, &parent) {
-                            err.span_label(
-                                span,
-                                format!("did you mean `{} {{ /* fields */ }}`?", path_str),
-                            );
-                        }
-                        PathSource::Expr(None) if followed_by_brace == true => {
-                            if let Some((sp, snippet)) = closing_brace {
-                                err.span_suggestion(
-                                    sp,
-                                    "surround the struct literal with parenthesis",
-                                    format!("({})", snippet),
-                                    Applicability::MaybeIncorrect,
-                                );
-                            } else {
-                                err.span_label(
-                                    span,
-                                    format!("did you mean `({} {{ /* fields */ }})`?", path_str),
-                                );
-                            }
-                        },
-                        _ => {
-                            err.span_label(
-                                span,
-                                format!("did you mean `{} {{ /* fields */ }}`?", path_str),
-                            );
-                        },
-                    }
+                    bad_struct_syntax_suggestion();
                 }
             }
             (Def::Union(..), _) |
             (Def::Variant(..), _) |
             (Def::Ctor(_, _, CtorKind::Fictive), _) if ns == ValueNS => {
-                err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", path_str));
+                bad_struct_syntax_suggestion();
             }
             (Def::SelfTy(..), _) if ns == ValueNS => {
                 err.span_label(span, fallback_label);

src/libsyntax/parse/parser.rs

@@ -2855,11 +2855,13 @@ impl<'a> Parser<'a> {
                         let (delim, tts) = self.expect_delimited_token_tree()?;
                         hi = self.prev_span;
                         ex = ExprKind::Mac(respan(lo.to(hi), Mac_ { path, tts, delim }));
-                    } else if self.check(&token::OpenDelim(token::Brace)) &&
-                              !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL) {
-                        // This is a struct literal, unless we're prohibited
-                        // from parsing struct literals here.
-                        return self.parse_struct_expr(lo, path, attrs);
+                    } else if self.check(&token::OpenDelim(token::Brace)) {
+                        if let Some(expr) = self.maybe_parse_struct_expr(lo, &path, &attrs) {
+                            return expr;
+                        } else {
+                            hi = path.span;
+                            ex = ExprKind::Path(None, path);
+                        }
                     } else {
                         hi = path.span;
                         ex = ExprKind::Path(None, path);
@@ -2902,6 +2904,47 @@ impl<'a> Parser<'a> {
         self.maybe_recover_from_bad_qpath(expr, true)
     }
 
+    fn maybe_parse_struct_expr(
+        &mut self,
+        lo: Span,
+        path: &ast::Path,
+        attrs: &ThinVec<Attribute>,
+    ) -> Option<PResult<'a, P<Expr>>> {
+        let struct_allowed = !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL);
+        let certainly_not_a_block = || self.look_ahead(1, |t| t.is_ident()) && (
+            // `{ ident, ` cannot start a block
+            self.look_ahead(2, |t| t == &token::Comma) ||
+            self.look_ahead(2, |t| t == &token::Colon) && (
+                // `{ ident: token, ` cannot start a block
+                self.look_ahead(4, |t| t == &token::Comma) ||
+                // `{ ident: ` cannot start a block unless it's a type ascription `ident: Type`
+                self.look_ahead(3, |t| !t.can_begin_type())
+            )
+        );
+
+        if struct_allowed || certainly_not_a_block() {
+            // This is a struct literal, but we don't can't accept them here
+            let expr = self.parse_struct_expr(lo, path.clone(), attrs.clone());
+            if let (Ok(expr), false) = (&expr, struct_allowed) {
+                let mut err = self.diagnostic().struct_span_err(
+                    expr.span,
+                    "struct literals are not allowed here",
+                );
+                err.multipart_suggestion(
+                    "surround the struct literal with parenthesis",
+                    vec![
+                        (lo.shrink_to_lo(), "(".to_string()),
+                        (expr.span.shrink_to_hi(), ")".to_string()),
+                    ],
+                    Applicability::MachineApplicable,
+                );
+                err.emit();
+            }
+            return Some(expr);
+        }
+        None
+    }
+
     fn parse_struct_expr(&mut self, lo: Span, pth: ast::Path, mut attrs: ThinVec<Attribute>)
                          -> PResult<'a, P<Expr>> {
         let struct_sp = lo.to(self.prev_span);

src/test/ui/error-codes/E0423.rs

@@ -10,15 +10,13 @@ fn bar() {
     struct T {}
 
     if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
-    //~^ ERROR E0423
-    //~|  expected type, found `1`
+    //~^ ERROR struct literals are not allowed here
     if T {} == T {} { println!("Ok"); }
     //~^ ERROR E0423
     //~| ERROR expected expression, found `==`
 }
 
 fn foo() {
     for _ in std::ops::Range { start: 0, end: 10 } {}
-    //~^ ERROR E0423
-    //~| ERROR expected type, found `0`
+    //~^ ERROR struct literals are not allowed here
 }

src/test/ui/error-codes/E0423.stderr

@@ -1,36 +1,28 @@
-error: expected type, found `1`
-  --> $DIR/E0423.rs:12:39
+error: struct literals are not allowed here
+  --> $DIR/E0423.rs:12:32
    |
 LL |     if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
-   |                                       ^ expecting a type here because of type ascription
-   |
-   = note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
-note: this expression expects an ascribed type after the colon
-  --> $DIR/E0423.rs:12:36
+   |                                ^^^^^^^^^^^^^^^^
+help: surround the struct literal with parenthesis
    |
-LL |     if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
-   |                                    ^
-   = help: this might be indicative of a syntax error elsewhere
+LL |     if let S { x: _x, y: 2 } = (S { x: 1, y: 2 }) { println!("Ok"); }
+   |                                ^                ^
 
 error: expected expression, found `==`
-  --> $DIR/E0423.rs:15:13
+  --> $DIR/E0423.rs:14:13
    |
 LL |     if T {} == T {} { println!("Ok"); }
    |             ^^ expected expression
 
-error: expected type, found `0`
-  --> $DIR/E0423.rs:21:39
+error: struct literals are not allowed here
+  --> $DIR/E0423.rs:20:14
    |
 LL |     for _ in std::ops::Range { start: 0, end: 10 } {}
-   |                                       ^ expecting a type here because of type ascription
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: surround the struct literal with parenthesis
    |
-   = note: type ascription is a nightly-only feature that lets you annotate an expression with a type: `<expr>: <type>`
-note: this expression expects an ascribed type after the colon
-  --> $DIR/E0423.rs:21:32
-   |
-LL |     for _ in std::ops::Range { start: 0, end: 10 } {}
-   |                                ^^^^^
-   = help: this might be indicative of a syntax error elsewhere
+LL |     for _ in (std::ops::Range { start: 0, end: 10 }) {}
+   |              ^                                     ^
 
 error[E0423]: expected function, found struct `Foo`
   --> $DIR/E0423.rs:4:13
@@ -41,30 +33,14 @@ LL |     let f = Foo();
    |             did you mean `Foo { /* fields */ }`?
    |             help: a function with a similar name exists: `foo`
 
-error[E0423]: expected value, found struct `S`
-  --> $DIR/E0423.rs:12:32
-   |
-LL |     if let S { x: _x, y: 2 } = S { x: 1, y: 2 } { println!("Ok"); }
-   |                                ^---------------
-   |                                |
-   |                                help: surround the struct literal with parenthesis: `(S { x: 1, y: 2 })`
-
 error[E0423]: expected value, found struct `T`
-  --> $DIR/E0423.rs:15:8
+  --> $DIR/E0423.rs:14:8
    |
 LL |     if T {} == T {} { println!("Ok"); }
    |        ^---
    |        |
    |        help: surround the struct literal with parenthesis: `(T {})`
 
-error[E0423]: expected value, found struct `std::ops::Range`
-  --> $DIR/E0423.rs:21:14
-   |
-LL |     for _ in std::ops::Range { start: 0, end: 10 } {}
-   |              ^^^^^^^^^^^^^^^----------------------
-   |              |
-   |              help: surround the struct literal with parenthesis: `(std::ops::Range { start: 0, end: 10 })`
-
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0423`.

src/test/ui/parser/struct-literal-in-for.rs

@@ -9,9 +9,9 @@ impl Foo {
 }
 
 fn main() {
-    for x in Foo { //~ ERROR expected value, found struct `Foo`
-        x: 3    //~ ERROR expected type, found `3`
-    }.hi() { //~ ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `{`
+    for x in Foo { //~ ERROR struct literals are not allowed here
+        x: 3       //~^ ERROR `bool` is not an iterator
+    }.hi() {
         println!("yo");
     }
 }