rust/tests/ui/parser/attr-stmt-expr-attr-bad.stderr

error: expected expression, found `]`
  --> $DIR/attr-stmt-expr-attr-bad.rs:3:40
   |
LL | #[cfg(FALSE)] fn e() { let _ = [#[attr]]; }
   |                                        ^ expected expression

error: expected one of `!`, `.`, `::`, `;`, `?`, `else`, `{`, or an operator, found `#`
  --> $DIR/attr-stmt-expr-attr-bad.rs:5:35
   |
LL | #[cfg(FALSE)] fn e() { let _ = foo#[attr](); }
   |                                   ^ expected one of 8 possible tokens

error: an inner attribute is not permitted in this context
  --> $DIR/attr-stmt-expr-attr-bad.rs:7:36
   |
LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
   |                                    ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted in this context
  --> $DIR/attr-stmt-expr-attr-bad.rs:9:36
   |
LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
   |                                    ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: expected expression, found `)`
  --> $DIR/attr-stmt-expr-attr-bad.rs:7:44
   |
LL | #[cfg(FALSE)] fn e() { let _ = foo(#![attr]); }
   |                                            ^ expected expression

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:10:38
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:13:38
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
   |                                      ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: expected expression, found `)`
  --> $DIR/attr-stmt-expr-attr-bad.rs:13:46
   |
LL | #[cfg(FALSE)] fn e() { let _ = x.foo(#![attr]); }
   |                                              ^ expected expression

error: an inner attribute is not permitted in this context
  --> $DIR/attr-stmt-expr-attr-bad.rs:16:36
   |
LL | #[cfg(FALSE)] fn e() { let _ = 0 + #![attr] 0; }
   |                                    ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted in this context
  --> $DIR/attr-stmt-expr-attr-bad.rs:18:33
   |
LL | #[cfg(FALSE)] fn e() { let _ = !#![attr] 0; }
   |                                 ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted in this context
  --> $DIR/attr-stmt-expr-attr-bad.rs:20:33
   |
LL | #[cfg(FALSE)] fn e() { let _ = -#![attr] 0; }
   |                                 ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: expected one of `!`, `.`, `::`, `;`, `?`, `else`, `{`, or an operator, found `#`
  --> $DIR/attr-stmt-expr-attr-bad.rs:22:34
   |
LL | #[cfg(FALSE)] fn e() { let _ = x #![attr] as Y; }
   |                                  ^ expected one of 8 possible tokens

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:21:35
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:24:35
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] foo; }
   |                                   ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:23:40
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:26:40
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] foo; }
   |                                        ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:25:35
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:28:35
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = || #![attr] {foo}; }
   |                                   ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:27:40
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:30:40
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = move || #![attr] {foo}; }
   |                                        ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: expected expression, found `..`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:29:40
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:32:40
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] ..#[attr] 0; }
   |                                        ^^ expected expression

error: expected expression, found `..`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:31:40
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:34:40
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] ..; }
   |                                        ^^ expected expression

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:33:41
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:36:41
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &#![attr] 0; }
   |                                         ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:35:45
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:38:45
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = #[attr] &mut #![attr] 0; }
   |                                             ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: outer attributes are not allowed on `if` and `else` branches
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:37:37
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:40:37
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if 0 #[attr] {}; }
   |                                --   ^^^^^^^ -- the attributes are attached to this branch
   |                                |    |
   |                                |    help: remove the attributes
   |                                the branch belongs to this `if`

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:39:38
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:42:38
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {#![attr]}; }
   |                                      ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:41:40
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:44:40
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} #[attr] else {}; }
   |                                        ^ expected one of `.`, `;`, `?`, `else`, or an operator

