mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make suggest_deref_or_ref return a multipart suggestion

Browse source
This commit is contained in:
Michael Goulet 2023-04-18 23:45:49 +00:00
parent a283f58183
commit 4731a25d2d
10 changed files with 235 additions and 176 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

121
compiler/rustc_hir_typeck/src/demand.rs
View file

@ -1087,7 +1087,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// ```ignore (illustrative)
/// opt.map(|param| { takes_ref(param) });
/// ```
fn can_use_as_ref(&self, expr: &hir::Expr<'_>) -> Option<(Span, &'static str, String)> {
fn can_use_as_ref(&self, expr: &hir::Expr<'_>) -> Option<(Vec<(Span, String)>, &'static str)> {
let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind else {
return None;
};
@ -1133,12 +1133,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
_ => false,
};
match (is_as_ref_able, self.sess().source_map().span_to_snippet(method_path.ident.span)) {
(true, Ok(src)) => {
let suggestion = format!("as_ref().{}", src);
Some((method_path.ident.span, "consider using `as_ref` instead", suggestion))
}
_ => None,
if is_as_ref_able {
Some((
vec![(method_path.ident.span.shrink_to_lo(), "as_ref().".to_string())],
"consider using `as_ref` instead",
))
} else {
None
}
}
@ -1223,8 +1224,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
checked_ty: Ty<'tcx>,
expected: Ty<'tcx>,
) -> Option<(
Span,
String,
Vec<(Span, String)>,
String,
Applicability,
bool, /* verbose */
@ -1254,30 +1254,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
&& let Ok(src) = sm.span_to_snippet(sp)
&& replace_prefix(&src, "b\"", "\"").is_some()
{
let pos = sp.lo() + BytePos(1);
return Some((
sp.with_hi(pos),
"consider removing the leading `b`".to_string(),
String::new(),
Applicability::MachineApplicable,
true,
false,
));
}
}
let pos = sp.lo() + BytePos(1);
return Some((
vec![(sp.with_hi(pos), String::new())],
"consider removing the leading `b`".to_string(),
Applicability::MachineApplicable,
true,
false,
));
}
}
(&ty::Array(arr, _) | &ty::Slice(arr), &ty::Str) if arr == self.tcx.types.u8 => {
if let hir::ExprKind::Lit(_) = expr.kind
&& let Ok(src) = sm.span_to_snippet(sp)
&& replace_prefix(&src, "\"", "b\"").is_some()
{
return Some((
sp.shrink_to_lo(),
"consider adding a leading `b`".to_string(),
"b".to_string(),
Applicability::MachineApplicable,
true,
false,
));
return Some((
vec![(sp.shrink_to_lo(), "b".to_string())],
"consider adding a leading `b`".to_string(),
Applicability::MachineApplicable,
true,
false,
));
}
}
_ => {}
@ -1320,14 +1318,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner) = expr.kind
&& let Some(1) = self.deref_steps(expected, checked_ty) {
&& let Some(1) = self.deref_steps(expected, checked_ty)
{
// We have `*&T`, check if what was expected was `&T`.
// If so, we may want to suggest removing a `*`.
sugg_sp = sugg_sp.with_hi(inner.span.lo());
return Some((
sugg_sp,
vec![(sugg_sp, String::new())],
"consider removing deref here".to_string(),
"".to_string(),
Applicability::MachineApplicable,
true,
false,
@ -1342,13 +1340,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
_ => false,
};
if let Some(sugg) = self.can_use_as_ref(expr) {
if let Some((sugg, msg)) = self.can_use_as_ref(expr) {
return Some((
sugg.0,
sugg.1.to_string(),
sugg.2,
sugg,
msg.to_string(),
Applicability::MachineApplicable,
false,
true,
false,
));
}
@ -1369,16 +1366,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
let (sp, sugg_expr, verbose) = if needs_parens {
let src = sm.span_to_snippet(sugg_sp).ok()?;
(sp, format!("({src})"), false)
let sugg = mutability.ref_prefix_str();
let (sugg, verbose) = if needs_parens {
(
vec![
(sp.shrink_to_lo(), format!("{prefix}{sugg}(")),
(sp.shrink_to_hi(), ")".to_string()),
],
false,
)
} else {
(sp.shrink_to_lo(), "".to_string(), true)
(vec![(sp.shrink_to_lo(), format!("{prefix}{sugg}"))], true)
};
return Some((
sp,
sugg,
format!("consider {}borrowing here", mutability.mutably_str()),
format!("{prefix}{}{sugg_expr}", mutability.ref_prefix_str()),
Applicability::MachineApplicable,
verbose,
false,
@ -1404,23 +1406,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
&& sm.is_span_accessible(call_span)
{
return Some((
sp.with_hi(call_span.lo()),
vec![(sp.with_hi(call_span.lo()), String::new())],
"consider removing the borrow".to_string(),
String::new(),
Applicability::MachineApplicable,
true,
true
true,
));
}
return None;
}
if sp.contains(expr.span)
&& sm.is_span_accessible(expr.span)
{
if sp.contains(expr.span) && sm.is_span_accessible(expr.span) {
return Some((
sp.with_hi(expr.span.lo()),
vec![(sp.with_hi(expr.span.lo()), String::new())],
"consider removing the borrow".to_string(),
String::new(),
Applicability::MachineApplicable,
true,
true,
@ -1444,23 +1442,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let suggestion = replace_prefix(&src, old_prefix, &new_prefix).map(|_| {
// skip `&` or `&mut ` if both mutabilities are mutable
let lo = sp.lo() + BytePos(min(old_prefix.len(), mutbl_b.ref_prefix_str().len()) as _);
let lo = sp.lo()
+ BytePos(min(old_prefix.len(), mutbl_b.ref_prefix_str().len()) as _);
// skip `&` or `&mut `
let hi = sp.lo() + BytePos(old_prefix.len() as _);
let sp = sp.with_lo(lo).with_hi(hi);
(
sp,
format!("{}{derefs}", if mutbl_a != mutbl_b { mutbl_b.prefix_str() } else { "" }),
if mutbl_b <= mutbl_a { Applicability::MachineApplicable } else { Applicability::MaybeIncorrect }
format!(
"{}{derefs}",
if mutbl_a != mutbl_b { mutbl_b.prefix_str() } else { "" }
),
if mutbl_b <= mutbl_a {
Applicability::MachineApplicable
} else {
Applicability::MaybeIncorrect
},
)
});
if let Some((span, src, applicability)) = suggestion {
return Some((
span,
vec![(span, src)],
"consider dereferencing".to_string(),
src,
applicability,
true,
false,
@ -1489,9 +1494,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// If we've reached our target type with just removing `&`, then just print now.
if steps == 0 && !remove.trim().is_empty() {
return Some((
prefix_span,
vec![(prefix_span, String::new())],
format!("consider removing the `{}`", remove.trim()),
String::new(),
// Do not remove `&&` to get to bool, because it might be something like
// { a } && b, which we have a separate fixup suggestion that is more
// likely correct...
@ -1557,9 +1561,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
return Some((
span,
vec![(span, suggestion)],
message,
suggestion,
Applicability::MachineApplicable,
true,
false,

6
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View file

@ -274,13 +274,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
) -> bool {
let expr = expr.peel_blocks();
if let Some((sp, msg, suggestion, applicability, verbose, annotation)) =
if let Some((suggestion, msg, applicability, verbose, annotation)) =
self.suggest_deref_or_ref(expr, found, expected)
{
if verbose {
err.span_suggestion_verbose(sp, msg, suggestion, applicability);
err.multipart_suggestion_verbose(msg, suggestion, applicability);
} else {
err.span_suggestion(sp, msg, suggestion, applicability);
err.multipart_suggestion(msg, suggestion, applicability);
}
if annotation {
let suggest_annotation = match expr.peel_drop_temps().kind {

20
tests/ui/issues/issue-46756-consider-borrowing-cast-or-binexpr.stderr
View file

@ -2,10 +2,8 @@ error[E0308]: mismatched types
--> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:12:42
|
LL | light_flows_our_war_of_mocking_words(behold as usize);
| ------------------------------------ ^^^^^^^^^^^^^^^
| | |
| | expected `&usize`, found `usize`
| | help: consider borrowing here: `&(behold as usize)`
| ------------------------------------ ^^^^^^^^^^^^^^^ expected `&usize`, found `usize`
| |
| arguments to this function are incorrect
|
note: function defined here
@ -13,15 +11,17 @@ note: function defined here
|
LL | fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ---------------
help: consider borrowing here
|
LL | light_flows_our_war_of_mocking_words(&(behold as usize));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:14:42
|
LL | light_flows_our_war_of_mocking_words(with_tears + 4);
| ------------------------------------ ^^^^^^^^^^^^^^
| | |
| | expected `&usize`, found `usize`
| | help: consider borrowing here: `&(with_tears + 4)`
| ------------------------------------ ^^^^^^^^^^^^^^ expected `&usize`, found `usize`
| |
| arguments to this function are incorrect
|
note: function defined here
@ -29,6 +29,10 @@ note: function defined here
|
LL | fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ---------------
help: consider borrowing here
|
LL | light_flows_our_war_of_mocking_words(&(with_tears + 4));
| ++ +
error: aborting due to 2 previous errors

12
tests/ui/range/issue-54505-no-std.rs
View file

@ -29,30 +29,30 @@ fn main() {
take_range(0..1);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(0..1)
//~| SUGGESTION &(
take_range(1..);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(1..)
//~| SUGGESTION &(
take_range(..);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..)
//~| SUGGESTION &(
take_range(0..=1);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(0..=1)
//~| SUGGESTION &(
take_range(..5);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..5)
//~| SUGGESTION &(
take_range(..=42);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..=42)
//~| SUGGESTION &(
}

60
tests/ui/range/issue-54505-no-std.stderr
View file

@ -14,10 +14,8 @@ error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:29:16
|
LL | take_range(0..1);
| ---------- ^^^^
| | |
| | expected `&_`, found `Range<{integer}>`
| | help: consider borrowing here: `&(0..1)`
| ---------- ^^^^ expected `&_`, found `Range<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -27,15 +25,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(0..1));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:34:16
|
LL | take_range(1..);
| ---------- ^^^
| | |
| | expected `&_`, found `RangeFrom<{integer}>`
| | help: consider borrowing here: `&(1..)`
| ---------- ^^^ expected `&_`, found `RangeFrom<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -45,15 +45,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(1..));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:39:16
|
LL | take_range(..);
| ---------- ^^
| | |
| | expected `&_`, found `RangeFull`
| | help: consider borrowing here: `&(..)`
| ---------- ^^ expected `&_`, found `RangeFull`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -63,15 +65,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(..));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:44:16
|
LL | take_range(0..=1);
| ---------- ^^^^^
| | |
| | expected `&_`, found `RangeInclusive<{integer}>`
| | help: consider borrowing here: `&(0..=1)`
| ---------- ^^^^^ expected `&_`, found `RangeInclusive<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -81,15 +85,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(0..=1));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:49:16
|
LL | take_range(..5);
| ---------- ^^^
| | |
| | expected `&_`, found `RangeTo<{integer}>`
| | help: consider borrowing here: `&(..5)`
| ---------- ^^^ expected `&_`, found `RangeTo<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -99,15 +105,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(..5));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:54:16
|
LL | take_range(..=42);
| ---------- ^^^^^
| | |
| | expected `&_`, found `RangeToInclusive<{integer}>`
| | help: consider borrowing here: `&(..=42)`
| ---------- ^^^^^ expected `&_`, found `RangeToInclusive<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -117,6 +125,10 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(..=42));
| ++ +
error: aborting due to 8 previous errors

12
tests/ui/range/issue-54505.fixed
View file

@ -14,30 +14,30 @@ fn main() {
take_range(&(0..1));
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(0..1)
//~| SUGGESTION &(
take_range(&(1..));
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(1..)
//~| SUGGESTION &(
take_range(&(..));
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..)
//~| SUGGESTION &(
take_range(&(0..=1));
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(0..=1)
//~| SUGGESTION &(
take_range(&(..5));
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..5)
//~| SUGGESTION &(
take_range(&(..=42));
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..=42)
//~| SUGGESTION &(
}

12
tests/ui/range/issue-54505.rs
View file

@ -14,30 +14,30 @@ fn main() {
take_range(0..1);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(0..1)
//~| SUGGESTION &(
take_range(1..);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(1..)
//~| SUGGESTION &(
take_range(..);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..)
//~| SUGGESTION &(
take_range(0..=1);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(0..=1)
//~| SUGGESTION &(
take_range(..5);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..5)
//~| SUGGESTION &(
take_range(..=42);
//~^ ERROR mismatched types [E0308]
//~| HELP consider borrowing here
//~| SUGGESTION &(..=42)
//~| SUGGESTION &(
}

60
tests/ui/range/issue-54505.stderr
View file

@ -2,10 +2,8 @@ error[E0308]: mismatched types
--> $DIR/issue-54505.rs:14:16
|
LL | take_range(0..1);
| ---------- ^^^^
| | |
| | expected `&_`, found `Range<{integer}>`
| | help: consider borrowing here: `&(0..1)`
| ---------- ^^^^ expected `&_`, found `Range<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -15,15 +13,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(0..1));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:19:16
|
LL | take_range(1..);
| ---------- ^^^
| | |
| | expected `&_`, found `RangeFrom<{integer}>`
| | help: consider borrowing here: `&(1..)`
| ---------- ^^^ expected `&_`, found `RangeFrom<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -33,15 +33,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(1..));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:24:16
|
LL | take_range(..);
| ---------- ^^
| | |
| | expected `&_`, found `RangeFull`
| | help: consider borrowing here: `&(..)`
| ---------- ^^ expected `&_`, found `RangeFull`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -51,15 +53,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(..));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:29:16
|
LL | take_range(0..=1);
| ---------- ^^^^^
| | |
| | expected `&_`, found `RangeInclusive<{integer}>`
| | help: consider borrowing here: `&(0..=1)`
| ---------- ^^^^^ expected `&_`, found `RangeInclusive<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -69,15 +73,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(0..=1));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:34:16
|
LL | take_range(..5);
| ---------- ^^^
| | |
| | expected `&_`, found `RangeTo<{integer}>`
| | help: consider borrowing here: `&(..5)`
| ---------- ^^^ expected `&_`, found `RangeTo<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -87,15 +93,17 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(..5));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:39:16
|
LL | take_range(..=42);
| ---------- ^^^^^
| | |
| | expected `&_`, found `RangeToInclusive<{integer}>`
| | help: consider borrowing here: `&(..=42)`
| ---------- ^^^^^ expected `&_`, found `RangeToInclusive<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&_`
@ -105,6 +113,10 @@ note: function defined here
|
LL | fn take_range(_r: &impl RangeBounds<i8>) {}
| ^^^^^^^^^^ -------------------------
help: consider borrowing here
|
LL | take_range(&(..=42));
| ++ +
error: aborting due to 6 previous errors

20
tests/ui/range/issue-73553-misinterp-range-literal.stderr
View file

@ -2,10 +2,8 @@ error[E0308]: mismatched types
--> $DIR/issue-73553-misinterp-range-literal.rs:12:10
|
LL | demo(tell(1)..tell(10));
| ---- ^^^^^^^^^^^^^^^^^
| | |
| | expected `&Range<usize>`, found `Range<usize>`
| | help: consider borrowing here: `&(tell(1)..tell(10))`
| ---- ^^^^^^^^^^^^^^^^^ expected `&Range<usize>`, found `Range<usize>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&std::ops::Range<usize>`
@ -15,15 +13,17 @@ note: function defined here
|
LL | fn demo(r: &Range) {
| ^^^^ ---------
help: consider borrowing here
|
LL | demo(&(tell(1)..tell(10)));
| ++ +
error[E0308]: mismatched types
--> $DIR/issue-73553-misinterp-range-literal.rs:14:10
|
LL | demo(1..10);
| ---- ^^^^^
| | |
| | expected `&Range<usize>`, found `Range<{integer}>`
| | help: consider borrowing here: `&(1..10)`
| ---- ^^^^^ expected `&Range<usize>`, found `Range<{integer}>`
| |
| arguments to this function are incorrect
|
= note: expected reference `&std::ops::Range<usize>`
@ -33,6 +33,10 @@ note: function defined here
|
LL | fn demo(r: &Range) {
| ^^^^ ---------
help: consider borrowing here
|
LL | demo(&(1..10));
| ++ +
error: aborting due to 2 previous errors

88
tests/ui/suggestions/as-ref.stderr
View file

@ -2,61 +2,73 @@ error[E0308]: mismatched types
--> $DIR/as-ref.rs:7:29
|
LL | opt.map(|arg| takes_ref(arg));
| --- --------- ^^^ expected `&Foo`, found `Foo`
| | |
| | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().map`
| --------- ^^^ expected `&Foo`, found `Foo`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/as-ref.rs:3:4
|
LL | fn takes_ref(_: &Foo) {}
| ^^^^^^^^^ -------
help: consider using `as_ref` instead
|
LL | opt.as_ref().map(|arg| takes_ref(arg));
| +++++++++
error[E0308]: mismatched types
--> $DIR/as-ref.rs:8:39
|
LL | opt.and_then(|arg| Some(takes_ref(arg)));
| -------- --------- ^^^ expected `&Foo`, found `Foo`
| | |
| | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().and_then`
| --------- ^^^ expected `&Foo`, found `Foo`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/as-ref.rs:3:4
|
LL | fn takes_ref(_: &Foo) {}
| ^^^^^^^^^ -------
help: consider using `as_ref` instead
|
LL | opt.as_ref().and_then(|arg| Some(takes_ref(arg)));
| +++++++++
error[E0308]: mismatched types
--> $DIR/as-ref.rs:10:29
|
LL | opt.map(|arg| takes_ref(arg));
| --- --------- ^^^ expected `&Foo`, found `Foo`
| | |
| | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().map`
| --------- ^^^ expected `&Foo`, found `Foo`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/as-ref.rs:3:4
|
LL | fn takes_ref(_: &Foo) {}
| ^^^^^^^^^ -------
help: consider using `as_ref` instead
|
LL | opt.as_ref().map(|arg| takes_ref(arg));
| +++++++++
error[E0308]: mismatched types
--> $DIR/as-ref.rs:11:37
|
LL | opt.and_then(|arg| Ok(takes_ref(arg)));
| -------- --------- ^^^ expected `&Foo`, found `Foo`
| | |
| | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().and_then`
| --------- ^^^ expected `&Foo`, found `Foo`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/as-ref.rs:3:4
|
LL | fn takes_ref(_: &Foo) {}
| ^^^^^^^^^ -------
help: consider using `as_ref` instead
|
LL | opt.as_ref().and_then(|arg| Ok(takes_ref(arg)));
| +++++++++
error[E0308]: mismatched types
--> $DIR/as-ref.rs:13:29
@ -101,61 +113,73 @@ error[E0308]: mismatched types
--> $DIR/as-ref.rs:22:42
|
LL | multiple_ref_opt.map(|arg| takes_ref(arg));
| --- --------- ^^^ expected `&Foo`, found `Foo`
| | |
| | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().map`
| --------- ^^^ expected `&Foo`, found `Foo`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/as-ref.rs:3:4
|
LL | fn takes_ref(_: &Foo) {}
| ^^^^^^^^^ -------
help: consider using `as_ref` instead
|
LL | multiple_ref_opt.as_ref().map(|arg| takes_ref(arg));
| +++++++++
error[E0308]: mismatched types
--> $DIR/as-ref.rs:23:52
|
LL | multiple_ref_opt.and_then(|arg| Some(takes_ref(arg)));
| -------- --------- ^^^ expected `&Foo`, found `Foo`
| | |
| | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().and_then`
| --------- ^^^ expected `&Foo`, found `Foo`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/as-ref.rs:3:4
|
LL | fn takes_ref(_: &Foo) {}
| ^^^^^^^^^ -------
help: consider using `as_ref` instead
|
LL | multiple_ref_opt.as_ref().and_then(|arg| Some(takes_ref(arg)));
| +++++++++
error[E0308]: mismatched types
--> $DIR/as-ref.rs:25:45
|
LL | multiple_ref_result.map(|arg| takes_ref(arg));
| --- --------- ^^^ expected `&Foo`, found `Foo`
| | |
| | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().map`
| --------- ^^^ expected `&Foo`, found `Foo`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/as-ref.rs:3:4
|
LL | fn takes_ref(_: &Foo) {}
| ^^^^^^^^^ -------
help: consider using `as_ref` instead
|
LL | multiple_ref_result.as_ref().map(|arg| takes_ref(arg));
| +++++++++
error[E0308]: mismatched types
--> $DIR/as-ref.rs:26:53
|
LL | multiple_ref_result.and_then(|arg| Ok(takes_ref(arg)));
| -------- --------- ^^^ expected `&Foo`, found `Foo`
| | |
| | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().and_then`
| --------- ^^^ expected `&Foo`, found `Foo`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/as-ref.rs:3:4
|
LL | fn takes_ref(_: &Foo) {}
| ^^^^^^^^^ -------
help: consider using `as_ref` instead
|
LL | multiple_ref_result.as_ref().and_then(|arg| Ok(takes_ref(arg)));
| +++++++++
error: aborting due to 11 previous errors