This attempts to bring better error messages to invalid method calls, by applying some heuristics to identify common mistakes.
The algorithm is inspired by Levenshtein distance and longest common sub-sequence. In essence, we treat the types of the function, and the types of the arguments you provided as two "words" and compute the edits to get from one to the other.
We then modify that algorithm to detect 4 cases:
- A function input is missing
- An extra argument was provided
- The type of an argument is straight up invalid
- Two arguments have been swapped
- A subset of the arguments have been shuffled
(We detect the last two as separate cases so that we can detect two swaps, instead of 4 parameters permuted.)
It helps to understand this argument by paying special attention to terminology: "inputs" refers to the inputs being *expected* by the function, and "arguments" refers to what has been provided at the call site.
The basic sketch of the algorithm is as follows:
- Construct a boolean grid, with a row for each argument, and a column for each input. The cell [i, j] is true if the i'th argument could satisfy the j'th input.
- If we find an argument that could satisfy no inputs, provided for an input that can't be satisfied by any other argument, we consider this an "invalid type".
- Extra arguments are those that can't satisfy any input, provided for an input that *could* be satisfied by another argument.
- Missing inputs are inputs that can't be satisfied by any argument, where the provided argument could satisfy another input
- Swapped / Permuted arguments are identified with a cycle detection algorithm.
As each issue is found, we remove the relevant inputs / arguments and check for more issues. If we find no issues, we match up any "valid" arguments, and start again.
Note that there's a lot of extra complexity:
- We try to stay efficient on the happy path, only computing the diagonal until we find a problem, and then filling in the rest of the matrix.
- Closure arguments are wrapped in a tuple and need to be unwrapped
- We need to resolve closure types after the rest, to allow the most specific type constraints
- We need to handle imported C functions that might be variadic in their inputs.
I tried to document a lot of this in comments in the code and keep the naming clear.
mut values: Option<ValuePairs<'tcx>>,
terr: &TypeError<'tcx>,
swap_secondary_and_primary: bool,
+ force_label: bool,
) {
let span = cause.span(self.tcx);
debug!("note_type_err cause={:?} values={:?}, terr={:?}", cause, values, terr);
TypeError::ObjectUnsafeCoercion(_) => {}
_ => {
let mut label_or_note = |span: Span, msg: &str| {
- if &[span] == diag.span.primary_spans() {
+ if force_label || &[span] == diag.span.primary_spans() {
diag.span_label(span, msg);
} else {
diag.span_note(span, msg);
struct_span_err!(self.tcx.sess, span, E0644, "{}", failure_str)
}
};
- self.note_type_err(&mut diag, &trace.cause, None, Some(trace.values), terr, false);
+ self.note_type_err(&mut diag, &trace.cause, None, Some(trace.values), terr, false, false);
diag
}
}
}
-enum FailureCode {
+pub enum FailureCode {
Error0038(DefId),
Error0317(&'static str),
Error0580(&'static str),
Error0644(&'static str),
}
-trait ObligationCauseExt<'tcx> {
+pub trait ObligationCauseExt<'tcx> {
fn as_failure_code(&self, terr: &TypeError<'tcx>) -> FailureCode;
fn as_requirement_str(&self) -> &'static str;
}
/// See the `error_reporting` module for more details.
#[derive(Clone, Debug)]
pub struct TypeTrace<'tcx> {
- cause: ObligationCause<'tcx>,
- values: ValuePairs<'tcx>,
+ pub cause: ObligationCause<'tcx>,
+ pub values: ValuePairs<'tcx>,
}
/// The origin of a `r1 <= r2` constraint.
}),
_ => None,
};
- self.note_type_err(&mut diag, &obligation.cause, secondary_span, values, err, true);
+ self.note_type_err(
+ &mut diag,
+ &obligation.cause,
+ secondary_span,
+ values,
+ err,
+ true,
+ false,
+ );
self.note_obligation_cause(&mut diag, obligation);
diag.emit();
});
found,
expected,
None,
- coercion_error,
+ Some(coercion_error),
);
}
})),
&terr,
false,
+ false,
);
return Err(diag.emit());
})),
&terr,
false,
+ false,
);
diag.emit();
}
expr_ty: Ty<'tcx>,
expected: Ty<'tcx>,
expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
- error: TypeError<'tcx>,
+ error: Option<TypeError<'tcx>>,
) {
self.annotate_expected_due_to_let_ty(err, expr, error);
self.suggest_deref_ref_or_into(err, expr, expected, expr_ty, expected_ty_expr);
let expr_ty = self.resolve_vars_with_obligations(checked_ty);
let mut err = self.report_mismatched_types(&cause, expected, expr_ty, e.clone());
- self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected, expected_ty_expr, e);
+ self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected, expected_ty_expr, Some(e));
(expected, Some(err))
}
&self,
err: &mut Diagnostic,
expr: &hir::Expr<'_>,
- error: TypeError<'_>,
+ error: Option<TypeError<'_>>,
) {
let parent = self.tcx.hir().get_parent_node(expr.hir_id);
match (self.tcx.hir().find(parent), error) {
Some(hir::Node::Expr(hir::Expr {
kind: hir::ExprKind::Assign(lhs, rhs, _), ..
})),
- TypeError::Sorts(ExpectedFound { expected, .. }),
+ Some(TypeError::Sorts(ExpectedFound { expected, .. })),
) if rhs.hir_id == expr.hir_id && !expected.is_closure() => {
// We ignore closures explicitly because we already point at them elsewhere.
// Point at the assigned-to binding.
}
#[instrument(skip(self, expr), level = "debug")]
- fn check_expr_kind(
+ pub(super) fn check_expr_kind(
&self,
expr: &'tcx hir::Expr<'tcx>,
expected: Expectation<'tcx>,
) {
let tcx = self.tcx;
- let adt_ty_hint = self
- .expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
- .get(0)
- .cloned()
- .unwrap_or(adt_ty);
+ let expected_inputs =
+ self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty]);
+ let adt_ty_hint = if let Some(expected_inputs) = expected_inputs {
+ expected_inputs.get(0).cloned().unwrap_or(adt_ty)
+ } else {
+ adt_ty
+ };
// re-link the regions that EIfEO can erase.
self.demand_eqtype(span, adt_ty_hint, adt_ty);
expected_ret: Expectation<'tcx>,
formal_ret: Ty<'tcx>,
formal_args: &[Ty<'tcx>],
- ) -> Vec<Ty<'tcx>> {
+ ) -> Option<Vec<Ty<'tcx>>> {
let formal_ret = self.resolve_vars_with_obligations(formal_ret);
- let Some(ret_ty) = expected_ret.only_has_type(self) else { return Vec::new() };
+ let Some(ret_ty) = expected_ret.only_has_type(self) else { return None };
// HACK(oli-obk): This is a hack to keep RPIT and TAIT in sync wrt their behaviour.
// Without it, the inference
if let ty::subst::GenericArgKind::Type(ty) = ty.unpack() {
if let ty::Opaque(def_id, _) = *ty.kind() {
if self.infcx.opaque_type_origin(def_id, DUMMY_SP).is_some() {
- return Vec::new();
+ return None;
}
}
}
// Record all the argument types, with the substitutions
// produced from the above subtyping unification.
- Ok(formal_args.iter().map(|&ty| self.resolve_vars_if_possible(ty)).collect())
+ Ok(Some(formal_args.iter().map(|&ty| self.resolve_vars_if_possible(ty)).collect()))
})
.unwrap_or_default();
debug!(?formal_args, ?formal_ret, ?expect_args, ?expected_ret);
--- /dev/null
+use std::cmp;
+
+use rustc_middle::ty::error::TypeError;
+
+// An issue that might be found in the compatibility matrix
+enum Issue {
+ /// The given argument is the invalid type for the input
+ Invalid(usize),
+ /// There is a missing input
+ Missing(usize),
+ /// There's a superfluous argument
+ Extra(usize),
+ /// Two arguments should be swapped
+ Swap(usize, usize),
+ /// Several arguments should be reordered
+ Permutation(Vec<Option<usize>>),
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum Compatibility<'tcx> {
+ Compatible,
+ Incompatible(Option<TypeError<'tcx>>),
+}
+
+/// Similar to `Issue`, but contains some extra information
+pub(crate) enum Error<'tcx> {
+ /// The given argument is the invalid type for the input
+ Invalid(usize, Compatibility<'tcx>),
+ /// There is a missing input
+ Missing(usize),
+ /// There's a superfluous argument
+ Extra(usize),
+ /// Two arguments should be swapped
+ Swap(usize, usize, usize, usize),
+ /// Several arguments should be reordered
+ Permutation(Vec<(usize, usize)>), // dest_arg, dest_input
+}
+
+pub(crate) struct ArgMatrix<'tcx> {
+ input_indexes: Vec<usize>,
+ arg_indexes: Vec<usize>,
+ compatibility_matrix: Vec<Vec<Compatibility<'tcx>>>,
+}
+
+impl<'tcx> ArgMatrix<'tcx> {
+ pub(crate) fn new<F: FnMut(usize, usize) -> Compatibility<'tcx>>(
+ minimum_input_count: usize,
+ provided_arg_count: usize,
+ mut is_compatible: F,
+ ) -> Self {
+ let compatibility_matrix = (0..provided_arg_count)
+ .map(|i| (0..minimum_input_count).map(|j| is_compatible(i, j)).collect())
+ .collect();
+ ArgMatrix {
+ input_indexes: (0..minimum_input_count).collect(),
+ arg_indexes: (0..provided_arg_count).collect(),
+ compatibility_matrix,
+ }
+ }
+
+ /// Remove a given input from consideration
+ fn eliminate_input(&mut self, idx: usize) {
+ self.input_indexes.remove(idx);
+ for row in &mut self.compatibility_matrix {
+ row.remove(idx);
+ }
+ }
+
+ /// Remove a given argument from consideration
+ fn eliminate_arg(&mut self, idx: usize) {
+ self.arg_indexes.remove(idx);
+ self.compatibility_matrix.remove(idx);
+ }
+
+ /// "satisfy" an input with a given arg, removing both from consideration
+ fn satisfy_input(&mut self, input_idx: usize, arg_idx: usize) {
+ self.eliminate_input(input_idx);
+ self.eliminate_arg(arg_idx);
+ }
+
+ fn eliminate_satisfied(&mut self) -> Vec<(usize, usize)> {
+ let mut i = cmp::min(self.input_indexes.len(), self.arg_indexes.len());
+ let mut eliminated = vec![];
+ while i > 0 {
+ let idx = i - 1;
+ if matches!(self.compatibility_matrix[idx][idx], Compatibility::Compatible) {
+ eliminated.push((self.arg_indexes[idx], self.input_indexes[idx]));
+ self.satisfy_input(idx, idx);
+ }
+ i -= 1;
+ }
+ return eliminated;
+ }
+
+ // Check for the above mismatch cases
+ fn find_issue(&self) -> Option<Issue> {
+ let mat = &self.compatibility_matrix;
+ let ai = &self.arg_indexes;
+ let ii = &self.input_indexes;
+
+ for i in 0..cmp::max(ai.len(), ii.len()) {
+ // If we eliminate the last row, any left-over inputs are considered missing
+ if i >= mat.len() {
+ return Some(Issue::Missing(i));
+ }
+ // If we eliminate the last column, any left-over arguments are extra
+ if mat[i].len() == 0 {
+ return Some(Issue::Extra(i));
+ }
+
+ // Make sure we don't pass the bounds of our matrix
+ let is_arg = i < ai.len();
+ let is_input = i < ii.len();
+ if is_arg && is_input && matches!(mat[i][i], Compatibility::Compatible) {
+ // This is a satisfied input, so move along
+ continue;
+ }
+
+ let mut useless = true;
+ let mut unsatisfiable = true;
+ if is_arg {
+ for j in 0..ii.len() {
+ // If we find at least one input this argument could satisfy
+ // this argument isn't completely useless
+ if matches!(mat[i][j], Compatibility::Compatible) {
+ useless = false;
+ break;
+ }
+ }
+ }
+ if is_input {
+ for j in 0..ai.len() {
+ // If we find at least one argument that could satisfy this input
+ // this argument isn't unsatisfiable
+ if matches!(mat[j][i], Compatibility::Compatible) {
+ unsatisfiable = false;
+ break;
+ }
+ }
+ }
+
+ match (is_arg, is_input, useless, unsatisfiable) {
+ // If an input is unsatisfied, and the argument in its position is useless
+ // then the most likely explanation is that we just got the types wrong
+ (true, true, true, true) => return Some(Issue::Invalid(i)),
+ // Otherwise, if an input is useless, then indicate that this is an extra argument
+ (true, _, true, _) => return Some(Issue::Extra(i)),
+ // Otherwise, if an argument is unsatisfiable, indicate that it's missing
+ (_, true, _, true) => return Some(Issue::Missing(i)),
+ (true, true, _, _) => {
+ // The argument isn't useless, and the input isn't unsatisfied,
+ // so look for a parameter we might swap it with
+ // We look for swaps explicitly, instead of just falling back on permutations
+ // so that cases like (A,B,C,D) given (B,A,D,C) show up as two swaps,
+ // instead of a large permutation of 4 elements.
+ for j in 0..cmp::min(ai.len(), ii.len()) {
+ if i == j || matches!(mat[j][j], Compatibility::Compatible) {
+ continue;
+ }
+ if matches!(mat[i][j], Compatibility::Compatible)
+ && matches!(mat[j][i], Compatibility::Compatible)
+ {
+ return Some(Issue::Swap(i, j));
+ }
+ }
+ }
+ _ => {
+ continue;
+ }
+ };
+ }
+
+ // We didn't find any of the individual issues above, but
+ // there might be a larger permutation of parameters, so we now check for that
+ // by checking for cycles
+ // We use a double option at position i in this vec to represent:
+ // - None: We haven't computed anything about this argument yet
+ // - Some(None): This argument definitely doesn't participate in a cycle
+ // - Some(Some(x)): the i-th argument could permute to the x-th position
+ let mut permutation: Vec<Option<Option<usize>>> = vec![None; mat.len()];
+ let mut permutation_found = false;
+ for i in 0..mat.len() {
+ if permutation[i].is_some() {
+ // We've already decided whether this argument is or is not in a loop
+ continue;
+ }
+
+ let mut stack = vec![];
+ let mut j = i;
+ let mut last = i;
+ let mut is_cycle = true;
+ loop {
+ stack.push(j);
+ // Look for params this one could slot into
+ let compat: Vec<_> =
+ mat[j]
+ .iter()
+ .enumerate()
+ .filter_map(|(i, c)| {
+ if matches!(c, Compatibility::Compatible) { Some(i) } else { None }
+ })
+ .collect();
+ if compat.len() != 1 {
+ // this could go into multiple slots, don't bother exploring both
+ is_cycle = false;
+ break;
+ }
+ j = compat[0];
+ if stack.contains(&j) {
+ last = j;
+ break;
+ }
+ }
+ if stack.len() <= 2 {
+ // If we encounter a cycle of 1 or 2 elements, we'll let the
+ // "satisfy" and "swap" code above handle those
+ is_cycle = false;
+ }
+ // We've built up some chain, some of which might be a cycle
+ // ex: [1,2,3,4]; last = 2; j = 2;
+ // So, we want to mark 4, 3, and 2 as part of a permutation
+ permutation_found = is_cycle;
+ while let Some(x) = stack.pop() {
+ if is_cycle {
+ permutation[x] = Some(Some(j));
+ j = x;
+ if j == last {
+ // From here on out, we're a tail leading into a cycle,
+ // not the cycle itself
+ is_cycle = false;
+ }
+ } else {
+ // Some(None) ensures we save time by skipping this argument again
+ permutation[x] = Some(None);
+ }
+ }
+ }
+
+ if permutation_found {
+ // Map unwrap to remove the first layer of Some
+ let final_permutation: Vec<Option<usize>> =
+ permutation.into_iter().map(|x| x.unwrap()).collect();
+ return Some(Issue::Permutation(final_permutation));
+ }
+ return None;
+ }
+
+ // Obviously, detecting exact user intention is impossible, so the goal here is to
+ // come up with as likely of a story as we can to be helpful.
+ //
+ // We'll iteratively removed "satisfied" input/argument pairs,
+ // then check for the cases above, until we've eliminated the entire grid
+ //
+ // We'll want to know which arguments and inputs these rows and columns correspond to
+ // even after we delete them.
+ pub(crate) fn find_errors(mut self) -> (Vec<Error<'tcx>>, Vec<Option<usize>>) {
+ let provided_arg_count = self.arg_indexes.len();
+
+ let mut errors: Vec<Error<'tcx>> = vec![];
+ // For each expected argument, the matched *actual* input
+ let mut matched_inputs: Vec<Option<usize>> = vec![None; self.input_indexes.len()];
+
+ // Before we start looking for issues, eliminate any arguments that are already satisfied,
+ // so that an argument which is already spoken for by the input it's in doesn't
+ // spill over into another similarly typed input
+ // ex:
+ // fn some_func(_a: i32, _b: i32) {}
+ // some_func(1, "");
+ // Without this elimination, the first argument causes the second argument
+ // to show up as both a missing input and extra argument, rather than
+ // just an invalid type.
+ for (arg, inp) in self.eliminate_satisfied() {
+ matched_inputs[inp] = Some(arg);
+ }
+
+ while self.input_indexes.len() > 0 || self.arg_indexes.len() > 0 {
+ // Check for the first relevant issue
+ match self.find_issue() {
+ Some(Issue::Invalid(idx)) => {
+ let compatibility = self.compatibility_matrix[idx][idx].clone();
+ let input_idx = self.input_indexes[idx];
+ self.satisfy_input(idx, idx);
+ errors.push(Error::Invalid(input_idx, compatibility));
+ }
+ Some(Issue::Extra(idx)) => {
+ let arg_idx = self.arg_indexes[idx];
+ self.eliminate_arg(idx);
+ errors.push(Error::Extra(arg_idx));
+ }
+ Some(Issue::Missing(idx)) => {
+ let input_idx = self.input_indexes[idx];
+ self.eliminate_input(idx);
+ errors.push(Error::Missing(input_idx));
+ }
+ Some(Issue::Swap(idx, other)) => {
+ let input_idx = self.input_indexes[idx];
+ let other_input_idx = self.input_indexes[other];
+ let arg_idx = self.arg_indexes[idx];
+ let other_arg_idx = self.arg_indexes[other];
+ let (min, max) = (cmp::min(idx, other), cmp::max(idx, other));
+ self.satisfy_input(min, max);
+ // Subtract 1 because we already removed the "min" row
+ self.satisfy_input(max - 1, min);
+ errors.push(Error::Swap(input_idx, other_input_idx, arg_idx, other_arg_idx));
+ matched_inputs[input_idx] = Some(other_arg_idx);
+ matched_inputs[other_input_idx] = Some(arg_idx);
+ }
+ Some(Issue::Permutation(args)) => {
+ // FIXME: If satisfy_input ever did anything non-trivial (emit obligations to help type checking, for example)
+ // we'd want to call this function with the correct arg/input pairs, but for now, we just throw them in a bucket.
+ // This works because they force a cycle, so each row is guaranteed to also be a column
+ let mut idxs: Vec<usize> = args.iter().filter_map(|&a| a).collect();
+
+ let mut real_idxs = vec![None; provided_arg_count];
+ for (src, dst) in
+ args.iter().enumerate().filter_map(|(src, dst)| dst.map(|dst| (src, dst)))
+ {
+ let src_arg = self.arg_indexes[src];
+ let dst_arg = self.arg_indexes[dst];
+ let dest_input = self.input_indexes[dst];
+ real_idxs[src_arg] = Some((dst_arg, dest_input));
+ matched_inputs[dest_input] = Some(src_arg);
+ }
+ idxs.sort();
+ idxs.reverse();
+ for i in idxs {
+ self.satisfy_input(i, i);
+ }
+ errors.push(Error::Permutation(real_idxs.into_iter().flatten().collect()));
+ }
+ None => {
+ // We didn't find any issues, so we need to push the algorithm forward
+ // First, eliminate any arguments that currently satisfy their inputs
+ for (arg, inp) in self.eliminate_satisfied() {
+ matched_inputs[inp] = Some(arg);
+ }
+ }
+ };
+ }
+
+ return (errors, matched_inputs);
+ }
+}
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::*;
potentially_plural_count, struct_span_err, BreakableCtxt, Diverges, Expectation, FnCtxt,
LocalTy, Needs, TupleArgumentsFlag,
};
+use crate::structured_errors::StructuredDiagnostic;
use rustc_ast as ast;
use rustc_data_structures::sync::Lrc;
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};
use rustc_session::Session;
use rustc_span::{self, Span};
use rustc_trait_selection::traits::{self, ObligationCauseCode, StatementAsExpression};
-use crate::structured_errors::StructuredDiagnostic;
use std::iter;
use std::slice;
-struct FnArgsAsTuple<'hir> {
- first: &'hir hir::Expr<'hir>,
- last: &'hir hir::Expr<'hir>,
+enum TupleMatchFound {
+ None,
+ Single,
+ /// Beginning and end Span
+ Multiple(Span, Span),
}
-
impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub(in super::super) fn check_casts(&self) {
let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
sp,
expr,
&err_inputs,
- vec![],
+ None,
args_no_rcvr,
false,
tuple_arguments,
// Types (as defined in the *signature* of the target function)
formal_input_tys: &[Ty<'tcx>],
// More specific expected types, after unifying with caller output types
- expected_input_tys: Vec<Ty<'tcx>>,
+ expected_input_tys: Option<Vec<Ty<'tcx>>>,
// The expressions for each provided argument
provided_args: &'tcx [hir::Expr<'tcx>],
// Whether the function is variadic, for example when imported from C
fn_def_id: Option<DefId>,
) {
let tcx = self.tcx;
- // Grab the argument types, supplying fresh type variables
- // if the wrong number of arguments were supplied
- let supplied_arg_count =
- if tuple_arguments == DontTupleArguments { provided_args.len() } else { 1 };
+
+ // Conceptually, we've got some number of expected inputs, and some number of provided aguments
+ // and we can form a grid of whether each argument could satisfy a given input:
+ // in1 | in2 | in3 | ...
+ // arg1 ? | | |
+ // arg2 | ? | |
+ // arg3 | | ? |
+ // ...
+ // Initially, we just check the diagonal, because in the case of correct code
+ // these are the only checks that matter
+ // However, in the unhappy path, we'll fill in this whole grid to attempt to provide
+ // better error messages about invalid method calls.
// All the input types from the fn signature must outlive the call
// so as to validate implied bounds.
self.register_wf_obligation(fn_input_ty.into(), arg_expr.span, traits::MiscObligation);
}
- let expected_arg_count = formal_input_tys.len();
-
- // expected_count, arg_count, error_code, sugg_unit, sugg_tuple_wrap_args
- let mut arg_count_error: Option<(usize, usize, &str, bool, Option<FnArgsAsTuple<'_>>)> =
- None;
+ let mut err_code = "E0061";
// If the arguments should be wrapped in a tuple (ex: closures), unwrap them here
let (formal_input_tys, expected_input_tys) = if tuple_arguments == TupleArguments {
ty::Tuple(arg_types) => {
// Argument length differs
if arg_types.len() != provided_args.len() {
- arg_count_error =
- Some((arg_types.len(), provided_args.len(), "E0057", false, None));
+ err_code = "E0057";
}
- let expected_input_tys = match expected_input_tys.get(0) {
- Some(&ty) => match ty.kind() {
- ty::Tuple(tys) => tys.iter().collect(),
- _ => vec![],
+ let expected_input_tys = match expected_input_tys {
+ Some(expected_input_tys) => match expected_input_tys.get(0) {
+ Some(ty) => match ty.kind() {
+ ty::Tuple(tys) => Some(tys.iter().collect()),
+ _ => None,
+ },
+ None => None,
},
- None => vec![],
+ None => None,
};
(arg_types.iter().collect(), expected_input_tys)
}
for the function trait is neither a tuple nor unit"
)
.emit();
- (self.err_args(provided_args.len()), vec![])
+ (self.err_args(provided_args.len()), None)
}
}
- } else if expected_arg_count == supplied_arg_count {
- (formal_input_tys.to_vec(), expected_input_tys)
- } else if c_variadic {
- if supplied_arg_count >= expected_arg_count {
- (formal_input_tys.to_vec(), expected_input_tys)
- } else {
- arg_count_error =
- Some((expected_arg_count, supplied_arg_count, "E0060", false, None));
- (self.err_args(supplied_arg_count), vec![])
- }
} else {
- // is the missing argument of type `()`?
- let sugg_unit = if expected_input_tys.len() == 1 && supplied_arg_count == 0 {
- self.resolve_vars_if_possible(expected_input_tys[0]).is_unit()
- } else if formal_input_tys.len() == 1 && supplied_arg_count == 0 {
- self.resolve_vars_if_possible(formal_input_tys[0]).is_unit()
- } else {
- false
- };
-
- // are we passing elements of a tuple without the tuple parentheses?
- let expected_input_tys = if expected_input_tys.is_empty() {
- // In most cases we can use expected_input_tys, but some callers won't have the type
- // information, in which case we fall back to the types from the input expressions.
- formal_input_tys
- } else {
- &*expected_input_tys
- };
-
- let sugg_tuple_wrap_args = self.suggested_tuple_wrap(expected_input_tys, provided_args);
-
- arg_count_error = Some((
- expected_arg_count,
- supplied_arg_count,
- "E0061",
- sugg_unit,
- sugg_tuple_wrap_args,
- ));
- (self.err_args(supplied_arg_count), vec![])
+ (formal_input_tys.to_vec(), expected_input_tys)
};
- debug!(
- "check_argument_types: formal_input_tys={:?}",
- formal_input_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>()
- );
-
- // If there is no expectation, expect formal_input_tys.
- let expected_input_tys = if !expected_input_tys.is_empty() {
+ // If there are no external expectations at the call site, just use the types from the function defn
+ let expected_input_tys = if let Some(expected_input_tys) = expected_input_tys {
+ assert_eq!(expected_input_tys.len(), formal_input_tys.len());
expected_input_tys
} else {
formal_input_tys.clone()
};
- assert_eq!(expected_input_tys.len(), formal_input_tys.len());
-
- let provided_arg_count: usize = provided_args.len();
+ let minimum_input_count = expected_input_tys.len();
+ let provided_arg_count = provided_args.len();
- // Keep track of the fully coerced argument types
+ // We'll also want to keep track of the fully coerced argument types, for an awkward hack near the end
let mut final_arg_types: Vec<Option<(Ty<'_>, Ty<'_>)>> = vec![None; provided_arg_count];
// We introduce a helper function to demand that a given argument satisfy a given input
debug!("checking argument {}: {:?} = {:?}", idx, provided_arg, formal_input_ty);
- // The special-cased logic below has three functions:
- // 1. Provide as good of an expected type as possible.
+ // We're on the happy path here, so we'll do a more involved check and write back types
+ // To check compatibility, we'll do 3 things:
+ // 1. Unify the provided argument with the expected type
let expectation = Expectation::rvalue_hint(self, expected_input_ty);
let checked_ty = self.check_expr_with_expectation(provided_arg, expectation);
final_arg_types[idx] = Some((checked_ty, coerced_ty));
// Cause selection errors caused by resolving a single argument to point at the
- // argument and not the call. This is otherwise redundant with the `demand_coerce`
- // call immediately after, but it lets us customize the span pointed to in the
+ // argument and not the call. This lets us customize the span pointed to in the
// fulfillment error to be more accurate.
let coerced_ty =
self.resolve_vars_with_obligations_and_mutate_fulfillment(coerced_ty, |errors| {
);
});
+ // Make sure we store the resolved type
final_arg_types[idx] = Some((checked_ty, coerced_ty));
- // We're processing function arguments so we definitely want to use
- // two-phase borrows.
- self.demand_coerce(&provided_arg, checked_ty, coerced_ty, None, AllowTwoPhase::Yes);
+ let coerce_error = self
+ .try_coerce(provided_arg, checked_ty, coerced_ty, AllowTwoPhase::Yes, None)
+ .err();
+
+ if coerce_error.is_some() {
+ return Compatibility::Incompatible(coerce_error);
+ }
+
+ // 3. Check if the formal type is a supertype of the checked one
+ // and register any such obligations for future type checks
+ let supertype_error = self
+ .at(&self.misc(provided_arg.span), self.param_env)
+ .sup(formal_input_ty, coerced_ty);
+ let subtyping_error = match supertype_error {
+ Ok(InferOk { obligations, value: () }) => {
+ self.register_predicates(obligations);
+ None
+ }
+ Err(err) => Some(err),
+ };
- // 3. Relate the expected type and the formal one,
- // if the expected type was used for the coercion.
- self.demand_suptype(provided_arg.span, formal_input_ty, coerced_ty);
+ // If neither check failed, the types are compatible
+ match subtyping_error {
+ None => Compatibility::Compatible,
+ Some(_) => Compatibility::Incompatible(subtyping_error),
+ }
};
- let minimum_input_count = formal_input_tys.len();
+ // A "softer" version of the helper above, which checks types without persisting them,
+ // and treats error types differently
+ // This will allow us to "probe" for other argument orders that would likely have been correct
+ let check_compatible = |arg_idx, input_idx| {
+ let formal_input_ty: Ty<'tcx> = formal_input_tys[input_idx];
+ let expected_input_ty: Ty<'tcx> = expected_input_tys[input_idx];
+
+ // If either is an error type, we defy the usual convention and consider them to *not* be
+ // coercible. This prevents our error message heuristic from trying to pass errors into
+ // every argument.
+ if formal_input_ty.references_error() || expected_input_ty.references_error() {
+ return Compatibility::Incompatible(None);
+ }
+
+ let provided_arg: &hir::Expr<'tcx> = &provided_args[arg_idx];
+ let expectation = Expectation::rvalue_hint(self, expected_input_ty);
+ // FIXME: check that this is safe; I don't believe this commits any of the obligations, but I can't be sure.
+ //
+ // I had another method of "soft" type checking before,
+ // but it was failing to find the type of some expressions (like "")
+ // so I prodded this method and made it pub(super) so I could call it, and it seems to work well.
+ let checked_ty = self.check_expr_kind(provided_arg, expectation);
+
+ let coerced_ty = expectation.only_has_type(self).unwrap_or(formal_input_ty);
+ let can_coerce = self.can_coerce(checked_ty, coerced_ty);
+
+ if !can_coerce {
+ return Compatibility::Incompatible(None);
+ }
+
+ let subtyping_result = self
+ .at(&self.misc(provided_arg.span), self.param_env)
+ .sup(formal_input_ty, coerced_ty);
+
+ // Same as above: if either the coerce type or the checked type is an error type,
+ // consider them *not* compatible.
+ let coercible =
+ !coerced_ty.references_error() && !checked_ty.references_error() && can_coerce;
+
+ match (coercible, &subtyping_result) {
+ (true, Ok(_)) => Compatibility::Compatible,
+ _ => Compatibility::Incompatible(subtyping_result.err()),
+ }
+ };
+
+ // To start, we only care "along the diagonal", where we expect every
+ // provided arg to be in the right spot
+ let mut compatibility = vec![Compatibility::Incompatible(None); provided_args.len()];
+
+ // Keep track of whether we *could possibly* be satisfied, i.e. whether we're on the happy path
+ // if the wrong number of arguments were supplied, we CAN'T be satisfied,
+ // and if we're c_variadic, the supplied arguments must be >= the minimum count from the function
+ // otherwise, they need to be identical, because rust doesn't currently support variadic functions
+ let mut call_appears_satisfied = if c_variadic {
+ provided_arg_count >= minimum_input_count
+ } else {
+ provided_arg_count == minimum_input_count
+ };
// Check the arguments.
// We do this in a pretty awful way: first we type-check any arguments
})
}
+ // Check each argument, to satisfy the input it was provided for
+ // Visually, we're traveling down the diagonal of the compatibility matrix
for (idx, arg) in provided_args.iter().enumerate() {
// Warn only for the first loop (the "no closures" one).
// Closure arguments themselves can't be diverging, but
continue;
}
- demand_compatible(idx, &mut final_arg_types);
+ let compatible = demand_compatible(idx, &mut final_arg_types);
+ let is_compatible = matches!(compatible, Compatibility::Compatible);
+ compatibility[idx] = compatible;
+
+ if !is_compatible {
+ call_appears_satisfied = false;
+ }
}
}
- // If there was an error in parameter count, emit that here
- if let Some((expected_count, arg_count, err_code, sugg_unit, sugg_tuple_wrap_args)) =
- arg_count_error
- {
- let (span, start_span, args, ctor_of) = match &call_expr.kind {
+ // Logic here is a bit hairy
+ 'errors: {
+ // If something above didn't typecheck, we've fallen off the happy path
+ // and we should make some effort to provide better error messages
+ if call_appears_satisfied {
+ break 'errors;
+ }
+
+ // The algorithm here is inspired by levenshtein distance and longest common subsequence.
+ // We'll try to detect 4 different types of mistakes:
+ // - An extra parameter has been provided that doesn't satisfy *any* of the other inputs
+ // - An input is missing, which isn't satisfied by *any* of the other arguments
+ // - Some number of arguments have been provided in the wrong order
+ // - A type is straight up invalid
+
+ // First, let's find the errors
+ let mut compatibility: Vec<_> = compatibility.into_iter().map(Some).collect();
+ let (mut errors, matched_inputs) =
+ ArgMatrix::new(minimum_input_count, provided_arg_count, |i, j| {
+ if i == j { compatibility[i].take().unwrap() } else { check_compatible(i, j) }
+ })
+ .find_errors();
+
+ // Okay, so here's where it gets complicated in regards to what errors
+ // we emit and how.
+ // There are 3 different "types" of errors we might encounter.
+ // 1) Missing/extra/swapped arguments
+ // 2) Valid but incorrect arguments
+ // 3) Invalid arguments
+ // - Currently I think this only comes up with `CyclicTy`
+ //
+ // We first need to go through, remove those from (3) and emit those
+ // as their own error, particularly since they're error code and
+ // message is special. From what I can tell, we *must* emit these
+ // here (vs somewhere prior to this function) since the arguments
+ // become invalid *because* of how they get used in the function.
+ // It is what it is.
+
+ let found_errors = !errors.is_empty();
+
+ errors.drain_filter(|error| {
+ let Error::Invalid(input_idx, Compatibility::Incompatible(error)) = error else { return false };
+ let expected_ty = expected_input_tys[*input_idx];
+ let provided_ty = final_arg_types[*input_idx].map(|ty| ty.0).unwrap();
+ let cause = &self.misc(provided_args[*input_idx].span);
+ let trace = TypeTrace::types(cause, true, expected_ty, provided_ty);
+ if let Some(e) = error {
+ if !matches!(trace.cause.as_failure_code(e), FailureCode::Error0308(_)) {
+ self.report_and_explain_type_error(trace, e).emit();
+ return true;
+ }
+ }
+ false
+ });
+
+ // We're done if we found errors, but we already emitted them.
+ // I don't think we *should* be able to enter this bit of code
+ // (`!call_appears_satisfied`) without *also* finding errors, but we
+ // don't want to accidentally not emit an error if there is some
+ // logic bug in the `ArgMatrix` code.
+ if found_errors && errors.is_empty() {
+ break 'errors;
+ }
+
+ // Next, let's construct the error
+ let (error_span, full_call_span, ctor_of) = match &call_expr.kind {
hir::ExprKind::Call(
hir::Expr {
span,
)),
..
},
- args,
- ) => (*span, *span, &args[..], Some(of)),
- hir::ExprKind::Call(hir::Expr { span, .. }, args) => {
- (*span, *span, &args[..], None)
+ _,
+ ) => (call_span, *span, Some(of)),
+ hir::ExprKind::Call(hir::Expr { span, .. }, _) => (call_span, *span, None),
+ hir::ExprKind::MethodCall(path_segment, _, span) => {
+ let ident_span = path_segment.ident.span;
+ let ident_span = if let Some(args) = path_segment.args {
+ ident_span.with_hi(args.span_ext.hi())
+ } else {
+ ident_span
+ };
+ (
+ *span, ident_span, None, // methods are never ctors
+ )
}
- hir::ExprKind::MethodCall(path_segment, args, _) => (
- path_segment.ident.span,
- // `sp` doesn't point at the whole `foo.bar()`, only at `bar`.
- path_segment
- .args
- .and_then(|args| args.args.iter().last())
- // Account for `foo.bar::<T>()`.
- .map(|arg| {
- // Skip the closing `>`.
- tcx.sess
- .source_map()
- .next_point(tcx.sess.source_map().next_point(arg.span()))
- })
- .unwrap_or(path_segment.ident.span),
- &args[1..], // Skip the receiver.
- None, // methods are never ctors
- ),
k => span_bug!(call_span, "checking argument types on a non-call: `{:?}`", k),
};
- let arg_spans = if provided_args.is_empty() {
- // foo()
- // ^^^-- supplied 0 arguments
- // |
- // expected 2 arguments
- vec![tcx.sess.source_map().next_point(start_span).with_hi(call_span.hi())]
- } else {
- // foo(1, 2, 3)
- // ^^^ - - - supplied 3 arguments
- // |
- // expected 2 arguments
- args.iter().map(|arg| arg.span).collect::<Vec<Span>>()
- };
+ let args_span = error_span.trim_start(full_call_span).unwrap_or(error_span);
let call_name = match ctor_of {
Some(CtorOf::Struct) => "struct",
Some(CtorOf::Variant) => "enum variant",
None => "function",
};
- let mut err = tcx.sess.struct_span_err_with_code(
- span,
- &format!(
- "this {} takes {}{} but {} {} supplied",
+ if c_variadic && provided_arg_count < minimum_input_count {
+ err_code = "E0060";
+ }
+
+ // Next special case: The case where we expect a single tuple and
+ // wrapping all the args in parentheses (or adding a comma to
+ // already existing parentheses) will result in a tuple that
+ // satisfies the call.
+ // This isn't super ideal code, because we copy code from elsewhere
+ // and somewhat duplicate this. We also delegate to the general type
+ // mismatch suggestions for the single arg case.
+ let sugg_tuple_wrap_args =
+ self.suggested_tuple_wrap(&expected_input_tys, provided_args);
+ match sugg_tuple_wrap_args {
+ TupleMatchFound::None => {}
+ TupleMatchFound::Single => {
+ let expected_ty = expected_input_tys[0];
+ let provided_ty = final_arg_types[0].map(|ty| ty.0).unwrap();
+ let cause = &self.misc(provided_args[0].span);
+ let compatibility = demand_compatible(0, &mut final_arg_types);
+ let type_error = match compatibility {
+ Compatibility::Incompatible(Some(error)) => error,
+ _ => TypeError::Mismatch,
+ };
+ let trace = TypeTrace::types(cause, true, expected_ty, provided_ty);
+ let mut err = self.report_and_explain_type_error(trace, &type_error);
+ self.emit_coerce_suggestions(
+ &mut err,
+ &provided_args[0],
+ final_arg_types[0].map(|ty| ty.0).unwrap(),
+ final_arg_types[0].map(|ty| ty.1).unwrap(),
+ None,
+ None,
+ );
+ err.span_label(
+ full_call_span,
+ format!("arguments to this {} are incorrect", call_name),
+ );
+ // Call out where the function is defined
+ if let Some(def_id) = fn_def_id && let Some(def_span) = tcx.def_ident_span(def_id) {
+ let mut spans: MultiSpan = def_span.into();
+
+ let params = tcx
+ .hir()
+ .get_if_local(def_id)
+ .and_then(|node| node.body_id())
+ .into_iter()
+ .map(|id| tcx.hir().body(id).params)
+ .flatten();
+
+ for param in params {
+ spans.push_span_label(param.span, String::new());
+ }
+
+ let def_kind = tcx.def_kind(def_id);
+ err.span_note(spans, &format!("{} defined here", def_kind.descr(def_id)));
+ }
+ err.emit();
+ break 'errors;
+ }
+ TupleMatchFound::Multiple(start, end) => {
+ let mut err = tcx.sess.struct_span_err_with_code(
+ full_call_span,
+ &format!(
+ "this {} takes {}{} but {} {} supplied",
+ call_name,
+ if c_variadic { "at least " } else { "" },
+ potentially_plural_count(minimum_input_count, "argument"),
+ potentially_plural_count(provided_arg_count, "argument"),
+ if provided_arg_count == 1 { "was" } else { "were" }
+ ),
+ DiagnosticId::Error(err_code.to_owned()),
+ );
+ // Call out where the function is defined
+ if let Some(def_id) = fn_def_id && let Some(def_span) = tcx.def_ident_span(def_id) {
+ let mut spans: MultiSpan = def_span.into();
+
+ let params = tcx
+ .hir()
+ .get_if_local(def_id)
+ .and_then(|node| node.body_id())
+ .into_iter()
+ .map(|id| tcx.hir().body(id).params)
+ .flatten();
+
+ for param in params {
+ spans.push_span_label(param.span, String::new());
+ }
+
+ let def_kind = tcx.def_kind(def_id);
+ err.span_note(spans, &format!("{} defined here", def_kind.descr(def_id)));
+ }
+ err.multipart_suggestion(
+ "use parentheses to construct a tuple",
+ vec![(start, '('.to_string()), (end, ')'.to_string())],
+ Applicability::MachineApplicable,
+ );
+ err.emit();
+ break 'errors;
+ }
+ }
+
+ // Okay, now that we've emitted the special errors separately, we
+ // are only left missing/extra/swapped and mismatched arguments, both
+ // can be collated pretty easily if needed.
+
+ // Next special case: if there is only one "Incompatible" error, just emit that
+ if errors.len() == 1 {
+ if let Some(Error::Invalid(input_idx, Compatibility::Incompatible(Some(error)))) =
+ errors.iter().next()
+ {
+ let expected_ty = expected_input_tys[*input_idx];
+ let provided_ty = final_arg_types[*input_idx].map(|ty| ty.0).unwrap();
+ let cause = &self.misc(provided_args[*input_idx].span);
+ let trace = TypeTrace::types(cause, true, expected_ty, provided_ty);
+ let mut err = self.report_and_explain_type_error(trace, error);
+ self.emit_coerce_suggestions(
+ &mut err,
+ &provided_args[*input_idx],
+ final_arg_types[*input_idx].map(|ty| ty.0).unwrap(),
+ final_arg_types[*input_idx].map(|ty| ty.1).unwrap(),
+ None,
+ None,
+ );
+ err.span_label(
+ full_call_span,
+ format!("arguments to this {} are incorrect", call_name),
+ );
+ // Call out where the function is defined
+ if let Some(def_id) = fn_def_id && let Some(def_span) = tcx.def_ident_span(def_id) {
+ let mut spans: MultiSpan = def_span.into();
+
+ let params = tcx
+ .hir()
+ .get_if_local(def_id)
+ .and_then(|node| node.body_id())
+ .into_iter()
+ .map(|id| tcx.hir().body(id).params)
+ .flatten();
+
+ for param in params {
+ spans.push_span_label(param.span, String::new());
+ }
+
+ let def_kind = tcx.def_kind(def_id);
+ err.span_note(spans, &format!("{} defined here", def_kind.descr(def_id)));
+ }
+ err.emit();
+ break 'errors;
+ }
+ }
+
+ let mut err = if minimum_input_count == provided_arg_count {
+ struct_span_err!(
+ tcx.sess,
+ full_call_span,
+ E0308,
+ "arguments to this {} are incorrect",
call_name,
- if c_variadic { "at least " } else { "" },
- potentially_plural_count(expected_count, "argument"),
- potentially_plural_count(arg_count, "argument"),
- if arg_count == 1 { "was" } else { "were" }
- ),
- DiagnosticId::Error(err_code.to_owned()),
- );
- let label = format!("supplied {}", potentially_plural_count(arg_count, "argument"));
- for (i, span) in arg_spans.into_iter().enumerate() {
- err.span_label(
- span,
- if arg_count == 0 || i + 1 == arg_count { &label } else { "" },
- );
+ )
+ } else {
+ tcx.sess.struct_span_err_with_code(
+ full_call_span,
+ &format!(
+ "this {} takes {}{} but {} {} supplied",
+ call_name,
+ if c_variadic { "at least " } else { "" },
+ potentially_plural_count(minimum_input_count, "argument"),
+ potentially_plural_count(provided_arg_count, "argument"),
+ if provided_arg_count == 1 { "was" } else { "were" }
+ ),
+ DiagnosticId::Error(err_code.to_owned()),
+ )
+ };
+
+ // As we encounter issues, keep track of what we want to provide for the suggestion
+ let mut labels = vec![];
+ // If there is a single error, we give a specific suggestion; otherwise, we change to
+ // "did you mean" with the suggested function call
+ enum SuggestionText {
+ None,
+ Provide(bool),
+ Remove(bool),
+ Swap,
+ Reorder,
+ DidYouMean,
}
+ let mut suggestion_text = SuggestionText::None;
+
+ let mut errors = errors.into_iter().peekable();
+ while let Some(error) = errors.next() {
+ match error {
+ Error::Invalid(input_idx, compatibility) => {
+ let expected_ty = expected_input_tys[input_idx];
+ if let Compatibility::Incompatible(error) = &compatibility {
+ let provided_ty = final_arg_types[input_idx].map(|ty| ty.0).unwrap();
+ let cause = &self.misc(provided_args[input_idx].span);
+ let trace = TypeTrace::types(cause, true, expected_ty, provided_ty);
+ if let Some(e) = error {
+ self.note_type_err(
+ &mut err,
+ &trace.cause,
+ None,
+ Some(trace.values),
+ e,
+ false,
+ true,
+ );
+ }
+ }
+
+ self.emit_coerce_suggestions(
+ &mut err,
+ &provided_args[input_idx],
+ final_arg_types[input_idx].map(|ty| ty.0).unwrap(),
+ final_arg_types[input_idx].map(|ty| ty.1).unwrap(),
+ None,
+ None,
+ );
+ }
+ Error::Extra(arg_idx) => {
+ let arg_type = if let Some((_, ty)) = final_arg_types[arg_idx] {
+ if ty.references_error() || ty.has_infer_types() {
+ "".into()
+ } else {
+ format!(" of type `{}`", ty)
+ }
+ } else {
+ "".into()
+ };
+ labels.push((
+ provided_args[arg_idx].span,
+ format!("argument{} unexpected", arg_type),
+ ));
+ suggestion_text = match suggestion_text {
+ SuggestionText::None => SuggestionText::Remove(false),
+ SuggestionText::Remove(_) => SuggestionText::Remove(true),
+ _ => SuggestionText::DidYouMean,
+ };
+ }
+ Error::Missing(input_idx) => {
+ // If there are multiple missing arguments adjacent to each other,
+ // then we can provide a single error.
+
+ let mut missing_idxs = vec![input_idx];
+ while let Some(e) = errors.next_if(|e| matches!(e, Error::Missing(input_idx) if *input_idx == (missing_idxs.last().unwrap() + 1))) {
+ match e {
+ Error::Missing(input_idx) => missing_idxs.push(input_idx),
+ _ => unreachable!(),
+ }
+ }
+
+ // NOTE: Because we might be re-arranging arguments, might have extra
+ // arguments, etc. it's hard to *really* know where we should provide
+ // this error label, so as a heuristic, we point to the provided arg, or
+ // to the call if the missing inputs pass the provided args.
+ match &missing_idxs[..] {
+ &[input_idx] => {
+ let expected_ty = expected_input_tys[input_idx];
+ let input_ty = self.resolve_vars_if_possible(expected_ty);
+ let span = if input_idx < provided_arg_count {
+ let arg_span = provided_args[input_idx].span;
+ Span::new(arg_span.lo(), arg_span.hi(), arg_span.ctxt(), None)
+ } else {
+ args_span
+ };
+ let arg_type =
+ if input_ty.references_error() || input_ty.has_infer_types() {
+ "".into()
+ } else {
+ format!(" of type `{}`", input_ty)
+ };
+ labels.push((span, format!("an argument{} is missing", arg_type)));
+ suggestion_text = match suggestion_text {
+ SuggestionText::None => SuggestionText::Provide(false),
+ SuggestionText::Provide(_) => SuggestionText::Provide(true),
+ _ => SuggestionText::DidYouMean,
+ };
+ }
+ &[first_idx, second_idx] => {
+ let first_input_ty =
+ self.resolve_vars_if_possible(expected_input_tys[first_idx]);
+ let second_input_ty =
+ self.resolve_vars_if_possible(expected_input_tys[second_idx]);
+
+ let span = if second_idx < provided_arg_count {
+ let first_arg_span = provided_args[first_idx].span;
+ let second_arg_span = provided_args[second_idx].span;
+ Span::new(
+ first_arg_span.lo(),
+ second_arg_span.hi(),
+ first_arg_span.ctxt(),
+ None,
+ )
+ } else {
+ args_span
+ };
+ let any_unnameable = false
+ || first_input_ty.references_error()
+ || first_input_ty.has_infer_types()
+ || second_input_ty.references_error()
+ || second_input_ty.has_infer_types();
+ let arg_type = if any_unnameable {
+ "".into()
+ } else {
+ format!(
+ " of type `{}` and `{}`",
+ first_input_ty, second_input_ty
+ )
+ };
+ labels
+ .push((span, format!("two arguments{} are missing", arg_type)));
+ suggestion_text = match suggestion_text {
+ SuggestionText::None | SuggestionText::Provide(_) => {
+ SuggestionText::Provide(true)
+ }
+ _ => SuggestionText::DidYouMean,
+ };
+ }
+ &[first_idx, second_idx, third_idx] => {
+ let first_input_ty =
+ self.resolve_vars_if_possible(expected_input_tys[first_idx]);
+ let second_input_ty =
+ self.resolve_vars_if_possible(expected_input_tys[second_idx]);
+ let third_input_ty =
+ self.resolve_vars_if_possible(expected_input_tys[second_idx]);
+ let span = if third_idx < provided_arg_count {
+ let first_arg_span = provided_args[first_idx].span;
+ let third_arg_span = provided_args[third_idx].span;
+ Span::new(
+ first_arg_span.lo(),
+ third_arg_span.hi(),
+ first_arg_span.ctxt(),
+ None,
+ )
+ } else {
+ args_span
+ };
+ let any_unnameable = false
+ || first_input_ty.references_error()
+ || first_input_ty.has_infer_types()
+ || second_input_ty.references_error()
+ || second_input_ty.has_infer_types()
+ || third_input_ty.references_error()
+ || third_input_ty.has_infer_types();
+ let arg_type = if any_unnameable {
+ "".into()
+ } else {
+ format!(
+ " of type `{}`, `{}`, and `{}`",
+ first_input_ty, second_input_ty, third_input_ty
+ )
+ };
+ labels.push((
+ span,
+ format!("three arguments{} are missing", arg_type),
+ ));
+ suggestion_text = match suggestion_text {
+ SuggestionText::None | SuggestionText::Provide(_) => {
+ SuggestionText::Provide(true)
+ }
+ _ => SuggestionText::DidYouMean,
+ };
+ }
+ missing_idxs => {
+ let first_idx = *missing_idxs.first().unwrap();
+ let second_idx = *missing_idxs.last().unwrap();
+ // NOTE: Because we might be re-arranging arguments, might have extra arguments, etc.
+ // It's hard to *really* know where we should provide this error label, so this is a
+ // decent heuristic
+ let span = if first_idx < provided_arg_count {
+ let first_arg_span = provided_args[first_idx].span;
+ let second_arg_span = provided_args[second_idx].span;
+ Span::new(
+ first_arg_span.lo(),
+ second_arg_span.hi(),
+ first_arg_span.ctxt(),
+ None,
+ )
+ } else {
+ // Otherwise just label the whole function
+ args_span
+ };
+ labels.push((span, format!("multiple arguments are missing")));
+ suggestion_text = match suggestion_text {
+ SuggestionText::None | SuggestionText::Provide(_) => {
+ SuggestionText::Provide(true)
+ }
+ _ => SuggestionText::DidYouMean,
+ };
+ }
+ }
+ }
+ Error::Swap(input_idx, other_input_idx, arg_idx, other_arg_idx) => {
+ let first_span = provided_args[arg_idx].span;
+ let second_span = provided_args[other_arg_idx].span;
+
+ let first_expected_ty =
+ self.resolve_vars_if_possible(expected_input_tys[input_idx]);
+ let first_provided_ty = if let Some((ty, _)) = final_arg_types[arg_idx] {
+ format!(",found `{}`", ty)
+ } else {
+ "".into()
+ };
+ labels.push((
+ first_span,
+ format!("expected `{}`{}", first_expected_ty, first_provided_ty),
+ ));
+ let other_expected_ty =
+ self.resolve_vars_if_possible(expected_input_tys[other_input_idx]);
+ let other_provided_ty =
+ if let Some((ty, _)) = final_arg_types[other_arg_idx] {
+ format!(",found `{}`", ty)
+ } else {
+ "".into()
+ };
+ labels.push((
+ second_span,
+ format!("expected `{}`{}", other_expected_ty, other_provided_ty),
+ ));
+ suggestion_text = match suggestion_text {
+ SuggestionText::None => SuggestionText::Swap,
+ _ => SuggestionText::DidYouMean,
+ };
+ }
+ Error::Permutation(args) => {
+ for (dst_arg, dest_input) in args {
+ let expected_ty =
+ self.resolve_vars_if_possible(expected_input_tys[dest_input]);
+ let provided_ty = if let Some((ty, _)) = final_arg_types[dst_arg] {
+ format!(",found `{}`", ty)
+ } else {
+ "".into()
+ };
+ labels.push((
+ provided_args[dst_arg].span,
+ format!("expected `{}`{}", expected_ty, provided_ty),
+ ));
+ }
+
+ suggestion_text = match suggestion_text {
+ SuggestionText::None => SuggestionText::Reorder,
+ _ => SuggestionText::DidYouMean,
+ };
+ }
+ }
+ }
+
+ // If we have less than 5 things to say, it would be useful to call out exactly what's wrong
+ if labels.len() <= 5 {
+ for (span, label) in labels {
+ err.span_label(span, label);
+ }
+ }
+
+ // Call out where the function is defined
if let Some(def_id) = fn_def_id && let Some(def_span) = tcx.def_ident_span(def_id) {
let mut spans: MultiSpan = def_span.into();
let def_kind = tcx.def_kind(def_id);
err.span_note(spans, &format!("{} defined here", def_kind.descr(def_id)));
}
- if sugg_unit {
- let sugg_span = tcx.sess.source_map().end_point(call_expr.span);
- // remove closing `)` from the span
- let sugg_span = sugg_span.shrink_to_lo();
- err.span_suggestion(
- sugg_span,
- "expected the unit value `()`; create it with empty parentheses",
- String::from("()"),
- Applicability::MachineApplicable,
- );
- } else if let Some(FnArgsAsTuple { first, last }) = sugg_tuple_wrap_args {
- err.multipart_suggestion(
- "use parentheses to construct a tuple",
- vec![
- (first.span.shrink_to_lo(), '('.to_string()),
- (last.span.shrink_to_hi(), ')'.to_string()),
- ],
- Applicability::MachineApplicable,
+
+ // And add a suggestion block for all of the parameters
+ let suggestion_text = match suggestion_text {
+ SuggestionText::None => None,
+ SuggestionText::Provide(plural) => {
+ Some(format!("provide the argument{}", if plural { "s" } else { "" }))
+ }
+ SuggestionText::Remove(plural) => {
+ Some(format!("remove the extra argument{}", if plural { "s" } else { "" }))
+ }
+ SuggestionText::Swap => Some(format!("swap these arguments")),
+ SuggestionText::Reorder => Some(format!("reorder these arguments")),
+ SuggestionText::DidYouMean => Some(format!("did you mean")),
+ };
+ if let Some(suggestion_text) = suggestion_text {
+ let source_map = self.sess().source_map();
+ let mut suggestion = format!(
+ "{}(",
+ source_map.span_to_snippet(full_call_span).unwrap_or_else(|_| String::new())
);
- } else {
- err.span_label(
- span,
- format!(
- "expected {}{}",
- if c_variadic { "at least " } else { "" },
- potentially_plural_count(expected_count, "argument")
- ),
+ for (idx, arg) in matched_inputs.iter().enumerate() {
+ let suggestion_text = if let Some(arg) = arg {
+ let arg_span = provided_args[*arg].span;
+ let arg_text = source_map.span_to_snippet(arg_span).unwrap();
+ arg_text
+ } else {
+ // Propose a placeholder of the correct type
+ let expected_ty = expected_input_tys[idx];
+ let input_ty = self.resolve_vars_if_possible(expected_ty);
+ if input_ty.is_unit() {
+ "()".to_string()
+ } else {
+ format!("{{{}}}", input_ty)
+ }
+ };
+ suggestion += &suggestion_text;
+ if idx < minimum_input_count - 1 {
+ suggestion += ", ";
+ }
+ }
+ suggestion += ")";
+ err.span_suggestion_verbose(
+ error_span,
+ &suggestion_text,
+ suggestion,
+ Applicability::HasPlaceholders,
);
}
err.emit();
for arg in provided_args.iter().skip(minimum_input_count) {
let arg_ty = self.check_expr(&arg);
+ // If the function is c-style variadic, we skipped a bunch of arguments
+ // so we need to check those, and write out the types
+ // Ideally this would be folded into the above, for uniform style
+ // but c-variadic is already a corner case
if c_variadic {
- // We also need to make sure we at least write the ty of the other
- // arguments which we skipped above, either because they were additional
- // c_variadic args, or because we had an argument count mismatch.
fn variadic_error<'tcx>(sess: &Session, span: Span, ty: Ty<'tcx>, cast_ty: &str) {
use crate::structured_errors::MissingCastForVariadicArg;
&self,
expected_input_tys: &[Ty<'tcx>],
provided_args: &'tcx [hir::Expr<'tcx>],
- ) -> Option<FnArgsAsTuple<'_>> {
- let [expected_arg_type] = expected_input_tys[..] else { return None };
-
+ ) -> TupleMatchFound {
+ // Only handle the case where we expect only one tuple arg
+ let [expected_arg_type] = expected_input_tys[..] else { return TupleMatchFound::None };
let &ty::Tuple(expected_types) = self.resolve_vars_if_possible(expected_arg_type).kind()
- else { return None };
+ else { return TupleMatchFound::None };
+
+ // First check that there are the same number of types.
+ if expected_types.len() != provided_args.len() {
+ return TupleMatchFound::None;
+ }
let supplied_types: Vec<_> = provided_args.iter().map(|arg| self.check_expr(arg)).collect();
let all_match = iter::zip(expected_types, supplied_types)
.all(|(expected, supplied)| self.can_eq(self.param_env, expected, supplied).is_ok());
- if all_match {
- match provided_args {
- [] => None,
- [_] => unreachable!(
- "shouldn't reach here - need count mismatch between 1-tuple and 1-argument"
- ),
- [first, .., last] => Some(FnArgsAsTuple { first, last }),
+ if !all_match {
+ return TupleMatchFound::None;
+ }
+ match provided_args {
+ [] => TupleMatchFound::None,
+ [_] => TupleMatchFound::Single,
+ [first, .., last] => {
+ TupleMatchFound::Multiple(first.span.shrink_to_lo(), last.span.shrink_to_hi())
}
- } else {
- None
}
}
mod _impl;
+mod arg_matrix;
mod checks;
mod suggestions;
pub use _impl::*;
-pub use checks::*;
pub use suggestions::*;
use crate::astconv::AstConv;
#![feature(box_patterns)]
#![feature(control_flow_enum)]
#![feature(crate_visibility_modifier)]
+#![feature(drain_filter)]
#![feature(hash_drain_filter)]
#![feature(if_let_guard)]
#![feature(is_sorted)]
+#![feature(label_break_value)]
#![feature(let_chains)]
#![feature(let_else)]
#![feature(min_specialization)]
+++ /dev/null
-// error-pattern: arguments were supplied
-
-fn f(x: isize) { }
-
-fn main() { let i: (); i = f(); }
+++ /dev/null
-error[E0061]: this function takes 1 argument but 0 arguments were supplied
- --> $DIR/arg-count-mismatch.rs:5:28
- |
-LL | fn main() { let i: (); i = f(); }
- | ^-- supplied 0 arguments
- | |
- | expected 1 argument
- |
-note: function defined here
- --> $DIR/arg-count-mismatch.rs:3:4
- |
-LL | fn f(x: isize) { }
- | ^ --------
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0061`.
+++ /dev/null
-// error-pattern: mismatched types
-
-fn f(x: isize) { }
-
-fn main() { let i: (); i = f(()); }
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/arg-type-mismatch.rs:5:30
- |
-LL | fn main() { let i: (); i = f(()); }
- | ^^ expected `isize`, found `()`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Some basic "obvious" cases for the heuristic error messages added for #65853
+// One for each of the detected cases
+
+enum E { X, Y }
+enum F { X2, Y2 }
+struct G {}
+struct H {}
+struct X {}
+struct Y {}
+struct Z {}
+
+
+fn invalid(_i: u32) {}
+fn extra() {}
+fn missing(_i: u32) {}
+fn swapped(_i: u32, _s: &str) {}
+fn permuted(_x: X, _y: Y, _z: Z) {}
+
+fn main() {
+ invalid(1.0); //~ ERROR mismatched types
+ extra(""); //~ ERROR this function takes
+ missing(); //~ ERROR this function takes
+ swapped("", 1); //~ ERROR arguments to this function are incorrect
+ permuted(Y {}, Z {}, X {}); //~ ERROR arguments to this function are incorrect
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/basic.rs:20:13
+ |
+LL | invalid(1.0);
+ | ------- ^^^ expected `u32`, found floating-point number
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/basic.rs:13:4
+ |
+LL | fn invalid(_i: u32) {}
+ | ^^^^^^^ -------
+
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+ --> $DIR/basic.rs:21:5
+ |
+LL | extra("");
+ | ^^^^^ -- argument unexpected
+ |
+note: function defined here
+ --> $DIR/basic.rs:14:4
+ |
+LL | fn extra() {}
+ | ^^^^^
+help: remove the extra argument
+ |
+LL | extra();
+ | ~~~~~~~
+
+error[E0061]: this function takes 1 argument but 0 arguments were supplied
+ --> $DIR/basic.rs:22:5
+ |
+LL | missing();
+ | ^^^^^^^-- an argument of type `u32` is missing
+ |
+note: function defined here
+ --> $DIR/basic.rs:15:4
+ |
+LL | fn missing(_i: u32) {}
+ | ^^^^^^^ -------
+help: provide the argument
+ |
+LL | missing({u32});
+ | ~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/basic.rs:23:5
+ |
+LL | swapped("", 1);
+ | ^^^^^^^ -- - expected `&str`,found `{integer}`
+ | |
+ | expected `u32`,found `&'static str`
+ |
+note: function defined here
+ --> $DIR/basic.rs:16:4
+ |
+LL | fn swapped(_i: u32, _s: &str) {}
+ | ^^^^^^^ ------- --------
+help: swap these arguments
+ |
+LL | swapped(1, "");
+ | ~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/basic.rs:24:5
+ |
+LL | permuted(Y {}, Z {}, X {});
+ | ^^^^^^^^ ---- ---- ---- expected `Z`,found `X`
+ | | |
+ | | expected `Y`,found `Z`
+ | expected `X`,found `Y`
+ |
+note: function defined here
+ --> $DIR/basic.rs:17:4
+ |
+LL | fn permuted(_x: X, _y: Y, _z: Z) {}
+ | ^^^^^^^^ ----- ----- -----
+help: reorder these arguments
+ |
+LL | permuted(X {}, Y {}, Z {});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 5 previous errors
+
+Some errors have detailed explanations: E0061, E0308.
+For more information about an error, try `rustc --explain E0061`.
--- /dev/null
+// A complex case with mixed suggestions from #65853
+
+enum E { X, Y }
+enum F { X2, Y2 }
+struct G {}
+struct H {}
+struct X {}
+struct Y {}
+struct Z {}
+
+fn complex(_i: u32, _s: &str, _e: E, _f: F, _g: G, _x: X, _y: Y, _z: Z ) {}
+
+fn main() {
+ complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
+ //~^ ERROR arguments to this function are incorrect
+}
--- /dev/null
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/complex.rs:14:3
+ |
+LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {});
+ | ^^^^^^^ --- expected `u32`, found floating-point number
+ |
+note: function defined here
+ --> $DIR/complex.rs:11:4
+ |
+LL | fn complex(_i: u32, _s: &str, _e: E, _f: F, _g: G, _x: X, _y: Y, _z: Z ) {}
+ | ^^^^^^^ ------- -------- ----- ----- ----- ----- ----- ------
+help: did you mean
+ |
+LL | complex({u32}, &"", {E}, F::X2, G{}, X {}, Y {}, Z {});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+fn empty() {}
+fn one_arg(_a: i32) {}
+fn two_arg_same(_a: i32, _b: i32) {}
+fn two_arg_diff(_a: i32, _b: &str) {}
+
+fn main() {
+ empty(""); //~ ERROR this function takes
+
+ one_arg(1, 1); //~ ERROR this function takes
+ one_arg(1, ""); //~ ERROR this function takes
+ one_arg(1, "", 1.0); //~ ERROR this function takes
+
+ two_arg_same(1, 1, 1); //~ ERROR this function takes
+ two_arg_same(1, 1, 1.0); //~ ERROR this function takes
+
+ two_arg_diff(1, 1, ""); //~ ERROR this function takes
+ two_arg_diff(1, "", ""); //~ ERROR this function takes
+ two_arg_diff(1, 1, "", ""); //~ ERROR this function takes
+ two_arg_diff(1, "", 1, ""); //~ ERROR this function takes
+
+ // Check with weird spacing and newlines
+ two_arg_same(1, 1, ""); //~ ERROR this function takes
+ two_arg_diff(1, 1, ""); //~ ERROR this function takes
+ two_arg_same( //~ ERROR this function takes
+ 1,
+ 1,
+ ""
+ );
+
+ two_arg_diff( //~ ERROR this function takes
+ 1,
+ 1,
+ ""
+ );
+}
--- /dev/null
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+ --> $DIR/extra_arguments.rs:7:3
+ |
+LL | empty("");
+ | ^^^^^ -- argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:1:4
+ |
+LL | fn empty() {}
+ | ^^^^^
+help: remove the extra argument
+ |
+LL | empty();
+ | ~~~~~~~
+
+error[E0061]: this function takes 1 argument but 2 arguments were supplied
+ --> $DIR/extra_arguments.rs:9:3
+ |
+LL | one_arg(1, 1);
+ | ^^^^^^^ - argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:2:4
+ |
+LL | fn one_arg(_a: i32) {}
+ | ^^^^^^^ -------
+help: remove the extra argument
+ |
+LL | one_arg(1);
+ | ~~~~~~~~~~
+
+error[E0061]: this function takes 1 argument but 2 arguments were supplied
+ --> $DIR/extra_arguments.rs:10:3
+ |
+LL | one_arg(1, "");
+ | ^^^^^^^ -- argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:2:4
+ |
+LL | fn one_arg(_a: i32) {}
+ | ^^^^^^^ -------
+help: remove the extra argument
+ |
+LL | one_arg(1);
+ | ~~~~~~~~~~
+
+error[E0061]: this function takes 1 argument but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:11:3
+ |
+LL | one_arg(1, "", 1.0);
+ | ^^^^^^^ -- --- argument unexpected
+ | |
+ | argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:2:4
+ |
+LL | fn one_arg(_a: i32) {}
+ | ^^^^^^^ -------
+help: remove the extra arguments
+ |
+LL | one_arg(1);
+ | ~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:13:3
+ |
+LL | two_arg_same(1, 1, 1);
+ | ^^^^^^^^^^^^ - argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:3:4
+ |
+LL | fn two_arg_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^^^^^ ------- -------
+help: remove the extra argument
+ |
+LL | two_arg_same(1, 1);
+ | ~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:14:3
+ |
+LL | two_arg_same(1, 1, 1.0);
+ | ^^^^^^^^^^^^ --- argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:3:4
+ |
+LL | fn two_arg_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^^^^^ ------- -------
+help: remove the extra argument
+ |
+LL | two_arg_same(1, 1);
+ | ~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:16:3
+ |
+LL | two_arg_diff(1, 1, "");
+ | ^^^^^^^^^^^^ - argument of type `&str` unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:4:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: &str) {}
+ | ^^^^^^^^^^^^ ------- --------
+help: remove the extra argument
+ |
+LL | two_arg_diff(1, "");
+ | ~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:17:3
+ |
+LL | two_arg_diff(1, "", "");
+ | ^^^^^^^^^^^^ -- argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:4:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: &str) {}
+ | ^^^^^^^^^^^^ ------- --------
+help: remove the extra argument
+ |
+LL | two_arg_diff(1, "");
+ | ~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 4 arguments were supplied
+ --> $DIR/extra_arguments.rs:18:3
+ |
+LL | two_arg_diff(1, 1, "", "");
+ | ^^^^^^^^^^^^ - -- argument unexpected
+ | |
+ | argument of type `&str` unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:4:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: &str) {}
+ | ^^^^^^^^^^^^ ------- --------
+help: remove the extra arguments
+ |
+LL | two_arg_diff(1, "");
+ | ~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 4 arguments were supplied
+ --> $DIR/extra_arguments.rs:19:3
+ |
+LL | two_arg_diff(1, "", 1, "");
+ | ^^^^^^^^^^^^ - -- argument unexpected
+ | |
+ | argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:4:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: &str) {}
+ | ^^^^^^^^^^^^ ------- --------
+help: remove the extra arguments
+ |
+LL | two_arg_diff(1, "");
+ | ~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:22:3
+ |
+LL | two_arg_same(1, 1, "");
+ | ^^^^^^^^^^^^ -- argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:3:4
+ |
+LL | fn two_arg_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^^^^^ ------- -------
+help: remove the extra argument
+ |
+LL | two_arg_same(1, 1);
+ | ~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:23:3
+ |
+LL | two_arg_diff(1, 1, "");
+ | ^^^^^^^^^^^^ - argument of type `&str` unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:4:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: &str) {}
+ | ^^^^^^^^^^^^ ------- --------
+help: remove the extra argument
+ |
+LL | two_arg_diff(1, "");
+ | ~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:24:3
+ |
+LL | two_arg_same(
+ | ^^^^^^^^^^^^
+...
+LL | ""
+ | -- argument unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:3:4
+ |
+LL | fn two_arg_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^^^^^ ------- -------
+help: remove the extra argument
+ |
+LL | two_arg_same(1, 1);
+ | ~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/extra_arguments.rs:30:3
+ |
+LL | two_arg_diff(
+ | ^^^^^^^^^^^^
+LL | 1,
+LL | 1,
+ | - argument of type `&str` unexpected
+ |
+note: function defined here
+ --> $DIR/extra_arguments.rs:4:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: &str) {}
+ | ^^^^^^^^^^^^ ------- --------
+help: remove the extra argument
+ |
+LL | two_arg_diff(1, "");
+ | ~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 14 previous errors
+
+For more information about this error, try `rustc --explain E0061`.
--- /dev/null
+// More nuanced test cases for invalid arguments #65853
+
+struct X {}
+
+fn one_arg(_a: i32) {}
+fn two_arg_same(_a: i32, _b: i32) {}
+fn two_arg_diff(_a: i32, _b: f32) {}
+fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
+fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
+
+fn main() {
+ // Providing an incorrect argument for a single parameter function
+ one_arg(1.0); //~ ERROR mismatched types
+
+ // Providing one or two invalid arguments to a two parameter function
+ two_arg_same(1, ""); //~ ERROR mismatched types
+ two_arg_same("", 1); //~ ERROR mismatched types
+ two_arg_same("", ""); //~ ERROR arguments to this function are incorrect
+ two_arg_diff(1, ""); //~ ERROR mismatched types
+ two_arg_diff("", 1.0); //~ ERROR mismatched types
+ two_arg_diff("", ""); //~ ERROR arguments to this function are incorrect
+
+ // Providing invalid arguments to a three parameter function
+ three_arg_diff(X{}, 1.0, ""); //~ ERROR mismatched types
+ three_arg_diff(1, X {}, ""); //~ ERROR mismatched types
+ three_arg_diff(1, 1.0, X {}); //~ ERROR mismatched types
+
+ three_arg_diff(X {}, X {}, ""); //~ ERROR arguments to this function are incorrect
+ three_arg_diff(X {}, 1.0, X {}); //~ ERROR arguments to this function are incorrect
+ three_arg_diff(1, X {}, X {}); //~ ERROR arguments to this function are incorrect
+
+ three_arg_diff(X {}, X {}, X {}); //~ ERROR arguments to this function are incorrect
+
+ three_arg_repeat(X {}, 1, ""); //~ ERROR mismatched types
+ three_arg_repeat(1, X {}, ""); //~ ERROR mismatched types
+ three_arg_repeat(1, 1, X {}); //~ ERROR mismatched types
+
+ three_arg_repeat(X {}, X {}, ""); //~ ERROR arguments to this function are incorrect
+ three_arg_repeat(X {}, 1, X {}); //~ ERROR arguments to this function are incorrect
+ three_arg_repeat(1, X {}, X{}); //~ ERROR arguments to this function are incorrect
+
+ three_arg_repeat(X {}, X {}, X {}); //~ ERROR arguments to this function are incorrect
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:13:11
+ |
+LL | one_arg(1.0);
+ | ------- ^^^ expected `i32`, found floating-point number
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:5:4
+ |
+LL | fn one_arg(_a: i32) {}
+ | ^^^^^^^ -------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:16:19
+ |
+LL | two_arg_same(1, "");
+ | ------------ ^^ expected `i32`, found `&str`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:6:4
+ |
+LL | fn two_arg_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^^^^^ ------- -------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:17:16
+ |
+LL | two_arg_same("", 1);
+ | ------------ ^^ expected `i32`, found `&str`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:6:4
+ |
+LL | fn two_arg_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^^^^^ ------- -------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:18:3
+ |
+LL | two_arg_same("", "");
+ | ^^^^^^^^^^^^ -- -- expected `i32`, found `&str`
+ | |
+ | expected `i32`, found `&str`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:6:4
+ |
+LL | fn two_arg_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^^^^^ ------- -------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:19:19
+ |
+LL | two_arg_diff(1, "");
+ | ------------ ^^ expected `f32`, found `&str`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:7:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: f32) {}
+ | ^^^^^^^^^^^^ ------- -------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:20:16
+ |
+LL | two_arg_diff("", 1.0);
+ | ------------ ^^ expected `i32`, found `&str`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:7:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: f32) {}
+ | ^^^^^^^^^^^^ ------- -------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:21:3
+ |
+LL | two_arg_diff("", "");
+ | ^^^^^^^^^^^^ -- -- expected `f32`, found `&str`
+ | |
+ | expected `i32`, found `&str`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:7:4
+ |
+LL | fn two_arg_diff(_a: i32, _b: f32) {}
+ | ^^^^^^^^^^^^ ------- -------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:24:18
+ |
+LL | three_arg_diff(X{}, 1.0, "");
+ | -------------- ^^^ expected `i32`, found struct `X`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:8:4
+ |
+LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:25:21
+ |
+LL | three_arg_diff(1, X {}, "");
+ | -------------- ^^^^ expected `f32`, found struct `X`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:8:4
+ |
+LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:26:26
+ |
+LL | three_arg_diff(1, 1.0, X {});
+ | -------------- ^^^^ expected `&str`, found struct `X`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:8:4
+ |
+LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:28:3
+ |
+LL | three_arg_diff(X {}, X {}, "");
+ | ^^^^^^^^^^^^^^ ---- ---- expected `f32`, found struct `X`
+ | |
+ | expected `i32`, found struct `X`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:8:4
+ |
+LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:29:3
+ |
+LL | three_arg_diff(X {}, 1.0, X {});
+ | ^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X`
+ | |
+ | expected `i32`, found struct `X`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:8:4
+ |
+LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:30:3
+ |
+LL | three_arg_diff(1, X {}, X {});
+ | ^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X`
+ | |
+ | expected `f32`, found struct `X`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:8:4
+ |
+LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:32:3
+ |
+LL | three_arg_diff(X {}, X {}, X {});
+ | ^^^^^^^^^^^^^^ ---- ---- ---- expected `&str`, found struct `X`
+ | | |
+ | | expected `f32`, found struct `X`
+ | expected `i32`, found struct `X`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:8:4
+ |
+LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:34:20
+ |
+LL | three_arg_repeat(X {}, 1, "");
+ | ---------------- ^^^^ expected `i32`, found struct `X`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:9:4
+ |
+LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
+ | ^^^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:35:23
+ |
+LL | three_arg_repeat(1, X {}, "");
+ | ---------------- ^^^^ expected `i32`, found struct `X`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:9:4
+ |
+LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
+ | ^^^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: mismatched types
+ --> $DIR/invalid_arguments.rs:36:26
+ |
+LL | three_arg_repeat(1, 1, X {});
+ | ---------------- ^^^^ expected `&str`, found struct `X`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:9:4
+ |
+LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
+ | ^^^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:38:3
+ |
+LL | three_arg_repeat(X {}, X {}, "");
+ | ^^^^^^^^^^^^^^^^ ---- ---- expected `i32`, found struct `X`
+ | |
+ | expected `i32`, found struct `X`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:9:4
+ |
+LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
+ | ^^^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:39:3
+ |
+LL | three_arg_repeat(X {}, 1, X {});
+ | ^^^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X`
+ | |
+ | expected `i32`, found struct `X`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:9:4
+ |
+LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
+ | ^^^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:40:3
+ |
+LL | three_arg_repeat(1, X {}, X{});
+ | ^^^^^^^^^^^^^^^^ ---- --- expected `&str`, found struct `X`
+ | |
+ | expected `i32`, found struct `X`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:9:4
+ |
+LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
+ | ^^^^^^^^^^^^^^^^ ------- ------- --------
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/invalid_arguments.rs:42:3
+ |
+LL | three_arg_repeat(X {}, X {}, X {});
+ | ^^^^^^^^^^^^^^^^ ---- ---- ---- expected `&str`, found struct `X`
+ | | |
+ | | expected `i32`, found struct `X`
+ | expected `i32`, found struct `X`
+ |
+note: function defined here
+ --> $DIR/invalid_arguments.rs:9:4
+ |
+LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {}
+ | ^^^^^^^^^^^^^^^^ ------- ------- --------
+
+error: aborting due to 21 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+fn one_arg(_a: i32) {}
+fn two_same(_a: i32, _b: i32) {}
+fn two_diff(_a: i32, _b: f32) {}
+fn three_same(_a: i32, _b: i32, _c: i32) {}
+fn three_diff(_a: i32, _b: f32, _c: &str) {}
+fn four_repeated(_a: i32, _b: f32, _c: f32, _d: &str) {}
+fn complex(_a: i32, _b: f32, _c: i32, _d: f32, _e: &str) {}
+
+fn main() {
+ one_arg(); //~ ERROR this function takes
+ // The headers here show the types expected,
+ // with formatting to emphasize which arguments are missing
+ /* i32 f32 */
+ two_same( ); //~ ERROR this function takes
+ two_same( 1 ); //~ ERROR this function takes
+ two_diff( ); //~ ERROR this function takes
+ two_diff( 1 ); //~ ERROR this function takes
+ two_diff( 1.0 ); //~ ERROR this function takes
+
+ /* i32 i32 i32 */
+ three_same( ); //~ ERROR this function takes
+ three_same( 1 ); //~ ERROR this function takes
+ three_same( 1, 1 ); //~ ERROR this function takes
+
+ /* i32 f32 &str */
+ three_diff( 1.0, "" ); //~ ERROR this function takes
+ three_diff( 1, "" ); //~ ERROR this function takes
+ three_diff( 1, 1.0 ); //~ ERROR this function takes
+ three_diff( "" ); //~ ERROR this function takes
+ three_diff( 1.0 ); //~ ERROR this function takes
+ three_diff( 1 ); //~ ERROR this function takes
+
+ /* i32 f32 f32 &str */
+ four_repeated( ); //~ ERROR this function takes
+ four_repeated( 1, "" ); //~ ERROR this function takes
+
+ /* i32 f32 i32 f32 &str */
+ complex( ); //~ ERROR this function takes
+ complex( 1, "" ); //~ ERROR this function takes
+}
--- /dev/null
+error[E0061]: this function takes 1 argument but 0 arguments were supplied
+ --> $DIR/missing_arguments.rs:10:3
+ |
+LL | one_arg();
+ | ^^^^^^^-- an argument of type `i32` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:1:4
+ |
+LL | fn one_arg(_a: i32) {}
+ | ^^^^^^^ -------
+help: provide the argument
+ |
+LL | one_arg({i32});
+ | ~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 0 arguments were supplied
+ --> $DIR/missing_arguments.rs:14:3
+ |
+LL | two_same( );
+ | ^^^^^^^^----------------- two arguments of type `i32` and `i32` are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:2:4
+ |
+LL | fn two_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^ ------- -------
+help: provide the arguments
+ |
+LL | two_same({i32}, {i32});
+ | ~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 1 argument was supplied
+ --> $DIR/missing_arguments.rs:15:3
+ |
+LL | two_same( 1 );
+ | ^^^^^^^^----------------- an argument of type `i32` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:2:4
+ |
+LL | fn two_same(_a: i32, _b: i32) {}
+ | ^^^^^^^^ ------- -------
+help: provide the argument
+ |
+LL | two_same(1, {i32});
+ | ~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 0 arguments were supplied
+ --> $DIR/missing_arguments.rs:16:3
+ |
+LL | two_diff( );
+ | ^^^^^^^^----------------- two arguments of type `i32` and `f32` are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:3:4
+ |
+LL | fn two_diff(_a: i32, _b: f32) {}
+ | ^^^^^^^^ ------- -------
+help: provide the arguments
+ |
+LL | two_diff({i32}, {f32});
+ | ~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 1 argument was supplied
+ --> $DIR/missing_arguments.rs:17:3
+ |
+LL | two_diff( 1 );
+ | ^^^^^^^^----------------- an argument of type `f32` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:3:4
+ |
+LL | fn two_diff(_a: i32, _b: f32) {}
+ | ^^^^^^^^ ------- -------
+help: provide the argument
+ |
+LL | two_diff(1, {f32});
+ | ~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 2 arguments but 1 argument was supplied
+ --> $DIR/missing_arguments.rs:18:3
+ |
+LL | two_diff( 1.0 );
+ | ^^^^^^^^ --- an argument of type `i32` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:3:4
+ |
+LL | fn two_diff(_a: i32, _b: f32) {}
+ | ^^^^^^^^ ------- -------
+help: provide the argument
+ |
+LL | two_diff({i32}, 1.0);
+ | ~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 0 arguments were supplied
+ --> $DIR/missing_arguments.rs:21:3
+ |
+LL | three_same( );
+ | ^^^^^^^^^^------------------------- three arguments of type `i32`, `i32`, and `i32` are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:4:4
+ |
+LL | fn three_same(_a: i32, _b: i32, _c: i32) {}
+ | ^^^^^^^^^^ ------- ------- -------
+help: provide the arguments
+ |
+LL | three_same({i32}, {i32}, {i32});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 1 argument was supplied
+ --> $DIR/missing_arguments.rs:22:3
+ |
+LL | three_same( 1 );
+ | ^^^^^^^^^^------------------------- two arguments of type `i32` and `i32` are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:4:4
+ |
+LL | fn three_same(_a: i32, _b: i32, _c: i32) {}
+ | ^^^^^^^^^^ ------- ------- -------
+help: provide the arguments
+ |
+LL | three_same(1, {i32}, {i32});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 2 arguments were supplied
+ --> $DIR/missing_arguments.rs:23:3
+ |
+LL | three_same( 1, 1 );
+ | ^^^^^^^^^^------------------------- an argument of type `i32` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:4:4
+ |
+LL | fn three_same(_a: i32, _b: i32, _c: i32) {}
+ | ^^^^^^^^^^ ------- ------- -------
+help: provide the argument
+ |
+LL | three_same(1, 1, {i32});
+ | ~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 2 arguments were supplied
+ --> $DIR/missing_arguments.rs:26:3
+ |
+LL | three_diff( 1.0, "" );
+ | ^^^^^^^^^^ --- an argument of type `i32` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:5:4
+ |
+LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: provide the argument
+ |
+LL | three_diff({i32}, 1.0, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 2 arguments were supplied
+ --> $DIR/missing_arguments.rs:27:3
+ |
+LL | three_diff( 1, "" );
+ | ^^^^^^^^^^ -- an argument of type `f32` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:5:4
+ |
+LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: provide the argument
+ |
+LL | three_diff(1, {f32}, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 2 arguments were supplied
+ --> $DIR/missing_arguments.rs:28:3
+ |
+LL | three_diff( 1, 1.0 );
+ | ^^^^^^^^^^------------------------- an argument of type `&str` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:5:4
+ |
+LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: provide the argument
+ |
+LL | three_diff(1, 1.0, {&str});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 1 argument was supplied
+ --> $DIR/missing_arguments.rs:29:3
+ |
+LL | three_diff( "" );
+ | ^^^^^^^^^^------------------------- two arguments of type `i32` and `f32` are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:5:4
+ |
+LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: provide the arguments
+ |
+LL | three_diff({i32}, {f32}, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 1 argument was supplied
+ --> $DIR/missing_arguments.rs:30:3
+ |
+LL | three_diff( 1.0 );
+ | ^^^^^^^^^^-------------------------
+ | | |
+ | | an argument of type `i32` is missing
+ | an argument of type `&str` is missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:5:4
+ |
+LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: provide the arguments
+ |
+LL | three_diff({i32}, 1.0, {&str});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 1 argument was supplied
+ --> $DIR/missing_arguments.rs:31:3
+ |
+LL | three_diff( 1 );
+ | ^^^^^^^^^^------------------------- two arguments of type `f32` and `&str` are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:5:4
+ |
+LL | fn three_diff(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: provide the arguments
+ |
+LL | three_diff(1, {f32}, {&str});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 4 arguments but 0 arguments were supplied
+ --> $DIR/missing_arguments.rs:34:3
+ |
+LL | four_repeated( );
+ | ^^^^^^^^^^^^^--------------------------------- multiple arguments are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:6:4
+ |
+LL | fn four_repeated(_a: i32, _b: f32, _c: f32, _d: &str) {}
+ | ^^^^^^^^^^^^^ ------- ------- ------- --------
+help: provide the arguments
+ |
+LL | four_repeated({i32}, {f32}, {f32}, {&str});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 4 arguments but 2 arguments were supplied
+ --> $DIR/missing_arguments.rs:35:3
+ |
+LL | four_repeated( 1, "" );
+ | ^^^^^^^^^^^^^--------------------------------- two arguments of type `f32` and `f32` are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:6:4
+ |
+LL | fn four_repeated(_a: i32, _b: f32, _c: f32, _d: &str) {}
+ | ^^^^^^^^^^^^^ ------- ------- ------- --------
+help: provide the arguments
+ |
+LL | four_repeated(1, {f32}, {f32}, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 5 arguments but 0 arguments were supplied
+ --> $DIR/missing_arguments.rs:38:3
+ |
+LL | complex( );
+ | ^^^^^^^--------------------------------- multiple arguments are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:7:4
+ |
+LL | fn complex(_a: i32, _b: f32, _c: i32, _d: f32, _e: &str) {}
+ | ^^^^^^^ ------- ------- ------- ------- --------
+help: provide the arguments
+ |
+LL | complex({i32}, {f32}, {i32}, {f32}, {&str});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 5 arguments but 2 arguments were supplied
+ --> $DIR/missing_arguments.rs:39:3
+ |
+LL | complex( 1, "" );
+ | ^^^^^^^--------------------------------- three arguments of type `f32`, `i32`, and `i32` are missing
+ |
+note: function defined here
+ --> $DIR/missing_arguments.rs:7:4
+ |
+LL | fn complex(_a: i32, _b: f32, _c: i32, _d: f32, _e: &str) {}
+ | ^^^^^^^ ------- ------- ------- ------- --------
+help: provide the arguments
+ |
+LL | complex(1, {f32}, {i32}, {f32}, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 19 previous errors
+
+For more information about this error, try `rustc --explain E0061`.
--- /dev/null
+// Cases where multiple argument suggestions are mixed
+
+struct X {}
+
+fn two_args(_a: i32, _b: f32) {}
+fn three_args(_a: i32, _b: f32, _c: &str) {}
+
+fn main() {
+ // Extra + Invalid
+ two_args(1, "", X {}); //~ ERROR this function takes
+ three_args(1, "", X {}, ""); //~ ERROR this function takes
+
+ // Missing and Invalid
+ three_args(1, X {}); //~ ERROR this function takes
+
+ // Missing and Extra
+ three_args(1, "", X {}); //~ ERROR arguments to this function are incorrect
+
+ // Swapped and Invalid
+ three_args("", X {}, 1); //~ ERROR arguments to this function are incorrect
+
+ // Swapped and missing
+ three_args("", 1); //~ ERROR this function takes
+}
--- /dev/null
+error[E0061]: this function takes 2 arguments but 3 arguments were supplied
+ --> $DIR/mixed_cases.rs:10:3
+ |
+LL | two_args(1, "", X {});
+ | ^^^^^^^^ -- ---- argument unexpected
+ | |
+ | expected `f32`, found `&str`
+ |
+note: function defined here
+ --> $DIR/mixed_cases.rs:5:4
+ |
+LL | fn two_args(_a: i32, _b: f32) {}
+ | ^^^^^^^^ ------- -------
+help: remove the extra argument
+ |
+LL | two_args(1, {f32});
+ | ~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 4 arguments were supplied
+ --> $DIR/mixed_cases.rs:11:3
+ |
+LL | three_args(1, "", X {}, "");
+ | ^^^^^^^^^^ -- ---- -- argument unexpected
+ | | |
+ | | argument of type `&str` unexpected
+ | an argument of type `f32` is missing
+ |
+note: function defined here
+ --> $DIR/mixed_cases.rs:6:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: did you mean
+ |
+LL | three_args(1, {f32}, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 2 arguments were supplied
+ --> $DIR/mixed_cases.rs:14:3
+ |
+LL | three_args(1, X {});
+ | ^^^^^^^^^^---------
+ | | |
+ | | expected `f32`, found struct `X`
+ | an argument of type `&str` is missing
+ |
+note: function defined here
+ --> $DIR/mixed_cases.rs:6:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: provide the argument
+ |
+LL | three_args(1, {f32}, {&str});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/mixed_cases.rs:17:3
+ |
+LL | three_args(1, "", X {});
+ | ^^^^^^^^^^ -- ---- argument of type `&str` unexpected
+ | |
+ | an argument of type `f32` is missing
+ |
+note: function defined here
+ --> $DIR/mixed_cases.rs:6:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: did you mean
+ |
+LL | three_args(1, {f32}, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/mixed_cases.rs:20:3
+ |
+LL | three_args("", X {}, 1);
+ | ^^^^^^^^^^ -- ---- - expected `&str`,found `{integer}`
+ | | |
+ | | expected `f32`, found struct `X`
+ | expected `i32`,found `&'static str`
+ |
+note: function defined here
+ --> $DIR/mixed_cases.rs:6:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: swap these arguments
+ |
+LL | three_args(1, {f32}, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0061]: this function takes 3 arguments but 2 arguments were supplied
+ --> $DIR/mixed_cases.rs:23:3
+ |
+LL | three_args("", 1);
+ | ^^^^^^^^^^ -- -
+ | | |
+ | | an argument of type `f32` is missing
+ | | expected `&str`,found `{integer}`
+ | expected `i32`,found `&'static str`
+ |
+note: function defined here
+ --> $DIR/mixed_cases.rs:6:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: did you mean
+ |
+LL | three_args(1, {f32}, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0061, E0308.
+For more information about an error, try `rustc --explain E0061`.
--- /dev/null
+// More complicated permutations
+struct X {}
+struct Y {}
+
+fn three_args(_a: i32, _b: f32, _c: &str) {}
+fn many_args(_a: i32, _b: f32, _c: &str, _d: X, _e: Y) {}
+
+fn main() {
+ // b, c, a
+ three_args(1.0, "", 1); //~ ERROR arguments to this function are incorrect
+ // d, e, b, a, c
+ many_args(X {}, Y {}, 1, 1.0, ""); //~ ERROR arguments to this function are incorrect
+}
--- /dev/null
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/permuted_arguments.rs:10:3
+ |
+LL | three_args(1.0, "", 1);
+ | ^^^^^^^^^^ --- -- - expected `&str`,found `{integer}`
+ | | |
+ | | expected `f32`,found `&'static str`
+ | expected `i32`,found `{float}`
+ |
+note: function defined here
+ --> $DIR/permuted_arguments.rs:5:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: reorder these arguments
+ |
+LL | three_args(1, 1.0, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/permuted_arguments.rs:12:3
+ |
+LL | many_args(X {}, Y {}, 1, 1.0, "");
+ | ^^^^^^^^^ ---- ---- - --- -- expected `Y`,found `&'static str`
+ | | | | |
+ | | | | expected `X`,found `{float}`
+ | | | expected `&str`,found `{integer}`
+ | | expected `f32`,found `Y`
+ | expected `i32`,found `X`
+ |
+note: function defined here
+ --> $DIR/permuted_arguments.rs:6:4
+ |
+LL | fn many_args(_a: i32, _b: f32, _c: &str, _d: X, _e: Y) {}
+ | ^^^^^^^^^ ------- ------- -------- ----- -----
+help: reorder these arguments
+ |
+LL | many_args(1, 1.0, "", X {}, Y {});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+struct X {}
+
+fn two_args(_a: i32, _b: f32) {}
+fn three_args(_a: i32, _b: f32, _c: &str) {}
+fn four_args(_a: i32, _b: f32, _c: &str, _d: X) {}
+
+fn main() {
+ two_args(1.0, 1); //~ ERROR arguments to this function are incorrect
+ three_args(1.0, 1, ""); //~ ERROR arguments to this function are incorrect
+ three_args( 1, "", 1.0); //~ ERROR arguments to this function are incorrect
+ three_args( "", 1.0, 1); //~ ERROR arguments to this function are incorrect
+
+ four_args(1.0, 1, X {}, ""); //~ ERROR arguments to this function are incorrect
+}
--- /dev/null
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/swapped_arguments.rs:8:3
+ |
+LL | two_args(1.0, 1);
+ | ^^^^^^^^ --- - expected `f32`,found `{integer}`
+ | |
+ | expected `i32`,found `{float}`
+ |
+note: function defined here
+ --> $DIR/swapped_arguments.rs:3:4
+ |
+LL | fn two_args(_a: i32, _b: f32) {}
+ | ^^^^^^^^ ------- -------
+help: swap these arguments
+ |
+LL | two_args(1, 1.0);
+ | ~~~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/swapped_arguments.rs:9:3
+ |
+LL | three_args(1.0, 1, "");
+ | ^^^^^^^^^^ --- - expected `f32`,found `{integer}`
+ | |
+ | expected `i32`,found `{float}`
+ |
+note: function defined here
+ --> $DIR/swapped_arguments.rs:4:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: swap these arguments
+ |
+LL | three_args(1, 1.0, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/swapped_arguments.rs:10:3
+ |
+LL | three_args( 1, "", 1.0);
+ | ^^^^^^^^^^ -- --- expected `&str`,found `{float}`
+ | |
+ | expected `f32`,found `&'static str`
+ |
+note: function defined here
+ --> $DIR/swapped_arguments.rs:4:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: swap these arguments
+ |
+LL | three_args(1, 1.0, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/swapped_arguments.rs:11:3
+ |
+LL | three_args( "", 1.0, 1);
+ | ^^^^^^^^^^ -- - expected `&str`,found `{integer}`
+ | |
+ | expected `i32`,found `&'static str`
+ |
+note: function defined here
+ --> $DIR/swapped_arguments.rs:4:4
+ |
+LL | fn three_args(_a: i32, _b: f32, _c: &str) {}
+ | ^^^^^^^^^^ ------- ------- --------
+help: swap these arguments
+ |
+LL | three_args(1, 1.0, "");
+ | ~~~~~~~~~~~~~~~~~~~~~~
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/swapped_arguments.rs:13:3
+ |
+LL | four_args(1.0, 1, X {}, "");
+ | ^^^^^^^^^ --- - ---- -- expected `X`,found `&'static str`
+ | | | |
+ | | | expected `&str`,found `X`
+ | | expected `f32`,found `{integer}`
+ | expected `i32`,found `{float}`
+ |
+note: function defined here
+ --> $DIR/swapped_arguments.rs:5:4
+ |
+LL | fn four_args(_a: i32, _b: f32, _c: &str, _d: X) {}
+ | ^^^^^^^^^ ------- ------- -------- -----
+help: did you mean
+ |
+LL | four_args(1, 1.0, "", X {});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--> $DIR/associated-type-projection-from-supertrait.rs:27:23
|
LL | fn b() { dent(ModelT, Blue); }
- | ^^^^ expected struct `Black`, found struct `Blue`
+ | ---- ^^^^ expected struct `Black`, found struct `Blue`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/associated-type-projection-from-supertrait.rs:25:4
+ |
+LL | fn dent<C:Car>(c: C, color: C::Color) { c.chip_paint(color) }
+ | ^^^^ ---- ---------------
error[E0308]: mismatched types
--> $DIR/associated-type-projection-from-supertrait.rs:28:23
|
LL | fn c() { dent(ModelU, Black); }
- | ^^^^^ expected struct `Blue`, found struct `Black`
+ | ---- ^^^^^ expected struct `Blue`, found struct `Black`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/associated-type-projection-from-supertrait.rs:25:4
+ |
+LL | fn dent<C:Car>(c: C, color: C::Color) { c.chip_paint(color) }
+ | ^^^^ ---- ---------------
error[E0308]: mismatched types
--> $DIR/associated-type-projection-from-supertrait.rs:32:28
|
LL | fn f() { ModelT.chip_paint(Blue); }
- | ^^^^ expected struct `Black`, found struct `Blue`
+ | ---------- ^^^^ expected struct `Black`, found struct `Blue`
+ | |
+ | arguments to this function are incorrect
+ |
+note: associated function defined here
+ --> $DIR/associated-type-projection-from-supertrait.rs:12:8
+ |
+LL | fn chip_paint(&self, c: Self::Color) { }
+ | ^^^^^^^^^^ ----- --------------
error[E0308]: mismatched types
--> $DIR/associated-type-projection-from-supertrait.rs:33:28
|
LL | fn g() { ModelU.chip_paint(Black); }
- | ^^^^^ expected struct `Blue`, found struct `Black`
+ | ---------- ^^^^^ expected struct `Blue`, found struct `Black`
+ | |
+ | arguments to this function are incorrect
+ |
+note: associated function defined here
+ --> $DIR/associated-type-projection-from-supertrait.rs:12:8
+ |
+LL | fn chip_paint(&self, c: Self::Color) { }
+ | ^^^^^^^^^^ ----- --------------
error: aborting due to 4 previous errors
--> $DIR/associated-types-path-2.rs:19:14
|
LL | f1(2i32, 4i32);
- | ^^^^ expected `u32`, found `i32`
+ | -- ^^^^ expected `u32`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/associated-types-path-2.rs:13:8
|
+LL | pub fn f1<T: Foo>(a: T, x: T::A) {}
+ | ^^ ---- -------
help: change the type of the numeric literal from `i32` to `u32`
|
LL | f1(2i32, 4u32);
--> $DIR/dont-suggest-missing-await.rs:14:18
|
LL | take_u32(x)
- | ^ expected `u32`, found opaque type
+ | -------- ^ expected `u32`, found opaque type
+ | |
+ | arguments to this function are incorrect
|
note: while checking the return type of the `async fn`
--> $DIR/dont-suggest-missing-await.rs:7:24
| ^^^ 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)
--> $DIR/generator-desc.rs:10:25
|
LL | fun(async {}, async {});
- | -- ^^ expected `async` block, found a different `async` block
- | |
+ | -- ^^
+ | | |
+ | | expected `async` block, found a different `async` block
+ | | arguments to this function are incorrect
| the expected `async` block
|
= note: expected `async` block `[static generator@$DIR/generator-desc.rs:10:15: 10:17]`
found `async` block `[static generator@$DIR/generator-desc.rs:10:25: 10:27]`
+note: function defined here
+ --> $SRC_DIR/core/src/future/mod.rs:LL:COL
+ |
+LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
+ | ^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/generator-desc.rs:12:16
|
LL | fun(one(), two());
- | ^^^^^ expected opaque type, found a different opaque type
- |
-note: while checking the return type of the `async fn`
- --> $DIR/generator-desc.rs:5:16
+ | --- ^^^^^ expected opaque type, found a different opaque type
+ | |
+ | arguments to this function are incorrect
|
-LL | async fn one() {}
- | ^ checked the `Output` of this `async fn`, expected opaque type
note: while checking the return type of the `async fn`
--> $DIR/generator-desc.rs:6:16
|
LL | async fn two() {}
| ^ checked the `Output` of this `async fn`, found opaque type
- = note: expected opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:5:16>)
- found opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:6:16>)
+ = note: expected type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:5:16>)
+ found opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:6:16>)
= help: consider `await`ing on both `Future`s
= note: distinct uses of `impl Trait` result in different opaque types
+note: function defined here
+ --> $DIR/generator-desc.rs:8:4
+ |
+LL | fn fun<F: Future<Output = ()>>(f1: F, f2: F) {}
+ | ^^^ ----- -----
error[E0308]: mismatched types
--> $DIR/generator-desc.rs:14:26
|
LL | fun((async || {})(), (async || {})());
- | -- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body
- | |
- | the expected `async` closure body
+ | --- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body
+ | |
+ | arguments to this function are incorrect
|
::: $SRC_DIR/core/src/future/mod.rs:LL:COL
|
LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
- | -------------------------------
- | |
- | the expected opaque type
- | the found opaque type
+ | ------------------------------- the found opaque type
+ |
+ = note: expected type `impl Future<Output = ()>` (`async` closure body)
+ found opaque type `impl Future<Output = ()>` (`async` closure body)
+note: function defined here
+ --> $DIR/generator-desc.rs:8:4
+ |
+LL | fn fun<F: Future<Output = ()>>(f1: F, f2: F) {}
+ | ^^^ ----- -----
+help: consider `await`ing on the `Future`
|
- = note: expected opaque type `impl Future<Output = ()>` (`async` closure body)
- found opaque type `impl Future<Output = ()>` (`async` closure body)
+LL | fun((async || {})(), (async || {})().await);
+ | ++++++
error: aborting due to 3 previous errors
--> $DIR/suggest-missing-await-closure.rs:16:18
|
LL | take_u32(x)
- | ^ expected `u32`, found opaque type
+ | -------- ^ expected `u32`, found opaque type
+ | |
+ | arguments to this function are incorrect
|
note: while checking the return type of the `async fn`
--> $DIR/suggest-missing-await-closure.rs:8:24
| ^^^ 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)
--> $DIR/suggest-missing-await.rs:12:14
|
LL | take_u32(x)
- | ^ expected `u32`, found opaque type
+ | -------- ^ expected `u32`, found opaque type
+ | |
+ | arguments to this function are incorrect
|
note: while checking the return type of the `async fn`
--> $DIR/suggest-missing-await.rs:5:24
| ^^^ 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)
--> $DIR/variadic-ffi-1.rs:20:9
|
LL | foo();
- | ^^^-- supplied 0 arguments
- | |
- | expected at least 2 arguments
+ | ^^^-- two arguments of type `isize` and `u8` are missing
|
note: function defined here
--> $DIR/variadic-ffi-1.rs:13:8
|
LL | fn foo(f: isize, x: u8, ...);
| ^^^
+help: provide the arguments
+ |
+LL | foo({isize}, {u8});
+ | ~~~~~~~~~~~~~~~~~~
error[E0060]: this function takes at least 2 arguments but 1 argument was supplied
--> $DIR/variadic-ffi-1.rs:21:9
|
LL | foo(1);
- | ^^^ - supplied 1 argument
- | |
- | expected at least 2 arguments
+ | ^^^--- an argument of type `u8` is missing
|
note: function defined here
--> $DIR/variadic-ffi-1.rs:13:8
|
LL | fn foo(f: isize, x: u8, ...);
| ^^^
+help: provide the argument
+ |
+LL | foo(1, {u8});
+ | ~~~~~~~~~~~~
error[E0308]: mismatched types
--> $DIR/variadic-ffi-1.rs:23:56
--> $DIR/cast-int-to-char.rs:4:16
|
LL | foo::<u32>('0');
- | ^^^ expected `u32`, found `char`
+ | ---------- ^^^ expected `u32`, found `char`
+ | |
+ | arguments to this function are incorrect
|
+note: function defined here
+ --> $DIR/cast-int-to-char.rs:1:4
+ |
+LL | fn foo<T>(_t: T) {}
+ | ^^^ -----
help: you can cast a `char` to a `u32`, since a `char` always occupies 4 bytes
|
LL | foo::<u32>('0' as u32);
--> $DIR/cast-int-to-char.rs:5:16
|
LL | foo::<i32>('0');
- | ^^^ expected `i32`, found `char`
+ | ---------- ^^^ expected `i32`, found `char`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/cast-int-to-char.rs:1:4
|
+LL | fn foo<T>(_t: T) {}
+ | ^^^ -----
help: you can cast a `char` to an `i32`, since a `char` always occupies 4 bytes
|
LL | foo::<i32>('0' as i32);
--> $DIR/cast-int-to-char.rs:6:16
|
LL | foo::<u64>('0');
- | ^^^ expected `u64`, found `char`
+ | ---------- ^^^ expected `u64`, found `char`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/cast-int-to-char.rs:1:4
|
+LL | fn foo<T>(_t: T) {}
+ | ^^^ -----
help: you can cast a `char` to a `u64`, since a `char` always occupies 4 bytes
|
LL | foo::<u64>('0' as u64);
--> $DIR/cast-int-to-char.rs:7:16
|
LL | foo::<i64>('0');
- | ^^^ expected `i64`, found `char`
+ | ---------- ^^^ expected `i64`, found `char`
+ | |
+ | arguments to this function are incorrect
|
+note: function defined here
+ --> $DIR/cast-int-to-char.rs:1:4
+ |
+LL | fn foo<T>(_t: T) {}
+ | ^^^ -----
help: you can cast a `char` to an `i64`, since a `char` always occupies 4 bytes
|
LL | foo::<i64>('0' as i64);
--> $DIR/cast-int-to-char.rs:8:17
|
LL | foo::<char>(0u32);
- | ^^^^ expected `char`, found `u32`
+ | ----------- ^^^^ expected `char`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/cast-int-to-char.rs:1:4
+ |
+LL | fn foo<T>(_t: T) {}
+ | ^^^ -----
error: aborting due to 5 previous errors
LL | let f = |s: &str| println!("{}{}", s, string);
| ------------------------------------- the found closure
LL | call_bare(f)
- | ^ expected fn pointer, found closure
+ | --------- ^ expected fn pointer, found closure
+ | |
+ | arguments to this function are incorrect
|
= note: expected fn pointer `for<'r> fn(&'r str)`
found closure `[closure@$DIR/closure-reform-bad.rs:10:13: 10:50]`
|
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
--> $DIR/issue-84128.rs:13:13
|
LL | Foo(())
- | ^^ expected integer, found `()`
+ | --- ^^ expected integer, found `()`
+ | |
+ | arguments to this struct are incorrect
|
note: return type inferred to be `{integer}` here
--> $DIR/issue-84128.rs:10:20
|
LL | return Foo(0);
| ^^^^^^
+note: tuple struct defined here
+ --> $DIR/issue-84128.rs:5:8
+ |
+LL | struct Foo<T>(T);
+ | ^^^
error: aborting due to previous error
--> $DIR/issue-87461.rs:10:8
|
LL | Ok(())
- | ^^ expected `u16`, found `()`
+ | -- ^^ expected `u16`, found `()`
+ | |
+ | arguments to this enum variant are incorrect
error[E0308]: mismatched types
--> $DIR/issue-87461.rs:17:8
|
LL | Ok(())
- | ^^ expected `u16`, found `()`
+ | -- ^^ expected `u16`, found `()`
+ | |
+ | arguments to this enum variant are incorrect
error[E0308]: mismatched types
--> $DIR/issue-87461.rs:26:12
|
LL | Ok(())
- | ^^ expected `u16`, found `()`
+ | -- ^^ expected `u16`, found `()`
+ | |
+ | arguments to this enum variant are incorrect
error: aborting due to 3 previous errors
--> $DIR/coerce-mut.rs:5:7
|
LL | f(&x);
- | ^^ types differ in mutability
+ | - ^^ types differ in mutability
+ | |
+ | arguments to this function are incorrect
|
= note: expected mutable reference `&mut i32`
found reference `&{integer}`
+note: function defined here
+ --> $DIR/coerce-mut.rs:1:4
+ |
+LL | fn f(x: &mut i32) {}
+ | ^ -----------
error: aborting due to previous error
--> $DIR/coerce-reborrow-multi-arg-fail.rs:4:18
|
LL | test(&mut 7, &7);
- | ^^ types differ in mutability
+ | ---- ^^ types differ in mutability
+ | |
+ | arguments to this function are incorrect
|
- = note: expected mutable reference `&mut {integer}`
- found reference `&{integer}`
+ = note: expected type `&mut {integer}`
+ found reference `&{integer}`
+note: function defined here
+ --> $DIR/coerce-reborrow-multi-arg-fail.rs:1:4
+ |
+LL | fn test<T>(_a: T, _b: T) {}
+ | ^^^^ ----- -----
error: aborting due to previous error
--> $DIR/coerce-to-bang.rs:6:17
|
LL | foo(return, 22, 44);
- | ^^ expected `!`, found integer
+ | --- ^^ expected `!`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
+note: function defined here
+ --> $DIR/coerce-to-bang.rs:3:4
+ |
+LL | fn foo(x: usize, y: !, z: usize) { }
+ | ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:18:13
|
LL | foo(22, 44, return);
- | ^^ expected `!`, found integer
+ | --- ^^ expected `!`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
+note: function defined here
+ --> $DIR/coerce-to-bang.rs:3:4
+ |
+LL | fn foo(x: usize, y: !, z: usize) { }
+ | ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:26:12
|
LL | foo(a, b, c); // ... and hence a reference to `a` is expected to diverge.
- | ^ expected `!`, found integer
+ | --- ^ expected `!`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
+note: function defined here
+ --> $DIR/coerce-to-bang.rs:3:4
+ |
+LL | fn foo(x: usize, y: !, z: usize) { }
+ | ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:36:12
|
LL | foo(a, b, c);
- | ^ expected `!`, found integer
+ | --- ^ expected `!`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
+note: function defined here
+ --> $DIR/coerce-to-bang.rs:3:4
+ |
+LL | fn foo(x: usize, y: !, z: usize) { }
+ | ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:45:12
|
LL | foo(a, b, c);
- | ^ expected `!`, found integer
+ | --- ^ expected `!`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `!`
found type `{integer}`
+note: function defined here
+ --> $DIR/coerce-to-bang.rs:3:4
+ |
+LL | fn foo(x: usize, y: !, z: usize) { }
+ | ^^^ -------- ---- --------
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:50:21
--- /dev/null
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/const-argument-cross-crate-mismatch.rs:7:41
+ |
+LL | let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8]));
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^----------^
+ | |
+ | expected `[u8; 3]`, found `[u8; 2]`
+ |
+help: provide an argument of the correct type
+ |
+LL | let _ = const_generic_lib::function(({[u8; 3]}));
+ | ^^^^^^^^^^^
+
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/const-argument-cross-crate-mismatch.rs:9:39
+ |
+LL | let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^
+ | |
+ | expected `[u8; 2]`, found `[u8; 3]`
+ |
+help: provide an argument of the correct type
+ |
+LL | let _: const_generic_lib::Alias = ({[u8; 2]});
+ | ^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--> $DIR/const-argument-cross-crate-mismatch.rs:6:67
|
LL | let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8]));
- | ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
+ | ------------------------- ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
+ | |
+ | arguments to this struct are incorrect
error[E0308]: mismatched types
--> $DIR/const-argument-cross-crate-mismatch.rs:8:65
|
LL | let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]);
- | ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements
+ | ------------------------- ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements
+ | |
+ | arguments to this struct are incorrect
error: aborting due to 2 previous errors
+error: constant expression depends on a generic parameter
+ --> $DIR/issue-62504.rs:18:25
+ |
+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`
+ | ----------- ^^^^^^^^^^^^^^^ expected `X`, found `Self::SIZE`
+ | |
+ | arguments to this struct are incorrect
|
= note: expected array `[u32; X]`
found array `[u32; _]`
-
-error: constant expression depends on a generic parameter
- --> $DIR/issue-62504.rs:18:25
+note: tuple struct defined here
+ --> $DIR/issue-62504.rs:14:8
|
-LL | ArrayHolder([0; Self::SIZE])
- | ^^^^^^^^^^
- |
- = note: this may fail depending on what value the parameter takes
+LL | struct ArrayHolder<const X: usize>([u32; X]);
+ | ^^^^^^^^^^^
error: aborting due to 2 previous errors
--> $DIR/issue-42764.rs:11:43
|
LL | this_function_expects_a_double_option(n);
- | ^ expected enum `DoubleOption`, found `usize`
+ | ------------------------------------- ^ expected enum `DoubleOption`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
= note: expected enum `DoubleOption<_>`
found type `usize`
+note: function defined here
+ --> $DIR/issue-42764.rs:7:4
+ |
+LL | fn this_function_expects_a_double_option<T>(d: DoubleOption<T>) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ------------------
help: try wrapping the expression in a variant of `DoubleOption`
|
LL | this_function_expects_a_double_option(DoubleOption::FirstSome(n));
--> $DIR/disambiguate-identical-names.rs:13:10
|
LL | test(&v);
- | ^^ expected struct `std::vec::Vec`, found struct `HashMap`
+ | ---- ^^ expected struct `std::vec::Vec`, found struct `HashMap`
+ | |
+ | arguments to this function are incorrect
|
= note: expected reference `&std::vec::Vec<std::vec::Vec<u32>>`
found reference `&HashMap<u8, u8>`
+note: function defined here
+ --> $DIR/disambiguate-identical-names.rs:6:4
+ |
+LL | fn test(_v: &Vec<Vec<u32>>) {
+ | ^^^^ ------------------
error: aborting due to previous error
--> $DIR/E0057.rs:3:13
|
LL | let a = f();
- | ^-- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^-- an argument is missing
+ |
+help: provide the argument
+ |
+LL | let a = f({_});
+ | ~~~~~~
error[E0057]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/E0057.rs:5:13
|
LL | let c = f(2, 3);
- | ^ - - supplied 2 arguments
- | |
- | expected 1 argument
+ | ^ - argument unexpected
+ |
+help: remove the extra argument
+ |
+LL | let c = f(2);
+ | ~~~~
error: aborting due to 2 previous errors
fn main() {
unsafe { printf(); }
//~^ ERROR E0060
- //~| expected at least 1 argument
}
--> $DIR/E0060.rs:6:14
|
LL | unsafe { printf(); }
- | ^^^^^^-- supplied 0 arguments
- | |
- | expected at least 1 argument
+ | ^^^^^^-- an argument of type `*const u8` is missing
|
note: function defined here
--> $DIR/E0060.rs:2:8
|
LL | fn printf(_: *const u8, ...) -> u32;
| ^^^^^^
+help: provide the argument
+ |
+LL | unsafe { printf({*const u8}); }
+ | ~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
fn main() {
f(0);
//~^ ERROR E0061
- //~| expected 2 arguments
f2();
//~^ ERROR E0061
- //~| expected 1 argument
}
--> $DIR/E0061.rs:6:5
|
LL | f(0);
- | ^ - supplied 1 argument
- | |
- | expected 2 arguments
+ | ^--- an argument of type `&str` is missing
|
note: function defined here
--> $DIR/E0061.rs:1:4
|
LL | fn f(a: u16, b: &str) {}
| ^ ------ -------
+help: provide the argument
+ |
+LL | f(0, {&str});
+ | ~~~~~~~~~~~~
error[E0061]: this function takes 1 argument but 0 arguments were supplied
- --> $DIR/E0061.rs:10:5
+ --> $DIR/E0061.rs:9:5
|
LL | f2();
- | ^^-- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^^-- an argument of type `u16` is missing
|
note: function defined here
--> $DIR/E0061.rs:3:4
|
LL | fn f2(a: u16) {}
| ^^ ------
+help: provide the argument
+ |
+LL | f2({u16});
+ | ~~~~~~~~~
error: aborting due to 2 previous errors
--- /dev/null
+fn wants_uniq(x: String) { }
+fn wants_slice(x: &str) { }
+
+fn has_uniq(x: String) {
+ wants_uniq(x);
+ wants_slice(&*x);
+}
+
+fn has_slice(x: &str) {
+ wants_uniq(x); //~ ERROR mismatched types
+ wants_slice(x);
+}
+
+fn main() {
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/estr-subtyping.rs:10:15
+ |
+LL | wants_uniq(x);
+ | ---------- ^- help: try using a conversion method: `.to_string()`
+ | | |
+ | | expected struct `String`, found `&str`
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/estr-subtyping.rs:1:4
+ |
+LL | fn wants_uniq(x: String) { }
+ | ^^^^^^^^^^ ---------
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--> $DIR/ifmt-bad-arg.rs:78:32
|
LL | println!("{} {:.*} {}", 1, 3.2, 4);
- | ^^^ expected `usize`, found floating-point number
+ | ---------------------------^^^----
+ | | |
+ | | expected `usize`, found floating-point number
+ | arguments to this function are incorrect
|
= note: expected reference `&usize`
found reference `&{float}`
+note: associated function defined here
+ --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
+ |
+LL | pub fn from_usize(x: &usize) -> ArgumentV1<'_> {
+ | ^^^^^^^^^^
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0308]: mismatched types
--> $DIR/ifmt-bad-arg.rs:81:35
|
LL | println!("{} {:07$.*} {}", 1, 3.2, 4);
- | ^^^ expected `usize`, found floating-point number
+ | ------------------------------^^^----
+ | | |
+ | | expected `usize`, found floating-point number
+ | arguments to this function are incorrect
|
= note: expected reference `&usize`
found reference `&{float}`
+note: associated function defined here
+ --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
+ |
+LL | pub fn from_usize(x: &usize) -> ArgumentV1<'_> {
+ | ^^^^^^^^^^
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 36 previous errors
fn main() {
eq(foo::<u8>, bar::<u8>);
//~^ ERROR mismatched types
- //~| expected fn item `fn(_) -> _ {foo::<u8>}`
+ //~| expected type `fn(_) -> _ {foo::<u8>}`
//~| found fn item `fn(_) -> _ {bar::<u8>}`
//~| expected fn item, found a different fn item
//~| different `fn` items always have unique types, even if their signatures are the same
eq(bar::<String>, bar::<Vec<u8>>);
//~^ ERROR mismatched types
- //~| expected fn item `fn(_) -> _ {bar::<String>}`
+ //~| expected type `fn(_) -> _ {bar::<String>}`
//~| found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
//~| expected struct `String`, found struct `Vec`
//~| different `fn` items always have unique types, even if their signatures are the same
eq(foo::<u8>, bar::<u8> as fn(isize) -> isize);
//~^ ERROR mismatched types
- //~| expected fn item `fn(_) -> _ {foo::<u8>}`
+ //~| expected type `fn(_) -> _ {foo::<u8>}`
//~| found fn pointer `fn(_) -> _`
//~| expected fn item, found fn pointer
//~| change the expected type to be function pointer
--> $DIR/fn-item-type.rs:13:19
|
LL | eq(foo::<u8>, bar::<u8>);
- | ^^^^^^^^^ expected fn item, found a different fn item
+ | -- ^^^^^^^^^ expected fn item, found a different fn item
+ | |
+ | arguments to this function are incorrect
|
- = note: expected fn item `fn(_) -> _ {foo::<u8>}`
- found fn item `fn(_) -> _ {bar::<u8>}`
+ = note: expected type `fn(_) -> _ {foo::<u8>}`
+ found fn item `fn(_) -> _ {bar::<u8>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`
+note: function defined here
+ --> $DIR/fn-item-type.rs:7:4
+ |
+LL | fn eq<T>(x: T, y: T) { }
+ | ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:22:19
|
LL | eq(foo::<u8>, foo::<i8>);
- | ^^^^^^^^^ expected `u8`, found `i8`
+ | -- ^^^^^^^^^ expected `u8`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
- = note: expected fn item `fn(_) -> _ {foo::<u8>}`
- found fn item `fn(_) -> _ {foo::<i8>}`
+ = note: expected type `fn(_) -> _ {foo::<u8>}`
+ found fn item `fn(_) -> _ {foo::<i8>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`
+note: function defined here
+ --> $DIR/fn-item-type.rs:7:4
+ |
+LL | fn eq<T>(x: T, y: T) { }
+ | ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:29:23
|
LL | eq(bar::<String>, bar::<Vec<u8>>);
- | ^^^^^^^^^^^^^^ expected struct `String`, found struct `Vec`
+ | -- ^^^^^^^^^^^^^^ expected struct `String`, found struct `Vec`
+ | |
+ | arguments to this function are incorrect
|
- = note: expected fn item `fn(_) -> _ {bar::<String>}`
- found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
+ = note: expected type `fn(_) -> _ {bar::<String>}`
+ found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `bar::<String> as fn(isize) -> isize`
+note: function defined here
+ --> $DIR/fn-item-type.rs:7:4
+ |
+LL | fn eq<T>(x: T, y: T) { }
+ | ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:39:26
|
LL | eq(<u8 as Foo>::foo, <u16 as Foo>::foo);
- | ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16`
+ | -- ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16`
+ | |
+ | arguments to this function are incorrect
|
- = note: expected fn item `fn() {<u8 as Foo>::foo}`
- found fn item `fn() {<u16 as Foo>::foo}`
+ = note: expected type `fn() {<u8 as Foo>::foo}`
+ found fn item `fn() {<u16 as Foo>::foo}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn()`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `<u8 as Foo>::foo as fn()`
+note: function defined here
+ --> $DIR/fn-item-type.rs:7:4
+ |
+LL | fn eq<T>(x: T, y: T) { }
+ | ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:46:19
|
LL | eq(foo::<u8>, bar::<u8> as fn(isize) -> isize);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer
+ | -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer
+ | |
+ | arguments to this function are incorrect
|
- = note: expected fn item `fn(_) -> _ {foo::<u8>}`
+ = note: expected type `fn(_) -> _ {foo::<u8>}`
found fn pointer `fn(_) -> _`
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`
+note: function defined here
+ --> $DIR/fn-item-type.rs:7:4
+ |
+LL | fn eq<T>(x: T, y: T) { }
+ | ^^ ---- ----
error: aborting due to 5 previous errors
LL | fn bug<'a, T: Fun<F<'a> = T>>(t: T) -> T::F<'a> {
| - this type parameter
LL | T::identity(())
- | ^^ expected type parameter `T`, found `()`
+ | ----------- ^^ expected type parameter `T`, found `()`
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `T`
found unit type `()`
+note: associated function defined here
+ --> $DIR/issue-68648-2.rs:6:8
+ |
+LL | fn identity<'a>(t: Self::F<'a>) -> Self::F<'a> { t }
+ | ^^^^^^^^ --------------
error: aborting due to previous error
| - this type parameter
...
LL | A(self.0 + rhs.0)
- | ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
+ | - ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
+ | |
+ | arguments to this struct are incorrect
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
+note: tuple struct defined here
+ --> $DIR/missing-bounds.rs:5:8
+ |
+LL | struct A<B>(B);
+ | ^
help: consider further restricting this bound
|
LL | impl<B> Add for A<B> where B: Add + Add<Output = B> {
| - this type parameter
...
LL | Self(self.0 + rhs.0)
- | ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
+ | ---- ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
+note: tuple struct defined here
+ --> $DIR/missing-bounds.rs:15:8
+ |
+LL | struct C<B>(B);
+ | ^
help: consider further restricting this bound
|
LL | impl<B: Add + Add<Output = B>> Add for C<B> {
| - this type parameter
...
LL | Self(self.0 + rhs.0)
- | ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
+ | ---- ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
+note: tuple struct defined here
+ --> $DIR/missing-bounds.rs:35:8
+ |
+LL | struct E<B>(B);
+ | ^
help: consider further restricting type parameter `B`
|
LL | impl<B: Add> Add for E<B> where <B as Add>::Output = B, B: Add<Output = B> {
--> $DIR/issue-58451.rs:12:9
|
LL | f(&[f()]);
- | ^-- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^-- an argument is missing
|
note: function defined here
--> $DIR/issue-58451.rs:5:4
|
LL | fn f<I>(i: I)
| ^ ----
+help: provide the argument
+ |
+LL | f(&[f({_})]);
+ | ~~~~~~
error: aborting due to previous error
| ---------------- the expected opaque type
...
LL | Anonymous(|| {
- | _______________^
+ | _____---------_^
+ | | |
+ | | arguments to this struct are incorrect
LL | | 3
LL | | })
| |_____^ expected closure, found a different closure
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
--> $DIR/indexing-requires-a-uint.rs:12:18
|
LL | bar::<isize>(i); // i should not be re-coerced back to an isize
- | ^ expected `isize`, found `usize`
+ | ------------ ^ expected `isize`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
-help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
+note: function defined here
+ --> $DIR/indexing-requires-a-uint.rs:5:8
|
-LL | bar::<isize>(i.try_into().unwrap()); // i should not be re-coerced back to an isize
- | ++++++++++++++++++++
+LL | fn bar<T>(_: T) {}
+ | ^^^ ----
error: aborting due to 2 previous errors
--> $DIR/deref-suggestion.rs:8:9
|
LL | foo(s);
- | ^- help: try using a conversion method: `.to_string()`
- | |
- | expected struct `String`, found `&String`
+ | --- ^- help: try using a conversion method: `.to_string()`
+ | | |
+ | | expected struct `String`, found `&String`
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/deref-suggestion.rs:5:4
+ |
+LL | fn foo(_: String) {}
+ | ^^^ ---------
error[E0308]: mismatched types
--> $DIR/deref-suggestion.rs:14:10
|
LL | foo3(u);
- | ^ expected `u32`, found `&u32`
+ | ---- ^ expected `u32`, found `&u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/deref-suggestion.rs:12:4
|
+LL | fn foo3(_: u32) {}
+ | ^^^^ ------
help: consider dereferencing the borrow
|
LL | foo3(*u);
--> $DIR/deref-suggestion.rs:30:9
|
LL | foo(&"aaa".to_owned());
- | ^^^^^^^^^^^^^^^^^ expected struct `String`, found `&String`
+ | --- ^^^^^^^^^^^^^^^^^ expected struct `String`, found `&String`
+ | |
+ | arguments to this function are incorrect
|
+note: function defined here
+ --> $DIR/deref-suggestion.rs:5:4
+ |
+LL | fn foo(_: String) {}
+ | ^^^ ---------
help: consider removing the borrow
|
LL - foo(&"aaa".to_owned());
--> $DIR/deref-suggestion.rs:32:9
|
LL | foo(&mut "aaa".to_owned());
- | ^^^^^^^^^^^^^^^^^^^^^ expected struct `String`, found `&mut String`
+ | --- ^^^^^^^^^^^^^^^^^^^^^ expected struct `String`, found `&mut String`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/deref-suggestion.rs:5:4
|
+LL | fn foo(_: String) {}
+ | ^^^ ---------
help: consider removing the borrow
|
LL - foo(&mut "aaa".to_owned());
| ^^^ expected `u32`, found `&{integer}`
...
LL | foo3(borrow!(0));
- | ---------- in this macro invocation
+ | ---- ---------- in this macro invocation
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/deref-suggestion.rs:12:4
|
+LL | fn foo3(_: u32) {}
+ | ^^^^ ------
= note: this error originates in the macro `borrow` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0308]: mismatched types
--> $DIR/tutorial-suffix-inference-test.rs:9:18
|
LL | identity_u16(x);
- | ^ expected `u16`, found `u8`
+ | ------------ ^ expected `u16`, found `u8`
+ | |
+ | arguments to this function are incorrect
|
+note: function defined here
+ --> $DIR/tutorial-suffix-inference-test.rs:6:8
+ |
+LL | fn identity_u16(n: u16) -> u16 { n }
+ | ^^^^^^^^^^^^ ------
help: you can convert a `u8` to a `u16`
|
LL | identity_u16(x.into());
--> $DIR/tutorial-suffix-inference-test.rs:12:18
|
LL | identity_u16(y);
- | ^ expected `u16`, found `i32`
+ | ------------ ^ expected `u16`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/tutorial-suffix-inference-test.rs:6:8
|
+LL | fn identity_u16(n: u16) -> u16 { n }
+ | ^^^^^^^^^^^^ ------
help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit
|
LL | identity_u16(y.try_into().unwrap());
--> $DIR/tutorial-suffix-inference-test.rs:21:18
|
LL | identity_u16(a);
- | ^ expected `u16`, found `isize`
+ | ------------ ^ expected `u16`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/tutorial-suffix-inference-test.rs:6:8
|
+LL | fn identity_u16(n: u16) -> u16 { n }
+ | ^^^^^^^^^^^^ ------
help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit
|
LL | identity_u16(a.try_into().unwrap());
--> $DIR/issue-10764.rs:4:15
|
LL | fn main() { f(bar) }
- | ^^^ expected "Rust" fn, found "C" fn
+ | - ^^^ expected "Rust" fn, found "C" fn
+ | |
+ | arguments to this function are incorrect
|
= note: expected fn pointer `fn()`
found fn item `extern "C" fn() {bar}`
+note: function defined here
+ --> $DIR/issue-10764.rs:1:4
+ |
+LL | fn f(_: extern "Rust" fn()) {}
+ | ^ ---------------------
error: aborting due to previous error
--> $DIR/issue-11374.rs:26:15
|
LL | c.read_to(v);
- | ^
- | |
- | expected `&mut [u8]`, found struct `Vec`
- | help: consider mutably borrowing here: `&mut v`
+ | ------- ^
+ | | |
+ | | expected `&mut [u8]`, found struct `Vec`
+ | | help: consider mutably borrowing here: `&mut v`
+ | arguments to this function are incorrect
|
= note: expected mutable reference `&mut [u8]`
found struct `Vec<_>`
+note: associated function defined here
+ --> $DIR/issue-11374.rs:13:12
+ |
+LL | pub fn read_to(&mut self, vec: &mut [u8]) {
+ | ^^^^^^^ --------- --------------
error: aborting due to previous error
LL | #[bench]
| -------- in this procedural macro expansion
LL | fn bar(x: isize) { }
- | ^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `&mut Bencher`
+ | ^^^^^^^^^^^^^^^^^^^^
+ | |
+ | expected `isize`, found `&mut Bencher`
+ | arguments to this function are incorrect
|
+note: function defined here
+ --> $DIR/issue-12997-2.rs:8:4
+ |
+LL | fn bar(x: isize) { }
+ | ^^^ --------
= note: this error originates in the attribute macro `bench` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error
--> $DIR/issue-13359.rs:6:9
|
LL | foo(1*(1 as isize));
- | ^^^^^^^^^^^^^^ expected `i16`, found `isize`
+ | --- ^^^^^^^^^^^^^^ expected `i16`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
-help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit
+note: function defined here
+ --> $DIR/issue-13359.rs:1:4
|
-LL | foo((1*(1 as isize)).try_into().unwrap());
- | + +++++++++++++++++++++
+LL | fn foo(_s: i16) { }
+ | ^^^ -------
error[E0308]: mismatched types
--> $DIR/issue-13359.rs:10:9
|
LL | bar(1*(1 as usize));
- | ^^^^^^^^^^^^^^ expected `u32`, found `usize`
+ | --- ^^^^^^^^^^^^^^ expected `u32`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
-help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit
+note: function defined here
+ --> $DIR/issue-13359.rs:3:4
|
-LL | bar((1*(1 as usize)).try_into().unwrap());
- | + +++++++++++++++++++++
+LL | fn bar(_s: u32) { }
+ | ^^^ -------
error: aborting due to 2 previous errors
--> $DIR/issue-13853.rs:37:13
|
LL | iterate(graph);
- | ^^^^^
- | |
- | expected reference, found struct `Vec`
- | help: consider borrowing here: `&graph`
+ | ------- ^^^^^
+ | | |
+ | | expected reference, found struct `Vec`
+ | | help: consider borrowing here: `&graph`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `Vec<Stuff>`
+note: function defined here
+ --> $DIR/issue-13853.rs:26:4
+ |
+LL | fn iterate<N: Node, G: Graph<N>>(graph: &G) {
+ | ^^^^^^^ ---------
error: aborting due to 3 previous errors
--> $DIR/issue-1448-2.rs:6:24
|
LL | println!("{}", foo(10i32));
- | ^^^^^ expected `u32`, found `i32`
+ | --- ^^^^^ expected `u32`, found `i32`
+ | |
+ | arguments to this function are incorrect
|
+note: function defined here
+ --> $DIR/issue-1448-2.rs:3:4
+ |
+LL | fn foo(a: u32) -> u32 { a }
+ | ^^^ ------
help: change the type of the numeric literal from `i32` to `u32`
|
LL | println!("{}", foo(10u32));
--> $DIR/issue-15783.rs:8:19
|
LL | let msg = foo(x);
- | ^ expected slice `[&str]`, found array `[&str; 1]`
+ | --- ^ expected slice `[&str]`, found array `[&str; 1]`
+ | |
+ | arguments to this function are incorrect
|
= note: expected enum `Option<&[&str]>`
found enum `Option<&[&str; 1]>`
+note: function defined here
+ --> $DIR/issue-15783.rs:1:8
+ |
+LL | pub fn foo(params: Option<&[&str]>) -> usize {
+ | ^^^ -----------------------
error: aborting due to previous error
--> $DIR/issue-16939.rs:5:9
|
LL | |t| f(t);
- | ^ - supplied 1 argument
- | |
- | expected 0 arguments
+ | ^ - argument unexpected
|
note: associated function defined here
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
|
LL | extern "rust-call" fn call(&self, args: Args) -> Self::Output;
| ^^^^
+help: remove the extra argument
+ |
+LL | |t| f();
+ | ~~~
error: aborting due to previous error
--> $DIR/issue-17033.rs:2:10
|
LL | (*p)(())
- | ^^
- | |
- | expected `&mut ()`, found `()`
- | help: consider mutably borrowing here: `&mut ()`
+ | ---- ^^
+ | | |
+ | | expected `&mut ()`, found `()`
+ | | help: consider mutably borrowing here: `&mut ()`
+ | arguments to this function are incorrect
error: aborting due to previous error
--> $DIR/issue-18819.rs:16:5
|
LL | print_x(X);
- | ^^^^^^^ - supplied 1 argument
- | |
- | expected 2 arguments
+ | ^^^^^^^---
+ | ||
+ | |expected reference, found struct `X`
+ | an argument of type `&str` is missing
|
+ = note: expected reference `&dyn Foo<Item = bool>`
+ found struct `X`
note: function defined here
--> $DIR/issue-18819.rs:11:4
|
LL | fn print_x(_: &dyn Foo<Item=bool>, extra: &str) {
| ^^^^^^^ ---------------------- -----------
+help: consider borrowing here
+ |
+LL | print_x(&X);
+ | ~~
+help: provide the argument
+ |
+LL | print_x({&dyn Foo<Item = bool>}, {&str});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
--> $DIR/issue-24819.rs:5:9
|
LL | foo(&mut v);
- | ^^^^^^ expected struct `HashSet`, found struct `Vec`
+ | --- ^^^^^^ expected struct `HashSet`, found struct `Vec`
+ | |
+ | arguments to this function are incorrect
|
= note: expected mutable reference `&mut HashSet<u32>`
found mutable reference `&mut Vec<_>`
+note: function defined here
+ --> $DIR/issue-24819.rs:10:4
+ |
+LL | fn foo(h: &mut HashSet<u32>) {
+ | ^^^ --------------------
error: aborting due to previous error
macro_rules! some_macro {
($other: expr) => ({
- $other(None) //~ NOTE supplied 1 argument
+ $other(None) //~ NOTE argument unexpected
})
}
fn main() {
some_macro!(some_function);
//~^ ERROR this function takes 0 arguments but 1 argument was supplied
- //~| NOTE expected 0 arguments
+ //~| NOTE in this expansion of some_macro!
}
--> $DIR/issue-26094.rs:10:17
|
LL | $other(None)
- | ---- supplied 1 argument
+ | ---- argument unexpected
...
LL | some_macro!(some_function);
- | ^^^^^^^^^^^^^ expected 0 arguments
+ | ^^^^^^^^^^^^^
|
note: function defined here
--> $DIR/issue-26094.rs:7:4
|
LL | fn some_function() {}
| ^^^^^^^^^^^^^
+help: remove the extra argument
+ |
+LL | some_function()
+ | ~~~~~~~~~~~~~~~
error: aborting due to previous error
let needlesArr: Vec<char> = vec!['a', 'f'];
needlesArr.iter().fold(|x, y| {
});
- //~^^ ERROR this function takes 2 arguments but 1 argument was supplied
+ //~^^ ERROR mismatched types
+ //~| ERROR this function takes 2 arguments but 1 argument was supplied
}
+error[E0308]: mismatched types
+ --> $DIR/issue-3044.rs:3:35
+ |
+LL | needlesArr.iter().fold(|x, y| {
+ | ___________________________________^
+LL | | });
+ | |_____^ expected closure, found `()`
+ |
+ = note: expected closure `[closure@$DIR/issue-3044.rs:3:28: 4:6]`
+ found unit type `()`
+
error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/issue-3044.rs:3:23
|
LL | needlesArr.iter().fold(|x, y| {
- | _______________________^^^^_-
- | | |
- | | expected 2 arguments
+ | _______________________^^^^-
LL | | });
- | |_____- supplied 1 argument
+ | |______- an argument is missing
|
note: associated function defined here
--> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
|
LL | fn fold<B, F>(mut self, init: B, mut f: F) -> B
| ^^^^
+help: provide the argument
+ |
+LL ~ needlesArr.iter().fold(|x, y| {
+LL ~ }, {_});
+ |
-error: aborting due to previous error
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0061`.
+Some errors have detailed explanations: E0061, E0308.
+For more information about an error, try `rustc --explain E0061`.
--> $DIR/issue-43420-no-over-suggest.rs:8:9
|
LL | foo(&a);
- | ^^ expected slice `[u16]`, found struct `Vec`
+ | --- ^^ expected slice `[u16]`, found struct `Vec`
+ | |
+ | arguments to this function are incorrect
|
= note: expected reference `&[u16]`
found reference `&Vec<u8>`
+note: function defined here
+ --> $DIR/issue-43420-no-over-suggest.rs:4:4
+ |
+LL | fn foo(b: &[u16]) {}
+ | ^^^ ---------
error: aborting due to previous error
--> $DIR/issue-4517.rs:5:9
|
LL | bar(foo);
- | ^^^ expected `usize`, found array `[u8; 4]`
+ | --- ^^^ expected `usize`, found array `[u8; 4]`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/issue-4517.rs:1:4
+ |
+LL | fn bar(int_param: usize) {}
+ | ^^^ ----------------
error: aborting due to previous error
--> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:12:42
|
LL | light_flows_our_war_of_mocking_words(behold as usize);
- | ^^^^^^^^^^^^^^^
- | |
- | expected `&usize`, found `usize`
- | help: consider borrowing here: `&(behold as usize)`
+ | ------------------------------------ ^^^^^^^^^^^^^^^
+ | | |
+ | | expected `&usize`, found `usize`
+ | | help: consider borrowing here: `&(behold as usize)`
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:5:4
+ |
+LL | fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ---------------
error[E0308]: mismatched types
--> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:14:42
|
LL | light_flows_our_war_of_mocking_words(with_tears + 4);
- | ^^^^^^^^^^^^^^
- | |
- | expected `&usize`, found `usize`
- | help: consider borrowing here: `&(with_tears + 4)`
+ | ------------------------------------ ^^^^^^^^^^^^^^
+ | | |
+ | | expected `&usize`, found `usize`
+ | | help: consider borrowing here: `&(with_tears + 4)`
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:5:4
+ |
+LL | fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ---------------
error: aborting due to 2 previous errors
--> $DIR/issue-48364.rs:2:21
|
LL | b"".starts_with(stringify!(foo))
- | ^^^^^^^^^^^^^^^ expected slice `[u8]`, found `str`
+ | ----------- ^^^^^^^^^^^^^^^ expected slice `[u8]`, found `str`
+ | |
+ | arguments to this function are incorrect
|
= note: expected reference `&[u8]`
found reference `&'static str`
+note: associated function defined here
+ --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
+ |
+LL | pub fn starts_with(&self, needle: &[T]) -> bool
+ | ^^^^^^^^^^^
= note: this error originates in the macro `stringify` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error
--> $DIR/issue-4935.rs:5:13
|
LL | fn main() { foo(5, 6) }
- | ^^^ - - supplied 2 arguments
- | |
- | expected 1 argument
+ | ^^^ - argument unexpected
|
note: function defined here
--> $DIR/issue-4935.rs:3:4
|
LL | fn foo(a: usize) {}
| ^^^ --------
+help: remove the extra argument
+ |
+LL | fn main() { foo(5) }
+ | ~~~~~~
error: aborting due to previous error
LL | fn foo<F: FnMut()>() {
| - this type parameter
LL | let _: Box<F> = Box::new(|| ());
- | ^^^^^ expected type parameter `F`, found closure
+ | -------- ^^^^^ expected type parameter `F`, found closure
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `F`
found closure `[closure@$DIR/issue-51154.rs:2:30: 2:35]`
= help: every closure has a distinct type and so could not always match the caller-chosen type of parameter `F`
+note: associated function defined here
+ --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+ |
+LL | pub fn new(x: T) -> Self {
+ | ^^^
error: aborting due to previous error
--> $DIR/issue-5216.rs:3:21
|
LL | pub static C: S = S(f);
- | ^ expected struct `Box`, found fn item
+ | - ^ expected struct `Box`, found fn item
+ | |
+ | arguments to this struct are incorrect
|
= note: expected struct `Box<(dyn FnMut() + Sync + 'static)>`
found fn item `fn() {f}`
+note: tuple struct defined here
+ --> $DIR/issue-5216.rs:2:8
+ |
+LL | struct S(Box<dyn FnMut() + Sync>);
+ | ^
error[E0308]: mismatched types
--> $DIR/issue-5216.rs:8:19
--> $DIR/issue-61106.rs:3:9
|
LL | foo(x.clone());
- | ^^^^^^^^^
- | |
- | expected `&str`, found struct `String`
- | help: consider borrowing here: `&x`
+ | --- ^^^^^^^^^
+ | | |
+ | | expected `&str`, found struct `String`
+ | | help: consider borrowing here: `&x`
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/issue-61106.rs:6:4
+ |
+LL | fn foo(_: &str) {}
+ | ^^^ -------
error: aborting due to previous error
LL | impl<T> S0<T> {
| - this type parameter
LL | const C: S0<u8> = Self(0);
- | ^ expected type parameter `T`, found integer
+ | ---- ^ expected type parameter `T`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `T`
found type `{integer}`
+note: tuple struct defined here
+ --> $DIR/issue-69306.rs:3:8
+ |
+LL | struct S0<T>(T);
+ | ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:5:23
| - this type parameter
...
LL | Self(0);
- | ^ expected type parameter `T`, found integer
+ | ---- ^ expected type parameter `T`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `T`
found type `{integer}`
+note: tuple struct defined here
+ --> $DIR/issue-69306.rs:3:8
+ |
+LL | struct S0<T>(T);
+ | ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:27:14
| - this type parameter
LL | fn foo() {
LL | Self(0);
- | ^ expected type parameter `T`, found integer
+ | ---- ^ expected type parameter `T`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `T`
found type `{integer}`
+note: tuple struct defined here
+ --> $DIR/issue-69306.rs:3:8
+ |
+LL | struct S0<T>(T);
+ | ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:33:32
LL | impl<T> S1<T, u8> {
| - this type parameter
LL | const C: S1<u8, u8> = Self(0, 1);
- | ^ expected type parameter `T`, found integer
+ | ---- ^ expected type parameter `T`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `T`
found type `{integer}`
+note: tuple struct defined here
+ --> $DIR/issue-69306.rs:31:8
+ |
+LL | struct S1<T, U>(T, U);
+ | ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:33:27
LL | fn map<U>(x: U) -> S2<U> {
| - found type parameter
LL | Self(x)
- | ^ expected type parameter `T`, found type parameter `U`
+ | ---- ^ expected type parameter `T`, found type parameter `U`
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `T`
found type parameter `U`
= note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
= note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
+note: tuple struct defined here
+ --> $DIR/issue-69306.rs:38:8
+ |
+LL | struct S2<T>(T);
+ | ^^
error[E0308]: mismatched types
--> $DIR/issue-69306.rs:41:9
--> $DIR/issue-29084.rs:4:13
|
LL | bar(&mut $d);
- | ^^^^^^^ expected `u8`, found `&mut u8`
+ | --- ^^^^^^^ expected `u8`, found `&mut u8`
+ | |
+ | arguments to this function are incorrect
...
LL | foo!(0u8);
| --------- in this macro invocation
|
+note: function defined here
+ --> $DIR/issue-29084.rs:3:12
+ |
+LL | fn bar(d: u8) { }
+ | ^^^ -----
+...
+LL | foo!(0u8);
+ | --------- in this macro invocation
= note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to previous error
--> $DIR/method-call-err-msg.rs:13:7
|
LL | x.zero(0)
- | ^^^^ - supplied 1 argument
- | |
- | expected 0 arguments
+ | ^^^^ - argument unexpected
|
note: associated function defined here
--> $DIR/method-call-err-msg.rs:5:8
|
LL | fn zero(self) -> Foo { self }
| ^^^^ ----
+help: remove the extra argument
+ |
+LL | x.zero()
+ | ~~~~~~
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/method-call-err-msg.rs:14:7
|
LL | .one()
- | ^^^- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^^^-- an argument of type `isize` is missing
|
note: associated function defined here
--> $DIR/method-call-err-msg.rs:6:8
|
LL | fn one(self, _: isize) -> Foo { self }
| ^^^ ---- --------
+help: provide the argument
+ |
+LL | .one({isize})
+ | ~~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/method-call-err-msg.rs:15:7
|
LL | .two(0);
- | ^^^ - supplied 1 argument
- | |
- | expected 2 arguments
+ | ^^^--- an argument of type `isize` is missing
|
note: associated function defined here
--> $DIR/method-call-err-msg.rs:7:8
|
LL | fn two(self, _: isize, _: isize) -> Foo { self }
| ^^^ ---- -------- --------
+help: provide the argument
+ |
+LL | .two(0, {isize});
+ | ~~~~~~~~~~~~~~~
error[E0599]: `Foo` is not an iterator
--> $DIR/method-call-err-msg.rs:19:7
--> $DIR/method-call-err-msg.rs:21:7
|
LL | y.three::<usize>();
- | ^^^^^--------- supplied 0 arguments
- | |
- | expected 3 arguments
+ | ^^^^^^^^^^^^^^-- three arguments of type `usize`, `usize`, and `usize` are missing
|
note: associated function defined here
--> $DIR/method-call-err-msg.rs:8:8
|
LL | fn three<T>(self, _: T, _: T, _: T) -> Foo { self }
| ^^^^^ ---- ---- ---- ----
+help: provide the arguments
+ |
+LL | y.three::<usize>({usize}, {usize}, {usize});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 5 previous errors
--> $DIR/method-self-arg-1.rs:11:14
|
LL | Foo::bar(x);
- | ^
- | |
- | expected `&Foo`, found struct `Foo`
- | help: consider borrowing here: `&x`
+ | -------- ^
+ | | |
+ | | expected `&Foo`, found struct `Foo`
+ | | help: consider borrowing here: `&x`
+ | arguments to this function are incorrect
+ |
+note: associated function defined here
+ --> $DIR/method-self-arg-1.rs:6:8
+ |
+LL | fn bar(&self) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/method-self-arg-1.rs:13:14
|
LL | Foo::bar(&42);
- | ^^^ expected struct `Foo`, found integer
+ | -------- ^^^ expected struct `Foo`, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected reference `&Foo`
found reference `&{integer}`
+note: associated function defined here
+ --> $DIR/method-self-arg-1.rs:6:8
+ |
+LL | fn bar(&self) {}
+ | ^^^ -----
error: aborting due to 2 previous errors
error[E0308]: mismatched types
--> $DIR/issue-26480.rs:16:19
|
+LL | write(stdout, $arr.as_ptr() as *const i8,
+ | ----- arguments to this function are incorrect
LL | $arr.len() * size_of($arr[0]));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `u64`, found `usize`
...
LL | write!(hello);
| ------------- in this macro invocation
|
- = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit
+note: function defined here
+ --> $DIR/issue-26480.rs:2:8
|
-LL | ($arr.len() * size_of($arr[0])).try_into().unwrap());
- | + +++++++++++++++++++++
+LL | fn write(fildes: i32, buf: *const i8, nbyte: u64) -> i64;
+ | ^^^^^
+ = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0605]: non-primitive cast: `{integer}` as `()`
--> $DIR/issue-26480.rs:22:19
| ---- this type parameter
LL | fn parse(text: &str) -> Option<bool> {
LL | Some(true)
- | ^^^^ expected type parameter `bool`, found `bool`
+ | ---- ^^^^ expected type parameter `bool`, found `bool`
+ | |
+ | arguments to this enum variant are incorrect
|
= note: expected type parameter `bool` (type parameter `bool`)
found type `bool` (`bool`)
--> $DIR/numeric-literal-cast.rs:6:9
|
LL | foo(1u8);
- | ^^^ expected `u16`, found `u8`
+ | --- ^^^ expected `u16`, found `u8`
+ | |
+ | arguments to this function are incorrect
|
+note: function defined here
+ --> $DIR/numeric-literal-cast.rs:1:4
+ |
+LL | fn foo(_: u16) {}
+ | ^^^ ------
help: change the type of the numeric literal from `u8` to `u16`
|
LL | foo(1u16);
--> $DIR/numeric-literal-cast.rs:8:10
|
LL | foo1(2f32);
- | ^^^^ expected `f64`, found `f32`
+ | ---- ^^^^ expected `f64`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-literal-cast.rs:2:4
|
+LL | fn foo1(_: f64) {}
+ | ^^^^ ------
help: change the type of the numeric literal from `f32` to `f64`
|
LL | foo1(2f64);
--> $DIR/numeric-literal-cast.rs:10:10
|
LL | foo2(3i16);
- | ^^^^ expected `i32`, found `i16`
+ | ---- ^^^^ expected `i32`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-literal-cast.rs:3:4
|
+LL | fn foo2(_: i32) {}
+ | ^^^^ ------
help: change the type of the numeric literal from `i16` to `i32`
|
LL | foo2(3i32);
//~^ 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
}
--> $DIR/overloaded-calls-bad.rs:28:17
|
LL | let ans = s("what");
- | ^^^^^^ expected `isize`, found `&str`
+ | - ^^^^^^ expected `isize`, found `&str`
+ | |
+ | arguments to this function are incorrect
+ |
+note: associated function defined here
+ --> $SRC_DIR/core/src/ops/function.rs:LL:COL
+ |
+LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
+ | ^^^^^^^^
error[E0057]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/overloaded-calls-bad.rs:29:15
|
LL | let ans = s();
- | ^-- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^-- an argument of type `isize` is missing
|
note: associated function defined here
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
|
LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
| ^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/overloaded-calls-bad.rs:31:17
+help: provide the argument
|
-LL | let ans = s("burma", "shave");
- | ^^^^^^^ expected `isize`, found `&str`
+LL | let ans = s({isize});
+ | ~~~~~~~~~~
error[E0057]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/overloaded-calls-bad.rs:31:15
|
LL | let ans = s("burma", "shave");
- | ^ ------- ------- supplied 2 arguments
- | |
- | expected 1 argument
+ | ^ ------- ------- argument unexpected
+ | |
+ | expected `isize`, found `&str`
|
note: associated function defined here
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
|
LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
| ^^^^^^^^
+help: remove the extra argument
+ |
+LL | let ans = s({isize});
+ | ~~~~~~~~~~
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
Some errors have detailed explanations: E0057, E0308.
For more information about an error, try `rustc --explain E0057`.
--> $DIR/trait-bounds-cant-coerce.rs:13:7
|
LL | a(x);
- | ^ expected trait `Foo + Send`, found trait `Foo`
+ | - ^ expected trait `Foo + Send`, found trait `Foo`
+ | |
+ | arguments to this function are incorrect
|
= 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
--> $DIR/mut-cross-borrowing.rs:7:7
|
LL | f(x)
- | ^
- | |
- | expected `&mut isize`, found struct `Box`
- | help: consider mutably borrowing here: `&mut x`
+ | - ^
+ | | |
+ | | expected `&mut isize`, found struct `Box`
+ | | help: consider mutably borrowing here: `&mut x`
+ | arguments to this function are incorrect
|
= 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
--> $DIR/call-fn-never-arg-wrong-type.rs:10:9
|
LL | foo("wow");
- | ^^^^^ expected `!`, found `&str`
+ | --- ^^^^^ expected `!`, found `&str`
+ | |
+ | arguments to this function are incorrect
|
= 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
--> $DIR/not-enough-arguments.rs:27:3
|
LL | foo(1, 2, 3);
- | ^^^ - - - supplied 3 arguments
- | |
- | expected 4 arguments
+ | ^^^--------- an argument of type `isize` is missing
|
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);
- | ^^^ - - - supplied 3 arguments
- | |
- | expected 6 arguments
+ | ^^^--------- three arguments of type `i32`, `i32`, and `i32` are missing
|
note: function defined here
--> $DIR/not-enough-arguments.rs:10:4
| ------
LL | f: i32,
| ------
+help: provide the arguments
+ |
+LL | bar(1, 2, 3, {i32}, {i32}, {i32});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
--> $DIR/integer-literal-suffix-inference.rs:38:11
|
LL | id_i8(a16);
- | ^^^ expected `i8`, found `i16`
+ | ----- ^^^ expected `i8`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:41:11
|
LL | id_i8(a32);
- | ^^^ expected `i8`, found `i32`
+ | ----- ^^^ expected `i8`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:44:11
|
LL | id_i8(a64);
- | ^^^ expected `i8`, found `i64`
+ | ----- ^^^ expected `i8`, found `i64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:47:11
|
LL | id_i8(asize);
- | ^^^^^ expected `i8`, found `isize`
+ | ----- ^^^^^ expected `i8`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:51:12
|
LL | id_i16(a8);
- | ^^ expected `i16`, found `i8`
+ | ------ ^^ expected `i16`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:55:12
|
LL | id_i16(a32);
- | ^^^ expected `i16`, found `i32`
+ | ------ ^^^ expected `i16`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:58:12
|
LL | id_i16(a64);
- | ^^^ expected `i16`, found `i64`
+ | ------ ^^^ expected `i16`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:61:12
|
LL | id_i16(asize);
- | ^^^^^ expected `i16`, found `isize`
+ | ------ ^^^^^ expected `i16`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:65:12
|
LL | id_i32(a8);
- | ^^ expected `i32`, found `i8`
+ | ------ ^^ expected `i32`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:68:12
|
LL | id_i32(a16);
- | ^^^ expected `i32`, found `i16`
+ | ------ ^^^ expected `i32`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:72:12
|
LL | id_i32(a64);
- | ^^^ expected `i32`, found `i64`
+ | ------ ^^^ expected `i32`, found `i64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:75:12
|
LL | id_i32(asize);
- | ^^^^^ expected `i32`, found `isize`
+ | ------ ^^^^^ expected `i32`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:79:12
|
LL | id_i64(a8);
- | ^^ expected `i64`, found `i8`
+ | ------ ^^ expected `i64`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:82:12
|
LL | id_i64(a16);
- | ^^^ expected `i64`, found `i16`
+ | ------ ^^^ expected `i64`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:85:12
|
LL | id_i64(a32);
- | ^^^ expected `i64`, found `i32`
+ | ------ ^^^ expected `i64`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:89:12
|
LL | id_i64(asize);
- | ^^^^^ expected `i64`, found `isize`
+ | ------ ^^^^^ expected `i64`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:93:14
|
LL | id_isize(a8);
- | ^^ expected `isize`, found `i8`
+ | -------- ^^ expected `isize`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:96:14
|
LL | id_isize(a16);
- | ^^^ expected `isize`, found `i16`
+ | -------- ^^^ expected `isize`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:99:14
|
LL | id_isize(a32);
- | ^^^ expected `isize`, found `i32`
+ | -------- ^^^ expected `isize`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:102:14
|
LL | id_isize(a64);
- | ^^^ expected `isize`, found `i64`
+ | -------- ^^^ expected `isize`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:108:11
|
LL | id_i8(c16);
- | ^^^ expected `i8`, found `i16`
+ | ----- ^^^ expected `i8`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:111:11
|
LL | id_i8(c32);
- | ^^^ expected `i8`, found `i32`
+ | ----- ^^^ expected `i8`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:114:11
|
LL | id_i8(c64);
- | ^^^ expected `i8`, found `i64`
+ | ----- ^^^ expected `i8`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:118:12
|
LL | id_i16(c8);
- | ^^ expected `i16`, found `i8`
+ | ------ ^^ expected `i16`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:122:12
|
LL | id_i16(c32);
- | ^^^ expected `i16`, found `i32`
+ | ------ ^^^ expected `i16`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:125:12
|
LL | id_i16(c64);
- | ^^^ expected `i16`, found `i64`
+ | ------ ^^^ expected `i16`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:129:12
|
LL | id_i32(c8);
- | ^^ expected `i32`, found `i8`
+ | ------ ^^ expected `i32`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:132:12
|
LL | id_i32(c16);
- | ^^^ expected `i32`, found `i16`
+ | ------ ^^^ expected `i32`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:136:12
|
LL | id_i32(c64);
- | ^^^ expected `i32`, found `i64`
+ | ------ ^^^ expected `i32`, found `i64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:140:12
|
LL | id_i64(a8);
- | ^^ expected `i64`, found `i8`
+ | ------ ^^ expected `i64`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:143:12
|
LL | id_i64(a16);
- | ^^^ expected `i64`, found `i16`
+ | ------ ^^^ expected `i64`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:146:12
|
LL | id_i64(a32);
- | ^^^ expected `i64`, found `i32`
+ | ------ ^^^ expected `i64`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:152:11
|
LL | id_u8(b16);
- | ^^^ expected `u8`, found `u16`
+ | ----- ^^^ expected `u8`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:155:11
|
LL | id_u8(b32);
- | ^^^ expected `u8`, found `u32`
+ | ----- ^^^ expected `u8`, found `u32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:158:11
|
LL | id_u8(b64);
- | ^^^ expected `u8`, found `u64`
+ | ----- ^^^ expected `u8`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:161:11
|
LL | id_u8(bsize);
- | ^^^^^ expected `u8`, found `usize`
+ | ----- ^^^^^ expected `u8`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:165:12
|
LL | id_u16(b8);
- | ^^ expected `u16`, found `u8`
+ | ------ ^^ expected `u16`, found `u8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:169:12
|
LL | id_u16(b32);
- | ^^^ expected `u16`, found `u32`
+ | ------ ^^^ expected `u16`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:172:12
|
LL | id_u16(b64);
- | ^^^ expected `u16`, found `u64`
+ | ------ ^^^ expected `u16`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:175:12
|
LL | id_u16(bsize);
- | ^^^^^ expected `u16`, found `usize`
+ | ------ ^^^^^ expected `u16`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:179:12
|
LL | id_u32(b8);
- | ^^ expected `u32`, found `u8`
+ | ------ ^^ expected `u32`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:182:12
|
LL | id_u32(b16);
- | ^^^ expected `u32`, found `u16`
+ | ------ ^^^ expected `u32`, found `u16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:186:12
|
LL | id_u32(b64);
- | ^^^ expected `u32`, found `u64`
+ | ------ ^^^ expected `u32`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:189:12
|
LL | id_u32(bsize);
- | ^^^^^ expected `u32`, found `usize`
+ | ------ ^^^^^ expected `u32`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:193:12
|
LL | id_u64(b8);
- | ^^ expected `u64`, found `u8`
+ | ------ ^^ expected `u64`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:196:12
|
LL | id_u64(b16);
- | ^^^ expected `u64`, found `u16`
+ | ------ ^^^ expected `u64`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:199:12
|
LL | id_u64(b32);
- | ^^^ expected `u64`, found `u32`
+ | ------ ^^^ expected `u64`, found `u32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:203:12
|
LL | id_u64(bsize);
- | ^^^^^ expected `u64`, found `usize`
+ | ------ ^^^^^ expected `u64`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:207:14
|
LL | id_usize(b8);
- | ^^ expected `usize`, found `u8`
+ | -------- ^^ expected `usize`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:210:14
|
LL | id_usize(b16);
- | ^^^ expected `usize`, found `u16`
+ | -------- ^^^ expected `usize`, found `u16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/integer-literal-suffix-inference.rs:213:14
|
LL | id_usize(b32);
- | ^^^ expected `usize`, found `u32`
+ | -------- ^^^ expected `usize`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/integer-literal-suffix-inference.rs:216:14
|
LL | id_usize(b64);
- | ^^^ expected `usize`, found `u64`
+ | -------- ^^^ expected `usize`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/len.rs:3:10
|
LL | test(array.len());
- | ^^^^^^^^^^^ expected `u32`, found `usize`
+ | ---- ^^^^^^^^^^^ expected `u32`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast-without-suggestion.rs:17:18
|
LL | foo::<usize>(x_f64);
- | ^^^^^ expected `usize`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:18:18
|
LL | foo::<usize>(x_f32);
- | ^^^^^ expected `usize`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:19:18
|
LL | foo::<isize>(x_f64);
- | ^^^^^ expected `isize`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:20:18
|
LL | foo::<isize>(x_f32);
- | ^^^^^ expected `isize`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:21:16
|
LL | foo::<u64>(x_f64);
- | ^^^^^ expected `u64`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:22:16
|
LL | foo::<u64>(x_f32);
- | ^^^^^ expected `u64`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:23:16
|
LL | foo::<i64>(x_f64);
- | ^^^^^ expected `i64`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:24:16
|
LL | foo::<i64>(x_f32);
- | ^^^^^ expected `i64`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:25:16
|
LL | foo::<u32>(x_f64);
- | ^^^^^ expected `u32`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:26:16
|
LL | foo::<u32>(x_f32);
- | ^^^^^ expected `u32`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:27:16
|
LL | foo::<i32>(x_f64);
- | ^^^^^ expected `i32`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:28:16
|
LL | foo::<i32>(x_f32);
- | ^^^^^ expected `i32`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:29:16
|
LL | foo::<u16>(x_f64);
- | ^^^^^ expected `u16`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:30:16
|
LL | foo::<u16>(x_f32);
- | ^^^^^ expected `u16`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:31:16
|
LL | foo::<i16>(x_f64);
- | ^^^^^ expected `i16`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:32:16
|
LL | foo::<i16>(x_f32);
- | ^^^^^ expected `i16`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:33:15
|
LL | foo::<u8>(x_f64);
- | ^^^^^ expected `u8`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:34:15
|
LL | foo::<u8>(x_f32);
- | ^^^^^ expected `u8`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:35:15
|
LL | foo::<i8>(x_f64);
- | ^^^^^ expected `i8`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:36:15
|
LL | foo::<i8>(x_f32);
- | ^^^^^ expected `i8`, found `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) {}
+ | ^^^ -----
error[E0308]: mismatched types
--> $DIR/numeric-cast-without-suggestion.rs:37:16
|
LL | foo::<f32>(x_f64);
- | ^^^^^ expected `f32`, found `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) {}
+ | ^^^ -----
error: aborting due to 21 previous errors
--> $DIR/numeric-cast.rs:23:18
|
LL | foo::<usize>(x_u64);
- | ^^^^^ expected `usize`, found `u64`
+ | ------------ ^^^^^ expected `usize`, found `u64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:25:18
|
LL | foo::<usize>(x_u32);
- | ^^^^^ expected `usize`, found `u32`
+ | ------------ ^^^^^ expected `usize`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:27:18
|
LL | foo::<usize>(x_u16);
- | ^^^^^ expected `usize`, found `u16`
+ | ------------ ^^^^^ expected `usize`, found `u16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:29:18
|
LL | foo::<usize>(x_u8);
- | ^^^^ expected `usize`, found `u8`
+ | ------------ ^^^^ expected `usize`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:31:18
|
LL | foo::<usize>(x_isize);
- | ^^^^^^^ expected `usize`, found `isize`
+ | ------------ ^^^^^^^ expected `usize`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:33:18
|
LL | foo::<usize>(x_i64);
- | ^^^^^ expected `usize`, found `i64`
+ | ------------ ^^^^^ expected `usize`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:35:18
|
LL | foo::<usize>(x_i32);
- | ^^^^^ expected `usize`, found `i32`
+ | ------------ ^^^^^ expected `usize`, found `i32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:37:18
|
LL | foo::<usize>(x_i16);
- | ^^^^^ expected `usize`, found `i16`
+ | ------------ ^^^^^ expected `usize`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:39:18
|
LL | foo::<usize>(x_i8);
- | ^^^^ expected `usize`, found `i8`
+ | ------------ ^^^^ expected `usize`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:44:18
|
LL | foo::<isize>(x_usize);
- | ^^^^^^^ expected `isize`, found `usize`
+ | ------------ ^^^^^^^ expected `isize`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:46:18
|
LL | foo::<isize>(x_u64);
- | ^^^^^ expected `isize`, found `u64`
+ | ------------ ^^^^^ expected `isize`, found `u64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:48:18
|
LL | foo::<isize>(x_u32);
- | ^^^^^ expected `isize`, found `u32`
+ | ------------ ^^^^^ expected `isize`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:50:18
|
LL | foo::<isize>(x_u16);
- | ^^^^^ expected `isize`, found `u16`
+ | ------------ ^^^^^ expected `isize`, found `u16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:52:18
|
LL | foo::<isize>(x_u8);
- | ^^^^ expected `isize`, found `u8`
+ | ------------ ^^^^ expected `isize`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:55:18
|
LL | foo::<isize>(x_i64);
- | ^^^^^ expected `isize`, found `i64`
+ | ------------ ^^^^^ expected `isize`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:57:18
|
LL | foo::<isize>(x_i32);
- | ^^^^^ expected `isize`, found `i32`
+ | ------------ ^^^^^ expected `isize`, found `i32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:59:18
|
LL | foo::<isize>(x_i16);
- | ^^^^^ expected `isize`, found `i16`
+ | ------------ ^^^^^ expected `isize`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:61:18
|
LL | foo::<isize>(x_i8);
- | ^^^^ expected `isize`, found `i8`
+ | ------------ ^^^^ expected `isize`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:66:16
|
LL | foo::<u64>(x_usize);
- | ^^^^^^^ expected `u64`, found `usize`
+ | ---------- ^^^^^^^ expected `u64`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:69:16
|
LL | foo::<u64>(x_u32);
- | ^^^^^ expected `u64`, found `u32`
+ | ---------- ^^^^^ expected `u64`, found `u32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:71:16
|
LL | foo::<u64>(x_u16);
- | ^^^^^ expected `u64`, found `u16`
+ | ---------- ^^^^^ expected `u64`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:73:16
|
LL | foo::<u64>(x_u8);
- | ^^^^ expected `u64`, found `u8`
+ | ---------- ^^^^ expected `u64`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:75:16
|
LL | foo::<u64>(x_isize);
- | ^^^^^^^ expected `u64`, found `isize`
+ | ---------- ^^^^^^^ expected `u64`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:77:16
|
LL | foo::<u64>(x_i64);
- | ^^^^^ expected `u64`, found `i64`
+ | ---------- ^^^^^ expected `u64`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:79:16
|
LL | foo::<u64>(x_i32);
- | ^^^^^ expected `u64`, found `i32`
+ | ---------- ^^^^^ expected `u64`, found `i32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:81:16
|
LL | foo::<u64>(x_i16);
- | ^^^^^ expected `u64`, found `i16`
+ | ---------- ^^^^^ expected `u64`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:83:16
|
LL | foo::<u64>(x_i8);
- | ^^^^ expected `u64`, found `i8`
+ | ---------- ^^^^ expected `u64`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:88:16
|
LL | foo::<i64>(x_usize);
- | ^^^^^^^ expected `i64`, found `usize`
+ | ---------- ^^^^^^^ expected `i64`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:90:16
|
LL | foo::<i64>(x_u64);
- | ^^^^^ expected `i64`, found `u64`
+ | ---------- ^^^^^ expected `i64`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:92:16
|
LL | foo::<i64>(x_u32);
- | ^^^^^ expected `i64`, found `u32`
+ | ---------- ^^^^^ expected `i64`, found `u32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:94:16
|
LL | foo::<i64>(x_u16);
- | ^^^^^ expected `i64`, found `u16`
+ | ---------- ^^^^^ expected `i64`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:96:16
|
LL | foo::<i64>(x_u8);
- | ^^^^ expected `i64`, found `u8`
+ | ---------- ^^^^ expected `i64`, found `u8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:98:16
|
LL | foo::<i64>(x_isize);
- | ^^^^^^^ expected `i64`, found `isize`
+ | ---------- ^^^^^^^ expected `i64`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:101:16
|
LL | foo::<i64>(x_i32);
- | ^^^^^ expected `i64`, found `i32`
+ | ---------- ^^^^^ expected `i64`, found `i32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:103:16
|
LL | foo::<i64>(x_i16);
- | ^^^^^ expected `i64`, found `i16`
+ | ---------- ^^^^^ expected `i64`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:105:16
|
LL | foo::<i64>(x_i8);
- | ^^^^ expected `i64`, found `i8`
+ | ---------- ^^^^ expected `i64`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:110:16
|
LL | foo::<u32>(x_usize);
- | ^^^^^^^ expected `u32`, found `usize`
+ | ---------- ^^^^^^^ expected `u32`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:112:16
|
LL | foo::<u32>(x_u64);
- | ^^^^^ expected `u32`, found `u64`
+ | ---------- ^^^^^ expected `u32`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:115:16
|
LL | foo::<u32>(x_u16);
- | ^^^^^ expected `u32`, found `u16`
+ | ---------- ^^^^^ expected `u32`, found `u16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:117:16
|
LL | foo::<u32>(x_u8);
- | ^^^^ expected `u32`, found `u8`
+ | ---------- ^^^^ expected `u32`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:119:16
|
LL | foo::<u32>(x_isize);
- | ^^^^^^^ expected `u32`, found `isize`
+ | ---------- ^^^^^^^ expected `u32`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:121:16
|
LL | foo::<u32>(x_i64);
- | ^^^^^ expected `u32`, found `i64`
+ | ---------- ^^^^^ expected `u32`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:123:16
|
LL | foo::<u32>(x_i32);
- | ^^^^^ expected `u32`, found `i32`
+ | ---------- ^^^^^ expected `u32`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:125:16
|
LL | foo::<u32>(x_i16);
- | ^^^^^ expected `u32`, found `i16`
+ | ---------- ^^^^^ expected `u32`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:127:16
|
LL | foo::<u32>(x_i8);
- | ^^^^ expected `u32`, found `i8`
+ | ---------- ^^^^ expected `u32`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:132:16
|
LL | foo::<i32>(x_usize);
- | ^^^^^^^ expected `i32`, found `usize`
+ | ---------- ^^^^^^^ expected `i32`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:134:16
|
LL | foo::<i32>(x_u64);
- | ^^^^^ expected `i32`, found `u64`
+ | ---------- ^^^^^ expected `i32`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:136:16
|
LL | foo::<i32>(x_u32);
- | ^^^^^ expected `i32`, found `u32`
+ | ---------- ^^^^^ expected `i32`, found `u32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:138:16
|
LL | foo::<i32>(x_u16);
- | ^^^^^ expected `i32`, found `u16`
+ | ---------- ^^^^^ expected `i32`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:140:16
|
LL | foo::<i32>(x_u8);
- | ^^^^ expected `i32`, found `u8`
+ | ---------- ^^^^ expected `i32`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:142:16
|
LL | foo::<i32>(x_isize);
- | ^^^^^^^ expected `i32`, found `isize`
+ | ---------- ^^^^^^^ expected `i32`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:144:16
|
LL | foo::<i32>(x_i64);
- | ^^^^^ expected `i32`, found `i64`
+ | ---------- ^^^^^ expected `i32`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:147:16
|
LL | foo::<i32>(x_i16);
- | ^^^^^ expected `i32`, found `i16`
+ | ---------- ^^^^^ expected `i32`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:149:16
|
LL | foo::<i32>(x_i8);
- | ^^^^ expected `i32`, found `i8`
+ | ---------- ^^^^ expected `i32`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:154:16
|
LL | foo::<u16>(x_usize);
- | ^^^^^^^ expected `u16`, found `usize`
+ | ---------- ^^^^^^^ expected `u16`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:156:16
|
LL | foo::<u16>(x_u64);
- | ^^^^^ expected `u16`, found `u64`
+ | ---------- ^^^^^ expected `u16`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:158:16
|
LL | foo::<u16>(x_u32);
- | ^^^^^ expected `u16`, found `u32`
+ | ---------- ^^^^^ expected `u16`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:161:16
|
LL | foo::<u16>(x_u8);
- | ^^^^ expected `u16`, found `u8`
+ | ---------- ^^^^ expected `u16`, found `u8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:163:16
|
LL | foo::<u16>(x_isize);
- | ^^^^^^^ expected `u16`, found `isize`
+ | ---------- ^^^^^^^ expected `u16`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:165:16
|
LL | foo::<u16>(x_i64);
- | ^^^^^ expected `u16`, found `i64`
+ | ---------- ^^^^^ expected `u16`, found `i64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:167:16
|
LL | foo::<u16>(x_i32);
- | ^^^^^ expected `u16`, found `i32`
+ | ---------- ^^^^^ expected `u16`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:169:16
|
LL | foo::<u16>(x_i16);
- | ^^^^^ expected `u16`, found `i16`
+ | ---------- ^^^^^ expected `u16`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:171:16
|
LL | foo::<u16>(x_i8);
- | ^^^^ expected `u16`, found `i8`
+ | ---------- ^^^^ expected `u16`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:176:16
|
LL | foo::<i16>(x_usize);
- | ^^^^^^^ expected `i16`, found `usize`
+ | ---------- ^^^^^^^ expected `i16`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:178:16
|
LL | foo::<i16>(x_u64);
- | ^^^^^ expected `i16`, found `u64`
+ | ---------- ^^^^^ expected `i16`, found `u64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:180:16
|
LL | foo::<i16>(x_u32);
- | ^^^^^ expected `i16`, found `u32`
+ | ---------- ^^^^^ expected `i16`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:182:16
|
LL | foo::<i16>(x_u16);
- | ^^^^^ expected `i16`, found `u16`
+ | ---------- ^^^^^ expected `i16`, found `u16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:184:16
|
LL | foo::<i16>(x_u8);
- | ^^^^ expected `i16`, found `u8`
+ | ---------- ^^^^ expected `i16`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:186:16
|
LL | foo::<i16>(x_isize);
- | ^^^^^^^ expected `i16`, found `isize`
+ | ---------- ^^^^^^^ expected `i16`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:188:16
|
LL | foo::<i16>(x_i64);
- | ^^^^^ expected `i16`, found `i64`
+ | ---------- ^^^^^ expected `i16`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:190:16
|
LL | foo::<i16>(x_i32);
- | ^^^^^ expected `i16`, found `i32`
+ | ---------- ^^^^^ expected `i16`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:193:16
|
LL | foo::<i16>(x_i8);
- | ^^^^ expected `i16`, found `i8`
+ | ---------- ^^^^ expected `i16`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:198:15
|
LL | foo::<u8>(x_usize);
- | ^^^^^^^ expected `u8`, found `usize`
+ | --------- ^^^^^^^ expected `u8`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:200:15
|
LL | foo::<u8>(x_u64);
- | ^^^^^ expected `u8`, found `u64`
+ | --------- ^^^^^ expected `u8`, found `u64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:202:15
|
LL | foo::<u8>(x_u32);
- | ^^^^^ expected `u8`, found `u32`
+ | --------- ^^^^^ expected `u8`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:204:15
|
LL | foo::<u8>(x_u16);
- | ^^^^^ expected `u8`, found `u16`
+ | --------- ^^^^^ expected `u8`, found `u16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:207:15
|
LL | foo::<u8>(x_isize);
- | ^^^^^^^ expected `u8`, found `isize`
+ | --------- ^^^^^^^ expected `u8`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:209:15
|
LL | foo::<u8>(x_i64);
- | ^^^^^ expected `u8`, found `i64`
+ | --------- ^^^^^ expected `u8`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:211:15
|
LL | foo::<u8>(x_i32);
- | ^^^^^ expected `u8`, found `i32`
+ | --------- ^^^^^ expected `u8`, found `i32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:213:15
|
LL | foo::<u8>(x_i16);
- | ^^^^^ expected `u8`, found `i16`
+ | --------- ^^^^^ expected `u8`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:215:15
|
LL | foo::<u8>(x_i8);
- | ^^^^ expected `u8`, found `i8`
+ | --------- ^^^^ expected `u8`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:220:15
|
LL | foo::<i8>(x_usize);
- | ^^^^^^^ expected `i8`, found `usize`
+ | --------- ^^^^^^^ expected `i8`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:222:15
|
LL | foo::<i8>(x_u64);
- | ^^^^^ expected `i8`, found `u64`
+ | --------- ^^^^^ expected `i8`, found `u64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:224:15
|
LL | foo::<i8>(x_u32);
- | ^^^^^ expected `i8`, found `u32`
+ | --------- ^^^^^ expected `i8`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:226:15
|
LL | foo::<i8>(x_u16);
- | ^^^^^ expected `i8`, found `u16`
+ | --------- ^^^^^ expected `i8`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:228:15
|
LL | foo::<i8>(x_u8);
- | ^^^^ expected `i8`, found `u8`
+ | --------- ^^^^ expected `i8`, found `u8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:230:15
|
LL | foo::<i8>(x_isize);
- | ^^^^^^^ expected `i8`, found `isize`
+ | --------- ^^^^^^^ expected `i8`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:232:15
|
LL | foo::<i8>(x_i64);
- | ^^^^^ expected `i8`, found `i64`
+ | --------- ^^^^^ expected `i8`, found `i64`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:234:15
|
LL | foo::<i8>(x_i32);
- | ^^^^^ expected `i8`, found `i32`
+ | --------- ^^^^^ expected `i8`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:236:15
|
LL | foo::<i8>(x_i16);
- | ^^^^^ expected `i8`, found `i16`
+ | --------- ^^^^^ expected `i8`, found `i16`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:242:16
|
LL | foo::<f64>(x_usize);
- | ^^^^^^^ expected `f64`, found `usize`
+ | ---------- ^^^^^^^ expected `f64`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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);
--> $DIR/numeric-cast.rs:244:16
|
LL | foo::<f64>(x_u64);
- | ^^^^^ expected `f64`, found `u64`
+ | ---------- ^^^^^ expected `f64`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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);
--> $DIR/numeric-cast.rs:246:16
|
LL | foo::<f64>(x_u32);
- | ^^^^^ expected `f64`, found `u32`
+ | ---------- ^^^^^ expected `f64`, found `u32`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:248:16
|
LL | foo::<f64>(x_u16);
- | ^^^^^ expected `f64`, found `u16`
+ | ---------- ^^^^^ expected `f64`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:250:16
|
LL | foo::<f64>(x_u8);
- | ^^^^ expected `f64`, found `u8`
+ | ---------- ^^^^ expected `f64`, found `u8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:252:16
|
LL | foo::<f64>(x_isize);
- | ^^^^^^^ expected `f64`, found `isize`
+ | ---------- ^^^^^^^ expected `f64`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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);
--> $DIR/numeric-cast.rs:254:16
|
LL | foo::<f64>(x_i64);
- | ^^^^^ expected `f64`, found `i64`
+ | ---------- ^^^^^ expected `f64`, found `i64`
+ | |
+ | arguments to this function are incorrect
|
+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);
--> $DIR/numeric-cast.rs:256:16
|
LL | foo::<f64>(x_i32);
- | ^^^^^ expected `f64`, found `i32`
+ | ---------- ^^^^^ expected `f64`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:258:16
|
LL | foo::<f64>(x_i16);
- | ^^^^^ expected `f64`, found `i16`
+ | ---------- ^^^^^ expected `f64`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:260:16
|
LL | foo::<f64>(x_i8);
- | ^^^^ expected `f64`, found `i8`
+ | ---------- ^^^^ expected `f64`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:263:16
|
LL | foo::<f64>(x_f32);
- | ^^^^^ expected `f64`, found `f32`
+ | ---------- ^^^^^ expected `f64`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:266:16
|
LL | foo::<f32>(x_usize);
- | ^^^^^^^ expected `f32`, found `usize`
+ | ---------- ^^^^^^^ expected `f32`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
+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);
--> $DIR/numeric-cast.rs:268:16
|
LL | foo::<f32>(x_u64);
- | ^^^^^ expected `f32`, found `u64`
+ | ---------- ^^^^^ expected `f32`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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);
--> $DIR/numeric-cast.rs:270:16
|
LL | foo::<f32>(x_u32);
- | ^^^^^ expected `f32`, found `u32`
+ | ---------- ^^^^^ expected `f32`, found `u32`
+ | |
+ | arguments to this function are incorrect
|
+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);
--> $DIR/numeric-cast.rs:272:16
|
LL | foo::<f32>(x_u16);
- | ^^^^^ expected `f32`, found `u16`
+ | ---------- ^^^^^ expected `f32`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:274:16
|
LL | foo::<f32>(x_u8);
- | ^^^^ expected `f32`, found `u8`
+ | ---------- ^^^^ expected `f32`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:276:16
|
LL | foo::<f32>(x_isize);
- | ^^^^^^^ expected `f32`, found `isize`
+ | ---------- ^^^^^^^ expected `f32`, found `isize`
+ | |
+ | arguments to this function are incorrect
|
+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);
--> $DIR/numeric-cast.rs:278:16
|
LL | foo::<f32>(x_i64);
- | ^^^^^ expected `f32`, found `i64`
+ | ---------- ^^^^^ expected `f32`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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);
--> $DIR/numeric-cast.rs:280:16
|
LL | foo::<f32>(x_i32);
- | ^^^^^ expected `f32`, found `i32`
+ | ---------- ^^^^^ expected `f32`, found `i32`
+ | |
+ | arguments to this function are incorrect
|
+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);
--> $DIR/numeric-cast.rs:282:16
|
LL | foo::<f32>(x_i16);
- | ^^^^^ expected `f32`, found `i16`
+ | ---------- ^^^^^ expected `f32`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:284:16
|
LL | foo::<f32>(x_i8);
- | ^^^^ expected `f32`, found `i8`
+ | ---------- ^^^^ expected `f32`, found `i8`
+ | |
+ | arguments to this function are incorrect
|
+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());
--> $DIR/numeric-cast.rs:289:16
|
LL | foo::<u32>(x_u8 as u16);
- | ^^^^^^^^^^^ expected `u32`, found `u16`
+ | ---------- ^^^^^^^^^^^ expected `u32`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
--> $DIR/numeric-cast.rs:291:16
|
LL | foo::<i32>(-x_i8);
- | ^^^^^ expected `i32`, found `i8`
+ | ---------- ^^^^^ expected `i32`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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());
+++ /dev/null
-// run-rustfix
-
-fn foo<N>(_x: N) {}
-
-fn main() {
- foo::<usize>(42_usize);
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42_usize);
- //~^ ERROR mismatched types
- foo::<usize>(42usize);
- //~^ ERROR mismatched types
- foo::<usize>(42usize);
- //~^ ERROR mismatched types
-
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- //~^ ERROR mismatched types
- foo::<isize>(42isize);
- //~^ ERROR mismatched types
- foo::<isize>(42isize);
- //~^ ERROR mismatched types
-
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- //~^ ERROR mismatched types
- foo::<u64>(42u64);
- //~^ ERROR mismatched types
- foo::<u64>(42u64);
- //~^ ERROR mismatched types
-
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- //~^ ERROR mismatched types
- foo::<i64>(42i64);
- //~^ ERROR mismatched types
- foo::<i64>(42i64);
- //~^ ERROR mismatched types
-
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- //~^ ERROR mismatched types
- foo::<u32>(42u32);
- //~^ ERROR mismatched types
- foo::<u32>(42u32);
- //~^ ERROR mismatched types
-
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- //~^ ERROR mismatched types
- foo::<i32>(42i32);
- //~^ ERROR mismatched types
- foo::<i32>(42i32);
- //~^ ERROR mismatched types
-
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- //~^ ERROR mismatched types
- foo::<u16>(42u16);
- //~^ ERROR mismatched types
- foo::<u16>(42u16);
- //~^ ERROR mismatched types
-
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- foo::<i16>(42_i16);
- //~^ ERROR mismatched types
- foo::<i16>(42i16);
- //~^ ERROR mismatched types
- foo::<i16>(42i16);
- //~^ ERROR mismatched types
-
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- //~^ ERROR mismatched types
- foo::<u8>(42u8);
- //~^ ERROR mismatched types
- foo::<u8>(42u8);
- //~^ ERROR mismatched types
-
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- foo::<i8>(42i8);
- //~^ ERROR mismatched types
- foo::<i8>(42i8);
- //~^ ERROR mismatched types
-
- foo::<f64>(42_f64);
- //~^ ERROR mismatched types
- foo::<f64>(42_f64);
- //~^ ERROR mismatched types
- foo::<f64>(42_u32.into());
- //~^ ERROR mismatched types
- foo::<f64>(42_u16.into());
- //~^ ERROR mismatched types
- foo::<f64>(42_u8.into());
- //~^ ERROR mismatched types
- foo::<f64>(42_f64);
- //~^ ERROR mismatched types
- foo::<f64>(42_f64);
- //~^ ERROR mismatched types
- foo::<f64>(42_i32.into());
- //~^ ERROR mismatched types
- foo::<f64>(42_i16.into());
- //~^ ERROR mismatched types
- foo::<f64>(42_i8.into());
- //~^ ERROR mismatched types
- foo::<f64>(42.0_f64);
- foo::<f64>(42.0_f64);
- //~^ ERROR mismatched types
-
- foo::<f32>(42_f32);
- //~^ ERROR mismatched types
- foo::<f32>(42_f32);
- //~^ ERROR mismatched types
- foo::<f32>(42_f32);
- //~^ ERROR mismatched types
- foo::<f32>(42_u16.into());
- //~^ ERROR mismatched types
- foo::<f32>(42_u8.into());
- //~^ ERROR mismatched types
- foo::<f32>(42_f32);
- //~^ ERROR mismatched types
- foo::<f32>(42_f32);
- //~^ ERROR mismatched types
- foo::<f32>(42_f32);
- //~^ ERROR mismatched types
- foo::<f32>(42_i16.into());
- //~^ ERROR mismatched types
- foo::<f32>(42_i8.into());
- //~^ ERROR mismatched types
- foo::<f32>(42.0_f32);
- //~^ ERROR mismatched types
- foo::<f32>(42.0_f32);
-
- foo::<u32>((42_u8 as u16).into());
- //~^ ERROR mismatched types
- foo::<i32>((-42_i8).into());
- //~^ ERROR mismatched types
-}
+++ /dev/null
-// run-rustfix
-
-fn foo<N>(_x: N) {}
-
-fn main() {
- foo::<usize>(42_usize);
- foo::<usize>(42_u64);
- //~^ ERROR mismatched types
- foo::<usize>(42_u32);
- //~^ ERROR mismatched types
- foo::<usize>(42_u16);
- //~^ ERROR mismatched types
- foo::<usize>(42_u8);
- //~^ ERROR mismatched types
- foo::<usize>(42_isize);
- //~^ ERROR mismatched types
- foo::<usize>(42_i64);
- //~^ ERROR mismatched types
- foo::<usize>(42_i32);
- //~^ ERROR mismatched types
- foo::<usize>(42_i16);
- //~^ ERROR mismatched types
- foo::<usize>(42_i8);
- //~^ ERROR mismatched types
- foo::<usize>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<usize>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<isize>(42_usize);
- //~^ ERROR mismatched types
- foo::<isize>(42_u64);
- //~^ ERROR mismatched types
- foo::<isize>(42_u32);
- //~^ ERROR mismatched types
- foo::<isize>(42_u16);
- //~^ ERROR mismatched types
- foo::<isize>(42_u8);
- //~^ ERROR mismatched types
- foo::<isize>(42_isize);
- foo::<isize>(42_i64);
- //~^ ERROR mismatched types
- foo::<isize>(42_i32);
- //~^ ERROR mismatched types
- foo::<isize>(42_i16);
- //~^ ERROR mismatched types
- foo::<isize>(42_i8);
- //~^ ERROR mismatched types
- foo::<isize>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<isize>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<u64>(42_usize);
- //~^ ERROR mismatched types
- foo::<u64>(42_u64);
- foo::<u64>(42_u32);
- //~^ ERROR mismatched types
- foo::<u64>(42_u16);
- //~^ ERROR mismatched types
- foo::<u64>(42_u8);
- //~^ ERROR mismatched types
- foo::<u64>(42_isize);
- //~^ ERROR mismatched types
- foo::<u64>(42_i64);
- //~^ ERROR mismatched types
- foo::<u64>(42_i32);
- //~^ ERROR mismatched types
- foo::<u64>(42_i16);
- //~^ ERROR mismatched types
- foo::<u64>(42_i8);
- //~^ ERROR mismatched types
- foo::<u64>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<u64>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<i64>(42_usize);
- //~^ ERROR mismatched types
- foo::<i64>(42_u64);
- //~^ ERROR mismatched types
- foo::<i64>(42_u32);
- //~^ ERROR mismatched types
- foo::<i64>(42_u16);
- //~^ ERROR mismatched types
- foo::<i64>(42_u8);
- //~^ ERROR mismatched types
- foo::<i64>(42_isize);
- //~^ ERROR mismatched types
- foo::<i64>(42_i64);
- foo::<i64>(42_i32);
- //~^ ERROR mismatched types
- foo::<i64>(42_i16);
- //~^ ERROR mismatched types
- foo::<i64>(42_i8);
- //~^ ERROR mismatched types
- foo::<i64>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<i64>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<u32>(42_usize);
- //~^ ERROR mismatched types
- foo::<u32>(42_u64);
- //~^ ERROR mismatched types
- foo::<u32>(42_u32);
- foo::<u32>(42_u16);
- //~^ ERROR mismatched types
- foo::<u32>(42_u8);
- //~^ ERROR mismatched types
- foo::<u32>(42_isize);
- //~^ ERROR mismatched types
- foo::<u32>(42_i64);
- //~^ ERROR mismatched types
- foo::<u32>(42_i32);
- //~^ ERROR mismatched types
- foo::<u32>(42_i16);
- //~^ ERROR mismatched types
- foo::<u32>(42_i8);
- //~^ ERROR mismatched types
- foo::<u32>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<u32>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<i32>(42_usize);
- //~^ ERROR mismatched types
- foo::<i32>(42_u64);
- //~^ ERROR mismatched types
- foo::<i32>(42_u32);
- //~^ ERROR mismatched types
- foo::<i32>(42_u16);
- //~^ ERROR mismatched types
- foo::<i32>(42_u8);
- //~^ ERROR mismatched types
- foo::<i32>(42_isize);
- //~^ ERROR mismatched types
- foo::<i32>(42_i64);
- //~^ ERROR mismatched types
- foo::<i32>(42_i32);
- foo::<i32>(42_i16);
- //~^ ERROR mismatched types
- foo::<i32>(42_i8);
- //~^ ERROR mismatched types
- foo::<i32>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<i32>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<u16>(42_usize);
- //~^ ERROR mismatched types
- foo::<u16>(42_u64);
- //~^ ERROR mismatched types
- foo::<u16>(42_u32);
- //~^ ERROR mismatched types
- foo::<u16>(42_u16);
- foo::<u16>(42_u8);
- //~^ ERROR mismatched types
- foo::<u16>(42_isize);
- //~^ ERROR mismatched types
- foo::<u16>(42_i64);
- //~^ ERROR mismatched types
- foo::<u16>(42_i32);
- //~^ ERROR mismatched types
- foo::<u16>(42_i16);
- //~^ ERROR mismatched types
- foo::<u16>(42_i8);
- //~^ ERROR mismatched types
- foo::<u16>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<u16>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<i16>(42_usize);
- //~^ ERROR mismatched types
- foo::<i16>(42_u64);
- //~^ ERROR mismatched types
- foo::<i16>(42_u32);
- //~^ ERROR mismatched types
- foo::<i16>(42_u16);
- //~^ ERROR mismatched types
- foo::<i16>(42_u8);
- //~^ ERROR mismatched types
- foo::<i16>(42_isize);
- //~^ ERROR mismatched types
- foo::<i16>(42_i64);
- //~^ ERROR mismatched types
- foo::<i16>(42_i32);
- //~^ ERROR mismatched types
- foo::<i16>(42_i16);
- foo::<i16>(42_i8);
- //~^ ERROR mismatched types
- foo::<i16>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<i16>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<u8>(42_usize);
- //~^ ERROR mismatched types
- foo::<u8>(42_u64);
- //~^ ERROR mismatched types
- foo::<u8>(42_u32);
- //~^ ERROR mismatched types
- foo::<u8>(42_u16);
- //~^ ERROR mismatched types
- foo::<u8>(42_u8);
- foo::<u8>(42_isize);
- //~^ ERROR mismatched types
- foo::<u8>(42_i64);
- //~^ ERROR mismatched types
- foo::<u8>(42_i32);
- //~^ ERROR mismatched types
- foo::<u8>(42_i16);
- //~^ ERROR mismatched types
- foo::<u8>(42_i8);
- //~^ ERROR mismatched types
- foo::<u8>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<u8>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<i8>(42_usize);
- //~^ ERROR mismatched types
- foo::<i8>(42_u64);
- //~^ ERROR mismatched types
- foo::<i8>(42_u32);
- //~^ ERROR mismatched types
- foo::<i8>(42_u16);
- //~^ ERROR mismatched types
- foo::<i8>(42_u8);
- //~^ ERROR mismatched types
- foo::<i8>(42_isize);
- //~^ ERROR mismatched types
- foo::<i8>(42_i64);
- //~^ ERROR mismatched types
- foo::<i8>(42_i32);
- //~^ ERROR mismatched types
- foo::<i8>(42_i16);
- //~^ ERROR mismatched types
- foo::<i8>(42_i8);
- foo::<i8>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<i8>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<f64>(42_usize);
- //~^ ERROR mismatched types
- foo::<f64>(42_u64);
- //~^ ERROR mismatched types
- foo::<f64>(42_u32);
- //~^ ERROR mismatched types
- foo::<f64>(42_u16);
- //~^ ERROR mismatched types
- foo::<f64>(42_u8);
- //~^ ERROR mismatched types
- foo::<f64>(42_isize);
- //~^ ERROR mismatched types
- foo::<f64>(42_i64);
- //~^ ERROR mismatched types
- foo::<f64>(42_i32);
- //~^ ERROR mismatched types
- foo::<f64>(42_i16);
- //~^ ERROR mismatched types
- foo::<f64>(42_i8);
- //~^ ERROR mismatched types
- foo::<f64>(42.0_f64);
- foo::<f64>(42.0_f32);
- //~^ ERROR mismatched types
-
- foo::<f32>(42_usize);
- //~^ ERROR mismatched types
- foo::<f32>(42_u64);
- //~^ ERROR mismatched types
- foo::<f32>(42_u32);
- //~^ ERROR mismatched types
- foo::<f32>(42_u16);
- //~^ ERROR mismatched types
- foo::<f32>(42_u8);
- //~^ ERROR mismatched types
- foo::<f32>(42_isize);
- //~^ ERROR mismatched types
- foo::<f32>(42_i64);
- //~^ ERROR mismatched types
- foo::<f32>(42_i32);
- //~^ ERROR mismatched types
- foo::<f32>(42_i16);
- //~^ ERROR mismatched types
- foo::<f32>(42_i8);
- //~^ ERROR mismatched types
- foo::<f32>(42.0_f64);
- //~^ ERROR mismatched types
- foo::<f32>(42.0_f32);
-
- foo::<u32>(42_u8 as u16);
- //~^ ERROR mismatched types
- foo::<i32>(-42_i8);
- //~^ ERROR mismatched types
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:7:18
- |
-LL | foo::<usize>(42_u64);
- | ^^^^^^ expected `usize`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:9:18
- |
-LL | foo::<usize>(42_u32);
- | ^^^^^^ expected `usize`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:11:18
- |
-LL | foo::<usize>(42_u16);
- | ^^^^^^ expected `usize`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:13:18
- |
-LL | foo::<usize>(42_u8);
- | ^^^^^ expected `usize`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:15:18
- |
-LL | foo::<usize>(42_isize);
- | ^^^^^^^^ expected `usize`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:17:18
- |
-LL | foo::<usize>(42_i64);
- | ^^^^^^ expected `usize`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:19:18
- |
-LL | foo::<usize>(42_i32);
- | ^^^^^^ expected `usize`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:21:18
- |
-LL | foo::<usize>(42_i16);
- | ^^^^^^ expected `usize`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:23:18
- |
-LL | foo::<usize>(42_i8);
- | ^^^^^ expected `usize`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `usize`
- |
-LL | foo::<usize>(42_usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:25:18
- |
-LL | foo::<usize>(42.0_f64);
- | ^^^^^^^^ expected `usize`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `usize`
- |
-LL | foo::<usize>(42usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:27:18
- |
-LL | foo::<usize>(42.0_f32);
- | ^^^^^^^^ expected `usize`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `usize`
- |
-LL | foo::<usize>(42usize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:30:18
- |
-LL | foo::<isize>(42_usize);
- | ^^^^^^^^ expected `isize`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:32:18
- |
-LL | foo::<isize>(42_u64);
- | ^^^^^^ expected `isize`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:34:18
- |
-LL | foo::<isize>(42_u32);
- | ^^^^^^ expected `isize`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:36:18
- |
-LL | foo::<isize>(42_u16);
- | ^^^^^^ expected `isize`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:38:18
- |
-LL | foo::<isize>(42_u8);
- | ^^^^^ expected `isize`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:41:18
- |
-LL | foo::<isize>(42_i64);
- | ^^^^^^ expected `isize`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:43:18
- |
-LL | foo::<isize>(42_i32);
- | ^^^^^^ expected `isize`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:45:18
- |
-LL | foo::<isize>(42_i16);
- | ^^^^^^ expected `isize`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:47:18
- |
-LL | foo::<isize>(42_i8);
- | ^^^^^ expected `isize`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `isize`
- |
-LL | foo::<isize>(42_isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:49:18
- |
-LL | foo::<isize>(42.0_f64);
- | ^^^^^^^^ expected `isize`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `isize`
- |
-LL | foo::<isize>(42isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:51:18
- |
-LL | foo::<isize>(42.0_f32);
- | ^^^^^^^^ expected `isize`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `isize`
- |
-LL | foo::<isize>(42isize);
- | ~~~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:54:16
- |
-LL | foo::<u64>(42_usize);
- | ^^^^^^^^ expected `u64`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:57:16
- |
-LL | foo::<u64>(42_u32);
- | ^^^^^^ expected `u64`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:59:16
- |
-LL | foo::<u64>(42_u16);
- | ^^^^^^ expected `u64`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:61:16
- |
-LL | foo::<u64>(42_u8);
- | ^^^^^ expected `u64`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:63:16
- |
-LL | foo::<u64>(42_isize);
- | ^^^^^^^^ expected `u64`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:65:16
- |
-LL | foo::<u64>(42_i64);
- | ^^^^^^ expected `u64`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:67:16
- |
-LL | foo::<u64>(42_i32);
- | ^^^^^^ expected `u64`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:69:16
- |
-LL | foo::<u64>(42_i16);
- | ^^^^^^ expected `u64`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:71:16
- |
-LL | foo::<u64>(42_i8);
- | ^^^^^ expected `u64`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `u64`
- |
-LL | foo::<u64>(42_u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:73:16
- |
-LL | foo::<u64>(42.0_f64);
- | ^^^^^^^^ expected `u64`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `u64`
- |
-LL | foo::<u64>(42u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:75:16
- |
-LL | foo::<u64>(42.0_f32);
- | ^^^^^^^^ expected `u64`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `u64`
- |
-LL | foo::<u64>(42u64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:78:16
- |
-LL | foo::<i64>(42_usize);
- | ^^^^^^^^ expected `i64`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:80:16
- |
-LL | foo::<i64>(42_u64);
- | ^^^^^^ expected `i64`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:82:16
- |
-LL | foo::<i64>(42_u32);
- | ^^^^^^ expected `i64`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:84:16
- |
-LL | foo::<i64>(42_u16);
- | ^^^^^^ expected `i64`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:86:16
- |
-LL | foo::<i64>(42_u8);
- | ^^^^^ expected `i64`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:88:16
- |
-LL | foo::<i64>(42_isize);
- | ^^^^^^^^ expected `i64`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:91:16
- |
-LL | foo::<i64>(42_i32);
- | ^^^^^^ expected `i64`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:93:16
- |
-LL | foo::<i64>(42_i16);
- | ^^^^^^ expected `i64`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:95:16
- |
-LL | foo::<i64>(42_i8);
- | ^^^^^ expected `i64`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `i64`
- |
-LL | foo::<i64>(42_i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:97:16
- |
-LL | foo::<i64>(42.0_f64);
- | ^^^^^^^^ expected `i64`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `i64`
- |
-LL | foo::<i64>(42i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:99:16
- |
-LL | foo::<i64>(42.0_f32);
- | ^^^^^^^^ expected `i64`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `i64`
- |
-LL | foo::<i64>(42i64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:102:16
- |
-LL | foo::<u32>(42_usize);
- | ^^^^^^^^ expected `u32`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:104:16
- |
-LL | foo::<u32>(42_u64);
- | ^^^^^^ expected `u32`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:107:16
- |
-LL | foo::<u32>(42_u16);
- | ^^^^^^ expected `u32`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:109:16
- |
-LL | foo::<u32>(42_u8);
- | ^^^^^ expected `u32`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:111:16
- |
-LL | foo::<u32>(42_isize);
- | ^^^^^^^^ expected `u32`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:113:16
- |
-LL | foo::<u32>(42_i64);
- | ^^^^^^ expected `u32`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:115:16
- |
-LL | foo::<u32>(42_i32);
- | ^^^^^^ expected `u32`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:117:16
- |
-LL | foo::<u32>(42_i16);
- | ^^^^^^ expected `u32`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:119:16
- |
-LL | foo::<u32>(42_i8);
- | ^^^^^ expected `u32`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `u32`
- |
-LL | foo::<u32>(42_u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:121:16
- |
-LL | foo::<u32>(42.0_f64);
- | ^^^^^^^^ expected `u32`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `u32`
- |
-LL | foo::<u32>(42u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:123:16
- |
-LL | foo::<u32>(42.0_f32);
- | ^^^^^^^^ expected `u32`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `u32`
- |
-LL | foo::<u32>(42u32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:126:16
- |
-LL | foo::<i32>(42_usize);
- | ^^^^^^^^ expected `i32`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:128:16
- |
-LL | foo::<i32>(42_u64);
- | ^^^^^^ expected `i32`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:130:16
- |
-LL | foo::<i32>(42_u32);
- | ^^^^^^ expected `i32`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:132:16
- |
-LL | foo::<i32>(42_u16);
- | ^^^^^^ expected `i32`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:134:16
- |
-LL | foo::<i32>(42_u8);
- | ^^^^^ expected `i32`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:136:16
- |
-LL | foo::<i32>(42_isize);
- | ^^^^^^^^ expected `i32`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:138:16
- |
-LL | foo::<i32>(42_i64);
- | ^^^^^^ expected `i32`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:141:16
- |
-LL | foo::<i32>(42_i16);
- | ^^^^^^ expected `i32`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:143:16
- |
-LL | foo::<i32>(42_i8);
- | ^^^^^ expected `i32`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `i32`
- |
-LL | foo::<i32>(42_i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:145:16
- |
-LL | foo::<i32>(42.0_f64);
- | ^^^^^^^^ expected `i32`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `i32`
- |
-LL | foo::<i32>(42i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:147:16
- |
-LL | foo::<i32>(42.0_f32);
- | ^^^^^^^^ expected `i32`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `i32`
- |
-LL | foo::<i32>(42i32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:150:16
- |
-LL | foo::<u16>(42_usize);
- | ^^^^^^^^ expected `u16`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:152:16
- |
-LL | foo::<u16>(42_u64);
- | ^^^^^^ expected `u16`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:154:16
- |
-LL | foo::<u16>(42_u32);
- | ^^^^^^ expected `u16`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:157:16
- |
-LL | foo::<u16>(42_u8);
- | ^^^^^ expected `u16`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:159:16
- |
-LL | foo::<u16>(42_isize);
- | ^^^^^^^^ expected `u16`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:161:16
- |
-LL | foo::<u16>(42_i64);
- | ^^^^^^ expected `u16`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:163:16
- |
-LL | foo::<u16>(42_i32);
- | ^^^^^^ expected `u16`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:165:16
- |
-LL | foo::<u16>(42_i16);
- | ^^^^^^ expected `u16`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:167:16
- |
-LL | foo::<u16>(42_i8);
- | ^^^^^ expected `u16`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `u16`
- |
-LL | foo::<u16>(42_u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:169:16
- |
-LL | foo::<u16>(42.0_f64);
- | ^^^^^^^^ expected `u16`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `u16`
- |
-LL | foo::<u16>(42u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:171:16
- |
-LL | foo::<u16>(42.0_f32);
- | ^^^^^^^^ expected `u16`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `u16`
- |
-LL | foo::<u16>(42u16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:174:16
- |
-LL | foo::<i16>(42_usize);
- | ^^^^^^^^ expected `i16`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:176:16
- |
-LL | foo::<i16>(42_u64);
- | ^^^^^^ expected `i16`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:178:16
- |
-LL | foo::<i16>(42_u32);
- | ^^^^^^ expected `i16`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:180:16
- |
-LL | foo::<i16>(42_u16);
- | ^^^^^^ expected `i16`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:182:16
- |
-LL | foo::<i16>(42_u8);
- | ^^^^^ expected `i16`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:184:16
- |
-LL | foo::<i16>(42_isize);
- | ^^^^^^^^ expected `i16`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:186:16
- |
-LL | foo::<i16>(42_i64);
- | ^^^^^^ expected `i16`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:188:16
- |
-LL | foo::<i16>(42_i32);
- | ^^^^^^ expected `i16`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:191:16
- |
-LL | foo::<i16>(42_i8);
- | ^^^^^ expected `i16`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `i16`
- |
-LL | foo::<i16>(42_i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:193:16
- |
-LL | foo::<i16>(42.0_f64);
- | ^^^^^^^^ expected `i16`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `i16`
- |
-LL | foo::<i16>(42i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:195:16
- |
-LL | foo::<i16>(42.0_f32);
- | ^^^^^^^^ expected `i16`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `i16`
- |
-LL | foo::<i16>(42i16);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:198:15
- |
-LL | foo::<u8>(42_usize);
- | ^^^^^^^^ expected `u8`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:200:15
- |
-LL | foo::<u8>(42_u64);
- | ^^^^^^ expected `u8`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:202:15
- |
-LL | foo::<u8>(42_u32);
- | ^^^^^^ expected `u8`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:204:15
- |
-LL | foo::<u8>(42_u16);
- | ^^^^^^ expected `u8`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:207:15
- |
-LL | foo::<u8>(42_isize);
- | ^^^^^^^^ expected `u8`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:209:15
- |
-LL | foo::<u8>(42_i64);
- | ^^^^^^ expected `u8`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:211:15
- |
-LL | foo::<u8>(42_i32);
- | ^^^^^^ expected `u8`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:213:15
- |
-LL | foo::<u8>(42_i16);
- | ^^^^^^ expected `u8`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:215:15
- |
-LL | foo::<u8>(42_i8);
- | ^^^^^ expected `u8`, found `i8`
- |
-help: change the type of the numeric literal from `i8` to `u8`
- |
-LL | foo::<u8>(42_u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:217:15
- |
-LL | foo::<u8>(42.0_f64);
- | ^^^^^^^^ expected `u8`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `u8`
- |
-LL | foo::<u8>(42u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:219:15
- |
-LL | foo::<u8>(42.0_f32);
- | ^^^^^^^^ expected `u8`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `u8`
- |
-LL | foo::<u8>(42u8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:222:15
- |
-LL | foo::<i8>(42_usize);
- | ^^^^^^^^ expected `i8`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:224:15
- |
-LL | foo::<i8>(42_u64);
- | ^^^^^^ expected `i8`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:226:15
- |
-LL | foo::<i8>(42_u32);
- | ^^^^^^ expected `i8`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:228:15
- |
-LL | foo::<i8>(42_u16);
- | ^^^^^^ expected `i8`, found `u16`
- |
-help: change the type of the numeric literal from `u16` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:230:15
- |
-LL | foo::<i8>(42_u8);
- | ^^^^^ expected `i8`, found `u8`
- |
-help: change the type of the numeric literal from `u8` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:232:15
- |
-LL | foo::<i8>(42_isize);
- | ^^^^^^^^ expected `i8`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:234:15
- |
-LL | foo::<i8>(42_i64);
- | ^^^^^^ expected `i8`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:236:15
- |
-LL | foo::<i8>(42_i32);
- | ^^^^^^ expected `i8`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:238:15
- |
-LL | foo::<i8>(42_i16);
- | ^^^^^^ expected `i8`, found `i16`
- |
-help: change the type of the numeric literal from `i16` to `i8`
- |
-LL | foo::<i8>(42_i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:241:15
- |
-LL | foo::<i8>(42.0_f64);
- | ^^^^^^^^ expected `i8`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `i8`
- |
-LL | foo::<i8>(42i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:243:15
- |
-LL | foo::<i8>(42.0_f32);
- | ^^^^^^^^ expected `i8`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `i8`
- |
-LL | foo::<i8>(42i8);
- | ~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:246:16
- |
-LL | foo::<f64>(42_usize);
- | ^^^^^^^^ expected `f64`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `f64`
- |
-LL | foo::<f64>(42_f64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:248:16
- |
-LL | foo::<f64>(42_u64);
- | ^^^^^^ expected `f64`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `f64`
- |
-LL | foo::<f64>(42_f64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:250:16
- |
-LL | foo::<f64>(42_u32);
- | ^^^^^^ expected `f64`, found `u32`
- |
-help: you can convert a `u32` to an `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(42_u32.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:252:16
- |
-LL | foo::<f64>(42_u16);
- | ^^^^^^ expected `f64`, found `u16`
- |
-help: you can convert a `u16` to an `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(42_u16.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:254:16
- |
-LL | foo::<f64>(42_u8);
- | ^^^^^ expected `f64`, found `u8`
- |
-help: you can convert a `u8` to an `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(42_u8.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:256:16
- |
-LL | foo::<f64>(42_isize);
- | ^^^^^^^^ expected `f64`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `f64`
- |
-LL | foo::<f64>(42_f64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:258:16
- |
-LL | foo::<f64>(42_i64);
- | ^^^^^^ expected `f64`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `f64`
- |
-LL | foo::<f64>(42_f64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:260:16
- |
-LL | foo::<f64>(42_i32);
- | ^^^^^^ expected `f64`, found `i32`
- |
-help: you can convert an `i32` to an `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(42_i32.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:262:16
- |
-LL | foo::<f64>(42_i16);
- | ^^^^^^ expected `f64`, found `i16`
- |
-help: you can convert an `i16` to an `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(42_i16.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:264:16
- |
-LL | foo::<f64>(42_i8);
- | ^^^^^ expected `f64`, found `i8`
- |
-help: you can convert an `i8` to an `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(42_i8.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:267:16
- |
-LL | foo::<f64>(42.0_f32);
- | ^^^^^^^^ expected `f64`, found `f32`
- |
-help: change the type of the numeric literal from `f32` to `f64`
- |
-LL | foo::<f64>(42.0_f64);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:270:16
- |
-LL | foo::<f32>(42_usize);
- | ^^^^^^^^ expected `f32`, found `usize`
- |
-help: change the type of the numeric literal from `usize` to `f32`
- |
-LL | foo::<f32>(42_f32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:272:16
- |
-LL | foo::<f32>(42_u64);
- | ^^^^^^ expected `f32`, found `u64`
- |
-help: change the type of the numeric literal from `u64` to `f32`
- |
-LL | foo::<f32>(42_f32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:274:16
- |
-LL | foo::<f32>(42_u32);
- | ^^^^^^ expected `f32`, found `u32`
- |
-help: change the type of the numeric literal from `u32` to `f32`
- |
-LL | foo::<f32>(42_f32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:276:16
- |
-LL | foo::<f32>(42_u16);
- | ^^^^^^ expected `f32`, found `u16`
- |
-help: you can convert a `u16` to an `f32`, producing the floating point representation of the integer
- |
-LL | foo::<f32>(42_u16.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:278:16
- |
-LL | foo::<f32>(42_u8);
- | ^^^^^ expected `f32`, found `u8`
- |
-help: you can convert a `u8` to an `f32`, producing the floating point representation of the integer
- |
-LL | foo::<f32>(42_u8.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:280:16
- |
-LL | foo::<f32>(42_isize);
- | ^^^^^^^^ expected `f32`, found `isize`
- |
-help: change the type of the numeric literal from `isize` to `f32`
- |
-LL | foo::<f32>(42_f32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:282:16
- |
-LL | foo::<f32>(42_i64);
- | ^^^^^^ expected `f32`, found `i64`
- |
-help: change the type of the numeric literal from `i64` to `f32`
- |
-LL | foo::<f32>(42_f32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:284:16
- |
-LL | foo::<f32>(42_i32);
- | ^^^^^^ expected `f32`, found `i32`
- |
-help: change the type of the numeric literal from `i32` to `f32`
- |
-LL | foo::<f32>(42_f32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:286:16
- |
-LL | foo::<f32>(42_i16);
- | ^^^^^^ expected `f32`, found `i16`
- |
-help: you can convert an `i16` to an `f32`, producing the floating point representation of the integer
- |
-LL | foo::<f32>(42_i16.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:288:16
- |
-LL | foo::<f32>(42_i8);
- | ^^^^^ expected `f32`, found `i8`
- |
-help: you can convert an `i8` to an `f32`, producing the floating point representation of the integer
- |
-LL | foo::<f32>(42_i8.into());
- | +++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:290:16
- |
-LL | foo::<f32>(42.0_f64);
- | ^^^^^^^^ expected `f32`, found `f64`
- |
-help: change the type of the numeric literal from `f64` to `f32`
- |
-LL | foo::<f32>(42.0_f32);
- | ~~~
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:294:16
- |
-LL | foo::<u32>(42_u8 as u16);
- | ^^^^^^^^^^^^ expected `u32`, found `u16`
- |
-help: you can convert a `u16` to a `u32`
- |
-LL | foo::<u32>((42_u8 as u16).into());
- | + ++++++++
-
-error[E0308]: mismatched types
- --> $DIR/numeric-suffix.rs:296:16
- |
-LL | foo::<i32>(-42_i8);
- | ^^^^^^ expected `i32`, found `i8`
- |
-help: you can convert an `i8` to an `i32`
- |
-LL | foo::<i32>((-42_i8).into());
- | + ++++++++
-
-error: aborting due to 134 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-i32.rs:28:16
+ |
+LL | foo::<i32>(42_usize);
+ | ---------- ^^^^^^^^ expected `i32`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42_u64);
+ | ---------- ^^^^^^ expected `i32`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42_u32);
+ | ---------- ^^^^^^ expected `i32`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42_u16);
+ | ---------- ^^^^^^ expected `i32`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42_u8);
+ | ---------- ^^^^^ expected `i32`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42_isize);
+ | ---------- ^^^^^^^^ expected `i32`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42_i64);
+ | ---------- ^^^^^^ expected `i32`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42_i16);
+ | ---------- ^^^^^^ expected `i32`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42_i8);
+ | ---------- ^^^^^ expected `i32`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42.0_f64);
+ | ---------- ^^^^^^^^ expected `i32`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i32>(42.0_f32);
+ | ---------- ^^^^^^^^ expected `i32`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+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);
+ | ~~~
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-i64.rs:28:16
+ |
+LL | foo::<i64>(42_usize);
+ | ---------- ^^^^^^^^ expected `i64`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42_u64);
+ | ---------- ^^^^^^ expected `i64`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42_u32);
+ | ---------- ^^^^^^ expected `i64`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42_u16);
+ | ---------- ^^^^^^ expected `i64`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42_u8);
+ | ---------- ^^^^^ expected `i64`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42_isize);
+ | ---------- ^^^^^^^^ expected `i64`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42_i32);
+ | ---------- ^^^^^^ expected `i64`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42_i16);
+ | ---------- ^^^^^^ expected `i64`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42_i8);
+ | ---------- ^^^^^ expected `i64`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42.0_f64);
+ | ---------- ^^^^^^^^ expected `i64`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<i64>(42.0_f32);
+ | ---------- ^^^^^^^^ expected `i64`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+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);
+ | ~~~
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-isize.rs:28:18
+ |
+LL | foo::<isize>(42_usize);
+ | ------------ ^^^^^^^^ expected `isize`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42_u64);
+ | ------------ ^^^^^^ expected `isize`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42_u32);
+ | ------------ ^^^^^^ expected `isize`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42_u16);
+ | ------------ ^^^^^^ expected `isize`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42_u8);
+ | ------------ ^^^^^ expected `isize`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42_i64);
+ | ------------ ^^^^^^ expected `isize`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42_i32);
+ | ------------ ^^^^^^ expected `isize`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42_i16);
+ | ------------ ^^^^^^ expected `isize`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42_i8);
+ | ------------ ^^^^^ expected `isize`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42.0_f64);
+ | ------------ ^^^^^^^^ expected `isize`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+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
+ |
+LL | foo::<isize>(42.0_f32);
+ | ------------ ^^^^^^^^ expected `isize`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+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);
+ | ~~~~~
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// 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
+}
--- /dev/null
+// 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_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42_u32);
+ foo::<u32>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u32>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:28:16
+ |
+LL | foo::<u32>(42_usize);
+ | ---------- ^^^^^^^^ expected `u32`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `usize` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:32:16
+ |
+LL | foo::<u32>(42_u64);
+ | ---------- ^^^^^^ expected `u32`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u64` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:37:16
+ |
+LL | foo::<u32>(42_u16);
+ | ---------- ^^^^^^ expected `u32`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u16` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:41:16
+ |
+LL | foo::<u32>(42_u8);
+ | ---------- ^^^^^ expected `u32`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u8` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:45:16
+ |
+LL | foo::<u32>(42_isize);
+ | ---------- ^^^^^^^^ expected `u32`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:49:16
+ |
+LL | foo::<u32>(42_i64);
+ | ---------- ^^^^^^ expected `u32`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:53:16
+ |
+LL | foo::<u32>(42_i32);
+ | ---------- ^^^^^^ expected `u32`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i32` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:57:16
+ |
+LL | foo::<u32>(42_i16);
+ | ---------- ^^^^^^ expected `u32`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i16` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:61:16
+ |
+LL | foo::<u32>(42_i8);
+ | ---------- ^^^^^ expected `u32`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i8` to `u32`
+ |
+LL | foo::<u32>(42_u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:65:16
+ |
+LL | foo::<u32>(42.0_f64);
+ | ---------- ^^^^^^^^ expected `u32`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f64` to `u32`
+ |
+LL | foo::<u32>(42u32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u32.rs:69:16
+ |
+LL | foo::<u32>(42.0_f32);
+ | ---------- ^^^^^^^^ expected `u32`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u32.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f32` to `u32`
+ |
+LL | foo::<u32>(42u32);
+ | ~~~
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// 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::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ foo::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+}
--- /dev/null
+// 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::<u64>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u64);
+ foo::<u64>(42_u32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u64>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:28:16
+ |
+LL | foo::<u64>(42_usize);
+ | ---------- ^^^^^^^^ expected `u64`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `usize` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:33:16
+ |
+LL | foo::<u64>(42_u32);
+ | ---------- ^^^^^^ expected `u64`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u32` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:37:16
+ |
+LL | foo::<u64>(42_u16);
+ | ---------- ^^^^^^ expected `u64`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u16` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:41:16
+ |
+LL | foo::<u64>(42_u8);
+ | ---------- ^^^^^ expected `u64`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u8` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:45:16
+ |
+LL | foo::<u64>(42_isize);
+ | ---------- ^^^^^^^^ expected `u64`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:49:16
+ |
+LL | foo::<u64>(42_i64);
+ | ---------- ^^^^^^ expected `u64`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:53:16
+ |
+LL | foo::<u64>(42_i32);
+ | ---------- ^^^^^^ expected `u64`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i32` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:57:16
+ |
+LL | foo::<u64>(42_i16);
+ | ---------- ^^^^^^ expected `u64`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i16` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:61:16
+ |
+LL | foo::<u64>(42_i8);
+ | ---------- ^^^^^ expected `u64`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i8` to `u64`
+ |
+LL | foo::<u64>(42_u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:65:16
+ |
+LL | foo::<u64>(42.0_f64);
+ | ---------- ^^^^^^^^ expected `u64`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f64` to `u64`
+ |
+LL | foo::<u64>(42u64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-u64.rs:69:16
+ |
+LL | foo::<u64>(42.0_f32);
+ | ---------- ^^^^^^^^ expected `u64`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-u64.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f32` to `u64`
+ |
+LL | foo::<u64>(42u64);
+ | ~~~
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// 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::<usize>(42_usize);
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+}
--- /dev/null
+// 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::<usize>(42_usize);
+ foo::<usize>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_u32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<usize>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:29:18
+ |
+LL | foo::<usize>(42_u64);
+ | ------------ ^^^^^^ expected `usize`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u64` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:33:18
+ |
+LL | foo::<usize>(42_u32);
+ | ------------ ^^^^^^ expected `usize`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u32` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:37:18
+ |
+LL | foo::<usize>(42_u16);
+ | ------------ ^^^^^^ expected `usize`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u16` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:41:18
+ |
+LL | foo::<usize>(42_u8);
+ | ------------ ^^^^^ expected `usize`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u8` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:45:18
+ |
+LL | foo::<usize>(42_isize);
+ | ------------ ^^^^^^^^ expected `usize`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:49:18
+ |
+LL | foo::<usize>(42_i64);
+ | ------------ ^^^^^^ expected `usize`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:53:18
+ |
+LL | foo::<usize>(42_i32);
+ | ------------ ^^^^^^ expected `usize`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i32` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:57:18
+ |
+LL | foo::<usize>(42_i16);
+ | ------------ ^^^^^^ expected `usize`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i16` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:61:18
+ |
+LL | foo::<usize>(42_i8);
+ | ------------ ^^^^^ expected `usize`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i8` to `usize`
+ |
+LL | foo::<usize>(42_usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:65:18
+ |
+LL | foo::<usize>(42.0_f64);
+ | ------------ ^^^^^^^^ expected `usize`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f64` to `usize`
+ |
+LL | foo::<usize>(42usize);
+ | ~~~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix-usize.rs:69:18
+ |
+LL | foo::<usize>(42.0_f32);
+ | ------------ ^^^^^^^^ expected `usize`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix-usize.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f32` to `usize`
+ |
+LL | foo::<usize>(42usize);
+ | ~~~~~
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// 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 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 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 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 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 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 function defined here
+//~| NOTE function defined here
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+
+
+fn main() {
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ foo::<i16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ foo::<i8>(42i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<f64>(42_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_u32.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_u16.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_u8.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_i32.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_i16.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_i8.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42.0_f64);
+ foo::<f64>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<f32>(42_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_u16.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_u8.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_i16.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_i8.into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42.0_f32);
+
+ foo::<u32>((42_u8 as u16).into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i32>((-42_i8).into());
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+}
--- /dev/null
+// 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 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 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 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 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 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 function defined here
+//~| NOTE function defined here
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+//~| NOTE
+
+
+fn main() {
+ foo::<u16>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_u16);
+ foo::<u16>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u16>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<i16>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_u32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42_i16);
+ foo::<i16>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i16>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<u8>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_u8);
+ foo::<u8>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<u8>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<i8>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_u32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42_i8);
+ foo::<i8>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i8>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<f64>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_u32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f64>(42.0_f64);
+ foo::<f64>(42.0_f32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+
+ foo::<f32>(42_usize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_u64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_u32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_u8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_isize);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_i64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_i32);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_i16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42.0_f64);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<f32>(42.0_f32);
+
+ foo::<u32>(42_u8 as u16);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+ foo::<i32>(-42_i8);
+ //~^ ERROR mismatched types
+ //~| NOTE expected
+ //~| NOTE arguments
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:143:16
+ |
+LL | foo::<u16>(42_usize);
+ | ---------- ^^^^^^^^ expected `u16`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `usize` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:147:16
+ |
+LL | foo::<u16>(42_u64);
+ | ---------- ^^^^^^ expected `u16`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u64` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:151:16
+ |
+LL | foo::<u16>(42_u32);
+ | ---------- ^^^^^^ expected `u16`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u32` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:156:16
+ |
+LL | foo::<u16>(42_u8);
+ | ---------- ^^^^^ expected `u16`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u8` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:160:16
+ |
+LL | foo::<u16>(42_isize);
+ | ---------- ^^^^^^^^ expected `u16`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:164:16
+ |
+LL | foo::<u16>(42_i64);
+ | ---------- ^^^^^^ expected `u16`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:168:16
+ |
+LL | foo::<u16>(42_i32);
+ | ---------- ^^^^^^ expected `u16`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i32` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:172:16
+ |
+LL | foo::<u16>(42_i16);
+ | ---------- ^^^^^^ expected `u16`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i16` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:176:16
+ |
+LL | foo::<u16>(42_i8);
+ | ---------- ^^^^^ expected `u16`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i8` to `u16`
+ |
+LL | foo::<u16>(42_u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:180:16
+ |
+LL | foo::<u16>(42.0_f64);
+ | ---------- ^^^^^^^^ expected `u16`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f64` to `u16`
+ |
+LL | foo::<u16>(42u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:184:16
+ |
+LL | foo::<u16>(42.0_f32);
+ | ---------- ^^^^^^^^ expected `u16`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f32` to `u16`
+ |
+LL | foo::<u16>(42u16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:189:16
+ |
+LL | foo::<i16>(42_usize);
+ | ---------- ^^^^^^^^ expected `i16`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `usize` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:193:16
+ |
+LL | foo::<i16>(42_u64);
+ | ---------- ^^^^^^ expected `i16`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u64` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:197:16
+ |
+LL | foo::<i16>(42_u32);
+ | ---------- ^^^^^^ expected `i16`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u32` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:201:16
+ |
+LL | foo::<i16>(42_u16);
+ | ---------- ^^^^^^ expected `i16`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u16` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:205:16
+ |
+LL | foo::<i16>(42_u8);
+ | ---------- ^^^^^ expected `i16`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u8` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:209:16
+ |
+LL | foo::<i16>(42_isize);
+ | ---------- ^^^^^^^^ expected `i16`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:213:16
+ |
+LL | foo::<i16>(42_i64);
+ | ---------- ^^^^^^ expected `i16`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:217:16
+ |
+LL | foo::<i16>(42_i32);
+ | ---------- ^^^^^^ expected `i16`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i32` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:222:16
+ |
+LL | foo::<i16>(42_i8);
+ | ---------- ^^^^^ expected `i16`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i8` to `i16`
+ |
+LL | foo::<i16>(42_i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:226:16
+ |
+LL | foo::<i16>(42.0_f64);
+ | ---------- ^^^^^^^^ expected `i16`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f64` to `i16`
+ |
+LL | foo::<i16>(42i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:230:16
+ |
+LL | foo::<i16>(42.0_f32);
+ | ---------- ^^^^^^^^ expected `i16`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f32` to `i16`
+ |
+LL | foo::<i16>(42i16);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:235:15
+ |
+LL | foo::<u8>(42_usize);
+ | --------- ^^^^^^^^ expected `u8`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `usize` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:239:15
+ |
+LL | foo::<u8>(42_u64);
+ | --------- ^^^^^^ expected `u8`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u64` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:243:15
+ |
+LL | foo::<u8>(42_u32);
+ | --------- ^^^^^^ expected `u8`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u32` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:247:15
+ |
+LL | foo::<u8>(42_u16);
+ | --------- ^^^^^^ expected `u8`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u16` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:252:15
+ |
+LL | foo::<u8>(42_isize);
+ | --------- ^^^^^^^^ expected `u8`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:256:15
+ |
+LL | foo::<u8>(42_i64);
+ | --------- ^^^^^^ expected `u8`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:260:15
+ |
+LL | foo::<u8>(42_i32);
+ | --------- ^^^^^^ expected `u8`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i32` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:264:15
+ |
+LL | foo::<u8>(42_i16);
+ | --------- ^^^^^^ expected `u8`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i16` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:268:15
+ |
+LL | foo::<u8>(42_i8);
+ | --------- ^^^^^ expected `u8`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i8` to `u8`
+ |
+LL | foo::<u8>(42_u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:272:15
+ |
+LL | foo::<u8>(42.0_f64);
+ | --------- ^^^^^^^^ expected `u8`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f64` to `u8`
+ |
+LL | foo::<u8>(42u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:276:15
+ |
+LL | foo::<u8>(42.0_f32);
+ | --------- ^^^^^^^^ expected `u8`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f32` to `u8`
+ |
+LL | foo::<u8>(42u8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:281:15
+ |
+LL | foo::<i8>(42_usize);
+ | --------- ^^^^^^^^ expected `i8`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `usize` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:285:15
+ |
+LL | foo::<i8>(42_u64);
+ | --------- ^^^^^^ expected `i8`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u64` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:289:15
+ |
+LL | foo::<i8>(42_u32);
+ | --------- ^^^^^^ expected `i8`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u32` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:293:15
+ |
+LL | foo::<i8>(42_u16);
+ | --------- ^^^^^^ expected `i8`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u16` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:297:15
+ |
+LL | foo::<i8>(42_u8);
+ | --------- ^^^^^ expected `i8`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u8` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:301:15
+ |
+LL | foo::<i8>(42_isize);
+ | --------- ^^^^^^^^ expected `i8`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:305:15
+ |
+LL | foo::<i8>(42_i64);
+ | --------- ^^^^^^ expected `i8`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:309:15
+ |
+LL | foo::<i8>(42_i32);
+ | --------- ^^^^^^ expected `i8`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i32` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:313:15
+ |
+LL | foo::<i8>(42_i16);
+ | --------- ^^^^^^ expected `i8`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i16` to `i8`
+ |
+LL | foo::<i8>(42_i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:318:15
+ |
+LL | foo::<i8>(42.0_f64);
+ | --------- ^^^^^^^^ expected `i8`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f64` to `i8`
+ |
+LL | foo::<i8>(42i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:322:15
+ |
+LL | foo::<i8>(42.0_f32);
+ | --------- ^^^^^^^^ expected `i8`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f32` to `i8`
+ |
+LL | foo::<i8>(42i8);
+ | ~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:327:16
+ |
+LL | foo::<f64>(42_usize);
+ | ---------- ^^^^^^^^ expected `f64`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `usize` to `f64`
+ |
+LL | foo::<f64>(42_f64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:331:16
+ |
+LL | foo::<f64>(42_u64);
+ | ---------- ^^^^^^ expected `f64`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u64` to `f64`
+ |
+LL | foo::<f64>(42_f64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:335:16
+ |
+LL | foo::<f64>(42_u32);
+ | ---------- ^^^^^^ expected `f64`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_u32.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:339:16
+ |
+LL | foo::<f64>(42_u16);
+ | ---------- ^^^^^^ expected `f64`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_u16.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:343:16
+ |
+LL | foo::<f64>(42_u8);
+ | ---------- ^^^^^ expected `f64`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_u8.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:347:16
+ |
+LL | foo::<f64>(42_isize);
+ | ---------- ^^^^^^^^ expected `f64`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `f64`
+ |
+LL | foo::<f64>(42_f64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:351:16
+ |
+LL | foo::<f64>(42_i64);
+ | ---------- ^^^^^^ expected `f64`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `f64`
+ |
+LL | foo::<f64>(42_f64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:355:16
+ |
+LL | foo::<f64>(42_i32);
+ | ---------- ^^^^^^ expected `f64`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_i32.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:359:16
+ |
+LL | foo::<f64>(42_i16);
+ | ---------- ^^^^^^ expected `f64`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_i16.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:363:16
+ |
+LL | foo::<f64>(42_i8);
+ | ---------- ^^^^^ expected `f64`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_i8.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:368:16
+ |
+LL | foo::<f64>(42.0_f32);
+ | ---------- ^^^^^^^^ expected `f64`, found `f32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f32` to `f64`
+ |
+LL | foo::<f64>(42.0_f64);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:373:16
+ |
+LL | foo::<f32>(42_usize);
+ | ---------- ^^^^^^^^ expected `f32`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `usize` to `f32`
+ |
+LL | foo::<f32>(42_f32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:377:16
+ |
+LL | foo::<f32>(42_u64);
+ | ---------- ^^^^^^ expected `f32`, found `u64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u64` to `f32`
+ |
+LL | foo::<f32>(42_f32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:381:16
+ |
+LL | foo::<f32>(42_u32);
+ | ---------- ^^^^^^ expected `f32`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `u32` to `f32`
+ |
+LL | foo::<f32>(42_f32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:385:16
+ |
+LL | foo::<f32>(42_u16);
+ | ---------- ^^^^^^ expected `f32`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_u16.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:389:16
+ |
+LL | foo::<f32>(42_u8);
+ | ---------- ^^^^^ expected `f32`, found `u8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_u8.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:393:16
+ |
+LL | foo::<f32>(42_isize);
+ | ---------- ^^^^^^^^ expected `f32`, found `isize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `isize` to `f32`
+ |
+LL | foo::<f32>(42_f32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:397:16
+ |
+LL | foo::<f32>(42_i64);
+ | ---------- ^^^^^^ expected `f32`, found `i64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i64` to `f32`
+ |
+LL | foo::<f32>(42_f32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:401:16
+ |
+LL | foo::<f32>(42_i32);
+ | ---------- ^^^^^^ expected `f32`, found `i32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `i32` to `f32`
+ |
+LL | foo::<f32>(42_f32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:405:16
+ |
+LL | foo::<f32>(42_i16);
+ | ---------- ^^^^^^ expected `f32`, found `i16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_i16.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:409:16
+ |
+LL | foo::<f32>(42_i8);
+ | ---------- ^^^^^ expected `f32`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3: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>(42_i8.into());
+ | +++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:413:16
+ |
+LL | foo::<f32>(42.0_f64);
+ | ---------- ^^^^^^^^ expected `f32`, found `f64`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: change the type of the numeric literal from `f64` to `f32`
+ |
+LL | foo::<f32>(42.0_f32);
+ | ~~~
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:419:16
+ |
+LL | foo::<u32>(42_u8 as u16);
+ | ---------- ^^^^^^^^^^^^ expected `u32`, found `u16`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: you can convert a `u16` to a `u32`
+ |
+LL | foo::<u32>((42_u8 as u16).into());
+ | + ++++++++
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-suffix.rs:423:16
+ |
+LL | foo::<i32>(-42_i8);
+ | ---------- ^^^^^^ expected `i32`, found `i8`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/numeric-suffix.rs:3:4
+ |
+LL | fn foo<N>(_x: N) {}
+ | ^^^ -----
+help: you can convert an `i8` to an `i32`
+ |
+LL | foo::<i32>((-42_i8).into());
+ | + ++++++++
+
+error: aborting due to 68 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
-pub fn f(
+pub fn f( //~ NOTE function defined here
/// Comment
//~^ ERROR documentation comments cannot be applied to function parameters
//~| NOTE doc comments are not allowed here
+ //~| NOTE
id: u8,
/// Other
//~^ ERROR documentation comments cannot be applied to function parameters
//~| NOTE doc comments are not allowed here
+ //~| NOTE
a: u8,
) {}
fn bar(id: #[allow(dead_code)] i32) {}
//~^ ERROR attributes cannot be applied to a function parameter's type
//~| NOTE attributes are not allowed here
+//~| NOTE function defined here
+//~| NOTE
fn main() {
// verify that the parser recovered and properly typechecked the args
f("", "");
- //~^ ERROR mismatched types
+ //~^ ERROR arguments to this function are incorrect
//~| NOTE expected `u8`, found `&str`
- //~| ERROR mismatched types
//~| NOTE expected `u8`, found `&str`
bar("");
//~^ ERROR mismatched types
+ //~| NOTE arguments to this function are incorrect
//~| NOTE expected `i32`, found `&str`
}
error: attributes cannot be applied to a function parameter's type
- --> $DIR/fn-arg-doc-comment.rs:12:12
+ --> $DIR/fn-arg-doc-comment.rs:14:12
|
LL | fn bar(id: #[allow(dead_code)] i32) {}
| ^^^^^^^^^^^^^^^^^^^ attributes are not allowed here
| ^^^^^^^^^^^ doc comments are not allowed here
error: documentation comments cannot be applied to function parameters
- --> $DIR/fn-arg-doc-comment.rs:6:5
+ --> $DIR/fn-arg-doc-comment.rs:7:5
|
LL | /// Other
| ^^^^^^^^^ doc comments are not allowed here
-error[E0308]: mismatched types
- --> $DIR/fn-arg-doc-comment.rs:18:7
+error[E0308]: arguments to this function are incorrect
+ --> $DIR/fn-arg-doc-comment.rs:22:5
|
LL | f("", "");
- | ^^ expected `u8`, found `&str`
-
-error[E0308]: mismatched types
- --> $DIR/fn-arg-doc-comment.rs:18:11
+ | ^ -- -- expected `u8`, found `&str`
+ | |
+ | expected `u8`, found `&str`
|
-LL | f("", "");
- | ^^ expected `u8`, found `&str`
+note: function defined here
+ --> $DIR/fn-arg-doc-comment.rs:1:8
+ |
+LL | pub fn f(
+ | ^
+LL | / /// Comment
+LL | |
+LL | |
+LL | |
+LL | | id: u8,
+ | |__________-
+LL | / /// Other
+LL | |
+LL | |
+LL | |
+LL | | a: u8,
+ | |_________-
error[E0308]: mismatched types
- --> $DIR/fn-arg-doc-comment.rs:23:9
+ --> $DIR/fn-arg-doc-comment.rs:26:9
|
LL | bar("");
- | ^^ expected `i32`, found `&str`
+ | --- ^^ expected `i32`, found `&str`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/fn-arg-doc-comment.rs:14:4
+ |
+LL | fn bar(id: #[allow(dead_code)] i32) {}
+ | ^^^ ---------------------------
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0308`.
--> $DIR/pattern-error-continue.rs:28:7
|
LL | f(true);
- | ^^^^ expected `char`, found `bool`
+ | - ^^^^ expected `char`, found `bool`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/pattern-error-continue.rs:13:4
+ |
+LL | fn f(_c: char) {}
+ | ^ --------
error: aborting due to 5 previous errors
|
= note: expected fn pointer `fn(proc_macro::TokenStream) -> proc_macro::TokenStream`
found fn item `unsafe extern "C" fn(i32, u32) -> u32 {foo}`
+note: associated function defined here
+ --> $SRC_DIR/proc_macro/src/bridge/client.rs:LL:COL
+ |
+LL | pub const fn custom_derive(
+ | ^^^^^^^^^^^^^
error: aborting due to previous error
--> $DIR/issue-54505-no-literals.rs:16:16
|
LL | take_range(std::ops::Range { start: 0, end: 1 });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `std::ops::Range`
- | help: consider borrowing here: `&std::ops::Range { start: 0, end: 1 }`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `std::ops::Range`
+ | | help: consider borrowing here: `&std::ops::Range { start: 0, end: 1 }`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `std::ops::Range<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:21:16
|
LL | take_range(::std::ops::Range { start: 0, end: 1 });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `std::ops::Range`
- | help: consider borrowing here: `&::std::ops::Range { start: 0, end: 1 }`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `std::ops::Range`
+ | | help: consider borrowing here: `&::std::ops::Range { start: 0, end: 1 }`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `std::ops::Range<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:26:16
|
LL | take_range(std::ops::RangeFrom { start: 1 });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeFrom`
- | help: consider borrowing here: `&std::ops::RangeFrom { start: 1 }`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeFrom`
+ | | help: consider borrowing here: `&std::ops::RangeFrom { start: 1 }`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeFrom<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:31:16
|
LL | take_range(::std::ops::RangeFrom { start: 1 });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeFrom`
- | help: consider borrowing here: `&::std::ops::RangeFrom { start: 1 }`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeFrom`
+ | | help: consider borrowing here: `&::std::ops::RangeFrom { start: 1 }`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeFrom<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:36:16
|
LL | take_range(std::ops::RangeFull {});
- | ^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeFull`
- | help: consider borrowing here: `&std::ops::RangeFull {}`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeFull`
+ | | help: consider borrowing here: `&std::ops::RangeFull {}`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeFull`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:41:16
|
LL | take_range(::std::ops::RangeFull {});
- | ^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeFull`
- | help: consider borrowing here: `&::std::ops::RangeFull {}`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeFull`
+ | | help: consider borrowing here: `&::std::ops::RangeFull {}`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeFull`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:46:16
|
LL | take_range(std::ops::RangeInclusive::new(0, 1));
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeInclusive`
- | help: consider borrowing here: `&std::ops::RangeInclusive::new(0, 1)`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeInclusive`
+ | | help: consider borrowing here: `&std::ops::RangeInclusive::new(0, 1)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeInclusive<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:51:16
|
LL | take_range(::std::ops::RangeInclusive::new(0, 1));
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeInclusive`
- | help: consider borrowing here: `&::std::ops::RangeInclusive::new(0, 1)`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeInclusive`
+ | | help: consider borrowing here: `&::std::ops::RangeInclusive::new(0, 1)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeInclusive<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:56:16
|
LL | take_range(std::ops::RangeTo { end: 5 });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeTo`
- | help: consider borrowing here: `&std::ops::RangeTo { end: 5 }`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeTo`
+ | | help: consider borrowing here: `&std::ops::RangeTo { end: 5 }`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeTo<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:61:16
|
LL | take_range(::std::ops::RangeTo { end: 5 });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeTo`
- | help: consider borrowing here: `&::std::ops::RangeTo { end: 5 }`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeTo`
+ | | help: consider borrowing here: `&::std::ops::RangeTo { end: 5 }`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeTo<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:66:16
|
LL | take_range(std::ops::RangeToInclusive { end: 5 });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeToInclusive`
- | help: consider borrowing here: `&std::ops::RangeToInclusive { end: 5 }`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeToInclusive`
+ | | help: consider borrowing here: `&std::ops::RangeToInclusive { end: 5 }`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeToInclusive<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-literals.rs:71:16
|
LL | take_range(::std::ops::RangeToInclusive { end: 5 });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `RangeToInclusive`
- | help: consider borrowing here: `&::std::ops::RangeToInclusive { end: 5 }`
+ | ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `RangeToInclusive`
+ | | help: consider borrowing here: `&::std::ops::RangeToInclusive { end: 5 }`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeToInclusive<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-literals.rs:12:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error: aborting due to 12 previous errors
--> $DIR/issue-54505-no-std.rs:27:16
|
LL | take_range(0..1);
- | ^^^^
- | |
- | expected reference, found struct `Range`
- | help: consider borrowing here: `&(0..1)`
+ | ---------- ^^^^
+ | | |
+ | | expected reference, found struct `Range`
+ | | help: consider borrowing here: `&(0..1)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `Range<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-std.rs:23:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:32:16
|
LL | take_range(1..);
- | ^^^
- | |
- | expected reference, found struct `RangeFrom`
- | help: consider borrowing here: `&(1..)`
+ | ---------- ^^^
+ | | |
+ | | expected reference, found struct `RangeFrom`
+ | | help: consider borrowing here: `&(1..)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeFrom<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-std.rs:23:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:37:16
|
LL | take_range(..);
- | ^^
- | |
- | expected reference, found struct `RangeFull`
- | help: consider borrowing here: `&(..)`
+ | ---------- ^^
+ | | |
+ | | expected reference, found struct `RangeFull`
+ | | help: consider borrowing here: `&(..)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeFull`
+note: function defined here
+ --> $DIR/issue-54505-no-std.rs:23:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:42:16
|
LL | take_range(0..=1);
- | ^^^^^
- | |
- | expected reference, found struct `RangeInclusive`
- | help: consider borrowing here: `&(0..=1)`
+ | ---------- ^^^^^
+ | | |
+ | | expected reference, found struct `RangeInclusive`
+ | | help: consider borrowing here: `&(0..=1)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeInclusive<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-std.rs:23:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:47:16
|
LL | take_range(..5);
- | ^^^
- | |
- | expected reference, found struct `RangeTo`
- | help: consider borrowing here: `&(..5)`
+ | ---------- ^^^
+ | | |
+ | | expected reference, found struct `RangeTo`
+ | | help: consider borrowing here: `&(..5)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeTo<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-std.rs:23:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505-no-std.rs:52:16
|
LL | take_range(..=42);
- | ^^^^^
- | |
- | expected reference, found struct `RangeToInclusive`
- | help: consider borrowing here: `&(..=42)`
+ | ---------- ^^^^^
+ | | |
+ | | expected reference, found struct `RangeToInclusive`
+ | | help: consider borrowing here: `&(..=42)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeToInclusive<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505-no-std.rs:23:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error: aborting due to 7 previous errors
--> $DIR/issue-54505.rs:14:16
|
LL | take_range(0..1);
- | ^^^^
- | |
- | expected reference, found struct `std::ops::Range`
- | help: consider borrowing here: `&(0..1)`
+ | ---------- ^^^^
+ | | |
+ | | expected reference, found struct `std::ops::Range`
+ | | help: consider borrowing here: `&(0..1)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `std::ops::Range<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505.rs:10:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:19:16
|
LL | take_range(1..);
- | ^^^
- | |
- | expected reference, found struct `RangeFrom`
- | help: consider borrowing here: `&(1..)`
+ | ---------- ^^^
+ | | |
+ | | expected reference, found struct `RangeFrom`
+ | | help: consider borrowing here: `&(1..)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeFrom<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505.rs:10:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:24:16
|
LL | take_range(..);
- | ^^
- | |
- | expected reference, found struct `RangeFull`
- | help: consider borrowing here: `&(..)`
+ | ---------- ^^
+ | | |
+ | | expected reference, found struct `RangeFull`
+ | | help: consider borrowing here: `&(..)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeFull`
+note: function defined here
+ --> $DIR/issue-54505.rs:10:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:29:16
|
LL | take_range(0..=1);
- | ^^^^^
- | |
- | expected reference, found struct `RangeInclusive`
- | help: consider borrowing here: `&(0..=1)`
+ | ---------- ^^^^^
+ | | |
+ | | expected reference, found struct `RangeInclusive`
+ | | help: consider borrowing here: `&(0..=1)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeInclusive<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505.rs:10:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:34:16
|
LL | take_range(..5);
- | ^^^
- | |
- | expected reference, found struct `RangeTo`
- | help: consider borrowing here: `&(..5)`
+ | ---------- ^^^
+ | | |
+ | | expected reference, found struct `RangeTo`
+ | | help: consider borrowing here: `&(..5)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeTo<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505.rs:10:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error[E0308]: mismatched types
--> $DIR/issue-54505.rs:39:16
|
LL | take_range(..=42);
- | ^^^^^
- | |
- | expected reference, found struct `RangeToInclusive`
- | help: consider borrowing here: `&(..=42)`
+ | ---------- ^^^^^
+ | | |
+ | | expected reference, found struct `RangeToInclusive`
+ | | help: consider borrowing here: `&(..=42)`
+ | arguments to this function are incorrect
|
= note: expected reference `&_`
found struct `RangeToInclusive<{integer}>`
+note: function defined here
+ --> $DIR/issue-54505.rs:10:4
+ |
+LL | fn take_range(_r: &impl RangeBounds<i8>) {}
+ | ^^^^^^^^^^ -------------------------
error: aborting due to 6 previous errors
--> $DIR/issue-73553-misinterp-range-literal.rs:12:10
|
LL | demo(tell(1)..tell(10));
- | ^^^^^^^^^^^^^^^^^
- | |
- | expected reference, found struct `std::ops::Range`
- | help: consider borrowing here: `&(tell(1)..tell(10))`
+ | ---- ^^^^^^^^^^^^^^^^^
+ | | |
+ | | expected reference, found struct `std::ops::Range`
+ | | help: consider borrowing here: `&(tell(1)..tell(10))`
+ | arguments to this function are incorrect
|
= note: expected reference `&std::ops::Range<usize>`
found struct `std::ops::Range<usize>`
+note: function defined here
+ --> $DIR/issue-73553-misinterp-range-literal.rs:3:4
+ |
+LL | fn demo(r: &Range) {
+ | ^^^^ ---------
error[E0308]: mismatched types
--> $DIR/issue-73553-misinterp-range-literal.rs:14:10
|
LL | demo(1..10);
- | ^^^^^
- | |
- | expected reference, found struct `std::ops::Range`
- | help: consider borrowing here: `&(1..10)`
+ | ---- ^^^^^
+ | | |
+ | | expected reference, found struct `std::ops::Range`
+ | | help: consider borrowing here: `&(1..10)`
+ | arguments to this function are incorrect
|
= note: expected reference `&std::ops::Range<usize>`
found struct `std::ops::Range<{integer}>`
+note: function defined here
+ --> $DIR/issue-73553-misinterp-range-literal.rs:3:4
+ |
+LL | fn demo(r: &Range) {
+ | ^^^^ ---------
error: aborting due to 2 previous errors
--> $DIR/resolve-primitive-fallback.rs:3:5
|
LL | std::mem::size_of(u16);
- | ^^^^^^^^^^^^^^^^^ --- supplied 1 argument
- | |
- | expected 0 arguments
+ | ^^^^^^^^^^^^^^^^^ --- argument unexpected
|
note: function defined here
--> $SRC_DIR/core/src/mem/mod.rs:LL:COL
|
LL | pub const fn size_of<T>() -> usize {
| ^^^^^^^
+help: remove the extra argument
+ |
+LL | std::mem::size_of();
+ | ~~~~~~~~~~~~~~~~~~~
error: aborting due to 3 previous errors
--> $DIR/issue-61882.rs:4:27
|
LL | const B: A<u8> = Self(0);
- | ^ expected `bool`, found integer
+ | ---- ^ expected `bool`, found integer
+ | |
+ | arguments to this function are incorrect
+ |
+note: tuple struct defined here
+ --> $DIR/issue-61882.rs:1:8
+ |
+LL | struct A<T>(T);
+ | ^
error[E0308]: mismatched types
--> $DIR/issue-61882.rs:4:22
--- /dev/null
+fn main() {
+ let f = |x| x * 3;
+ let a = f(); //~ ERROR E0057
+ let b = f(4);
+ let c = f(2, 3); //~ ERROR E0057
+}
--- /dev/null
+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
+ |
+help: provide the argument
+ |
+LL | let a = f({_});
+ | ~~~~~~
+
+error[E0057]: this function takes 1 argument but 2 arguments were supplied
+ --> $DIR/E0057.rs:5:13
+ |
+LL | let c = f(2, 3);
+ | ^ - argument unexpected
+ |
+help: remove the extra argument
+ |
+LL | let c = f(2);
+ | ~~~~
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0057`.
--> $DIR/coerce-suggestions.rs:12:10
|
LL | test(&y);
- | ^^ types differ in mutability
+ | ---- ^^ types differ in mutability
+ | |
+ | arguments to this function are incorrect
|
= note: expected mutable reference `&mut String`
found reference `&String`
+note: function defined here
+ --> $DIR/coerce-suggestions.rs:1:4
+ |
+LL | fn test(_x: &mut String) {}
+ | ^^^^ ---------------
error[E0308]: mismatched types
--> $DIR/coerce-suggestions.rs:14:11
|
LL | test2(&y);
- | ^^ types differ in mutability
+ | ----- ^^ types differ in mutability
+ | |
+ | arguments to this function are incorrect
|
= note: expected mutable reference `&mut i32`
found reference `&String`
+note: function defined here
+ --> $DIR/coerce-suggestions.rs:3:4
+ |
+LL | fn test2(_x: &mut i32) {}
+ | ^^^^^ ------------
error[E0308]: mismatched types
--> $DIR/coerce-suggestions.rs:17:9
--> $DIR/issue-34264.rs:7:5
|
LL | foo(Some(42), 2, "");
- | ^^^ -------- - -- supplied 3 arguments
- | |
- | expected 2 arguments
+ | ^^^ -- argument unexpected
|
note: function defined here
--> $DIR/issue-34264.rs:1:4
|
LL | fn foo(Option<i32>, String) {}
| ^^^ ----------- ------
+help: remove the extra argument
+ |
+LL | foo(Some(42), 2);
+ | ~~~~~~~~~~~~~~~~
error[E0308]: mismatched types
--> $DIR/issue-34264.rs:8:13
|
LL | bar("", "");
- | ^^ expected `usize`, found `&str`
+ | --- ^^ expected `usize`, found `&str`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/issue-34264.rs:3:4
+ |
+LL | fn bar(x, y: usize) {}
+ | ^^^ - --------
error[E0061]: this function takes 2 arguments but 3 arguments were supplied
--> $DIR/issue-34264.rs:10:5
|
LL | bar(1, 2, 3);
- | ^^^ - - - supplied 3 arguments
- | |
- | expected 2 arguments
+ | ^^^ - argument unexpected
|
note: function defined here
--> $DIR/issue-34264.rs:3:4
|
LL | fn bar(x, y: usize) {}
| ^^^ - --------
+help: remove the extra argument
+ |
+LL | bar(1, 2);
+ | ~~~~~~~~~
error: aborting due to 6 previous errors
--> $DIR/missing-unit-argument.rs:11:33
|
LL | let _: Result<(), String> = Ok();
- | ^^-- supplied 0 arguments
+ | ^^-- an argument of type `()` is missing
|
-help: expected the unit value `()`; create it with empty parentheses
+help: provide the argument
|
LL | let _: Result<(), String> = Ok(());
- | ++
+ | ~~~~~~
error[E0061]: this function takes 2 arguments but 0 arguments were supplied
--> $DIR/missing-unit-argument.rs:12:5
|
LL | foo();
- | ^^^-- supplied 0 arguments
- | |
- | expected 2 arguments
+ | ^^^-- two arguments of type `()` and `()` are missing
|
note: function defined here
--> $DIR/missing-unit-argument.rs:1:4
|
LL | fn foo(():(), ():()) {}
| ^^^ ----- -----
+help: provide the arguments
+ |
+LL | foo((), ());
+ | ~~~~~~~~~~~
error[E0061]: this function takes 2 arguments but 1 argument was supplied
--> $DIR/missing-unit-argument.rs:13:5
|
LL | foo(());
- | ^^^ -- supplied 1 argument
- | |
- | expected 2 arguments
+ | ^^^---- an argument of type `()` is missing
|
note: function defined here
--> $DIR/missing-unit-argument.rs:1:4
|
LL | fn foo(():(), ():()) {}
| ^^^ ----- -----
+help: provide the argument
+ |
+LL | foo((), ());
+ | ~~~~~~~~~~~
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/missing-unit-argument.rs:14:5
|
LL | bar();
- | ^^^-- supplied 0 arguments
+ | ^^^-- an argument of type `()` is missing
|
note: function defined here
--> $DIR/missing-unit-argument.rs:2:4
|
LL | fn bar(():()) {}
| ^^^ -----
-help: expected the unit value `()`; create it with empty parentheses
+help: provide the argument
|
LL | bar(());
- | ++
+ | ~~~~~~~
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/missing-unit-argument.rs:15:7
|
LL | S.baz();
- | ^^^- supplied 0 arguments
+ | ^^^-- an argument of type `()` is missing
|
note: associated function defined here
--> $DIR/missing-unit-argument.rs:6:8
|
LL | fn baz(self, (): ()) { }
| ^^^ ---- ------
-help: expected the unit value `()`; create it with empty parentheses
+help: provide the argument
|
LL | S.baz(());
- | ++
+ | ~~~~~~~
error[E0061]: this function takes 1 argument but 0 arguments were supplied
--> $DIR/missing-unit-argument.rs:16:7
|
LL | S.generic::<()>();
- | ^^^^^^^------ supplied 0 arguments
+ | ^^^^^^^^^^^^^-- an argument of type `()` is missing
|
note: associated function defined here
--> $DIR/missing-unit-argument.rs:7:8
|
LL | fn generic<T>(self, _: T) { }
| ^^^^^^^ ---- ----
-help: expected the unit value `()`; create it with empty parentheses
+help: provide the argument
|
LL | S.generic::<()>(());
- | ++
+ | ~~~~~~~~~~~~~~~~~
error: aborting due to 6 previous errors
--> $DIR/args-instead-of-tuple-errors.rs:6:34
|
LL | let _: Option<(i32, bool)> = Some(1, 2);
- | ^^^^ - - supplied 2 arguments
- | |
- | expected 1 argument
+ | ^^^^ - - argument unexpected
+ | |
+ | expected tuple, found integer
+ |
+ = note: expected tuple `(i32, bool)`
+ found type `{integer}`
+help: remove the extra argument
+ |
+LL | let _: Option<(i32, bool)> = Some({(i32, bool)});
+ | ~~~~~~~~~~~~~~~~~~~
error[E0061]: this function takes 1 argument but 2 arguments were supplied
--> $DIR/args-instead-of-tuple-errors.rs:8:5
|
LL | int_bool(1, 2);
- | ^^^^^^^^ - - supplied 2 arguments
- | |
- | expected 1 argument
+ | ^^^^^^^^ - - argument unexpected
+ | |
+ | expected tuple, found integer
|
+ = note: expected tuple `(i32, bool)`
+ found type `{integer}`
note: function defined here
--> $DIR/args-instead-of-tuple-errors.rs:21:4
|
LL | fn int_bool(_: (i32, bool)) {
| ^^^^^^^^ --------------
+help: remove the extra argument
+ |
+LL | int_bool({(i32, bool)});
+ | ~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this enum variant takes 1 argument but 0 arguments were supplied
--> $DIR/args-instead-of-tuple-errors.rs:11:28
|
LL | let _: Option<(i8,)> = Some();
- | ^^^^-- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^^^^-- an argument of type `(i8,)` is missing
+ |
+help: provide the argument
+ |
+LL | let _: Option<(i8,)> = Some({(i8,)});
+ | ~~~~~~~~~~~~~
error[E0308]: mismatched types
--> $DIR/args-instead-of-tuple-errors.rs:14:34
|
LL | let _: Option<(i32,)> = Some(5_usize);
- | ^^^^^^^ expected tuple, found `usize`
+ | ---- ^^^^^^^ expected tuple, found `usize`
+ | |
+ | arguments to this enum variant are incorrect
|
= note: expected tuple `(i32,)`
found type `usize`
--> $DIR/args-instead-of-tuple-errors.rs:17:34
|
LL | let _: Option<(i32,)> = Some((5_usize));
- | ^^^^^^^^^ expected tuple, found `usize`
+ | ---- ^^^^^^^^^ expected tuple, found `usize`
+ | |
+ | arguments to this enum variant are incorrect
|
= note: expected tuple `(i32,)`
found type `usize`
--> $DIR/args-instead-of-tuple.rs:7:36
|
LL | let _: Result<(i32, i8), ()> = Ok(1, 2);
- | ^^ - - supplied 2 arguments
+ | ^^
|
help: use parentheses to construct a tuple
|
--> $DIR/args-instead-of-tuple.rs:9:46
|
LL | let _: Option<(i32, i8, &'static str)> = Some(1, 2, "hi");
- | ^^^^ - - ---- supplied 3 arguments
+ | ^^^^
|
help: use parentheses to construct a tuple
|
--> $DIR/args-instead-of-tuple.rs:11:25
|
LL | let _: Option<()> = Some();
- | ^^^^-- supplied 0 arguments
+ | ^^^^-- an argument of type `()` is missing
|
-help: expected the unit value `()`; create it with empty parentheses
+help: provide the argument
|
LL | let _: Option<()> = Some(());
- | ++
+ | ~~~~~~~~
error[E0308]: mismatched types
--> $DIR/args-instead-of-tuple.rs:14:34
|
LL | let _: Option<(i32,)> = Some(3);
- | ^ expected tuple, found integer
+ | ---- ^ expected tuple, found integer
+ | |
+ | arguments to this enum variant are incorrect
|
= note: expected tuple `(i32,)`
found type `{integer}`
--> $DIR/args-instead-of-tuple.rs:17:34
|
LL | let _: Option<(i32,)> = Some((3));
- | ^^^ expected tuple, found integer
+ | ---- ^^^ expected tuple, found integer
+ | |
+ | arguments to this enum variant are incorrect
|
= note: expected tuple `(i32,)`
found type `{integer}`
--> $DIR/args-instead-of-tuple.rs:20:5
|
LL | two_ints(1, 2);
- | ^^^^^^^^ - - supplied 2 arguments
+ | ^^^^^^^^
|
note: function defined here
--> $DIR/args-instead-of-tuple.rs:25:4
--> $DIR/args-instead-of-tuple.rs:22:5
|
LL | with_generic(3, 4);
- | ^^^^^^^^^^^^ - - supplied 2 arguments
+ | ^^^^^^^^^^^^
|
note: function defined here
--> $DIR/args-instead-of-tuple.rs:28:4
--> $DIR/args-instead-of-tuple.rs:31:9
|
LL | with_generic(a, b);
- | ^^^^^^^^^^^^ - - supplied 2 arguments
+ | ^^^^^^^^^^^^
|
note: function defined here
--> $DIR/args-instead-of-tuple.rs:28:4
--> $DIR/as-ref.rs:7:29
|
LL | opt.map(|arg| takes_ref(arg));
- | --- ^^^ expected `&Foo`, found struct `Foo`
- | |
+ | --- --------- ^^^ expected `&Foo`, found struct `Foo`
+ | | |
+ | | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().map`
+ |
+note: function defined here
+ --> $DIR/as-ref.rs:3:4
+ |
+LL | fn takes_ref(_: &Foo) {}
+ | ^^^^^^^^^ -------
error[E0308]: mismatched types
--> $DIR/as-ref.rs:8:39
|
LL | opt.and_then(|arg| Some(takes_ref(arg)));
- | -------- ^^^ expected `&Foo`, found struct `Foo`
- | |
+ | -------- --------- ^^^ expected `&Foo`, found struct `Foo`
+ | | |
+ | | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().and_then`
+ |
+note: function defined here
+ --> $DIR/as-ref.rs:3:4
+ |
+LL | fn takes_ref(_: &Foo) {}
+ | ^^^^^^^^^ -------
error[E0308]: mismatched types
--> $DIR/as-ref.rs:10:29
|
LL | opt.map(|arg| takes_ref(arg));
- | --- ^^^ expected `&Foo`, found struct `Foo`
- | |
+ | --- --------- ^^^ expected `&Foo`, found struct `Foo`
+ | | |
+ | | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().map`
+ |
+note: function defined here
+ --> $DIR/as-ref.rs:3:4
+ |
+LL | fn takes_ref(_: &Foo) {}
+ | ^^^^^^^^^ -------
error[E0308]: mismatched types
--> $DIR/as-ref.rs:11:37
|
LL | opt.and_then(|arg| Ok(takes_ref(arg)));
- | -------- ^^^ expected `&Foo`, found struct `Foo`
- | |
+ | -------- --------- ^^^ expected `&Foo`, found struct `Foo`
+ | | |
+ | | arguments to this function are incorrect
| help: consider using `as_ref` instead: `as_ref().and_then`
+ |
+note: function defined here
+ --> $DIR/as-ref.rs:3:4
+ |
+LL | fn takes_ref(_: &Foo) {}
+ | ^^^^^^^^^ -------
error[E0308]: mismatched types
--> $DIR/as-ref.rs:13:29
--> $DIR/boxed-variant-field.rs:9:31
|
LL | Ty::List(elem) => foo(elem),
- | ^^^^ expected enum `Ty`, found struct `Box`
+ | --- ^^^^ expected enum `Ty`, found struct `Box`
+ | |
+ | arguments to this function are incorrect
|
= note: expected enum `Ty`
found struct `Box<Ty>`
+note: function defined here
+ --> $DIR/boxed-variant-field.rs:6:4
+ |
+LL | fn foo(x: Ty) -> Ty {
+ | ^^^ -----
help: consider unboxing the value
|
LL | Ty::List(elem) => foo(*elem),
LL | Pin::new(x)
| -------- ^ expected struct `Box`, found type parameter `F`
| |
+ | arguments to this function are incorrect
| help: use `Box::pin` to pin and box this expression: `Box::pin`
|
= note: expected struct `Box<dyn Future<Output = i32> + Send>`
found type parameter `F`
+note: associated function defined here
+ --> $SRC_DIR/core/src/pin.rs:LL:COL
+ |
+LL | pub const fn new(pointer: P) -> Pin<P> {
+ | ^^^
error[E0277]: `dyn Future<Output = i32> + Send` cannot be unpinned
--> $DIR/expected-boxed-future-isnt-pinned.rs:19:5
--> $DIR/issue-86100-tuple-paren-comma.rs:13:9
|
LL | foo((Some(3)));
- | ^^^^^^^^^ expected tuple, found enum `Option`
+ | --- ^^^^^^^^^ expected tuple, found enum `Option`
+ | |
+ | arguments to this function are incorrect
|
= note: expected tuple `(_,)`
found enum `Option<{integer}>`
+note: function defined here
+ --> $DIR/issue-86100-tuple-paren-comma.rs:5:4
+ |
+LL | fn foo<T>(_t: (T,)) {}
+ | ^^^ --------
help: use a trailing comma to create a tuple with one element
|
LL | foo((Some(3),));
--> $DIR/issue-90213-expected-boxfuture-self-ice.rs:9:19
|
LL | Self::foo(None)
- | ^^^^ expected struct `Box`, found enum `Option`
+ | --------- ^^^^ expected struct `Box`, found enum `Option`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Box<Option<S>>`
found enum `Option<_>`
= note: for more on the distinction between the stack and the heap, read https://doc.rust-lang.org/book/ch15-01-box.html, https://doc.rust-lang.org/rust-by-example/std/box.html, and https://doc.rust-lang.org/std/boxed/index.html
+note: associated function defined here
+ --> $DIR/issue-90213-expected-boxfuture-self-ice.rs:7:8
+ |
+LL | fn foo(_: Box<Option<S>>) {}
+ | ^^^ -----------------
help: store this in the heap by calling `Box::new`
|
LL | Self::foo(Box::new(None))
--> $DIR/recover-from-semicolon-trailing-item.rs:14:9
|
LL | foo("");
- | ^^ expected `usize`, found `&str`
+ | --- ^^ expected `usize`, found `&str`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/recover-from-semicolon-trailing-item.rs:6:4
+ |
+LL | fn foo(a: usize) {};
+ | ^^^ --------
error: aborting due to 6 previous errors
--> $DIR/suggest-ref-macro.rs:15:11
|
LL | x(123);
- | ^^^
- | |
- | expected `&mut i32`, found integer
- | help: consider mutably borrowing here: `&mut 123`
+ | - ^^^
+ | | |
+ | | expected `&mut i32`, found integer
+ | | help: consider mutably borrowing here: `&mut 123`
+ | arguments to this function are incorrect
...
LL | bla!();
| ------ in this macro invocation
|
+note: function defined here
+ --> $DIR/suggest-ref-macro.rs:11:4
+ |
+LL | fn x(_: &mut i32) {}
+ | ^ -----------
= note: this error originates in the macro `bla` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0308]: mismatched types
--> $DIR/suggest-ref-macro.rs:26:10
|
+LL | x($v)
+ | - arguments to this function are incorrect
+...
LL | bla!(456);
| ^^^
| |
| expected `&mut i32`, found integer
| help: consider mutably borrowing here: `&mut 456`
+ |
+note: function defined here
+ --> $DIR/suggest-ref-macro.rs:11:4
+ |
+LL | fn x(_: &mut i32) {}
+ | ^ -----------
error[E0308]: mismatched types
--> $DIR/suggest-ref-macro.rs:8:1
|
LL | #[hello]
- | ^^^^^^^^ expected `&mut i32`, found integer
+ | ^^^^^^^^
+ | |
+ | expected `&mut i32`, found integer
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/suggest-ref-macro.rs:8:1
|
+LL | #[hello]
+ | _-^^^^^^^
+LL | | fn abc() {}
+LL | |
+LL | | fn x(_: &mut i32) {}
+LL | |
+LL | | macro_rules! bla {
+ | |_____________-
= note: this error originates in the attribute macro `hello` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 3 previous errors
--> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:13:13
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<impl Trait as Trait>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:41:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<impl Trait as Trait>::A` to `usize`
|
LL | fn foo<'a, T: Trait + 'a>(&self, _: impl Trait, x: impl Trait<A = usize>, _: T) {
--> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:17:13
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<T as Trait>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:41:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<T as Trait>::A` to `usize`
|
LL | fn ban<T>(x: T) where T: Trait<A = usize> {
--> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:22:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<impl Trait as Trait>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:41:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<impl Trait as Trait>::A` to `usize`
|
LL | fn foo<'a, T: Trait + 'a>(_: impl Trait, x: impl Trait<A = usize>, _: T) {
--> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:26:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<T as Trait>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:41:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<T as Trait>::A` to `usize`
|
LL | fn bar<T: Trait<A = usize>>(x: T) {
--> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:30:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<impl Trait<i32> as Trait<i32>>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:41:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<impl Trait<i32> as Trait<i32>>::A` to `usize`
|
LL | fn foo2(x: impl Trait<i32, A = usize>) {
--> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:34:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<T as Trait<i32>>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:41:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<T as Trait<i32>>::A` to `usize`
|
LL | fn bar2<T: Trait<i32, A = usize>>(x: T) {
--> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:38:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<T as Trait>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:41:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<T as Trait>::A` to `usize`
|
LL | fn ban<T>(x: T) where T: Trait<A = usize> {
--> $DIR/trait-with-missing-associated-type-restriction.rs:14:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<impl Trait as Trait>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction.rs:42:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<impl Trait as Trait>::A` to `usize`
|
LL | fn foo(_: impl Trait, x: impl Trait<A = usize>) {
--> $DIR/trait-with-missing-associated-type-restriction.rs:18:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<T as Trait>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction.rs:42:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<T as Trait>::A` to `usize`
|
LL | fn bar<T: Trait<A = usize>>(x: T) {
--> $DIR/trait-with-missing-associated-type-restriction.rs:22:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<impl Trait<i32> as Trait<i32>>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction.rs:42:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<impl Trait<i32> as Trait<i32>>::A` to `usize`
|
LL | fn foo2(x: impl Trait<i32, A = usize>) {
--> $DIR/trait-with-missing-associated-type-restriction.rs:26:12
|
LL | x.funk(3);
- | ^ expected associated type, found integer
+ | ---- ^ expected associated type, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected associated type `<T as Trait<i32>>::A`
found type `{integer}`
LL | fn funk(&self, _: Self::A);
LL | fn funq(&self) -> Self::A {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^ consider calling `Trait::funq`
+note: associated function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction.rs:9:8
+ |
+LL | fn funk(&self, _: Self::A);
+ | ^^^^
help: consider constraining the associated type `<T as Trait<i32>>::A` to `{integer}`
|
LL | fn bar2<T: Trait<i32, A = {integer}>>(x: T) {
--> $DIR/trait-with-missing-associated-type-restriction.rs:27:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<T as Trait<i32>>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction.rs:42:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<T as Trait<i32>>::A` to `usize`
|
LL | fn bar2<T: Trait<i32, A = usize>>(x: T) {
LL | fn baz<D: std::fmt::Debug, T: Trait<A = D>>(x: T) {
| - this type parameter
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found type parameter `D`
+ | --- ^^^^^^^^ expected `usize`, found type parameter `D`
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found type parameter `D`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction.rs:42:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
error[E0308]: mismatched types
--> $DIR/trait-with-missing-associated-type-restriction.rs:35:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found `()`
+ | --- ^^^^^^^^ expected `usize`, found `()`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction.rs:42:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
error[E0308]: mismatched types
--> $DIR/trait-with-missing-associated-type-restriction.rs:39:9
|
LL | qux(x.func())
- | ^^^^^^^^ expected `usize`, found associated type
+ | --- ^^^^^^^^ expected `usize`, found associated type
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found associated type `<T as Trait>::A`
+note: function defined here
+ --> $DIR/trait-with-missing-associated-type-restriction.rs:42:4
+ |
+LL | fn qux(_: usize) {}
+ | ^^^ --------
help: consider constraining the associated type `<T as Trait>::A` to `usize`
|
LL | fn ban<T>(x: T) where T: Trait<A = usize> {
fn main() {
let _: () = 42;
- //~^ ERROR mismatched types
+ //~^ ERROR arguments to this function are incorrect
}
--> $DIR/terr-in-field.rs:13:14
|
LL | want_foo(b);
- | ^ expected struct `Foo`, found struct `Bar`
+ | -------- ^ expected struct `Foo`, found struct `Bar`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/terr-in-field.rs:11:4
+ |
+LL | fn want_foo(f: Foo) {}
+ | ^^^^^^^^ ------
error: aborting due to previous error
--> $DIR/terr-sorts.rs:10:14
|
LL | want_foo(b);
- | ^ expected struct `Foo`, found struct `Box`
+ | -------- ^ expected struct `Foo`, found struct `Box`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo`
found struct `Box<Foo>`
+note: function defined here
+ --> $DIR/terr-sorts.rs:8:4
+ |
+LL | fn want_foo(f: Foo) {}
+ | ^^^^^^^^ ------
help: consider unboxing the value
|
LL | want_foo(*b);
--> $DIR/sugar.rs:12:7
|
LL | a(x);
- | ^ expected trait `Foo + Send`, found trait `Foo + Sync`
+ | - ^ expected trait `Foo + Send`, found trait `Foo + Sync`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Box<(dyn Foo + Send + 'static)>`
found struct `Box<(dyn Foo + Sync + 'static)>`
+note: function defined here
+ --> $DIR/sugar.rs:5:4
+ |
+LL | fn a(_x: Box<dyn Foo + Send>) {
+ | ^ -----------------------
error: aborting due to previous error
| - this type parameter
...
LL | builder.push(output);
- | ^^^^^^ expected type parameter `F`, found struct `Class`
+ | ---- ^^^^^^ expected type parameter `F`, found struct `Class`
+ | |
+ | arguments to this function are incorrect
|
- = note: expected type parameter `F`
- found struct `Class<P>`
+ = note: expected type `F`
+ found struct `Class<P>`
+note: associated function defined here
+ --> $DIR/issue-52893.rs:11:8
+ |
+LL | fn push(self, other: T) -> Self::PushRes;
+ | ^^^^
error: aborting due to previous error
--> $DIR/multidispatch-bad.rs:19:17
|
LL | test(22i32, 44i32);
- | ^^^^^ expected `u32`, found `i32`
+ | ---- ^^^^^ expected `u32`, found `i32`
+ | |
+ | arguments to this function are incorrect
|
+note: function defined here
+ --> $DIR/multidispatch-bad.rs:13:4
+ |
+LL | fn test<T,U>(_: T, _: U)
+ | ^^^^ ---- ----
help: change the type of the numeric literal from `i32` to `u32`
|
LL | test(22i32, 44u32);
--> $DIR/tuple-arity-mismatch.rs:6:20
|
LL | let y = first ((1,2.0,3));
- | ^^^^^^^^^ expected a tuple with 2 elements, found one with 3 elements
+ | ----- ^^^^^^^^^ expected a tuple with 2 elements, found one with 3 elements
+ | |
+ | arguments to this function are incorrect
|
= note: expected tuple `(isize, f64)`
found tuple `(isize, f64, {integer})`
+note: function defined here
+ --> $DIR/tuple-arity-mismatch.rs:3:4
+ |
+LL | fn first((value, _): (isize, f64)) -> isize { value }
+ | ^^^^^ ------------------------
error[E0308]: mismatched types
--> $DIR/tuple-arity-mismatch.rs:12:20
|
LL | let y = first ((1,));
- | ^^^^ expected a tuple with 2 elements, found one with 1 element
+ | ----- ^^^^ expected a tuple with 2 elements, found one with 1 element
+ | |
+ | arguments to this function are incorrect
|
= note: expected tuple `(isize, f64)`
found tuple `(isize,)`
+note: function defined here
+ --> $DIR/tuple-arity-mismatch.rs:3:4
+ |
+LL | fn first((value, _): (isize, f64)) -> isize { value }
+ | ^^^^^ ------------------------
error: aborting due to 2 previous errors
--> $DIR/wrong_argument_ice-2.rs:13:5
|
LL | test(x.qux(), x.qux());
- | ^^^^ ------- ------- supplied 2 arguments
+ | ^^^^
|
note: function defined here
--> $DIR/wrong_argument_ice-2.rs:1:4
--> $DIR/wrong_argument_ice-3.rs:9:16
|
LL | groups.push(new_group, vec![process]);
- | ^^^^ --------- ------------- supplied 2 arguments
- | |
- | expected 1 argument
+ | ^^^^ --------- ------------- argument unexpected
+ | |
+ | expected tuple, found struct `Vec`
|
+ = note: expected tuple `(Vec<String>, Vec<Process>)`
+ found struct `Vec<String>`
note: associated function defined here
--> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
|
LL | pub fn push(&mut self, value: T) {
| ^^^^
+help: remove the extra argument
+ |
+LL | groups.push({(Vec<String>, Vec<Process>)});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
|
LL | (|| {})(|| {
| _____^^^^^^^_-
- | | |
- | | expected 0 arguments
LL | |
LL | | let b = 1;
LL | | });
- | |_____- supplied 1 argument
+ | |_____- argument unexpected
+ |
+help: remove the extra argument
+ |
+LL | (|| {})();
+ | ~~~~~~~~~
error: aborting due to previous error
--> $DIR/wrong_argument_ice.rs:11:18
|
LL | self.acc.push_back(self.current_provides, self.current_requires);
- | ^^^^^^^^^ --------------------- --------------------- supplied 2 arguments
+ | ^^^^^^^^^
|
note: associated function defined here
--> $SRC_DIR/alloc/src/collections/vec_deque/mod.rs:LL:COL
| - this type parameter
LL | fn ts_variant() {
LL | Self::TSVariant(());
- | ^^ expected type parameter `T`, found `()`
+ | --------------- ^^ expected type parameter `T`, found `()`
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `T`
found unit type `()`
+note: tuple variant defined here
+ --> $DIR/enum-variant-generic-args.rs:7:16
+ |
+LL | enum Enum<T> { TSVariant(T), SVariant { v: T }, UVariant }
+ | ^^^^^^^^^
error[E0109]: type arguments are not allowed for this type
--> $DIR/enum-variant-generic-args.rs:15:27
| - this type parameter
...
LL | Self::<()>::TSVariant(());
- | ^^ expected type parameter `T`, found `()`
+ | --------------------- ^^ expected type parameter `T`, found `()`
+ | |
+ | arguments to this function are incorrect
|
= note: expected type parameter `T`
found unit type `()`
+note: tuple variant defined here
+ --> $DIR/enum-variant-generic-args.rs:7:16
+ |
+LL | enum Enum<T> { TSVariant(T), SVariant { v: T }, UVariant }
+ | ^^^^^^^^^
error[E0109]: type arguments are not allowed for this type
--> $DIR/enum-variant-generic-args.rs:20:16
--> $DIR/enum-variant-priority-higher-than-other-inherent.rs:21:5
|
LL | <E>::V();
- | ^^^^^^-- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^^^^^^-- an argument of type `u8` is missing
|
note: tuple variant defined here
--> $DIR/enum-variant-priority-higher-than-other-inherent.rs:5:5
|
LL | V(u8)
| ^
+help: provide the argument
+ |
+LL | <E>::V({u8});
+ | ~~~~~~~~~~~~
error[E0308]: mismatched types
--> $DIR/enum-variant-priority-higher-than-other-inherent.rs:22:17
--> $DIR/type-ascription-instead-of-initializer.rs:2:12
|
LL | let x: Vec::with_capacity(10, 20);
- | ^^^^^^^^^^^^^^^^^^ -- -- supplied 2 arguments
- | |
- | expected 1 argument
+ | ^^^^^^^^^^^^^^^^^^ -- argument unexpected
|
note: associated function defined here
--> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
|
LL | pub fn with_capacity(capacity: usize) -> Self {
| ^^^^^^^^^^^^^
+help: remove the extra argument
+ |
+LL | let x: Vec::with_capacity(10);
+ | ~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
--> $DIR/type-mismatch-same-crate-name.rs:16:20
|
LL | a::try_foo(foo2);
- | ^^^^ expected struct `main::a::Foo`, found a different struct `main::a::Foo`
+ | ---------- ^^^^ expected struct `main::a::Foo`, found a different struct `main::a::Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: perhaps two different versions of crate `crate_a1` are being used?
+note: function defined here
+ --> $DIR/auxiliary/crate_a1.rs:10:8
+ |
+LL | pub fn try_foo(x: Foo){}
+ | ^^^^^^^
error[E0308]: mismatched types
--> $DIR/type-mismatch-same-crate-name.rs:20:20
|
LL | a::try_bar(bar2);
- | ^^^^ expected trait `main::a::Bar`, found a different trait `main::a::Bar`
+ | ---------- ^^^^ expected trait `main::a::Bar`, found a different trait `main::a::Bar`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Box<(dyn main::a::Bar + 'static)>`
found struct `Box<dyn main::a::Bar>`
= note: perhaps two different versions of crate `crate_a1` are being used?
+note: function defined here
+ --> $DIR/auxiliary/crate_a1.rs:11:8
+ |
+LL | pub fn try_bar(x: Box<Bar>){}
+ | ^^^^^^^
error: aborting due to 2 previous errors
--> $DIR/type-mismatch.rs:17:17
|
LL | want::<foo>(f);
- | ^ expected struct `foo`, found `usize`
+ | ----------- ^ expected struct `foo`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:18:17
|
LL | want::<bar>(f);
- | ^ expected struct `bar`, found `usize`
+ | ----------- ^ expected struct `bar`, found `usize`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:19:24
|
LL | want::<Foo<usize>>(f);
- | ^ expected struct `Foo`, found `usize`
+ | ------------------ ^ expected struct `Foo`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize>`
found type `usize`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:20:27
|
LL | want::<Foo<usize, B>>(f);
- | ^ expected struct `Foo`, found `usize`
+ | --------------------- ^ expected struct `Foo`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize, B>`
found type `usize`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:21:22
|
LL | want::<Foo<foo>>(f);
- | ^ expected struct `Foo`, found `usize`
+ | ---------------- ^ expected struct `Foo`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<foo>`
found type `usize`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:22:25
|
LL | want::<Foo<foo, B>>(f);
- | ^ expected struct `Foo`, found `usize`
+ | ------------------- ^ expected struct `Foo`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<foo, B>`
found type `usize`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:23:22
|
LL | want::<Foo<bar>>(f);
- | ^ expected struct `Foo`, found `usize`
+ | ---------------- ^ expected struct `Foo`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar>`
found type `usize`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:24:25
|
LL | want::<Foo<bar, B>>(f);
- | ^ expected struct `Foo`, found `usize`
+ | ------------------- ^ expected struct `Foo`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar, B>`
found type `usize`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:28:19
|
LL | want::<usize>(f);
- | ^ expected `usize`, found struct `foo`
+ | ------------- ^ expected `usize`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:29:17
|
LL | want::<bar>(f);
- | ^ expected struct `bar`, found struct `foo`
+ | ----------- ^ expected struct `bar`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
+ |
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:30:24
|
LL | want::<Foo<usize>>(f);
- | ^ expected struct `Foo`, found struct `foo`
+ | ------------------ ^ expected struct `Foo`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize>`
found struct `foo`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:31:27
|
LL | want::<Foo<usize, B>>(f);
- | ^ expected struct `Foo`, found struct `foo`
+ | --------------------- ^ expected struct `Foo`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize, B>`
found struct `foo`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:32:22
|
LL | want::<Foo<foo>>(f);
- | ^ expected struct `Foo`, found struct `foo`
+ | ---------------- ^ expected struct `Foo`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<foo>`
found struct `foo`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:33:25
|
LL | want::<Foo<foo, B>>(f);
- | ^ expected struct `Foo`, found struct `foo`
+ | ------------------- ^ expected struct `Foo`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<foo, B>`
found struct `foo`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:34:22
|
LL | want::<Foo<bar>>(f);
- | ^ expected struct `Foo`, found struct `foo`
+ | ---------------- ^ expected struct `Foo`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar>`
found struct `foo`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:35:25
|
LL | want::<Foo<bar, B>>(f);
- | ^ expected struct `Foo`, found struct `foo`
+ | ------------------- ^ expected struct `Foo`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar, B>`
found struct `foo`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:39:19
|
LL | want::<usize>(f);
- | ^ expected `usize`, found struct `Foo`
+ | ------------- ^ expected `usize`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found struct `Foo<foo>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:40:17
|
LL | want::<foo>(f);
- | ^ expected struct `foo`, found struct `Foo`
+ | ----------- ^ expected struct `foo`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `foo`
found struct `Foo<foo>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:41:17
|
LL | want::<bar>(f);
- | ^ expected struct `bar`, found struct `Foo`
+ | ----------- ^ expected struct `bar`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `bar`
found struct `Foo<foo>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:42:24
|
LL | want::<Foo<usize>>(f);
- | ^ expected `usize`, found struct `foo`
+ | ------------------ ^ expected `usize`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize>`
found struct `Foo<foo>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:43:27
|
LL | want::<Foo<usize, B>>(f);
- | ^ expected `usize`, found struct `foo`
+ | --------------------- ^ expected `usize`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize, B>`
found struct `Foo<foo, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:44:25
|
LL | want::<Foo<foo, B>>(f);
- | ^ expected struct `B`, found struct `A`
+ | ------------------- ^ expected struct `B`, found struct `A`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<_, B>`
found struct `Foo<_, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:45:22
|
LL | want::<Foo<bar>>(f);
- | ^ expected struct `bar`, found struct `foo`
+ | ---------------- ^ expected struct `bar`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar>`
found struct `Foo<foo>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:46:25
|
LL | want::<Foo<bar, B>>(f);
- | ^ expected struct `bar`, found struct `foo`
+ | ------------------- ^ expected struct `bar`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar, B>`
found struct `Foo<foo, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:47:23
|
LL | want::<&Foo<foo>>(f);
- | ^
- | |
- | expected `&Foo<foo>`, found struct `Foo`
- | help: consider borrowing here: `&f`
+ | ----------------- ^
+ | | |
+ | | expected `&Foo<foo>`, found struct `Foo`
+ | | help: consider borrowing here: `&f`
+ | arguments to this function are incorrect
|
= note: expected reference `&Foo<foo>`
found struct `Foo<foo>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:48:26
|
LL | want::<&Foo<foo, B>>(f);
- | ^ expected `&Foo<foo, B>`, found struct `Foo`
+ | -------------------- ^ expected `&Foo<foo, B>`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected reference `&Foo<foo, B>`
found struct `Foo<foo>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:52:19
|
LL | want::<usize>(f);
- | ^ expected `usize`, found struct `Foo`
+ | ------------- ^ expected `usize`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found struct `Foo<foo, B>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:53:17
|
LL | want::<foo>(f);
- | ^ expected struct `foo`, found struct `Foo`
+ | ----------- ^ expected struct `foo`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `foo`
found struct `Foo<foo, B>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:54:17
|
LL | want::<bar>(f);
- | ^ expected struct `bar`, found struct `Foo`
+ | ----------- ^ expected struct `bar`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `bar`
found struct `Foo<foo, B>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:55:24
|
LL | want::<Foo<usize>>(f);
- | ^ expected `usize`, found struct `foo`
+ | ------------------ ^ expected `usize`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize, A>`
found struct `Foo<foo, B>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:56:27
|
LL | want::<Foo<usize, B>>(f);
- | ^ expected `usize`, found struct `foo`
+ | --------------------- ^ expected `usize`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize, _>`
found struct `Foo<foo, _>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:57:22
|
LL | want::<Foo<foo>>(f);
- | ^ expected struct `A`, found struct `B`
+ | ---------------- ^ expected struct `A`, found struct `B`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<_, A>`
found struct `Foo<_, B>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:58:22
|
LL | want::<Foo<bar>>(f);
- | ^ expected struct `bar`, found struct `foo`
+ | ---------------- ^ expected struct `bar`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar, A>`
found struct `Foo<foo, B>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:59:25
|
LL | want::<Foo<bar, B>>(f);
- | ^ expected struct `bar`, found struct `foo`
+ | ------------------- ^ expected struct `bar`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar, _>`
found struct `Foo<foo, _>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:60:23
|
LL | want::<&Foo<foo>>(f);
- | ^ expected `&Foo<foo>`, found struct `Foo`
+ | ----------------- ^ expected `&Foo<foo>`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected reference `&Foo<foo>`
found struct `Foo<foo, B>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:61:26
|
LL | want::<&Foo<foo, B>>(f);
- | ^
- | |
- | expected `&Foo<foo, B>`, found struct `Foo`
- | help: consider borrowing here: `&f`
+ | -------------------- ^
+ | | |
+ | | expected `&Foo<foo, B>`, found struct `Foo`
+ | | help: consider borrowing here: `&f`
+ | arguments to this function are incorrect
|
= note: expected reference `&Foo<foo, B>`
found struct `Foo<foo, B>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:65:19
|
LL | want::<usize>(f);
- | ^ expected `usize`, found struct `Foo`
+ | ------------- ^ expected `usize`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected type `usize`
found struct `Foo<foo, B, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:66:17
|
LL | want::<foo>(f);
- | ^ expected struct `foo`, found struct `Foo`
+ | ----------- ^ expected struct `foo`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `foo`
found struct `Foo<foo, B, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:67:17
|
LL | want::<bar>(f);
- | ^ expected struct `bar`, found struct `Foo`
+ | ----------- ^ expected struct `bar`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `bar`
found struct `Foo<foo, B, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:68:24
|
LL | want::<Foo<usize>>(f);
- | ^ expected `usize`, found struct `foo`
+ | ------------------ ^ expected `usize`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize, A, B>`
found struct `Foo<foo, B, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:69:27
|
LL | want::<Foo<usize, B>>(f);
- | ^ expected `usize`, found struct `foo`
+ | --------------------- ^ expected `usize`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<usize, _, B>`
found struct `Foo<foo, _, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:70:22
|
LL | want::<Foo<foo>>(f);
- | ^ expected struct `A`, found struct `B`
+ | ---------------- ^ expected struct `A`, found struct `B`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<_, A, B>`
found struct `Foo<_, B, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:71:25
|
LL | want::<Foo<foo, B>>(f);
- | ^ expected struct `B`, found struct `A`
+ | ------------------- ^ expected struct `B`, found struct `A`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<_, _, B>`
found struct `Foo<_, _, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:72:22
|
LL | want::<Foo<bar>>(f);
- | ^ expected struct `bar`, found struct `foo`
+ | ---------------- ^ expected struct `bar`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar, A, B>`
found struct `Foo<foo, B, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:73:25
|
LL | want::<Foo<bar, B>>(f);
- | ^ expected struct `bar`, found struct `foo`
+ | ------------------- ^ expected struct `bar`, found struct `foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected struct `Foo<bar, _, B>`
found struct `Foo<foo, _, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:74:23
|
LL | want::<&Foo<foo>>(f);
- | ^ expected `&Foo<foo>`, found struct `Foo`
+ | ----------------- ^ expected `&Foo<foo>`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected reference `&Foo<foo>`
found struct `Foo<foo, B, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error[E0308]: mismatched types
--> $DIR/type-mismatch.rs:75:26
|
LL | want::<&Foo<foo, B>>(f);
- | ^ expected `&Foo<foo, B>`, found struct `Foo`
+ | -------------------- ^ expected `&Foo<foo, B>`, found struct `Foo`
+ | |
+ | arguments to this function are incorrect
|
= note: expected reference `&Foo<foo, B>`
found struct `Foo<foo, B, A>`
+note: function defined here
+ --> $DIR/type-mismatch.rs:14:4
+ |
+LL | fn want<T>(t: T) {}
+ | ^^^^ ----
error: aborting due to 47 previous errors
--> $DIR/issue-46112.rs:9:21
|
LL | fn main() { test(Ok(())); }
- | ^^ expected enum `Option`, found `()`
+ | -- ^^ expected enum `Option`, found `()`
+ | |
+ | arguments to this enum variant are incorrect
|
= note: expected enum `Option<()>`
found unit type `()`
--> $DIR/issue-84768.rs:7:42
|
LL | <F as FnOnce(&mut u8)>::call_once(f, 1)
- | ^ expected tuple, found integer
+ | --------------------------------- ^ expected tuple, found integer
+ | |
+ | arguments to this function are incorrect
|
= note: expected tuple `(&mut u8,)`
found type `{integer}`
+note: associated function defined here
+ --> $SRC_DIR/core/src/ops/function.rs:LL:COL
+ |
+LL | extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+ | ^^^^^^^^^
error: aborting due to 2 previous errors
--> $DIR/issue-89856.rs:6:20
|
LL | take_str_maybe(option);
- | ^^^^^^ expected `str`, found struct `String`
+ | -------------- ^^^^^^ expected `str`, found struct `String`
+ | |
+ | arguments to this function are incorrect
|
= note: expected enum `Option<&str>`
found enum `Option<&String>`
+note: function defined here
+ --> $DIR/issue-89856.rs:1:4
+ |
+LL | fn take_str_maybe(x: Option<&str>) -> Option<&str> { None }
+ | ^^^^^^^^^^^^^^ ---------------
help: try converting the passed type into a `&str`
|
LL | take_str_maybe(option.map(|x| &**x));
--> $DIR/struct-enum-wrong-args.rs:6:13
|
LL | let _ = Some(3, 2);
- | ^^^^ - - supplied 2 arguments
- | |
- | expected 1 argument
+ | ^^^^ - argument unexpected
+ |
+help: remove the extra argument
+ |
+LL | let _ = Some(3);
+ | ~~~~~~~
error[E0061]: this enum variant takes 1 argument but 3 arguments were supplied
--> $DIR/struct-enum-wrong-args.rs:7:13
|
LL | let _ = Ok(3, 6, 2);
- | ^^ - - - supplied 3 arguments
- | |
- | expected 1 argument
+ | ^^ - - argument unexpected
+ | |
+ | argument unexpected
+ |
+help: remove the extra arguments
+ |
+LL | let _ = Ok(3);
+ | ~~~~~
error[E0061]: this enum variant takes 1 argument but 0 arguments were supplied
--> $DIR/struct-enum-wrong-args.rs:8:13
|
LL | let _ = Ok();
- | ^^-- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^^-- an argument is missing
+ |
+help: provide the argument
+ |
+LL | let _ = Ok({_});
+ | ~~~~~~~
error[E0061]: this struct takes 1 argument but 0 arguments were supplied
--> $DIR/struct-enum-wrong-args.rs:9:13
|
LL | let _ = Wrapper();
- | ^^^^^^^-- supplied 0 arguments
- | |
- | expected 1 argument
+ | ^^^^^^^-- an argument of type `i32` is missing
|
note: tuple struct defined here
--> $DIR/struct-enum-wrong-args.rs:2:8
|
LL | struct Wrapper(i32);
| ^^^^^^^
+help: provide the argument
+ |
+LL | let _ = Wrapper({i32});
+ | ~~~~~~~~~~~~~~
error[E0061]: this struct takes 1 argument but 2 arguments were supplied
--> $DIR/struct-enum-wrong-args.rs:10:13
|
LL | let _ = Wrapper(5, 2);
- | ^^^^^^^ - - supplied 2 arguments
- | |
- | expected 1 argument
+ | ^^^^^^^ - argument unexpected
|
note: tuple struct defined here
--> $DIR/struct-enum-wrong-args.rs:2:8
|
LL | struct Wrapper(i32);
| ^^^^^^^
+help: remove the extra argument
+ |
+LL | let _ = Wrapper(5);
+ | ~~~~~~~~~~
error[E0061]: this struct takes 2 arguments but 0 arguments were supplied
--> $DIR/struct-enum-wrong-args.rs:11:13
|
LL | let _ = DoubleWrapper();
- | ^^^^^^^^^^^^^-- supplied 0 arguments
- | |
- | expected 2 arguments
+ | ^^^^^^^^^^^^^-- two arguments of type `i32` and `i32` are missing
|
note: tuple struct defined here
--> $DIR/struct-enum-wrong-args.rs:3:8
|
LL | struct DoubleWrapper(i32, i32);
| ^^^^^^^^^^^^^
+help: provide the arguments
+ |
+LL | let _ = DoubleWrapper({i32}, {i32});
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this struct takes 2 arguments but 1 argument was supplied
--> $DIR/struct-enum-wrong-args.rs:12:13
|
LL | let _ = DoubleWrapper(5);
- | ^^^^^^^^^^^^^ - supplied 1 argument
- | |
- | expected 2 arguments
+ | ^^^^^^^^^^^^^--- an argument of type `i32` is missing
|
note: tuple struct defined here
--> $DIR/struct-enum-wrong-args.rs:3:8
|
LL | struct DoubleWrapper(i32, i32);
| ^^^^^^^^^^^^^
+help: provide the argument
+ |
+LL | let _ = DoubleWrapper(5, {i32});
+ | ~~~~~~~~~~~~~~~~~~~~~~~
error[E0061]: this struct takes 2 arguments but 3 arguments were supplied
--> $DIR/struct-enum-wrong-args.rs:13:13
|
LL | let _ = DoubleWrapper(5, 2, 7);
- | ^^^^^^^^^^^^^ - - - supplied 3 arguments
- | |
- | expected 2 arguments
+ | ^^^^^^^^^^^^^ - argument unexpected
|
note: tuple struct defined here
--> $DIR/struct-enum-wrong-args.rs:3:8
|
LL | struct DoubleWrapper(i32, i32);
| ^^^^^^^^^^^^^
+help: remove the extra argument
+ |
+LL | let _ = DoubleWrapper(5, 2);
+ | ~~~~~~~~~~~~~~~~~~~
error: aborting due to 8 previous errors
--> $DIR/ufcs-qpath-self-mismatch.rs:6:28
|
LL | <i32 as Add<i32>>::add(1u32, 2);
- | ^^^^ expected `i32`, found `u32`
+ | ---------------------- ^^^^ expected `i32`, found `u32`
+ | |
+ | arguments to this function are incorrect
|
+note: associated function defined here
+ --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
+ |
+LL | fn add(self, rhs: Rhs) -> Self::Output;
+ | ^^^
help: change the type of the numeric literal from `u32` to `i32`
|
LL | <i32 as Add<i32>>::add(1i32, 2);
--> $DIR/ufcs-qpath-self-mismatch.rs:8:31
|
LL | <i32 as Add<i32>>::add(1, 2u32);
- | ^^^^ expected `i32`, found `u32`
+ | ---------------------- ^^^^ expected `i32`, found `u32`
+ | |
+ | arguments to this function are incorrect
+ |
+note: associated function defined here
+ --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
|
+LL | fn add(self, rhs: Rhs) -> Self::Output;
+ | ^^^
help: change the type of the numeric literal from `u32` to `i32`
|
LL | <i32 as Add<i32>>::add(1, 2i32);
--> $DIR/unboxed-closures-type-mismatch.rs:5:15
|
LL | let z = f(1_usize, 2);
- | ^^^^^^^ expected `isize`, found `usize`
+ | - ^^^^^^^ expected `isize`, found `usize`
+ | |
+ | arguments to this function are incorrect
|
help: change the type of the numeric literal from `usize` to `isize`
|
projects / rust.git / commitdiff