error: outer attributes are not allowed on `if` and `else` branches
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:43:45
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:46:45
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] {}; }
   |                                        ---- ^^^^^^^ -- the attributes are attached to this branch
   |                                        |    |
   |                                        |    help: remove the attributes
   |                                        the branch belongs to this `else`

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:45:46
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:48:46
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else {#![attr]}; }
   |                                              ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: outer attributes are not allowed on `if` and `else` branches
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:47:45
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:50:45
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else #[attr] if 0 {}; }
   |                                        ---- ^^^^^^^ ------- the attributes are attached to this branch
   |                                        |    |
   |                                        |    help: remove the attributes
   |                                        the branch belongs to this `else`

error: outer attributes are not allowed on `if` and `else` branches
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:49:50
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:52:50
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 #[attr] {}; }
   |                                             --   ^^^^^^^ -- the attributes are attached to this branch
   |                                             |    |
   |                                             |    help: remove the attributes
   |                                             the branch belongs to this `if`

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:51:51
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:54:51
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if 0 {} else if 0 {#![attr]}; }
   |                                                   ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: outer attributes are not allowed on `if` and `else` branches
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:53:45
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:56:45
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 #[attr] {}; }
   |                                --           ^^^^^^^ -- the attributes are attached to this branch
   |                                |            |
   |                                |            help: remove the attributes
   |                                the branch belongs to this `if`

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:55:46
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:58:46
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {#![attr]}; }
   |                                              ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:57:48
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:60:48
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} #[attr] else {}; }
   |                                                ^ expected one of `.`, `;`, `?`, `else`, or an operator

error: outer attributes are not allowed on `if` and `else` branches
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:59:53
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:62:53
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] {}; }
   |                                                ---- ^^^^^^^ -- the attributes are attached to this branch
   |                                                |    |
   |                                                |    help: remove the attributes
   |                                                the branch belongs to this `else`

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:61:54
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:64:54
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else {#![attr]}; }
   |                                                      ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: outer attributes are not allowed on `if` and `else` branches
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:63:53
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:66:53
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else #[attr] if let _ = 0 {}; }
   |                                                ---- ^^^^^^^ --------------- the attributes are attached to this branch
   |                                                |    |
   |                                                |    help: remove the attributes
   |                                                the branch belongs to this `else`

error: outer attributes are not allowed on `if` and `else` branches
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:65:66
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:68:66
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 #[attr] {}; }
   |                                                     --           ^^^^^^^ -- the attributes are attached to this branch
   |                                                     |            |
   |                                                     |            help: remove the attributes
   |                                                     the branch belongs to this `if`

error: an inner attribute is not permitted in this context
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:67:67
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:70:67
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = if let _ = 0 {} else if let _ = 0 {#![attr]}; }
   |                                                                   ^^^^^^^^
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted following an outer attribute
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:70:32
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:73:32
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] let _ = 0; }
   |                        ------- ^^^^^^^^ not permitted following an outer attribute
   |                        |
   |                        previous outer attribute
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted following an outer attribute
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:72:32
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:75:32
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] 0; }
   |                        ------- ^^^^^^^^ not permitted following an outer attribute
   |                        |
   |                        previous outer attribute
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
   = note: outer attributes, like `#[test]`, annotate the item following them

error: an inner attribute is not permitted following an outer attribute
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:74:32
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:77:32
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
   |                        ------- ^^^^^^^^ ------- the inner attribute doesn't annotate this item macro invocation
   |                        |       |
   |                        |       not permitted following an outer attribute
   |                        previous outer attribute
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
help: to annotate the item macro invocation, change the attribute from inner to outer style
   |
LL - #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!(); }
   |

error: an inner attribute is not permitted following an outer attribute
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:76:32
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:79:32
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
   |                        ------- ^^^^^^^^ ------- the inner attribute doesn't annotate this item macro invocation
   |                        |       |
   |                        |       not permitted following an outer attribute
   |                        previous outer attribute
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
help: to annotate the item macro invocation, change the attribute from inner to outer style
   |
LL - #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo![]; }
   |

error: an inner attribute is not permitted following an outer attribute
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:78:32
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:81:32
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
   |                        ------- ^^^^^^^^ ------ the inner attribute doesn't annotate this item macro invocation
   |                        |       |
   |                        |       not permitted following an outer attribute
   |                        previous outer attribute
   |
   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
help: to annotate the item macro invocation, change the attribute from inner to outer style
   |
LL - #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!{}; }
   |

error[E0586]: inclusive range with no end
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:84:35
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:87:35
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
   |                                   ^^^ help: use `..` instead
   |
   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

error: expected one of `=>`, `if`, or `|`, found `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:84:38
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:87:38
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
   |                                      ^ expected one of `=>`, `if`, or `|`

error[E0586]: inclusive range with no end
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:87:35
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:90:35
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
   |                                   ^^^ help: use `..` instead
   |
   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

error: expected one of `=>`, `if`, or `|`, found `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:87:38
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:90:38
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
   |                                      ^ expected one of `=>`, `if`, or `|`

error: unexpected token: `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:90:39
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:93:39
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=-#[attr] 10 => () } }
   |                                       ^

error[E0586]: inclusive range with no end
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:92:35
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:95:35
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
   |                                   ^^^ help: use `..` instead
   |
   = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

error: expected one of `=>`, `if`, or `|`, found `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:92:38
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:95:38
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
   |                                      ^ expected one of `=>`, `if`, or `|`

error: unexpected token: `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:96:34
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:99:34
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
   |                                  ^

error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:96:34
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:99:34
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
   |                                  ^ expected one of `.`, `;`, `?`, `else`, or an operator

error: unexpected token: `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:99:34
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:102:34
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
   |                                  ^

error: expected one of `.`, `;`, `?`, `else`, or an operator, found `#`
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:99:34
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:102:34
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
   |                                  ^ expected one of `.`, `;`, `?`, `else`, or an operator

error: expected statement after outer attribute
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:104:37
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:107:37
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr]; } } }
   |                                     ^^^^^^^

error: expected statement after outer attribute
<<<<<<< HEAD
  --> $DIR/attr-stmt-expr-attr-bad.rs:106:37
=======
  --> $DIR/attr-stmt-expr-attr-bad.rs:109:37
>>>>>>> 30182b1d322 (Rip it out)
   |
LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr] } } }
   |                                     ^^^^^^^

<<<<<<< HEAD
error: aborting due to 52 previous errors
=======
error: aborting due to 54 previous errors
>>>>>>> 30182b1d322 (Rip it out)

For more information about this error, try `rustc --explain E0586`.