rust/tests/ui/lint/unused/must-use-ops.stderr

warning: unused comparison that must be used
  --> $DIR/must-use-ops.rs:18:5
   |
LL |     val == 1;
   |     ^^^^^^^^ the comparison produces a value
   |
note: the lint level is defined here
  --> $DIR/must-use-ops.rs:5:9
   |
LL | #![warn(unused_must_use)]
   |         ^^^^^^^^^^^^^^^
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val == 1;
   |     +++++++

warning: unused comparison that must be used
  --> $DIR/must-use-ops.rs:19:5
   |
LL |     val < 1;
   |     ^^^^^^^ the comparison produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val < 1;
   |     +++++++

warning: unused comparison that must be used
  --> $DIR/must-use-ops.rs:20:5
   |
LL |     val <= 1;
   |     ^^^^^^^^ the comparison produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val <= 1;
   |     +++++++

warning: unused comparison that must be used
  --> $DIR/must-use-ops.rs:21:5
   |
LL |     val != 1;
   |     ^^^^^^^^ the comparison produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val != 1;
   |     +++++++

warning: unused comparison that must be used
  --> $DIR/must-use-ops.rs:22:5
   |
LL |     val >= 1;
   |     ^^^^^^^^ the comparison produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val >= 1;
   |     +++++++

warning: unused comparison that must be used
  --> $DIR/must-use-ops.rs:23:5
   |
LL |     val > 1;
   |     ^^^^^^^ the comparison produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val > 1;
   |     +++++++

warning: unused arithmetic operation that must be used
  --> $DIR/must-use-ops.rs:26:5
   |
LL |     val + 2;
   |     ^^^^^^^ the arithmetic operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val + 2;
   |     +++++++

warning: unused arithmetic operation that must be used
  --> $DIR/must-use-ops.rs:27:5
   |
LL |     val - 2;
   |     ^^^^^^^ the arithmetic operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val - 2;
   |     +++++++

warning: unused arithmetic operation that must be used
  --> $DIR/must-use-ops.rs:28:5
   |
LL |     val / 2;
   |     ^^^^^^^ the arithmetic operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val / 2;
   |     +++++++

warning: unused arithmetic operation that must be used
  --> $DIR/must-use-ops.rs:29:5
   |
LL |     val * 2;
   |     ^^^^^^^ the arithmetic operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val * 2;
   |     +++++++

warning: unused arithmetic operation that must be used
  --> $DIR/must-use-ops.rs:30:5
   |
LL |     val % 2;
   |     ^^^^^^^ the arithmetic operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = val % 2;
   |     +++++++

warning: unused logical operation that must be used
  --> $DIR/must-use-ops.rs:33:5
   |
LL |     true && true;
   |     ^^^^^^^^^^^^ the logical operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = true && true;
   |     +++++++

warning: unused logical operation that must be used
  --> $DIR/must-use-ops.rs:34:5
   |
LL |     false || true;
   |     ^^^^^^^^^^^^^ the logical operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = false || true;
   |     +++++++

warning: unused bitwise operation that must be used
  --> $DIR/must-use-ops.rs:37:5
   |
LL |     5 ^ val;
   |     ^^^^^^^ the bitwise operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = 5 ^ val;
   |     +++++++

warning: unused bitwise operation that must be used
  --> $DIR/must-use-ops.rs:38:5
   |
LL |     5 & val;
   |     ^^^^^^^ the bitwise operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = 5 & val;
   |     +++++++

warning: unused bitwise operation that must be used
  --> $DIR/must-use-ops.rs:39:5
   |
LL |     5 | val;
   |     ^^^^^^^ the bitwise operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = 5 | val;
   |     +++++++

warning: unused bitwise operation that must be used
  --> $DIR/must-use-ops.rs:40:5
   |
LL |     5 << val;
   |     ^^^^^^^^ the bitwise operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = 5 << val;
   |     +++++++

warning: unused bitwise operation that must be used
  --> $DIR/must-use-ops.rs:41:5
   |
LL |     5 >> val;
   |     ^^^^^^^^ the bitwise operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = 5 >> val;
   |     +++++++

warning: unused unary operation that must be used
  --> $DIR/must-use-ops.rs:44:5
   |
LL |     !val;
   |     ^^^^ the unary operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = !val;
   |     +++++++

warning: unused unary operation that must be used
  --> $DIR/must-use-ops.rs:45:5
   |
LL |     -val;
   |     ^^^^ the unary operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = -val;
   |     +++++++

warning: unused unary operation that must be used
  --> $DIR/must-use-ops.rs:46:5
   |
LL |     *val_pointer;
   |     ^^^^^^^^^^^^ the unary operation produces a value
   |
help: use `let _ = ...` to ignore the resulting value
   |
LL |     let _ = *val_pointer;
   |     +++++++

warning: 21 warnings emitted