error: requires at least a template string argument
  --> $DIR/parse-error.rs:9:9
   |
LL |         asm!();
   |         ^^^^^^

error: asm template must be a string literal
  --> $DIR/parse-error.rs:11:14
   |
LL |         asm!(foo);
   |              ^^^

error: expected token: `,`
  --> $DIR/parse-error.rs:13:19
   |
LL |         asm!("{}" foo);
   |                   ^^^ expected `,`

error: expected operand, clobber_abi, options, or additional template string
  --> $DIR/parse-error.rs:15:20
   |
LL |         asm!("{}", foo);
   |                    ^^^ expected operand, clobber_abi, options, or additional template string

error: expected `(`, found `foo`
  --> $DIR/parse-error.rs:17:23
   |
LL |         asm!("{}", in foo);
   |                       ^^^ expected `(`

error: expected `)`, found `foo`
  --> $DIR/parse-error.rs:19:27
   |
LL |         asm!("{}", in(reg foo));
   |                           ^^^ expected `)`

error: expected expression, found end of macro arguments
  --> $DIR/parse-error.rs:21:27
   |
LL |         asm!("{}", in(reg));
   |                           ^ expected expression

error: expected register class or explicit register
  --> $DIR/parse-error.rs:23:26
   |
LL |         asm!("{}", inout(=) foo => bar);
   |                          ^

error: expected expression, found end of macro arguments
  --> $DIR/parse-error.rs:25:37
   |
LL |         asm!("{}", inout(reg) foo =>);
   |                                     ^ expected expression

error: expected one of `!`, `,`, `.`, `::`, `?`, `{`, or an operator, found `=>`
  --> $DIR/parse-error.rs:27:32
   |
LL |         asm!("{}", in(reg) foo => bar);
   |                                ^^ expected one of 7 possible tokens

error: expected a path for argument to `sym`
  --> $DIR/parse-error.rs:29:24
   |
LL |         asm!("{}", sym foo + bar);
   |                        ^^^^^^^^^

error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
  --> $DIR/parse-error.rs:31:26
   |
LL |         asm!("", options(foo));
   |                          ^^^ expected one of 10 possible tokens

error: expected one of `)` or `,`, found `foo`
  --> $DIR/parse-error.rs:33:32
   |
LL |         asm!("", options(nomem foo));
   |                                ^^^ expected one of `)` or `,`

error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
  --> $DIR/parse-error.rs:35:33
   |
LL |         asm!("", options(nomem, foo));
   |                                 ^^^ expected one of 10 possible tokens

error: at least one abi must be provided as an argument to `clobber_abi`
  --> $DIR/parse-error.rs:42:30
   |
LL |         asm!("", clobber_abi());
   |                              ^

error: expected string literal
  --> $DIR/parse-error.rs:44:30
   |
LL |         asm!("", clobber_abi(foo));
   |                              ^^^ not a string literal

error: expected one of `)` or `,`, found `foo`
  --> $DIR/parse-error.rs:46:34
   |
LL |         asm!("", clobber_abi("C" foo));
   |                                  ^^^ expected one of `)` or `,`

error: expected string literal
  --> $DIR/parse-error.rs:48:35
   |
LL |         asm!("", clobber_abi("C", foo));
   |                                   ^^^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:50:30
   |
LL |         asm!("", clobber_abi(1));
   |                              ^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:52:30
   |
LL |         asm!("", clobber_abi(()));
   |                              ^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:54:30
   |
LL |         asm!("", clobber_abi(uwu));
   |                              ^^^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:56:30
   |
LL |         asm!("", clobber_abi({}));
   |                              ^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:58:30
   |
LL |         asm!("", clobber_abi(loop {}));
   |                              ^^^^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:60:30
   |
LL |         asm!("", clobber_abi(if));
   |                              ^^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:62:30
   |
LL |         asm!("", clobber_abi(do));
   |                              ^^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:64:30
   |
LL |         asm!("", clobber_abi(<));
   |                              ^ not a string literal

error: expected string literal
  --> $DIR/parse-error.rs:66:30
   |
LL |         asm!("", clobber_abi(.));
   |                              ^ not a string literal

error: duplicate argument named `a`
  --> $DIR/parse-error.rs:74:36
   |
LL |         asm!("{a}", a = const foo, a = const bar);
   |                     -------------  ^^^^^^^^^^^^^ duplicate argument
   |                     |
   |                     previously here

error: argument never used
  --> $DIR/parse-error.rs:74:36
   |
