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

Auto merge of #92364 - jackh726:Quantumplation/65853/param-heuristics, r=estebank

Browse source 
Better method call error messages

Rebase/continuation of #71827

~Based on #92360~
~Based on #93118~

There's a decent description in #71827 that I won't copy here (for now at least)

In addition to rebasing, I've tried to restore most of the original suggestions for invalid arguments. Unfortunately, this does make some of the errors a bit verbose. To fix this will require a bit of refactoring to some of the generalized error suggestion functions, and I just don't have the time to go into it right now.

I think this is in a state that the error messages are overall better than before without a reduction in the suggestions given.

~I've tried to split out some of the easier and self-contained changes into separate commits (mostly in #92360, but also one here). There might be more than can be done here, but again just lacking time.~

r? `@estebank` as the original reviewer of #71827
This commit is contained in:
bors 2022-04-16 06:55:28 +00:00
commit 07bb916d44
180 changed files with 10446 additions and 3067 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View file

@ -1448,6 +1448,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
mut values: Option<ValuePairs<'tcx>>,
terr: &TypeError<'tcx>,
swap_secondary_and_primary: bool,
force_label: bool,
) {
let span = cause.span(self.tcx);
debug!("note_type_err cause={:?} values={:?}, terr={:?}", cause, values, terr);
@ -1623,7 +1624,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
TypeError::ObjectUnsafeCoercion(_) => {}
_ => {
let mut label_or_note = |span: Span, msg: &str| {
if &[span] == diag.span.primary_spans() {
if force_label || &[span] == diag.span.primary_spans() {
diag.span_label(span, msg);
} else {
diag.span_note(span, msg);
@ -2171,7 +2172,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
struct_span_err!(self.tcx.sess, span, E0644, "{}", failure_str)
}
};
self.note_type_err(&mut diag, &trace.cause, None, Some(trace.values), terr, false);
self.note_type_err(&mut diag, &trace.cause, None, Some(trace.values), terr, false, false);
diag
}
@ -2765,7 +2766,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
}
}
enum FailureCode {
pub enum FailureCode {
Error0038(DefId),
Error0317(&'static str),
Error0580(&'static str),
@ -2773,7 +2774,7 @@ enum FailureCode {
Error0644(&'static str),
}
trait ObligationCauseExt<'tcx> {
pub trait ObligationCauseExt<'tcx> {
fn as_failure_code(&self, terr: &TypeError<'tcx>) -> FailureCode;
fn as_requirement_str(&self) -> &'static str;
}

4
compiler/rustc_infer/src/infer/mod.rs
View file

@ -385,8 +385,8 @@ impl<'tcx> ValuePairs<'tcx> {
/// See the `error_reporting` module for more details.
#[derive(Clone, Debug)]
pub struct TypeTrace<'tcx> {
cause: ObligationCause<'tcx>,
values: ValuePairs<'tcx>,
pub cause: ObligationCause<'tcx>,
pub values: ValuePairs<'tcx>,
}
/// The origin of a `r1 <= r2` constraint.

10
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View file

@ -1654,7 +1654,15 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
}),
_ => None,
};
self.note_type_err(&mut diag, &obligation.cause, secondary_span, values, err, true);
self.note_type_err(
&mut diag,
&obligation.cause,
secondary_span,
values,
err,
true,
false,
);
self.note_obligation_cause(&mut diag, obligation);
diag.emit();
});

2
compiler/rustc_typeck/src/check/coercion.rs
View file

@ -1499,7 +1499,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
found,
expected,
None,
coercion_error,
Some(coercion_error),
);
}

2
compiler/rustc_typeck/src/check/compare_method.rs
View file

@ -384,6 +384,7 @@ fn compare_predicate_entailment<'tcx>(
})),
&terr,
false,
false,
);
return Err(diag.emit());
@ -1072,6 +1073,7 @@ crate fn compare_const_impl<'tcx>(
})),
&terr,
false,
false,
);
diag.emit();
}

8
compiler/rustc_typeck/src/check/demand.rs
View file

@ -28,7 +28,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expr_ty: Ty<'tcx>,
expected: Ty<'tcx>,
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
error: TypeError<'tcx>,
error: Option<TypeError<'tcx>>,
) {
self.annotate_expected_due_to_let_ty(err, expr, error);
self.suggest_deref_ref_or_into(err, expr, expected, expr_ty, expected_ty_expr);
@ -150,7 +150,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let expr_ty = self.resolve_vars_with_obligations(checked_ty);
let mut err = self.report_mismatched_types(&cause, expected, expr_ty, e.clone());
self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected, expected_ty_expr, e);
self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected, expected_ty_expr, Some(e));
(expected, Some(err))
}
@ -159,7 +159,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
&self,
err: &mut Diagnostic,
expr: &hir::Expr<'_>,
error: TypeError<'_>,
error: Option<TypeError<'_>>,
) {
let parent = self.tcx.hir().get_parent_node(expr.hir_id);
match (self.tcx.hir().find(parent), error) {
@ -173,7 +173,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Some(hir::Node::Expr(hir::Expr {
kind: hir::ExprKind::Assign(lhs, rhs, _), ..
})),
TypeError::Sorts(ExpectedFound { expected, .. }),
Some(TypeError::Sorts(ExpectedFound { expected, .. })),
) if rhs.hir_id == expr.hir_id && !expected.is_closure() => {
// We ignore closures explicitly because we already point at them elsewhere.
// Point at the assigned-to binding.

14
compiler/rustc_typeck/src/check/expr.rs
View file

@ -259,7 +259,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
#[instrument(skip(self, expr), level = "debug")]
fn check_expr_kind(
pub(super) fn check_expr_kind(
&self,
expr: &'tcx hir::Expr<'tcx>,
expected: Expectation<'tcx>,
@ -1366,11 +1366,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) {
let tcx = self.tcx;
let adt_ty_hint = self
.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
.get(0)
.cloned()
.unwrap_or(adt_ty);
let expected_inputs =
self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty]);
let adt_ty_hint = if let Some(expected_inputs) = expected_inputs {
expected_inputs.get(0).cloned().unwrap_or(adt_ty)
} else {
adt_ty
};
// re-link the regions that EIfEO can erase.
self.demand_eqtype(span, adt_ty_hint, adt_ty);

8
compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
View file

@ -755,9 +755,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expected_ret: Expectation<'tcx>,
formal_ret: Ty<'tcx>,
formal_args: &[Ty<'tcx>],
) -> Vec<Ty<'tcx>> {
) -> Option<Vec<Ty<'tcx>>> {
let formal_ret = self.resolve_vars_with_obligations(formal_ret);
let Some(ret_ty) = expected_ret.only_has_type(self) else { return Vec::new() };
let Some(ret_ty) = expected_ret.only_has_type(self) else { return None };
// HACK(oli-obk): This is a hack to keep RPIT and TAIT in sync wrt their behaviour.
// Without it, the inference
@ -779,7 +779,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let ty::subst::GenericArgKind::Type(ty) = ty.unpack() {
if let ty::Opaque(def_id, _) = *ty.kind() {
if self.infcx.opaque_type_origin(def_id, DUMMY_SP).is_some() {
return Vec::new();
return None;
}
}
}
@ -820,7 +820,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Record all the argument types, with the substitutions
// produced from the above subtyping unification.
Ok(formal_args.iter().map(|&ty| self.resolve_vars_if_possible(ty)).collect())
Ok(Some(formal_args.iter().map(|&ty| self.resolve_vars_if_possible(ty)).collect()))
})
.unwrap_or_default();
debug!(?formal_args, ?formal_ret, ?expect_args, ?expected_ret);

343
compiler/rustc_typeck/src/check/fn_ctxt/arg_matrix.rs Normal file
View file

@ -0,0 +1,343 @@
use std::cmp;
use rustc_middle::ty::error::TypeError;
// An issue that might be found in the compatibility matrix
enum Issue {
/// The given argument is the invalid type for the input
Invalid(usize),
/// There is a missing input
Missing(usize),
/// There's a superfluous argument
Extra(usize),
/// Two arguments should be swapped
Swap(usize, usize),
/// Several arguments should be reordered
Permutation(Vec<Option<usize>>),
}
#[derive(Clone, Debug)]
pub(crate) enum Compatibility<'tcx> {
Compatible,
Incompatible(Option<TypeError<'tcx>>),
}
/// Similar to `Issue`, but contains some extra information
pub(crate) enum Error<'tcx> {
/// The given argument is the invalid type for the input
Invalid(usize, Compatibility<'tcx>),
/// There is a missing input
Missing(usize),
/// There's a superfluous argument
Extra(usize),
/// Two arguments should be swapped
Swap(usize, usize, usize, usize),
/// Several arguments should be reordered
Permutation(Vec<(usize, usize)>), // dest_arg, dest_input
}
pub(crate) struct ArgMatrix<'tcx> {
input_indexes: Vec<usize>,
arg_indexes: Vec<usize>,
compatibility_matrix: Vec<Vec<Compatibility<'tcx>>>,
}
impl<'tcx> ArgMatrix<'tcx> {
pub(crate) fn new<F: FnMut(usize, usize) -> Compatibility<'tcx>>(
minimum_input_count: usize,
provided_arg_count: usize,
mut is_compatible: F,
) -> Self {
let compatibility_matrix = (0..provided_arg_count)
.map(|i| (0..minimum_input_count).map(|j| is_compatible(i, j)).collect())
.collect();
ArgMatrix {
input_indexes: (0..minimum_input_count).collect(),
arg_indexes: (0..provided_arg_count).collect(),
compatibility_matrix,
}
}
/// Remove a given input from consideration
fn eliminate_input(&mut self, idx: usize) {
self.input_indexes.remove(idx);
for row in &mut self.compatibility_matrix {
row.remove(idx);
}
}
/// Remove a given argument from consideration
fn eliminate_arg(&mut self, idx: usize) {
self.arg_indexes.remove(idx);
self.compatibility_matrix.remove(idx);
}
/// "satisfy" an input with a given arg, removing both from consideration
fn satisfy_input(&mut self, input_idx: usize, arg_idx: usize) {
self.eliminate_input(input_idx);
self.eliminate_arg(arg_idx);
}
fn eliminate_satisfied(&mut self) -> Vec<(usize, usize)> {
let mut i = cmp::min(self.input_indexes.len(), self.arg_indexes.len());
let mut eliminated = vec![];
while i > 0 {
let idx = i - 1;
if matches!(self.compatibility_matrix[idx][idx], Compatibility::Compatible) {
eliminated.push((self.arg_indexes[idx], self.input_indexes[idx]));
self.satisfy_input(idx, idx);
}
i -= 1;
}
return eliminated;
}
// Check for the above mismatch cases
fn find_issue(&self) -> Option<Issue> {
let mat = &self.compatibility_matrix;
let ai = &self.arg_indexes;
let ii = &self.input_indexes;
for i in 0..cmp::max(ai.len(), ii.len()) {
// If we eliminate the last row, any left-over inputs are considered missing
if i >= mat.len() {
return Some(Issue::Missing(i));
}
// If we eliminate the last column, any left-over arguments are extra
if mat[i].len() == 0 {
return Some(Issue::Extra(i));
}
// Make sure we don't pass the bounds of our matrix
let is_arg = i < ai.len();
let is_input = i < ii.len();
if is_arg && is_input && matches!(mat[i][i], Compatibility::Compatible) {
// This is a satisfied input, so move along
continue;
}
let mut useless = true;
let mut unsatisfiable = true;
if is_arg {
for j in 0..ii.len() {
// If we find at least one input this argument could satisfy
// this argument isn't completely useless
if matches!(mat[i][j], Compatibility::Compatible) {
useless = false;
break;
}
}
}
if is_input {
for j in 0..ai.len() {
// If we find at least one argument that could satisfy this input
// this argument isn't unsatisfiable
if matches!(mat[j][i], Compatibility::Compatible) {
unsatisfiable = false;
break;
}
}
}
match (is_arg, is_input, useless, unsatisfiable) {
// If an input is unsatisfied, and the argument in its position is useless
// then the most likely explanation is that we just got the types wrong
(true, true, true, true) => return Some(Issue::Invalid(i)),
// Otherwise, if an input is useless, then indicate that this is an extra argument
(true, _, true, _) => return Some(Issue::Extra(i)),
// Otherwise, if an argument is unsatisfiable, indicate that it's missing
(_, true, _, true) => return Some(Issue::Missing(i)),
(true, true, _, _) => {
// The argument isn't useless, and the input isn't unsatisfied,
// so look for a parameter we might swap it with
// We look for swaps explicitly, instead of just falling back on permutations
// so that cases like (A,B,C,D) given (B,A,D,C) show up as two swaps,
// instead of a large permutation of 4 elements.
for j in 0..cmp::min(ai.len(), ii.len()) {
if i == j || matches!(mat[j][j], Compatibility::Compatible) {
continue;
}
if matches!(mat[i][j], Compatibility::Compatible)
&& matches!(mat[j][i], Compatibility::Compatible)
{
return Some(Issue::Swap(i, j));
}
}
}
_ => {
continue;
}
};
}
// We didn't find any of the individual issues above, but
// there might be a larger permutation of parameters, so we now check for that
// by checking for cycles
// We use a double option at position i in this vec to represent:
// - None: We haven't computed anything about this argument yet
// - Some(None): This argument definitely doesn't participate in a cycle
// - Some(Some(x)): the i-th argument could permute to the x-th position
let mut permutation: Vec<Option<Option<usize>>> = vec![None; mat.len()];
let mut permutation_found = false;
for i in 0..mat.len() {
if permutation[i].is_some() {
// We've already decided whether this argument is or is not in a loop
continue;
}
let mut stack = vec![];
let mut j = i;
let mut last = i;
let mut is_cycle = true;
loop {
stack.push(j);
// Look for params this one could slot into
let compat: Vec<_> =
mat[j]
.iter()
.enumerate()
.filter_map(|(i, c)| {
if matches!(c, Compatibility::Compatible) { Some(i) } else { None }
})
.collect();
if compat.len() != 1 {
// this could go into multiple slots, don't bother exploring both
is_cycle = false;
break;
}
j = compat[0];
if stack.contains(&j) {
last = j;
break;
}
}
if stack.len() <= 2 {
// If we encounter a cycle of 1 or 2 elements, we'll let the
// "satisfy" and "swap" code above handle those
is_cycle = false;
}
// We've built up some chain, some of which might be a cycle
// ex: [1,2,3,4]; last = 2; j = 2;
// So, we want to mark 4, 3, and 2 as part of a permutation
permutation_found = is_cycle;
while let Some(x) = stack.pop() {
if is_cycle {
permutation[x] = Some(Some(j));
j = x;
if j == last {
// From here on out, we're a tail leading into a cycle,
// not the cycle itself
is_cycle = false;
}
} else {
// Some(None) ensures we save time by skipping this argument again
permutation[x] = Some(None);
}
}
}
if permutation_found {
// Map unwrap to remove the first layer of Some
let final_permutation: Vec<Option<usize>> =
permutation.into_iter().map(|x| x.unwrap()).collect();
return Some(Issue::Permutation(final_permutation));
}
return None;
}
// Obviously, detecting exact user intention is impossible, so the goal here is to
// come up with as likely of a story as we can to be helpful.
//
// We'll iteratively removed "satisfied" input/argument pairs,
// then check for the cases above, until we've eliminated the entire grid
//
// We'll want to know which arguments and inputs these rows and columns correspond to
// even after we delete them.
pub(crate) fn find_errors(mut self) -> (Vec<Error<'tcx>>, Vec<Option<usize>>) {
let provided_arg_count = self.arg_indexes.len();
let mut errors: Vec<Error<'tcx>> = vec![];
// For each expected argument, the matched *actual* input
let mut matched_inputs: Vec<Option<usize>> = vec![None; self.input_indexes.len()];
// Before we start looking for issues, eliminate any arguments that are already satisfied,
// so that an argument which is already spoken for by the input it's in doesn't
// spill over into another similarly typed input
// ex:
// fn some_func(_a: i32, _b: i32) {}
// some_func(1, "");
// Without this elimination, the first argument causes the second argument
// to show up as both a missing input and extra argument, rather than
// just an invalid type.
for (arg, inp) in self.eliminate_satisfied() {
matched_inputs[inp] = Some(arg);
}
while self.input_indexes.len() > 0 || self.arg_indexes.len() > 0 {
// Check for the first relevant issue
match self.find_issue() {
Some(Issue::Invalid(idx)) => {
let compatibility = self.compatibility_matrix[idx][idx].clone();
let input_idx = self.input_indexes[idx];
self.satisfy_input(idx, idx);
errors.push(Error::Invalid(input_idx, compatibility));
}
Some(Issue::Extra(idx)) => {
let arg_idx = self.arg_indexes[idx];
self.eliminate_arg(idx);
errors.push(Error::Extra(arg_idx));
}
Some(Issue::Missing(idx)) => {
let input_idx = self.input_indexes[idx];
self.eliminate_input(idx);
errors.push(Error::Missing(input_idx));
}
Some(Issue::Swap(idx, other)) => {
let input_idx = self.input_indexes[idx];
let other_input_idx = self.input_indexes[other];
let arg_idx = self.arg_indexes[idx];
let other_arg_idx = self.arg_indexes[other];
let (min, max) = (cmp::min(idx, other), cmp::max(idx, other));
self.satisfy_input(min, max);
// Subtract 1 because we already removed the "min" row
self.satisfy_input(max - 1, min);
errors.push(Error::Swap(input_idx, other_input_idx, arg_idx, other_arg_idx));
matched_inputs[input_idx] = Some(other_arg_idx);
matched_inputs[other_input_idx] = Some(arg_idx);
}
Some(Issue::Permutation(args)) => {
// FIXME: If satisfy_input ever did anything non-trivial (emit obligations to help type checking, for example)
// we'd want to call this function with the correct arg/input pairs, but for now, we just throw them in a bucket.
// This works because they force a cycle, so each row is guaranteed to also be a column
let mut idxs: Vec<usize> = args.iter().filter_map(|&a| a).collect();
let mut real_idxs = vec![None; provided_arg_count];
for (src, dst) in
args.iter().enumerate().filter_map(|(src, dst)| dst.map(|dst| (src, dst)))
{
let src_arg = self.arg_indexes[src];
let dst_arg = self.arg_indexes[dst];
let dest_input = self.input_indexes[dst];
real_idxs[src_arg] = Some((dst_arg, dest_input));
matched_inputs[dest_input] = Some(src_arg);
}
idxs.sort();
idxs.reverse();
for i in idxs {
self.satisfy_input(i, i);
}
errors.push(Error::Permutation(real_idxs.into_iter().flatten().collect()));
}
None => {
// We didn't find any issues, so we need to push the algorithm forward
// First, eliminate any arguments that currently satisfy their inputs
for (arg, inp) in self.eliminate_satisfied() {
matched_inputs[inp] = Some(arg);
}
}
};
}
return (errors, matched_inputs);
}
}

