Do not complain about type ascription on likely incorrect struct literal

Author: estebank

src/librustc_resolve/lib.rs

@@ -3222,11 +3222,30 @@ impl<'a> Resolver<'a> {
         let is_expected = &|def| source.is_expected(def);
 
         let report_errors = |this: &mut Self, def: Option<Def>| {
-            let (err, candidates) = this.smart_resolve_report_errors(path, span, source, def);
-            let def_id = this.current_module.normal_ancestor_id;
-            let node_id = this.definitions.as_local_node_id(def_id).unwrap();
-            let better = def.is_some();
-            this.use_injections.push(UseError { err, candidates, node_id, better });
+            let mut report = true;
+
+            if let &[segment] = path {
+                if this.session.parse_sess.missing_ident_could_be_struct_literal
+                    .borrow().contains(&segment.ident.span)
+                {
+                    for sp in this.session.possible_struct_literal.borrow().iter() {
+                        if sp.overlaps(segment.ident.span) {
+                            // Ignore errors caused by likely struct literals. An error has
+                            // already been emitted suggesting surrounding struct literal with
+                            // `()` in a case like `if x == E::V { field: field } {}`
+                            report = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            if report {
+                let (err, candidates) = this.smart_resolve_report_errors(path, span, source, def);
+                let def_id = this.current_module.normal_ancestor_id;
+                let node_id = this.definitions.as_local_node_id(def_id).unwrap();
+                let better = def.is_some();
+                this.use_injections.push(UseError { err, candidates, node_id, better });
+            }
             err_path_resolution()
         };
 

src/libsyntax/parse/parser.rs

@@ -2922,18 +2922,27 @@ impl<'a> Parser<'a> {
             )
         );
         // could be a block but we won't know until type-checking
-        if self.look_ahead(1, |t| t.is_ident()) && (
-            // foo { bar }
-            self.look_ahead(2, |t| t == &token::CloseDelim(token::Brace)) ||
-            // foo { bar: baz }
-            self.look_ahead(2, |t| t == &token::Colon)
-        ) {
+        // foo { bar }
+        if self.look_ahead(1, |t| t.is_ident()) &&
+            self.look_ahead(2, |t| t == &token::CloseDelim(token::Brace))
+        {
             self.look_ahead(1, |t| {
                 if let token::Ident(ident, _) = t {
                     self.sess.missing_ident_could_be_struct_literal.borrow_mut().insert(ident.span);
                 }
             });
         }
+        // foo { bar: baz }
+        if self.look_ahead(1, |t| t.is_ident()) &&
+            self.look_ahead(2, |t| t == &token::Colon) &&
+            self.look_ahead(3, |t| t.is_ident())
+        {
+            self.look_ahead(3, |t| {
+                if let token::Ident(ident, _) = t {
+                    self.sess.missing_ident_could_be_struct_literal.borrow_mut().insert(ident.span);
+                }
+            });
+        }
 
         if struct_allowed || certainly_not_a_block() {
             // This is a struct literal, but we don't can't accept them here

src/test/ui/struct-literal-variant-in-if.rs

@@ -9,6 +9,8 @@ fn test_E(x: E) {
     let field = true;
     if x == E::V { field } {}
     //~^ ERROR expected value, found struct variant `E::V`
+    if x == E::V { field: field } {}
+    //~^ ERROR expected value, found struct variant `E::V`
     if x == E::I { field1: true, field2: 42 } {}
     //~^ ERROR struct literals are not allowed here
     if x == E::V { field: false } {}

src/test/ui/struct-literal-variant-in-if.stderr

@@ -1,5 +1,5 @@
 error: struct literals are not allowed here
-  --> $DIR/struct-literal-variant-in-if.rs:12:13
+  --> $DIR/struct-literal-variant-in-if.rs:14:13
    |
 LL |     if x == E::I { field1: true, field2: 42 } {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL |     if x == (E::I { field1: true, field2: 42 }) {}
    |             ^                                 ^
 
 error: struct literals are not allowed here
-  --> $DIR/struct-literal-variant-in-if.rs:14:13
+  --> $DIR/struct-literal-variant-in-if.rs:16:13
    |
 LL |     if x == E::V { field: false } {}
    |             ^^^^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     if x == (E::V { field: false }) {}
    |             ^                     ^
 
 error: struct literals are not allowed here
-  --> $DIR/struct-literal-variant-in-if.rs:16:13
+  --> $DIR/struct-literal-variant-in-if.rs:18:13
    |
 LL |     if x == E::J { field: -42 } {}
    |             ^^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |     if x == (E::J { field: -42 }) {}
    |             ^                   ^
 
 error: struct literals are not allowed here
-  --> $DIR/struct-literal-variant-in-if.rs:18:13
+  --> $DIR/struct-literal-variant-in-if.rs:20:13
    |
 LL |     if x == E::K { field: "" } {}
    |             ^^^^^^^^^^^^^^^^^^
@@ -46,16 +46,24 @@ LL |     if x == E::V { field } {}
    |             |
    |             help: surround the struct literal with parenthesis: `(E::V { field })`
 
+error[E0423]: expected value, found struct variant `E::V`
+  --> $DIR/struct-literal-variant-in-if.rs:12:13
+   |
+LL |     if x == E::V { field: field } {}
+   |             ^^^^-----------------
+   |             |
+   |             help: surround the struct literal with parenthesis: `(E::V { field: field })`
+
 error[E0308]: mismatched types
-  --> $DIR/struct-literal-variant-in-if.rs:20:20
+  --> $DIR/struct-literal-variant-in-if.rs:22:20
    |
 LL |     let y: usize = ();
    |                    ^^ expected usize, found ()
    |
    = note: expected type `usize`
               found type `()`
 
-error: aborting due to 6 previous errors
+error: aborting due to 7 previous errors
 
 Some errors have detailed explanations: E0308, E0423.
 For more information about an error, try `rustc --explain E0308`.