Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-04-27 18:57:42 +03:00
Code Issues Packages Projects Releases Wiki Activity

Remove arg_matrix.rs, bless tests

Browse Source
This commit is contained in:
Michael Goulet
2022-06-03 10:22:04 -07:00
parent b0793b33da
commit 2f1bf166b5
161 changed files with 1540 additions and 6797 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/rustc_typeck/src/check/fn_ctxt/arg_matrix.rs
-351
View File
@@ -1,351 +0,0 @@
use std::cmp;
use rustc_middle::ty::error::TypeError;
// An issue that might be found in the compatibility matrix
#[derive(Debug)]
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
#[derive(Debug)]
pub(crate) enum Error<'tcx> {
/// The provided argument is the invalid type for the expected input
Invalid(usize, usize, Compatibility<'tcx>), // provided, expected
/// 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> {
/// Maps the indices in the `compatibility_matrix` rows to the indices of
/// the *user provided* inputs
input_indexes: Vec<usize>,
/// Maps the indices in the `compatibility_matrix` columns to the indices
/// of the *expected* args
arg_indexes: Vec<usize>,
/// The first dimension (rows) are the remaining user provided inputs to
/// match and the second dimension (cols) are the remaining expected args
/// to match
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..provided_arg_count).collect(),
arg_indexes: (0..minimum_input_count).collect(),
compatibility_matrix,
}
}
/// Remove a given input from consideration
fn eliminate_input(&mut self, idx: usize) {
self.input_indexes.remove(idx);
self.compatibility_matrix.remove(idx);
}
/// Remove a given argument from consideration
fn eliminate_arg(&mut self, idx: usize) {
self.arg_indexes.remove(idx);
for row in &mut self.compatibility_matrix {
row.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);
}
// Returns a `Vec` of (user input, expected arg) of matched arguments. These
// are inputs on the remaining diagonal that match.
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.input_indexes[idx], self.arg_indexes[idx]));
self.satisfy_input(idx, idx);
}
i -= 1;
}
return eliminated;
}
// Find some issue in the compatibility matrix
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 unsatisfiable
if matches!(mat[j][i], Compatibility::Compatible) {
unsatisfiable = 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 useless
if matches!(mat[i][j], Compatibility::Compatible) {
useless = false;
break;
}
}
}
match (is_input, is_arg, useless, unsatisfiable) {
// If an argument is unsatisfied, and the input 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.input_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.arg_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 (inp, arg) in self.eliminate_satisfied() {
matched_inputs[arg] = Some(inp);
}
while self.input_indexes.len() > 0 || self.arg_indexes.len() > 0 {
match self.find_issue() {
Some(Issue::Invalid(idx)) => {
let compatibility = self.compatibility_matrix[idx][idx].clone();
let input_idx = self.input_indexes[idx];
let arg_idx = self.arg_indexes[idx];
self.satisfy_input(idx, idx);
errors.push(Error::Invalid(input_idx, arg_idx, compatibility));
}
Some(Issue::Extra(idx)) => {
let input_idx = self.input_indexes[idx];
self.eliminate_input(idx);
errors.push(Error::Extra(input_idx));
}
Some(Issue::Missing(idx)) => {
let arg_idx = self.arg_indexes[idx];
self.eliminate_arg(idx);
errors.push(Error::Missing(arg_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[other_arg_idx] = Some(input_idx);
matched_inputs[arg_idx] = Some(other_input_idx);
}
Some(Issue::Permutation(args)) => {
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_input_idx = self.input_indexes[src];
let dst_input_idx = self.input_indexes[dst];
let dest_arg_idx = self.arg_indexes[dst];
real_idxs[src_input_idx] = Some((dest_arg_idx, dst_input_idx));
matched_inputs[dest_arg_idx] = Some(src_input_idx);
}
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 (inp, arg) in self.eliminate_satisfied() {
matched_inputs[arg] = Some(inp);
}
}
};
}
return (errors, matched_inputs);
}
}
compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
+1 -6
View File
@@ -1,6 +1,5 @@
use crate::astconv::AstConv;
use crate::check::coercion::CoerceMany;
use crate::check::fn_ctxt::arg_matrix::{ArgMatrix, Compatibility, Error};
use crate::check::gather_locals::Declaration;
use crate::check::method::MethodCallee;
use crate::check::Expectation::*;
@@ -18,13 +17,9 @@
use rustc_hir::def::{CtorOf, DefKind, Res};
use rustc_hir::def_id::DefId;
use rustc_hir::{ExprKind, Node, QPath};
use rustc_infer::infer::error_reporting::{FailureCode, ObligationCauseExt};
use rustc_infer::infer::InferOk;
use rustc_infer::infer::TypeTrace;
use rustc_middle::ty::adjustment::AllowTwoPhase;
use rustc_middle::ty::error::TypeError;
use rustc_middle::ty::fold::TypeFoldable;
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_middle::ty::{self, Ty};
use rustc_session::Session;
use rustc_span::symbol::Ident;
use rustc_span::{self, Span};
compiler/rustc_typeck/src/check/fn_ctxt/mod.rs
-1
View File
@@ -1,5 +1,4 @@
mod _impl;
mod arg_matrix;
mod checks;
mod suggestions;
src/test/ui/argument-suggestions/basic.rs
+5 -2
View File
@@ -20,8 +20,11 @@ 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
swapped("", 1); //~ ERROR mismatched types
//~^ ERROR mismatched types
permuted(Y {}, Z {}, X {}); //~ ERROR mismatched types
//~^ ERROR mismatched types
//~| ERROR mismatched types
let closure = |x| x;
closure(); //~ ERROR this function takes
src/test/ui/argument-suggestions/basic.stderr
+34 -61
View File
@@ -2,102 +2,75 @@ 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) {}
| ^^^^^^^ -------
| ^^^ expected `u32`, found floating-point number
error[E0061]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/basic.rs:21:5
|
LL | extra("");
| ^^^^^ -- argument unexpected
| ^^^^^ -- supplied 1 argument
| |
| expected 0 arguments
|
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
| ^^^^^^^-- supplied 0 arguments
| |
| expected 1 argument
|
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
error[E0308]: mismatched types
--> $DIR/basic.rs:23:13
|
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, "");
| ~~~~~~~~~~~~~~
| ^^ expected `u32`, found `&str`
error[E0308]: arguments to this function are incorrect
--> $DIR/basic.rs:24:5
error[E0308]: mismatched types
--> $DIR/basic.rs:23:17
|
LL | swapped("", 1);
| ^ expected `&str`, found integer
error[E0308]: mismatched types
--> $DIR/basic.rs:25:14
|
LL | permuted(Y {}, Z {}, X {});
| ^^^^^^^^ ---- ---- ---- expected `Z`,found `X`
| | |
| | expected `Y`,found `Z`
| expected `X`,found `Y`
| ^^^^ expected struct `X`, found struct `Y`
error[E0308]: mismatched types
--> $DIR/basic.rs:25:20
|
note: function defined here
--> $DIR/basic.rs:17:4
LL | permuted(Y {}, Z {}, X {});
| ^^^^ expected struct `Y`, found struct `Z`
error[E0308]: mismatched types
--> $DIR/basic.rs:25:26
|
LL | fn permuted(_x: X, _y: Y, _z: Z) {}
| ^^^^^^^^ ----- ----- -----
help: reorder these arguments
|
LL | permuted(X {}, Y {}, Z {});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
LL | permuted(Y {}, Z {}, X {});
| ^^^^ expected struct `Z`, found struct `X`
error[E0057]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/basic.rs:27:5
--> $DIR/basic.rs:30:5
|
LL | closure();
| ^^^^^^^-- an argument is missing
|
note: closure defined here
--> $DIR/basic.rs:26:19
|
LL | let closure = |x| x;
| ^^^
help: provide the argument
|
LL | closure({_});
| ~~~~~~~~~~~~
| ^^^^^^^-- supplied 0 arguments
| |
| expected 1 argument
error: aborting due to 6 previous errors
error: aborting due to 9 previous errors
Some errors have detailed explanations: E0057, E0061, E0308.
For more information about an error, try `rustc --explain E0057`.
src/test/ui/argument-suggestions/complex.rs
+8 -1
View File
@@ -12,5 +12,12 @@ 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
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
}
src/test/ui/argument-suggestions/complex.stderr
+46 -14
View File
@@ -1,19 +1,51 @@
error[E0308]: arguments to this function are incorrect
--> $DIR/complex.rs:14:3
error[E0308]: mismatched types
--> $DIR/complex.rs:14:11
|
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 {});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| ^^^ expected `u32`, found floating-point number
error: aborting due to previous error
error[E0308]: mismatched types
--> $DIR/complex.rs:14:16
|
LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
| ^^^^ expected `&str`, found struct `H`
error[E0308]: mismatched types
--> $DIR/complex.rs:14:22
|
LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
| ^^^ expected enum `E`, found `&&'static str`
error[E0308]: mismatched types
--> $DIR/complex.rs:14:27
|
LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
| ^^^ expected enum `F`, found struct `G`
error[E0308]: mismatched types
--> $DIR/complex.rs:14:32
|
LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
| ^^^^^ expected struct `G`, found enum `F`
error[E0308]: mismatched types
--> $DIR/complex.rs:14:39
|
LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
| ^^^^ expected struct `X`, found struct `Z`
error[E0308]: mismatched types
--> $DIR/complex.rs:14:45
|
LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
| ^^^^ expected struct `Y`, found struct `X`
error[E0308]: mismatched types
--> $DIR/complex.rs:14:51
|
LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
| ^^^^ expected struct `Z`, found struct `Y`
error: aborting due to 8 previous errors
For more information about this error, try `rustc --explain E0308`.
src/test/ui/argument-suggestions/extra_arguments.stderr
+47 -79
View File
@@ -2,237 +2,205 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/extra_arguments.rs:7:3
|
LL | empty("");
| ^^^^^ -- argument unexpected
| ^^^^^ -- supplied 1 argument
| |
| expected 0 arguments
|
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
| ^^^^^^^ - - supplied 2 arguments
| |
| expected 1 argument
|
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
| ^^^^^^^ - -- supplied 2 arguments
| |
| expected 1 argument
|
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
| ^^^^^^^ - -- --- supplied 3 arguments
| |
| expected 1 argument
|
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
| ^^^^^^^^^^^^ - - - supplied 3 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^^^ - - --- supplied 3 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^^^ - - -- supplied 3 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^^^ - -- -- supplied 3 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^^^ - - -- -- supplied 4 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^^^ - -- - -- supplied 4 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^^^ - - -- supplied 3 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^^^ - - -- supplied 3 arguments
| |
| expected 2 arguments
|
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(
| ^^^^^^^^^^^^
...
| ^^^^^^^^^^^^ expected 2 arguments
LL | 1,
| -
LL | 1,
| -
LL | ""
| -- argument unexpected
| -- supplied 3 arguments
|
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(
| ^^^^^^^^^^^^
| ^^^^^^^^^^^^ expected 2 arguments
LL | 1,
| -
LL | 1,
| - argument of type `&str` unexpected
| -
LL | ""
| -- supplied 3 arguments
|
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
src/test/ui/argument-suggestions/invalid_arguments.rs
+32 -11
View File
@@ -15,29 +15,50 @@ fn main() {
// 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_same("", "");
//~^ ERROR mismatched types
//~| ERROR mismatched types
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
two_arg_diff("", "");
//~^ ERROR mismatched types
//~| ERROR mismatched types
// 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 {}, "");
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_arg_diff(X {}, 1.0, X {});
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_arg_diff(1, X {}, X {});
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_arg_diff(X {}, X {}, X {}); //~ ERROR arguments to this function are incorrect
three_arg_diff(X {}, X {}, X {});
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
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 {}, "");
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_arg_repeat(X {}, 1, X {});
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_arg_repeat(1, X {}, X{});
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_arg_repeat(X {}, X {}, X {}); //~ ERROR arguments to this function are incorrect
three_arg_repeat(X {}, X {}, X {});
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
}
src/test/ui/argument-suggestions/invalid_arguments.stderr
+122 -220
View File
@@ -2,298 +2,200 @@ 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) {}
| ^^^^^^^ -------
| ^^^ expected `i32`, found floating-point number
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) {}
| ^^^^^^^^^^^^ ------- -------
| ^^ expected `i32`, found `&str`
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) {}
| ^^^^^^^^^^^^ ------- -------
| ^^ expected `i32`, found `&str`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:18:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:18:16
|
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) {}
| ^^^^^^^^^^^^ ------- -------
| ^^ expected `i32`, found `&str`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:19:19
--> $DIR/invalid_arguments.rs:18:20
|
LL | two_arg_same("", "");
| ^^ expected `i32`, found `&str`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:21: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) {}
| ^^^^^^^^^^^^ ------- -------
| ^^ expected `f32`, found `&str`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:20:16
--> $DIR/invalid_arguments.rs:22: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) {}
| ^^^^^^^^^^^^ ------- -------
| ^^ expected `i32`, found `&str`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:21:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:23:16
|
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) {}
| ^^^^^^^^^^^^ ------- -------
| ^^ expected `i32`, found `&str`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:24:18
--> $DIR/invalid_arguments.rs:23:20
|
LL | two_arg_diff("", "");
| ^^ expected `f32`, found `&str`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:27: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) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
| ^^^ expected `i32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:25:21
--> $DIR/invalid_arguments.rs:28: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) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `f32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:26:26
--> $DIR/invalid_arguments.rs:29: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) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `&str`, found struct `X`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:28:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:31:18
|
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) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:29:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:31:24
|
LL | three_arg_diff(X {}, X {}, "");
| ^^^^ expected `f32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:34:18
|
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) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:30:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:34:29
|
LL | three_arg_diff(X {}, 1.0, X {});
| ^^^^ expected `&str`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:37:21
|
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) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `f32`, found struct `X`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:32:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:37:27
|
LL | three_arg_diff(1, X {}, X {});
| ^^^^ expected `&str`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:41:18
|
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) {}
| ^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:34:20
--> $DIR/invalid_arguments.rs:41:24
|
LL | three_arg_diff(X {}, X {}, X {});
| ^^^^ expected `f32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:41:30
|
LL | three_arg_diff(X {}, X {}, X {});
| ^^^^ expected `&str`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:46: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) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:35:23
--> $DIR/invalid_arguments.rs:47: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) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:36:26
--> $DIR/invalid_arguments.rs:48: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) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `&str`, found struct `X`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:38:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:50:20
|
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) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:39:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:50:26
|
LL | three_arg_repeat(X {}, X {}, "");
| ^^^^ expected `i32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:53:20
|
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) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:40:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:53:29
|
LL | three_arg_repeat(X {}, 1, X {});
| ^^^^ expected `&str`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:56:23
|
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) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error[E0308]: arguments to this function are incorrect
--> $DIR/invalid_arguments.rs:42:3
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:56:29
|
LL | three_arg_repeat(1, X {}, X{});
| ^^^ expected `&str`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:60:20
|
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) {}
| ^^^^^^^^^^^^^^^^ ------- ------- --------
| ^^^^ expected `i32`, found struct `X`
error: aborting due to 21 previous errors
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:60:26
|
LL | three_arg_repeat(X {}, X {}, X {});
| ^^^^ expected `i32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/invalid_arguments.rs:60:32
|
LL | three_arg_repeat(X {}, X {}, X {});
| ^^^^ expected `&str`, found struct `X`
error: aborting due to 33 previous errors
For more information about this error, try `rustc --explain E0308`.
src/test/ui/argument-suggestions/issue-96638.stderr
+3 -5
View File
@@ -2,17 +2,15 @@ error[E0061]: this function takes 3 arguments but 2 arguments were supplied
--> $DIR/issue-96638.rs:8:5
|
LL | f(&x, "");
| ^ -- an argument of type `usize` is missing
| ^ -- -- supplied 2 arguments
| |
| expected 3 arguments
|
note: function defined here
--> $DIR/issue-96638.rs:1:4
|
LL | fn f(_: usize, _: &usize, _: usize) {}
| ^ -------- --------- --------
help: provide the argument
|
LL | f({usize}, &x, {usize});
| ~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
src/test/ui/argument-suggestions/issue-97197.stderr
+3 -5
View File
@@ -2,17 +2,15 @@ error[E0061]: this function takes 6 arguments but 2 arguments were supplied
--> $DIR/issue-97197.rs:2:5
|
LL | g((), ());
| ^-------- multiple arguments are missing
| ^ -- -- supplied 2 arguments
| |
| expected 6 arguments
|
note: function defined here
--> $DIR/issue-97197.rs:6:8
|
LL | pub fn g(a1: (), a2: bool, a3: bool, a4: bool, a5: bool, a6: ()) -> () {}
| ^ ------ -------- -------- -------- -------- ------
help: provide the arguments
|
LL | g((), {bool}, {bool}, {bool}, {bool}, ());
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
src/test/ui/argument-suggestions/missing_arguments.stderr
+57 -98
View File
@@ -2,308 +2,267 @@ 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
| ^^^^^^^-- supplied 0 arguments
| |
| expected 1 argument
|
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
| ^^^^^^^^----------------- supplied 0 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^ - supplied 1 argument
| |
| expected 2 arguments
|
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
| ^^^^^^^^----------------- supplied 0 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^ - supplied 1 argument
| |
| expected 2 arguments
|
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
| ^^^^^^^^ --- supplied 1 argument
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^------------------------- supplied 0 arguments
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ - supplied 1 argument
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ - - supplied 2 arguments
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ --- -- supplied 2 arguments
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ - -- supplied 2 arguments
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ - --- supplied 2 arguments
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ -- supplied 1 argument
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ --- supplied 1 argument
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ - supplied 1 argument
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^^^^--------------------------------- supplied 0 arguments
| |
| expected 4 arguments
|
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
| ^^^^^^^^^^^^^ - -- supplied 2 arguments
| |
| expected 4 arguments
|
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
| ^^^^^^^--------------------------------- supplied 0 arguments
| |
| expected 5 arguments
|
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 `f32` are missing
| ^^^^^^^ - -- supplied 2 arguments
| |
| expected 5 arguments
|
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
src/test/ui/argument-suggestions/mixed_cases.rs
+7 -2
View File
@@ -14,10 +14,15 @@ fn main() {
three_args(1, X {}); //~ ERROR this function takes
// Missing and Extra
three_args(1, "", X {}); //~ ERROR arguments to this function are incorrect
three_args(1, "", X {});
//~^ ERROR mismatched types
//~| ERROR mismatched types
// Swapped and Invalid
three_args("", X {}, 1); //~ ERROR arguments to this function are incorrect
three_args("", X {}, 1);
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
// Swapped and missing
three_args("", 1); //~ ERROR this function takes
src/test/ui/argument-suggestions/mixed_cases.stderr
+36 -63
View File
@@ -2,116 +2,89 @@ 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`
| ^^^^^^^^ - -- ---- supplied 3 arguments
| |
| expected 2 arguments
|
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
| ^^^^^^^^^^ - -- ---- -- supplied 4 arguments
| |
| expected 3 arguments
|
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
| ^^^^^^^^^^ - ---- supplied 2 arguments
| |
| expected 3 arguments
|
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
error[E0308]: mismatched types
--> $DIR/mixed_cases.rs:17:17
|
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}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~
| ^^ expected `f32`, found `&str`
error[E0308]: arguments to this function are incorrect
--> $DIR/mixed_cases.rs:20:3
error[E0308]: mismatched types
--> $DIR/mixed_cases.rs:17:21
|
LL | three_args(1, "", X {});
| ^^^^ expected `&str`, found struct `X`
error[E0308]: mismatched types
--> $DIR/mixed_cases.rs:22:14
|
LL | three_args("", X {}, 1);
| ^^^^^^^^^^ -- ---- - expected `&str`,found `{integer}`
| | |
| | expected `f32`, found struct `X`
| expected `i32`,found `&'static str`
| ^^ expected `i32`, found `&str`
error[E0308]: mismatched types
--> $DIR/mixed_cases.rs:22:18
|
note: function defined here
--> $DIR/mixed_cases.rs:6:4
LL | three_args("", X {}, 1);
| ^^^^ expected `f32`, found struct `X`
error[E0308]: mismatched types
--> $DIR/mixed_cases.rs:22:24
|
LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
| ^^^^^^^^^^ ------- ------- --------
help: swap these arguments
|
LL | three_args(1, {f32}, "");
| ~~~~~~~~~~~~~~~~~~~~~~~~
LL | three_args("", X {}, 1);
| ^ expected `&str`, found integer
error[E0061]: this function takes 3 arguments but 2 arguments were supplied
--> $DIR/mixed_cases.rs:23:3
--> $DIR/mixed_cases.rs:28:3
|
LL | three_args("", 1);
| ^^^^^^^^^^ -- -
| | |
| | an argument of type `f32` is missing
| | expected `&str`,found `{integer}`
| expected `i32`,found `&'static str`
| ^^^^^^^^^^ -- - supplied 2 arguments
| |
| expected 3 arguments
|
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
error: aborting due to 9 previous errors
Some errors have detailed explanations: E0061, E0308.
For more information about an error, try `rustc --explain E0061`.
src/test/ui/argument-suggestions/permuted_arguments.rs
+10 -2
View File
@@ -7,7 +7,15 @@ 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
three_args(1.0, "", 1);
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
// d, e, b, a, c
many_args(X {}, Y {}, 1, 1.0, ""); //~ ERROR arguments to this function are incorrect
many_args(X {}, Y {}, 1, 1.0, "");
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
}
src/test/ui/argument-suggestions/permuted_arguments.stderr
+43 -35
View File
@@ -1,43 +1,51 @@
error[E0308]: arguments to this function are incorrect
--> $DIR/permuted_arguments.rs:10:3
error[E0308]: mismatched types
--> $DIR/permuted_arguments.rs:10:14
|
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, "");
| ~~~~~~~~~~~~~~~~~~~~~~
| ^^^ expected `i32`, found floating-point number
error[E0308]: arguments to this function are incorrect
--> $DIR/permuted_arguments.rs:12:3
error[E0308]: mismatched types
--> $DIR/permuted_arguments.rs:10:19
|
LL | three_args(1.0, "", 1);
| ^^ expected `f32`, found `&str`
error[E0308]: mismatched types
--> $DIR/permuted_arguments.rs:10:23
|
LL | three_args(1.0, "", 1);
| ^ expected `&str`, found integer
error[E0308]: mismatched types
--> $DIR/permuted_arguments.rs:15:13
|
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 {});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| ^^^^ expected `i32`, found struct `X`
error: aborting due to 2 previous errors
error[E0308]: mismatched types
--> $DIR/permuted_arguments.rs:15:19
|
LL | many_args(X {}, Y {}, 1, 1.0, "");
| ^^^^ expected `f32`, found struct `Y`
error[E0308]: mismatched types
--> $DIR/permuted_arguments.rs:15:25
|
LL | many_args(X {}, Y {}, 1, 1.0, "");
| ^ expected `&str`, found integer
error[E0308]: mismatched types
--> $DIR/permuted_arguments.rs:15:28
|
LL | many_args(X {}, Y {}, 1, 1.0, "");
| ^^^ expected struct `X`, found floating-point number
error[E0308]: mismatched types
--> $DIR/permuted_arguments.rs:15:33
|
LL | many_args(X {}, Y {}, 1, 1.0, "");
| ^^ expected struct `Y`, found `&str`
error: aborting due to 8 previous errors
For more information about this error, try `rustc --explain E0308`.
src/test/ui/argument-suggestions/swapped_arguments.rs
+17 -6
View File
@@ -5,10 +5,21 @@ 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
two_args(1.0, 1);
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_args(1.0, 1, "");
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_args( 1, "", 1.0);
//~^ ERROR mismatched types
//~| ERROR mismatched types
three_args( "", 1.0, 1);
//~^ ERROR mismatched types
//~| ERROR mismatched types
four_args(1.0, 1, X {}, "");
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
//~| ERROR mismatched types
}
src/test/ui/argument-suggestions/swapped_arguments.stderr
+67 -78
View File
@@ -1,95 +1,84 @@
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:8:3
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:8:12
|
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);
| ~~~~~~~~~~~~~~~~
| ^^^ expected `i32`, found floating-point number
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:9:3
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:8:17
|
LL | two_args(1.0, 1);
| ^
| |
| expected `f32`, found integer
| help: use a float literal: `1.0`
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:11:14
|
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, "");
| ~~~~~~~~~~~~~~~~~~~~~~
| ^^^ expected `i32`, found floating-point number
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:10:3
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:11:21
|
LL | three_args(1.0, 1, "");
| ^
| |
| expected `f32`, found integer
| help: use a float literal: `1.0`
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:14:20
|
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, "");
| ~~~~~~~~~~~~~~~~~~~~~~
| ^^ expected `f32`, found `&str`
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:11:3
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:14:24
|
LL | three_args( 1, "", 1.0);
| ^^^ expected `&str`, found floating-point number
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:17:15
|
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, "");
| ~~~~~~~~~~~~~~~~~~~~~~
| ^^ expected `i32`, found `&str`
error[E0308]: arguments to this function are incorrect
--> $DIR/swapped_arguments.rs:13:3
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:17:26
|
LL | three_args( "", 1.0, 1);
| ^ expected `&str`, found integer
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:20:13
|
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 {});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~
| ^^^ expected `i32`, found floating-point number
error: aborting due to 5 previous errors
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:20:18
|
LL | four_args(1.0, 1, X {}, "");
| ^
| |
| expected `f32`, found integer
| help: use a float literal: `1.0`
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:20:21
|
LL | four_args(1.0, 1, X {}, "");
| ^^^^ expected `&str`, found struct `X`
error[E0308]: mismatched types
--> $DIR/swapped_arguments.rs:20:27
|
LL | four_args(1.0, 1, X {}, "");
| ^^ expected struct `X`, found `&str`
error: aborting due to 12 previous errors
For more information about this error, try `rustc --explain E0308`.
src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr
+4 -36
View File
@@ -2,57 +2,25 @@ 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`
| |
| 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) }
| ^^^^ ---- ---------------
| ^^^^ expected struct `Black`, found struct `Blue`
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`
| |
| 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) }
| ^^^^ ---- ---------------
| ^^^^^ expected struct `Blue`, found struct `Black`
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`
| |
| 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) { }
| ^^^^^^^^^^ ----- --------------
| ^^^^ expected struct `Black`, found struct `Blue`
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`
| |
| 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) { }
| ^^^^^^^^^^ ----- --------------
| ^^^^^ expected struct `Blue`, found struct `Black`
error: aborting due to 4 previous errors
src/test/ui/associated-types/associated-types-path-2.stderr
+1 -8
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/associated-types-path-2.rs:19:14
|
LL | f1(2i32, 4i32);
| -- ^^^^ expected `u32`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^ expected `u32`, found `i32`
|
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);
src/test/ui/async-await/dont-suggest-missing-await.stderr
+1 -8
View File
@@ -2,9 +2,7 @@ error[E0308]: mismatched types
--> $DIR/dont-suggest-missing-await.rs:14:18
|
LL | take_u32(x)
| -------- ^ expected `u32`, found opaque type
| |
| arguments to this function are incorrect
| ^ expected `u32`, found opaque type
|
note: while checking the return type of the `async fn`
--> $DIR/dont-suggest-missing-await.rs:7:24
@@ -13,11 +11,6 @@ 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)
src/test/ui/async-await/generator-desc.stderr
+6 -26
View File
@@ -2,27 +2,18 @@ error[E0308]: mismatched types
--> $DIR/generator-desc.rs:10:25
|
LL | fun(async {}, async {});
| -- ^^
| | |
| | expected `async` block, found a different `async` block
| | arguments to this function are incorrect
| -- ^^ expected `async` block, found a different `async` block
| |
| 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
| |
| arguments to this function are incorrect
| ^^^^^ expected opaque type, found a different opaque type
|
note: while checking the return type of the `async fn`
--> $DIR/generator-desc.rs:5:16
@@ -38,20 +29,14 @@ LL | async fn two() {}
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
| arguments to this function are incorrect
| -- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body
| |
| the expected `async` closure body
|
::: $SRC_DIR/core/src/future/mod.rs:LL:COL
|
@@ -63,11 +48,6 @@ LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
|
= note: expected opaque 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) {}
| ^^^ ----- -----
error: aborting due to 3 previous errors
src/test/ui/async-await/suggest-missing-await-closure.stderr
+1 -8
View File
@@ -2,9 +2,7 @@ error[E0308]: mismatched types
--> $DIR/suggest-missing-await-closure.rs:16:18
|
LL | take_u32(x)
| -------- ^ expected `u32`, found opaque type
| |
| arguments to this function are incorrect
| ^ expected `u32`, found opaque type
|
note: while checking the return type of the `async fn`
--> $DIR/suggest-missing-await-closure.rs:8:24
@@ -13,11 +11,6 @@ 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)
src/test/ui/async-await/suggest-missing-await.stderr
+1 -8
View File
@@ -2,9 +2,7 @@ error[E0308]: mismatched types
--> $DIR/suggest-missing-await.rs:12:14
|
LL | take_u32(x)
| -------- ^ expected `u32`, found opaque type
| |
| arguments to this function are incorrect
| ^ expected `u32`, found opaque type
|
note: while checking the return type of the `async fn`
--> $DIR/suggest-missing-await.rs:5:24
@@ -13,11 +11,6 @@ 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)
src/test/ui/c-variadic/variadic-ffi-1.stderr
+6 -10
View File
@@ -8,33 +8,29 @@ error[E0060]: this function takes at least 2 arguments but 0 arguments were supp
--> $DIR/variadic-ffi-1.rs:20:9
|
LL | foo();
| ^^^-- two arguments of type `isize` and `u8` are missing
| ^^^-- supplied 0 arguments
| |
| expected at least 2 arguments
|
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);
| ^^^--- an argument of type `u8` is missing
| ^^^ - supplied 1 argument
| |
| expected at least 2 arguments
|
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
src/test/ui/cast/cast-int-to-char.stderr
+5 -41
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:4:16
|
LL | foo::<u32>('0');
| ---------- ^^^ expected `u32`, found `char`
| |
| arguments to this function are incorrect
| ^^^ expected `u32`, found `char`
|
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);
@@ -20,15 +13,8 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:5:16
|
LL | foo::<i32>('0');
| ---------- ^^^ expected `i32`, found `char`
| |
| arguments to this function are incorrect
| ^^^ expected `i32`, found `char`
|
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);
@@ -38,15 +24,8 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:6:16
|
LL | foo::<u64>('0');
| ---------- ^^^ expected `u64`, found `char`
| |
| arguments to this function are incorrect
| ^^^ expected `u64`, found `char`
|
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);
@@ -56,15 +35,8 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:7:16
|
LL | foo::<i64>('0');
| ---------- ^^^ expected `i64`, found `char`
| |
| arguments to this function are incorrect
| ^^^ expected `i64`, found `char`
|
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);
@@ -74,15 +46,7 @@ error[E0308]: mismatched types
--> $DIR/cast-int-to-char.rs:8:17
|
LL | foo::<char>(0u32);
| ----------- ^^^^ 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) {}
| ^^^ -----
| ^^^^ expected `char`, found `u32`
error: aborting due to 5 previous errors
src/test/ui/closures/closure-reform-bad.stderr
+1 -8
View File
@@ -4,9 +4,7 @@ error[E0308]: mismatched types
LL | let f = |s: &str| println!("{}{}", s, string);
| ------------------------------------- the found closure
LL | call_bare(f)
| --------- ^ expected fn pointer, found closure
| |
| arguments to this function are incorrect
| ^ expected fn pointer, found closure
|
= note: expected fn pointer `for<'r> fn(&'r str)`
found closure `[closure@$DIR/closure-reform-bad.rs:10:13: 10:50]`
@@ -15,11 +13,6 @@ 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
src/test/ui/closures/issue-84128.stderr
+1 -8
View File
@@ -2,20 +2,13 @@ error[E0308]: mismatched types
--> $DIR/issue-84128.rs:13:13
|
LL | Foo(())
| --- ^^ expected integer, found `()`
| |
| arguments to this struct are incorrect
| ^^ expected integer, found `()`
|
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
src/test/ui/closures/issue-87461.stderr
+3 -9
View File
@@ -2,25 +2,19 @@ error[E0308]: mismatched types
--> $DIR/issue-87461.rs:10:8
|
LL | Ok(())
| -- ^^ expected `u16`, found `()`
| |
| arguments to this enum variant are incorrect
| ^^ expected `u16`, found `()`
error[E0308]: mismatched types
--> $DIR/issue-87461.rs:17:8
|
LL | Ok(())
| -- ^^ expected `u16`, found `()`
| |
| arguments to this enum variant are incorrect
| ^^ expected `u16`, found `()`
error[E0308]: mismatched types
--> $DIR/issue-87461.rs:26:12
|
LL | Ok(())
| -- ^^ expected `u16`, found `()`
| |
| arguments to this enum variant are incorrect
| ^^ expected `u16`, found `()`
error: aborting due to 3 previous errors
src/test/ui/coercion/coerce-mut.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/coerce-mut.rs:5:7
|
LL | f(&x);
| - ^^ types differ in mutability
| |
| arguments to this function are incorrect
| ^^ types differ in mutability
|
= 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
src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/coerce-reborrow-multi-arg-fail.rs:4:18
|
LL | test(&mut 7, &7);
| ---- ^^ types differ in mutability
| |
| arguments to this function are incorrect
| ^^ types differ in mutability
|
= note: expected mutable reference `&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
src/test/ui/coercion/coerce-to-bang.stderr
+5 -40
View File
@@ -2,81 +2,46 @@ error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:6:17
|
LL | foo(return, 22, 44);
| --- ^^ expected `!`, found integer
| |
| arguments to this function are incorrect
| ^^ expected `!`, found integer
|
= 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
| |
| arguments to this function are incorrect
| ^^ expected `!`, found integer
|
= 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
| |
| arguments to this function are incorrect
| ^ expected `!`, found integer
|
= 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
| |
| arguments to this function are incorrect
| ^ expected `!`, found integer
|
= 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
| |
| arguments to this function are incorrect
| ^ expected `!`, found integer
|
= 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
src/test/ui/const-generics/const-argument-cross-crate-mismatch.stderr
+2 -6
View File
@@ -2,17 +2,13 @@ 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
| |
| arguments to this struct are incorrect
| ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
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
| |
| arguments to this struct are incorrect
| ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements
error: aborting due to 2 previous errors
src/test/ui/const-generics/generic_const_exprs/issue-62504.min.stderr
+9 -16
View File
@@ -1,3 +1,12 @@
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
|
@@ -6,22 +15,6 @@ 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`.
src/test/ui/did_you_mean/issue-42764.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-42764.rs:11:43
|
LL | this_function_expects_a_double_option(n);
| ------------------------------------- ^ expected enum `DoubleOption`, found `usize`
| |
| arguments to this function are incorrect
| ^ expected enum `DoubleOption`, found `usize`
|
= 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));
src/test/ui/disambiguate-identical-names.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/disambiguate-identical-names.rs:13:10
|
LL | test(&v);
| ---- ^^ expected struct `std::vec::Vec`, found struct `HashMap`
| |
| arguments to this function are incorrect
| ^^ expected struct `std::vec::Vec`, found struct `HashMap`
|
= 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
src/test/ui/error-codes/E0057.stderr
+6 -22
View File
@@ -2,33 +2,17 @@ error[E0057]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/E0057.rs:3:13
|
LL | let a = f();
| ^-- an argument is missing
|
note: closure defined here
--> $DIR/E0057.rs:2:13
|
LL | let f = |x| x * 3;
| ^^^
help: provide the argument
|
LL | let a = f({_});
| ~~~~~~
| ^-- supplied 0 arguments
| |
| expected 1 argument
error[E0057]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/E0057.rs:5:13
|
LL | let c = f(2, 3);
| ^ - argument unexpected
|
note: closure defined here
--> $DIR/E0057.rs:2:13
|
LL | let f = |x| x * 3;
| ^^^
help: remove the extra argument
|
LL | let c = f(2);
| ~~~~
| ^ - - supplied 2 arguments
| |
| expected 1 argument
error: aborting due to 2 previous errors
src/test/ui/error-codes/E0060.stderr
+3 -5
View File
@@ -2,17 +2,15 @@ error[E0060]: this function takes at least 1 argument but 0 arguments were suppl
--> $DIR/E0060.rs:6:14
|
LL | unsafe { printf(); }
| ^^^^^^-- an argument of type `*const u8` is missing
| ^^^^^^-- supplied 0 arguments
| |
| expected at least 1 argument
|
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
src/test/ui/error-codes/E0061.stderr
+6 -10
View File
@@ -2,33 +2,29 @@ error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/E0061.rs:6:5
|
LL | f(0);
| ^--- an argument of type `&str` is missing
| ^ - supplied 1 argument
| |
| expected 2 arguments
|
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:9:5
|
LL | f2();
| ^^-- an argument of type `u16` is missing
| ^^-- supplied 0 arguments
| |
| expected 1 argument
|
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
src/test/ui/fmt/ifmt-bad-arg.stderr
+2 -18
View File
@@ -296,36 +296,20 @@ error[E0308]: mismatched types
--> $DIR/ifmt-bad-arg.rs:78:32
|
LL | println!("{} {:.*} {}", 1, 3.2, 4);
| ---------------------------^^^----
| | |
| | expected `usize`, found floating-point number
| arguments to this function are incorrect
| ^^^ expected `usize`, found floating-point number
|
= 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
| arguments to this function are incorrect
| ^^^ expected `usize`, found floating-point number
|
= 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
src/test/ui/fn/fn-item-type.stderr
+5 -40
View File
@@ -2,95 +2,60 @@ 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
| |
| arguments to this function are incorrect
| ^^^^^^^^^ expected fn item, found a different fn item
|
= note: expected fn item `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`
| |
| arguments to this function are incorrect
| ^^^^^^^^^ expected `u8`, found `i8`
|
= note: expected fn item `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`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^ expected struct `String`, found struct `Vec`
|
= note: expected fn item `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:38:26
|
LL | eq(<u8 as Foo>::foo, <u16 as Foo>::foo);
| -- ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16`
|
= note: expected fn item `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:45:19
|
LL | eq(foo::<u8>, bar::<u8> as fn(isize) -> isize);
| -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer
|
= note: expected fn item `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
src/test/ui/generic-associated-types/issue-68648-2.stderr
+1 -8
View File
@@ -4,17 +4,10 @@ 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 `()`
| |
| arguments to this function are incorrect
| ^^ expected type parameter `T`, found `()`
|
= 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
src/test/ui/generic-associated-types/missing-bounds.stderr
+3 -24
View File
@@ -17,17 +17,10 @@ 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
| |
| arguments to this struct are incorrect
| ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
note: tuple struct defined here
--> $DIR/missing-bounds.rs:3: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> {
@@ -40,17 +33,10 @@ LL | impl<B: Add> Add for C<B> {
| - this type parameter
...
LL | Self(self.0 + rhs.0)
| ---- ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
note: tuple struct defined here
--> $DIR/missing-bounds.rs:13:8
|
LL | struct C<B>(B);
| ^
help: consider further restricting this bound
|
LL | impl<B: Add + Add<Output = B>> Add for C<B> {
@@ -76,17 +62,10 @@ 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
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
note: tuple struct defined here
--> $DIR/missing-bounds.rs:33:8
|
LL | struct E<B>(B);
| ^
help: consider further restricting this bound
|
LL | impl<B: Add + Add<Output = B>> Add for E<B> where <B as Add>::Output = B {
src/test/ui/hrtb/issue-58451.stderr
+3 -5
View File
@@ -2,17 +2,15 @@ error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/issue-58451.rs:12:9
|
LL | f(&[f()]);
| ^-- an argument is missing
| ^-- supplied 0 arguments
| |
| expected 1 argument
|
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
src/test/ui/impl-trait/issues/issue-74282.stderr
+1 -8
View File
@@ -5,9 +5,7 @@ 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
@@ -16,11 +14,6 @@ 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
src/test/ui/indexing-requires-a-uint.stderr
+1 -8
View File
@@ -12,15 +12,8 @@ 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`
| |
| arguments to this function are incorrect
| ^ expected `isize`, found `usize`
|
note: function defined here
--> $DIR/indexing-requires-a-uint.rs:5:8
|
LL | fn bar<T>(_: T) {}
| ^^^ ----
help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
|
LL | bar::<isize>(i.try_into().unwrap()); // i should not be re-coerced back to an isize
src/test/ui/inference/deref-suggestion.stderr
+7 -42
View File
@@ -2,30 +2,16 @@ 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`
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/deref-suggestion.rs:5:4
|
LL | fn foo(_: String) {}
| ^^^ ---------
| ^- help: try using a conversion method: `.to_string()`
| |
| expected struct `String`, found `&String`
error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:14:10
|
LL | foo3(u);
| ---- ^ expected `u32`, found `&u32`
| |
| arguments to this function are incorrect
| ^ expected `u32`, found `&u32`
|
note: function defined here
--> $DIR/deref-suggestion.rs:12:4
|
LL | fn foo3(_: u32) {}
| ^^^^ ------
help: consider dereferencing the borrow
|
LL | foo3(*u);
@@ -35,15 +21,8 @@ error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:30:9
|
LL | foo(&"aaa".to_owned());
| --- ^^^^^^^^^^^^^^^^^ expected struct `String`, found `&String`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^^^^ expected struct `String`, found `&String`
|
note: function defined here
--> $DIR/deref-suggestion.rs:5:4
|
LL | fn foo(_: String) {}
| ^^^ ---------
help: consider removing the borrow
|
LL - foo(&"aaa".to_owned());
@@ -54,15 +33,8 @@ error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:32:9
|
LL | foo(&mut "aaa".to_owned());
| --- ^^^^^^^^^^^^^^^^^^^^^ expected struct `String`, found `&mut String`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^^^^^^^^ expected struct `String`, found `&mut String`
|
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());
@@ -76,15 +48,8 @@ LL | ($x:expr) => { &$x }
| ^^^ expected `u32`, found `&{integer}`
...
LL | foo3(borrow!(0));
| ---- ---------- in this macro invocation
| |
| arguments to this function are incorrect
| ---------- in this macro invocation
|
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
src/test/ui/inference/tutorial-suffix-inference-test.stderr
+3 -24
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/tutorial-suffix-inference-test.rs:9:18
|
LL | identity_u16(x);
| ------------ ^ expected `u16`, found `u8`
| |
| arguments to this function are incorrect
| ^ expected `u16`, found `u8`
|
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());
@@ -20,15 +13,8 @@ error[E0308]: mismatched types
--> $DIR/tutorial-suffix-inference-test.rs:12:18
|
LL | identity_u16(y);
| ------------ ^ expected `u16`, found `i32`
| |
| arguments to this function are incorrect
| ^ expected `u16`, found `i32`
|
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());
@@ -38,15 +24,8 @@ error[E0308]: mismatched types
--> $DIR/tutorial-suffix-inference-test.rs:21:18
|
LL | identity_u16(a);
| ------------ ^ expected `u16`, found `isize`
| |
| arguments to this function are incorrect
| ^ expected `u16`, found `isize`
|
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());
src/test/ui/issues/issue-10764.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-10764.rs:4:15
|
LL | fn main() { f(bar) }
| - ^^^ expected "Rust" fn, found "C" fn
| |
| arguments to this function are incorrect
| ^^^ expected "Rust" fn, found "C" fn
|
= 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
src/test/ui/issues/issue-11374.stderr
+4 -10
View File
@@ -2,19 +2,13 @@ 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`
| arguments to this function are incorrect
| ^
| |
| expected `&mut [u8]`, found struct `Vec`
| help: consider mutably borrowing here: `&mut v`
|
= 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
src/test/ui/issues/issue-12997-2.stderr
+1 -9
View File
@@ -4,16 +4,8 @@ error[E0308]: mismatched types
LL | #[bench]
| -------- in this procedural macro expansion
LL | fn bar(x: isize) { }
| ^^^^^^^^^^^^^^^^^^^^
| |
| expected `isize`, found `&mut Bencher`
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `&mut Bencher`
|
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
src/test/ui/issues/issue-13359.stderr
+2 -16
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/issue-13359.rs:6:9
|
LL | foo(1*(1 as isize));
| --- ^^^^^^^^^^^^^^ expected `i16`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^ expected `i16`, found `isize`
|
note: function defined here
--> $DIR/issue-13359.rs:1:4
|
LL | fn foo(_s: i16) { }
| ^^^ -------
help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
|
LL | foo((1*(1 as isize)).try_into().unwrap());
@@ -20,15 +13,8 @@ error[E0308]: mismatched types
--> $DIR/issue-13359.rs:10:9
|
LL | bar(1*(1 as usize));
| --- ^^^^^^^^^^^^^^ expected `u32`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^ expected `u32`, found `usize`
|
note: function defined here
--> $DIR/issue-13359.rs:3:4
|
LL | fn bar(_s: u32) { }
| ^^^ -------
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
|
LL | bar((1*(1 as usize)).try_into().unwrap());
src/test/ui/issues/issue-13853.stderr
+4 -10
View File
@@ -20,19 +20,13 @@ error[E0308]: mismatched types
--> $DIR/issue-13853.rs:37:13
|
LL | iterate(graph);
| ------- ^^^^^
| | |
| | expected reference, found struct `Vec`
| | help: consider borrowing here: `&graph`
| arguments to this function are incorrect
| ^^^^^
| |
| expected reference, found struct `Vec`
| help: consider borrowing here: `&graph`
|
= 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
src/test/ui/issues/issue-1448-2.stderr
+1 -8
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/issue-1448-2.rs:6:24
|
LL | println!("{}", foo(10i32));
| --- ^^^^^ expected `u32`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u32`, found `i32`
|
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));
src/test/ui/issues/issue-15783.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-15783.rs:8:19
|
LL | let msg = foo(x);
| --- ^ expected slice `[&str]`, found array `[&str; 1]`
| |
| arguments to this function are incorrect
| ^ expected slice `[&str]`, found array `[&str; 1]`
|
= 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
src/test/ui/issues/issue-16939.stderr
+3 -5
View File
@@ -2,17 +2,15 @@ error[E0057]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/issue-16939.rs:5:9
|
LL | |t| f(t);
| ^ - argument unexpected
| ^ - supplied 1 argument
| |
| expected 0 arguments
|
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
src/test/ui/issues/issue-17033.stderr
+4 -5
View File
@@ -2,11 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-17033.rs:2:10
|
LL | (*p)(())
| ---- ^^
| | |
| | expected `&mut ()`, found `()`
| | help: consider mutably borrowing here: `&mut ()`
| arguments to this function are incorrect
| ^^
| |
| expected `&mut ()`, found `()`
| help: consider mutably borrowing here: `&mut ()`
error: aborting due to previous error
src/test/ui/issues/issue-18819.stderr
+3 -14
View File
@@ -2,26 +2,15 @@ error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/issue-18819.rs:16:5
|
LL | print_x(X);
| ^^^^^^^---
| ||
| |expected reference, found struct `X`
| an argument of type `&str` is missing
| ^^^^^^^ - supplied 1 argument
| |
| expected 2 arguments
|
= 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
src/test/ui/issues/issue-24819.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-24819.rs:5:9
|
LL | foo(&mut v);
| --- ^^^^^^ expected struct `HashSet`, found struct `Vec`
| |
| arguments to this function are incorrect
| ^^^^^^ expected struct `HashSet`, found struct `Vec`
|
= 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
src/test/ui/issues/issue-26094.rs
+2 -2
View File
@@ -1,6 +1,6 @@
macro_rules! some_macro {
($other: expr) => ({
$other(None) //~ NOTE argument unexpected
$other(None) //~ NOTE supplied 1 argument
})
}
@@ -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 in this expansion of some_macro!
//~| NOTE expected 0 arguments
}
src/test/ui/issues/issue-26094.stderr
+2 -6
View File
@@ -2,20 +2,16 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/issue-26094.rs:10:17
|
LL | $other(None)
| ---- argument unexpected
| ---- supplied 1 argument
...
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
src/test/ui/issues/issue-3044.rs
+1 -2
View File
@@ -2,6 +2,5 @@ fn main() {
let needlesArr: Vec<char> = vec!['a', 'f'];
needlesArr.iter().fold(|x, y| {
});
//~^^ ERROR mismatched types
//~| ERROR this function takes 2 arguments but 1 argument was supplied
//~^^ ERROR this function takes 2 arguments but 1 argument was supplied
}
src/test/ui/issues/issue-3044.stderr
+6 -21
View File
@@ -1,34 +1,19 @@
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 | | });
| |______- an argument is missing
| |_____- supplied 1 argument
|
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 2 previous errors
error: aborting due to previous error
Some errors have detailed explanations: E0061, E0308.
For more information about an error, try `rustc --explain E0061`.
For more information about this error, try `rustc --explain E0061`.
src/test/ui/issues/issue-43420-no-over-suggest.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-43420-no-over-suggest.rs:8:9
|
LL | foo(&a);
| --- ^^ expected slice `[u16]`, found struct `Vec`
| |
| arguments to this function are incorrect
| ^^ expected slice `[u16]`, found struct `Vec`
|
= 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
src/test/ui/issues/issue-4517.stderr
+1 -9
View File
@@ -2,15 +2,7 @@ error[E0308]: mismatched types
--> $DIR/issue-4517.rs:5:9
|
LL | bar(foo);
| --- ^^^ 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) {}
| ^^^ ----------------
| ^^^ expected `usize`, found array `[u8; 4]`
error: aborting due to previous error
src/test/ui/issues/issue-46756-consider-borrowing-cast-or-binexpr.stderr
+8 -22
View File
@@ -2,33 +2,19 @@ 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)`
| 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 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ---------------
| ^^^^^^^^^^^^^^^
| |
| expected `&usize`, found `usize`
| help: consider borrowing here: `&(behold as usize)`
error[E0308]: mismatched types
--> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:14:42
|
LL | light_flows_our_war_of_mocking_words(with_tears + 4);
| ------------------------------------ ^^^^^^^^^^^^^^
| | |
| | expected `&usize`, found `usize`
| | help: consider borrowing here: `&(with_tears + 4)`
| 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 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ---------------
| ^^^^^^^^^^^^^^
| |
| expected `&usize`, found `usize`
| help: consider borrowing here: `&(with_tears + 4)`
error: aborting due to 2 previous errors
src/test/ui/issues/issue-48364.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-48364.rs:2:21
|
LL | b"".starts_with(stringify!(foo))
| ----------- ^^^^^^^^^^^^^^^ expected slice `[u8]`, found `str`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^^^^^ expected slice `[u8]`, found `str`
|
= 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
src/test/ui/issues/issue-4935.stderr
+3 -5
View File
@@ -2,17 +2,15 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/issue-4935.rs:5:13
|
LL | fn main() { foo(5, 6) }
| ^^^ - argument unexpected
| ^^^ - - supplied 2 arguments
| |
| expected 1 argument
|
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
src/test/ui/issues/issue-51154.stderr
+1 -8
View File
@@ -4,18 +4,11 @@ error[E0308]: mismatched types
LL | fn foo<F: FnMut()>() {
| - this type parameter
LL | let _: Box<F> = Box::new(|| ());
| -------- ^^^^^ expected type parameter `F`, found closure
| |
| arguments to this function are incorrect
| ^^^^^ expected type parameter `F`, found closure
|
= 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
src/test/ui/issues/issue-5216.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-5216.rs:3:21
|
LL | pub static C: S = S(f);
| - ^ expected struct `Box`, found fn item
| |
| arguments to this struct are incorrect
| ^ expected struct `Box`, found fn item
|
= 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
src/test/ui/issues/issue-61106.stderr
+4 -11
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-61106.rs:3:9
|
LL | foo(x.clone());
| --- ^^^^^^^^^
| | |
| | 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) {}
| ^^^ -------
| ^^^^^^^^^
| |
| expected `&str`, found struct `String`
| help: consider borrowing here: `&x`
error: aborting due to previous error
src/test/ui/issues/issue-69306.stderr
+5 -40
View File
@@ -4,17 +4,10 @@ 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
| |
| arguments to this function are incorrect
| ^ expected type parameter `T`, found integer
|
= 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
@@ -34,17 +27,10 @@ LL | impl<T> S0<T> {
| - this type parameter
...
LL | Self(0);
| ---- ^ expected type parameter `T`, found integer
| |
| arguments to this function are incorrect
| ^ expected type parameter `T`, found integer
|
= 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
@@ -53,17 +39,10 @@ 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
| |
| arguments to this function are incorrect
| ^ expected type parameter `T`, found integer
|
= 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
@@ -71,17 +50,10 @@ 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
| |
| arguments to this function are incorrect
| ^ expected type parameter `T`, found integer
|
= 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
@@ -102,19 +74,12 @@ 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`
| |
| arguments to this function are incorrect
| ^ expected type parameter `T`, found type parameter `U`
|
= 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
src/test/ui/macros/issue-29084.stderr
+1 -11
View File
@@ -2,21 +2,11 @@ error[E0308]: mismatched types
--> $DIR/issue-29084.rs:4:13
|
LL | bar(&mut $d);
| --- ^^^^^^^ expected `u8`, found `&mut u8`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u8`, found `&mut u8`
...
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
src/test/ui/methods/method-call-err-msg.stderr
+12 -20
View File
@@ -2,49 +2,43 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/method-call-err-msg.rs:13:7
|
LL | x.zero(0)
| ^^^^ - argument unexpected
| ^^^^ - supplied 1 argument
| |
| expected 0 arguments
|
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()
| ^^^-- an argument of type `isize` is missing
| ^^^- supplied 0 arguments
| |
| expected 1 argument
|
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);
| ^^^--- an argument of type `isize` is missing
| ^^^ - supplied 1 argument
| |
| expected 2 arguments
|
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
@@ -80,17 +74,15 @@ error[E0061]: this function takes 3 arguments but 0 arguments were supplied
--> $DIR/method-call-err-msg.rs:21:7
|
LL | y.three::<usize>();
| ^^^^^^^^^^^^^^-- three arguments of type `usize`, `usize`, and `usize` are missing
| ^^^^^--------- supplied 0 arguments
| |
| expected 3 arguments
|
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
src/test/ui/methods/method-self-arg-1.stderr
+5 -19
View File
@@ -2,33 +2,19 @@ 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`
| arguments to this function are incorrect
|
note: associated function defined here
--> $DIR/method-self-arg-1.rs:6:8
|
LL | fn bar(&self) {}
| ^^^ -----
| ^
| |
| expected `&Foo`, found struct `Foo`
| help: consider borrowing here: `&x`
error[E0308]: mismatched types
--> $DIR/method-self-arg-1.rs:13:14
|
LL | Foo::bar(&42);
| -------- ^^^ expected struct `Foo`, found integer
| |
| arguments to this function are incorrect
| ^^^ expected struct `Foo`, found integer
|
= 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
src/test/ui/mismatched_types/issue-26480.stderr
-7
View File
@@ -1,19 +1,12 @@
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: function defined here
--> $DIR/issue-26480.rs:2:8
|
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)
help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
|
src/test/ui/mismatched_types/issue-35030.stderr
+1 -3
View File
@@ -5,9 +5,7 @@ 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`
| |
| arguments to this enum variant are incorrect
| ^^^^ expected type parameter `bool`, found `bool`
|
= note: expected type parameter `bool` (type parameter `bool`)
found type `bool` (`bool`)
src/test/ui/mismatched_types/numeric-literal-cast.stderr
+3 -24
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-literal-cast.rs:6:9
|
LL | foo(1u8);
| --- ^^^ expected `u16`, found `u8`
| |
| arguments to this function are incorrect
| ^^^ expected `u16`, found `u8`
|
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);
@@ -20,15 +13,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-literal-cast.rs:8:10
|
LL | foo1(2f32);
| ---- ^^^^ expected `f64`, found `f32`
| |
| arguments to this function are incorrect
| ^^^^ expected `f64`, found `f32`
|
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);
@@ -38,15 +24,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-literal-cast.rs:10:10
|
LL | foo2(3i16);
| ---- ^^^^ expected `i32`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^ expected `i32`, found `i16`
|
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);
src/test/ui/mismatched_types/overloaded-calls-bad.rs
+3 -5
View File
@@ -21,13 +21,11 @@ extern "rust-call" fn call_once(mut self, (z,): (isize,)) -> isize {
}
fn main() {
let mut s = S {
x: 3,
y: 3,
};
let ans = s("what"); //~ ERROR mismatched types
let mut s = S { x: 3, y: 3 };
let ans = s("what"); //~ ERROR mismatched types
let ans = s();
//~^ 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
}
src/test/ui/mismatched_types/overloaded-calls-bad.stderr
+27 -35
View File
@@ -1,52 +1,44 @@
error[E0308]: mismatched types
--> $DIR/overloaded-calls-bad.rs:25:17
|
LL | let ans = s("what");
| ^^^^^^ expected `isize`, found `&str`
error[E0057]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/overloaded-calls-bad.rs:26:15
|
LL | let ans = s();
| ^-- supplied 0 arguments
| |
| expected 1 argument
|
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:28:17
|
LL | let ans = s("what");
| - ^^^^^^ 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();
| ^-- 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;
| ^^^^^^^^
help: provide the argument
|
LL | let ans = s({isize});
| ~~~~~~~~~~
LL | let ans = s("burma", "shave");
| ^^^^^^^ expected `isize`, found `&str`
error[E0057]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/overloaded-calls-bad.rs:31:15
--> $DIR/overloaded-calls-bad.rs:28:15
|
LL | let ans = s("burma", "shave");
| ^ ------- ------- argument unexpected
| |
| expected `isize`, found `&str`
| ^ ------- ------- supplied 2 arguments
| |
| expected 1 argument
|
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 3 previous errors
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0057, E0308.
For more information about an error, try `rustc --explain E0057`.
src/test/ui/mismatched_types/trait-bounds-cant-coerce.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/trait-bounds-cant-coerce.rs:13:7
|
LL | a(x);
| - ^ expected trait `Foo + Send`, found trait `Foo`
| |
| arguments to this function are incorrect
| ^ expected trait `Foo + Send`, found trait `Foo`
|
= note: expected struct `Box<(dyn Foo + Send + 'static)>`
found struct `Box<(dyn Foo + 'static)>`
note: function defined here
--> $DIR/trait-bounds-cant-coerce.rs:5:4
|
LL | fn a(_x: Box<dyn Foo + Send>) {
| ^ -----------------------
error: aborting due to previous error
src/test/ui/mut/mut-cross-borrowing.stderr
+4 -10
View File
@@ -2,19 +2,13 @@ error[E0308]: mismatched types
--> $DIR/mut-cross-borrowing.rs:7:7
|
LL | f(x)
| - ^
| | |
| | expected `&mut isize`, found struct `Box`
| | help: consider mutably borrowing here: `&mut x`
| arguments to this function are incorrect
| ^
| |
| expected `&mut isize`, found struct `Box`
| help: consider mutably borrowing here: `&mut x`
|
= note: expected mutable reference `&mut isize`
found struct `Box<{integer}>`
note: function defined here
--> $DIR/mut-cross-borrowing.rs:1:4
|
LL | fn f(_: &mut isize) {}
| ^ -------------
error: aborting due to previous error
src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr
+1 -8
View File
@@ -2,17 +2,10 @@ error[E0308]: mismatched types
--> $DIR/call-fn-never-arg-wrong-type.rs:10:9
|
LL | foo("wow");
| --- ^^^^^ expected `!`, found `&str`
| |
| arguments to this function are incorrect
| ^^^^^ expected `!`, found `&str`
|
= note: expected type `!`
found reference `&'static str`
note: function defined here
--> $DIR/call-fn-never-arg-wrong-type.rs:5:4
|
LL | fn foo(x: !) -> ! {
| ^^^ ----
error: aborting due to previous error
src/test/ui/never_type/issue-96335.stderr
+1 -9
View File
@@ -17,18 +17,10 @@ error[E0308]: mismatched types
--> $DIR/issue-96335.rs:2:9
|
LL | 0.....{loop{}1};
| ----^^^^^^^^^^^
| | |
| | expected integer, found struct `RangeTo`
| arguments to this function are incorrect
| ^^^^^^^^^^^ expected integer, found struct `RangeTo`
|
= note: expected type `{integer}`
found struct `RangeTo<{integer}>`
note: associated function defined here
--> $SRC_DIR/core/src/ops/range.rs:LL:COL
|
LL | pub const fn new(start: Idx, end: Idx) -> Self {
| ^^^
error: aborting due to 2 previous errors
src/test/ui/not-enough-arguments.stderr
+6 -10
View File
@@ -2,23 +2,23 @@ error[E0061]: this function takes 4 arguments but 3 arguments were supplied
--> $DIR/not-enough-arguments.rs:27:3
|
LL | foo(1, 2, 3);
| ^^^--------- an argument of type `isize` is missing
| ^^^ - - - supplied 3 arguments
| |
| expected 4 arguments
|
note: function defined here
--> $DIR/not-enough-arguments.rs:5:4
|
LL | fn foo(a: isize, b: isize, c: isize, d:isize) {
| ^^^ -------- -------- -------- -------
help: provide the argument
|
LL | foo(1, 2, 3, {isize});
| ~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 6 arguments but 3 arguments were supplied
--> $DIR/not-enough-arguments.rs:29:3
|
LL | bar(1, 2, 3);
| ^^^--------- three arguments of type `i32`, `i32`, and `i32` are missing
| ^^^ - - - supplied 3 arguments
| |
| expected 6 arguments
|
note: function defined here
--> $DIR/not-enough-arguments.rs:10:4
@@ -37,10 +37,6 @@ LL | e: i32,
| ------
LL | f: i32,
| ------
help: provide the arguments
|
LL | bar(1, 2, 3, {i32}, {i32}, {i32});
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
src/test/ui/numeric/integer-literal-suffix-inference.stderr
+52 -416
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:38:11
|
LL | id_i8(a16);
| ----- ^^^ expected `i8`, found `i16`
| |
| arguments to this function are incorrect
| ^^^ expected `i8`, found `i16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:15:8
|
LL | fn id_i8(n: i8) -> i8 { n }
| ^^^^^ -----
help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(a16.try_into().unwrap());
@@ -20,15 +13,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:41:11
|
LL | id_i8(a32);
| ----- ^^^ expected `i8`, found `i32`
| |
| arguments to this function are incorrect
| ^^^ expected `i8`, found `i32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:15:8
|
LL | fn id_i8(n: i8) -> i8 { n }
| ^^^^^ -----
help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(a32.try_into().unwrap());
@@ -38,15 +24,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:44:11
|
LL | id_i8(a64);
| ----- ^^^ expected `i8`, found `i64`
| |
| arguments to this function are incorrect
| ^^^ expected `i8`, found `i64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:15:8
|
LL | fn id_i8(n: i8) -> i8 { n }
| ^^^^^ -----
help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(a64.try_into().unwrap());
@@ -56,15 +35,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:47:11
|
LL | id_i8(asize);
| ----- ^^^^^ expected `i8`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i8`, found `isize`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:15:8
|
LL | fn id_i8(n: i8) -> i8 { n }
| ^^^^^ -----
help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(asize.try_into().unwrap());
@@ -74,15 +46,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:51:12
|
LL | id_i16(a8);
| ------ ^^ expected `i16`, found `i8`
| |
| arguments to this function are incorrect
| ^^ expected `i16`, found `i8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:16:8
|
LL | fn id_i16(n: i16) -> i16 { n }
| ^^^^^^ ------
help: you can convert an `i8` to an `i16`
|
LL | id_i16(a8.into());
@@ -92,15 +57,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:55:12
|
LL | id_i16(a32);
| ------ ^^^ expected `i16`, found `i32`
| |
| arguments to this function are incorrect
| ^^^ expected `i16`, found `i32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:16:8
|
LL | fn id_i16(n: i16) -> i16 { n }
| ^^^^^^ ------
help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(a32.try_into().unwrap());
@@ -110,15 +68,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:58:12
|
LL | id_i16(a64);
| ------ ^^^ expected `i16`, found `i64`
| |
| arguments to this function are incorrect
| ^^^ expected `i16`, found `i64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:16:8
|
LL | fn id_i16(n: i16) -> i16 { n }
| ^^^^^^ ------
help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(a64.try_into().unwrap());
@@ -128,15 +79,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:61:12
|
LL | id_i16(asize);
| ------ ^^^^^ expected `i16`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i16`, found `isize`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:16:8
|
LL | fn id_i16(n: i16) -> i16 { n }
| ^^^^^^ ------
help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(asize.try_into().unwrap());
@@ -146,15 +90,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:65:12
|
LL | id_i32(a8);
| ------ ^^ expected `i32`, found `i8`
| |
| arguments to this function are incorrect
| ^^ expected `i32`, found `i8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:17:8
|
LL | fn id_i32(n: i32) -> i32 { n }
| ^^^^^^ ------
help: you can convert an `i8` to an `i32`
|
LL | id_i32(a8.into());
@@ -164,15 +101,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:68:12
|
LL | id_i32(a16);
| ------ ^^^ expected `i32`, found `i16`
| |
| arguments to this function are incorrect
| ^^^ expected `i32`, found `i16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:17:8
|
LL | fn id_i32(n: i32) -> i32 { n }
| ^^^^^^ ------
help: you can convert an `i16` to an `i32`
|
LL | id_i32(a16.into());
@@ -182,15 +112,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:72:12
|
LL | id_i32(a64);
| ------ ^^^ expected `i32`, found `i64`
| |
| arguments to this function are incorrect
| ^^^ expected `i32`, found `i64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:17:8
|
LL | fn id_i32(n: i32) -> i32 { n }
| ^^^^^^ ------
help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
|
LL | id_i32(a64.try_into().unwrap());
@@ -200,15 +123,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:75:12
|
LL | id_i32(asize);
| ------ ^^^^^ expected `i32`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `isize`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:17:8
|
LL | fn id_i32(n: i32) -> i32 { n }
| ^^^^^^ ------
help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit
|
LL | id_i32(asize.try_into().unwrap());
@@ -218,15 +134,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:79:12
|
LL | id_i64(a8);
| ------ ^^ expected `i64`, found `i8`
| |
| arguments to this function are incorrect
| ^^ expected `i64`, found `i8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:18:8
|
LL | fn id_i64(n: i64) -> i64 { n }
| ^^^^^^ ------
help: you can convert an `i8` to an `i64`
|
LL | id_i64(a8.into());
@@ -236,15 +145,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:82:12
|
LL | id_i64(a16);
| ------ ^^^ expected `i64`, found `i16`
| |
| arguments to this function are incorrect
| ^^^ expected `i64`, found `i16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:18:8
|
LL | fn id_i64(n: i64) -> i64 { n }
| ^^^^^^ ------
help: you can convert an `i16` to an `i64`
|
LL | id_i64(a16.into());
@@ -254,15 +156,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:85:12
|
LL | id_i64(a32);
| ------ ^^^ expected `i64`, found `i32`
| |
| arguments to this function are incorrect
| ^^^ expected `i64`, found `i32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:18:8
|
LL | fn id_i64(n: i64) -> i64 { n }
| ^^^^^^ ------
help: you can convert an `i32` to an `i64`
|
LL | id_i64(a32.into());
@@ -272,15 +167,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:89:12
|
LL | id_i64(asize);
| ------ ^^^^^ expected `i64`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i64`, found `isize`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:18:8
|
LL | fn id_i64(n: i64) -> i64 { n }
| ^^^^^^ ------
help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit
|
LL | id_i64(asize.try_into().unwrap());
@@ -290,15 +178,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:93:14
|
LL | id_isize(a8);
| -------- ^^ expected `isize`, found `i8`
| |
| arguments to this function are incorrect
| ^^ expected `isize`, found `i8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:19:8
|
LL | fn id_isize(n: isize) -> isize { n }
| ^^^^^^^^ --------
help: you can convert an `i8` to an `isize`
|
LL | id_isize(a8.into());
@@ -308,15 +189,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:96:14
|
LL | id_isize(a16);
| -------- ^^^ expected `isize`, found `i16`
| |
| arguments to this function are incorrect
| ^^^ expected `isize`, found `i16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:19:8
|
LL | fn id_isize(n: isize) -> isize { n }
| ^^^^^^^^ --------
help: you can convert an `i16` to an `isize`
|
LL | id_isize(a16.into());
@@ -326,15 +200,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:99:14
|
LL | id_isize(a32);
| -------- ^^^ expected `isize`, found `i32`
| |
| arguments to this function are incorrect
| ^^^ expected `isize`, found `i32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:19:8
|
LL | fn id_isize(n: isize) -> isize { n }
| ^^^^^^^^ --------
help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit
|
LL | id_isize(a32.try_into().unwrap());
@@ -344,15 +211,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:102:14
|
LL | id_isize(a64);
| -------- ^^^ expected `isize`, found `i64`
| |
| arguments to this function are incorrect
| ^^^ expected `isize`, found `i64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:19:8
|
LL | fn id_isize(n: isize) -> isize { n }
| ^^^^^^^^ --------
help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit
|
LL | id_isize(a64.try_into().unwrap());
@@ -362,15 +222,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:108:11
|
LL | id_i8(c16);
| ----- ^^^ expected `i8`, found `i16`
| |
| arguments to this function are incorrect
| ^^^ expected `i8`, found `i16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:15:8
|
LL | fn id_i8(n: i8) -> i8 { n }
| ^^^^^ -----
help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(c16.try_into().unwrap());
@@ -380,15 +233,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:111:11
|
LL | id_i8(c32);
| ----- ^^^ expected `i8`, found `i32`
| |
| arguments to this function are incorrect
| ^^^ expected `i8`, found `i32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:15:8
|
LL | fn id_i8(n: i8) -> i8 { n }
| ^^^^^ -----
help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(c32.try_into().unwrap());
@@ -398,15 +244,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:114:11
|
LL | id_i8(c64);
| ----- ^^^ expected `i8`, found `i64`
| |
| arguments to this function are incorrect
| ^^^ expected `i8`, found `i64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:15:8
|
LL | fn id_i8(n: i8) -> i8 { n }
| ^^^^^ -----
help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
|
LL | id_i8(c64.try_into().unwrap());
@@ -416,15 +255,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:118:12
|
LL | id_i16(c8);
| ------ ^^ expected `i16`, found `i8`
| |
| arguments to this function are incorrect
| ^^ expected `i16`, found `i8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:16:8
|
LL | fn id_i16(n: i16) -> i16 { n }
| ^^^^^^ ------
help: you can convert an `i8` to an `i16`
|
LL | id_i16(c8.into());
@@ -434,15 +266,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:122:12
|
LL | id_i16(c32);
| ------ ^^^ expected `i16`, found `i32`
| |
| arguments to this function are incorrect
| ^^^ expected `i16`, found `i32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:16:8
|
LL | fn id_i16(n: i16) -> i16 { n }
| ^^^^^^ ------
help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(c32.try_into().unwrap());
@@ -452,15 +277,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:125:12
|
LL | id_i16(c64);
| ------ ^^^ expected `i16`, found `i64`
| |
| arguments to this function are incorrect
| ^^^ expected `i16`, found `i64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:16:8
|
LL | fn id_i16(n: i16) -> i16 { n }
| ^^^^^^ ------
help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
|
LL | id_i16(c64.try_into().unwrap());
@@ -470,15 +288,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:129:12
|
LL | id_i32(c8);
| ------ ^^ expected `i32`, found `i8`
| |
| arguments to this function are incorrect
| ^^ expected `i32`, found `i8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:17:8
|
LL | fn id_i32(n: i32) -> i32 { n }
| ^^^^^^ ------
help: you can convert an `i8` to an `i32`
|
LL | id_i32(c8.into());
@@ -488,15 +299,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:132:12
|
LL | id_i32(c16);
| ------ ^^^ expected `i32`, found `i16`
| |
| arguments to this function are incorrect
| ^^^ expected `i32`, found `i16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:17:8
|
LL | fn id_i32(n: i32) -> i32 { n }
| ^^^^^^ ------
help: you can convert an `i16` to an `i32`
|
LL | id_i32(c16.into());
@@ -506,15 +310,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:136:12
|
LL | id_i32(c64);
| ------ ^^^ expected `i32`, found `i64`
| |
| arguments to this function are incorrect
| ^^^ expected `i32`, found `i64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:17:8
|
LL | fn id_i32(n: i32) -> i32 { n }
| ^^^^^^ ------
help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
|
LL | id_i32(c64.try_into().unwrap());
@@ -524,15 +321,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:140:12
|
LL | id_i64(a8);
| ------ ^^ expected `i64`, found `i8`
| |
| arguments to this function are incorrect
| ^^ expected `i64`, found `i8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:18:8
|
LL | fn id_i64(n: i64) -> i64 { n }
| ^^^^^^ ------
help: you can convert an `i8` to an `i64`
|
LL | id_i64(a8.into());
@@ -542,15 +332,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:143:12
|
LL | id_i64(a16);
| ------ ^^^ expected `i64`, found `i16`
| |
| arguments to this function are incorrect
| ^^^ expected `i64`, found `i16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:18:8
|
LL | fn id_i64(n: i64) -> i64 { n }
| ^^^^^^ ------
help: you can convert an `i16` to an `i64`
|
LL | id_i64(a16.into());
@@ -560,15 +343,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:146:12
|
LL | id_i64(a32);
| ------ ^^^ expected `i64`, found `i32`
| |
| arguments to this function are incorrect
| ^^^ expected `i64`, found `i32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:18:8
|
LL | fn id_i64(n: i64) -> i64 { n }
| ^^^^^^ ------
help: you can convert an `i32` to an `i64`
|
LL | id_i64(a32.into());
@@ -578,15 +354,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:152:11
|
LL | id_u8(b16);
| ----- ^^^ expected `u8`, found `u16`
| |
| arguments to this function are incorrect
| ^^^ expected `u8`, found `u16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:27:8
|
LL | fn id_u8(n: u8) -> u8 { n }
| ^^^^^ -----
help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit
|
LL | id_u8(b16.try_into().unwrap());
@@ -596,15 +365,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:155:11
|
LL | id_u8(b32);
| ----- ^^^ expected `u8`, found `u32`
| |
| arguments to this function are incorrect
| ^^^ expected `u8`, found `u32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:27:8
|
LL | fn id_u8(n: u8) -> u8 { n }
| ^^^^^ -----
help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit
|
LL | id_u8(b32.try_into().unwrap());
@@ -614,15 +376,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:158:11
|
LL | id_u8(b64);
| ----- ^^^ expected `u8`, found `u64`
| |
| arguments to this function are incorrect
| ^^^ expected `u8`, found `u64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:27:8
|
LL | fn id_u8(n: u8) -> u8 { n }
| ^^^^^ -----
help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit
|
LL | id_u8(b64.try_into().unwrap());
@@ -632,15 +387,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:161:11
|
LL | id_u8(bsize);
| ----- ^^^^^ expected `u8`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u8`, found `usize`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:27:8
|
LL | fn id_u8(n: u8) -> u8 { n }
| ^^^^^ -----
help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit
|
LL | id_u8(bsize.try_into().unwrap());
@@ -650,15 +398,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:165:12
|
LL | id_u16(b8);
| ------ ^^ expected `u16`, found `u8`
| |
| arguments to this function are incorrect
| ^^ expected `u16`, found `u8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:28:8
|
LL | fn id_u16(n: u16) -> u16 { n }
| ^^^^^^ ------
help: you can convert a `u8` to a `u16`
|
LL | id_u16(b8.into());
@@ -668,15 +409,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:169:12
|
LL | id_u16(b32);
| ------ ^^^ expected `u16`, found `u32`
| |
| arguments to this function are incorrect
| ^^^ expected `u16`, found `u32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:28:8
|
LL | fn id_u16(n: u16) -> u16 { n }
| ^^^^^^ ------
help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit
|
LL | id_u16(b32.try_into().unwrap());
@@ -686,15 +420,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:172:12
|
LL | id_u16(b64);
| ------ ^^^ expected `u16`, found `u64`
| |
| arguments to this function are incorrect
| ^^^ expected `u16`, found `u64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:28:8
|
LL | fn id_u16(n: u16) -> u16 { n }
| ^^^^^^ ------
help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit
|
LL | id_u16(b64.try_into().unwrap());
@@ -704,15 +431,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:175:12
|
LL | id_u16(bsize);
| ------ ^^^^^ expected `u16`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u16`, found `usize`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:28:8
|
LL | fn id_u16(n: u16) -> u16 { n }
| ^^^^^^ ------
help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit
|
LL | id_u16(bsize.try_into().unwrap());
@@ -722,15 +442,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:179:12
|
LL | id_u32(b8);
| ------ ^^ expected `u32`, found `u8`
| |
| arguments to this function are incorrect
| ^^ expected `u32`, found `u8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:29:8
|
LL | fn id_u32(n: u32) -> u32 { n }
| ^^^^^^ ------
help: you can convert a `u8` to a `u32`
|
LL | id_u32(b8.into());
@@ -740,15 +453,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:182:12
|
LL | id_u32(b16);
| ------ ^^^ expected `u32`, found `u16`
| |
| arguments to this function are incorrect
| ^^^ expected `u32`, found `u16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:29:8
|
LL | fn id_u32(n: u32) -> u32 { n }
| ^^^^^^ ------
help: you can convert a `u16` to a `u32`
|
LL | id_u32(b16.into());
@@ -758,15 +464,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:186:12
|
LL | id_u32(b64);
| ------ ^^^ expected `u32`, found `u64`
| |
| arguments to this function are incorrect
| ^^^ expected `u32`, found `u64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:29:8
|
LL | fn id_u32(n: u32) -> u32 { n }
| ^^^^^^ ------
help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
|
LL | id_u32(b64.try_into().unwrap());
@@ -776,15 +475,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:189:12
|
LL | id_u32(bsize);
| ------ ^^^^^ expected `u32`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u32`, found `usize`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:29:8
|
LL | fn id_u32(n: u32) -> u32 { n }
| ^^^^^^ ------
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
|
LL | id_u32(bsize.try_into().unwrap());
@@ -794,15 +486,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:193:12
|
LL | id_u64(b8);
| ------ ^^ expected `u64`, found `u8`
| |
| arguments to this function are incorrect
| ^^ expected `u64`, found `u8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:30:8
|
LL | fn id_u64(n: u64) -> u64 { n }
| ^^^^^^ ------
help: you can convert a `u8` to a `u64`
|
LL | id_u64(b8.into());
@@ -812,15 +497,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:196:12
|
LL | id_u64(b16);
| ------ ^^^ expected `u64`, found `u16`
| |
| arguments to this function are incorrect
| ^^^ expected `u64`, found `u16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:30:8
|
LL | fn id_u64(n: u64) -> u64 { n }
| ^^^^^^ ------
help: you can convert a `u16` to a `u64`
|
LL | id_u64(b16.into());
@@ -830,15 +508,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:199:12
|
LL | id_u64(b32);
| ------ ^^^ expected `u64`, found `u32`
| |
| arguments to this function are incorrect
| ^^^ expected `u64`, found `u32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:30:8
|
LL | fn id_u64(n: u64) -> u64 { n }
| ^^^^^^ ------
help: you can convert a `u32` to a `u64`
|
LL | id_u64(b32.into());
@@ -848,15 +519,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:203:12
|
LL | id_u64(bsize);
| ------ ^^^^^ expected `u64`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u64`, found `usize`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:30:8
|
LL | fn id_u64(n: u64) -> u64 { n }
| ^^^^^^ ------
help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
|
LL | id_u64(bsize.try_into().unwrap());
@@ -866,15 +530,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:207:14
|
LL | id_usize(b8);
| -------- ^^ expected `usize`, found `u8`
| |
| arguments to this function are incorrect
| ^^ expected `usize`, found `u8`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:31:8
|
LL | fn id_usize(n: usize) -> usize { n }
| ^^^^^^^^ --------
help: you can convert a `u8` to a `usize`
|
LL | id_usize(b8.into());
@@ -884,15 +541,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:210:14
|
LL | id_usize(b16);
| -------- ^^^ expected `usize`, found `u16`
| |
| arguments to this function are incorrect
| ^^^ expected `usize`, found `u16`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:31:8
|
LL | fn id_usize(n: usize) -> usize { n }
| ^^^^^^^^ --------
help: you can convert a `u16` to a `usize`
|
LL | id_usize(b16.into());
@@ -902,15 +552,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:213:14
|
LL | id_usize(b32);
| -------- ^^^ expected `usize`, found `u32`
| |
| arguments to this function are incorrect
| ^^^ expected `usize`, found `u32`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:31:8
|
LL | fn id_usize(n: usize) -> usize { n }
| ^^^^^^^^ --------
help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit
|
LL | id_usize(b32.try_into().unwrap());
@@ -920,15 +563,8 @@ error[E0308]: mismatched types
--> $DIR/integer-literal-suffix-inference.rs:216:14
|
LL | id_usize(b64);
| -------- ^^^ expected `usize`, found `u64`
| |
| arguments to this function are incorrect
| ^^^ expected `usize`, found `u64`
|
note: function defined here
--> $DIR/integer-literal-suffix-inference.rs:31:8
|
LL | fn id_usize(n: usize) -> usize { n }
| ^^^^^^^^ --------
help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit
|
LL | id_usize(b64.try_into().unwrap());
src/test/ui/numeric/len.stderr
+1 -8
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/len.rs:3:10
|
LL | test(array.len());
| ---- ^^^^^^^^^^^ expected `u32`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^ expected `u32`, found `usize`
|
note: function defined here
--> $DIR/len.rs:6:4
|
LL | fn test(length: u32) {
| ^^^^ -----------
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
|
LL | test(array.len().try_into().unwrap());
src/test/ui/numeric/numeric-cast-without-suggestion.stderr
+21 -189
View File
@@ -2,295 +2,127 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:17:18
|
LL | foo::<usize>(x_f64);
| ------------ ^^^^^ expected `usize`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `usize`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:18:18
|
LL | foo::<usize>(x_f32);
| ------------ ^^^^^ expected `usize`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `usize`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:19:18
|
LL | foo::<isize>(x_f64);
| ------------ ^^^^^ expected `isize`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `isize`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:20:18
|
LL | foo::<isize>(x_f32);
| ------------ ^^^^^ expected `isize`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `isize`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:21:16
|
LL | foo::<u64>(x_f64);
| ---------- ^^^^^ expected `u64`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `u64`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:22:16
|
LL | foo::<u64>(x_f32);
| ---------- ^^^^^ expected `u64`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `u64`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:23:16
|
LL | foo::<i64>(x_f64);
| ---------- ^^^^^ expected `i64`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `i64`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:24:16
|
LL | foo::<i64>(x_f32);
| ---------- ^^^^^ expected `i64`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `i64`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:25:16
|
LL | foo::<u32>(x_f64);
| ---------- ^^^^^ expected `u32`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `u32`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:26:16
|
LL | foo::<u32>(x_f32);
| ---------- ^^^^^ expected `u32`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `u32`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:27:16
|
LL | foo::<i32>(x_f64);
| ---------- ^^^^^ expected `i32`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `i32`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:28:16
|
LL | foo::<i32>(x_f32);
| ---------- ^^^^^ expected `i32`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `i32`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:29:16
|
LL | foo::<u16>(x_f64);
| ---------- ^^^^^ expected `u16`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `u16`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:30:16
|
LL | foo::<u16>(x_f32);
| ---------- ^^^^^ expected `u16`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `u16`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:31:16
|
LL | foo::<i16>(x_f64);
| ---------- ^^^^^ expected `i16`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `i16`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:32:16
|
LL | foo::<i16>(x_f32);
| ---------- ^^^^^ expected `i16`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `i16`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:33:15
|
LL | foo::<u8>(x_f64);
| --------- ^^^^^ expected `u8`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `u8`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:34:15
|
LL | foo::<u8>(x_f32);
| --------- ^^^^^ expected `u8`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `u8`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:35:15
|
LL | foo::<i8>(x_f64);
| --------- ^^^^^ expected `i8`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `i8`, found `f64`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:36:15
|
LL | foo::<i8>(x_f32);
| --------- ^^^^^ expected `i8`, found `f32`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `i8`, found `f32`
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:37:16
|
LL | foo::<f32>(x_f64);
| ---------- ^^^^^ expected `f32`, found `f64`
| |
| arguments to this function are incorrect
|
note: function defined here
--> $DIR/numeric-cast-without-suggestion.rs:1:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
| ^^^^^ expected `f32`, found `f64`
error: aborting due to 21 previous errors
src/test/ui/numeric/numeric-cast.stderr
+113 -904
View File
@@ -2,15 +2,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:23:18
|
LL | foo::<usize>(x_u64);
| ------------ ^^^^^ expected `usize`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `usize`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit
|
LL | foo::<usize>(x_u64.try_into().unwrap());
@@ -20,15 +13,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:25:18
|
LL | foo::<usize>(x_u32);
| ------------ ^^^^^ expected `usize`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `usize`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit
|
LL | foo::<usize>(x_u32.try_into().unwrap());
@@ -38,15 +24,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:27:18
|
LL | foo::<usize>(x_u16);
| ------------ ^^^^^ expected `usize`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `usize`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to a `usize`
|
LL | foo::<usize>(x_u16.into());
@@ -56,15 +35,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:29:18
|
LL | foo::<usize>(x_u8);
| ------------ ^^^^ expected `usize`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `usize`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to a `usize`
|
LL | foo::<usize>(x_u8.into());
@@ -74,15 +46,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:31:18
|
LL | foo::<usize>(x_isize);
| ------------ ^^^^^^^ expected `usize`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `usize`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit
|
LL | foo::<usize>(x_isize.try_into().unwrap());
@@ -92,15 +57,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:33:18
|
LL | foo::<usize>(x_i64);
| ------------ ^^^^^ expected `usize`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `usize`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to a `usize` and panic if the converted value doesn't fit
|
LL | foo::<usize>(x_i64.try_into().unwrap());
@@ -110,15 +68,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:35:18
|
LL | foo::<usize>(x_i32);
| ------------ ^^^^^ expected `usize`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `usize`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit
|
LL | foo::<usize>(x_i32.try_into().unwrap());
@@ -128,15 +79,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:37:18
|
LL | foo::<usize>(x_i16);
| ------------ ^^^^^ expected `usize`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `usize`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to a `usize` and panic if the converted value doesn't fit
|
LL | foo::<usize>(x_i16.try_into().unwrap());
@@ -146,15 +90,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:39:18
|
LL | foo::<usize>(x_i8);
| ------------ ^^^^ expected `usize`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `usize`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to a `usize` and panic if the converted value doesn't fit
|
LL | foo::<usize>(x_i8.try_into().unwrap());
@@ -164,15 +101,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:44:18
|
LL | foo::<isize>(x_usize);
| ------------ ^^^^^^^ expected `isize`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `isize`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
|
LL | foo::<isize>(x_usize.try_into().unwrap());
@@ -182,15 +112,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:46:18
|
LL | foo::<isize>(x_u64);
| ------------ ^^^^^ expected `isize`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `isize`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to an `isize` and panic if the converted value doesn't fit
|
LL | foo::<isize>(x_u64.try_into().unwrap());
@@ -200,15 +123,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:48:18
|
LL | foo::<isize>(x_u32);
| ------------ ^^^^^ expected `isize`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `isize`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to an `isize` and panic if the converted value doesn't fit
|
LL | foo::<isize>(x_u32.try_into().unwrap());
@@ -218,15 +134,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:50:18
|
LL | foo::<isize>(x_u16);
| ------------ ^^^^^ expected `isize`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `isize`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to an `isize` and panic if the converted value doesn't fit
|
LL | foo::<isize>(x_u16.try_into().unwrap());
@@ -236,15 +145,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:52:18
|
LL | foo::<isize>(x_u8);
| ------------ ^^^^ expected `isize`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `isize`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to an `isize`
|
LL | foo::<isize>(x_u8.into());
@@ -254,15 +156,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:55:18
|
LL | foo::<isize>(x_i64);
| ------------ ^^^^^ expected `isize`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `isize`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit
|
LL | foo::<isize>(x_i64.try_into().unwrap());
@@ -272,15 +167,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:57:18
|
LL | foo::<isize>(x_i32);
| ------------ ^^^^^ expected `isize`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `isize`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit
|
LL | foo::<isize>(x_i32.try_into().unwrap());
@@ -290,15 +178,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:59:18
|
LL | foo::<isize>(x_i16);
| ------------ ^^^^^ expected `isize`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `isize`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to an `isize`
|
LL | foo::<isize>(x_i16.into());
@@ -308,15 +189,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:61:18
|
LL | foo::<isize>(x_i8);
| ------------ ^^^^ expected `isize`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `isize`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to an `isize`
|
LL | foo::<isize>(x_i8.into());
@@ -326,15 +200,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:66:16
|
LL | foo::<u64>(x_usize);
| ---------- ^^^^^^^ expected `u64`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u64`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
|
LL | foo::<u64>(x_usize.try_into().unwrap());
@@ -344,15 +211,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:69:16
|
LL | foo::<u64>(x_u32);
| ---------- ^^^^^ expected `u64`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u64`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to a `u64`
|
LL | foo::<u64>(x_u32.into());
@@ -362,15 +222,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:71:16
|
LL | foo::<u64>(x_u16);
| ---------- ^^^^^ expected `u64`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u64`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to a `u64`
|
LL | foo::<u64>(x_u16.into());
@@ -380,15 +233,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:73:16
|
LL | foo::<u64>(x_u8);
| ---------- ^^^^ expected `u64`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `u64`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to a `u64`
|
LL | foo::<u64>(x_u8.into());
@@ -398,15 +244,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:75:16
|
LL | foo::<u64>(x_isize);
| ---------- ^^^^^^^ expected `u64`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u64`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to a `u64` and panic if the converted value doesn't fit
|
LL | foo::<u64>(x_isize.try_into().unwrap());
@@ -416,15 +255,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:77:16
|
LL | foo::<u64>(x_i64);
| ---------- ^^^^^ expected `u64`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u64`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to a `u64` and panic if the converted value doesn't fit
|
LL | foo::<u64>(x_i64.try_into().unwrap());
@@ -434,15 +266,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:79:16
|
LL | foo::<u64>(x_i32);
| ---------- ^^^^^ expected `u64`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u64`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit
|
LL | foo::<u64>(x_i32.try_into().unwrap());
@@ -452,15 +277,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:81:16
|
LL | foo::<u64>(x_i16);
| ---------- ^^^^^ expected `u64`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u64`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to a `u64` and panic if the converted value doesn't fit
|
LL | foo::<u64>(x_i16.try_into().unwrap());
@@ -470,15 +288,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:83:16
|
LL | foo::<u64>(x_i8);
| ---------- ^^^^ expected `u64`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `u64`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to a `u64` and panic if the converted value doesn't fit
|
LL | foo::<u64>(x_i8.try_into().unwrap());
@@ -488,15 +299,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:88:16
|
LL | foo::<i64>(x_usize);
| ---------- ^^^^^^^ expected `i64`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `i64`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to an `i64` and panic if the converted value doesn't fit
|
LL | foo::<i64>(x_usize.try_into().unwrap());
@@ -506,15 +310,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:90:16
|
LL | foo::<i64>(x_u64);
| ---------- ^^^^^ expected `i64`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i64`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to an `i64` and panic if the converted value doesn't fit
|
LL | foo::<i64>(x_u64.try_into().unwrap());
@@ -524,15 +321,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:92:16
|
LL | foo::<i64>(x_u32);
| ---------- ^^^^^ expected `i64`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i64`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to an `i64`
|
LL | foo::<i64>(x_u32.into());
@@ -542,15 +332,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:94:16
|
LL | foo::<i64>(x_u16);
| ---------- ^^^^^ expected `i64`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i64`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to an `i64`
|
LL | foo::<i64>(x_u16.into());
@@ -560,15 +343,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:96:16
|
LL | foo::<i64>(x_u8);
| ---------- ^^^^ expected `i64`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `i64`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to an `i64`
|
LL | foo::<i64>(x_u8.into());
@@ -578,15 +354,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:98:16
|
LL | foo::<i64>(x_isize);
| ---------- ^^^^^^^ expected `i64`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `i64`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit
|
LL | foo::<i64>(x_isize.try_into().unwrap());
@@ -596,15 +365,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:101:16
|
LL | foo::<i64>(x_i32);
| ---------- ^^^^^ expected `i64`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i64`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to an `i64`
|
LL | foo::<i64>(x_i32.into());
@@ -614,15 +376,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:103:16
|
LL | foo::<i64>(x_i16);
| ---------- ^^^^^ expected `i64`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i64`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to an `i64`
|
LL | foo::<i64>(x_i16.into());
@@ -632,15 +387,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:105:16
|
LL | foo::<i64>(x_i8);
| ---------- ^^^^ expected `i64`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `i64`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to an `i64`
|
LL | foo::<i64>(x_i8.into());
@@ -650,15 +398,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:110:16
|
LL | foo::<u32>(x_usize);
| ---------- ^^^^^^^ expected `u32`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u32`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
|
LL | foo::<u32>(x_usize.try_into().unwrap());
@@ -668,15 +409,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:112:16
|
LL | foo::<u32>(x_u64);
| ---------- ^^^^^ expected `u32`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u32`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
|
LL | foo::<u32>(x_u64.try_into().unwrap());
@@ -686,15 +420,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:115:16
|
LL | foo::<u32>(x_u16);
| ---------- ^^^^^ expected `u32`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u32`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to a `u32`
|
LL | foo::<u32>(x_u16.into());
@@ -704,15 +431,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:117:16
|
LL | foo::<u32>(x_u8);
| ---------- ^^^^ expected `u32`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `u32`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to a `u32`
|
LL | foo::<u32>(x_u8.into());
@@ -722,15 +442,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:119:16
|
LL | foo::<u32>(x_isize);
| ---------- ^^^^^^^ expected `u32`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u32`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to a `u32` and panic if the converted value doesn't fit
|
LL | foo::<u32>(x_isize.try_into().unwrap());
@@ -740,15 +453,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:121:16
|
LL | foo::<u32>(x_i64);
| ---------- ^^^^^ expected `u32`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u32`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to a `u32` and panic if the converted value doesn't fit
|
LL | foo::<u32>(x_i64.try_into().unwrap());
@@ -758,15 +464,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:123:16
|
LL | foo::<u32>(x_i32);
| ---------- ^^^^^ expected `u32`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u32`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit
|
LL | foo::<u32>(x_i32.try_into().unwrap());
@@ -776,15 +475,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:125:16
|
LL | foo::<u32>(x_i16);
| ---------- ^^^^^ expected `u32`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u32`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to a `u32` and panic if the converted value doesn't fit
|
LL | foo::<u32>(x_i16.try_into().unwrap());
@@ -794,15 +486,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:127:16
|
LL | foo::<u32>(x_i8);
| ---------- ^^^^ expected `u32`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `u32`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to a `u32` and panic if the converted value doesn't fit
|
LL | foo::<u32>(x_i8.try_into().unwrap());
@@ -812,15 +497,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:132:16
|
LL | foo::<i32>(x_usize);
| ---------- ^^^^^^^ expected `i32`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `i32`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to an `i32` and panic if the converted value doesn't fit
|
LL | foo::<i32>(x_usize.try_into().unwrap());
@@ -830,15 +508,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:134:16
|
LL | foo::<i32>(x_u64);
| ---------- ^^^^^ expected `i32`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to an `i32` and panic if the converted value doesn't fit
|
LL | foo::<i32>(x_u64.try_into().unwrap());
@@ -848,15 +519,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:136:16
|
LL | foo::<i32>(x_u32);
| ---------- ^^^^^ expected `i32`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit
|
LL | foo::<i32>(x_u32.try_into().unwrap());
@@ -866,15 +530,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:138:16
|
LL | foo::<i32>(x_u16);
| ---------- ^^^^^ expected `i32`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to an `i32`
|
LL | foo::<i32>(x_u16.into());
@@ -884,15 +541,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:140:16
|
LL | foo::<i32>(x_u8);
| ---------- ^^^^ expected `i32`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `i32`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to an `i32`
|
LL | foo::<i32>(x_u8.into());
@@ -902,15 +552,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:142:16
|
LL | foo::<i32>(x_isize);
| ---------- ^^^^^^^ expected `i32`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `i32`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit
|
LL | foo::<i32>(x_isize.try_into().unwrap());
@@ -920,15 +563,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:144:16
|
LL | foo::<i32>(x_i64);
| ---------- ^^^^^ expected `i32`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit
|
LL | foo::<i32>(x_i64.try_into().unwrap());
@@ -938,15 +574,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:147:16
|
LL | foo::<i32>(x_i16);
| ---------- ^^^^^ expected `i32`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to an `i32`
|
LL | foo::<i32>(x_i16.into());
@@ -956,15 +585,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:149:16
|
LL | foo::<i32>(x_i8);
| ---------- ^^^^ expected `i32`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `i32`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to an `i32`
|
LL | foo::<i32>(x_i8.into());
@@ -974,15 +596,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:154:16
|
LL | foo::<u16>(x_usize);
| ---------- ^^^^^^^ expected `u16`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u16`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit
|
LL | foo::<u16>(x_usize.try_into().unwrap());
@@ -992,15 +607,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:156:16
|
LL | foo::<u16>(x_u64);
| ---------- ^^^^^ expected `u16`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u16`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit
|
LL | foo::<u16>(x_u64.try_into().unwrap());
@@ -1010,15 +618,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:158:16
|
LL | foo::<u16>(x_u32);
| ---------- ^^^^^ expected `u16`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u16`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit
|
LL | foo::<u16>(x_u32.try_into().unwrap());
@@ -1028,15 +629,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:161:16
|
LL | foo::<u16>(x_u8);
| ---------- ^^^^ expected `u16`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `u16`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to a `u16`
|
LL | foo::<u16>(x_u8.into());
@@ -1046,15 +640,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:163:16
|
LL | foo::<u16>(x_isize);
| ---------- ^^^^^^^ expected `u16`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u16`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit
|
LL | foo::<u16>(x_isize.try_into().unwrap());
@@ -1064,15 +651,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:165:16
|
LL | foo::<u16>(x_i64);
| ---------- ^^^^^ expected `u16`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u16`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to a `u16` and panic if the converted value doesn't fit
|
LL | foo::<u16>(x_i64.try_into().unwrap());
@@ -1082,15 +662,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:167:16
|
LL | foo::<u16>(x_i32);
| ---------- ^^^^^ expected `u16`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u16`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit
|
LL | foo::<u16>(x_i32.try_into().unwrap());
@@ -1100,15 +673,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:169:16
|
LL | foo::<u16>(x_i16);
| ---------- ^^^^^ expected `u16`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u16`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to a `u16` and panic if the converted value doesn't fit
|
LL | foo::<u16>(x_i16.try_into().unwrap());
@@ -1118,15 +684,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:171:16
|
LL | foo::<u16>(x_i8);
| ---------- ^^^^ expected `u16`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `u16`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to a `u16` and panic if the converted value doesn't fit
|
LL | foo::<u16>(x_i8.try_into().unwrap());
@@ -1136,15 +695,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:176:16
|
LL | foo::<i16>(x_usize);
| ---------- ^^^^^^^ expected `i16`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `i16`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to an `i16` and panic if the converted value doesn't fit
|
LL | foo::<i16>(x_usize.try_into().unwrap());
@@ -1154,15 +706,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:178:16
|
LL | foo::<i16>(x_u64);
| ---------- ^^^^^ expected `i16`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i16`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to an `i16` and panic if the converted value doesn't fit
|
LL | foo::<i16>(x_u64.try_into().unwrap());
@@ -1172,15 +717,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:180:16
|
LL | foo::<i16>(x_u32);
| ---------- ^^^^^ expected `i16`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i16`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to an `i16` and panic if the converted value doesn't fit
|
LL | foo::<i16>(x_u32.try_into().unwrap());
@@ -1190,15 +728,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:182:16
|
LL | foo::<i16>(x_u16);
| ---------- ^^^^^ expected `i16`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i16`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to an `i16` and panic if the converted value doesn't fit
|
LL | foo::<i16>(x_u16.try_into().unwrap());
@@ -1208,15 +739,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:184:16
|
LL | foo::<i16>(x_u8);
| ---------- ^^^^ expected `i16`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `i16`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to an `i16`
|
LL | foo::<i16>(x_u8.into());
@@ -1226,15 +750,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:186:16
|
LL | foo::<i16>(x_isize);
| ---------- ^^^^^^^ expected `i16`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `i16`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
|
LL | foo::<i16>(x_isize.try_into().unwrap());
@@ -1244,15 +761,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:188:16
|
LL | foo::<i16>(x_i64);
| ---------- ^^^^^ expected `i16`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i16`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit
|
LL | foo::<i16>(x_i64.try_into().unwrap());
@@ -1262,15 +772,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:190:16
|
LL | foo::<i16>(x_i32);
| ---------- ^^^^^ expected `i16`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i16`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit
|
LL | foo::<i16>(x_i32.try_into().unwrap());
@@ -1280,15 +783,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:193:16
|
LL | foo::<i16>(x_i8);
| ---------- ^^^^ expected `i16`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `i16`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to an `i16`
|
LL | foo::<i16>(x_i8.into());
@@ -1298,15 +794,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:198:15
|
LL | foo::<u8>(x_usize);
| --------- ^^^^^^^ expected `u8`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u8`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_usize.try_into().unwrap());
@@ -1316,15 +805,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:200:15
|
LL | foo::<u8>(x_u64);
| --------- ^^^^^ expected `u8`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u8`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_u64.try_into().unwrap());
@@ -1334,15 +816,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:202:15
|
LL | foo::<u8>(x_u32);
| --------- ^^^^^ expected `u8`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u8`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_u32.try_into().unwrap());
@@ -1352,15 +827,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:204:15
|
LL | foo::<u8>(x_u16);
| --------- ^^^^^ expected `u8`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u8`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_u16.try_into().unwrap());
@@ -1370,15 +838,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:207:15
|
LL | foo::<u8>(x_isize);
| --------- ^^^^^^^ expected `u8`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `u8`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_isize.try_into().unwrap());
@@ -1388,15 +849,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:209:15
|
LL | foo::<u8>(x_i64);
| --------- ^^^^^ expected `u8`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u8`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_i64.try_into().unwrap());
@@ -1406,15 +860,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:211:15
|
LL | foo::<u8>(x_i32);
| --------- ^^^^^ expected `u8`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u8`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_i32.try_into().unwrap());
@@ -1424,15 +871,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:213:15
|
LL | foo::<u8>(x_i16);
| --------- ^^^^^ expected `u8`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `u8`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_i16.try_into().unwrap());
@@ -1442,15 +882,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:215:15
|
LL | foo::<u8>(x_i8);
| --------- ^^^^ expected `u8`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `u8`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to a `u8` and panic if the converted value doesn't fit
|
LL | foo::<u8>(x_i8.try_into().unwrap());
@@ -1460,15 +893,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:220:15
|
LL | foo::<i8>(x_usize);
| --------- ^^^^^^^ expected `i8`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `i8`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `usize` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_usize.try_into().unwrap());
@@ -1478,15 +904,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:222:15
|
LL | foo::<i8>(x_u64);
| --------- ^^^^^ expected `i8`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i8`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u64` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_u64.try_into().unwrap());
@@ -1496,15 +915,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:224:15
|
LL | foo::<i8>(x_u32);
| --------- ^^^^^ expected `i8`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i8`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_u32.try_into().unwrap());
@@ -1514,15 +926,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:226:15
|
LL | foo::<i8>(x_u16);
| --------- ^^^^^ expected `i8`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i8`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_u16.try_into().unwrap());
@@ -1532,15 +937,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:228:15
|
LL | foo::<i8>(x_u8);
| --------- ^^^^ expected `i8`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `i8`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_u8.try_into().unwrap());
@@ -1550,15 +948,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:230:15
|
LL | foo::<i8>(x_isize);
| --------- ^^^^^^^ expected `i8`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `i8`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_isize.try_into().unwrap());
@@ -1568,15 +959,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:232:15
|
LL | foo::<i8>(x_i64);
| --------- ^^^^^ expected `i8`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i8`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_i64.try_into().unwrap());
@@ -1586,15 +970,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:234:15
|
LL | foo::<i8>(x_i32);
| --------- ^^^^^ expected `i8`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i8`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_i32.try_into().unwrap());
@@ -1604,15 +981,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:236:15
|
LL | foo::<i8>(x_i16);
| --------- ^^^^^ expected `i8`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i8`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit
|
LL | foo::<i8>(x_i16.try_into().unwrap());
@@ -1622,15 +992,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:242:16
|
LL | foo::<f64>(x_usize);
| ---------- ^^^^^^^ expected `f64`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `f64`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can cast a `usize` to an `f64`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f64>(x_usize as f64);
@@ -1640,15 +1003,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:244:16
|
LL | foo::<f64>(x_u64);
| ---------- ^^^^^ expected `f64`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f64`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can cast a `u64` to an `f64`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f64>(x_u64 as f64);
@@ -1658,15 +1014,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:246:16
|
LL | foo::<f64>(x_u32);
| ---------- ^^^^^ expected `f64`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f64`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u32` to an `f64`, producing the floating point representation of the integer
|
LL | foo::<f64>(x_u32.into());
@@ -1676,15 +1025,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:248:16
|
LL | foo::<f64>(x_u16);
| ---------- ^^^^^ expected `f64`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f64`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to an `f64`, producing the floating point representation of the integer
|
LL | foo::<f64>(x_u16.into());
@@ -1694,15 +1036,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:250:16
|
LL | foo::<f64>(x_u8);
| ---------- ^^^^ expected `f64`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `f64`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to an `f64`, producing the floating point representation of the integer
|
LL | foo::<f64>(x_u8.into());
@@ -1712,15 +1047,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:252:16
|
LL | foo::<f64>(x_isize);
| ---------- ^^^^^^^ expected `f64`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `f64`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to an `f64`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f64>(x_isize as f64);
@@ -1730,15 +1058,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:254:16
|
LL | foo::<f64>(x_i64);
| ---------- ^^^^^ expected `f64`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f64`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to an `f64`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f64>(x_i64 as f64);
@@ -1748,15 +1069,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:256:16
|
LL | foo::<f64>(x_i32);
| ---------- ^^^^^ expected `f64`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f64`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to an `f64`, producing the floating point representation of the integer
|
LL | foo::<f64>(x_i32.into());
@@ -1766,15 +1080,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:258:16
|
LL | foo::<f64>(x_i16);
| ---------- ^^^^^ expected `f64`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f64`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to an `f64`, producing the floating point representation of the integer
|
LL | foo::<f64>(x_i16.into());
@@ -1784,15 +1091,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:260:16
|
LL | foo::<f64>(x_i8);
| ---------- ^^^^ expected `f64`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `f64`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to an `f64`, producing the floating point representation of the integer
|
LL | foo::<f64>(x_i8.into());
@@ -1802,15 +1102,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:263:16
|
LL | foo::<f64>(x_f32);
| ---------- ^^^^^ expected `f64`, found `f32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f64`, found `f32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `f32` to an `f64`
|
LL | foo::<f64>(x_f32.into());
@@ -1820,15 +1113,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:266:16
|
LL | foo::<f32>(x_usize);
| ---------- ^^^^^^^ expected `f32`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `f32`, found `usize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can cast a `usize` to an `f32`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f32>(x_usize as f32);
@@ -1838,15 +1124,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:268:16
|
LL | foo::<f32>(x_u64);
| ---------- ^^^^^ expected `f32`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f32`, found `u64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can cast a `u64` to an `f32`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f32>(x_u64 as f32);
@@ -1856,15 +1135,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:270:16
|
LL | foo::<f32>(x_u32);
| ---------- ^^^^^ expected `f32`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f32`, found `u32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can cast a `u32` to an `f32`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f32>(x_u32 as f32);
@@ -1874,15 +1146,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:272:16
|
LL | foo::<f32>(x_u16);
| ---------- ^^^^^ expected `f32`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f32`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to an `f32`, producing the floating point representation of the integer
|
LL | foo::<f32>(x_u16.into());
@@ -1892,15 +1157,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:274:16
|
LL | foo::<f32>(x_u8);
| ---------- ^^^^ expected `f32`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^ expected `f32`, found `u8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u8` to an `f32`, producing the floating point representation of the integer
|
LL | foo::<f32>(x_u8.into());
@@ -1910,15 +1168,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:276:16
|
LL | foo::<f32>(x_isize);
| ---------- ^^^^^^^ expected `f32`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^ expected `f32`, found `isize`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `isize` to an `f32`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f32>(x_isize as f32);
@@ -1928,15 +1179,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:278:16
|
LL | foo::<f32>(x_i64);
| ---------- ^^^^^ expected `f32`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f32`, found `i64`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i64` to an `f32`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f32>(x_i64 as f32);
@@ -1946,15 +1190,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:280:16
|
LL | foo::<f32>(x_i32);
| ---------- ^^^^^ expected `f32`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f32`, found `i32`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i32` to an `f32`, producing the floating point representation of the integer, rounded if necessary
|
LL | foo::<f32>(x_i32 as f32);
@@ -1964,15 +1201,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:282:16
|
LL | foo::<f32>(x_i16);
| ---------- ^^^^^ expected `f32`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^ expected `f32`, found `i16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i16` to an `f32`, producing the floating point representation of the integer
|
LL | foo::<f32>(x_i16.into());
@@ -1982,15 +1212,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:284:16
|
LL | foo::<f32>(x_i8);
| ---------- ^^^^ expected `f32`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^ expected `f32`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to an `f32`, producing the floating point representation of the integer
|
LL | foo::<f32>(x_i8.into());
@@ -2000,15 +1223,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:289:16
|
LL | foo::<u32>(x_u8 as u16);
| ---------- ^^^^^^^^^^^ expected `u32`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^^^^^^^ expected `u32`, found `u16`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert a `u16` to a `u32`
|
LL | foo::<u32>((x_u8 as u16).into());
@@ -2018,15 +1234,8 @@ error[E0308]: mismatched types
--> $DIR/numeric-cast.rs:291:16
|
LL | foo::<i32>(-x_i8);
| ---------- ^^^^^ expected `i32`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `i8`
|
note: function defined here
--> $DIR/numeric-cast.rs:6:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: you can convert an `i8` to an `i32`
|
LL | foo::<i32>((-x_i8).into());
src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed
-33
View File
@@ -1,73 +1,40 @@
// run-rustfix
fn foo<N>(_x: N) {}
//~^ NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
fn main() {
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
}
src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs
-33
View File
@@ -1,73 +1,40 @@
// run-rustfix
fn foo<N>(_x: N) {}
//~^ NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
fn main() {
foo::<i32>(42_usize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_u64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_u16);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_u8);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i32);
foo::<i32>(42_i16);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42_i8);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42.0_f64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i32>(42.0_f32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
}
src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr
+22 -99
View File
@@ -1,196 +1,119 @@
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:28:16
--> $DIR/numeric-suffix-i32.rs:6:16
|
LL | foo::<i32>(42_usize);
| ---------- ^^^^^^^^ expected `i32`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `i32`, found `usize`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `usize` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:32:16
--> $DIR/numeric-suffix-i32.rs:9:16
|
LL | foo::<i32>(42_u64);
| ---------- ^^^^^^ expected `i32`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i32`, found `u64`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u64` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:36:16
--> $DIR/numeric-suffix-i32.rs:12:16
|
LL | foo::<i32>(42_u32);
| ---------- ^^^^^^ expected `i32`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i32`, found `u32`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u32` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:40:16
--> $DIR/numeric-suffix-i32.rs:15:16
|
LL | foo::<i32>(42_u16);
| ---------- ^^^^^^ expected `i32`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i32`, found `u16`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u16` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:44:16
--> $DIR/numeric-suffix-i32.rs:18:16
|
LL | foo::<i32>(42_u8);
| ---------- ^^^^^ expected `i32`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `u8`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u8` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:48:16
--> $DIR/numeric-suffix-i32.rs:21:16
|
LL | foo::<i32>(42_isize);
| ---------- ^^^^^^^^ expected `i32`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `i32`, found `isize`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `isize` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:52:16
--> $DIR/numeric-suffix-i32.rs:24:16
|
LL | foo::<i32>(42_i64);
| ---------- ^^^^^^ expected `i32`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i32`, found `i64`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i64` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:57:16
--> $DIR/numeric-suffix-i32.rs:28:16
|
LL | foo::<i32>(42_i16);
| ---------- ^^^^^^ expected `i32`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i32`, found `i16`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i16` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:61:16
--> $DIR/numeric-suffix-i32.rs:31:16
|
LL | foo::<i32>(42_i8);
| ---------- ^^^^^ expected `i32`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i32`, found `i8`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i8` to `i32`
|
LL | foo::<i32>(42_i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:65:16
--> $DIR/numeric-suffix-i32.rs:34:16
|
LL | foo::<i32>(42.0_f64);
| ---------- ^^^^^^^^ expected `i32`, found `f64`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `i32`, found `f64`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `f64` to `i32`
|
LL | foo::<i32>(42i32);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i32.rs:69:16
--> $DIR/numeric-suffix-i32.rs:37:16
|
LL | foo::<i32>(42.0_f32);
| ---------- ^^^^^^^^ expected `i32`, found `f32`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `i32`, found `f32`
|
note: function defined here
--> $DIR/numeric-suffix-i32.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `f32` to `i32`
|
LL | foo::<i32>(42i32);
src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed
-33
View File
@@ -1,73 +1,40 @@
// run-rustfix
fn foo<N>(_x: N) {}
//~^ NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
fn main() {
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
}
src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs
-33
View File
@@ -1,73 +1,40 @@
// run-rustfix
fn foo<N>(_x: N) {}
//~^ NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
fn main() {
foo::<i64>(42_usize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_u64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_u16);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_u8);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i64);
foo::<i64>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i16);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42_i8);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42.0_f64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<i64>(42.0_f32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
}
src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr
+22 -99
View File
@@ -1,196 +1,119 @@
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:28:16
--> $DIR/numeric-suffix-i64.rs:6:16
|
LL | foo::<i64>(42_usize);
| ---------- ^^^^^^^^ expected `i64`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `i64`, found `usize`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `usize` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:32:16
--> $DIR/numeric-suffix-i64.rs:9:16
|
LL | foo::<i64>(42_u64);
| ---------- ^^^^^^ expected `i64`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i64`, found `u64`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u64` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:36:16
--> $DIR/numeric-suffix-i64.rs:12:16
|
LL | foo::<i64>(42_u32);
| ---------- ^^^^^^ expected `i64`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i64`, found `u32`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u32` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:40:16
--> $DIR/numeric-suffix-i64.rs:15:16
|
LL | foo::<i64>(42_u16);
| ---------- ^^^^^^ expected `i64`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i64`, found `u16`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u16` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:44:16
--> $DIR/numeric-suffix-i64.rs:18:16
|
LL | foo::<i64>(42_u8);
| ---------- ^^^^^ expected `i64`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i64`, found `u8`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u8` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:48:16
--> $DIR/numeric-suffix-i64.rs:21:16
|
LL | foo::<i64>(42_isize);
| ---------- ^^^^^^^^ expected `i64`, found `isize`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `i64`, found `isize`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `isize` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:53:16
--> $DIR/numeric-suffix-i64.rs:25:16
|
LL | foo::<i64>(42_i32);
| ---------- ^^^^^^ expected `i64`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i64`, found `i32`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i32` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:57:16
--> $DIR/numeric-suffix-i64.rs:28:16
|
LL | foo::<i64>(42_i16);
| ---------- ^^^^^^ expected `i64`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `i64`, found `i16`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i16` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:61:16
--> $DIR/numeric-suffix-i64.rs:31:16
|
LL | foo::<i64>(42_i8);
| ---------- ^^^^^ expected `i64`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^^ expected `i64`, found `i8`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i8` to `i64`
|
LL | foo::<i64>(42_i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:65:16
--> $DIR/numeric-suffix-i64.rs:34:16
|
LL | foo::<i64>(42.0_f64);
| ---------- ^^^^^^^^ expected `i64`, found `f64`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `i64`, found `f64`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `f64` to `i64`
|
LL | foo::<i64>(42i64);
| ~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-i64.rs:69:16
--> $DIR/numeric-suffix-i64.rs:37:16
|
LL | foo::<i64>(42.0_f32);
| ---------- ^^^^^^^^ expected `i64`, found `f32`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `i64`, found `f32`
|
note: function defined here
--> $DIR/numeric-suffix-i64.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `f32` to `i64`
|
LL | foo::<i64>(42i64);
src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed
-33
View File
@@ -1,73 +1,40 @@
// run-rustfix
fn foo<N>(_x: N) {}
//~^ NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
fn main() {
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42isize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
}
src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs
-33
View File
@@ -1,73 +1,40 @@
// run-rustfix
fn foo<N>(_x: N) {}
//~^ NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
fn main() {
foo::<isize>(42_usize);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_u64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_u16);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_u8);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_isize);
foo::<isize>(42_i64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_i32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_i16);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42_i8);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42.0_f64);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<isize>(42.0_f32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
}
src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr
+22 -99
View File
@@ -1,196 +1,119 @@
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:28:18
--> $DIR/numeric-suffix-isize.rs:6:18
|
LL | foo::<isize>(42_usize);
| ------------ ^^^^^^^^ expected `isize`, found `usize`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `isize`, found `usize`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `usize` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:32:18
--> $DIR/numeric-suffix-isize.rs:9:18
|
LL | foo::<isize>(42_u64);
| ------------ ^^^^^^ expected `isize`, found `u64`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `isize`, found `u64`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u64` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:36:18
--> $DIR/numeric-suffix-isize.rs:12:18
|
LL | foo::<isize>(42_u32);
| ------------ ^^^^^^ expected `isize`, found `u32`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `isize`, found `u32`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u32` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:40:18
--> $DIR/numeric-suffix-isize.rs:15:18
|
LL | foo::<isize>(42_u16);
| ------------ ^^^^^^ expected `isize`, found `u16`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `isize`, found `u16`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u16` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:44:18
--> $DIR/numeric-suffix-isize.rs:18:18
|
LL | foo::<isize>(42_u8);
| ------------ ^^^^^ expected `isize`, found `u8`
| |
| arguments to this function are incorrect
| ^^^^^ expected `isize`, found `u8`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `u8` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:49:18
--> $DIR/numeric-suffix-isize.rs:22:18
|
LL | foo::<isize>(42_i64);
| ------------ ^^^^^^ expected `isize`, found `i64`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `isize`, found `i64`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i64` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:53:18
--> $DIR/numeric-suffix-isize.rs:25:18
|
LL | foo::<isize>(42_i32);
| ------------ ^^^^^^ expected `isize`, found `i32`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `isize`, found `i32`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i32` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:57:18
--> $DIR/numeric-suffix-isize.rs:28:18
|
LL | foo::<isize>(42_i16);
| ------------ ^^^^^^ expected `isize`, found `i16`
| |
| arguments to this function are incorrect
| ^^^^^^ expected `isize`, found `i16`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i16` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:61:18
--> $DIR/numeric-suffix-isize.rs:31:18
|
LL | foo::<isize>(42_i8);
| ------------ ^^^^^ expected `isize`, found `i8`
| |
| arguments to this function are incorrect
| ^^^^^ expected `isize`, found `i8`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `i8` to `isize`
|
LL | foo::<isize>(42_isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:65:18
--> $DIR/numeric-suffix-isize.rs:34:18
|
LL | foo::<isize>(42.0_f64);
| ------------ ^^^^^^^^ expected `isize`, found `f64`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `isize`, found `f64`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `f64` to `isize`
|
LL | foo::<isize>(42isize);
| ~~~~~
error[E0308]: mismatched types
--> $DIR/numeric-suffix-isize.rs:69:18
--> $DIR/numeric-suffix-isize.rs:37:18
|
LL | foo::<isize>(42.0_f32);
| ------------ ^^^^^^^^ expected `isize`, found `f32`
| |
| arguments to this function are incorrect
| ^^^^^^^^ expected `isize`, found `f32`
|
note: function defined here
--> $DIR/numeric-suffix-isize.rs:3:4
|
LL | fn foo<N>(_x: N) {}
| ^^^ -----
help: change the type of the numeric literal from `f32` to `isize`
|
LL | foo::<isize>(42isize);
src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed
-33
View File
@@ -1,73 +1,40 @@
// run-rustfix
fn foo<N>(_x: N) {}
//~^ NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE function defined here
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
//~| NOTE
fn main() {
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42_u32);
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42_u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
foo::<u32>(42u32);
//~^ ERROR mismatched types
//~| NOTE expected
//~| NOTE arguments
}

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