925
compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
View file

File diff suppressed because it is too large Load diff

2
compiler/rustc_typeck/src/check/fn_ctxt/mod.rs
View file

@ -1,9 +1,9 @@
mod _impl;
mod arg_matrix;
mod checks;
mod suggestions;
pub use _impl::*;
pub use checks::*;
pub use suggestions::*;
use crate::astconv::AstConv;

2
compiler/rustc_typeck/src/lib.rs
View file

@ -61,9 +61,11 @@ This API is completely unstable and subject to change.
#![feature(box_patterns)]
#![feature(control_flow_enum)]
#![feature(crate_visibility_modifier)]
#![feature(drain_filter)]
#![feature(hash_drain_filter)]
#![feature(if_let_guard)]
#![feature(is_sorted)]
#![feature(label_break_value)]
#![feature(let_chains)]
#![feature(let_else)]
#![feature(min_specialization)]

5
src/test/ui/arg-count-mismatch.rs
View file

@ -1,5 +0,0 @@
// error-pattern: arguments were supplied
fn f(x: isize) { }
fn main() { let i: (); i = f(); }

17
src/test/ui/arg-count-mismatch.stderr
View file

@ -1,17 +0,0 @@
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/arg-count-mismatch.rs:5:28
|
LL | fn main() { let i: (); i = f(); }
| ^-- supplied 0 arguments
| |
| expected 1 argument
|
note: function defined here
--> $DIR/arg-count-mismatch.rs:3:4
|
LL | fn f(x: isize) { }
| ^ --------
error: aborting due to previous error
For more information about this error, try `rustc --explain E0061`.

5
src/test/ui/arg-type-mismatch.rs
View file

@ -1,5 +0,0 @@
// error-pattern: mismatched types
fn f(x: isize) { }
fn main() { let i: (); i = f(()); }

9
src/test/ui/arg-type-mismatch.stderr
View file

@ -1,9 +0,0 @@
error[E0308]: mismatched types
--> $DIR/arg-type-mismatch.rs:5:30
|
LL | fn main() { let i: (); i = f(()); }
| ^^ expected `isize`, found `()`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.

25
src/test/ui/argument-suggestions/basic.rs Normal file
View file

@ -0,0 +1,25 @@
// Some basic "obvious" cases for the heuristic error messages added for #65853
// One for each of the detected cases
enum E { X, Y }
enum F { X2, Y2 }
struct G {}
struct H {}
struct X {}
struct Y {}
struct Z {}
fn invalid(_i: u32) {}
fn extra() {}
fn missing(_i: u32) {}
fn swapped(_i: u32, _s: &str) {}
fn permuted(_x: X, _y: Y, _z: Z) {}
fn main() {
invalid(1.0); //~ ERROR mismatched types
extra(""); //~ ERROR this function takes
missing(); //~ ERROR this function takes
swapped("", 1); //~ ERROR arguments to this function are incorrect
permuted(Y {}, Z {}, X {}); //~ ERROR arguments to this function are incorrect
}

87
src/test/ui/argument-suggestions/basic.stderr Normal file
View file

@ -0,0 +1,87 @@
error[E0308]: mismatched types
--> $DIR/basic.rs:20:13
|
LL | invalid(1.0);
| ------- ^^^ expected `u32`, found floating-point number
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/basic.rs:13:4
|
LL | fn invalid(_i: u32) {}
| ^^^^^^^ -------
error[E0061]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/basic.rs:21:5
|
LL | extra("");
| ^^^^^ -- argument unexpected
|
note: function defined here
--> $DIR/basic.rs:14:4
|
LL | fn extra() {}
| ^^^^^
help: remove the extra argument
|
LL | extra();
| ~~~~~~~
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/basic.rs:22:5
|
LL | missing();
| ^^^^^^^-- an argument of type `u32` is missing
|
note: function defined here
--> $DIR/basic.rs:15:4
|
LL | fn missing(_i: u32) {}
| ^^^^^^^ -------
help: provide the argument
|
LL | missing({u32});
| ~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/basic.rs:23:5
|
LL | swapped("", 1);
| ^^^^^^^ -- - expected `&str`,found `{integer}`
| |
| expected `u32`,found `&'static str`
|
note: function defined here
--> $DIR/basic.rs:16:4
|
LL | fn swapped(_i: u32, _s: &str) {}
| ^^^^^^^ ------- --------
help: swap these arguments
|
LL | swapped(1, "");
| ~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/basic.rs:24:5
|
LL | permuted(Y {}, Z {}, X {});
| ^^^^^^^^ ---- ---- ---- expected `Z`,found `X`
| | |
| | expected `Y`,found `Z`
| expected `X`,found `Y`
|
note: function defined here
--> $DIR/basic.rs:17:4
|
LL | fn permuted(_x: X, _y: Y, _z: Z) {}
| ^^^^^^^^ ----- ----- -----
help: reorder these arguments
|
LL | permuted(X {}, Y {}, Z {});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 5 previous errors
Some errors have detailed explanations: E0061, E0308.
For more information about an error, try `rustc --explain E0061`.

16
src/test/ui/argument-suggestions/complex.rs Normal file
View file

@ -0,0 +1,16 @@
// A complex case with mixed suggestions from #65853
enum E { X, Y }
enum F { X2, Y2 }
struct G {}
struct H {}
struct X {}
struct Y {}
struct Z {}
fn complex(_i: u32, _s: &str, _e: E, _f: F, _g: G, _x: X, _y: Y, _z: Z ) {}
fn main() {
complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
//~^ ERROR arguments to this function are incorrect
}

19
src/test/ui/argument-suggestions/complex.stderr Normal file
View file

@ -0,0 +1,19 @@
error[E0308]: arguments to this function are incorrect
--> $DIR/complex.rs:14:3
|
LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
| ^^^^^^^ --- expected `u32`, found floating-point number
|
note: function defined here
--> $DIR/complex.rs:11:4
|
LL | fn complex(_i: u32, _s: &str, _e: E, _f: F, _g: G, _x: X, _y: Y, _z: Z ) {}
| ^^^^^^^ ------- -------- ----- ----- ----- ----- ----- ------
help: did you mean
|
LL | complex({u32}, &"", {E}, F::X2, G{}, X {}, Y {}, Z {});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.

35
src/test/ui/argument-suggestions/extra_arguments.rs Normal file
View file

@ -0,0 +1,35 @@
fn empty() {}
fn one_arg(_a: i32) {}
fn two_arg_same(_a: i32, _b: i32) {}
fn two_arg_diff(_a: i32, _b: &str) {}
fn main() {
empty(""); //~ ERROR this function takes
one_arg(1, 1); //~ ERROR this function takes
one_arg(1, ""); //~ ERROR this function takes
one_arg(1, "", 1.0); //~ ERROR this function takes
two_arg_same(1, 1, 1); //~ ERROR this function takes
two_arg_same(1, 1, 1.0); //~ ERROR this function takes
two_arg_diff(1, 1, ""); //~ ERROR this function takes
two_arg_diff(1, "", ""); //~ ERROR this function takes
two_arg_diff(1, 1, "", ""); //~ ERROR this function takes
two_arg_diff(1, "", 1, ""); //~ ERROR this function takes
// Check with weird spacing and newlines
two_arg_same(1, 1, ""); //~ ERROR this function takes
two_arg_diff(1, 1, ""); //~ ERROR this function takes
two_arg_same( //~ ERROR this function takes
1,
1,
""
);
two_arg_diff( //~ ERROR this function takes
1,
1,
""
);
}

239
src/test/ui/argument-suggestions/extra_arguments.stderr Normal file
View file