LL |         asm!("{a}", a = const foo, a = const bar);
   |                                    ^^^^^^^^^^^^^ argument never used
   |
   = help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`

error: expected one of `#`, `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `""`
  --> $DIR/parse-error.rs:80:29
   |
LL |         asm!("", options(), "");
   |                             ^^ expected one of 11 possible tokens

error: expected one of `#`, `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `"{}"`
  --> $DIR/parse-error.rs:82:33
   |
LL |         asm!("{}", in(reg) foo, "{}", out(reg) foo);
   |                                 ^^^^ expected one of 11 possible tokens

error: asm template must be a string literal
  --> $DIR/parse-error.rs:84:14
   |
LL |         asm!(format!("{{{}}}", 0), in(reg) foo);
   |              ^^^^^^^^^^^^^^^^^^^^
   |
   = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)

error: asm template must be a string literal
  --> $DIR/parse-error.rs:86:21
   |
LL |         asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
   |                     ^^^^^^^^^^^^^^^^^^^^
   |
   = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)

error: _ cannot be used for input operands
  --> $DIR/parse-error.rs:88:28
   |
LL |         asm!("{}", in(reg) _);
   |                            ^

error: _ cannot be used for input operands
  --> $DIR/parse-error.rs:90:31
   |
LL |         asm!("{}", inout(reg) _);
   |                               ^

error: _ cannot be used for input operands
  --> $DIR/parse-error.rs:92:35
   |
LL |         asm!("{}", inlateout(reg) _);
   |                                   ^

error: requires at least a template string argument
  --> $DIR/parse-error.rs:99:1
   |
LL | global_asm!();
   | ^^^^^^^^^^^^^

error: asm template must be a string literal
  --> $DIR/parse-error.rs:101:13
   |
LL | global_asm!(FOO);
   |             ^^^

error: expected token: `,`
  --> $DIR/parse-error.rs:103:18
   |
LL | global_asm!("{}" FOO);
   |                  ^^^ expected `,`

error: expected operand, options, or additional template string
  --> $DIR/parse-error.rs:105:19
   |
LL | global_asm!("{}", FOO);
   |                   ^^^ expected operand, options, or additional template string

error: expected expression, found end of macro arguments
  --> $DIR/parse-error.rs:107:24
   |
LL | global_asm!("{}", const);
   |                        ^ expected expression

error: expected one of `,`, `.`, `?`, or an operator, found `FOO`
  --> $DIR/parse-error.rs:109:30
   |
LL | global_asm!("{}", const(reg) FOO);
   |                              ^^^ expected one of `,`, `.`, `?`, or an operator

error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
  --> $DIR/parse-error.rs:111:25
   |
LL | global_asm!("", options(FOO));
   |                         ^^^ expected one of `)`, `att_syntax`, or `raw`

error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
  --> $DIR/parse-error.rs:113:25
   |
LL | global_asm!("", options(FOO,));
   |                         ^^^ expected one of `)`, `att_syntax`, or `raw`

error: expected one of `)` or `,`, found `FOO`
  --> $DIR/parse-error.rs:115:31
   |
LL | global_asm!("", options(nomem FOO));
   |                               ^^^ expected one of `)` or `,`

error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
  --> $DIR/parse-error.rs:117:32
   |
LL | global_asm!("", options(nomem, FOO));
   |                                ^^^ expected one of `)`, `att_syntax`, or `raw`

error: expected string literal
  --> $DIR/parse-error.rs:120:29
   |
LL | global_asm!("", clobber_abi(FOO));
   |                             ^^^ not a string literal

error: expected one of `)` or `,`, found `FOO`
  --> $DIR/parse-error.rs:122:33
   |
LL | global_asm!("", clobber_abi("C" FOO));
   |                                 ^^^ expected one of `)` or `,`

error: expected string literal
  --> $DIR/parse-error.rs:124:34
   |
LL | global_asm!("", clobber_abi("C", FOO));
   |                                  ^^^ not a string literal

error: `clobber_abi` cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:126:19
   |
LL | global_asm!("{}", clobber_abi("C"), const FOO);
   |                   ^^^^^^^^^^^^^^^^

error: `clobber_abi` cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:128:28
   |
LL | global_asm!("", options(), clobber_abi("C"));
   |                            ^^^^^^^^^^^^^^^^

error: `clobber_abi` cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:130:30
   |
LL | global_asm!("{}", options(), clobber_abi("C"), const FOO);
   |                              ^^^^^^^^^^^^^^^^

error: `clobber_abi` cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:132:17
   |
LL | global_asm!("", clobber_abi("C"), clobber_abi("C"));
   |                 ^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^

error: duplicate argument named `a`
  --> $DIR/parse-error.rs:134:35
   |
LL | global_asm!("{a}", a = const FOO, a = const BAR);
   |                    -------------  ^^^^^^^^^^^^^ duplicate argument
   |                    |
   |                    previously here

error: argument never used
  --> $DIR/parse-error.rs:134:35
   |
LL | global_asm!("{a}", a = const FOO, a = const BAR);
   |                                   ^^^^^^^^^^^^^ argument never used
   |
   = help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`

