src/test/ui/parser/attr-stmt-expr-attr-bad.stderr - third_party/rust - Git at Google

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

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

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

 error: an inner attribute is not permitted in this context
   --> $DIR/attr-stmt-expr-attr-bad.rs:11: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. Outer attributes, like `#[test]`, annotate the item following them.

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

 error: an inner attribute is not permitted in this context
   --> $DIR/attr-stmt-expr-attr-bad.rs:14:38
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: expected expression, found `)`
   --> $DIR/attr-stmt-expr-attr-bad.rs:14: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:17: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. 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:19: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. 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:21: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. Outer attributes, like `#[test]`, annotate the item following them.

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

 error: an inner attribute is not permitted in this context
   --> $DIR/attr-stmt-expr-attr-bad.rs:25:35
    |
 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. 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:27:40
    |
 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. 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:29:35
    |
 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. 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:31:40
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

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

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

 error: an inner attribute is not permitted in this context
   --> $DIR/attr-stmt-expr-attr-bad.rs:37:41
    |
 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. 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:39:45
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: outer attributes are not allowed on `if` and `else` branches
   --> $DIR/attr-stmt-expr-attr-bad.rs:41:37
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:43:38
    |
 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. 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:45:40
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:47:45
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:49:46
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: outer attributes are not allowed on `if` and `else` branches
   --> $DIR/attr-stmt-expr-attr-bad.rs:51:45
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:53:50
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:55:51
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: outer attributes are not allowed on `if` and `else` branches
   --> $DIR/attr-stmt-expr-attr-bad.rs:57:45
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:59:46
    |
 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. 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:61:48
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:63:53
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:65:54
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: outer attributes are not allowed on `if` and `else` branches
   --> $DIR/attr-stmt-expr-attr-bad.rs:67:53
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:69:66
    |
 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
   --> $DIR/attr-stmt-expr-attr-bad.rs:71:67
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: an inner attribute is not permitted following an outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:74:32
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: an inner attribute is not permitted following an outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:76:32
    |
 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: an inner attribute is not permitted following an outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:78:32
    |
 LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
    |                        ------- ^^^^^^^^ 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: an inner attribute is not permitted following an outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:80:32
    |
 LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
    |                        ------- ^^^^^^^^ 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. Outer attributes, like `#[test]`, annotate the item following them.

 error: an inner attribute is not permitted following an outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:82:32
    |
 LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
    |                        ------- ^^^^^^^^ 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. Outer attributes, like `#[test]`, annotate the item following them.

 error[E0586]: inclusive range with no end
   --> $DIR/attr-stmt-expr-attr-bad.rs:88:35
    |
 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 `#`
   --> $DIR/attr-stmt-expr-attr-bad.rs:88:38
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
    |                                      ^ expected one of `=>`, `if`, or `|`

 error[E0586]: inclusive range with no end
   --> $DIR/attr-stmt-expr-attr-bad.rs:91:35
    |
 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 `#`
   --> $DIR/attr-stmt-expr-attr-bad.rs:91:38
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
    |                                      ^ expected one of `=>`, `if`, or `|`

 error: unexpected token: `#`
   --> $DIR/attr-stmt-expr-attr-bad.rs:94:39
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=-#[attr] 10 => () } }
    |                                       ^

 error[E0586]: inclusive range with no end
   --> $DIR/attr-stmt-expr-attr-bad.rs:96:35
    |
 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 `#`
   --> $DIR/attr-stmt-expr-attr-bad.rs:96:38
    |
 LL | #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
    |                                      ^ expected one of `=>`, `if`, or `|`

 error: unexpected token: `#`
   --> $DIR/attr-stmt-expr-attr-bad.rs:100:34
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
    |                                  ^

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

 error: unexpected token: `#`
   --> $DIR/attr-stmt-expr-attr-bad.rs:103:34
    |
 LL | #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
    |                                  ^

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

 error: expected statement after outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:108:37
    |
 LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr]; } } }
    |                                     ^^^^^^^

 error: expected statement after outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:110:37
    |
 LL | #[cfg(FALSE)] fn e() { { fn foo() { #[attr] } } }
    |                                     ^^^^^^^

 error: aborting due to 53 previous errors

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

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

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

	error: an inner attribute is not permitted in this context
	--> $DIR/attr-stmt-expr-attr-bad.rs:11: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. Outer attributes, like `#[test]`, annotate the item following them.

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

	error: an inner attribute is not permitted in this context
	--> $DIR/attr-stmt-expr-attr-bad.rs:14:38
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

	error: expected expression, found `)`
	--> $DIR/attr-stmt-expr-attr-bad.rs:14: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:17: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. 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:19: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. 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:21: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. Outer attributes, like `#[test]`, annotate the item following them.

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

	error: an inner attribute is not permitted in this context
	--> $DIR/attr-stmt-expr-attr-bad.rs:25:35
	\|
	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. 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:27:40
	\|
	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. 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:29:35
	\|
	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. 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:31:40
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

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

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

	error: an inner attribute is not permitted in this context
	--> $DIR/attr-stmt-expr-attr-bad.rs:37:41
	\|
	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. 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:39:45
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

	error: outer attributes are not allowed on `if` and `else` branches
	--> $DIR/attr-stmt-expr-attr-bad.rs:41:37
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:43:38
	\|
	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. 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:45:40
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:47:45
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:49:46
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

	error: outer attributes are not allowed on `if` and `else` branches
	--> $DIR/attr-stmt-expr-attr-bad.rs:51:45
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:53:50
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:55:51
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

	error: outer attributes are not allowed on `if` and `else` branches
	--> $DIR/attr-stmt-expr-attr-bad.rs:57:45
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:59:46
	\|
	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. 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:61:48
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:63:53
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:65:54
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

	error: outer attributes are not allowed on `if` and `else` branches
	--> $DIR/attr-stmt-expr-attr-bad.rs:67:53
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:69:66
	\|
	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
	--> $DIR/attr-stmt-expr-attr-bad.rs:71:67
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

	error: an inner attribute is not permitted following an outer attribute
	--> $DIR/attr-stmt-expr-attr-bad.rs:74:32
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

	error: an inner attribute is not permitted following an outer attribute
	--> $DIR/attr-stmt-expr-attr-bad.rs:76:32
	\|
	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. Outer attributes, like `#[test]`, annotate the item following them.

	error: an inner attribute is not permitted following an outer attribute
	--> $DIR/attr-stmt-expr-attr-bad.rs:78:32
	\|
	LL \| #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
	\| ------- ^^^^^^^^ 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. Outer attributes, like `#[test]`, annotate the item following them.

	error: an inner attribute is not permitted following an outer attribute
	--> $DIR/attr-stmt-expr-attr-bad.rs:80:32
	\|
	LL \| #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
	\| ------- ^^^^^^^^ 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. Outer attributes, like `#[test]`, annotate the item following them.

	error: an inner attribute is not permitted following an outer attribute
	--> $DIR/attr-stmt-expr-attr-bad.rs:82:32
	\|
	LL \| #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
	\| ------- ^^^^^^^^ 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. Outer attributes, like `#[test]`, annotate the item following them.

	error[E0586]: inclusive range with no end
	--> $DIR/attr-stmt-expr-attr-bad.rs:88:35
	\|
	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 `#`
	--> $DIR/attr-stmt-expr-attr-bad.rs:88:38
	\|
	LL \| #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] 10 => () } }
	\| ^ expected one of `=>`, `if`, or `\|`

	error[E0586]: inclusive range with no end
	--> $DIR/attr-stmt-expr-attr-bad.rs:91:35
	\|
	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 `#`
	--> $DIR/attr-stmt-expr-attr-bad.rs:91:38
	\|
	LL \| #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] -10 => () } }
	\| ^ expected one of `=>`, `if`, or `\|`

	error: unexpected token: `#`
	--> $DIR/attr-stmt-expr-attr-bad.rs:94:39
	\|
	LL \| #[cfg(FALSE)] fn e() { match 0 { 0..=-#[attr] 10 => () } }
	\| ^

	error[E0586]: inclusive range with no end
	--> $DIR/attr-stmt-expr-attr-bad.rs:96:35
	\|
	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 `#`
	--> $DIR/attr-stmt-expr-attr-bad.rs:96:38
	\|
	LL \| #[cfg(FALSE)] fn e() { match 0 { 0..=#[attr] FOO => () } }
	\| ^ expected one of `=>`, `if`, or `\|`

	error: unexpected token: `#`
	--> $DIR/attr-stmt-expr-attr-bad.rs:100:34
	\|
	LL \| #[cfg(FALSE)] fn e() { let _ = x.#![attr]foo(); }
	\| ^

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

	error: unexpected token: `#`
	--> $DIR/attr-stmt-expr-attr-bad.rs:103:34
	\|
	LL \| #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
	\| ^

	error: expected one of `.`, `;`, `?`, or an operator, found `#`
	--> $DIR/attr-stmt-expr-attr-bad.rs:103:34
	\|
	LL \| #[cfg(FALSE)] fn e() { let _ = x.#[attr]foo(); }
	\| ^ expected one of `.`, `;`, `?`, or an operator

	error: expected statement after outer attribute
	--> $DIR/attr-stmt-expr-attr-bad.rs:108:37
	\|
	LL \| #[cfg(FALSE)] fn e() { { fn foo() { #[attr]; } } }
	\| ^^^^^^^

	error: expected statement after outer attribute
	--> $DIR/attr-stmt-expr-attr-bad.rs:110:37
	\|
	LL \| #[cfg(FALSE)] fn e() { { fn foo() { #[attr] } } }
	\| ^^^^^^^

	error: aborting due to 53 previous errors

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