src/test/ui/parser/expr-as-stmt.stderr

   1 error: expected expression, found `+`
   2   --> $DIR/expr-as-stmt.rs:8:9
   3    |
   4 LL |     {2} + {2}
   5    |         ^ expected expression
   6    |
   7 help: parentheses are required to parse this as an expression
   8    |
   9 LL |     ({2}) + {2}
  10    |     +   +
  11
  12 error: leading `+` is not supported
  13   --> $DIR/expr-as-stmt.rs:13:9
  14    |
  15 LL |     {2} + 2
  16    |         ^ unexpected `+`
  17    |
  18 help: parentheses are required to parse this as an expression
  19    |
  20 LL |     ({2}) + 2
  21    |     +   +
  22
  23 error: expected expression, found `+`
  24   --> $DIR/expr-as-stmt.rs:19:12
  25    |
  26 LL |     { 42 } + foo;
  27    |            ^ expected expression
  28    |
  29 help: parentheses are required to parse this as an expression
  30    |
  31 LL |     ({ 42 }) + foo;
  32    |     +      +
  33
  34 error: expected expression, found `>`
  35   --> $DIR/expr-as-stmt.rs:32:7
  36    |
  37 LL |     } > 0
  38    |       ^ expected expression
  39    |
  40 help: parentheses are required to parse this as an expression
  41    |
  42 LL ~     (match x {
  43 LL |         _ => 1,
  44 LL ~     }) > 0
  45    |
  46
  47 error: expected parameter name, found `{`
  48   --> $DIR/expr-as-stmt.rs:41:16
  49    |
  50 LL |     { true } | { true }
  51    |                ^ expected parameter name
  52    |
  53 help: parentheses are required to parse this as an expression
  54    |
  55 LL |     ({ true }) | { true }
  56    |     +        +
  57
  58 error: expected expression, found `+`
  59   --> $DIR/expr-as-stmt.rs:69:26
  60    |
  61 LL |     match () { () => 1 } + match () { () => 1 }
  62    |                          ^ expected expression
  63    |
  64 help: parentheses are required to parse this as an expression
  65    |
  66 LL |     (match () { () => 1 }) + match () { () => 1 }
  67    |     +                    +
  68
  69 error: expected expression, found `+`
  70   --> $DIR/expr-as-stmt.rs:75:18
  71    |
  72 LL |     unsafe { 1 } + unsafe { 1 }
  73    |                  ^ expected expression
  74    |
  75 help: parentheses are required to parse this as an expression
  76    |
  77 LL |     (unsafe { 1 }) + unsafe { 1 }
  78    |     +            +
  79
  80 error[E0308]: mismatched types
  81   --> $DIR/expr-as-stmt.rs:64:7
  82    |
  83 LL |     { foo() } || { true }
  84    |       ^^^^^- help: consider using a semicolon here: `;`
  85    |       |
  86    |       expected `()`, found `i32`
  87
  88 error[E0308]: mismatched types
  89   --> $DIR/expr-as-stmt.rs:8:6
  90    |
  91 LL |     {2} + {2}
  92    |      ^ expected `()`, found integer
  93    |
  94 help: you might have meant to return this value
  95    |
  96 LL |     {return 2;} + {2}
  97    |      ++++++  +
  98
  99 error[E0308]: mismatched types
 100   --> $DIR/expr-as-stmt.rs:13:6
 101    |
 102 LL |     {2} + 2
 103    |      ^ expected `()`, found integer
 104    |
 105 help: you might have meant to return this value
 106    |
 107 LL |     {return 2;} + 2
 108    |      ++++++  +
 109
 110 error[E0308]: mismatched types
 111   --> $DIR/expr-as-stmt.rs:19:7
 112    |
 113 LL |     { 42 } + foo;
 114    |       ^^ expected `()`, found integer
 115    |
 116 help: you might have meant to return this value
 117    |
 118 LL |     { return 42; } + foo;
 119    |       ++++++   +
 120
 121 error[E0308]: mismatched types
 122   --> $DIR/expr-as-stmt.rs:25:7
 123    |
 124 LL |     { 3 } * 3
 125    |       ^ expected `()`, found integer
 126    |
 127 help: you might have meant to return this value
 128    |
 129 LL |     { return 3; } * 3
 130    |       ++++++  +
 131
 132 error[E0614]: type `{integer}` cannot be dereferenced
 133   --> $DIR/expr-as-stmt.rs:25:11
 134    |
 135 LL |     { 3 } * 3
 136    |           ^^^
 137    |
 138 help: parentheses are required to parse this as an expression
 139    |
 140 LL |     ({ 3 }) * 3
 141    |     +     +
 142
 143 error[E0308]: mismatched types
 144   --> $DIR/expr-as-stmt.rs:36:6
 145    |
 146 LL |     {2} - 2
 147    |      ^ expected `()`, found integer
 148    |
 149 help: you might have meant to return this value
 150    |
 151 LL |     {return 2;} - 2
 152    |      ++++++  +
 153
 154 error[E0600]: cannot apply unary operator `-` to type `u32`
 155   --> $DIR/expr-as-stmt.rs:36:9
 156    |
 157 LL |     {2} - 2
 158    |         ^^^ cannot apply unary operator `-`
 159    |
 160 help: parentheses are required to parse this as an expression
 161    |
 162 LL |     ({2}) - 2
 163    |     +   +
 164
 165 error[E0308]: mismatched types
 166   --> $DIR/expr-as-stmt.rs:41:7
 167    |
 168 LL |     { true } | { true }
 169    |       ^^^^ expected `()`, found `bool`
 170    |
 171 help: you might have meant to return this value
 172    |
 173 LL |     { return true; } | { true }
 174    |       ++++++     +
 175
 176 error[E0308]: mismatched types
 177   --> $DIR/expr-as-stmt.rs:46:7
 178    |
 179 LL |     { true } && { true }
 180    |       ^^^^ expected `()`, found `bool`
 181    |
 182 help: you might have meant to return this value
 183    |
 184 LL |     { return true; } && { true }
 185    |       ++++++     +
 186
 187 error[E0308]: mismatched types
 188   --> $DIR/expr-as-stmt.rs:46:14
 189    |
 190 LL | fn revenge_from_mars() -> bool {
 191    |                           ---- expected `bool` because of return type
 192 LL |     { true } && { true }
 193    |              ^^^^^^^^^^^ expected `bool`, found `&&bool`
 194    |
 195 help: parentheses are required to parse this as an expression
 196    |
 197 LL |     ({ true }) && { true }
 198    |     +        +
 199
 200 error[E0308]: mismatched types
 201   --> $DIR/expr-as-stmt.rs:51:7
 202    |
 203 LL |     { true } || { true }
 204    |       ^^^^ expected `()`, found `bool`
 205    |
 206 help: you might have meant to return this value
 207    |
 208 LL |     { return true; } || { true }
 209    |       ++++++     +
 210
 211 error[E0308]: mismatched types
 212   --> $DIR/expr-as-stmt.rs:51:14
 213    |
 214 LL | fn attack_from_mars() -> bool {
 215    |                          ---- expected `bool` because of return type
 216 LL |     { true } || { true }
 217    |              ^^^^^^^^^^^ expected `bool`, found closure
 218    |
 219    = note: expected type `bool`
 220            found closure `[closure@$DIR/expr-as-stmt.rs:51:14: 51:16]`
 221 help: parentheses are required to parse this as an expression
 222    |
 223 LL |     ({ true }) || { true }
 224    |     +        +
 225
 226 error[E0308]: mismatched types
 227   --> $DIR/expr-as-stmt.rs:69:5
 228    |
 229 LL |     match () { () => 1 } + match () { () => 1 }
 230    |     ^^^^^^^^^^^^^^^^^^^^- help: consider using a semicolon here
 231    |     |
 232    |     expected `()`, found integer
 233
 234 error[E0308]: mismatched types
 235   --> $DIR/expr-as-stmt.rs:75:14
 236    |
 237 LL |     unsafe { 1 } + unsafe { 1 }
 238    |              ^ expected `()`, found integer
 239    |
 240 help: you might have meant to return this value
 241    |
 242 LL |     unsafe { return 1; } + unsafe { 1 }
 243    |              ++++++  +
 244
 245 error: aborting due to 22 previous errors
 246
 247 Some errors have detailed explanations: E0308, E0600, E0614.
 248 For more information about an error, try `rustc --explain E0308`.