languages/rust
languages/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust synced 2024-09-18 16:02:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implementation for 65853

Browse source 
This attempts to bring better error messages to invalid method calls, by applying some heuristics to identify common mistakes.

The algorithm is inspired by Levenshtein distance and longest common sub-sequence.   In essence, we treat the types of the function, and the types of the arguments you provided as two "words" and compute the edits to get from one to the other.

We then modify that algorithm to detect 4 cases:

 - A function input is missing
 - An extra argument was provided
 - The type of an argument is straight up invalid
 - Two arguments have been swapped
 - A subset of the arguments have been shuffled

(We detect the last two as separate cases so that we can detect two swaps, instead of 4 parameters permuted.)

It helps to understand this argument by paying special attention to terminology: "inputs" refers to the inputs being *expected* by the function, and "arguments" refers to what has been provided at the call site.

The basic sketch of the algorithm is as follows:

 - Construct a boolean grid, with a row for each argument, and a column for each input.  The cell [i, j] is true if the i'th argument could satisfy the j'th input.
 - If we find an argument that could satisfy no inputs, provided for an input that can't be satisfied by any other argument, we consider this an "invalid type".
 - Extra arguments are those that can't satisfy any input, provided for an input that *could* be satisfied by another argument.
 - Missing inputs are inputs that can't be satisfied by any argument, where the provided argument could satisfy another input
 - Swapped / Permuted arguments are identified with a cycle detection algorithm.

As each issue is found, we remove the relevant inputs / arguments and check for more issues.  If we find no issues, we match up any "valid" arguments, and start again.

Note that there's a lot of extra complexity:
 - We try to stay efficient on the happy path, only computing the diagonal until we find a problem, and then filling in the rest of the matrix.
 - Closure arguments are wrapped in a tuple and need to be unwrapped
 - We need to resolve closure types after the rest, to allow the most specific type constraints
 - We need to handle imported C functions that might be variadic in their inputs.

I tried to document a lot of this in comments in the code and keep the naming clear.
This commit is contained in:
Jack Huey 2022-01-21 23:50:54 -05:00
parent e7575f9670
commit b6c87c555f
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 @@ pub fn note_type_err(
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 @@ enum Mismatch<'a> {
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 @@ pub fn report_and_explain_type_error(
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 @@ fn report_inference_failure(
}
}
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 @@ pub fn ty(&self) -> Option<(Ty<'tcx>, Ty<'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 @@ fn report_projection_error(
}),
_ => 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

@ -1502,7 +1502,7 @@ pub fn coerce_forced_unit<'a>(
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());
@ -1074,6 +1075,7 @@ fn compare_const_param_types<'tcx>(
})),
&terr,
false,
false,
);
diag.emit();
}

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

@ -28,7 +28,7 @@ pub fn emit_coerce_suggestions(
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 @@ pub fn demand_coerce_diag(
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 @@ fn annotate_expected_due_to_let_ty(
&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 @@ fn annotate_expected_due_to_let_ty(
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 @@ pub(super) fn check_expr_with_expectation_and_args(
}
#[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>,
@ -1367,11 +1367,13 @@ fn check_expr_struct_fields(
) {
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 @@ pub(in super::super) fn expected_inputs_for_expected_output(
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 @@ pub(in super::super) fn expected_inputs_for_expected_output(
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 @@ pub(in super::super) fn expected_inputs_for_expected_output(
// 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 @@
#![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 @@
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