Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-05-22 18:15:07 +03:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #73195 - ayazhafiz:i/73145, r=estebank

Browse Source 
Provide suggestion to convert numeric op LHS rather than unwrapping RHS

Given a code

```rust
fn foo(x: u8, y: u32) -> bool {
    x > y
}
fn main() {}
```

it could be more helpful to provide a suggestion to do "u32::from(x)"
rather than "y.try_into().unwrap()", since the latter may panic.

We do this by passing the LHS of a binary expression up the stack into
the coercion checker.

Closes #73145
This commit is contained in:
Dylan DPC
2020-06-12 00:05:33 +02:00
committed by GitHub
parent 838d25b5e3 0c02f8aea9
commit 7bdf7d09b0
8 changed files with 2126 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/librustc_typeck/check/coercion.rs
+1 -1
View File
@@ -1377,7 +1377,7 @@ fn coerce_inner<'a>(
}
if let Some(expr) = expression {
fcx.emit_coerce_suggestions(&mut err, expr, found, expected);
fcx.emit_coerce_suggestions(&mut err, expr, found, expected, None);
}
// Error possibly reported in `check_assign` so avoid emitting error again.
src/librustc_typeck/check/demand.rs
+79 -30
View File
@@ -24,10 +24,11 @@ pub fn emit_coerce_suggestions(
expr: &hir::Expr<'_>,
expr_ty: Ty<'tcx>,
expected: Ty<'tcx>,
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
) {
self.annotate_expected_due_to_let_ty(err, expr);
self.suggest_compatible_variants(err, expr, expected, expr_ty);
self.suggest_deref_ref_or_into(err, expr, expected, expr_ty);
self.suggest_deref_ref_or_into(err, expr, expected, expr_ty, expected_ty_expr);
if self.suggest_calling_boxed_future_when_appropriate(err, expr, expected, expr_ty) {
return;
}
@@ -102,9 +103,11 @@ pub fn demand_coerce(
expr: &hir::Expr<'_>,
checked_ty: Ty<'tcx>,
expected: Ty<'tcx>,
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
allow_two_phase: AllowTwoPhase,
) -> Ty<'tcx> {
let (ty, err) = self.demand_coerce_diag(expr, checked_ty, expected, allow_two_phase);
let (ty, err) =
self.demand_coerce_diag(expr, checked_ty, expected, expected_ty_expr, allow_two_phase);
if let Some(mut err) = err {
err.emit();
}
@@ -121,6 +124,7 @@ pub fn demand_coerce_diag(
expr: &hir::Expr<'_>,
checked_ty: Ty<'tcx>,
expected: Ty<'tcx>,
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
allow_two_phase: AllowTwoPhase,
) -> (Ty<'tcx>, Option<DiagnosticBuilder<'tcx>>) {
let expected = self.resolve_vars_with_obligations(expected);
@@ -141,7 +145,7 @@ pub fn demand_coerce_diag(
return (expected, None);
}
self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected);
self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected, expected_ty_expr);
(expected, Some(err))
}
@@ -671,6 +675,7 @@ pub fn check_for_cast(
expr: &hir::Expr<'_>,
checked_ty: Ty<'tcx>,
expected_ty: Ty<'tcx>,
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
) -> bool {
if self.tcx.sess.source_map().is_imported(expr.span) {
// Ignore if span is from within a macro.
@@ -747,7 +752,6 @@ pub fn check_for_cast(
let msg = format!("you can convert an `{}` to `{}`", checked_ty, expected_ty);
let cast_msg = format!("you can cast an `{} to `{}`", checked_ty, expected_ty);
let try_msg = format!("{} and panic if the converted value wouldn't fit", msg);
let lit_msg = format!(
"change the type of the numeric literal from `{}` to `{}`",
checked_ty, expected_ty,
@@ -761,7 +765,6 @@ pub fn check_for_cast(
};
let cast_suggestion = format!("{}{} as {}", prefix, with_opt_paren(&src), expected_ty);
let try_into_suggestion = format!("{}{}.try_into().unwrap()", prefix, with_opt_paren(&src));
let into_suggestion = format!("{}{}.into()", prefix, with_opt_paren(&src));
let suffix_suggestion = with_opt_paren(&format_args!(
"{}{}",
@@ -782,22 +785,55 @@ pub fn check_for_cast(
};
let in_const_context = self.tcx.hir().is_inside_const_context(expr.hir_id);
let suggest_fallible_into_or_lhs_from =
|err: &mut DiagnosticBuilder<'_>, exp_to_found_is_fallible: bool| {
// If we know the expression the expected type is derived from, we might be able
// to suggest a widening conversion rather than a narrowing one (which may
// panic). For example, given x: u8 and y: u32, if we know the span of "x",
// x > y
// can be given the suggestion "u32::from(x) > y" rather than
// "x > y.try_into().unwrap()".
let lhs_expr_and_src = expected_ty_expr.and_then(|expr| {
match self.tcx.sess.source_map().span_to_snippet(expr.span).ok() {
Some(src) => Some((expr, src)),
None => None,
}
});
let (span, msg, suggestion) = if let (Some((lhs_expr, lhs_src)), false) =
(lhs_expr_and_src, exp_to_found_is_fallible)
{
let msg = format!(
"you can convert `{}` from `{}` to `{}`, matching the type of `{}`",
lhs_src, expected_ty, checked_ty, src
);
let suggestion = format!("{}::from({})", checked_ty, lhs_src,);
(lhs_expr.span, msg, suggestion)
} else {
let msg = format!("{} and panic if the converted value wouldn't fit", msg);
let suggestion =
format!("{}{}.try_into().unwrap()", prefix, with_opt_paren(&src));
(expr.span, msg, suggestion)
};
err.span_suggestion(span, &msg, suggestion, Applicability::MachineApplicable);
};
let suggest_to_change_suffix_or_into =
|err: &mut DiagnosticBuilder<'_>, is_fallible: bool| {
|err: &mut DiagnosticBuilder<'_>,
found_to_exp_is_fallible: bool,
exp_to_found_is_fallible: bool| {
let msg = if literal_is_ty_suffixed(expr) {
&lit_msg
} else if in_const_context {
// Do not recommend `into` or `try_into` in const contexts.
return;
} else if is_fallible {
&try_msg
} else if found_to_exp_is_fallible {
return suggest_fallible_into_or_lhs_from(err, exp_to_found_is_fallible);
} else {
&msg
};
let suggestion = if literal_is_ty_suffixed(expr) {
suffix_suggestion.clone()
} else if is_fallible {
try_into_suggestion
} else {
into_suggestion.clone()
};
@@ -806,41 +842,54 @@ pub fn check_for_cast(
match (&expected_ty.kind, &checked_ty.kind) {
(&ty::Int(ref exp), &ty::Int(ref found)) => {
let is_fallible = match (exp.bit_width(), found.bit_width()) {
(Some(exp), Some(found)) if exp < found => true,
(None, Some(8 | 16)) => false,
(None, _) | (_, None) => true,
_ => false,
let (f2e_is_fallible, e2f_is_fallible) = match (exp.bit_width(), found.bit_width())
{
(Some(exp), Some(found)) if exp < found => (true, false),
(Some(exp), Some(found)) if exp > found => (false, true),
(None, Some(8 | 16)) => (false, true),
(Some(8 | 16), None) => (true, false),
(None, _) | (_, None) => (true, true),
_ => (false, false),
};
suggest_to_change_suffix_or_into(err, is_fallible);
suggest_to_change_suffix_or_into(err, f2e_is_fallible, e2f_is_fallible);
true
}
(&ty::Uint(ref exp), &ty::Uint(ref found)) => {
let is_fallible = match (exp.bit_width(), found.bit_width()) {
(Some(exp), Some(found)) if exp < found => true,
(None, Some(8 | 16)) => false,
(None, _) | (_, None) => true,
_ => false,
let (f2e_is_fallible, e2f_is_fallible) = match (exp.bit_width(), found.bit_width())
{
(Some(exp), Some(found)) if exp < found => (true, false),
(Some(exp), Some(found)) if exp > found => (false, true),
(None, Some(8 | 16)) => (false, true),
(Some(8 | 16), None) => (true, false),
(None, _) | (_, None) => (true, true),
_ => (false, false),
};
suggest_to_change_suffix_or_into(err, is_fallible);
suggest_to_change_suffix_or_into(err, f2e_is_fallible, e2f_is_fallible);
true
}
(&ty::Int(exp), &ty::Uint(found)) => {
let is_fallible = match (exp.bit_width(), found.bit_width()) {
(Some(exp), Some(found)) if found < exp => false,
(None, Some(8)) => false,
_ => true,
let (f2e_is_fallible, e2f_is_fallible) = match (exp.bit_width(), found.bit_width())
{
(Some(exp), Some(found)) if found < exp => (false, true),
(None, Some(8)) => (false, true),
_ => (true, true),
};
suggest_to_change_suffix_or_into(err, is_fallible);
suggest_to_change_suffix_or_into(err, f2e_is_fallible, e2f_is_fallible);
true
}
(&ty::Uint(_), &ty::Int(_)) => {
suggest_to_change_suffix_or_into(err, true);
(&ty::Uint(exp), &ty::Int(found)) => {
let (f2e_is_fallible, e2f_is_fallible) = match (exp.bit_width(), found.bit_width())
{
(Some(exp), Some(found)) if found > exp => (true, false),
(Some(8), None) => (true, false),
_ => (true, true),
};
suggest_to_change_suffix_or_into(err, f2e_is_fallible, e2f_is_fallible);
true
}
(&ty::Float(ref exp), &ty::Float(ref found)) => {
if found.bit_width() < exp.bit_width() {
suggest_to_change_suffix_or_into(err, false);
suggest_to_change_suffix_or_into(err, false, true);
} else if literal_is_ty_suffixed(expr) {
err.span_suggestion(
expr.span,
src/librustc_typeck/check/expr.rs
+12 -11
View File
@@ -86,7 +86,7 @@ fn check_expr_meets_expectation_or_error(
if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
let expr = expr.peel_drop_temps();
self.suggest_deref_ref_or_into(&mut err, expr, expected_ty, ty);
self.suggest_deref_ref_or_into(&mut err, expr, expected_ty, ty, None);
extend_err(&mut err);
// Error possibly reported in `check_assign` so avoid emitting error again.
err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
@@ -98,10 +98,11 @@ pub(super) fn check_expr_coercable_to_type(
&self,
expr: &'tcx hir::Expr<'tcx>,
expected: Ty<'tcx>,
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
) -> Ty<'tcx> {
let ty = self.check_expr_with_hint(expr, expected);
// checks don't need two phase
self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
self.demand_coerce(expr, ty, expected, expected_ty_expr, AllowTwoPhase::No)
}
pub(super) fn check_expr_with_hint(
@@ -776,7 +777,7 @@ fn check_expr_assign(
span: &Span,
) -> Ty<'tcx> {
let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty, Some(lhs));
let expected_ty = expected.coercion_target_type(self, expr.span);
if expected_ty == self.tcx.types.bool {
@@ -1026,7 +1027,7 @@ fn check_expr_repeat(
let (element_ty, t) = match uty {
Some(uty) => {
self.check_expr_coercable_to_type(&element, uty);
self.check_expr_coercable_to_type(&element, uty, None);
(uty, uty)
}
None => {
@@ -1063,7 +1064,7 @@ fn check_expr_tuple(
let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds {
Some(ref fs) if i < fs.len() => {
let ety = fs[i].expect_ty();
self.check_expr_coercable_to_type(&e, ety);
self.check_expr_coercable_to_type(&e, ety, None);
ety
}
_ => self.check_expr_with_expectation(&e, NoExpectation),
@@ -1237,7 +1238,7 @@ fn check_expr_struct_fields(
// Make sure to give a type to the field even if there's
// an error, so we can continue type-checking.
self.check_expr_coercable_to_type(&field.expr, field_type);
self.check_expr_coercable_to_type(&field.expr, field_type, None);
}
// Make sure the programmer specified correct number of fields.
@@ -1735,7 +1736,7 @@ fn check_expr_index(
match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
Some((index_ty, element_ty)) => {
// two-phase not needed because index_ty is never mutable
self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
self.demand_coerce(idx, idx_t, index_ty, None, AllowTwoPhase::No);
element_ty
}
None => {
@@ -1788,7 +1789,7 @@ fn check_expr_yield(
) -> Ty<'tcx> {
match self.resume_yield_tys {
Some((resume_ty, yield_ty)) => {
self.check_expr_coercable_to_type(&value, yield_ty);
self.check_expr_coercable_to_type(&value, yield_ty, None);
resume_ty
}
@@ -1797,7 +1798,7 @@ fn check_expr_yield(
// information. Hence, we check the source of the yield expression here and check its
// value's type against `()` (this check should always hold).
None if src.is_await() => {
self.check_expr_coercable_to_type(&value, self.tcx.mk_unit());
self.check_expr_coercable_to_type(&value, self.tcx.mk_unit(), None);
self.tcx.mk_unit()
}
_ => {
@@ -1836,11 +1837,11 @@ fn check_expr_asm_operand(&self, expr: &'tcx hir::Expr<'tcx>, is_input: bool) {
match ty.kind {
ty::FnDef(..) => {
let fnptr_ty = self.tcx.mk_fn_ptr(ty.fn_sig(self.tcx));
self.demand_coerce(expr, ty, fnptr_ty, AllowTwoPhase::No);
self.demand_coerce(expr, ty, fnptr_ty, None, AllowTwoPhase::No);
}
ty::Ref(_, base_ty, mutbl) => {
let ptr_ty = self.tcx.mk_ptr(ty::TypeAndMut { ty: base_ty, mutbl });
self.demand_coerce(expr, ty, ptr_ty, AllowTwoPhase::No);
self.demand_coerce(expr, ty, ptr_ty, None, AllowTwoPhase::No);
}
_ => {}
}
src/librustc_typeck/check/mod.rs
+5 -4
View File
@@ -1046,7 +1046,7 @@ fn typeck_tables_of_with_fallback<'tcx>(
// Gather locals in statics (because of block expressions).
GatherLocalsVisitor { fcx: &fcx, parent_id: id }.visit_body(body);
fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
fcx.check_expr_coercable_to_type(&body.value, revealed_ty, None);
fcx.write_ty(id, revealed_ty);
@@ -4123,7 +4123,7 @@ fn check_argument_types(
let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
// We're processing function arguments so we definitely want to use
// two-phase borrows.
self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
self.demand_coerce(&arg, checked_ty, coerce_ty, None, AllowTwoPhase::Yes);
final_arg_types.push((i, checked_ty, coerce_ty));
// 3. Relate the expected type and the formal one,
@@ -4541,7 +4541,7 @@ pub fn check_decl_initializer(
self.demand_eqtype(init.span, local_ty, init_ty);
init_ty
} else {
self.check_expr_coercable_to_type(init, local_ty)
self.check_expr_coercable_to_type(init, local_ty, None)
}
}
@@ -5027,6 +5027,7 @@ pub fn suggest_deref_ref_or_into(
expr: &hir::Expr<'_>,
expected: Ty<'tcx>,
found: Ty<'tcx>,
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
) {
if let Some((sp, msg, suggestion, applicability)) = self.check_ref(expr, found, expected) {
err.span_suggestion(sp, msg, suggestion, applicability);
@@ -5037,7 +5038,7 @@ pub fn suggest_deref_ref_or_into(
let sp = self.sess().source_map().guess_head_span(sp);
err.span_label(sp, &format!("{} defined here", found));
}
} else if !self.check_for_cast(err, expr, found, expected) {
} else if !self.check_for_cast(err, expr, found, expected, expected_ty_expr) {
let is_struct_pat_shorthand_field =
self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
let methods = self.get_conversion_methods(expr.span, expected, found, expr.hir_id);
src/librustc_typeck/check/op.rs
+4 -4
View File
@@ -57,9 +57,9 @@ pub fn check_binop(
match BinOpCategory::from(op) {
BinOpCategory::Shortcircuit => {
// && and || are a simple case.
self.check_expr_coercable_to_type(lhs_expr, tcx.types.bool);
self.check_expr_coercable_to_type(lhs_expr, tcx.types.bool, None);
let lhs_diverges = self.diverges.get();
self.check_expr_coercable_to_type(rhs_expr, tcx.types.bool);
self.check_expr_coercable_to_type(rhs_expr, tcx.types.bool, None);
// Depending on the LHS' value, the RHS can never execute.
self.diverges.set(lhs_diverges);
@@ -170,7 +170,7 @@ fn check_overloaded_binop(
kind: TypeVariableOriginKind::MiscVariable,
span: lhs_expr.span,
});
self.demand_coerce(lhs_expr, lhs_ty, fresh_var, AllowTwoPhase::No)
self.demand_coerce(lhs_expr, lhs_ty, fresh_var, Some(rhs_expr), AllowTwoPhase::No)
}
IsAssign::Yes => {
// rust-lang/rust#52126: We have to use strict
@@ -196,7 +196,7 @@ fn check_overloaded_binop(
let result = self.lookup_op_method(lhs_ty, &[rhs_ty_var], Op::Binary(op, is_assign));
// see `NB` above
let rhs_ty = self.check_expr_coercable_to_type(rhs_expr, rhs_ty_var);
let rhs_ty = self.check_expr_coercable_to_type(rhs_expr, rhs_ty_var, Some(lhs_expr));
let rhs_ty = self.resolve_vars_with_obligations(rhs_ty);
let return_ty = match result {
src/test/ui/numeric/numeric-cast-binop.fixed
+320
View File
@@ -0,0 +1,320 @@
// run-rustfix
// The `try_into` suggestion doesn't include this, but we do suggest it after applying it
use std::convert::TryInto;
#[allow(unused_must_use)]
fn main() {
let x_usize: usize = 1;
let x_u128: u128 = 2;
let x_u64: u64 = 3;
let x_u32: u32 = 4;
let x_u16: u16 = 5;
let x_u8: u8 = 6;
let x_isize: isize = 7;
let x_i64: i64 = 8;
let x_i32: i32 = 9;
let x_i16: i16 = 10;
let x_i8: i8 = 11;
let x_i128: i128 = 12;
/* u<->u */
{
u16::from(x_u8) > x_u16;
//~^ ERROR mismatched types
u32::from(x_u8) > x_u32;
//~^ ERROR mismatched types
u64::from(x_u8) > x_u64;
//~^ ERROR mismatched types
u128::from(x_u8) > x_u128;
//~^ ERROR mismatched types
usize::from(x_u8) > x_usize;
//~^ ERROR mismatched types
x_u16 > x_u8.into();
//~^ ERROR mismatched types
u32::from(x_u16) > x_u32;
//~^ ERROR mismatched types
u64::from(x_u16) > x_u64;
//~^ ERROR mismatched types
u128::from(x_u16) > x_u128;
//~^ ERROR mismatched types
usize::from(x_u16) > x_usize;
//~^ ERROR mismatched types
x_u32 > x_u8.into();
//~^ ERROR mismatched types
x_u32 > x_u16.into();
//~^ ERROR mismatched types
u64::from(x_u32) > x_u64;
//~^ ERROR mismatched types
u128::from(x_u32) > x_u128;
//~^ ERROR mismatched types
x_u32 > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
x_u64 > x_u8.into();
//~^ ERROR mismatched types
x_u64 > x_u16.into();
//~^ ERROR mismatched types
x_u64 > x_u32.into();
//~^ ERROR mismatched types
u128::from(x_u64) > x_u128;
//~^ ERROR mismatched types
x_u64 > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
x_u128 > x_u8.into();
//~^ ERROR mismatched types
x_u128 > x_u16.into();
//~^ ERROR mismatched types
x_u128 > x_u32.into();
//~^ ERROR mismatched types
x_u128 > x_u64.into();
//~^ ERROR mismatched types
x_u128 > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_u8.into();
//~^ ERROR mismatched types
x_usize > x_u16.into();
//~^ ERROR mismatched types
x_usize > x_u32.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_u64.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_u128.try_into().unwrap();
//~^ ERROR mismatched types
}
/* i<->i */
{
i16::from(x_i8) > x_i16;
//~^ ERROR mismatched types
i32::from(x_i8) > x_i32;
//~^ ERROR mismatched types
i64::from(x_i8) > x_i64;
//~^ ERROR mismatched types
i128::from(x_i8) > x_i128;
//~^ ERROR mismatched types
isize::from(x_i8) > x_isize;
//~^ ERROR mismatched types
x_i16 > x_i8.into();
//~^ ERROR mismatched types
i32::from(x_i16) > x_i32;
//~^ ERROR mismatched types
i64::from(x_i16) > x_i64;
//~^ ERROR mismatched types
i128::from(x_i16) > x_i128;
//~^ ERROR mismatched types
isize::from(x_i16) > x_isize;
//~^ ERROR mismatched types
x_i32 > x_i8.into();
//~^ ERROR mismatched types
x_i32 > x_i16.into();
//~^ ERROR mismatched types
i64::from(x_i32) > x_i64;
//~^ ERROR mismatched types
i128::from(x_i32) > x_i128;
//~^ ERROR mismatched types
x_i32 > x_isize.try_into().unwrap();
//~^ ERROR mismatched types
x_i64 > x_i8.into();
//~^ ERROR mismatched types
x_i64 > x_i16.into();
//~^ ERROR mismatched types
x_i64 > x_i32.into();
//~^ ERROR mismatched types
i128::from(x_i64) > x_i128;
//~^ ERROR mismatched types
x_i64 > x_isize.try_into().unwrap();
//~^ ERROR mismatched types
x_i128 > x_i8.into();
//~^ ERROR mismatched types
x_i128 > x_i16.into();
//~^ ERROR mismatched types
x_i128 > x_i32.into();
//~^ ERROR mismatched types
x_i128 > x_i64.into();
//~^ ERROR mismatched types
x_i128 > x_isize.try_into().unwrap();
//~^ ERROR mismatched types
x_isize > x_i8.into();
//~^ ERROR mismatched types
x_isize > x_i16.into();
//~^ ERROR mismatched types
x_isize > x_i32.try_into().unwrap();
//~^ ERROR mismatched types
x_isize > x_i64.try_into().unwrap();
//~^ ERROR mismatched types
x_isize > x_i128.try_into().unwrap();
//~^ ERROR mismatched types
}
/* u<->i */
{
x_u8 > x_i8.try_into().unwrap();
//~^ ERROR mismatched types
i16::from(x_u8) > x_i16;
//~^ ERROR mismatched types
i32::from(x_u8) > x_i32;
//~^ ERROR mismatched types
i64::from(x_u8) > x_i64;
//~^ ERROR mismatched types
i128::from(x_u8) > x_i128;
//~^ ERROR mismatched types
isize::from(x_u8) > x_isize;
//~^ ERROR mismatched types
x_u16 > x_i8.try_into().unwrap();
//~^ ERROR mismatched types
x_u16 > x_i16.try_into().unwrap();
//~^ ERROR mismatched types
i32::from(x_u16) > x_i32;
//~^ ERROR mismatched types
i64::from(x_u16) > x_i64;
//~^ ERROR mismatched types
i128::from(x_u16) > x_i128;
//~^ ERROR mismatched types
x_u16 > x_isize.try_into().unwrap();
//~^ ERROR mismatched types
x_u32 > x_i8.try_into().unwrap();
//~^ ERROR mismatched types
x_u32 > x_i16.try_into().unwrap();
//~^ ERROR mismatched types
x_u32 > x_i32.try_into().unwrap();
//~^ ERROR mismatched types
i64::from(x_u32) > x_i64;
//~^ ERROR mismatched types
i128::from(x_u32) > x_i128;
//~^ ERROR mismatched types
x_u32 > x_isize.try_into().unwrap();
//~^ ERROR mismatched types
x_u64 > x_i8.try_into().unwrap();
//~^ ERROR mismatched types
x_u64 > x_i16.try_into().unwrap();
//~^ ERROR mismatched types
x_u64 > x_i32.try_into().unwrap();
//~^ ERROR mismatched types
x_u64 > x_i64.try_into().unwrap();
//~^ ERROR mismatched types
i128::from(x_u64) > x_i128;
//~^ ERROR mismatched types
x_u64 > x_isize.try_into().unwrap();
//~^ ERROR mismatched types
x_u128 > x_i8.try_into().unwrap();
//~^ ERROR mismatched types
x_u128 > x_i16.try_into().unwrap();
//~^ ERROR mismatched types
x_u128 > x_i32.try_into().unwrap();
//~^ ERROR mismatched types
x_u128 > x_i64.try_into().unwrap();
//~^ ERROR mismatched types
x_u128 > x_i128.try_into().unwrap();
//~^ ERROR mismatched types
x_u128 > x_isize.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_i8.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_i16.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_i32.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_i64.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_i128.try_into().unwrap();
//~^ ERROR mismatched types
x_usize > x_isize.try_into().unwrap();
//~^ ERROR mismatched types
}
/* i<->u */
{
x_i8 > x_u8.try_into().unwrap();
//~^ ERROR mismatched types
x_i8 > x_u16.try_into().unwrap();
//~^ ERROR mismatched types
x_i8 > x_u32.try_into().unwrap();
//~^ ERROR mismatched types
x_i8 > x_u64.try_into().unwrap();
//~^ ERROR mismatched types
x_i8 > x_u128.try_into().unwrap();
//~^ ERROR mismatched types
x_i8 > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
x_i16 > x_u8.into();
//~^ ERROR mismatched types
x_i16 > x_u16.try_into().unwrap();
//~^ ERROR mismatched types
x_i16 > x_u32.try_into().unwrap();
//~^ ERROR mismatched types
x_i16 > x_u64.try_into().unwrap();
//~^ ERROR mismatched types
x_i16 > x_u128.try_into().unwrap();
//~^ ERROR mismatched types
x_i16 > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
x_i32 > x_u8.into();
//~^ ERROR mismatched types
x_i32 > x_u16.into();
//~^ ERROR mismatched types
x_i32 > x_u32.try_into().unwrap();
//~^ ERROR mismatched types
x_i32 > x_u64.try_into().unwrap();
//~^ ERROR mismatched types
x_i32 > x_u128.try_into().unwrap();
//~^ ERROR mismatched types
x_i32 > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
x_i64 > x_u8.into();
//~^ ERROR mismatched types
x_i64 > x_u16.into();
//~^ ERROR mismatched types
x_i64 > x_u32.into();
//~^ ERROR mismatched types
x_i64 > x_u64.try_into().unwrap();
//~^ ERROR mismatched types
x_i64 > x_u128.try_into().unwrap();
//~^ ERROR mismatched types
x_i64 > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
x_i128 > x_u8.into();
//~^ ERROR mismatched types
x_i128 > x_u16.into();
//~^ ERROR mismatched types
x_i128 > x_u32.into();
//~^ ERROR mismatched types
x_i128 > x_u64.into();
//~^ ERROR mismatched types
x_i128 > x_u128.try_into().unwrap();
//~^ ERROR mismatched types
x_i128 > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
x_isize > x_u8.into();
//~^ ERROR mismatched types
x_isize > x_u16.try_into().unwrap();
//~^ ERROR mismatched types
x_isize > x_u32.try_into().unwrap();
//~^ ERROR mismatched types
x_isize > x_u64.try_into().unwrap();
//~^ ERROR mismatched types
x_isize > x_u128.try_into().unwrap();
//~^ ERROR mismatched types
x_isize > x_usize.try_into().unwrap();
//~^ ERROR mismatched types
}
}
src/test/ui/numeric/numeric-cast-binop.rs
+320
View File
@@ -0,0 +1,320 @@
// run-rustfix
// The `try_into` suggestion doesn't include this, but we do suggest it after applying it
use std::convert::TryInto;
#[allow(unused_must_use)]
fn main() {
let x_usize: usize = 1;
let x_u128: u128 = 2;
let x_u64: u64 = 3;
let x_u32: u32 = 4;
let x_u16: u16 = 5;
let x_u8: u8 = 6;
let x_isize: isize = 7;
let x_i64: i64 = 8;
let x_i32: i32 = 9;
let x_i16: i16 = 10;
let x_i8: i8 = 11;
let x_i128: i128 = 12;
/* u<->u */
{
x_u8 > x_u16;
//~^ ERROR mismatched types
x_u8 > x_u32;
//~^ ERROR mismatched types
x_u8 > x_u64;
//~^ ERROR mismatched types
x_u8 > x_u128;
//~^ ERROR mismatched types
x_u8 > x_usize;
//~^ ERROR mismatched types
x_u16 > x_u8;
//~^ ERROR mismatched types
x_u16 > x_u32;
//~^ ERROR mismatched types
x_u16 > x_u64;
//~^ ERROR mismatched types
x_u16 > x_u128;
//~^ ERROR mismatched types
x_u16 > x_usize;
//~^ ERROR mismatched types
x_u32 > x_u8;
//~^ ERROR mismatched types
x_u32 > x_u16;
//~^ ERROR mismatched types
x_u32 > x_u64;
//~^ ERROR mismatched types
x_u32 > x_u128;
//~^ ERROR mismatched types
x_u32 > x_usize;
//~^ ERROR mismatched types
x_u64 > x_u8;
//~^ ERROR mismatched types
x_u64 > x_u16;
//~^ ERROR mismatched types
x_u64 > x_u32;
//~^ ERROR mismatched types
x_u64 > x_u128;
//~^ ERROR mismatched types
x_u64 > x_usize;
//~^ ERROR mismatched types
x_u128 > x_u8;
//~^ ERROR mismatched types
x_u128 > x_u16;
//~^ ERROR mismatched types
x_u128 > x_u32;
//~^ ERROR mismatched types
x_u128 > x_u64;
//~^ ERROR mismatched types
x_u128 > x_usize;
//~^ ERROR mismatched types
x_usize > x_u8;
//~^ ERROR mismatched types
x_usize > x_u16;
//~^ ERROR mismatched types
x_usize > x_u32;
//~^ ERROR mismatched types
x_usize > x_u64;
//~^ ERROR mismatched types
x_usize > x_u128;
//~^ ERROR mismatched types
}
/* i<->i */
{
x_i8 > x_i16;
//~^ ERROR mismatched types
x_i8 > x_i32;
//~^ ERROR mismatched types
x_i8 > x_i64;
//~^ ERROR mismatched types
x_i8 > x_i128;
//~^ ERROR mismatched types
x_i8 > x_isize;
//~^ ERROR mismatched types
x_i16 > x_i8;
//~^ ERROR mismatched types
x_i16 > x_i32;
//~^ ERROR mismatched types
x_i16 > x_i64;
//~^ ERROR mismatched types
x_i16 > x_i128;
//~^ ERROR mismatched types
x_i16 > x_isize;
//~^ ERROR mismatched types
x_i32 > x_i8;
//~^ ERROR mismatched types
x_i32 > x_i16;
//~^ ERROR mismatched types
x_i32 > x_i64;
//~^ ERROR mismatched types
x_i32 > x_i128;
//~^ ERROR mismatched types
x_i32 > x_isize;
//~^ ERROR mismatched types
x_i64 > x_i8;
//~^ ERROR mismatched types
x_i64 > x_i16;
//~^ ERROR mismatched types
x_i64 > x_i32;
//~^ ERROR mismatched types
x_i64 > x_i128;
//~^ ERROR mismatched types
x_i64 > x_isize;
//~^ ERROR mismatched types
x_i128 > x_i8;
//~^ ERROR mismatched types
x_i128 > x_i16;
//~^ ERROR mismatched types
x_i128 > x_i32;
//~^ ERROR mismatched types
x_i128 > x_i64;
//~^ ERROR mismatched types
x_i128 > x_isize;
//~^ ERROR mismatched types
x_isize > x_i8;
//~^ ERROR mismatched types
x_isize > x_i16;
//~^ ERROR mismatched types
x_isize > x_i32;
//~^ ERROR mismatched types
x_isize > x_i64;
//~^ ERROR mismatched types
x_isize > x_i128;
//~^ ERROR mismatched types
}
/* u<->i */
{
x_u8 > x_i8;
//~^ ERROR mismatched types
x_u8 > x_i16;
//~^ ERROR mismatched types
x_u8 > x_i32;
//~^ ERROR mismatched types
x_u8 > x_i64;
//~^ ERROR mismatched types
x_u8 > x_i128;
//~^ ERROR mismatched types
x_u8 > x_isize;
//~^ ERROR mismatched types
x_u16 > x_i8;
//~^ ERROR mismatched types
x_u16 > x_i16;
//~^ ERROR mismatched types
x_u16 > x_i32;
//~^ ERROR mismatched types
x_u16 > x_i64;
//~^ ERROR mismatched types
x_u16 > x_i128;
//~^ ERROR mismatched types
x_u16 > x_isize;
//~^ ERROR mismatched types
x_u32 > x_i8;
//~^ ERROR mismatched types
x_u32 > x_i16;
//~^ ERROR mismatched types
x_u32 > x_i32;
//~^ ERROR mismatched types
x_u32 > x_i64;
//~^ ERROR mismatched types
x_u32 > x_i128;
//~^ ERROR mismatched types
x_u32 > x_isize;
//~^ ERROR mismatched types
x_u64 > x_i8;
//~^ ERROR mismatched types
x_u64 > x_i16;
//~^ ERROR mismatched types
x_u64 > x_i32;
//~^ ERROR mismatched types
x_u64 > x_i64;
//~^ ERROR mismatched types
x_u64 > x_i128;
//~^ ERROR mismatched types
x_u64 > x_isize;
//~^ ERROR mismatched types
x_u128 > x_i8;
//~^ ERROR mismatched types
x_u128 > x_i16;
//~^ ERROR mismatched types
x_u128 > x_i32;
//~^ ERROR mismatched types
x_u128 > x_i64;
//~^ ERROR mismatched types
x_u128 > x_i128;
//~^ ERROR mismatched types
x_u128 > x_isize;
//~^ ERROR mismatched types
x_usize > x_i8;
//~^ ERROR mismatched types
x_usize > x_i16;
//~^ ERROR mismatched types
x_usize > x_i32;
//~^ ERROR mismatched types
x_usize > x_i64;
//~^ ERROR mismatched types
x_usize > x_i128;
//~^ ERROR mismatched types
x_usize > x_isize;
//~^ ERROR mismatched types
}
/* i<->u */
{
x_i8 > x_u8;
//~^ ERROR mismatched types
x_i8 > x_u16;
//~^ ERROR mismatched types
x_i8 > x_u32;
//~^ ERROR mismatched types
x_i8 > x_u64;
//~^ ERROR mismatched types
x_i8 > x_u128;
//~^ ERROR mismatched types
x_i8 > x_usize;
//~^ ERROR mismatched types
x_i16 > x_u8;
//~^ ERROR mismatched types
x_i16 > x_u16;
//~^ ERROR mismatched types
x_i16 > x_u32;
//~^ ERROR mismatched types
x_i16 > x_u64;
//~^ ERROR mismatched types
x_i16 > x_u128;
//~^ ERROR mismatched types
x_i16 > x_usize;
//~^ ERROR mismatched types
x_i32 > x_u8;
//~^ ERROR mismatched types
x_i32 > x_u16;
//~^ ERROR mismatched types
x_i32 > x_u32;
//~^ ERROR mismatched types
x_i32 > x_u64;
//~^ ERROR mismatched types
x_i32 > x_u128;
//~^ ERROR mismatched types
x_i32 > x_usize;
//~^ ERROR mismatched types
x_i64 > x_u8;
//~^ ERROR mismatched types
x_i64 > x_u16;
//~^ ERROR mismatched types
x_i64 > x_u32;
//~^ ERROR mismatched types
x_i64 > x_u64;
//~^ ERROR mismatched types
x_i64 > x_u128;
//~^ ERROR mismatched types
x_i64 > x_usize;
//~^ ERROR mismatched types
x_i128 > x_u8;
//~^ ERROR mismatched types
x_i128 > x_u16;
//~^ ERROR mismatched types
x_i128 > x_u32;
//~^ ERROR mismatched types
x_i128 > x_u64;
//~^ ERROR mismatched types
x_i128 > x_u128;
//~^ ERROR mismatched types
x_i128 > x_usize;
//~^ ERROR mismatched types
x_isize > x_u8;
//~^ ERROR mismatched types
x_isize > x_u16;
//~^ ERROR mismatched types
x_isize > x_u32;
//~^ ERROR mismatched types
x_isize > x_u64;
//~^ ERROR mismatched types
x_isize > x_u128;
//~^ ERROR mismatched types
x_isize > x_usize;
//~^ ERROR mismatched types
}
}
src/test/ui/numeric/numeric-cast-binop.stderr
+1385
View File
@@ -0,0 +1,1385 @@
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:23:16
|
LL | x_u8 > x_u16;
| ^^^^^ expected `u8`, found `u16`
|
help: you can convert `x_u8` from `u8` to `u16`, matching the type of `x_u16`
|
LL | u16::from(x_u8) > x_u16;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:25:16
|
LL | x_u8 > x_u32;
| ^^^^^ expected `u8`, found `u32`
|
help: you can convert `x_u8` from `u8` to `u32`, matching the type of `x_u32`
|
LL | u32::from(x_u8) > x_u32;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:27:16
|
LL | x_u8 > x_u64;
| ^^^^^ expected `u8`, found `u64`
|
help: you can convert `x_u8` from `u8` to `u64`, matching the type of `x_u64`
|
LL | u64::from(x_u8) > x_u64;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:29:16
|
LL | x_u8 > x_u128;
| ^^^^^^ expected `u8`, found `u128`
|
help: you can convert `x_u8` from `u8` to `u128`, matching the type of `x_u128`
|
LL | u128::from(x_u8) > x_u128;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:31:16
|
LL | x_u8 > x_usize;
| ^^^^^^^ expected `u8`, found `usize`
|
help: you can convert `x_u8` from `u8` to `usize`, matching the type of `x_usize`
|
LL | usize::from(x_u8) > x_usize;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:34:17
|
LL | x_u16 > x_u8;
| ^^^^
| |
| expected `u16`, found `u8`
| help: you can convert an `u8` to `u16`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:36:17
|
LL | x_u16 > x_u32;
| ^^^^^ expected `u16`, found `u32`
|
help: you can convert `x_u16` from `u16` to `u32`, matching the type of `x_u32`
|
LL | u32::from(x_u16) > x_u32;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:38:17
|
LL | x_u16 > x_u64;
| ^^^^^ expected `u16`, found `u64`
|
help: you can convert `x_u16` from `u16` to `u64`, matching the type of `x_u64`
|
LL | u64::from(x_u16) > x_u64;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:40:17
|
LL | x_u16 > x_u128;
| ^^^^^^ expected `u16`, found `u128`
|
help: you can convert `x_u16` from `u16` to `u128`, matching the type of `x_u128`
|
LL | u128::from(x_u16) > x_u128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:42:17
|
LL | x_u16 > x_usize;
| ^^^^^^^ expected `u16`, found `usize`
|
help: you can convert `x_u16` from `u16` to `usize`, matching the type of `x_usize`
|
LL | usize::from(x_u16) > x_usize;
| ^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:45:17
|
LL | x_u32 > x_u8;
| ^^^^
| |
| expected `u32`, found `u8`
| help: you can convert an `u8` to `u32`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:47:17
|
LL | x_u32 > x_u16;
| ^^^^^
| |
| expected `u32`, found `u16`
| help: you can convert an `u16` to `u32`: `x_u16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:49:17
|
LL | x_u32 > x_u64;
| ^^^^^ expected `u32`, found `u64`
|
help: you can convert `x_u32` from `u32` to `u64`, matching the type of `x_u64`
|
LL | u64::from(x_u32) > x_u64;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:51:17
|
LL | x_u32 > x_u128;
| ^^^^^^ expected `u32`, found `u128`
|
help: you can convert `x_u32` from `u32` to `u128`, matching the type of `x_u128`
|
LL | u128::from(x_u32) > x_u128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:53:17
|
LL | x_u32 > x_usize;
| ^^^^^^^ expected `u32`, found `usize`
|
help: you can convert an `usize` to `u32` and panic if the converted value wouldn't fit
|
LL | x_u32 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:56:17
|
LL | x_u64 > x_u8;
| ^^^^
| |
| expected `u64`, found `u8`
| help: you can convert an `u8` to `u64`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:58:17
|
LL | x_u64 > x_u16;
| ^^^^^
| |
| expected `u64`, found `u16`
| help: you can convert an `u16` to `u64`: `x_u16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:60:17
|
LL | x_u64 > x_u32;
| ^^^^^
| |
| expected `u64`, found `u32`
| help: you can convert an `u32` to `u64`: `x_u32.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:62:17
|
LL | x_u64 > x_u128;
| ^^^^^^ expected `u64`, found `u128`
|
help: you can convert `x_u64` from `u64` to `u128`, matching the type of `x_u128`
|
LL | u128::from(x_u64) > x_u128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:64:17
|
LL | x_u64 > x_usize;
| ^^^^^^^ expected `u64`, found `usize`
|
help: you can convert an `usize` to `u64` and panic if the converted value wouldn't fit
|
LL | x_u64 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:67:18
|
LL | x_u128 > x_u8;
| ^^^^
| |
| expected `u128`, found `u8`
| help: you can convert an `u8` to `u128`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:69:18
|
LL | x_u128 > x_u16;
| ^^^^^
| |
| expected `u128`, found `u16`
| help: you can convert an `u16` to `u128`: `x_u16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:71:18
|
LL | x_u128 > x_u32;
| ^^^^^
| |
| expected `u128`, found `u32`
| help: you can convert an `u32` to `u128`: `x_u32.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:73:18
|
LL | x_u128 > x_u64;
| ^^^^^
| |
| expected `u128`, found `u64`
| help: you can convert an `u64` to `u128`: `x_u64.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:75:18
|
LL | x_u128 > x_usize;
| ^^^^^^^ expected `u128`, found `usize`
|
help: you can convert an `usize` to `u128` and panic if the converted value wouldn't fit
|
LL | x_u128 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:78:19
|
LL | x_usize > x_u8;
| ^^^^
| |
| expected `usize`, found `u8`
| help: you can convert an `u8` to `usize`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:80:19
|
LL | x_usize > x_u16;
| ^^^^^
| |
| expected `usize`, found `u16`
| help: you can convert an `u16` to `usize`: `x_u16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:82:19
|
LL | x_usize > x_u32;
| ^^^^^ expected `usize`, found `u32`
|
help: you can convert an `u32` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:84:19
|
LL | x_usize > x_u64;
| ^^^^^ expected `usize`, found `u64`
|
help: you can convert an `u64` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:86:19
|
LL | x_usize > x_u128;
| ^^^^^^ expected `usize`, found `u128`
|
help: you can convert an `u128` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:92:16
|
LL | x_i8 > x_i16;
| ^^^^^ expected `i8`, found `i16`
|
help: you can convert `x_i8` from `i8` to `i16`, matching the type of `x_i16`
|
LL | i16::from(x_i8) > x_i16;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:94:16
|
LL | x_i8 > x_i32;
| ^^^^^ expected `i8`, found `i32`
|
help: you can convert `x_i8` from `i8` to `i32`, matching the type of `x_i32`
|
LL | i32::from(x_i8) > x_i32;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:96:16
|
LL | x_i8 > x_i64;
| ^^^^^ expected `i8`, found `i64`
|
help: you can convert `x_i8` from `i8` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_i8) > x_i64;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:98:16
|
LL | x_i8 > x_i128;
| ^^^^^^ expected `i8`, found `i128`
|
help: you can convert `x_i8` from `i8` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_i8) > x_i128;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:100:16
|
LL | x_i8 > x_isize;
| ^^^^^^^ expected `i8`, found `isize`
|
help: you can convert `x_i8` from `i8` to `isize`, matching the type of `x_isize`
|
LL | isize::from(x_i8) > x_isize;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:103:17
|
LL | x_i16 > x_i8;
| ^^^^
| |
| expected `i16`, found `i8`
| help: you can convert an `i8` to `i16`: `x_i8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:105:17
|
LL | x_i16 > x_i32;
| ^^^^^ expected `i16`, found `i32`
|
help: you can convert `x_i16` from `i16` to `i32`, matching the type of `x_i32`
|
LL | i32::from(x_i16) > x_i32;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:107:17
|
LL | x_i16 > x_i64;
| ^^^^^ expected `i16`, found `i64`
|
help: you can convert `x_i16` from `i16` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_i16) > x_i64;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:109:17
|
LL | x_i16 > x_i128;
| ^^^^^^ expected `i16`, found `i128`
|
help: you can convert `x_i16` from `i16` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_i16) > x_i128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:111:17
|
LL | x_i16 > x_isize;
| ^^^^^^^ expected `i16`, found `isize`
|
help: you can convert `x_i16` from `i16` to `isize`, matching the type of `x_isize`
|
LL | isize::from(x_i16) > x_isize;
| ^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:114:17
|
LL | x_i32 > x_i8;
| ^^^^
| |
| expected `i32`, found `i8`
| help: you can convert an `i8` to `i32`: `x_i8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:116:17
|
LL | x_i32 > x_i16;
| ^^^^^
| |
| expected `i32`, found `i16`
| help: you can convert an `i16` to `i32`: `x_i16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:118:17
|
LL | x_i32 > x_i64;
| ^^^^^ expected `i32`, found `i64`
|
help: you can convert `x_i32` from `i32` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_i32) > x_i64;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:120:17
|
LL | x_i32 > x_i128;
| ^^^^^^ expected `i32`, found `i128`
|
help: you can convert `x_i32` from `i32` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_i32) > x_i128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:122:17
|
LL | x_i32 > x_isize;
| ^^^^^^^ expected `i32`, found `isize`
|
help: you can convert an `isize` to `i32` and panic if the converted value wouldn't fit
|
LL | x_i32 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:125:17
|
LL | x_i64 > x_i8;
| ^^^^
| |
| expected `i64`, found `i8`
| help: you can convert an `i8` to `i64`: `x_i8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:127:17
|
LL | x_i64 > x_i16;
| ^^^^^
| |
| expected `i64`, found `i16`
| help: you can convert an `i16` to `i64`: `x_i16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:129:17
|
LL | x_i64 > x_i32;
| ^^^^^
| |
| expected `i64`, found `i32`
| help: you can convert an `i32` to `i64`: `x_i32.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:131:17
|
LL | x_i64 > x_i128;
| ^^^^^^ expected `i64`, found `i128`
|
help: you can convert `x_i64` from `i64` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_i64) > x_i128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:133:17
|
LL | x_i64 > x_isize;
| ^^^^^^^ expected `i64`, found `isize`
|
help: you can convert an `isize` to `i64` and panic if the converted value wouldn't fit
|
LL | x_i64 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:136:18
|
LL | x_i128 > x_i8;
| ^^^^
| |
| expected `i128`, found `i8`
| help: you can convert an `i8` to `i128`: `x_i8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:138:18
|
LL | x_i128 > x_i16;
| ^^^^^
| |
| expected `i128`, found `i16`
| help: you can convert an `i16` to `i128`: `x_i16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:140:18
|
LL | x_i128 > x_i32;
| ^^^^^
| |
| expected `i128`, found `i32`
| help: you can convert an `i32` to `i128`: `x_i32.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:142:18
|
LL | x_i128 > x_i64;
| ^^^^^
| |
| expected `i128`, found `i64`
| help: you can convert an `i64` to `i128`: `x_i64.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:144:18
|
LL | x_i128 > x_isize;
| ^^^^^^^ expected `i128`, found `isize`
|
help: you can convert an `isize` to `i128` and panic if the converted value wouldn't fit
|
LL | x_i128 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:147:19
|
LL | x_isize > x_i8;
| ^^^^
| |
| expected `isize`, found `i8`
| help: you can convert an `i8` to `isize`: `x_i8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:149:19
|
LL | x_isize > x_i16;
| ^^^^^
| |
| expected `isize`, found `i16`
| help: you can convert an `i16` to `isize`: `x_i16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:151:19
|
LL | x_isize > x_i32;
| ^^^^^ expected `isize`, found `i32`
|
help: you can convert an `i32` to `isize` and panic if the converted value wouldn't fit
|
LL | x_isize > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:153:19
|
LL | x_isize > x_i64;
| ^^^^^ expected `isize`, found `i64`
|
help: you can convert an `i64` to `isize` and panic if the converted value wouldn't fit
|
LL | x_isize > x_i64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:155:19
|
LL | x_isize > x_i128;
| ^^^^^^ expected `isize`, found `i128`
|
help: you can convert an `i128` to `isize` and panic if the converted value wouldn't fit
|
LL | x_isize > x_i128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:161:16
|
LL | x_u8 > x_i8;
| ^^^^ expected `u8`, found `i8`
|
help: you can convert an `i8` to `u8` and panic if the converted value wouldn't fit
|
LL | x_u8 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:163:16
|
LL | x_u8 > x_i16;
| ^^^^^ expected `u8`, found `i16`
|
help: you can convert `x_u8` from `u8` to `i16`, matching the type of `x_i16`
|
LL | i16::from(x_u8) > x_i16;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:165:16
|
LL | x_u8 > x_i32;
| ^^^^^ expected `u8`, found `i32`
|
help: you can convert `x_u8` from `u8` to `i32`, matching the type of `x_i32`
|
LL | i32::from(x_u8) > x_i32;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:167:16
|
LL | x_u8 > x_i64;
| ^^^^^ expected `u8`, found `i64`
|
help: you can convert `x_u8` from `u8` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_u8) > x_i64;
| ^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:169:16
|
LL | x_u8 > x_i128;
| ^^^^^^ expected `u8`, found `i128`
|
help: you can convert `x_u8` from `u8` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_u8) > x_i128;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:171:16
|
LL | x_u8 > x_isize;
| ^^^^^^^ expected `u8`, found `isize`
|
help: you can convert `x_u8` from `u8` to `isize`, matching the type of `x_isize`
|
LL | isize::from(x_u8) > x_isize;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:174:17
|
LL | x_u16 > x_i8;
| ^^^^ expected `u16`, found `i8`
|
help: you can convert an `i8` to `u16` and panic if the converted value wouldn't fit
|
LL | x_u16 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:176:17
|
LL | x_u16 > x_i16;
| ^^^^^ expected `u16`, found `i16`
|
help: you can convert an `i16` to `u16` and panic if the converted value wouldn't fit
|
LL | x_u16 > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:178:17
|
LL | x_u16 > x_i32;
| ^^^^^ expected `u16`, found `i32`
|
help: you can convert `x_u16` from `u16` to `i32`, matching the type of `x_i32`
|
LL | i32::from(x_u16) > x_i32;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:180:17
|
LL | x_u16 > x_i64;
| ^^^^^ expected `u16`, found `i64`
|
help: you can convert `x_u16` from `u16` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_u16) > x_i64;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:182:17
|
LL | x_u16 > x_i128;
| ^^^^^^ expected `u16`, found `i128`
|
help: you can convert `x_u16` from `u16` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_u16) > x_i128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:184:17
|
LL | x_u16 > x_isize;
| ^^^^^^^ expected `u16`, found `isize`
|
help: you can convert an `isize` to `u16` and panic if the converted value wouldn't fit
|
LL | x_u16 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:187:17
|
LL | x_u32 > x_i8;
| ^^^^ expected `u32`, found `i8`
|
help: you can convert an `i8` to `u32` and panic if the converted value wouldn't fit
|
LL | x_u32 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:189:17
|
LL | x_u32 > x_i16;
| ^^^^^ expected `u32`, found `i16`
|
help: you can convert an `i16` to `u32` and panic if the converted value wouldn't fit
|
LL | x_u32 > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:191:17
|
LL | x_u32 > x_i32;
| ^^^^^ expected `u32`, found `i32`
|
help: you can convert an `i32` to `u32` and panic if the converted value wouldn't fit
|
LL | x_u32 > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:193:17
|
LL | x_u32 > x_i64;
| ^^^^^ expected `u32`, found `i64`
|
help: you can convert `x_u32` from `u32` to `i64`, matching the type of `x_i64`
|
LL | i64::from(x_u32) > x_i64;
| ^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:195:17
|
LL | x_u32 > x_i128;
| ^^^^^^ expected `u32`, found `i128`
|
help: you can convert `x_u32` from `u32` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_u32) > x_i128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:197:17
|
LL | x_u32 > x_isize;
| ^^^^^^^ expected `u32`, found `isize`
|
help: you can convert an `isize` to `u32` and panic if the converted value wouldn't fit
|
LL | x_u32 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:200:17
|
LL | x_u64 > x_i8;
| ^^^^ expected `u64`, found `i8`
|
help: you can convert an `i8` to `u64` and panic if the converted value wouldn't fit
|
LL | x_u64 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:202:17
|
LL | x_u64 > x_i16;
| ^^^^^ expected `u64`, found `i16`
|
help: you can convert an `i16` to `u64` and panic if the converted value wouldn't fit
|
LL | x_u64 > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:204:17
|
LL | x_u64 > x_i32;
| ^^^^^ expected `u64`, found `i32`
|
help: you can convert an `i32` to `u64` and panic if the converted value wouldn't fit
|
LL | x_u64 > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:206:17
|
LL | x_u64 > x_i64;
| ^^^^^ expected `u64`, found `i64`
|
help: you can convert an `i64` to `u64` and panic if the converted value wouldn't fit
|
LL | x_u64 > x_i64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:208:17
|
LL | x_u64 > x_i128;
| ^^^^^^ expected `u64`, found `i128`
|
help: you can convert `x_u64` from `u64` to `i128`, matching the type of `x_i128`
|
LL | i128::from(x_u64) > x_i128;
| ^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:210:17
|
LL | x_u64 > x_isize;
| ^^^^^^^ expected `u64`, found `isize`
|
help: you can convert an `isize` to `u64` and panic if the converted value wouldn't fit
|
LL | x_u64 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:213:18
|
LL | x_u128 > x_i8;
| ^^^^ expected `u128`, found `i8`
|
help: you can convert an `i8` to `u128` and panic if the converted value wouldn't fit
|
LL | x_u128 > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:215:18
|
LL | x_u128 > x_i16;
| ^^^^^ expected `u128`, found `i16`
|
help: you can convert an `i16` to `u128` and panic if the converted value wouldn't fit
|
LL | x_u128 > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:217:18
|
LL | x_u128 > x_i32;
| ^^^^^ expected `u128`, found `i32`
|
help: you can convert an `i32` to `u128` and panic if the converted value wouldn't fit
|
LL | x_u128 > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:219:18
|
LL | x_u128 > x_i64;
| ^^^^^ expected `u128`, found `i64`
|
help: you can convert an `i64` to `u128` and panic if the converted value wouldn't fit
|
LL | x_u128 > x_i64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:221:18
|
LL | x_u128 > x_i128;
| ^^^^^^ expected `u128`, found `i128`
|
help: you can convert an `i128` to `u128` and panic if the converted value wouldn't fit
|
LL | x_u128 > x_i128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:223:18
|
LL | x_u128 > x_isize;
| ^^^^^^^ expected `u128`, found `isize`
|
help: you can convert an `isize` to `u128` and panic if the converted value wouldn't fit
|
LL | x_u128 > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:226:19
|
LL | x_usize > x_i8;
| ^^^^ expected `usize`, found `i8`
|
help: you can convert an `i8` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_i8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:228:19
|
LL | x_usize > x_i16;
| ^^^^^ expected `usize`, found `i16`
|
help: you can convert an `i16` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_i16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:230:19
|
LL | x_usize > x_i32;
| ^^^^^ expected `usize`, found `i32`
|
help: you can convert an `i32` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_i32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:232:19
|
LL | x_usize > x_i64;
| ^^^^^ expected `usize`, found `i64`
|
help: you can convert an `i64` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_i64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:234:19
|
LL | x_usize > x_i128;
| ^^^^^^ expected `usize`, found `i128`
|
help: you can convert an `i128` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_i128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:236:19
|
LL | x_usize > x_isize;
| ^^^^^^^ expected `usize`, found `isize`
|
help: you can convert an `isize` to `usize` and panic if the converted value wouldn't fit
|
LL | x_usize > x_isize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:242:16
|
LL | x_i8 > x_u8;
| ^^^^ expected `i8`, found `u8`
|
help: you can convert an `u8` to `i8` and panic if the converted value wouldn't fit
|
LL | x_i8 > x_u8.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:244:16
|
LL | x_i8 > x_u16;
| ^^^^^ expected `i8`, found `u16`
|
help: you can convert an `u16` to `i8` and panic if the converted value wouldn't fit
|
LL | x_i8 > x_u16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:246:16
|
LL | x_i8 > x_u32;
| ^^^^^ expected `i8`, found `u32`
|
help: you can convert an `u32` to `i8` and panic if the converted value wouldn't fit
|
LL | x_i8 > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:248:16
|
LL | x_i8 > x_u64;
| ^^^^^ expected `i8`, found `u64`
|
help: you can convert an `u64` to `i8` and panic if the converted value wouldn't fit
|
LL | x_i8 > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:250:16
|
LL | x_i8 > x_u128;
| ^^^^^^ expected `i8`, found `u128`
|
help: you can convert an `u128` to `i8` and panic if the converted value wouldn't fit
|
LL | x_i8 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:252:16
|
LL | x_i8 > x_usize;
| ^^^^^^^ expected `i8`, found `usize`
|
help: you can convert an `usize` to `i8` and panic if the converted value wouldn't fit
|
LL | x_i8 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:255:17
|
LL | x_i16 > x_u8;
| ^^^^
| |
| expected `i16`, found `u8`
| help: you can convert an `u8` to `i16`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:257:17
|
LL | x_i16 > x_u16;
| ^^^^^ expected `i16`, found `u16`
|
help: you can convert an `u16` to `i16` and panic if the converted value wouldn't fit
|
LL | x_i16 > x_u16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:259:17
|
LL | x_i16 > x_u32;
| ^^^^^ expected `i16`, found `u32`
|
help: you can convert an `u32` to `i16` and panic if the converted value wouldn't fit
|
LL | x_i16 > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:261:17
|
LL | x_i16 > x_u64;
| ^^^^^ expected `i16`, found `u64`
|
help: you can convert an `u64` to `i16` and panic if the converted value wouldn't fit
|
LL | x_i16 > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:263:17
|
LL | x_i16 > x_u128;
| ^^^^^^ expected `i16`, found `u128`
|
help: you can convert an `u128` to `i16` and panic if the converted value wouldn't fit
|
LL | x_i16 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:265:17
|
LL | x_i16 > x_usize;
| ^^^^^^^ expected `i16`, found `usize`
|
help: you can convert an `usize` to `i16` and panic if the converted value wouldn't fit
|
LL | x_i16 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:268:17
|
LL | x_i32 > x_u8;
| ^^^^
| |
| expected `i32`, found `u8`
| help: you can convert an `u8` to `i32`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:270:17
|
LL | x_i32 > x_u16;
| ^^^^^
| |
| expected `i32`, found `u16`
| help: you can convert an `u16` to `i32`: `x_u16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:272:17
|
LL | x_i32 > x_u32;
| ^^^^^ expected `i32`, found `u32`
|
help: you can convert an `u32` to `i32` and panic if the converted value wouldn't fit
|
LL | x_i32 > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:274:17
|
LL | x_i32 > x_u64;
| ^^^^^ expected `i32`, found `u64`
|
help: you can convert an `u64` to `i32` and panic if the converted value wouldn't fit
|
LL | x_i32 > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:276:17
|
LL | x_i32 > x_u128;
| ^^^^^^ expected `i32`, found `u128`
|
help: you can convert an `u128` to `i32` and panic if the converted value wouldn't fit
|
LL | x_i32 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:278:17
|
LL | x_i32 > x_usize;
| ^^^^^^^ expected `i32`, found `usize`
|
help: you can convert an `usize` to `i32` and panic if the converted value wouldn't fit
|
LL | x_i32 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:281:17
|
LL | x_i64 > x_u8;
| ^^^^
| |
| expected `i64`, found `u8`
| help: you can convert an `u8` to `i64`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:283:17
|
LL | x_i64 > x_u16;
| ^^^^^
| |
| expected `i64`, found `u16`
| help: you can convert an `u16` to `i64`: `x_u16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:285:17
|
LL | x_i64 > x_u32;
| ^^^^^
| |
| expected `i64`, found `u32`
| help: you can convert an `u32` to `i64`: `x_u32.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:287:17
|
LL | x_i64 > x_u64;
| ^^^^^ expected `i64`, found `u64`
|
help: you can convert an `u64` to `i64` and panic if the converted value wouldn't fit
|
LL | x_i64 > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:289:17
|
LL | x_i64 > x_u128;
| ^^^^^^ expected `i64`, found `u128`
|
help: you can convert an `u128` to `i64` and panic if the converted value wouldn't fit
|
LL | x_i64 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:291:17
|
LL | x_i64 > x_usize;
| ^^^^^^^ expected `i64`, found `usize`
|
help: you can convert an `usize` to `i64` and panic if the converted value wouldn't fit
|
LL | x_i64 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:294:18
|
LL | x_i128 > x_u8;
| ^^^^
| |
| expected `i128`, found `u8`
| help: you can convert an `u8` to `i128`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:296:18
|
LL | x_i128 > x_u16;
| ^^^^^
| |
| expected `i128`, found `u16`
| help: you can convert an `u16` to `i128`: `x_u16.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:298:18
|
LL | x_i128 > x_u32;
| ^^^^^
| |
| expected `i128`, found `u32`
| help: you can convert an `u32` to `i128`: `x_u32.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:300:18
|
LL | x_i128 > x_u64;
| ^^^^^
| |
| expected `i128`, found `u64`
| help: you can convert an `u64` to `i128`: `x_u64.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:302:18
|
LL | x_i128 > x_u128;
| ^^^^^^ expected `i128`, found `u128`
|
help: you can convert an `u128` to `i128` and panic if the converted value wouldn't fit
|
LL | x_i128 > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:304:18
|
LL | x_i128 > x_usize;
| ^^^^^^^ expected `i128`, found `usize`
|
help: you can convert an `usize` to `i128` and panic if the converted value wouldn't fit
|
LL | x_i128 > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:307:19
|
LL | x_isize > x_u8;
| ^^^^
| |
| expected `isize`, found `u8`
| help: you can convert an `u8` to `isize`: `x_u8.into()`
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:309:19
|
LL | x_isize > x_u16;
| ^^^^^ expected `isize`, found `u16`
|
help: you can convert an `u16` to `isize` and panic if the converted value wouldn't fit
|
LL | x_isize > x_u16.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:311:19
|
LL | x_isize > x_u32;
| ^^^^^ expected `isize`, found `u32`
|
help: you can convert an `u32` to `isize` and panic if the converted value wouldn't fit
|
LL | x_isize > x_u32.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:313:19
|
LL | x_isize > x_u64;
| ^^^^^ expected `isize`, found `u64`
|
help: you can convert an `u64` to `isize` and panic if the converted value wouldn't fit
|
LL | x_isize > x_u64.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:315:19
|
LL | x_isize > x_u128;
| ^^^^^^ expected `isize`, found `u128`
|
help: you can convert an `u128` to `isize` and panic if the converted value wouldn't fit
|
LL | x_isize > x_u128.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/numeric-cast-binop.rs:317:19
|
LL | x_isize > x_usize;
| ^^^^^^^ expected `isize`, found `usize`
|
help: you can convert an `usize` to `isize` and panic if the converted value wouldn't fit
|
LL | x_isize > x_usize.try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 132 previous errors
For more information about this error, try `rustc --explain E0308`.