src/librustc_typeck/check/demand.rs

   1 use crate::check::FnCtxt;
   2 use rustc::infer::InferOk;
   3 use rustc::traits::{self, ObligationCause, ObligationCauseCode};
   4
   5 use syntax::symbol::sym;
   6 use syntax::util::parser::PREC_POSTFIX;
   7 use syntax_pos::Span;
   8 use rustc::hir;
   9 use rustc::hir::Node;
  10 use rustc::hir::{print, lowering::is_range_literal};
  11 use rustc::ty::{self, Ty, AssocItem};
  12 use rustc::ty::adjustment::AllowTwoPhase;
  13 use errors::{Applicability, DiagnosticBuilder};
  14
  15 use super::method::probe;
  16
  17 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  18     // Requires that the two types unify, and prints an error message if
  19     // they don't.
  20     pub fn demand_suptype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
  21         self.demand_suptype_diag(sp, expected, actual).map(|mut e| e.emit());
  22     }
  23
  24     pub fn demand_suptype_diag(&self,
  25                                sp: Span,
  26                                expected: Ty<'tcx>,
  27                                actual: Ty<'tcx>) -> Option<DiagnosticBuilder<'tcx>> {
  28         let cause = &self.misc(sp);
  29         match self.at(cause, self.param_env).sup(expected, actual) {
  30             Ok(InferOk { obligations, value: () }) => {
  31                 self.register_predicates(obligations);
  32                 None
  33             },
  34             Err(e) => {
  35                 Some(self.report_mismatched_types(&cause, expected, actual, e))
  36             }
  37         }
  38     }
  39
  40     pub fn demand_eqtype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
  41         if let Some(mut err) = self.demand_eqtype_diag(sp, expected, actual) {
  42             err.emit();
  43         }
  44     }
  45
  46     pub fn demand_eqtype_diag(&self,
  47                              sp: Span,
  48                              expected: Ty<'tcx>,
  49                              actual: Ty<'tcx>) -> Option<DiagnosticBuilder<'tcx>> {
  50         self.demand_eqtype_with_origin(&self.misc(sp), expected, actual)
  51     }
  52
  53     pub fn demand_eqtype_with_origin(&self,
  54                                      cause: &ObligationCause<'tcx>,
  55                                      expected: Ty<'tcx>,
  56                                      actual: Ty<'tcx>) -> Option<DiagnosticBuilder<'tcx>> {
  57         match self.at(cause, self.param_env).eq(expected, actual) {
  58             Ok(InferOk { obligations, value: () }) => {
  59                 self.register_predicates(obligations);
  60                 None
  61             }
  62             Err(e) => {
  63                 Some(self.report_mismatched_types(cause, expected, actual, e))
  64             }
  65         }
  66     }
  67
  68     pub fn demand_eqtype_pat(
  69         &self,
  70         cause_span: Span,
  71         expected: Ty<'tcx>,
  72         actual: Ty<'tcx>,
  73         match_expr_span: Option<Span>,
  74     ) {
  75         let cause = if let Some(span) = match_expr_span {
  76             self.cause(
  77                 cause_span,
  78                 ObligationCauseCode::MatchExpressionArmPattern { span, ty: expected },
  79             )
  80         } else {
  81             self.misc(cause_span)
  82         };
  83         self.demand_eqtype_with_origin(&cause, expected, actual).map(|mut err| err.emit());
  84     }
  85
  86
  87     pub fn demand_coerce(&self,
  88                          expr: &hir::Expr,
  89                          checked_ty: Ty<'tcx>,
  90                          expected: Ty<'tcx>,
  91                          allow_two_phase: AllowTwoPhase)
  92                          -> Ty<'tcx> {
  93         let (ty, err) = self.demand_coerce_diag(expr, checked_ty, expected, allow_two_phase);
  94         if let Some(mut err) = err {
  95             err.emit();
  96         }
  97         ty
  98     }
  99
 100     // Checks that the type of `expr` can be coerced to `expected`.
 101     //
 102     // N.B., this code relies on `self.diverges` to be accurate. In
 103     // particular, assignments to `!` will be permitted if the
 104     // diverges flag is currently "always".
 105     pub fn demand_coerce_diag(&self,
 106                               expr: &hir::Expr,
 107                               checked_ty: Ty<'tcx>,
 108                               expected: Ty<'tcx>,
 109                               allow_two_phase: AllowTwoPhase)
 110                               -> (Ty<'tcx>, Option<DiagnosticBuilder<'tcx>>) {
 111         let expected = self.resolve_type_vars_with_obligations(expected);
 112
 113         let e = match self.try_coerce(expr, checked_ty, expected, allow_two_phase) {
 114             Ok(ty) => return (ty, None),
 115             Err(e) => e
 116         };
 117
 118         let expr = expr.peel_drop_temps();
 119         let cause = self.misc(expr.span);
 120         let expr_ty = self.resolve_type_vars_with_obligations(checked_ty);
 121         let mut err = self.report_mismatched_types(&cause, expected, expr_ty, e);
 122
 123         if self.is_assign_to_bool(expr, expected) {
 124             // Error reported in `check_assign` so avoid emitting error again.
 125             err.delay_as_bug();
 126             return (expected, None)
 127         }
 128
 129         self.suggest_compatible_variants(&mut err, expr, expected, expr_ty);
 130         self.suggest_ref_or_into(&mut err, expr, expected, expr_ty);
 131         self.suggest_boxing_when_appropriate(&mut err, expr, expected, expr_ty);
 132         self.suggest_missing_await(&mut err, expr, expected, expr_ty);
 133
 134         (expected, Some(err))
 135     }
 136
 137     /// Returns whether the expected type is `bool` and the expression is `x = y`.
 138     pub fn is_assign_to_bool(&self, expr: &hir::Expr, expected: Ty<'tcx>) -> bool {
 139         if let hir::ExprKind::Assign(..) = expr.kind {
 140             return expected == self.tcx.types.bool;
 141         }
 142         false
 143     }
 144
 145     /// If the expected type is an enum (Issue #55250) with any variants whose
 146     /// sole field is of the found type, suggest such variants. (Issue #42764)
 147     fn suggest_compatible_variants(
 148         &self,
 149         err: &mut DiagnosticBuilder<'_>,
 150         expr: &hir::Expr,
 151         expected: Ty<'tcx>,
 152         expr_ty: Ty<'tcx>,
 153     ) {
 154         if let ty::Adt(expected_adt, substs) = expected.kind {
 155             if !expected_adt.is_enum() {
 156                 return;
 157             }
 158
 159             let mut compatible_variants = expected_adt.variants
 160                 .iter()
 161                 .filter(|variant| variant.fields.len() == 1)
 162                 .filter_map(|variant| {
 163                     let sole_field = &variant.fields[0];
 164                     let sole_field_ty = sole_field.ty(self.tcx, substs);
 165                     if self.can_coerce(expr_ty, sole_field_ty) {
 166                         let variant_path = self.tcx.def_path_str(variant.def_id);
 167                         // FIXME #56861: DRYer prelude filtering
 168                         Some(variant_path.trim_start_matches("std::prelude::v1::").to_string())
 169                     } else {
 170                         None
 171                     }
 172                 }).peekable();
 173
 174             if compatible_variants.peek().is_some() {
 175                 let expr_text = print::to_string(print::NO_ANN, |s| s.print_expr(expr));
 176                 let suggestions = compatible_variants
 177                     .map(|v| format!("{}({})", v, expr_text));
 178                 let msg = "try using a variant of the expected type";
 179                 err.span_suggestions(expr.span, msg, suggestions, Applicability::MaybeIncorrect);
 180             }
 181         }
 182     }
 183
 184     pub fn get_conversion_methods(&self, span: Span, expected: Ty<'tcx>, checked_ty: Ty<'tcx>)
 185                               -> Vec<AssocItem> {
 186         let mut methods = self.probe_for_return_type(span,
 187                                                      probe::Mode::MethodCall,
 188                                                      expected,
 189                                                      checked_ty,
 190                                                      hir::DUMMY_HIR_ID);
 191         methods.retain(|m| {
 192             self.has_no_input_arg(m) &&
 193                 self.tcx.get_attrs(m.def_id).iter()
 194                 // This special internal attribute is used to whitelist
 195                 // "identity-like" conversion methods to be suggested here.
 196                 //
 197                 // FIXME (#46459 and #46460): ideally
 198                 // `std::convert::Into::into` and `std::borrow:ToOwned` would
 199                 // also be `#[rustc_conversion_suggestion]`, if not for
 200                 // method-probing false-positives and -negatives (respectively).
 201                 //
 202                 // FIXME? Other potential candidate methods: `as_ref` and
 203                 // `as_mut`?
 204                 .find(|a| a.check_name(sym::rustc_conversion_suggestion)).is_some()
 205         });
 206
 207         methods
 208     }
 209
 210     // This function checks if the method isn't static and takes other arguments than `self`.
 211     fn has_no_input_arg(&self, method: &AssocItem) -> bool {
 212         match method.kind {
 213             ty::AssocKind::Method => {
 214                 self.tcx.fn_sig(method.def_id).inputs().skip_binder().len() == 1
 215             }
 216             _ => false,
 217         }
 218     }
 219
 220     /// Identify some cases where `as_ref()` would be appropriate and suggest it.
 221     ///
 222     /// Given the following code:
 223     /// ```
 224     /// struct Foo;
 225     /// fn takes_ref(_: &Foo) {}
 226     /// let ref opt = Some(Foo);
 227     ///
 228     /// opt.map(|param| takes_ref(param));
 229     /// ```
 230     /// Suggest using `opt.as_ref().map(|param| takes_ref(param));` instead.
 231     ///
 232     /// It only checks for `Option` and `Result` and won't work with
 233     /// ```
 234     /// opt.map(|param| { takes_ref(param) });
 235     /// ```
 236     fn can_use_as_ref(
 237         &self,
 238         expr: &hir::Expr,
 239     ) -> Option<(Span, &'static str, String)> {
 240         let path = match expr.kind {
 241             hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => path,
 242             _ => return None
 243         };
 244
 245         let local_id = match path.res {
 246             hir::def::Res::Local(id) => id,
 247             _ => return None
 248         };
 249
 250         let local_parent = self.tcx.hir().get_parent_node(local_id);
 251         let param_hir_id = match self.tcx.hir().find(local_parent) {
 252             Some(Node::Param(hir::Param { hir_id, .. })) => hir_id,
 253             _ => return None
 254         };
 255
 256         let param_parent = self.tcx.hir().get_parent_node(*param_hir_id);
 257         let (expr_hir_id, closure_fn_decl) = match self.tcx.hir().find(param_parent) {
 258             Some(Node::Expr(
 259                 hir::Expr { hir_id, kind: hir::ExprKind::Closure(_, decl, ..), .. }
 260             )) => (hir_id, decl),
 261             _ => return None
 262         };
 263
 264         let expr_parent = self.tcx.hir().get_parent_node(*expr_hir_id);
 265         let hir = self.tcx.hir().find(expr_parent);
 266         let closure_params_len = closure_fn_decl.inputs.len();
 267         let (method_path, method_span, method_expr) = match (hir, closure_params_len) {
 268             (Some(Node::Expr(
 269                 hir::Expr { kind: hir::ExprKind::MethodCall(path, span, expr), .. }
 270             )), 1) => (path, span, expr),
 271             _ => return None
 272         };
 273
 274         let self_ty = self.tables.borrow().node_type(method_expr[0].hir_id);
 275         let self_ty = format!("{:?}", self_ty);
 276         let name = method_path.ident.as_str();
 277         let is_as_ref_able = (
 278             self_ty.starts_with("&std::option::Option") ||
 279             self_ty.starts_with("&std::result::Result") ||
 280             self_ty.starts_with("std::option::Option") ||
 281             self_ty.starts_with("std::result::Result")
 282         ) && (name == "map" || name == "and_then");
 283         match (is_as_ref_able, self.sess().source_map().span_to_snippet(*method_span)) {
 284             (true, Ok(src)) => {
 285                 let suggestion = format!("as_ref().{}", src);
 286                 Some((*method_span, "consider using `as_ref` instead", suggestion))
 287             },
 288             _ => None
 289         }
 290     }
 291
 292     crate fn is_hir_id_from_struct_pattern_shorthand_field(
 293         &self,
 294         hir_id: hir::HirId,
 295         sp: Span,
 296     ) -> bool {
 297         let cm = self.sess().source_map();
 298         let parent_id = self.tcx.hir().get_parent_node(hir_id);
 299         if let Some(parent) = self.tcx.hir().find(parent_id) {
 300             // Account for fields
 301             if let Node::Expr(hir::Expr {
 302                 kind: hir::ExprKind::Struct(_, fields, ..), ..
 303             }) = parent {
 304                 if let Ok(src) = cm.span_to_snippet(sp) {
 305                     for field in fields {
 306                         if field.ident.as_str() == src.as_str() && field.is_shorthand {
 307                             return true;
 308                         }
 309                     }
 310                 }
 311             }
 312         }
 313         false
 314     }
 315
 316     /// This function is used to determine potential "simple" improvements or users' errors and
 317     /// provide them useful help. For example:
 318     ///
 319     /// ```
 320     /// fn some_fn(s: &str) {}
 321     ///
 322     /// let x = "hey!".to_owned();
 323     /// some_fn(x); // error
 324     /// ```
 325     ///
 326     /// No need to find every potential function which could make a coercion to transform a
 327     /// `String` into a `&str` since a `&` would do the trick!
 328     ///
 329     /// In addition of this check, it also checks between references mutability state. If the
 330     /// expected is mutable but the provided isn't, maybe we could just say "Hey, try with
 331     /// `&mut`!".
 332     pub fn check_ref(
 333         &self,
 334         expr: &hir::Expr,
 335         checked_ty: Ty<'tcx>,
 336         expected: Ty<'tcx>,
 337     ) -> Option<(Span, &'static str, String)> {
 338         let cm = self.sess().source_map();
 339         let sp = expr.span;
 340         if !cm.span_to_filename(sp).is_real() {
 341             // Ignore if span is from within a macro #41858, #58298. We previously used the macro
 342             // call span, but that breaks down when the type error comes from multiple calls down.
 343             return None;
 344         }
 345
 346         let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
 347             expr.hir_id,
 348             sp,
 349         );
 350
 351         // If the span is from a macro, then it's hard to extract the text
 352         // and make a good suggestion, so don't bother.
 353         let is_macro = sp.from_expansion() && sp.desugaring_kind().is_none();
 354
 355         // `ExprKind::DropTemps` is semantically irrelevant for these suggestions.
 356         let expr = expr.peel_drop_temps();
 357
 358         match (&expr.kind, &expected.kind, &checked_ty.kind) {
 359             (_, &ty::Ref(_, exp, _), &ty::Ref(_, check, _)) => match (&exp.kind, &check.kind) {
 360                 (&ty::Str, &ty::Array(arr, _)) |
 361                 (&ty::Str, &ty::Slice(arr)) if arr == self.tcx.types.u8 => {
 362                     if let hir::ExprKind::Lit(_) = expr.kind {
 363                         if let Ok(src) = cm.span_to_snippet(sp) {
 364                             if src.starts_with("b\"") {
 365                                 return Some((sp,
 366                                              "consider removing the leading `b`",
 367                                              src[1..].to_string()));
 368                             }
 369                         }
 370                     }
 371                 },
 372                 (&ty::Array(arr, _), &ty::Str) |
 373                 (&ty::Slice(arr), &ty::Str) if arr == self.tcx.types.u8 => {
 374                     if let hir::ExprKind::Lit(_) = expr.kind {
 375                         if let Ok(src) = cm.span_to_snippet(sp) {
 376                             if src.starts_with("\"") {
 377                                 return Some((sp,
 378                                              "consider adding a leading `b`",
 379                                              format!("b{}", src)));
 380                             }
 381                         }
 382                     }
 383                 }
 384                 _ => {}
 385             },
 386             (_, &ty::Ref(_, _, mutability), _) => {
 387                 // Check if it can work when put into a ref. For example:
 388                 //
 389                 // ```
 390                 // fn bar(x: &mut i32) {}
 391                 //
 392                 // let x = 0u32;
 393                 // bar(&x); // error, expected &mut
 394                 // ```
 395                 let ref_ty = match mutability {
 396                     hir::Mutability::MutMutable => {
 397                         self.tcx.mk_mut_ref(self.tcx.mk_region(ty::ReStatic), checked_ty)
 398                     }
 399                     hir::Mutability::MutImmutable => {
 400                         self.tcx.mk_imm_ref(self.tcx.mk_region(ty::ReStatic), checked_ty)
 401                     }
 402                 };
 403                 if self.can_coerce(ref_ty, expected) {
 404                     let mut sugg_sp = sp;
 405                     if let hir::ExprKind::MethodCall(segment, _sp, args) = &expr.kind {
 406                         let clone_trait = self.tcx.lang_items().clone_trait().unwrap();
 407                         if let ([arg], Some(true), "clone") = (
 408                             &args[..],
 409                             self.tables.borrow().type_dependent_def_id(expr.hir_id).map(|did| {
 410                                 let ai = self.tcx.associated_item(did);
 411                                 ai.container == ty::TraitContainer(clone_trait)
 412                             }),
 413                             &segment.ident.as_str()[..],
 414                         ) {
 415                             // If this expression had a clone call when suggesting borrowing
 416                             // we want to suggest removing it because it'd now be unecessary.
 417                             sugg_sp = arg.span;
 418                         }
 419                     }
 420                     if let Ok(src) = cm.span_to_snippet(sugg_sp) {
 421                         let needs_parens = match expr.kind {
 422                             // parenthesize if needed (Issue #46756)
 423                             hir::ExprKind::Cast(_, _) |
 424                             hir::ExprKind::Binary(_, _, _) => true,
 425                             // parenthesize borrows of range literals (Issue #54505)
 426                             _ if is_range_literal(self.tcx.sess, expr) => true,
 427                             _ => false,
 428                         };
 429                         let sugg_expr = if needs_parens {
 430                             format!("({})", src)
 431                         } else {
 432                             src
 433                         };
 434
 435                         if let Some(sugg) = self.can_use_as_ref(expr) {
 436                             return Some(sugg);
 437                         }
 438                         let field_name = if is_struct_pat_shorthand_field {
 439                             format!("{}: ", sugg_expr)
 440                         } else {
 441                             String::new()
 442                         };
 443                         if let Some(hir::Node::Expr(hir::Expr {
 444                             kind: hir::ExprKind::Assign(left_expr, _),
 445                             ..
 446                         })) = self.tcx.hir().find(
 447                             self.tcx.hir().get_parent_node(expr.hir_id),
 448                         ) {
 449                             if mutability == hir::Mutability::MutMutable {
 450                                 // Found the following case:
 451                                 // fn foo(opt: &mut Option<String>){ opt = None }
 452                                 //                                   ---   ^^^^
 453                                 //                                   |     |
 454                                 //    consider dereferencing here: `*opt`  |
 455                                 // expected mutable reference, found enum `Option`
 456                                 if let Ok(src) = cm.span_to_snippet(left_expr.span) {
 457                                     return Some((
 458                                         left_expr.span,
 459                                         "consider dereferencing here to assign to the mutable \
 460                                          borrowed piece of memory",
 461                                         format!("*{}", src),
 462                                     ));
 463                                 }
 464                             }
 465                         }
 466
 467                         return Some(match mutability {
 468                             hir::Mutability::MutMutable => (
 469                                 sp,
 470                                 "consider mutably borrowing here",
 471                                 format!("{}&mut {}", field_name, sugg_expr),
 472                             ),
 473                             hir::Mutability::MutImmutable => (
 474                                 sp,
 475                                 "consider borrowing here",
 476                                 format!("{}&{}", field_name, sugg_expr),
 477                             ),
 478                         });
 479                     }
 480                 }
 481             },
 482             (hir::ExprKind::AddrOf(_, ref expr), _, &ty::Ref(_, checked, _)) if {
 483                 self.infcx.can_sub(self.param_env, checked, &expected).is_ok() && !is_macro
 484             } => {
 485                 // We have `&T`, check if what was expected was `T`. If so,
 486                 // we may want to suggest removing a `&`.
 487                 if !cm.span_to_filename(expr.span).is_real() {
 488                     if let Ok(code) = cm.span_to_snippet(sp) {
 489                         if code.chars().next() == Some('&') {
 490                             return Some((
 491                                 sp,
 492                                 "consider removing the borrow",
 493                                 code[1..].to_string(),
 494                             ));
 495                         }
 496                     }
 497                     return None;
 498                 }
 499                 if let Ok(code) = cm.span_to_snippet(expr.span) {
 500                     return Some((sp, "consider removing the borrow", code));
 501                 }
 502             },
 503             _ if sp == expr.span && !is_macro => {
 504                 // Check for `Deref` implementations by constructing a predicate to
 505                 // prove: `<T as Deref>::Output == U`
 506                 let deref_trait = self.tcx.lang_items().deref_trait().unwrap();
 507                 let item_def_id = self.tcx.associated_items(deref_trait).next().unwrap().def_id;
 508                 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
 509                     // `<T as Deref>::Output`
 510                     projection_ty: ty::ProjectionTy {
 511                         // `T`
 512                         substs: self.tcx.mk_substs_trait(
 513                             checked_ty,
 514                             self.fresh_substs_for_item(sp, item_def_id),
 515                         ),
 516                         // `Deref::Output`
 517                         item_def_id,
 518                     },
 519                     // `U`
 520                     ty: expected,
 521                 }));
 522                 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
 523                 let impls_deref = self.infcx.predicate_may_hold(&obligation);
 524
 525                 // For a suggestion to make sense, the type would need to be `Copy`.
 526                 let is_copy = self.infcx.type_is_copy_modulo_regions(self.param_env, expected, sp);
 527
 528                 if is_copy && impls_deref {
 529                     if let Ok(code) = cm.span_to_snippet(sp) {
 530                         let message = if checked_ty.is_region_ptr() {
 531                             "consider dereferencing the borrow"
 532                         } else {
 533                             "consider dereferencing the type"
 534                         };
 535                         let suggestion = if is_struct_pat_shorthand_field {
 536                             format!("{}: *{}", code, code)
 537                         } else {
 538                             format!("*{}", code)
 539                         };
 540                         return Some((sp, message, suggestion));
 541                     }
 542                 }
 543             }
 544             _ => {}
 545         }
 546         None
 547     }
 548
 549     pub fn check_for_cast(
 550         &self,
 551         err: &mut DiagnosticBuilder<'tcx>,
 552         expr: &hir::Expr,
 553         checked_ty: Ty<'tcx>,
 554         expected_ty: Ty<'tcx>,
 555     ) -> bool {
 556         if self.tcx.hir().is_const_context(expr.hir_id) {
 557             // Shouldn't suggest `.into()` on `const`s.
 558             // FIXME(estebank): modify once we decide to suggest `as` casts
 559             return false;
 560         }
 561         if !self.tcx.sess.source_map().span_to_filename(expr.span).is_real() {
 562             // Ignore if span is from within a macro.
 563             return false;
 564         }
 565
 566         // If casting this expression to a given numeric type would be appropriate in case of a type
 567         // mismatch.
 568         //
 569         // We want to minimize the amount of casting operations that are suggested, as it can be a
 570         // lossy operation with potentially bad side effects, so we only suggest when encountering
 571         // an expression that indicates that the original type couldn't be directly changed.
 572         //
 573         // For now, don't suggest casting with `as`.
 574         let can_cast = false;
 575
 576         let mut prefix = String::new();
 577         if let Some(hir::Node::Expr(hir::Expr {
 578             kind: hir::ExprKind::Struct(_, fields, _),
 579             ..
 580         })) = self.tcx.hir().find(self.tcx.hir().get_parent_node(expr.hir_id)) {
 581             // `expr` is a literal field for a struct, only suggest if appropriate
 582             for field in fields {
 583                 if field.expr.hir_id == expr.hir_id && field.is_shorthand {
 584                     // This is a field literal
 585                     prefix = format!("{}: ", field.ident);
 586                     break;
 587                 }
 588             }
 589             if &prefix == "" {
 590                 // Likely a field was meant, but this field wasn't found. Do not suggest anything.
 591                 return false;
 592             }
 593         }
 594         if let hir::ExprKind::Call(path, args) = &expr.kind {
 595             if let (
 596                 hir::ExprKind::Path(hir::QPath::TypeRelative(base_ty, path_segment)),
 597                 1,
 598             ) = (&path.kind, args.len()) {
 599                 // `expr` is a conversion like `u32::from(val)`, do not suggest anything (#63697).
 600                 if let (
 601                     hir::TyKind::Path(hir::QPath::Resolved(None, base_ty_path)),
 602                     sym::from,
 603                 ) = (&base_ty.kind, path_segment.ident.name) {
 604                     if let Some(ident) = &base_ty_path.segments.iter().map(|s| s.ident).next() {
 605                         match ident.name {
 606                             sym::i128 | sym::i64 | sym::i32 | sym::i16 | sym::i8 |
 607                             sym::u128 | sym::u64 | sym::u32 | sym::u16 | sym::u8 |
 608                             sym::isize | sym::usize
 609                             if base_ty_path.segments.len() == 1 => {
 610                                 return false;
 611                             }
 612                             _ => {}
 613                         }
 614                     }
 615                 }
 616             }
 617         }
 618
 619         let msg = format!("you can convert an `{}` to `{}`", checked_ty, expected_ty);
 620         let cast_msg = format!("you can cast an `{} to `{}`", checked_ty, expected_ty);
 621         let try_msg = format!("{} and panic if the converted value wouldn't fit", msg);
 622         let lit_msg = format!(
 623             "change the type of the numeric literal from `{}` to `{}`",
 624             checked_ty,
 625             expected_ty,
 626         );
 627
 628         let needs_paren = expr.precedence().order() < (PREC_POSTFIX as i8);
 629
 630         if let Ok(src) = self.tcx.sess.source_map().span_to_snippet(expr.span) {
 631             let cast_suggestion = format!(
 632                 "{}{}{}{} as {}",
 633                 prefix,
 634                 if needs_paren { "(" } else { "" },
 635                 src,
 636                 if needs_paren { ")" } else { "" },
 637                 expected_ty,
 638             );
 639             let try_into_suggestion = format!(
 640                 "{}{}{}{}.try_into().unwrap()",
 641                 prefix,
 642                 if needs_paren { "(" } else { "" },
 643                 src,
 644                 if needs_paren { ")" } else { "" },
 645             );
 646             let into_suggestion = format!(
 647                 "{}{}{}{}.into()",
 648                 prefix,
 649                 if needs_paren { "(" } else { "" },
 650                 src,
 651                 if needs_paren { ")" } else { "" },
 652             );
 653             let suffix_suggestion = format!(
 654                 "{}{}{}{}",
 655                 if needs_paren { "(" } else { "" },
 656                 if let (ty::Int(_), ty::Float(_)) | (ty::Uint(_), ty::Float(_)) = (
 657                     &expected_ty.kind,
 658                     &checked_ty.kind,
 659                 ) {
 660                     // Remove fractional part from literal, for example `42.0f32` into `42`
 661                     let src = src.trim_end_matches(&checked_ty.to_string());
 662                     src.split(".").next().unwrap()
 663                 } else {
 664                     src.trim_end_matches(&checked_ty.to_string())
 665                 },
 666                 expected_ty,
 667                 if needs_paren { ")" } else { "" },
 668             );
 669             let literal_is_ty_suffixed = |expr: &hir::Expr| {
 670                 if let hir::ExprKind::Lit(lit) = &expr.kind {
 671                     lit.node.is_suffixed()
 672                 } else {
 673                     false
 674                 }
 675             };
 676
 677             let suggest_to_change_suffix_or_into = |
 678                 err: &mut DiagnosticBuilder<'_>,
 679                 is_fallible: bool,
 680             | {
 681                 let into_sugg = into_suggestion.clone();
 682                 err.span_suggestion(
 683                     expr.span,
 684                     if literal_is_ty_suffixed(expr) {
 685                         &lit_msg
 686                     } else if is_fallible {
 687                         &try_msg
 688                     } else {
 689                         &msg
 690                     },
 691                     if literal_is_ty_suffixed(expr) {
 692                         suffix_suggestion.clone()
 693                     } else if is_fallible {
 694                         try_into_suggestion
 695                     } else {
 696                         into_sugg
 697                     },
 698                     Applicability::MachineApplicable,
 699                 );
 700             };
 701
 702             match (&expected_ty.kind, &checked_ty.kind) {
 703                 (&ty::Int(ref exp), &ty::Int(ref found)) => {
 704                     let is_fallible = match (found.bit_width(), exp.bit_width()) {
 705                         (Some(found), Some(exp)) if found > exp => true,
 706                         (None, _) | (_, None) => true,
 707                         _ => false,
 708                     };
 709                     suggest_to_change_suffix_or_into(err, is_fallible);
 710                     true
 711                 }
 712                 (&ty::Uint(ref exp), &ty::Uint(ref found)) => {
 713                     let is_fallible = match (found.bit_width(), exp.bit_width()) {
 714                         (Some(found), Some(exp)) if found > exp => true,
 715                         (None, _) | (_, None) => true,
 716                         _ => false,
 717                     };
 718                     suggest_to_change_suffix_or_into(err, is_fallible);
 719                     true
 720                 }
 721                 (&ty::Int(_), &ty::Uint(_)) | (&ty::Uint(_), &ty::Int(_)) => {
 722                     suggest_to_change_suffix_or_into(err, true);
 723                     true
 724                 }
 725                 (&ty::Float(ref exp), &ty::Float(ref found)) => {
 726                     if found.bit_width() < exp.bit_width() {
 727                         suggest_to_change_suffix_or_into(err, false);
 728                     } else if literal_is_ty_suffixed(expr) {
 729                         err.span_suggestion(
 730                             expr.span,
 731                             &lit_msg,
 732                             suffix_suggestion,
 733                             Applicability::MachineApplicable,
 734                         );
 735                     } else if can_cast { // Missing try_into implementation for `f64` to `f32`
 736                         err.span_suggestion(
 737                             expr.span,
 738                             &format!("{}, producing the closest possible value", cast_msg),
 739                             cast_suggestion,
 740                             Applicability::MaybeIncorrect,  // lossy conversion
 741                         );
 742                     }
 743                     true
 744                 }
 745                 (&ty::Uint(_), &ty::Float(_)) | (&ty::Int(_), &ty::Float(_)) => {
 746                     if literal_is_ty_suffixed(expr) {
 747                         err.span_suggestion(
 748                             expr.span,
 749                             &lit_msg,
 750                             suffix_suggestion,
 751                             Applicability::MachineApplicable,
 752                         );
 753                     } else if can_cast {
 754                         // Missing try_into implementation for `{float}` to `{integer}`
 755                         err.span_suggestion(
 756                             expr.span,
 757                             &format!("{}, rounding the float towards zero", msg),
 758                             cast_suggestion,
 759                             Applicability::MaybeIncorrect  // lossy conversion
 760                         );
 761                         err.warn("if the rounded value cannot be represented by the target \
 762                                   integer type, including `Inf` and `NaN`, casting will cause \
 763                                   undefined behavior \
 764                                   (https://github.com/rust-lang/rust/issues/10184)");
 765                     }
 766                     true
 767                 }
 768                 (&ty::Float(ref exp), &ty::Uint(ref found)) => {
 769                     // if `found` is `None` (meaning found is `usize`), don't suggest `.into()`
 770                     if exp.bit_width() > found.bit_width().unwrap_or(256) {
 771                         err.span_suggestion(
 772                             expr.span,
 773                             &format!(
 774                                 "{}, producing the floating point representation of the integer",
 775                                 msg,
 776                             ),
 777                             into_suggestion,
 778                             Applicability::MachineApplicable
 779                         );
 780                     } else if literal_is_ty_suffixed(expr) {
 781                         err.span_suggestion(
 782                             expr.span,
 783                             &lit_msg,
 784                             suffix_suggestion,
 785                             Applicability::MachineApplicable,
 786                         );
 787                     } else {
 788                         // Missing try_into implementation for `{integer}` to `{float}`
 789                         err.span_suggestion(
 790                             expr.span,
 791                             &format!(
 792                                 "{}, producing the floating point representation of the integer,
 793                                  rounded if necessary",
 794                                 cast_msg,
 795                             ),
 796                             cast_suggestion,
 797                             Applicability::MaybeIncorrect  // lossy conversion
 798                         );
 799                     }
 800                     true
 801                 }
 802                 (&ty::Float(ref exp), &ty::Int(ref found)) => {
 803                     // if `found` is `None` (meaning found is `isize`), don't suggest `.into()`
 804                     if exp.bit_width() > found.bit_width().unwrap_or(256) {
 805                         err.span_suggestion(
 806                             expr.span,
 807                             &format!(
 808                                 "{}, producing the floating point representation of the integer",
 809                                 &msg,
 810                             ),
 811                             into_suggestion,
 812                             Applicability::MachineApplicable
 813                         );
 814                     } else if literal_is_ty_suffixed(expr) {
 815                         err.span_suggestion(
 816                             expr.span,
 817                             &lit_msg,
 818                             suffix_suggestion,
 819                             Applicability::MachineApplicable,
 820                         );
 821                     } else {
 822                         // Missing try_into implementation for `{integer}` to `{float}`
 823                         err.span_suggestion(
 824                             expr.span,
 825                             &format!(
 826                                 "{}, producing the floating point representation of the integer, \
 827                                  rounded if necessary",
 828                                 &msg,
 829                             ),
 830                             cast_suggestion,
 831                             Applicability::MaybeIncorrect  // lossy conversion
 832                         );
 833                     }
 834                     true
 835                 }
 836                 _ => false,
 837             }
 838         } else {
 839             false
 840         }
 841     }
 842 }