Brace-ident-colon can certainly no longer start a block

fmease · fmease · commit 82796dd8585c · 2025-03-25T15:15:21.000+01:00
thanks to the removal of type ascription.
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
@@ -3474,19 +3474,9 @@ impl<'a> Parser<'a> {
     }
 
     fn is_certainly_not_a_block(&self) -> bool {
+        // `{ ident, ` and `{ ident: ` cannot start 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())
-                        )
-            )
+            && self.look_ahead(2, |t| t == &token::Comma || t == &token::Colon)
     }
 
     fn maybe_parse_struct_expr(
diff --git a/tests/ui/parser/issues/issue-111692.rs b/tests/ui/parser/issues/issue-111692.rs
@@ -9,23 +9,25 @@ mod module {
 }
 
 fn test(x: module::Type) {
-    if x == module::Type { x: module::C, y: 1 } { //~ ERROR invalid struct literal
+    if x == module::Type { x: module::C, y: 1 } { //~ ERROR struct literals are not allowed here
     }
 }
 
 fn test2(x: module::Type) {
-    if x ==module::Type { x: module::C, y: 1 } { //~ ERROR invalid struct literal
+    if x ==module::Type { x: module::C, y: 1 } { //~ ERROR struct literals are not allowed here
     }
 }
 
 
 fn test3(x: module::Type) {
-    if x == Type { x: module::C, y: 1 } { //~ ERROR invalid struct literal
+    use module::Type;
+    if x == Type { x: module::C, y: 1 } { //~ ERROR struct literals are not allowed here
     }
 }
 
 fn test4(x: module::Type) {
-    if x == demo_module::Type { x: module::C, y: 1 } { //~ ERROR invalid struct literal
+    use module as demo_module;
+    if x == demo_module::Type { x: module::C, y: 1 } { //~ ERROR struct literals are not allowed here
     }
 }
 
diff --git a/tests/ui/parser/issues/issue-111692.stderr b/tests/ui/parser/issues/issue-111692.stderr
@@ -1,43 +1,43 @@
-error: invalid struct literal
-  --> $DIR/issue-111692.rs:12:21
+error: struct literals are not allowed here
+  --> $DIR/issue-111692.rs:12:13
    |
 LL |     if x == module::Type { x: module::C, y: 1 } {
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: you might need to surround the struct literal with parentheses
+help: surround the struct literal with parentheses
    |
 LL |     if x == (module::Type { x: module::C, y: 1 }) {
    |             +                                   +
 
-error: invalid struct literal
-  --> $DIR/issue-111692.rs:17:20
+error: struct literals are not allowed here
+  --> $DIR/issue-111692.rs:17:12
    |
 LL |     if x ==module::Type { x: module::C, y: 1 } {
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: you might need to surround the struct literal with parentheses
+help: surround the struct literal with parentheses
    |
 LL |     if x ==(module::Type { x: module::C, y: 1 }) {
    |            +                                   +
 
-error: invalid struct literal
-  --> $DIR/issue-111692.rs:23:13
+error: struct literals are not allowed here
+  --> $DIR/issue-111692.rs:24:13
    |
 LL |     if x == Type { x: module::C, y: 1 } {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: you might need to surround the struct literal with parentheses
+help: surround the struct literal with parentheses
    |
 LL |     if x == (Type { x: module::C, y: 1 }) {
    |             +                           +
 
-error: invalid struct literal
-  --> $DIR/issue-111692.rs:28:26
+error: struct literals are not allowed here
+  --> $DIR/issue-111692.rs:30:13
    |
 LL |     if x == demo_module::Type { x: module::C, y: 1 } {
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: you might need to surround the struct literal with parentheses
+help: surround the struct literal with parentheses
    |
 LL |     if x == (demo_module::Type { x: module::C, y: 1 }) {
    |             +                                        +
diff --git a/tests/ui/parser/method-call-on-struct-literal-in-if-condition.rs b/tests/ui/parser/method-call-on-struct-literal-in-if-condition.rs
@@ -7,7 +7,7 @@ impl Example {
 fn one() -> i32 { 1 }
 
 fn main() {
-    if Example { a: one(), }.is_pos() { //~ ERROR invalid struct literal
+    if Example { a: one(), }.is_pos() { //~ ERROR struct literals are not allowed here
         println!("Positive!");
     }
 }
diff --git a/tests/ui/parser/method-call-on-struct-literal-in-if-condition.stderr b/tests/ui/parser/method-call-on-struct-literal-in-if-condition.stderr
@@ -1,10 +1,10 @@
-error: invalid struct literal
+error: struct literals are not allowed here
   --> $DIR/method-call-on-struct-literal-in-if-condition.rs:10:8
    |
 LL |     if Example { a: one(), }.is_pos() {
    |        ^^^^^^^^^^^^^^^^^^^^^
    |
-help: you might need to surround the struct literal with parentheses
+help: surround the struct literal with parentheses
    |
 LL |     if (Example { a: one(), }).is_pos() {
    |        +                     +
diff --git a/tests/ui/parser/type-ascription-in-pattern.rs b/tests/ui/parser/type-ascription-in-pattern.rs
@@ -1,11 +1,10 @@
 fn foo(x: bool) -> i32 {
-    match x {
+    match x { //~ ERROR struct literals are not allowed here
         x: i32 => x, //~ ERROR expected
-        //~^ ERROR mismatched types
-        true => 42.,
-        false => 0.333,
+        true => 42., //~ ERROR expected identifier
+        false => 0.333, //~ ERROR expected identifier
     }
-}
+} //~ ERROR expected one of
 
 fn main() {
     match foo(true) {
diff --git a/tests/ui/parser/type-ascription-in-pattern.stderr b/tests/ui/parser/type-ascription-in-pattern.stderr
@@ -1,34 +1,80 @@
-error: expected one of `@` or `|`, found `:`
-  --> $DIR/type-ascription-in-pattern.rs:3:10
+error: expected one of `!`, `,`, `.`, `::`, `?`, `{`, `}`, or an operator, found `=>`
+  --> $DIR/type-ascription-in-pattern.rs:3:16
    |
+LL |     match x {
+   |           - while parsing this struct
 LL |         x: i32 => x,
-   |          ^ --- specifying the type of a pattern isn't supported
-   |          |
-   |          expected one of `@` or `|`
+   |               -^^ expected one of 8 possible tokens
+   |               |
+   |               help: try adding a comma: `,`
+
+error: expected identifier, found keyword `true`
+  --> $DIR/type-ascription-in-pattern.rs:4:9
    |
-help: maybe write a path separator here
+LL |     match x {
+   |           - while parsing this struct
+LL |         x: i32 => x,
+LL |         true => 42.,
+   |         ^^^^ expected identifier, found keyword
+
+error: expected identifier, found keyword `false`
+  --> $DIR/type-ascription-in-pattern.rs:5:9
    |
-LL |         x::i32 => x,
-   |          ~~
+LL |     match x {
+   |           - while parsing this struct
+...
+LL |         false => 0.333,
+   |         ^^^^^ expected identifier, found keyword
+
+error: struct literals are not allowed here
+  --> $DIR/type-ascription-in-pattern.rs:2:11
+   |
+LL |       match x {
+   |  ___________^
+LL | |         x: i32 => x,
+LL | |         true => 42.,
+LL | |         false => 0.333,
+LL | |     }
+   | |_____^
+   |
+help: surround the struct literal with parentheses
+   |
+LL ~     match (x {
+LL |         x: i32 => x,
+LL |         true => 42.,
+LL |         false => 0.333,
+LL ~     })
+   |
+
+error: expected one of `.`, `?`, `{`, or an operator, found `}`
+  --> $DIR/type-ascription-in-pattern.rs:7:1
+   |
+LL |     match x {
+   |     ----- while parsing this `match` expression
+...
+LL |     }
+   |      - expected one of `.`, `?`, `{`, or an operator
+LL | }
+   | ^ unexpected token
 
 error: expected one of `...`, `..=`, `..`, or `|`, found `:`
-  --> $DIR/type-ascription-in-pattern.rs:12:11
+  --> $DIR/type-ascription-in-pattern.rs:11:11
    |
 LL |         42: i32 => (),
    |           ^ --- specifying the type of a pattern isn't supported
    |           |
    |           expected one of `...`, `..=`, `..`, or `|`
 
 error: expected `|`, found `:`
-  --> $DIR/type-ascription-in-pattern.rs:13:10
+  --> $DIR/type-ascription-in-pattern.rs:12:10
    |
 LL |         _: f64 => (),
    |          ^ --- specifying the type of a pattern isn't supported
    |          |
    |          expected `|`
 
 error: expected one of `@` or `|`, found `:`
-  --> $DIR/type-ascription-in-pattern.rs:14:10
+  --> $DIR/type-ascription-in-pattern.rs:13:10
    |
 LL |         x: i32 => (),
    |          ^ --- specifying the type of a pattern isn't supported
@@ -40,15 +86,5 @@ help: maybe write a path separator here
 LL |         x::i32 => (),
    |          ~~
 
-error[E0308]: mismatched types
-  --> $DIR/type-ascription-in-pattern.rs:3:19
-   |
-LL | fn foo(x: bool) -> i32 {
-   |                    --- expected `i32` because of return type
-LL |     match x {
-LL |         x: i32 => x,
-   |                   ^ expected `i32`, found `bool`
-
-error: aborting due to 5 previous errors
+error: aborting due to 8 previous errors
 
-For more information about this error, try `rustc --explain E0308`.

Original file line number	Diff line number	Diff line change
`@@ -9,23 +9,25 @@ mod module {`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`fn test(x: module::Type) {`
`12`		`- if x == module::Type { x: module::C, y: 1 } { //~ ERROR invalid struct literal`
	`12`	`+ if x == module::Type { x: module::C, y: 1 } { //~ ERROR struct literals are not allowed here`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`fn test2(x: module::Type) {`
`17`		`- if x ==module::Type { x: module::C, y: 1 } { //~ ERROR invalid struct literal`
	`17`	`+ if x ==module::Type { x: module::C, y: 1 } { //~ ERROR struct literals are not allowed here`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`21`	`21`
`22`	`22`	`fn test3(x: module::Type) {`
`23`		`- if x == Type { x: module::C, y: 1 } { //~ ERROR invalid struct literal`
	`23`	`+ use module::Type;`
	`24`	`+ if x == Type { x: module::C, y: 1 } { //~ ERROR struct literals are not allowed here`
`24`	`25`	`}`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`fn test4(x: module::Type) {`
`28`		`- if x == demo_module::Type { x: module::C, y: 1 } { //~ ERROR invalid struct literal`
	`29`	`+ use module as demo_module;`
	`30`	`+ if x == demo_module::Type { x: module::C, y: 1 } { //~ ERROR struct literals are not allowed here`
`29`	`31`	`}`
`30`	`32`	`}`
`31`	`33`
Original file line number	Diff line number	Diff line change
`@@ -1,43 +1,43 @@`
`1`		`-error: invalid struct literal`
`2`		`- --> $DIR/issue-111692.rs:12:21`
	`1`	`+error: struct literals are not allowed here`
	`2`	`+ --> $DIR/issue-111692.rs:12:13`
`3`	`3`	`\|`
`4`	`4`	`LL \| if x == module::Type { x: module::C, y: 1 } {`
`5`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^`
	`5`	`+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`		`-help: you might need to surround the struct literal with parentheses`
	`7`	`+help: surround the struct literal with parentheses`
`8`	`8`	`\|`
`9`	`9`	`LL \| if x == (module::Type { x: module::C, y: 1 }) {`
`10`	`10`	`\| + +`
`11`	`11`
`12`		`-error: invalid struct literal`
`13`		`- --> $DIR/issue-111692.rs:17:20`
	`12`	`+error: struct literals are not allowed here`
	`13`	`+ --> $DIR/issue-111692.rs:17:12`
`14`	`14`	`\|`
`15`	`15`	`LL \| if x ==module::Type { x: module::C, y: 1 } {`
`16`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^`
	`16`	`+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`17`	`17`	`\|`
`18`		`-help: you might need to surround the struct literal with parentheses`
	`18`	`+help: surround the struct literal with parentheses`
`19`	`19`	`\|`
`20`	`20`	`LL \| if x ==(module::Type { x: module::C, y: 1 }) {`
`21`	`21`	`\| + +`
`22`	`22`
`23`		`-error: invalid struct literal`
`24`		`- --> $DIR/issue-111692.rs:23:13`
	`23`	`+error: struct literals are not allowed here`
	`24`	`+ --> $DIR/issue-111692.rs:24:13`
`25`	`25`	`\|`
`26`	`26`	`LL \| if x == Type { x: module::C, y: 1 } {`
`27`	`27`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`28`	`28`	`\|`
`29`		`-help: you might need to surround the struct literal with parentheses`
	`29`	`+help: surround the struct literal with parentheses`
`30`	`30`	`\|`
`31`	`31`	`LL \| if x == (Type { x: module::C, y: 1 }) {`
`32`	`32`	`\| + +`
`33`	`33`
`34`		`-error: invalid struct literal`
`35`		`- --> $DIR/issue-111692.rs:28:26`
	`34`	`+error: struct literals are not allowed here`
	`35`	`+ --> $DIR/issue-111692.rs:30:13`
`36`	`36`	`\|`
`37`	`37`	`LL \| if x == demo_module::Type { x: module::C, y: 1 } {`
`38`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^`
	`38`	`+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`39`	`39`	`\|`
`40`		`-help: you might need to surround the struct literal with parentheses`
	`40`	`+help: surround the struct literal with parentheses`
`41`	`41`	`\|`
`42`	`42`	`LL \| if x == (demo_module::Type { x: module::C, y: 1 }) {`
`43`	`43`	`\| + +`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ impl Example {`
`7`	`7`	`fn one() -> i32 { 1 }`
`8`	`8`
`9`	`9`	`fn main() {`
`10`		`- if Example { a: one(), }.is_pos() { //~ ERROR invalid struct literal`
	`10`	`+ if Example { a: one(), }.is_pos() { //~ ERROR struct literals are not allowed here`
`11`	`11`	`println!("Positive!");`
`12`	`12`	`}`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,10 @@`
`1`		`-error: invalid struct literal`
	`1`	`+error: struct literals are not allowed here`
`2`	`2`	`--> $DIR/method-call-on-struct-literal-in-if-condition.rs:10:8`
`3`	`3`	`\|`
`4`	`4`	`LL \| if Example { a: one(), }.is_pos() {`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`		`-help: you might need to surround the struct literal with parentheses`
	`7`	`+help: surround the struct literal with parentheses`
`8`	`8`	`\|`
`9`	`9`	`LL \| if (Example { a: one(), }).is_pos() {`
`10`	`10`	`\| + +`