@ -0,0 +1,239 @@
error[E0061]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/extra_arguments.rs:7:3
|
LL | empty("");
| ^^^^^ -- argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:1:4
|
LL | fn empty() {}
| ^^^^^
help: remove the extra argument
|
LL | empty();
| ~~~~~~~
error[E0061]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/extra_arguments.rs:9:3
|
LL | one_arg(1, 1);
| ^^^^^^^ - argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:2:4
|
LL | fn one_arg(_a: i32) {}
| ^^^^^^^ -------
help: remove the extra argument
|
LL | one_arg(1);
| ~~~~~~~~~~
error[E0061]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/extra_arguments.rs:10:3
|
LL | one_arg(1, "");
| ^^^^^^^ -- argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:2:4
|
LL | fn one_arg(_a: i32) {}
| ^^^^^^^ -------
help: remove the extra argument
|
LL | one_arg(1);
| ~~~~~~~~~~
error[E0061]: this function takes 1 argument but 3 arguments were supplied
--> $DIR/extra_arguments.rs:11:3
|
LL | one_arg(1, "", 1.0);
| ^^^^^^^ -- --- argument unexpected
| |
| argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:2:4
|
LL | fn one_arg(_a: i32) {}
| ^^^^^^^ -------
help: remove the extra arguments
|
LL | one_arg(1);
| ~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/extra_arguments.rs:13:3
|
LL | two_arg_same(1, 1, 1);
| ^^^^^^^^^^^^ - argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:3:4
|
LL | fn two_arg_same(_a: i32, _b: i32) {}
| ^^^^^^^^^^^^ ------- -------
help: remove the extra argument
|
LL | two_arg_same(1, 1);
| ~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/extra_arguments.rs:14:3
|
LL | two_arg_same(1, 1, 1.0);
| ^^^^^^^^^^^^ --- argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:3:4
|
LL | fn two_arg_same(_a: i32, _b: i32) {}
| ^^^^^^^^^^^^ ------- -------
help: remove the extra argument
|
LL | two_arg_same(1, 1);
| ~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/extra_arguments.rs:16:3
|
LL | two_arg_diff(1, 1, "");
| ^^^^^^^^^^^^ - argument of type `&str` unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:4:4
|
LL | fn two_arg_diff(_a: i32, _b: &str) {}
| ^^^^^^^^^^^^ ------- --------
help: remove the extra argument
|
LL | two_arg_diff(1, "");
| ~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/extra_arguments.rs:17:3
|
LL | two_arg_diff(1, "", "");
| ^^^^^^^^^^^^ -- argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:4:4
|
LL | fn two_arg_diff(_a: i32, _b: &str) {}
| ^^^^^^^^^^^^ ------- --------
help: remove the extra argument
|
LL | two_arg_diff(1, "");
| ~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 4 arguments were supplied
--> $DIR/extra_arguments.rs:18:3
|
LL | two_arg_diff(1, 1, "", "");
| ^^^^^^^^^^^^ - -- argument unexpected
| |
| argument of type `&str` unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:4:4
|
LL | fn two_arg_diff(_a: i32, _b: &str) {}
| ^^^^^^^^^^^^ ------- --------
help: remove the extra arguments
|
LL | two_arg_diff(1, "");
| ~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 4 arguments were supplied
--> $DIR/extra_arguments.rs:19:3
|
LL | two_arg_diff(1, "", 1, "");
| ^^^^^^^^^^^^ - -- argument unexpected
| |
| argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:4:4
|
LL | fn two_arg_diff(_a: i32, _b: &str) {}
| ^^^^^^^^^^^^ ------- --------
help: remove the extra arguments
|
LL | two_arg_diff(1, "");
| ~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/extra_arguments.rs:22:3
|
LL | two_arg_same(1, 1, "");
| ^^^^^^^^^^^^ -- argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:3:4
|
LL | fn two_arg_same(_a: i32, _b: i32) {}
| ^^^^^^^^^^^^ ------- -------
help: remove the extra argument
|
LL | two_arg_same(1, 1);
| ~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/extra_arguments.rs:23:3
|
LL | two_arg_diff(1, 1, "");
| ^^^^^^^^^^^^ - argument of type `&str` unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:4:4
|
LL | fn two_arg_diff(_a: i32, _b: &str) {}
| ^^^^^^^^^^^^ ------- --------
help: remove the extra argument
|
LL | two_arg_diff(1, "");
| ~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/extra_arguments.rs:24:3
|
LL | two_arg_same(
| ^^^^^^^^^^^^
...
LL | ""
| -- argument unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:3:4
|
LL | fn two_arg_same(_a: i32, _b: i32) {}
| ^^^^^^^^^^^^ ------- -------
help: remove the extra argument
|
LL | two_arg_same(1, 1);
| ~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/extra_arguments.rs:30:3
|
LL | two_arg_diff(
| ^^^^^^^^^^^^
LL | 1,
LL | 1,
| - argument of type `&str` unexpected
|
note: function defined here
--> $DIR/extra_arguments.rs:4:4
|
LL | fn two_arg_diff(_a: i32, _b: &str) {}
| ^^^^^^^^^^^^ ------- --------
help: remove the extra argument
|
LL | two_arg_diff(1, "");
| ~~~~~~~~~~~~~~~~~~~
error: aborting due to 14 previous errors
For more information about this error, try `rustc --explain E0061`.

43
src/test/ui/argument-suggestions/invalid_arguments.rs Normal file
View file

@ -0,0 +1,43 @@
// More nuanced test cases for invalid arguments #65853
struct X {}
fn one_arg(_a: i32) {}
fn two_arg_same(_a: i32, _b: i32) {}
fn two_arg_diff(_a: i32, _b: f32) {}
fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
fn main() {
// Providing an incorrect argument for a single parameter function
one_arg(1.0); //~ ERROR mismatched types
// Providing one or two invalid arguments to a two parameter function
two_arg_same(1, ""); //~ ERROR mismatched types
two_arg_same("", 1); //~ ERROR mismatched types
two_arg_same("", ""); //~ ERROR arguments to this function are incorrect
two_arg_diff(1, ""); //~ ERROR mismatched types
two_arg_diff("", 1.0); //~ ERROR mismatched types
two_arg_diff("", ""); //~ ERROR arguments to this function are incorrect
// Providing invalid arguments to a three parameter function
three_arg_diff(X{}, 1.0, ""); //~ ERROR mismatched types
three_arg_diff(1, X {}, ""); //~ ERROR mismatched types
three_arg_diff(1, 1.0, X {}); //~ ERROR mismatched types
three_arg_diff(X {}, X {}, ""); //~ ERROR arguments to this function are incorrect
three_arg_diff(X {}, 1.0, X {}); //~ ERROR arguments to this function are incorrect
three_arg_diff(1, X {}, X {}); //~ ERROR arguments to this function are incorrect
three_arg_diff(X {}, X {}, X {}); //~ ERROR arguments to this function are incorrect
three_arg_repeat(X {}, 1, ""); //~ ERROR mismatched types
three_arg_repeat(1, X {}, ""); //~ ERROR mismatched types
three_arg_repeat(1, 1, X {}); //~ ERROR mismatched types
three_arg_repeat(X {}, X {}, ""); //~ ERROR arguments to this function are incorrect
three_arg_repeat(X {}, 1, X {}); //~ ERROR arguments to this function are incorrect
three_arg_repeat(1, X {}, X{}); //~ ERROR arguments to this function are incorrect
three_arg_repeat(X {}, X {}, X {}); //~ ERROR arguments to this function are incorrect
}

299
src/test/ui/argument-suggestions/invalid_arguments.stderr Normal file
View file

@ -0,0 +1,299 @@
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:13:11
|
LL | one_arg(1.0);
| ------- ^^^ expected `i32`, found floating-point number
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:5:4
|
LL | fn one_arg(_a: i32) {}
| ^^^^^^^ -------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:16:19
|
LL | two_arg_same(1, "");
| ------------ ^^ expected `i32`, found `&str`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:6:4
|
LL | fn two_arg_same(_a: i32, _b: i32) {}
| ^^^^^^^^^^^^ ------- -------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:17:16
|
LL | two_arg_same("", 1);
| ------------ ^^ expected `i32`, found `&str`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:6:4
|
LL | fn two_arg_same(_a: i32, _b: i32) {}
| ^^^^^^^^^^^^ ------- -------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:18:3
|
LL | two_arg_same("", "");
| ^^^^^^^^^^^^ -- -- expected `i32`, found `&str`
| |
| expected `i32`, found `&str`
|
note: function defined here
--> $DIR/invalid_arguments.rs:6:4
|
LL | fn two_arg_same(_a: i32, _b: i32) {}
| ^^^^^^^^^^^^ ------- -------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:19:19
|
LL | two_arg_diff(1, "");
| ------------ ^^ expected `f32`, found `&str`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:7:4
|
LL | fn two_arg_diff(_a: i32, _b: f32) {}
| ^^^^^^^^^^^^ ------- -------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:20:16
|
LL | two_arg_diff("", 1.0);
| ------------ ^^ expected `i32`, found `&str`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:7:4
|
LL | fn two_arg_diff(_a: i32, _b: f32) {}
| ^^^^^^^^^^^^ ------- -------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:21:3
|
LL | two_arg_diff("", "");
| ^^^^^^^^^^^^ -- -- expected `f32`, found `&str`
| |
| expected `i32`, found `&str`
|
note: function defined here
--> $DIR/invalid_arguments.rs:7:4
|
LL | fn two_arg_diff(_a: i32, _b: f32) {}
| ^^^^^^^^^^^^ ------- -------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:24:18
|
LL | three_arg_diff(X{}, 1.0, "");
| -------------- ^^^ expected `i32`, found struct `X`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:8:4
|
LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:25:21
|
LL | three_arg_diff(1, X {}, "");
| -------------- ^^^^ expected `f32`, found struct `X`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:8:4
|
LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:26:26
|
LL | three_arg_diff(1, 1.0, X {});
| -------------- ^^^^ expected `&str`, found struct `X`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:8:4
|
LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:28:3
|
LL | three_arg_diff(X {}, X {}, "");
| ^^^^^^^^^^^^^^ ---- ---- expected `f32`, found struct `X`
| |
| expected `i32`, found struct `X`
|
note: function defined here
--> $DIR/invalid_arguments.rs:8:4
|
LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:29:3
|
LL | three_arg_diff(X {}, 1.0, X {});
| ^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X`
| |
| expected `i32`, found struct `X`
|
note: function defined here
--> $DIR/invalid_arguments.rs:8:4
|
LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:30:3
|
LL | three_arg_diff(1, X {}, X {});
| ^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X`
| |
| expected `f32`, found struct `X`
|
note: function defined here
--> $DIR/invalid_arguments.rs:8:4
|
LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:32:3
|
LL | three_arg_diff(X {}, X {}, X {});
| ^^^^^^^^^^^^^^ ---- ---- ---- expected `&str`, found struct `X`
| | |
| | expected `f32`, found struct `X`
| expected `i32`, found struct `X`
|
note: function defined here
--> $DIR/invalid_arguments.rs:8:4
|
LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:34:20
|
LL | three_arg_repeat(X {}, 1, "");
| ---------------- ^^^^ expected `i32`, found struct `X`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:9:4
|
LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:35:23
|
LL | three_arg_repeat(1, X {}, "");
| ---------------- ^^^^ expected `i32`, found struct `X`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:9:4
|
LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:36:26
|
LL | three_arg_repeat(1, 1, X {});
| ---------------- ^^^^ expected `&str`, found struct `X`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/invalid_arguments.rs:9:4
|
LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:38:3
|
LL | three_arg_repeat(X {}, X {}, "");
| ^^^^^^^^^^^^^^^^ ---- ---- expected `i32`, found struct `X`
| |
| expected `i32`, found struct `X`
|
note: function defined here
--> $DIR/invalid_arguments.rs:9:4
|
LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:39:3
|
LL | three_arg_repeat(X {}, 1, X {});
| ^^^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X`
| |
| expected `i32`, found struct `X`
|
note: function defined here
--> $DIR/invalid_arguments.rs:9:4
|
LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:40:3
|
LL | three_arg_repeat(1, X {}, X{});
| ^^^^^^^^^^^^^^^^ ---- --- expected `&str`, found struct `X`
| |
| expected `i32`, found struct `X`
|
note: function defined here
--> $DIR/invalid_arguments.rs:9:4
|
LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:42:3
|
LL | three_arg_repeat(X {}, X {}, X {});
| ^^^^^^^^^^^^^^^^ ---- ---- ---- expected `&str`, found struct `X`
| | |
| | expected `i32`, found struct `X`
| expected `i32`, found struct `X`
|
note: function defined here
--> $DIR/invalid_arguments.rs:9:4
|
LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
error: aborting due to 21 previous errors
For more information about this error, try `rustc --explain E0308`.

40
src/test/ui/argument-suggestions/missing_arguments.rs Normal file
View file

@ -0,0 +1,40 @@
fn one_arg(_a: i32) {}
fn two_same(_a: i32, _b: i32) {}
fn two_diff(_a: i32, _b: f32) {}
fn three_same(_a: i32, _b: i32, _c: i32) {}
fn three_diff(_a: i32, _b: f32, _c: &str) {}
fn four_repeated(_a: i32, _b: f32, _c: f32, _d: &str) {}
fn complex(_a: i32, _b: f32, _c: i32, _d: f32, _e: &str) {}
fn main() {
one_arg(); //~ ERROR this function takes
// The headers here show the types expected,
// with formatting to emphasize which arguments are missing
/* i32 f32 */
two_same( ); //~ ERROR this function takes
two_same( 1 ); //~ ERROR this function takes
two_diff( ); //~ ERROR this function takes
two_diff( 1 ); //~ ERROR this function takes
two_diff( 1.0 ); //~ ERROR this function takes
/* i32 i32 i32 */
three_same( ); //~ ERROR this function takes
three_same( 1 ); //~ ERROR this function takes
three_same( 1, 1 ); //~ ERROR this function takes
/* i32 f32 &str */
three_diff( 1.0, "" ); //~ ERROR this function takes
three_diff( 1, "" ); //~ ERROR this function takes
three_diff( 1, 1.0 ); //~ ERROR this function takes
three_diff( "" ); //~ ERROR this function takes
three_diff( 1.0 ); //~ ERROR this function takes
three_diff( 1 ); //~ ERROR this function takes
/* i32 f32 f32 &str */
four_repeated( ); //~ ERROR this function takes
four_repeated( 1, "" ); //~ ERROR this function takes
/* i32 f32 i32 f32 &str */
complex( ); //~ ERROR this function takes
complex( 1, "" ); //~ ERROR this function takes
}

310
src/test/ui/argument-suggestions/missing_arguments.stderr Normal file
View file

@ -0,0 +1,310 @@
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/missing_arguments.rs:10:3
|
LL | one_arg();
| ^^^^^^^-- an argument of type `i32` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:1:4
|
LL | fn one_arg(_a: i32) {}
| ^^^^^^^ -------
help: provide the argument
|
LL | one_arg({i32});
| ~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 0 arguments were supplied
--> $DIR/missing_arguments.rs:14:3
|
LL | two_same( );
| ^^^^^^^^----------------- two arguments of type `i32` and `i32` are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:2:4
|
LL | fn two_same(_a: i32, _b: i32) {}
| ^^^^^^^^ ------- -------
help: provide the arguments
|
LL | two_same({i32}, {i32});
| ~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/missing_arguments.rs:15:3
|
LL | two_same( 1 );
| ^^^^^^^^----------------- an argument of type `i32` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:2:4
|
LL | fn two_same(_a: i32, _b: i32) {}
| ^^^^^^^^ ------- -------
help: provide the argument
|
LL | two_same(1, {i32});
| ~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 0 arguments were supplied
--> $DIR/missing_arguments.rs:16:3
|
LL | two_diff( );
| ^^^^^^^^----------------- two arguments of type `i32` and `f32` are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:3:4
|
LL | fn two_diff(_a: i32, _b: f32) {}
| ^^^^^^^^ ------- -------
help: provide the arguments
|
LL | two_diff({i32}, {f32});
| ~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/missing_arguments.rs:17:3
|
LL | two_diff( 1 );
| ^^^^^^^^----------------- an argument of type `f32` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:3:4
|
LL | fn two_diff(_a: i32, _b: f32) {}
| ^^^^^^^^ ------- -------
help: provide the argument
|
LL | two_diff(1, {f32});
| ~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/missing_arguments.rs:18:3
|
LL | two_diff( 1.0 );
| ^^^^^^^^ --- an argument of type `i32` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:3:4
|
LL | fn two_diff(_a: i32, _b: f32) {}
| ^^^^^^^^ ------- -------
help: provide the argument
|
LL | two_diff({i32}, 1.0);
| ~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 0 arguments were supplied
--> $DIR/missing_arguments.rs:21:3
|
LL | three_same( );
| ^^^^^^^^^^------------------------- three arguments of type `i32`, `i32`, and `i32` are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:4:4
|
LL | fn three_same(_a: i32, _b: i32, _c: i32) {}
| ^^^^^^^^^^ ------- ------- -------
help: provide the arguments
|
LL | three_same({i32}, {i32}, {i32});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 1 argument was supplied
--> $DIR/missing_arguments.rs:22:3
|
LL | three_same( 1 );
| ^^^^^^^^^^------------------------- two arguments of type `i32` and `i32` are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:4:4
|
LL | fn three_same(_a: i32, _b: i32, _c: i32) {}
| ^^^^^^^^^^ ------- ------- -------
help: provide the arguments
|
LL | three_same(1, {i32}, {i32});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 2 arguments were supplied
--> $DIR/missing_arguments.rs:23:3
|
LL | three_same( 1, 1 );
| ^^^^^^^^^^------------------------- an argument of type `i32` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:4:4
|
LL | fn three_same(_a: i32, _b: i32, _c: i32) {}
| ^^^^^^^^^^ ------- ------- -------
help: provide the argument
|
LL | three_same(1, 1, {i32});
| ~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 2 arguments were supplied
--> $DIR/missing_arguments.rs:26:3
|
LL | three_diff( 1.0, "" );
| ^^^^^^^^^^ --- an argument of type `i32` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:5:4
|
LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: provide the argument
|
LL | three_diff({i32}, 1.0, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 2 arguments were supplied
--> $DIR/missing_arguments.rs:27:3
|
LL | three_diff( 1, "" );
| ^^^^^^^^^^ -- an argument of type `f32` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:5:4
|
LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: provide the argument
|
LL | three_diff(1, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 2 arguments were supplied
--> $DIR/missing_arguments.rs:28:3
|
LL | three_diff( 1, 1.0 );
| ^^^^^^^^^^------------------------- an argument of type `&str` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:5:4
|
LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: provide the argument
|
LL | three_diff(1, 1.0, {&str});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 1 argument was supplied
--> $DIR/missing_arguments.rs:29:3
|
LL | three_diff( "" );
| ^^^^^^^^^^------------------------- two arguments of type `i32` and `f32` are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:5:4
|
LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: provide the arguments
|
LL | three_diff({i32}, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 1 argument was supplied
--> $DIR/missing_arguments.rs:30:3
|
LL | three_diff( 1.0 );
| ^^^^^^^^^^-------------------------
| | |
| | an argument of type `i32` is missing
| an argument of type `&str` is missing
|
note: function defined here
--> $DIR/missing_arguments.rs:5:4
|
LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: provide the arguments
|
LL | three_diff({i32}, 1.0, {&str});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 1 argument was supplied
--> $DIR/missing_arguments.rs:31:3
|
LL | three_diff( 1 );
| ^^^^^^^^^^------------------------- two arguments of type `f32` and `&str` are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:5:4
|
LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: provide the arguments
|
LL | three_diff(1, {f32}, {&str});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 4 arguments but 0 arguments were supplied
--> $DIR/missing_arguments.rs:34:3
|
LL | four_repeated( );
| ^^^^^^^^^^^^^--------------------------------- multiple arguments are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:6:4
|
LL | fn four_repeated(_a: i32, _b: f32, _c: f32, _d: &str) {}
| ^^^^^^^^^^^^^ ------- ------- ------- --------
help: provide the arguments
|
LL | four_repeated({i32}, {f32}, {f32}, {&str});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 4 arguments but 2 arguments were supplied
--> $DIR/missing_arguments.rs:35:3
|
LL | four_repeated( 1, "" );
| ^^^^^^^^^^^^^--------------------------------- two arguments of type `f32` and `f32` are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:6:4
|
LL | fn four_repeated(_a: i32, _b: f32, _c: f32, _d: &str) {}
| ^^^^^^^^^^^^^ ------- ------- ------- --------
help: provide the arguments
|
LL | four_repeated(1, {f32}, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 5 arguments but 0 arguments were supplied
--> $DIR/missing_arguments.rs:38:3
|
LL | complex( );
| ^^^^^^^--------------------------------- multiple arguments are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:7:4
|
LL | fn complex(_a: i32, _b: f32, _c: i32, _d: f32, _e: &str) {}
| ^^^^^^^ ------- ------- ------- ------- --------
help: provide the arguments
|
LL | complex({i32}, {f32}, {i32}, {f32}, {&str});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 5 arguments but 2 arguments were supplied
--> $DIR/missing_arguments.rs:39:3
|
LL | complex( 1, "" );
| ^^^^^^^--------------------------------- three arguments of type `f32`, `i32`, and `i32` are missing
|
note: function defined here
--> $DIR/missing_arguments.rs:7:4
|
LL | fn complex(_a: i32, _b: f32, _c: i32, _d: f32, _e: &str) {}
| ^^^^^^^ ------- ------- ------- ------- --------
help: provide the arguments
|
LL | complex(1, {f32}, {i32}, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 19 previous errors
For more information about this error, try `rustc --explain E0061`.

24
src/test/ui/argument-suggestions/mixed_cases.rs Normal file
View file

@ -0,0 +1,24 @@
// Cases where multiple argument suggestions are mixed
struct X {}
fn two_args(_a: i32, _b: f32) {}
fn three_args(_a: i32, _b: f32, _c: &str) {}
fn main() {
// Extra + Invalid
two_args(1, "", X {}); //~ ERROR this function takes
three_args(1, "", X {}, ""); //~ ERROR this function takes
// Missing and Invalid
three_args(1, X {}); //~ ERROR this function takes
// Missing and Extra
three_args(1, "", X {}); //~ ERROR arguments to this function are incorrect
// Swapped and Invalid
three_args("", X {}, 1); //~ ERROR arguments to this function are incorrect
// Swapped and missing
three_args("", 1); //~ ERROR this function takes
}

117
src/test/ui/argument-suggestions/mixed_cases.stderr Normal file
View file

@ -0,0 +1,117 @@
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/mixed_cases.rs:10:3
|
LL | two_args(1, "", X {});
| ^^^^^^^^ -- ---- argument unexpected
| |
| expected `f32`, found `&str`
|
note: function defined here
--> $DIR/mixed_cases.rs:5:4
|
LL | fn two_args(_a: i32, _b: f32) {}
| ^^^^^^^^ ------- -------
help: remove the extra argument
|
LL | two_args(1, {f32});
| ~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 4 arguments were supplied
--> $DIR/mixed_cases.rs:11:3
|
LL | three_args(1, "", X {}, "");
| ^^^^^^^^^^ -- ---- -- argument unexpected
| | |
| | argument of type `&str` unexpected
| an argument of type `f32` is missing
|
note: function defined here
--> $DIR/mixed_cases.rs:6:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: did you mean
|
LL | three_args(1, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 2 arguments were supplied
--> $DIR/mixed_cases.rs:14:3
|
LL | three_args(1, X {});
| ^^^^^^^^^^---------
| | |
| | expected `f32`, found struct `X`
| an argument of type `&str` is missing
|
note: function defined here
--> $DIR/mixed_cases.rs:6:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: provide the argument
|
LL | three_args(1, {f32}, {&str});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/mixed_cases.rs:17:3
|
LL | three_args(1, "", X {});
| ^^^^^^^^^^ -- ---- argument of type `&str` unexpected
| |
| an argument of type `f32` is missing
|
note: function defined here
--> $DIR/mixed_cases.rs:6:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: did you mean
|
LL | three_args(1, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/mixed_cases.rs:20:3
|
LL | three_args("", X {}, 1);
| ^^^^^^^^^^ -- ---- - expected `&str`,found `{integer}`
| | |
| | expected `f32`, found struct `X`
| expected `i32`,found `&'static str`
|
note: function defined here
--> $DIR/mixed_cases.rs:6:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: swap these arguments
|
LL | three_args(1, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 3 arguments but 2 arguments were supplied
--> $DIR/mixed_cases.rs:23:3
|
LL | three_args("", 1);
| ^^^^^^^^^^ -- -
| | |
| | an argument of type `f32` is missing
| | expected `&str`,found `{integer}`
| expected `i32`,found `&'static str`
|
note: function defined here
--> $DIR/mixed_cases.rs:6:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: did you mean
|
LL | three_args(1, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 6 previous errors
Some errors have detailed explanations: E0061, E0308.
For more information about an error, try `rustc --explain E0061`.

13
src/test/ui/argument-suggestions/permuted_arguments.rs Normal file
View file

@ -0,0 +1,13 @@
// More complicated permutations
struct X {}
struct Y {}
fn three_args(_a: i32, _b: f32, _c: &str) {}
fn many_args(_a: i32, _b: f32, _c: &str, _d: X, _e: Y) {}
fn main() {
// b, c, a
three_args(1.0, "", 1); //~ ERROR arguments to this function are incorrect
// d, e, b, a, c
many_args(X {}, Y {}, 1, 1.0, ""); //~ ERROR arguments to this function are incorrect
}

43
src/test/ui/argument-suggestions/permuted_arguments.stderr Normal file
View file

@ -0,0 +1,43 @@
error[E0308]: arguments to this function are incorrect
--> $DIR/permuted_arguments.rs:10:3
|
LL | three_args(1.0, "", 1);
| ^^^^^^^^^^ --- -- - expected `&str`,found `{integer}`
| | |
| | expected `f32`,found `&'static str`
| expected `i32`,found `{float}`
|
note: function defined here
--> $DIR/permuted_arguments.rs:5:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: reorder these arguments
|
LL | three_args(1, 1.0, "");
| ~~~~~~~~~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/permuted_arguments.rs:12:3
|
LL | many_args(X {}, Y {}, 1, 1.0, "");
| ^^^^^^^^^ ---- ---- - --- -- expected `Y`,found `&'static str`
| | | | |
| | | | expected `X`,found `{float}`
| | | expected `&str`,found `{integer}`
| | expected `f32`,found `Y`
| expected `i32`,found `X`
|
note: function defined here
--> $DIR/permuted_arguments.rs:6:4
|
LL | fn many_args(_a: i32, _b: f32, _c: &str, _d: X, _e: Y) {}
| ^^^^^^^^^ ------- ------- -------- ----- -----
help: reorder these arguments
|
LL | many_args(1, 1.0, "", X {}, Y {});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0308`.

14
src/test/ui/argument-suggestions/swapped_arguments.rs Normal file
View file

@ -0,0 +1,14 @@
struct X {}
fn two_args(_a: i32, _b: f32) {}
fn three_args(_a: i32, _b: f32, _c: &str) {}
fn four_args(_a: i32, _b: f32, _c: &str, _d: X) {}
fn main() {
two_args(1.0, 1); //~ ERROR arguments to this function are incorrect
three_args(1.0, 1, ""); //~ ERROR arguments to this function are incorrect
three_args( 1, "", 1.0); //~ ERROR arguments to this function are incorrect
three_args( "", 1.0, 1); //~ ERROR arguments to this function are incorrect
four_args(1.0, 1, X {}, ""); //~ ERROR arguments to this function are incorrect
}

95
src/test/ui/argument-suggestions/swapped_arguments.stderr Normal file
View file

@ -0,0 +1,95 @@
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:8:3
|
LL | two_args(1.0, 1);
| ^^^^^^^^ --- - expected `f32`,found `{integer}`
| |
| expected `i32`,found `{float}`
|
note: function defined here
--> $DIR/swapped_arguments.rs:3:4
|
LL | fn two_args(_a: i32, _b: f32) {}
| ^^^^^^^^ ------- -------
help: swap these arguments
|
LL | two_args(1, 1.0);
| ~~~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:9:3
|
LL | three_args(1.0, 1, "");
| ^^^^^^^^^^ --- - expected `f32`,found `{integer}`
| |
| expected `i32`,found `{float}`
|
note: function defined here
--> $DIR/swapped_arguments.rs:4:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: swap these arguments
|
LL | three_args(1, 1.0, "");
| ~~~~~~~~~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:10:3
|
LL | three_args( 1, "", 1.0);
| ^^^^^^^^^^ -- --- expected `&str`,found `{float}`
| |
| expected `f32`,found `&'static str`
|
note: function defined here
--> $DIR/swapped_arguments.rs:4:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: swap these arguments
|
LL | three_args(1, 1.0, "");
| ~~~~~~~~~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:11:3
|
LL | three_args( "", 1.0, 1);
| ^^^^^^^^^^ -- - expected `&str`,found `{integer}`
| |
| expected `i32`,found `&'static str`
|
note: function defined here
--> $DIR/swapped_arguments.rs:4:4
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: swap these arguments
|
LL | three_args(1, 1.0, "");
| ~~~~~~~~~~~~~~~~~~~~~~
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:13:3
|
LL | four_args(1.0, 1, X {}, "");
| ^^^^^^^^^ --- - ---- -- expected `X`,found `&'static str`
| | | |
| | | expected `&str`,found `X`
| | expected `f32`,found `{integer}`
| expected `i32`,found `{float}`
|
note: function defined here
--> $DIR/swapped_arguments.rs:5:4
|
LL | fn four_args(_a: i32, _b: f32, _c: &str, _d: X) {}
| ^^^^^^^^^ ------- ------- -------- -----
help: did you mean
|
LL | four_args(1, 1.0, "", X {});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0308`.

40
src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr
View file

@ -2,25 +2,57 @@ error[E0308]: mismatched types
--> $DIR/associated-type-projection-from-supertrait.rs:27:23
|
LL | fn b() { dent(ModelT, Blue); }
| ^^^^ expected struct `Black`, found struct `Blue`
| ---- ^^^^ expected struct `Black`, found struct `Blue`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/associated-type-projection-from-supertrait.rs:25:4
|
LL | fn dent<C:Car>(c: C, color: C::Color) { c.chip_paint(color) }
| ^^^^ ---- ---------------
error[E0308]: mismatched types
--> $DIR/associated-type-projection-from-supertrait.rs:28:23
|
LL | fn c() { dent(ModelU, Black); }
| ^^^^^ expected struct `Blue`, found struct `Black`
| ---- ^^^^^ expected struct `Blue`, found struct `Black`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/associated-type-projection-from-supertrait.rs:25:4
|
LL | fn dent<C:Car>(c: C, color: C::Color) { c.chip_paint(color) }
| ^^^^ ---- ---------------
error[E0308]: mismatched types
--> $DIR/associated-type-projection-from-supertrait.rs:32:28
|
LL | fn f() { ModelT.chip_paint(Blue); }
| ^^^^ expected struct `Black`, found struct `Blue`
| ---------- ^^^^ expected struct `Black`, found struct `Blue`
| |
| arguments to this function are incorrect
|
note: associated function defined here
--> $DIR/associated-type-projection-from-supertrait.rs:12:8
|
LL | fn chip_paint(&self, c: Self::Color) { }
| ^^^^^^^^^^ ----- --------------
error[E0308]: mismatched types
--> $DIR/associated-type-projection-from-supertrait.rs:33:28
|
LL | fn g() { ModelU.chip_paint(Black); }
| ^^^^^ expected struct `Blue`, found struct `Black`
| ---------- ^^^^^ expected struct `Blue`, found struct `Black`
| |
| arguments to this function are incorrect
|
note: associated function defined here
--> $DIR/associated-type-projection-from-supertrait.rs:12:8
|
LL | fn chip_paint(&self, c: Self::Color) { }
| ^^^^^^^^^^ ----- --------------
error: aborting due to 4 previous errors

9
src/test/ui/associated-types/associated-types-path-2.stderr
View file

@ -2,8 +2,15 @@ error[E0308]: mismatched types
--> $DIR/associated-types-path-2.rs:19:14
|
LL | f1(2i32, 4i32);
| ^^^^ expected `u32`, found `i32`
| -- ^^^^ expected `u32`, found `i32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/associated-types-path-2.rs:13:8
|
LL | pub fn f1<T: Foo>(a: T, x: T::A) {}
| ^^ ---- -------
help: change the type of the numeric literal from `i32` to `u32`
|
LL | f1(2i32, 4u32);

9
src/test/ui/async-await/dont-suggest-missing-await.stderr
View file

@ -2,7 +2,9 @@ error[E0308]: mismatched types
--> $DIR/dont-suggest-missing-await.rs:14:18
|
LL | take_u32(x)
| ^ expected `u32`, found opaque type
| -------- ^ expected `u32`, found opaque type
| |
| arguments to this function are incorrect
|
note: while checking the return type of the `async fn`
--> $DIR/dont-suggest-missing-await.rs:7:24
@ -11,6 +13,11 @@ LL | async fn make_u32() -> u32 {
| ^^^ checked the `Output` of this `async fn`, found opaque type
= note: expected type `u32`
found opaque type `impl Future<Output = u32>`
note: function defined here
--> $DIR/dont-suggest-missing-await.rs:5:4
|
LL | fn take_u32(x: u32) {}
| ^^^^^^^^ ------
help: consider `await`ing on the `Future`
|
LL | take_u32(x.await)

53
src/test/ui/async-await/generator-desc.stderr
View file

@ -2,52 +2,67 @@ error[E0308]: mismatched types
--> $DIR/generator-desc.rs:10:25
|
LL | fun(async {}, async {});
| -- ^^ expected `async` block, found a different `async` block
| |
| -- ^^
| | |
| | expected `async` block, found a different `async` block
| | arguments to this function are incorrect
| the expected `async` block
|
= note: expected `async` block `[static generator@$DIR/generator-desc.rs:10:15: 10:17]`
found `async` block `[static generator@$DIR/generator-desc.rs:10:25: 10:27]`
note: function defined here
--> $SRC_DIR/core/src/future/mod.rs:LL:COL
|
LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
| ^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/generator-desc.rs:12:16
|
LL | fun(one(), two());
| ^^^^^ expected opaque type, found a different opaque type
| --- ^^^^^ expected opaque type, found a different opaque type
| |
| arguments to this function are incorrect
|
note: while checking the return type of the `async fn`
--> $DIR/generator-desc.rs:5:16
|
LL | async fn one() {}
| ^ checked the `Output` of this `async fn`, expected opaque type
note: while checking the return type of the `async fn`
--> $DIR/generator-desc.rs:6:16
|
LL | async fn two() {}
| ^ checked the `Output` of this `async fn`, found opaque type
= note: expected opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:5:16>)
found opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:6:16>)
= note: expected type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:5:16>)
found opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:6:16>)
= help: consider `await`ing on both `Future`s
= note: distinct uses of `impl Trait` result in different opaque types
note: function defined here
--> $DIR/generator-desc.rs:8:4
|
LL | fn fun<F: Future<Output = ()>>(f1: F, f2: F) {}
| ^^^ ----- -----
error[E0308]: mismatched types
--> $DIR/generator-desc.rs:14:26
|
LL | fun((async || {})(), (async || {})());
| -- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body
| |
| the expected `async` closure body
| --- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body
| |
| arguments to this function are incorrect
|
::: $SRC_DIR/core/src/future/mod.rs:LL:COL
|
LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
| -------------------------------
| |
| the expected opaque type
| the found opaque type
| ------------------------------- the found opaque type
|
= note: expected opaque type `impl Future<Output = ()>` (`async` closure body)
found opaque type `impl Future<Output = ()>` (`async` closure body)
= note: expected type `impl Future<Output = ()>` (`async` closure body)
found opaque type `impl Future<Output = ()>` (`async` closure body)
note: function defined here
--> $DIR/generator-desc.rs:8:4
|
LL | fn fun<F: Future<Output = ()>>(f1: F, f2: F) {}
| ^^^ ----- -----
help: consider `await`ing on the `Future`
|
LL | fun((async || {})(), (async || {})().await);
| ++++++
error: aborting due to 3 previous errors

9
src/test/ui/async-await/suggest-missing-await-closure.stderr
View file

@ -2,7 +2,9 @@ error[E0308]: mismatched types
--> $DIR/suggest-missing-await-closure.rs:16:18
|
LL | take_u32(x)
| ^ expected `u32`, found opaque type
| -------- ^ expected `u32`, found opaque type
| |
| arguments to this function are incorrect
|
note: while checking the return type of the `async fn`
--> $DIR/suggest-missing-await-closure.rs:8:24
@ -11,6 +13,11 @@ LL | async fn make_u32() -> u32 {
| ^^^ checked the `Output` of this `async fn`, found opaque type
= note: expected type `u32`
found opaque type `impl Future<Output = u32>`
note: function defined here
--> $DIR/suggest-missing-await-closure.rs:6:4
|
LL | fn take_u32(_x: u32) {}
| ^^^^^^^^ -------
help: consider `await`ing on the `Future`
|
LL | take_u32(x.await)

9
src/test/ui/async-await/suggest-missing-await.stderr
View file

@ -2,7 +2,9 @@ error[E0308]: mismatched types
--> $DIR/suggest-missing-await.rs:12:14
|
LL | take_u32(x)
| ^ expected `u32`, found opaque type
| -------- ^ expected `u32`, found opaque type
| |
| arguments to this function are incorrect
|
note: while checking the return type of the `async fn`
--> $DIR/suggest-missing-await.rs:5:24
@ -11,6 +13,11 @@ LL | async fn make_u32() -> u32 {
| ^^^ checked the `Output` of this `async fn`, found opaque type
= note: expected type `u32`
found opaque type `impl Future<Output = u32>`
note: function defined here
--> $DIR/suggest-missing-await.rs:3:4
|
LL | fn take_u32(_x: u32) {}
| ^^^^^^^^ -------
help: consider `await`ing on the `Future`
|
LL | take_u32(x.await)

16
src/test/ui/c-variadic/variadic-ffi-1.stderr
View file

@ -8,29 +8,33 @@ error[E0060]: this function takes at least 2 arguments but 0 arguments were supp
--> $DIR/variadic-ffi-1.rs:20:9
|
LL | foo();
| ^^^-- supplied 0 arguments
| |
| expected at least 2 arguments
| ^^^-- two arguments of type `isize` and `u8` are missing
|
note: function defined here
--> $DIR/variadic-ffi-1.rs:13:8
|
LL | fn foo(f: isize, x: u8, ...);
| ^^^
help: provide the arguments
|
LL | foo({isize}, {u8});
| ~~~~~~~~~~~~~~~~~~
error[E0060]: this function takes at least 2 arguments but 1 argument was supplied
--> $DIR/variadic-ffi-1.rs:21:9
|
LL | foo(1);
| ^^^ - supplied 1 argument
| |
| expected at least 2 arguments
| ^^^--- an argument of type `u8` is missing
|
note: function defined here
--> $DIR/variadic-ffi-1.rs:13:8
|
LL | fn foo(f: isize, x: u8, ...);
| ^^^
help: provide the argument
|
LL | foo(1, {u8});
| ~~~~~~~~~~~~
error[E0308]: mismatched types
--> $DIR/variadic-ffi-1.rs:23:56

46
src/test/ui/cast/cast-int-to-char.stderr
View file

@ -2,8 +2,15 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:4:16
|
LL | foo::<u32>('0');
| ^^^ expected `u32`, found `char`
| ---------- ^^^ expected `u32`, found `char`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/cast-int-to-char.rs:1:4
|
LL | fn foo<T>(_t: T) {}
| ^^^ -----
help: you can cast a `char` to a `u32`, since a `char` always occupies 4 bytes
|
LL | foo::<u32>('0' as u32);
@ -13,8 +20,15 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:5:16
|
LL | foo::<i32>('0');
| ^^^ expected `i32`, found `char`
| ---------- ^^^ expected `i32`, found `char`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/cast-int-to-char.rs:1:4
|
LL | fn foo<T>(_t: T) {}
| ^^^ -----
help: you can cast a `char` to an `i32`, since a `char` always occupies 4 bytes
|
LL | foo::<i32>('0' as i32);
@ -24,8 +38,15 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:6:16
|
LL | foo::<u64>('0');
| ^^^ expected `u64`, found `char`
| ---------- ^^^ expected `u64`, found `char`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/cast-int-to-char.rs:1:4
|
LL | fn foo<T>(_t: T) {}
| ^^^ -----
help: you can cast a `char` to a `u64`, since a `char` always occupies 4 bytes
|
LL | foo::<u64>('0' as u64);
@ -35,8 +56,15 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:7:16
|
LL | foo::<i64>('0');
| ^^^ expected `i64`, found `char`
| ---------- ^^^ expected `i64`, found `char`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/cast-int-to-char.rs:1:4
|
LL | fn foo<T>(_t: T) {}
| ^^^ -----
help: you can cast a `char` to an `i64`, since a `char` always occupies 4 bytes
|
LL | foo::<i64>('0' as i64);
@ -46,7 +74,15 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:8:17
|
LL | foo::<char>(0u32);
| ^^^^ expected `char`, found `u32`
| ----------- ^^^^ expected `char`, found `u32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/cast-int-to-char.rs:1:4
|
LL | fn foo<T>(_t: T) {}
| ^^^ -----
error: aborting due to 5 previous errors

9
src/test/ui/closures/closure-reform-bad.stderr
View file

@ -4,7 +4,9 @@ error[E0308]: mismatched types
LL | let f = |s: &str| println!("{}{}", s, string);
| ------------------------------------- the found closure
LL | call_bare(f)
| ^ expected fn pointer, found closure
| --------- ^ expected fn pointer, found closure
| |
| arguments to this function are incorrect
|
= note: expected fn pointer `for<'r> fn(&'r str)`
found closure `[closure@$DIR/closure-reform-bad.rs:10:13: 10:50]`
@ -13,6 +15,11 @@ note: closures can only be coerced to `fn` types if they do not capture any vari
|
LL | let f = |s: &str| println!("{}{}", s, string);
| ^^^^^^ `string` captured here
note: function defined here
--> $DIR/closure-reform-bad.rs:4:4
|
LL | fn call_bare(f: fn(&str)) {
| ^^^^^^^^^ -----------
error: aborting due to previous error

9
src/test/ui/closures/issue-84128.stderr
View file

@ -2,13 +2,20 @@ error[E0308]: mismatched types
--> $DIR/issue-84128.rs:13:13
|
LL | Foo(())
| ^^ expected integer, found `()`
| --- ^^ expected integer, found `()`
| |
| arguments to this struct are incorrect
|
note: return type inferred to be `{integer}` here
--> $DIR/issue-84128.rs:10:20
|
LL | return Foo(0);
| ^^^^^^
note: tuple struct defined here
--> $DIR/issue-84128.rs:5:8
|
LL | struct Foo<T>(T);
| ^^^
error: aborting due to previous error

12
src/test/ui/closures/issue-87461.stderr
View file

@ -2,19 +2,25 @@ error[E0308]: mismatched types
--> $DIR/issue-87461.rs:10:8
|
LL | Ok(())
| ^^ expected `u16`, found `()`
| -- ^^ expected `u16`, found `()`
| |
| arguments to this enum variant are incorrect
error[E0308]: mismatched types
--> $DIR/issue-87461.rs:17:8
|
LL | Ok(())
| ^^ expected `u16`, found `()`
| -- ^^ expected `u16`, found `()`
| |
| arguments to this enum variant are incorrect
error[E0308]: mismatched types
--> $DIR/issue-87461.rs:26:12
|
LL | Ok(())
| ^^ expected `u16`, found `()`
| -- ^^ expected `u16`, found `()`
| |
| arguments to this enum variant are incorrect
error: aborting due to 3 previous errors

9
src/test/ui/coercion/coerce-mut.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/coerce-mut.rs:5:7
|
LL | f(&x);
| ^^ types differ in mutability
| - ^^ types differ in mutability
| |
| arguments to this function are incorrect
|
= note: expected mutable reference `&mut i32`
found reference `&{integer}`
note: function defined here
--> $DIR/coerce-mut.rs:1:4
|
LL | fn f(x: &mut i32) {}
| ^ -----------
error: aborting due to previous error

13
src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/coerce-reborrow-multi-arg-fail.rs:4:18
|
LL | test(&mut 7, &7);
| ^^ types differ in mutability
| ---- ^^ types differ in mutability
| |
| arguments to this function are incorrect
|
= note: expected mutable reference `&mut {integer}`
found reference `&{integer}`
= note: expected type `&mut {integer}`
found reference `&{integer}`
note: function defined here
--> $DIR/coerce-reborrow-multi-arg-fail.rs:1:4
|
LL | fn test<T>(_a: T, _b: T) {}
| ^^^^ ----- -----
error: aborting due to previous error

45
src/test/ui/coercion/coerce-to-bang.stderr
View file

@ -2,46 +2,81 @@ error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:6:17
|
LL | foo(return, 22, 44);
| ^^ expected `!`, found integer
| --- ^^ expected `!`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
note: function defined here
--> $DIR/coerce-to-bang.rs:3:4
|
LL | fn foo(x: usize, y: !, z: usize) { }
| ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:18:13
|
LL | foo(22, 44, return);
| ^^ expected `!`, found integer
| --- ^^ expected `!`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
note: function defined here
--> $DIR/coerce-to-bang.rs:3:4
|
LL | fn foo(x: usize, y: !, z: usize) { }
| ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:26:12
|
LL | foo(a, b, c); // ... and hence a reference to `a` is expected to diverge.
| ^ expected `!`, found integer
| --- ^ expected `!`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
note: function defined here
--> $DIR/coerce-to-bang.rs:3:4
|
LL | fn foo(x: usize, y: !, z: usize) { }
| ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:36:12
|
LL | foo(a, b, c);
| ^ expected `!`, found integer
| --- ^ expected `!`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
note: function defined here
--> $DIR/coerce-to-bang.rs:3:4
|
LL | fn foo(x: usize, y: !, z: usize) { }
| ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:45:12
|
LL | foo(a, b, c);
| ^ expected `!`, found integer
| --- ^ expected `!`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
note: function defined here
--> $DIR/coerce-to-bang.rs:3:4
|
LL | fn foo(x: usize, y: !, z: usize) { }
| ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:50:21

29
src/test/ui/const-generics/const-argument-cross-crate-mismatch.min.stderr Normal file
View file

@ -0,0 +1,29 @@
error[E0308]: arguments to this function are incorrect
--> $DIR/const-argument-cross-crate-mismatch.rs:7:41
|
LL | let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8]));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^----------^
| |
| expected `[u8; 3]`, found `[u8; 2]`
|
help: provide an argument of the correct type
|
LL | let _ = const_generic_lib::function(({[u8; 3]}));
| ^^^^^^^^^^^
error[E0308]: arguments to this function are incorrect
--> $DIR/const-argument-cross-crate-mismatch.rs:9:39
|
LL | let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^
| |
| expected `[u8; 2]`, found `[u8; 3]`
|
help: provide an argument of the correct type
|
LL | let _: const_generic_lib::Alias = ({[u8; 2]});
| ^^^^^^^^^^^
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0308`.

8
src/test/ui/const-generics/const-argument-cross-crate-mismatch.stderr
View file

@ -2,13 +2,17 @@ error[E0308]: mismatched types
--> $DIR/const-argument-cross-crate-mismatch.rs:6:67
|
LL | let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8]));
| ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
| ------------------------- ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
| |
| arguments to this struct are incorrect
error[E0308]: mismatched types
--> $DIR/const-argument-cross-crate-mismatch.rs:8:65
|
LL | let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]);
| ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements
| ------------------------- ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements
| |
| arguments to this struct are incorrect
error: aborting due to 2 previous errors

