From e243f623174e661e7e2392eb234a0af9ce9129cd Mon Sep 17 00:00:00 2001 From: Ayaz Hafiz Date: Tue, 9 Jun 2020 11:45:40 -0700 Subject: [PATCH] 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 --- src/librustc_typeck/check/coercion.rs | 2 +- src/librustc_typeck/check/demand.rs | 109 +- src/librustc_typeck/check/expr.rs | 23 +- src/librustc_typeck/check/mod.rs | 9 +- src/librustc_typeck/check/op.rs | 8 +- src/test/ui/numeric/numeric-cast-binop.rs | 315 ++++ src/test/ui/numeric/numeric-cast-binop.stderr | 1385 +++++++++++++++++ 7 files changed, 1801 insertions(+), 50 deletions(-) create mode 100644 src/test/ui/numeric/numeric-cast-binop.rs create mode 100644 src/test/ui/numeric/numeric-cast-binop.stderr diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index efafb05c040..96c0d98ab06 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -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. diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 7ac88698985..cc2244ccf40 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -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>) { 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, diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs index 266e9b21d69..902fae9dcd4 100644 --- a/src/librustc_typeck/check/expr.rs +++ b/src/librustc_typeck/check/expr.rs @@ -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); } _ => {} } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 18846813c45..657565949fe 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -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); diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs index d89993e3547..a3a27dc138b 100644 --- a/src/librustc_typeck/check/op.rs +++ b/src/librustc_typeck/check/op.rs @@ -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 { diff --git a/src/test/ui/numeric/numeric-cast-binop.rs b/src/test/ui/numeric/numeric-cast-binop.rs new file mode 100644 index 00000000000..3cecdf18c5b --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-binop.rs @@ -0,0 +1,315 @@ +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_i128: i128 = 8; + let x_i64: i64 = 9; + let x_i32: i32 = 10; + let x_i16: i16 = 11; + let x_i8: i8 = 12; + let x_i128: i128 = 13; + + /* 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 + } +} diff --git a/src/test/ui/numeric/numeric-cast-binop.stderr b/src/test/ui/numeric/numeric-cast-binop.stderr new file mode 100644 index 00000000000..f305c272558 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-binop.stderr @@ -0,0 +1,1385 @@ +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:18: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:20: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:22: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:24: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:26: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:29: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:31: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:33: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:35: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:37: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:40: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:42: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:44: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:46: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:48: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:51: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:53: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:55: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:57: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:59: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:62: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:64: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:66: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:68: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:70: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:73: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:75: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:77: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:79: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:81: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:87: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:89: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:91: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:93: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:95: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:98: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:100: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:102: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:104: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:106: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:109: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:111: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:113: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:115: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:117: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:120: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:122: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:124: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:126: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:128: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:131: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:133: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:135: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:137: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:139: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:142: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:144: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:146: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:148: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:150: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:156: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:158: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:160: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:162: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:164: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:166: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:169: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:171: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:173: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:175: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:177: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:179: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:182: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:184: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:186: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:188: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:190: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:192: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:195: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:197: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:199: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:201: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:203: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:205: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:208: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:210: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:212: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:214: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:216: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:218: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:221: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:223: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:225: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:227: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:229: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:231: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:237: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:239: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:241: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:243: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:245: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:247: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:250: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:252: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:254: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:256: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:258: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:260: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:263: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:265: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:267: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:269: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:271: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:273: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:276: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:278: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:280: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:282: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:284: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:286: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:289: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:291: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:293: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:295: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:297: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:299: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:302: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:304: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:306: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:308: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:310: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:312: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`. -- GitLab