error: expected one of `#`, `clobber_abi`, `const`, `options`, or `sym`, found `""`
  --> $DIR/parse-error.rs:137:28
   |
LL | global_asm!("", options(), "");
   |                            ^^ expected one of `#`, `clobber_abi`, `const`, `options`, or `sym`

error: expected one of `#`, `clobber_abi`, `const`, `options`, or `sym`, found `"{}"`
  --> $DIR/parse-error.rs:139:30
   |
LL | global_asm!("{}", const FOO, "{}", const FOO);
   |                              ^^^^ expected one of `#`, `clobber_abi`, `const`, `options`, or `sym`

error: asm template must be a string literal
  --> $DIR/parse-error.rs:141:13
   |
LL | global_asm!(format!("{{{}}}", 0), const FOO);
   |             ^^^^^^^^^^^^^^^^^^^^
   |
   = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)

error: asm template must be a string literal
  --> $DIR/parse-error.rs:143:20
   |
LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
   |                    ^^^^^^^^^^^^^^^^^^^^
   |
   = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)

error: the `in` operand cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:146:19
   |
LL | global_asm!("{}", in(reg));
   |                   ^^ the `in` operand is not meaningful for global-scoped inline assembly, remove it

error: the `out` operand cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:148:19
   |
LL | global_asm!("{}", out(reg));
   |                   ^^^ the `out` operand is not meaningful for global-scoped inline assembly, remove it

error: the `lateout` operand cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:150:19
   |
LL | global_asm!("{}", lateout(reg));
   |                   ^^^^^^^ the `lateout` operand is not meaningful for global-scoped inline assembly, remove it

error: the `inout` operand cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:152:19
   |
LL | global_asm!("{}", inout(reg));
   |                   ^^^^^ the `inout` operand is not meaningful for global-scoped inline assembly, remove it

error: the `inlateout` operand cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:154:19
   |
LL | global_asm!("{}", inlateout(reg));
   |                   ^^^^^^^^^ the `inlateout` operand is not meaningful for global-scoped inline assembly, remove it

error: the `label` operand cannot be used with `global_asm!`
  --> $DIR/parse-error.rs:156:19
   |
LL | global_asm!("{}", label(reg));
   |                   ^^^^^ the `label` operand is not meaningful for global-scoped inline assembly, remove it

error[E0435]: attempt to use a non-constant value in a constant
  --> $DIR/parse-error.rs:37:37
   |
LL |         asm!("{}", options(), const foo);
   |                                     ^^^ non-constant value
   |
help: consider using `const` instead of `let`
   |
LL -     let mut foo = 0;
LL +     const foo: /* Type */ = 0;
   |

error[E0435]: attempt to use a non-constant value in a constant
  --> $DIR/parse-error.rs:69:44
   |
LL |         asm!("{}", clobber_abi("C"), const foo);
   |                                            ^^^ non-constant value
   |
help: consider using `const` instead of `let`
   |
LL -     let mut foo = 0;
LL +     const foo: /* Type */ = 0;
   |

error[E0435]: attempt to use a non-constant value in a constant
  --> $DIR/parse-error.rs:72:55
   |
LL |         asm!("{}", options(), clobber_abi("C"), const foo);
   |                                                       ^^^ non-constant value
   |
help: consider using `const` instead of `let`
   |
LL -     let mut foo = 0;
LL +     const foo: /* Type */ = 0;
   |

error[E0435]: attempt to use a non-constant value in a constant
  --> $DIR/parse-error.rs:74:31
   |
LL |         asm!("{a}", a = const foo, a = const bar);
   |                               ^^^ non-constant value
   |
help: consider using `const` instead of `let`
   |
LL -     let mut foo = 0;
LL +     const foo: /* Type */ = 0;
   |

error[E0435]: attempt to use a non-constant value in a constant
  --> $DIR/parse-error.rs:74:46
   |
LL |         asm!("{a}", a = const foo, a = const bar);
   |                                              ^^^ non-constant value
   |
help: consider using `const` instead of `let`
   |
LL -     let mut bar = 0;
LL +     const bar: /* Type */ = 0;
   |

error: aborting due to 70 previous errors

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