25
src/test/ui/const-generics/generic_const_exprs/issue-62504.min.stderr
View file

@ -1,12 +1,3 @@
error[E0308]: mismatched types
--> $DIR/issue-62504.rs:18:21
|
LL | ArrayHolder([0; Self::SIZE])
| ^^^^^^^^^^^^^^^ expected `X`, found `Self::SIZE`
|
= note: expected array `[u32; X]`
found array `[u32; _]`
error: constant expression depends on a generic parameter
--> $DIR/issue-62504.rs:18:25
|
@ -15,6 +6,22 @@ LL | ArrayHolder([0; Self::SIZE])
|
= note: this may fail depending on what value the parameter takes
error[E0308]: mismatched types
--> $DIR/issue-62504.rs:18:21
|
LL | ArrayHolder([0; Self::SIZE])
| ----------- ^^^^^^^^^^^^^^^ expected `X`, found `Self::SIZE`
| |
| arguments to this struct are incorrect
|
= note: expected array `[u32; X]`
found array `[u32; _]`
note: tuple struct defined here
--> $DIR/issue-62504.rs:14:8
|
LL | struct ArrayHolder<const X: usize>([u32; X]);
| ^^^^^^^^^^^
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0308`.

9
src/test/ui/did_you_mean/issue-42764.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/issue-42764.rs:11:43
|
LL | this_function_expects_a_double_option(n);
| ^ expected enum `DoubleOption`, found `usize`
| ------------------------------------- ^ expected enum `DoubleOption`, found `usize`
| |
| arguments to this function are incorrect
|
= note: expected enum `DoubleOption<_>`
found type `usize`
note: function defined here
--> $DIR/issue-42764.rs:7:4
|
LL | fn this_function_expects_a_double_option<T>(d: DoubleOption<T>) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ------------------
help: try wrapping the expression in a variant of `DoubleOption`
|
LL | this_function_expects_a_double_option(DoubleOption::FirstSome(n));

9
src/test/ui/disambiguate-identical-names.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/disambiguate-identical-names.rs:13:10
|
LL | test(&v);
| ^^ expected struct `std::vec::Vec`, found struct `HashMap`
| ---- ^^ expected struct `std::vec::Vec`, found struct `HashMap`
| |
| arguments to this function are incorrect
|
= note: expected reference `&std::vec::Vec<std::vec::Vec<u32>>`
found reference `&HashMap<u8, u8>`
note: function defined here
--> $DIR/disambiguate-identical-names.rs:6:4
|
LL | fn test(_v: &Vec<Vec<u32>>) {
| ^^^^ ------------------
error: aborting due to previous error

18
src/test/ui/error-codes/E0057.stderr
View file

@ -2,17 +2,23 @@ error[E0057]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/E0057.rs:3:13
|
LL | let a = f();
| ^-- supplied 0 arguments
| |
| expected 1 argument
| ^-- an argument is missing
|
help: provide the argument
|
LL | let a = f({_});
| ~~~~~~
error[E0057]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/E0057.rs:5:13
|
LL | let c = f(2, 3);
| ^ - - supplied 2 arguments
| |
| expected 1 argument
| ^ - argument unexpected
|
help: remove the extra argument
|
LL | let c = f(2);
| ~~~~
error: aborting due to 2 previous errors

1
src/test/ui/error-codes/E0060.rs
View file

@ -5,5 +5,4 @@ extern "C" {
fn main() {
unsafe { printf(); }
//~^ ERROR E0060
//~| expected at least 1 argument
}

8
src/test/ui/error-codes/E0060.stderr
View file

@ -2,15 +2,17 @@ error[E0060]: this function takes at least 1 argument but 0 arguments were suppl
--> $DIR/E0060.rs:6:14
|
LL | unsafe { printf(); }
| ^^^^^^-- supplied 0 arguments
| |
| expected at least 1 argument
| ^^^^^^-- an argument of type `*const u8` is missing
|
note: function defined here
--> $DIR/E0060.rs:2:8
|
LL | fn printf(_: *const u8, ...) -> u32;
| ^^^^^^
help: provide the argument
|
LL | unsafe { printf({*const u8}); }
| ~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error

2
src/test/ui/error-codes/E0061.rs
View file

@ -5,9 +5,7 @@ fn f2(a: u16) {}
fn main() {
f(0);
//~^ ERROR E0061
//~| expected 2 arguments
f2();
//~^ ERROR E0061
//~| expected 1 argument
}

18
src/test/ui/error-codes/E0061.stderr
View file

@ -2,29 +2,33 @@ error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/E0061.rs:6:5
|
LL | f(0);
| ^ - supplied 1 argument
| |
| expected 2 arguments
| ^--- an argument of type `&str` is missing
|
note: function defined here
--> $DIR/E0061.rs:1:4
|
LL | fn f(a: u16, b: &str) {}
| ^ ------ -------
help: provide the argument
|
LL | f(0, {&str});
| ~~~~~~~~~~~~
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/E0061.rs:10:5
--> $DIR/E0061.rs:9:5
|
LL | f2();
| ^^-- supplied 0 arguments
| |
| expected 1 argument
| ^^-- an argument of type `u16` is missing
|
note: function defined here
--> $DIR/E0061.rs:3:4
|
LL | fn f2(a: u16) {}
| ^^ ------
help: provide the argument
|
LL | f2({u16});
| ~~~~~~~~~
error: aborting due to 2 previous errors

15
src/test/ui/estr-subtyping.rs Normal file
View file

@ -0,0 +1,15 @@
fn wants_uniq(x: String) { }
fn wants_slice(x: &str) { }
fn has_uniq(x: String) {
wants_uniq(x);
wants_slice(&*x);
}
fn has_slice(x: &str) {
wants_uniq(x); //~ ERROR mismatched types
wants_slice(x);
}
fn main() {
}

18
src/test/ui/estr-subtyping.stderr Normal file
View file

@ -0,0 +1,18 @@
error[E0308]: mismatched types
--> $DIR/estr-subtyping.rs:10:15
|
LL | wants_uniq(x);
| ---------- ^- help: try using a conversion method: `.to_string()`
| | |
| | expected struct `String`, found `&str`
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/estr-subtyping.rs:1:4
|
LL | fn wants_uniq(x: String) { }
| ^^^^^^^^^^ ---------
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.

20
src/test/ui/fmt/ifmt-bad-arg.stderr
View file

@ -296,20 +296,36 @@ error[E0308]: mismatched types
--> $DIR/ifmt-bad-arg.rs:78:32
|
LL | println!("{} {:.*} {}", 1, 3.2, 4);
| ^^^ expected `usize`, found floating-point number
| ---------------------------^^^----
| | |
| | expected `usize`, found floating-point number
| arguments to this function are incorrect
|
= note: expected reference `&usize`
found reference `&{float}`
note: associated function defined here
--> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
|
LL | pub fn from_usize(x: &usize) -> ArgumentV1<'_> {
| ^^^^^^^^^^
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0308]: mismatched types
--> $DIR/ifmt-bad-arg.rs:81:35
|
LL | println!("{} {:07$.*} {}", 1, 3.2, 4);
| ^^^ expected `usize`, found floating-point number
| ------------------------------^^^----
| | |
| | expected `usize`, found floating-point number
| arguments to this function are incorrect
|
= note: expected reference `&usize`
found reference `&{float}`
note: associated function defined here
--> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
|
LL | pub fn from_usize(x: &usize) -> ArgumentV1<'_> {
| ^^^^^^^^^^
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 36 previous errors

6
src/test/ui/fn/fn-item-type.rs
View file

@ -12,7 +12,7 @@ impl<T> Foo for T { /* `foo` is still default here */ }
fn main() {
eq(foo::<u8>, bar::<u8>);
//~^ ERROR mismatched types
//~| expected fn item `fn(_) -> _ {foo::<u8>}`
//~| expected type `fn(_) -> _ {foo::<u8>}`
//~| found fn item `fn(_) -> _ {bar::<u8>}`
//~| expected fn item, found a different fn item
//~| different `fn` items always have unique types, even if their signatures are the same
@ -28,7 +28,7 @@ fn main() {
eq(bar::<String>, bar::<Vec<u8>>);
//~^ ERROR mismatched types
//~| expected fn item `fn(_) -> _ {bar::<String>}`
//~| expected type `fn(_) -> _ {bar::<String>}`
//~| found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
//~| expected struct `String`, found struct `Vec`
//~| different `fn` items always have unique types, even if their signatures are the same
@ -45,7 +45,7 @@ fn main() {
eq(foo::<u8>, bar::<u8> as fn(isize) -> isize);
//~^ ERROR mismatched types
//~| expected fn item `fn(_) -> _ {foo::<u8>}`
//~| expected type `fn(_) -> _ {foo::<u8>}`
//~| found fn pointer `fn(_) -> _`
//~| expected fn item, found fn pointer
//~| change the expected type to be function pointer

63
src/test/ui/fn/fn-item-type.stderr
View file

@ -2,60 +2,95 @@ error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:13:19
|
LL | eq(foo::<u8>, bar::<u8>);
| ^^^^^^^^^ expected fn item, found a different fn item
| -- ^^^^^^^^^ expected fn item, found a different fn item
| |
| arguments to this function are incorrect
|
= note: expected fn item `fn(_) -> _ {foo::<u8>}`
found fn item `fn(_) -> _ {bar::<u8>}`
= note: expected type `fn(_) -> _ {foo::<u8>}`
found fn item `fn(_) -> _ {bar::<u8>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`
note: function defined here
--> $DIR/fn-item-type.rs:7:4
|
LL | fn eq<T>(x: T, y: T) { }
| ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:22:19
|
LL | eq(foo::<u8>, foo::<i8>);
| ^^^^^^^^^ expected `u8`, found `i8`
| -- ^^^^^^^^^ expected `u8`, found `i8`
| |
| arguments to this function are incorrect
|
= note: expected fn item `fn(_) -> _ {foo::<u8>}`
found fn item `fn(_) -> _ {foo::<i8>}`
= note: expected type `fn(_) -> _ {foo::<u8>}`
found fn item `fn(_) -> _ {foo::<i8>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`
note: function defined here
--> $DIR/fn-item-type.rs:7:4
|
LL | fn eq<T>(x: T, y: T) { }
| ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:29:23
|
LL | eq(bar::<String>, bar::<Vec<u8>>);
| ^^^^^^^^^^^^^^ expected struct `String`, found struct `Vec`
| -- ^^^^^^^^^^^^^^ expected struct `String`, found struct `Vec`
| |
| arguments to this function are incorrect
|
= note: expected fn item `fn(_) -> _ {bar::<String>}`
found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
= note: expected type `fn(_) -> _ {bar::<String>}`
found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `bar::<String> as fn(isize) -> isize`
note: function defined here
--> $DIR/fn-item-type.rs:7:4
|
LL | fn eq<T>(x: T, y: T) { }
| ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:39:26
|
LL | eq(<u8 as Foo>::foo, <u16 as Foo>::foo);
| ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16`
| -- ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16`
| |
| arguments to this function are incorrect
|
= note: expected fn item `fn() {<u8 as Foo>::foo}`
found fn item `fn() {<u16 as Foo>::foo}`
= note: expected type `fn() {<u8 as Foo>::foo}`
found fn item `fn() {<u16 as Foo>::foo}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn()`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `<u8 as Foo>::foo as fn()`
note: function defined here
--> $DIR/fn-item-type.rs:7:4
|
LL | fn eq<T>(x: T, y: T) { }
| ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:46:19
|
LL | eq(foo::<u8>, bar::<u8> as fn(isize) -> isize);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer
| -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer
| |
| arguments to this function are incorrect
|
= note: expected fn item `fn(_) -> _ {foo::<u8>}`
= note: expected type `fn(_) -> _ {foo::<u8>}`
found fn pointer `fn(_) -> _`
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`
note: function defined here
--> $DIR/fn-item-type.rs:7:4
|
LL | fn eq<T>(x: T, y: T) { }
| ^^ ---- ----
error: aborting due to 5 previous errors

9
src/test/ui/generic-associated-types/issue-68648-2.stderr
View file

@ -4,10 +4,17 @@ error[E0308]: mismatched types
LL | fn bug<'a, T: Fun<F<'a> = T>>(t: T) -> T::F<'a> {
| - this type parameter
LL | T::identity(())
| ^^ expected type parameter `T`, found `()`
| ----------- ^^ expected type parameter `T`, found `()`
| |
| arguments to this function are incorrect
|
= note: expected type parameter `T`
found unit type `()`
note: associated function defined here
--> $DIR/issue-68648-2.rs:6:8
|
LL | fn identity<'a>(t: Self::F<'a>) -> Self::F<'a> { t }
| ^^^^^^^^ --------------
error: aborting due to previous error

27
src/test/ui/generic-associated-types/missing-bounds.stderr
View file

@ -17,10 +17,17 @@ LL | impl<B> Add for A<B> where B: Add {
| - this type parameter
...
LL | A(self.0 + rhs.0)
| ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
| - ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
| |
| arguments to this struct are incorrect
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
note: tuple struct defined here
--> $DIR/missing-bounds.rs:5:8
|
LL | struct A<B>(B);
| ^
help: consider further restricting this bound
|
LL | impl<B> Add for A<B> where B: Add + Add<Output = B> {
@ -33,10 +40,17 @@ LL | impl<B: Add> Add for C<B> {
| - this type parameter
...
LL | Self(self.0 + rhs.0)
| ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
| ---- ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
| |
| arguments to this function are incorrect
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
note: tuple struct defined here
--> $DIR/missing-bounds.rs:15:8
|
LL | struct C<B>(B);
| ^
help: consider further restricting this bound
|
LL | impl<B: Add + Add<Output = B>> Add for C<B> {
@ -62,10 +76,17 @@ LL | impl<B: Add> Add for E<B> where <B as Add>::Output = B {
| - this type parameter
...
LL | Self(self.0 + rhs.0)
| ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
| ---- ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
| |
| arguments to this function are incorrect
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
note: tuple struct defined here
--> $DIR/missing-bounds.rs:35:8
|
LL | struct E<B>(B);
| ^
help: consider further restricting type parameter `B`
|
LL | impl<B: Add> Add for E<B> where <B as Add>::Output = B, B: Add<Output = B> {

8
src/test/ui/hrtb/issue-58451.stderr
View file

@ -2,15 +2,17 @@ error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/issue-58451.rs:12:9
|
LL | f(&[f()]);
| ^-- supplied 0 arguments
| |
| expected 1 argument
| ^-- an argument is missing
|
note: function defined here
--> $DIR/issue-58451.rs:5:4
|
LL | fn f<I>(i: I)
| ^ ----
help: provide the argument
|
LL | f(&[f({_})]);
| ~~~~~~
error: aborting due to previous error

9
src/test/ui/impl-trait/issues/issue-74282.stderr
View file

@ -5,7 +5,9 @@ LL | type Closure = impl Fn() -> u64;
| ---------------- the expected opaque type
...
LL | Anonymous(|| {
| _______________^
| _____---------_^
| | |
| | arguments to this struct are incorrect
LL | | 3
LL | | })
| |_____^ expected closure, found a different closure
@ -14,6 +16,11 @@ LL | | })
found closure `[closure@$DIR/issue-74282.rs:8:15: 10:6]`
= note: no two closures, even if identical, have the same type
= help: consider boxing your closure and/or using it as a trait object
note: tuple struct defined here
--> $DIR/issue-74282.rs:4:8
|
LL | struct Anonymous(Closure);
| ^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/issue-74282.rs:8:5

11
src/test/ui/indexing-requires-a-uint.stderr
View file

@ -12,12 +12,15 @@ error[E0308]: mismatched types
--> $DIR/indexing-requires-a-uint.rs:12:18
|
LL | bar::<isize>(i); // i should not be re-coerced back to an isize
| ^ expected `isize`, found `usize`
| ------------ ^ expected `isize`, found `usize`
| |
| arguments to this function are incorrect
|
help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
note: function defined here
--> $DIR/indexing-requires-a-uint.rs:5:8
|
LL | bar::<isize>(i.try_into().unwrap()); // i should not be re-coerced back to an isize
| ++++++++++++++++++++
LL | fn bar<T>(_: T) {}
| ^^^ ----
error: aborting due to 2 previous errors

49
src/test/ui/inference/deref-suggestion.stderr
View file

@ -2,16 +2,30 @@ error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:8:9
|
LL | foo(s);
| ^- help: try using a conversion method: `.to_string()`
| |
| expected struct `String`, found `&String`
| --- ^- help: try using a conversion method: `.to_string()`
| | |
| | expected struct `String`, found `&String`
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/deref-suggestion.rs:5:4
|
LL | fn foo(_: String) {}
| ^^^ ---------
error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:14:10
|
LL | foo3(u);
| ^ expected `u32`, found `&u32`
| ---- ^ expected `u32`, found `&u32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/deref-suggestion.rs:12:4
|
LL | fn foo3(_: u32) {}
| ^^^^ ------
help: consider dereferencing the borrow
|
LL | foo3(*u);
@ -21,8 +35,15 @@ error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:30:9
|
LL | foo(&"aaa".to_owned());
| ^^^^^^^^^^^^^^^^^ expected struct `String`, found `&String`
| --- ^^^^^^^^^^^^^^^^^ expected struct `String`, found `&String`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/deref-suggestion.rs:5:4
|
LL | fn foo(_: String) {}
| ^^^ ---------
help: consider removing the borrow
|
LL - foo(&"aaa".to_owned());
@ -33,8 +54,15 @@ error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:32:9
|
LL | foo(&mut "aaa".to_owned());
| ^^^^^^^^^^^^^^^^^^^^^ expected struct `String`, found `&mut String`
| --- ^^^^^^^^^^^^^^^^^^^^^ expected struct `String`, found `&mut String`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/deref-suggestion.rs:5:4
|
LL | fn foo(_: String) {}
| ^^^ ---------
help: consider removing the borrow
|
LL - foo(&mut "aaa".to_owned());
@ -48,8 +76,15 @@ LL | ($x:expr) => { &$x }
| ^^^ expected `u32`, found `&{integer}`
...
LL | foo3(borrow!(0));
| ---------- in this macro invocation
| ---- ---------- in this macro invocation
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/deref-suggestion.rs:12:4
|
LL | fn foo3(_: u32) {}
| ^^^^ ------
= note: this error originates in the macro `borrow` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0308]: mismatched types

27
src/test/ui/inference/tutorial-suffix-inference-test.stderr
View file

@ -2,8 +2,15 @@ error[E0308]: mismatched types
--> $DIR/tutorial-suffix-inference-test.rs:9:18
|
LL | identity_u16(x);
| ^ expected `u16`, found `u8`
| ------------ ^ expected `u16`, found `u8`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/tutorial-suffix-inference-test.rs:6:8
|
LL | fn identity_u16(n: u16) -> u16 { n }
| ^^^^^^^^^^^^ ------
help: you can convert a `u8` to a `u16`
|
LL | identity_u16(x.into());
@ -13,8 +20,15 @@ error[E0308]: mismatched types
--> $DIR/tutorial-suffix-inference-test.rs:12:18
|
LL | identity_u16(y);
| ^ expected `u16`, found `i32`
| ------------ ^ expected `u16`, found `i32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/tutorial-suffix-inference-test.rs:6:8
|
LL | fn identity_u16(n: u16) -> u16 { n }
| ^^^^^^^^^^^^ ------
help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit
|
LL | identity_u16(y.try_into().unwrap());
@ -24,8 +38,15 @@ error[E0308]: mismatched types
--> $DIR/tutorial-suffix-inference-test.rs:21:18
|
LL | identity_u16(a);
| ^ expected `u16`, found `isize`
| ------------ ^ expected `u16`, found `isize`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/tutorial-suffix-inference-test.rs:6:8
|
LL | fn identity_u16(n: u16) -> u16 { n }
| ^^^^^^^^^^^^ ------
help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit
|
LL | identity_u16(a.try_into().unwrap());

9
src/test/ui/issues/issue-10764.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/issue-10764.rs:4:15
|
LL | fn main() { f(bar) }
| ^^^ expected "Rust" fn, found "C" fn
| - ^^^ expected "Rust" fn, found "C" fn
| |
| arguments to this function are incorrect
|
= note: expected fn pointer `fn()`
found fn item `extern "C" fn() {bar}`
note: function defined here
--> $DIR/issue-10764.rs:1:4
|
LL | fn f(_: extern "Rust" fn()) {}
| ^ ---------------------
error: aborting due to previous error

14
src/test/ui/issues/issue-11374.stderr
View file

@ -2,13 +2,19 @@ error[E0308]: mismatched types
--> $DIR/issue-11374.rs:26:15
|
LL | c.read_to(v);
| ^
| |
| expected `&mut [u8]`, found struct `Vec`
| help: consider mutably borrowing here: `&mut v`
| ------- ^
| | |
| | expected `&mut [u8]`, found struct `Vec`
| | help: consider mutably borrowing here: `&mut v`
| arguments to this function are incorrect
|
= note: expected mutable reference `&mut [u8]`
found struct `Vec<_>`
note: associated function defined here
--> $DIR/issue-11374.rs:13:12
|
LL | pub fn read_to(&mut self, vec: &mut [u8]) {
| ^^^^^^^ --------- --------------
error: aborting due to previous error

10
src/test/ui/issues/issue-12997-2.stderr
View file

@ -4,8 +4,16 @@ error[E0308]: mismatched types
LL | #[bench]
| -------- in this procedural macro expansion
LL | fn bar(x: isize) { }
| ^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `&mut Bencher`
| ^^^^^^^^^^^^^^^^^^^^
| |
| expected `isize`, found `&mut Bencher`
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/issue-12997-2.rs:8:4
|
LL | fn bar(x: isize) { }
| ^^^ --------
= note: this error originates in the attribute macro `bench` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error

22
src/test/ui/issues/issue-13359.stderr
View file

@ -2,23 +2,29 @@ error[E0308]: mismatched types
--> $DIR/issue-13359.rs:6:9
|
LL | foo(1*(1 as isize));
| ^^^^^^^^^^^^^^ expected `i16`, found `isize`
| --- ^^^^^^^^^^^^^^ expected `i16`, found `isize`
| |
| arguments to this function are incorrect
|
help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
note: function defined here
--> $DIR/issue-13359.rs:1:4
|
LL | foo((1*(1 as isize)).try_into().unwrap());
| + +++++++++++++++++++++
LL | fn foo(_s: i16) { }
| ^^^ -------
error[E0308]: mismatched types
--> $DIR/issue-13359.rs:10:9
|
LL | bar(1*(1 as usize));
| ^^^^^^^^^^^^^^ expected `u32`, found `usize`
| --- ^^^^^^^^^^^^^^ expected `u32`, found `usize`
| |
| arguments to this function are incorrect
|
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
note: function defined here
--> $DIR/issue-13359.rs:3:4
|
LL | bar((1*(1 as usize)).try_into().unwrap());
| + +++++++++++++++++++++
LL | fn bar(_s: u32) { }
| ^^^ -------
error: aborting due to 2 previous errors

14
src/test/ui/issues/issue-13853.stderr
View file

@ -20,13 +20,19 @@ error[E0308]: mismatched types
--> $DIR/issue-13853.rs:37:13
|
LL | iterate(graph);
| ^^^^^
| |
| expected reference, found struct `Vec`
| help: consider borrowing here: `&graph`
| ------- ^^^^^
| | |
| | expected reference, found struct `Vec`
| | help: consider borrowing here: `&graph`
| arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `Vec<Stuff>`
note: function defined here
--> $DIR/issue-13853.rs:26:4
|
LL | fn iterate<N: Node, G: Graph<N>>(graph: &G) {
| ^^^^^^^ ---------
error: aborting due to 3 previous errors

9
src/test/ui/issues/issue-1448-2.stderr
View file

@ -2,8 +2,15 @@ error[E0308]: mismatched types
--> $DIR/issue-1448-2.rs:6:24
|
LL | println!("{}", foo(10i32));
| ^^^^^ expected `u32`, found `i32`
| --- ^^^^^ expected `u32`, found `i32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/issue-1448-2.rs:3:4
|
LL | fn foo(a: u32) -> u32 { a }
| ^^^ ------
help: change the type of the numeric literal from `i32` to `u32`
|
LL | println!("{}", foo(10u32));

9
src/test/ui/issues/issue-15783.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/issue-15783.rs:8:19
|
LL | let msg = foo(x);
| ^ expected slice `[&str]`, found array `[&str; 1]`
| --- ^ expected slice `[&str]`, found array `[&str; 1]`
| |
| arguments to this function are incorrect
|
= note: expected enum `Option<&[&str]>`
found enum `Option<&[&str; 1]>`
note: function defined here
--> $DIR/issue-15783.rs:1:8
|
LL | pub fn foo(params: Option<&[&str]>) -> usize {
| ^^^ -----------------------
error: aborting due to previous error

8
src/test/ui/issues/issue-16939.stderr
View file

@ -2,15 +2,17 @@ error[E0057]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/issue-16939.rs:5:9
|
LL | |t| f(t);
| ^ - supplied 1 argument
| |
| expected 0 arguments
| ^ - argument unexpected
|
note: associated function defined here
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
|
LL | extern "rust-call" fn call(&self, args: Args) -> Self::Output;
| ^^^^
help: remove the extra argument
|
LL | |t| f();
| ~~~
error: aborting due to previous error

9
src/test/ui/issues/issue-17033.stderr
View file

@ -2,10 +2,11 @@ error[E0308]: mismatched types
--> $DIR/issue-17033.rs:2:10
|
LL | (*p)(())
| ^^
| |
| expected `&mut ()`, found `()`
| help: consider mutably borrowing here: `&mut ()`
| ---- ^^
| | |
| | expected `&mut ()`, found `()`
| | help: consider mutably borrowing here: `&mut ()`
| arguments to this function are incorrect
error: aborting due to previous error

17
src/test/ui/issues/issue-18819.stderr
View file

@ -2,15 +2,26 @@ error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/issue-18819.rs:16:5
|
LL | print_x(X);
| ^^^^^^^ - supplied 1 argument
| |
| expected 2 arguments
| ^^^^^^^---
| ||
| |expected reference, found struct `X`
| an argument of type `&str` is missing
|
= note: expected reference `&dyn Foo<Item = bool>`
found struct `X`
note: function defined here
--> $DIR/issue-18819.rs:11:4
|
LL | fn print_x(_: &dyn Foo<Item=bool>, extra: &str) {
| ^^^^^^^ ---------------------- -----------
help: consider borrowing here
|
LL | print_x(&X);
| ~~
help: provide the argument
|
LL | print_x({&dyn Foo<Item = bool>}, {&str});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error

9
src/test/ui/issues/issue-24819.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/issue-24819.rs:5:9
|
LL | foo(&mut v);
| ^^^^^^ expected struct `HashSet`, found struct `Vec`
| --- ^^^^^^ expected struct `HashSet`, found struct `Vec`
| |
| arguments to this function are incorrect
|
= note: expected mutable reference `&mut HashSet<u32>`
found mutable reference `&mut Vec<_>`
note: function defined here
--> $DIR/issue-24819.rs:10:4
|
LL | fn foo(h: &mut HashSet<u32>) {
| ^^^ --------------------
error: aborting due to previous error

4
src/test/ui/issues/issue-26094.rs
View file

@ -1,6 +1,6 @@
macro_rules! some_macro {
($other: expr) => ({
$other(None) //~ NOTE supplied 1 argument
$other(None) //~ NOTE argument unexpected
})
}
@ -9,5 +9,5 @@ fn some_function() {} //~ NOTE defined here
fn main() {
some_macro!(some_function);
//~^ ERROR this function takes 0 arguments but 1 argument was supplied
//~| NOTE expected 0 arguments
//~| NOTE in this expansion of some_macro!
}

8
src/test/ui/issues/issue-26094.stderr
View file

@ -2,16 +2,20 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/issue-26094.rs:10:17
|
LL | $other(None)
| ---- supplied 1 argument
| ---- argument unexpected
...
LL | some_macro!(some_function);
| ^^^^^^^^^^^^^ expected 0 arguments
| ^^^^^^^^^^^^^
|
note: function defined here
--> $DIR/issue-26094.rs:7:4
|
LL | fn some_function() {}
| ^^^^^^^^^^^^^
help: remove the extra argument
|
LL | some_function()
| ~~~~~~~~~~~~~~~
error: aborting due to previous error

3
src/test/ui/issues/issue-3044.rs
View file

@ -2,5 +2,6 @@ fn main() {
let needlesArr: Vec<char> = vec!['a', 'f'];
needlesArr.iter().fold(|x, y| {
});
//~^^ ERROR this function takes 2 arguments but 1 argument was supplied
//~^^ ERROR mismatched types
//~| ERROR this function takes 2 arguments but 1 argument was supplied
}

27
src/test/ui/issues/issue-3044.stderr
View file

@ -1,19 +1,34 @@
error[E0308]: mismatched types
--> $DIR/issue-3044.rs:3:35
|
LL | needlesArr.iter().fold(|x, y| {
| ___________________________________^
LL | | });
| |_____^ expected closure, found `()`
|
= note: expected closure `[closure@$DIR/issue-3044.rs:3:28: 4:6]`
found unit type `()`
error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/issue-3044.rs:3:23
|
LL | needlesArr.iter().fold(|x, y| {
| _______________________^^^^_-
| | |
| | expected 2 arguments
| _______________________^^^^-
LL | | });
| |_____- supplied 1 argument
| |______- an argument is missing
|
note: associated function defined here
--> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
|
LL | fn fold<B, F>(mut self, init: B, mut f: F) -> B
| ^^^^
help: provide the argument
|
LL ~ needlesArr.iter().fold(|x, y| {
LL ~ }, {_});
|
error: aborting due to previous error
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0061`.
Some errors have detailed explanations: E0061, E0308.
For more information about an error, try `rustc --explain E0061`.

9
src/test/ui/issues/issue-43420-no-over-suggest.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/issue-43420-no-over-suggest.rs:8:9
|
LL | foo(&a);
| ^^ expected slice `[u16]`, found struct `Vec`
| --- ^^ expected slice `[u16]`, found struct `Vec`
| |
| arguments to this function are incorrect
|
= note: expected reference `&[u16]`
found reference `&Vec<u8>`
note: function defined here
--> $DIR/issue-43420-no-over-suggest.rs:4:4
|
LL | fn foo(b: &[u16]) {}
| ^^^ ---------
error: aborting due to previous error

10
src/test/ui/issues/issue-4517.stderr
View file

@ -2,7 +2,15 @@ error[E0308]: mismatched types
--> $DIR/issue-4517.rs:5:9
|
LL | bar(foo);
| ^^^ expected `usize`, found array `[u8; 4]`
| --- ^^^ expected `usize`, found array `[u8; 4]`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/issue-4517.rs:1:4
|
LL | fn bar(int_param: usize) {}
| ^^^ ----------------
error: aborting due to previous error

30
src/test/ui/issues/issue-46756-consider-borrowing-cast-or-binexpr.stderr
View file

@ -2,19 +2,33 @@ 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`
| | help: consider borrowing here: `&(behold as usize)`
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:5:4
|
LL | fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> 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`
| | help: consider borrowing here: `&(with_tears + 4)`
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:5:4
|
LL | fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ---------------
error: aborting due to 2 previous errors

9
src/test/ui/issues/issue-48364.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/issue-48364.rs:2:21
|
LL | b"".starts_with(stringify!(foo))
| ^^^^^^^^^^^^^^^ expected slice `[u8]`, found `str`
| ----------- ^^^^^^^^^^^^^^^ expected slice `[u8]`, found `str`
| |
| arguments to this function are incorrect
|
= note: expected reference `&[u8]`
found reference `&'static str`
note: associated function defined here
--> $SRC_DIR/core/src/slice/mod.rs:LL:COL
|
LL | pub fn starts_with(&self, needle: &[T]) -> bool
| ^^^^^^^^^^^
= note: this error originates in the macro `stringify` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error

8
src/test/ui/issues/issue-4935.stderr
View file

@ -2,15 +2,17 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/issue-4935.rs:5:13
|
LL | fn main() { foo(5, 6) }
| ^^^ - - supplied 2 arguments
| |
| expected 1 argument
| ^^^ - argument unexpected
|
note: function defined here
--> $DIR/issue-4935.rs:3:4
|
LL | fn foo(a: usize) {}
| ^^^ --------
help: remove the extra argument
|
LL | fn main() { foo(5) }
| ~~~~~~
error: aborting due to previous error

9
src/test/ui/issues/issue-51154.stderr
View file

@ -4,11 +4,18 @@ error[E0308]: mismatched types
LL | fn foo<F: FnMut()>() {
| - this type parameter
LL | let _: Box<F> = Box::new(|| ());
| ^^^^^ expected type parameter `F`, found closure
| -------- ^^^^^ expected type parameter `F`, found closure
| |
| arguments to this function are incorrect
|
= note: expected type parameter `F`
found closure `[closure@$DIR/issue-51154.rs:2:30: 2:35]`
= help: every closure has a distinct type and so could not always match the caller-chosen type of parameter `F`
note: associated function defined here
--> $SRC_DIR/alloc/src/boxed.rs:LL:COL
|
LL | pub fn new(x: T) -> Self {
| ^^^
error: aborting due to previous error

9
src/test/ui/issues/issue-5216.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/issue-5216.rs:3:21
|
LL | pub static C: S = S(f);
| ^ expected struct `Box`, found fn item
| - ^ expected struct `Box`, found fn item
| |
| arguments to this struct are incorrect
|
= note: expected struct `Box<(dyn FnMut() + Sync + 'static)>`
found fn item `fn() {f}`
note: tuple struct defined here
--> $DIR/issue-5216.rs:2:8
|
LL | struct S(Box<dyn FnMut() + Sync>);
| ^
error[E0308]: mismatched types
--> $DIR/issue-5216.rs:8:19

15
src/test/ui/issues/issue-61106.stderr
View file

@ -2,10 +2,17 @@ error[E0308]: mismatched types
--> $DIR/issue-61106.rs:3:9
|
LL | foo(x.clone());
| ^^^^^^^^^
| |
| expected `&str`, found struct `String`
| help: consider borrowing here: `&x`
| --- ^^^^^^^^^
| | |
| | expected `&str`, found struct `String`
| | help: consider borrowing here: `&x`
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/issue-61106.rs:6:4
|
LL | fn foo(_: &str) {}
| ^^^ -------
error: aborting due to previous error

45
src/test/ui/issues/issue-69306.stderr
View file

@ -4,10 +4,17 @@ error[E0308]: mismatched types
LL | impl<T> S0<T> {
| - this type parameter
LL | const C: S0<u8> = Self(0);
| ^ expected type parameter `T`, found integer
| ---- ^ expected type parameter `T`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type parameter `T`
found type `{integer}`
note: tuple struct defined here
--> $DIR/issue-69306.rs:3:8
|
LL | struct S0<T>(T);
| ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:5:23
@ -27,10 +34,17 @@ LL | impl<T> S0<T> {
| - this type parameter
...
LL | Self(0);
| ^ expected type parameter `T`, found integer
| ---- ^ expected type parameter `T`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type parameter `T`
found type `{integer}`
note: tuple struct defined here
--> $DIR/issue-69306.rs:3:8
|
LL | struct S0<T>(T);
| ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:27:14
@ -39,10 +53,17 @@ LL | impl<T> Foo<T> for <S0<T> as Fun>::Out {
| - this type parameter
LL | fn foo() {
LL | Self(0);
| ^ expected type parameter `T`, found integer
| ---- ^ expected type parameter `T`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type parameter `T`
found type `{integer}`
note: tuple struct defined here
--> $DIR/issue-69306.rs:3:8
|
LL | struct S0<T>(T);
| ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:33:32
@ -50,10 +71,17 @@ error[E0308]: mismatched types
LL | impl<T> S1<T, u8> {
| - this type parameter
LL | const C: S1<u8, u8> = Self(0, 1);
| ^ expected type parameter `T`, found integer
| ---- ^ expected type parameter `T`, found integer
| |
| arguments to this function are incorrect
|
= note: expected type parameter `T`
found type `{integer}`
note: tuple struct defined here
--> $DIR/issue-69306.rs:31:8
|
LL | struct S1<T, U>(T, U);
| ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:33:27
@ -74,12 +102,19 @@ LL | impl<T> S2<T> {
LL | fn map<U>(x: U) -> S2<U> {
| - found type parameter
LL | Self(x)
| ^ expected type parameter `T`, found type parameter `U`
| ---- ^ expected type parameter `T`, found type parameter `U`
| |
| arguments to this function are incorrect
|
= note: expected type parameter `T`
found type parameter `U`
= note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
= note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
note: tuple struct defined here
--> $DIR/issue-69306.rs:38:8
|
LL | struct S2<T>(T);
| ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:41:9

12
src/test/ui/macros/issue-29084.stderr
View file

@ -2,11 +2,21 @@ error[E0308]: mismatched types
--> $DIR/issue-29084.rs:4:13
|
LL | bar(&mut $d);
| ^^^^^^^ expected `u8`, found `&mut u8`
| --- ^^^^^^^ expected `u8`, found `&mut u8`
| |
| arguments to this function are incorrect
...
LL | foo!(0u8);
| --------- in this macro invocation
|
note: function defined here
--> $DIR/issue-29084.rs:3:12
|
LL | fn bar(d: u8) { }
| ^^^ -----
...
LL | foo!(0u8);
| --------- in this macro invocation
= note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error

32
src/test/ui/methods/method-call-err-msg.stderr
View file

@ -2,43 +2,49 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/method-call-err-msg.rs:13:7
|
LL | x.zero(0)
| ^^^^ - supplied 1 argument
| |
| expected 0 arguments
| ^^^^ - argument unexpected
|
note: associated function defined here
--> $DIR/method-call-err-msg.rs:5:8
|
LL | fn zero(self) -> Foo { self }
| ^^^^ ----
help: remove the extra argument
|
LL | x.zero()
| ~~~~~~
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/method-call-err-msg.rs:14:7
|
LL | .one()
| ^^^- supplied 0 arguments
| |
| expected 1 argument
| ^^^-- an argument of type `isize` is missing
|
note: associated function defined here
--> $DIR/method-call-err-msg.rs:6:8
|
LL | fn one(self, _: isize) -> Foo { self }
| ^^^ ---- --------
help: provide the argument
|
LL | .one({isize})
| ~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/method-call-err-msg.rs:15:7
|
LL | .two(0);
| ^^^ - supplied 1 argument
| |
| expected 2 arguments
| ^^^--- an argument of type `isize` is missing
|
note: associated function defined here
--> $DIR/method-call-err-msg.rs:7:8
|
LL | fn two(self, _: isize, _: isize) -> Foo { self }
| ^^^ ---- -------- --------
help: provide the argument
|
LL | .two(0, {isize});
| ~~~~~~~~~~~~~~~
error[E0599]: `Foo` is not an iterator
--> $DIR/method-call-err-msg.rs:19:7
@ -74,15 +80,17 @@ error[E0061]: this function takes 3 arguments but 0 arguments were supplied
--> $DIR/method-call-err-msg.rs:21:7
|
LL | y.three::<usize>();
| ^^^^^--------- supplied 0 arguments
| |
| expected 3 arguments
| ^^^^^^^^^^^^^^-- three arguments of type `usize`, `usize`, and `usize` are missing
|
note: associated function defined here
--> $DIR/method-call-err-msg.rs:8:8
|
LL | fn three<T>(self, _: T, _: T, _: T) -> Foo { self }
| ^^^^^ ---- ---- ---- ----
help: provide the arguments
|
LL | y.three::<usize>({usize}, {usize}, {usize});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 5 previous errors

24
src/test/ui/methods/method-self-arg-1.stderr
View file

@ -2,19 +2,33 @@ error[E0308]: mismatched types
--> $DIR/method-self-arg-1.rs:11:14
|
LL | Foo::bar(x);
| ^
| |
| expected `&Foo`, found struct `Foo`
| help: consider borrowing here: `&x`
| -------- ^
| | |
| | expected `&Foo`, found struct `Foo`
| | help: consider borrowing here: `&x`
| arguments to this function are incorrect
|
note: associated function defined here
--> $DIR/method-self-arg-1.rs:6:8
|
LL | fn bar(&self) {}
| ^^^ -----
error[E0308]: mismatched types
--> $DIR/method-self-arg-1.rs:13:14
|
LL | Foo::bar(&42);
| ^^^ expected struct `Foo`, found integer
| -------- ^^^ expected struct `Foo`, found integer
| |
| arguments to this function are incorrect
|
= note: expected reference `&Foo`
found reference `&{integer}`
note: associated function defined here
--> $DIR/method-self-arg-1.rs:6:8
|
LL | fn bar(&self) {}
| ^^^ -----
error: aborting due to 2 previous errors

11
src/test/ui/mismatched_types/issue-26480.stderr
View file

@ -1,17 +1,20 @@
error[E0308]: mismatched types
--> $DIR/issue-26480.rs:16:19
|
LL | write(stdout, $arr.as_ptr() as *const i8,
| ----- arguments to this function are incorrect
LL | $arr.len() * size_of($arr[0]));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `u64`, found `usize`
...
LL | write!(hello);
| ------------- in this macro invocation
|
= note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
note: function defined here
--> $DIR/issue-26480.rs:2:8
|
LL | ($arr.len() * size_of($arr[0])).try_into().unwrap());
| + +++++++++++++++++++++
LL | fn write(fildes: i32, buf: *const i8, nbyte: u64) -> i64;
| ^^^^^
= note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0605]: non-primitive cast: `{integer}` as `()`
--> $DIR/issue-26480.rs:22:19

4
src/test/ui/mismatched_types/issue-35030.stderr
View file

@ -5,7 +5,9 @@ LL | impl<bool> Parser<bool> for bool {
| ---- this type parameter
LL | fn parse(text: &str) -> Option<bool> {
LL | Some(true)
| ^^^^ expected type parameter `bool`, found `bool`
| ---- ^^^^ expected type parameter `bool`, found `bool`
| |
| arguments to this enum variant are incorrect
|
= note: expected type parameter `bool` (type parameter `bool`)
found type `bool` (`bool`)

27
src/test/ui/mismatched_types/numeric-literal-cast.stderr
View file

@ -2,8 +2,15 @@ error[E0308]: mismatched types
--> $DIR/numeric-literal-cast.rs:6:9
|
LL | foo(1u8);
| ^^^ expected `u16`, found `u8`
| --- ^^^ expected `u16`, found `u8`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-literal-cast.rs:1:4
|
LL | fn foo(_: u16) {}
| ^^^ ------
help: change the type of the numeric literal from `u8` to `u16`
|
LL | foo(1u16);
@ -13,8 +20,15 @@ error[E0308]: mismatched types
--> $DIR/numeric-literal-cast.rs:8:10
|
LL | foo1(2f32);
| ^^^^ expected `f64`, found `f32`
| ---- ^^^^ expected `f64`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-literal-cast.rs:2:4
|
LL | fn foo1(_: f64) {}
| ^^^^ ------
help: change the type of the numeric literal from `f32` to `f64`
|
LL | foo1(2f64);
@ -24,8 +38,15 @@ error[E0308]: mismatched types
--> $DIR/numeric-literal-cast.rs:10:10
|
LL | foo2(3i16);
| ^^^^ expected `i32`, found `i16`
| ---- ^^^^ expected `i32`, found `i16`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-literal-cast.rs:3:4
|
LL | fn foo2(_: i32) {}
| ^^^^ ------
help: change the type of the numeric literal from `i16` to `i32`
|
LL | foo2(3i32);

1
src/test/ui/mismatched_types/overloaded-calls-bad.rs
View file

@ -30,5 +30,4 @@ fn main() {
//~^ ERROR this function takes 1 argument but 0 arguments were supplied
let ans = s("burma", "shave");
//~^ ERROR this function takes 1 argument but 2 arguments were supplied
//~| ERROR mismatched types
}

34
src/test/ui/mismatched_types/overloaded-calls-bad.stderr
View file

@ -2,43 +2,51 @@ error[E0308]: mismatched types
--> $DIR/overloaded-calls-bad.rs:28:17
|
LL | let ans = s("what");
| ^^^^^^ expected `isize`, found `&str`
| - ^^^^^^ expected `isize`, found `&str`
| |
| arguments to this function are incorrect
|
note: associated function defined here
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
|
LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
| ^^^^^^^^
error[E0057]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/overloaded-calls-bad.rs:29:15
|
LL | let ans = s();
| ^-- supplied 0 arguments
| |
| expected 1 argument
| ^-- an argument of type `isize` is missing
|
note: associated function defined here
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
|
LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
| ^^^^^^^^
error[E0308]: mismatched types
--> $DIR/overloaded-calls-bad.rs:31:17
help: provide the argument
|
LL | let ans = s("burma", "shave");
| ^^^^^^^ expected `isize`, found `&str`
LL | let ans = s({isize});
| ~~~~~~~~~~
error[E0057]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/overloaded-calls-bad.rs:31:15
|
LL | let ans = s("burma", "shave");
| ^ ------- ------- supplied 2 arguments
| |
| expected 1 argument
| ^ ------- ------- argument unexpected
| |
| expected `isize`, found `&str`
|
note: associated function defined here
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
|
LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
| ^^^^^^^^
help: remove the extra argument
|
LL | let ans = s({isize});
| ~~~~~~~~~~
error: aborting due to 4 previous errors
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0057, E0308.
For more information about an error, try `rustc --explain E0057`.

Some files were not shown because too many files have changed in this diff Show more