nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 16:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Simplify suggestion.

Browse Source
This commit is contained in:
Markus Reiter 2024-04-23 21:19:12 +02:00
parent 3fe0be9e38
commit 7531eafa7e
No known key found for this signature in database
GPG Key ID: 245293B51702655B
3 changed files with 22 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View File

@ -2227,7 +2227,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) -> bool {
let tcx = self.tcx;
let (adt, args, unwrap) = match expected.kind() {
// In case Option<NonZero*> is wanted, but * is provided, suggest calling new
// In case `Option<NonZero<T>>` is wanted, but `T` is provided, suggest calling `new`.
ty::Adt(adt, args) if tcx.is_diagnostic_item(sym::Option, adt.did()) => {
let nonzero_type = args.type_at(0); // Unwrap option type.
let ty::Adt(adt, args) = nonzero_type.kind() else {
@ -2235,7 +2235,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
(adt, args, "")
}
// In case `NonZero<*>` is wanted but `*` is provided, also add `.unwrap()` to satisfy types.
// In case `NonZero<T>` is wanted but `T` is provided, also add `.unwrap()` to satisfy types.
ty::Adt(adt, args) => (adt, args, ".unwrap()"),
_ => return false,
};
@ -2244,32 +2244,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
return false;
}
// FIXME: This can be simplified once `NonZero<T>` is stable.
let coercable_types = [
("NonZeroU8", tcx.types.u8),
("NonZeroU16", tcx.types.u16),
("NonZeroU32", tcx.types.u32),
("NonZeroU64", tcx.types.u64),
("NonZeroU128", tcx.types.u128),
("NonZeroI8", tcx.types.i8),
("NonZeroI16", tcx.types.i16),
("NonZeroI32", tcx.types.i32),
("NonZeroI64", tcx.types.i64),
("NonZeroI128", tcx.types.i128),
];
let int_type = args.type_at(0);
let Some(nonzero_alias) = coercable_types.iter().find_map(|(nonzero_alias, t)| {
if *t == int_type && self.can_coerce(expr_ty, *t) { Some(nonzero_alias) } else { None }
}) else {
if !self.can_coerce(expr_ty, int_type) {
return false;
};
}
err.multipart_suggestion(
format!("consider calling `{nonzero_alias}::new`"),
format!("consider calling `{}::new`", sym::NonZero),
vec![
(expr.span.shrink_to_lo(), format!("{nonzero_alias}::new(")),
(expr.span.shrink_to_lo(), format!("{}::new(", sym::NonZero)),
(expr.span.shrink_to_hi(), format!("){unwrap}")),
],
Applicability::MaybeIncorrect,

8
tests/ui/mismatched_types/non_zero_assigned_something.rs
View File

@ -1,9 +1,9 @@
fn main() {
let _: std::num::NonZeroU64 = 1;
let _: std::num::NonZero<u64> = 1;
//~^ ERROR mismatched types
//~| HELP consider calling `NonZeroU64::new`
//~| HELP consider calling `NonZero::new`
let _: Option<std::num::NonZeroU64> = 1;
let _: Option<std::num::NonZero<u64>> = 1;
//~^ ERROR mismatched types
//~| HELP consider calling `NonZeroU64::new`
//~| HELP consider calling `NonZero::new`
}

24
tests/ui/mismatched_types/non_zero_assigned_something.stderr
View File

@ -1,32 +1,32 @@
error[E0308]: mismatched types
--> $DIR/non_zero_assigned_something.rs:2:35
--> $DIR/non_zero_assigned_something.rs:2:37
|
LL | let _: std::num::NonZeroU64 = 1;
| -------------------- ^ expected `NonZero<u64>`, found integer
LL | let _: std::num::NonZero<u64> = 1;
| ---------------------- ^ expected `NonZero<u64>`, found integer
| |
| expected due to this
|
= note: expected struct `NonZero<u64>`
found type `{integer}`
help: consider calling `NonZeroU64::new`
help: consider calling `NonZero::new`
|
LL | let _: std::num::NonZeroU64 = NonZeroU64::new(1).unwrap();
| ++++++++++++++++ ++++++++++
LL | let _: std::num::NonZero<u64> = NonZero::new(1).unwrap();
| +++++++++++++ ++++++++++
error[E0308]: mismatched types
--> $DIR/non_zero_assigned_something.rs:6:43
--> $DIR/non_zero_assigned_something.rs:6:45
|
LL | let _: Option<std::num::NonZeroU64> = 1;
| ---------------------------- ^ expected `Option<NonZero<u64>>`, found integer
LL | let _: Option<std::num::NonZero<u64>> = 1;
| ------------------------------ ^ expected `Option<NonZero<u64>>`, found integer
| |
| expected due to this
|
= note: expected enum `Option<NonZero<u64>>`
found type `{integer}`
help: consider calling `NonZeroU64::new`
help: consider calling `NonZero::new`
|
LL | let _: Option<std::num::NonZeroU64> = NonZeroU64::new(1);
| ++++++++++++++++ +
LL | let _: Option<std::num::NonZero<u64>> = NonZero::new(1);
| +++++++++++++ +
error: aborting due to 2 previous errors