diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index f3a5b9f13dd1b..427b22dfb1259 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -1416,13 +1416,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ) { let tcx = self.tcx; - 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 - }; + let adt_ty_hint = self + .expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty]) + .get(0) + .cloned() + .unwrap_or(adt_ty); // re-link the regions that EIfEO can erase. self.demand_eqtype(span, adt_ty_hint, adt_ty); diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs index 501ce31557dda..4f8cfe01163fe 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs @@ -755,9 +755,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { expected_ret: Expectation<'tcx>, formal_ret: Ty<'tcx>, formal_args: &[Ty<'tcx>], - ) -> Option>> { + ) -> Vec> { let formal_ret = self.resolve_vars_with_obligations(formal_ret); - let ret_ty = expected_ret.only_has_type(self)?; + let Some(ret_ty) = expected_ret.only_has_type(self) else { return vec![]; }; // HACK(oli-obk): This is a hack to keep RPIT and TAIT in sync wrt their behaviour. // Without it, the inference @@ -779,7 +779,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let ty::subst::GenericArgKind::Type(ty) = ty.unpack() { if let ty::Opaque(def_id, _) = *ty.kind() { if self.infcx.opaque_type_origin(def_id, DUMMY_SP).is_some() { - return None; + return vec![]; } } } @@ -820,7 +820,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // Record all the argument types, with the substitutions // produced from the above subtyping unification. - Ok(Some(formal_args.iter().map(|&ty| self.resolve_vars_if_possible(ty)).collect())) + Ok(formal_args.iter().map(|&ty| self.resolve_vars_if_possible(ty)).collect()) }) .unwrap_or_default(); debug!(?formal_args, ?formal_ret, ?expect_args, ?expected_ret); diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/arg_matrix.rs b/compiler/rustc_typeck/src/check/fn_ctxt/arg_matrix.rs deleted file mode 100644 index b7ba9d9787846..0000000000000 --- a/compiler/rustc_typeck/src/check/fn_ctxt/arg_matrix.rs +++ /dev/null @@ -1,351 +0,0 @@ -use std::cmp; - -use rustc_middle::ty::error::TypeError; - -// An issue that might be found in the compatibility matrix -#[derive(Debug)] -enum Issue { - /// The given argument is the invalid type for the input - Invalid(usize), - /// There is a missing input - Missing(usize), - /// There's a superfluous argument - Extra(usize), - /// Two arguments should be swapped - Swap(usize, usize), - /// Several arguments should be reordered - Permutation(Vec>), -} - -#[derive(Clone, Debug)] -pub(crate) enum Compatibility<'tcx> { - Compatible, - Incompatible(Option>), -} - -/// Similar to `Issue`, but contains some extra information -#[derive(Debug)] -pub(crate) enum Error<'tcx> { - /// The provided argument is the invalid type for the expected input - Invalid(usize, usize, Compatibility<'tcx>), // provided, expected - /// There is a missing input - Missing(usize), - /// There's a superfluous argument - Extra(usize), - /// Two arguments should be swapped - Swap(usize, usize, usize, usize), - /// Several arguments should be reordered - Permutation(Vec<(usize, usize)>), // dest_arg, dest_input -} - -pub(crate) struct ArgMatrix<'tcx> { - /// Maps the indices in the `compatibility_matrix` rows to the indices of - /// the *user provided* inputs - input_indexes: Vec, - /// Maps the indices in the `compatibility_matrix` columns to the indices - /// of the *expected* args - arg_indexes: Vec, - /// The first dimension (rows) are the remaining user provided inputs to - /// match and the second dimension (cols) are the remaining expected args - /// to match - compatibility_matrix: Vec>>, -} - -impl<'tcx> ArgMatrix<'tcx> { - pub(crate) fn new Compatibility<'tcx>>( - minimum_input_count: usize, - provided_arg_count: usize, - mut is_compatible: F, - ) -> Self { - let compatibility_matrix = (0..provided_arg_count) - .map(|i| (0..minimum_input_count).map(|j| is_compatible(i, j)).collect()) - .collect(); - ArgMatrix { - input_indexes: (0..provided_arg_count).collect(), - arg_indexes: (0..minimum_input_count).collect(), - compatibility_matrix, - } - } - - /// Remove a given input from consideration - fn eliminate_input(&mut self, idx: usize) { - self.input_indexes.remove(idx); - self.compatibility_matrix.remove(idx); - } - - /// Remove a given argument from consideration - fn eliminate_arg(&mut self, idx: usize) { - self.arg_indexes.remove(idx); - for row in &mut self.compatibility_matrix { - row.remove(idx); - } - } - - /// "satisfy" an input with a given arg, removing both from consideration - fn satisfy_input(&mut self, input_idx: usize, arg_idx: usize) { - self.eliminate_input(input_idx); - self.eliminate_arg(arg_idx); - } - - // Returns a `Vec` of (user input, expected arg) of matched arguments. These - // are inputs on the remaining diagonal that match. - fn eliminate_satisfied(&mut self) -> Vec<(usize, usize)> { - let mut i = cmp::min(self.input_indexes.len(), self.arg_indexes.len()); - let mut eliminated = vec![]; - while i > 0 { - let idx = i - 1; - if matches!(self.compatibility_matrix[idx][idx], Compatibility::Compatible) { - eliminated.push((self.input_indexes[idx], self.arg_indexes[idx])); - self.satisfy_input(idx, idx); - } - i -= 1; - } - return eliminated; - } - - // Find some issue in the compatibility matrix - fn find_issue(&self) -> Option { - let mat = &self.compatibility_matrix; - let ai = &self.arg_indexes; - let ii = &self.input_indexes; - - for i in 0..cmp::max(ai.len(), ii.len()) { - // If we eliminate the last row, any left-over inputs are considered missing - if i >= mat.len() { - return Some(Issue::Missing(i)); - } - // If we eliminate the last column, any left-over arguments are extra - if mat[i].len() == 0 { - return Some(Issue::Extra(i)); - } - - // Make sure we don't pass the bounds of our matrix - let is_arg = i < ai.len(); - let is_input = i < ii.len(); - if is_arg && is_input && matches!(mat[i][i], Compatibility::Compatible) { - // This is a satisfied input, so move along - continue; - } - - let mut useless = true; - let mut unsatisfiable = true; - if is_arg { - for j in 0..ii.len() { - // If we find at least one input this argument could satisfy - // this argument isn't unsatisfiable - if matches!(mat[j][i], Compatibility::Compatible) { - unsatisfiable = false; - break; - } - } - } - if is_input { - for j in 0..ai.len() { - // If we find at least one argument that could satisfy this input - // this argument isn't useless - if matches!(mat[i][j], Compatibility::Compatible) { - useless = false; - break; - } - } - } - - match (is_input, is_arg, useless, unsatisfiable) { - // If an argument is unsatisfied, and the input in its position is useless - // then the most likely explanation is that we just got the types wrong - (true, true, true, true) => return Some(Issue::Invalid(i)), - // Otherwise, if an input is useless, then indicate that this is an extra argument - (true, _, true, _) => return Some(Issue::Extra(i)), - // Otherwise, if an argument is unsatisfiable, indicate that it's missing - (_, true, _, true) => return Some(Issue::Missing(i)), - (true, true, _, _) => { - // The argument isn't useless, and the input isn't unsatisfied, - // so look for a parameter we might swap it with - // We look for swaps explicitly, instead of just falling back on permutations - // so that cases like (A,B,C,D) given (B,A,D,C) show up as two swaps, - // instead of a large permutation of 4 elements. - for j in 0..cmp::min(ai.len(), ii.len()) { - if i == j || matches!(mat[j][j], Compatibility::Compatible) { - continue; - } - if matches!(mat[i][j], Compatibility::Compatible) - && matches!(mat[j][i], Compatibility::Compatible) - { - return Some(Issue::Swap(i, j)); - } - } - } - _ => { - continue; - } - } - } - - // We didn't find any of the individual issues above, but - // there might be a larger permutation of parameters, so we now check for that - // by checking for cycles - // We use a double option at position i in this vec to represent: - // - None: We haven't computed anything about this argument yet - // - Some(None): This argument definitely doesn't participate in a cycle - // - Some(Some(x)): the i-th argument could permute to the x-th position - let mut permutation: Vec>> = 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> = - 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>, Vec>) { - let provided_arg_count = self.input_indexes.len(); - - let mut errors: Vec> = vec![]; - // For each expected argument, the matched *actual* input - let mut matched_inputs: Vec> = vec![None; self.arg_indexes.len()]; - - // Before we start looking for issues, eliminate any arguments that are already satisfied, - // so that an argument which is already spoken for by the input it's in doesn't - // spill over into another similarly typed input - // ex: - // fn some_func(_a: i32, _b: i32) {} - // some_func(1, ""); - // Without this elimination, the first argument causes the second argument - // to show up as both a missing input and extra argument, rather than - // just an invalid type. - for (inp, arg) in self.eliminate_satisfied() { - matched_inputs[arg] = Some(inp); - } - - while self.input_indexes.len() > 0 || self.arg_indexes.len() > 0 { - match self.find_issue() { - Some(Issue::Invalid(idx)) => { - let compatibility = self.compatibility_matrix[idx][idx].clone(); - let input_idx = self.input_indexes[idx]; - let arg_idx = self.arg_indexes[idx]; - self.satisfy_input(idx, idx); - errors.push(Error::Invalid(input_idx, arg_idx, compatibility)); - } - Some(Issue::Extra(idx)) => { - let input_idx = self.input_indexes[idx]; - self.eliminate_input(idx); - errors.push(Error::Extra(input_idx)); - } - Some(Issue::Missing(idx)) => { - let arg_idx = self.arg_indexes[idx]; - self.eliminate_arg(idx); - errors.push(Error::Missing(arg_idx)); - } - Some(Issue::Swap(idx, other)) => { - let input_idx = self.input_indexes[idx]; - let other_input_idx = self.input_indexes[other]; - let arg_idx = self.arg_indexes[idx]; - let other_arg_idx = self.arg_indexes[other]; - let (min, max) = (cmp::min(idx, other), cmp::max(idx, other)); - self.satisfy_input(min, max); - // Subtract 1 because we already removed the "min" row - self.satisfy_input(max - 1, min); - errors.push(Error::Swap(input_idx, other_input_idx, arg_idx, other_arg_idx)); - matched_inputs[other_arg_idx] = Some(input_idx); - matched_inputs[arg_idx] = Some(other_input_idx); - } - Some(Issue::Permutation(args)) => { - let mut idxs: Vec = args.iter().filter_map(|&a| a).collect(); - - let mut real_idxs = vec![None; provided_arg_count]; - for (src, dst) in - args.iter().enumerate().filter_map(|(src, dst)| dst.map(|dst| (src, dst))) - { - let src_input_idx = self.input_indexes[src]; - let dst_input_idx = self.input_indexes[dst]; - let dest_arg_idx = self.arg_indexes[dst]; - real_idxs[src_input_idx] = Some((dest_arg_idx, dst_input_idx)); - matched_inputs[dest_arg_idx] = Some(src_input_idx); - } - idxs.sort(); - idxs.reverse(); - for i in idxs { - self.satisfy_input(i, i); - } - errors.push(Error::Permutation(real_idxs.into_iter().flatten().collect())); - } - None => { - // We didn't find any issues, so we need to push the algorithm forward - // First, eliminate any arguments that currently satisfy their inputs - for (inp, arg) in self.eliminate_satisfied() { - matched_inputs[arg] = Some(inp); - } - } - }; - } - - return (errors, matched_inputs); - } -} diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs index f1c7d52675c74..09179b1989e50 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs @@ -1,6 +1,5 @@ use crate::astconv::AstConv; use crate::check::coercion::CoerceMany; -use crate::check::fn_ctxt::arg_matrix::{ArgMatrix, Compatibility, Error}; use crate::check::gather_locals::Declaration; use crate::check::method::MethodCallee; use crate::check::Expectation::*; @@ -18,13 +17,9 @@ use rustc_hir as hir; use rustc_hir::def::{CtorOf, DefKind, Res}; use rustc_hir::def_id::DefId; use rustc_hir::{ExprKind, Node, QPath}; -use rustc_infer::infer::error_reporting::{FailureCode, ObligationCauseExt}; -use rustc_infer::infer::InferOk; -use rustc_infer::infer::TypeTrace; use rustc_middle::ty::adjustment::AllowTwoPhase; -use rustc_middle::ty::error::TypeError; use rustc_middle::ty::fold::TypeFoldable; -use rustc_middle::ty::{self, Ty, TyCtxt}; +use rustc_middle::ty::{self, Ty}; use rustc_session::Session; use rustc_span::symbol::Ident; use rustc_span::{self, Span}; @@ -73,7 +68,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { sp, expr, &err_inputs, - None, + vec![], args_no_rcvr, false, tuple_arguments, @@ -114,7 +109,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // 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: Option>>, + expected_input_tys: Vec>, // The expressions for each provided argument provided_args: &'tcx [hir::Expr<'tcx>], // Whether the function is variadic, for example when imported from C @@ -125,18 +120,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fn_def_id: Option, ) { let tcx = self.tcx; - - // 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. + // 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 }; // All the input types from the fn signature must outlive the call // so as to validate implied bounds. @@ -144,7 +131,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { self.register_wf_obligation(fn_input_ty.into(), arg_expr.span, traits::MiscObligation); } - let mut err_code = "E0061"; + let expected_arg_count = formal_input_tys.len(); + + // expected_count, arg_count, error_code, sugg_tuple_wrap_args + let mut arg_count_error: Option<(usize, usize, &str, TupleMatchFound)> = None; // 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 { @@ -154,17 +144,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ty::Tuple(arg_types) => { // Argument length differs if arg_types.len() != provided_args.len() { - err_code = "E0057"; + arg_count_error = Some(( + arg_types.len(), + provided_args.len(), + "E0057", + TupleMatchFound::None, + )); } - 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, + let expected_input_tys = match expected_input_tys.get(0) { + Some(&ty) => match ty.kind() { + ty::Tuple(tys) => tys.iter().collect(), + _ => vec![], }, - None => None, + None => vec![], }; (arg_types.iter().collect(), expected_input_tys) } @@ -179,25 +171,53 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { for the function trait is neither a tuple nor unit" ) .emit(); - (self.err_args(provided_args.len()), None) + (self.err_args(provided_args.len()), vec![]) } } - } else { + } 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", TupleMatchFound::None)); + (self.err_args(supplied_arg_count), vec![]) + } + } else { + // 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_tuple_wrap_args)); + (self.err_args(supplied_arg_count), vec![]) }; - // 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()); + debug!( + "check_argument_types: formal_input_tys={:?}", + formal_input_tys.iter().map(|t| self.ty_to_string(*t)).collect::>() + ); + + // If there is no expectation, expect formal_input_tys. + let expected_input_tys = if !expected_input_tys.is_empty() { expected_input_tys } else { formal_input_tys.clone() }; - let minimum_input_count = expected_input_tys.len(); - let provided_arg_count = provided_args.len(); + assert_eq!(expected_input_tys.len(), formal_input_tys.len()); - // We'll also want to keep track of the fully coerced argument types, for an awkward hack near the end + let provided_arg_count: usize = provided_args.len(); + + // Keep track of the fully coerced argument types let mut final_arg_types: Vec, Ty<'_>)>> = vec![None; provided_arg_count]; // We introduce a helper function to demand that a given argument satisfy a given input @@ -210,9 +230,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { debug!("checking argument {}: {:?} = {:?}", idx, provided_arg, formal_input_ty); - // 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 + // The special-cased logic below has three functions: + // 1. Provide as good of an expected type as possible. let expectation = Expectation::rvalue_hint(self, expected_input_ty); let checked_ty = self.check_expr_with_expectation(provided_arg, expectation); @@ -226,7 +245,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { 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 lets us customize the span pointed to in 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 // fulfillment error to be more accurate. let coerced_ty = self.resolve_vars_with_obligations_and_mutate_fulfillment(coerced_ty, |errors| { @@ -240,95 +260,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ); }); - // Make sure we store the resolved type final_arg_types[idx] = Some((checked_ty, coerced_ty)); - 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), - }; - - // If neither check failed, the types are compatible - match subtyping_error { - None => Compatibility::Compatible, - Some(_) => Compatibility::Incompatible(subtyping_error), - } - }; - - // 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 = |input_idx, arg_idx| { - let formal_input_ty: Ty<'tcx> = formal_input_tys[arg_idx]; - let expected_input_ty: Ty<'tcx> = expected_input_tys[arg_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[input_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); + // 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 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()), - } + // 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); }; - // 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 - }; + let minimum_input_count = formal_input_tys.len(); // Check the arguments. // We do this in a pretty awful way: first we type-check any arguments @@ -352,8 +295,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { }) } - // 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 @@ -376,84 +317,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { continue; } - 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; - } + demand_compatible(idx, &mut final_arg_types); } } - // 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; - } - - self.set_tainted_by_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, arg_idx, Compatibility::Incompatible(error)) = error else { return false }; - let expected_ty = expected_input_tys[*arg_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 { + // If there was an error in parameter count, emit that here + if let Some((expected_count, arg_count, err_code, sugg_tuple_wrap_args)) = arg_count_error { + let (span, start_span, args, ctor_of) = match &call_expr.kind { hir::ExprKind::Call( hir::Expr { span, @@ -464,503 +334,129 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { )), .. }, - _, - ) => (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 - ) + args, + ) => (*span, *span, &args[..], Some(of)), + hir::ExprKind::Call(hir::Expr { span, .. }, args) => { + (*span, *span, &args[..], None) } + 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::()`. + .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 args_span = error_span.trim_start(full_call_span).unwrap_or(error_span); + 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::>() + }; let call_name = match ctor_of { Some(CtorOf::Struct) => "struct", Some(CtorOf::Variant) => "enum variant", None => "function", }; - if c_variadic && provided_arg_count < minimum_input_count { - err_code = "E0060"; + let mut err = tcx.sess.struct_span_err_with_code( + span, + &format!( + "this {} takes {}{} but {} {} supplied", + 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 { "" }, + ); } + 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()); + } - // 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); + let def_kind = tcx.def_kind(def_id); + err.span_note(spans, &format!("{} defined here", def_kind.descr(def_id))); + } 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 expected_ty = self.resolve_vars_if_possible(expected_ty); - let provided_ty = self.resolve_vars_if_possible(provided_ty); - 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), + 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, ); - // Call out where the function is defined - label_fn_like(tcx, &mut err, fn_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 - label_fn_like(tcx, &mut err, fn_def_id); + TupleMatchFound::Multiple(first, last) => { err.multipart_suggestion( "use parentheses to construct a tuple", - vec![(start, '('.to_string()), (end, ')'.to_string())], + vec![ + (first.shrink_to_lo(), '('.to_string()), + (last.shrink_to_hi(), ')'.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, - arg_idx, - Compatibility::Incompatible(Some(error)), - )) = errors.iter().next() - { - let expected_ty = expected_input_tys[*arg_idx]; - let provided_ty = final_arg_types[*arg_idx].map(|ty| ty.0).unwrap(); - let expected_ty = self.resolve_vars_if_possible(expected_ty); - let provided_ty = self.resolve_vars_if_possible(provided_ty); - 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], - provided_ty, - 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), + span, + format!( + "expected {}{}", + if c_variadic { "at least " } else { "" }, + potentially_plural_count(expected_count, "argument") + ), ); - // Call out where the function is defined - label_fn_like(tcx, &mut err, fn_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, - ) - } 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, arg_idx, compatibility) => { - let expected_ty = expected_input_tys[arg_idx]; - let provided_ty = final_arg_types[input_idx].map(|ty| ty.0).unwrap(); - let expected_ty = self.resolve_vars_if_possible(expected_ty); - let provided_ty = self.resolve_vars_if_possible(provided_ty); - if let Compatibility::Incompatible(error) = &compatibility { - 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[third_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 last_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 last_idx < provided_arg_count { - let first_arg_span = provided_args[first_idx].span; - let last_arg_span = provided_args[last_idx].span; - Span::new( - first_arg_span.lo(), - last_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[input_idx].span; - let second_span = provided_args[other_input_idx].span; - - let first_expected_ty = - self.resolve_vars_if_possible(expected_input_tys[arg_idx]); - let first_provided_ty = if let Some((ty, _)) = final_arg_types[input_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_arg_idx]); - let other_provided_ty = - if let Some((ty, _)) = final_arg_types[other_input_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 - label_fn_like(tcx, &mut err, fn_def_id); - - // 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("swap these arguments".to_string()), - SuggestionText::Reorder => Some("reorder these arguments".to_string()), - SuggestionText::DidYouMean => Some("did you mean".to_string()), - }; - 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()) - ); - for (arg_index, input_idx) in matched_inputs.iter().enumerate() { - let suggestion_text = if let Some(input_idx) = input_idx { - let arg_span = provided_args[*input_idx].span.source_callsite(); - 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[arg_index]; - 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 arg_index < 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 { - fn variadic_error<'tcx>(sess: &Session, span: Span, ty: Ty<'tcx>, cast_ty: &str) { + // 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: &'tcx Session, span: Span, ty: Ty<'tcx>, cast_ty: &str) { use crate::structured_errors::MissingCastForVariadicArg; MissingCastForVariadicArg { sess, span, ty, cast_ty }.diagnostic().emit(); @@ -1725,47 +1221,3 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } } - -fn label_fn_like<'tcx>( - tcx: TyCtxt<'tcx>, - err: &mut rustc_errors::DiagnosticBuilder<'tcx, rustc_errors::ErrorGuaranteed>, - def_id: Option, -) { - let Some(def_id) = def_id else { - return; - }; - - if 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))); - } else { - match tcx.hir().get_if_local(def_id) { - Some(hir::Node::Expr(hir::Expr { - kind: hir::ExprKind::Closure(_, _, _, span, ..), - .. - })) => { - let spans: MultiSpan = (*span).into(); - - // Note: We don't point to param spans here because they overlap - // with the closure span itself - - err.span_note(spans, "closure defined here"); - } - _ => {} - } - } -} diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs b/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs index ce9ff61bd9e6f..d04277bcf87b1 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs @@ -1,5 +1,4 @@ mod _impl; -mod arg_matrix; mod checks; mod suggestions; diff --git a/src/test/ui/argument-suggestions/basic.rs b/src/test/ui/argument-suggestions/basic.rs index 3e96322d67efb..bebf3772b7636 100644 --- a/src/test/ui/argument-suggestions/basic.rs +++ b/src/test/ui/argument-suggestions/basic.rs @@ -20,8 +20,11 @@ fn main() { invalid(1.0); //~ ERROR mismatched types extra(""); //~ ERROR this function takes missing(); //~ ERROR this function takes - swapped("", 1); //~ ERROR arguments to this function are incorrect - permuted(Y {}, Z {}, X {}); //~ ERROR arguments to this function are incorrect + swapped("", 1); //~ ERROR mismatched types + //~^ ERROR mismatched types + permuted(Y {}, Z {}, X {}); //~ ERROR mismatched types + //~^ ERROR mismatched types + //~| ERROR mismatched types let closure = |x| x; closure(); //~ ERROR this function takes diff --git a/src/test/ui/argument-suggestions/basic.stderr b/src/test/ui/argument-suggestions/basic.stderr index 8300a22c5483d..3a103e4033733 100644 --- a/src/test/ui/argument-suggestions/basic.stderr +++ b/src/test/ui/argument-suggestions/basic.stderr @@ -2,102 +2,75 @@ error[E0308]: mismatched types --> $DIR/basic.rs:20:13 | LL | invalid(1.0); - | ------- ^^^ expected `u32`, found floating-point number - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/basic.rs:13:4 - | -LL | fn invalid(_i: u32) {} - | ^^^^^^^ ------- + | ^^^ expected `u32`, found floating-point number error[E0061]: this function takes 0 arguments but 1 argument was supplied --> $DIR/basic.rs:21:5 | LL | extra(""); - | ^^^^^ -- argument unexpected + | ^^^^^ -- supplied 1 argument + | | + | expected 0 arguments | note: function defined here --> $DIR/basic.rs:14:4 | LL | fn extra() {} | ^^^^^ -help: remove the extra argument - | -LL | extra(); - | ~~~~~~~ error[E0061]: this function takes 1 argument but 0 arguments were supplied --> $DIR/basic.rs:22:5 | LL | missing(); - | ^^^^^^^-- an argument of type `u32` is missing + | ^^^^^^^-- supplied 0 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/basic.rs:15:4 | LL | fn missing(_i: u32) {} | ^^^^^^^ ------- -help: provide the argument - | -LL | missing({u32}); - | ~~~~~~~~~~~~~~ -error[E0308]: arguments to this function are incorrect - --> $DIR/basic.rs:23:5 +error[E0308]: mismatched types + --> $DIR/basic.rs:23:13 | LL | swapped("", 1); - | ^^^^^^^ -- - expected `&str`,found `{integer}` - | | - | expected `u32`,found `&'static str` - | -note: function defined here - --> $DIR/basic.rs:16:4 - | -LL | fn swapped(_i: u32, _s: &str) {} - | ^^^^^^^ ------- -------- -help: swap these arguments + | ^^ expected `u32`, found `&str` + +error[E0308]: mismatched types + --> $DIR/basic.rs:23:17 | -LL | swapped(1, ""); - | ~~~~~~~~~~~~~~ +LL | swapped("", 1); + | ^ expected `&str`, found integer -error[E0308]: arguments to this function are incorrect - --> $DIR/basic.rs:24:5 +error[E0308]: mismatched types + --> $DIR/basic.rs:25:14 | LL | permuted(Y {}, Z {}, X {}); - | ^^^^^^^^ ---- ---- ---- expected `Z`,found `X` - | | | - | | expected `Y`,found `Z` - | expected `X`,found `Y` - | -note: function defined here - --> $DIR/basic.rs:17:4 + | ^^^^ expected struct `X`, found struct `Y` + +error[E0308]: mismatched types + --> $DIR/basic.rs:25:20 | -LL | fn permuted(_x: X, _y: Y, _z: Z) {} - | ^^^^^^^^ ----- ----- ----- -help: reorder these arguments +LL | permuted(Y {}, Z {}, X {}); + | ^^^^ expected struct `Y`, found struct `Z` + +error[E0308]: mismatched types + --> $DIR/basic.rs:25:26 | -LL | permuted(X {}, Y {}, Z {}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~ +LL | permuted(Y {}, Z {}, X {}); + | ^^^^ expected struct `Z`, found struct `X` error[E0057]: this function takes 1 argument but 0 arguments were supplied - --> $DIR/basic.rs:27:5 + --> $DIR/basic.rs:30:5 | LL | closure(); - | ^^^^^^^-- an argument is missing - | -note: closure defined here - --> $DIR/basic.rs:26:19 - | -LL | let closure = |x| x; - | ^^^ -help: provide the argument - | -LL | closure({_}); - | ~~~~~~~~~~~~ + | ^^^^^^^-- supplied 0 arguments + | | + | expected 1 argument -error: aborting due to 6 previous errors +error: aborting due to 9 previous errors Some errors have detailed explanations: E0057, E0061, E0308. For more information about an error, try `rustc --explain E0057`. diff --git a/src/test/ui/argument-suggestions/complex.rs b/src/test/ui/argument-suggestions/complex.rs index 384cdca7e4fdc..66ca38dcf4d74 100644 --- a/src/test/ui/argument-suggestions/complex.rs +++ b/src/test/ui/argument-suggestions/complex.rs @@ -12,5 +12,12 @@ fn complex(_i: u32, _s: &str, _e: E, _f: F, _g: G, _x: X, _y: Y, _z: Z ) {} fn main() { complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); - //~^ ERROR arguments to this function are incorrect + //~^ ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types } diff --git a/src/test/ui/argument-suggestions/complex.stderr b/src/test/ui/argument-suggestions/complex.stderr index c628f7dff3466..4ee7882313f56 100644 --- a/src/test/ui/argument-suggestions/complex.stderr +++ b/src/test/ui/argument-suggestions/complex.stderr @@ -1,19 +1,51 @@ -error[E0308]: arguments to this function are incorrect - --> $DIR/complex.rs:14:3 +error[E0308]: mismatched types + --> $DIR/complex.rs:14:11 | LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); - | ^^^^^^^ --- expected `u32`, found floating-point number + | ^^^ expected `u32`, found floating-point number + +error[E0308]: mismatched types + --> $DIR/complex.rs:14:16 + | +LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); + | ^^^^ expected `&str`, found struct `H` + +error[E0308]: mismatched types + --> $DIR/complex.rs:14:22 + | +LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); + | ^^^ expected enum `E`, found `&&'static str` + +error[E0308]: mismatched types + --> $DIR/complex.rs:14:27 + | +LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); + | ^^^ expected enum `F`, found struct `G` + +error[E0308]: mismatched types + --> $DIR/complex.rs:14:32 | -note: function defined here - --> $DIR/complex.rs:11:4 +LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); + | ^^^^^ expected struct `G`, found enum `F` + +error[E0308]: mismatched types + --> $DIR/complex.rs:14:39 | -LL | fn complex(_i: u32, _s: &str, _e: E, _f: F, _g: G, _x: X, _y: Y, _z: Z ) {} - | ^^^^^^^ ------- -------- ----- ----- ----- ----- ----- ------ -help: did you mean +LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); + | ^^^^ expected struct `X`, found struct `Z` + +error[E0308]: mismatched types + --> $DIR/complex.rs:14:45 | -LL | complex({u32}, &"", {E}, F::X2, G{}, X {}, Y {}, Z {}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); + | ^^^^ expected struct `Y`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/complex.rs:14:51 + | +LL | complex(1.0, H {}, &"", G{}, F::X2, Z {}, X {}, Y {}); + | ^^^^ expected struct `Z`, found struct `Y` -error: aborting due to previous error +error: aborting due to 8 previous errors For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/argument-suggestions/extra_arguments.stderr b/src/test/ui/argument-suggestions/extra_arguments.stderr index 9b63f9bcbfae4..74df06a92f4a9 100644 --- a/src/test/ui/argument-suggestions/extra_arguments.stderr +++ b/src/test/ui/argument-suggestions/extra_arguments.stderr @@ -2,237 +2,205 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied --> $DIR/extra_arguments.rs:7:3 | LL | empty(""); - | ^^^^^ -- argument unexpected + | ^^^^^ -- supplied 1 argument + | | + | expected 0 arguments | note: function defined here --> $DIR/extra_arguments.rs:1:4 | LL | fn empty() {} | ^^^^^ -help: remove the extra argument - | -LL | empty(); - | ~~~~~~~ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $DIR/extra_arguments.rs:9:3 | LL | one_arg(1, 1); - | ^^^^^^^ - argument unexpected + | ^^^^^^^ - - supplied 2 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/extra_arguments.rs:2:4 | LL | fn one_arg(_a: i32) {} | ^^^^^^^ ------- -help: remove the extra argument - | -LL | one_arg(1); - | ~~~~~~~~~~ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $DIR/extra_arguments.rs:10:3 | LL | one_arg(1, ""); - | ^^^^^^^ -- argument unexpected + | ^^^^^^^ - -- supplied 2 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/extra_arguments.rs:2:4 | LL | fn one_arg(_a: i32) {} | ^^^^^^^ ------- -help: remove the extra argument - | -LL | one_arg(1); - | ~~~~~~~~~~ error[E0061]: this function takes 1 argument but 3 arguments were supplied --> $DIR/extra_arguments.rs:11:3 | LL | one_arg(1, "", 1.0); - | ^^^^^^^ -- --- argument unexpected - | | - | argument unexpected + | ^^^^^^^ - -- --- supplied 3 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/extra_arguments.rs:2:4 | LL | fn one_arg(_a: i32) {} | ^^^^^^^ ------- -help: remove the extra arguments - | -LL | one_arg(1); - | ~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/extra_arguments.rs:13:3 | LL | two_arg_same(1, 1, 1); - | ^^^^^^^^^^^^ - argument unexpected + | ^^^^^^^^^^^^ - - - supplied 3 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/extra_arguments.rs:3:4 | LL | fn two_arg_same(_a: i32, _b: i32) {} | ^^^^^^^^^^^^ ------- ------- -help: remove the extra argument - | -LL | two_arg_same(1, 1); - | ~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/extra_arguments.rs:14:3 | LL | two_arg_same(1, 1, 1.0); - | ^^^^^^^^^^^^ --- argument unexpected + | ^^^^^^^^^^^^ - - --- supplied 3 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/extra_arguments.rs:3:4 | LL | fn two_arg_same(_a: i32, _b: i32) {} | ^^^^^^^^^^^^ ------- ------- -help: remove the extra argument - | -LL | two_arg_same(1, 1); - | ~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/extra_arguments.rs:16:3 | LL | two_arg_diff(1, 1, ""); - | ^^^^^^^^^^^^ - argument of type `&str` unexpected + | ^^^^^^^^^^^^ - - -- supplied 3 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/extra_arguments.rs:4:4 | LL | fn two_arg_diff(_a: i32, _b: &str) {} | ^^^^^^^^^^^^ ------- -------- -help: remove the extra argument - | -LL | two_arg_diff(1, ""); - | ~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/extra_arguments.rs:17:3 | LL | two_arg_diff(1, "", ""); - | ^^^^^^^^^^^^ -- argument unexpected + | ^^^^^^^^^^^^ - -- -- supplied 3 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/extra_arguments.rs:4:4 | LL | fn two_arg_diff(_a: i32, _b: &str) {} | ^^^^^^^^^^^^ ------- -------- -help: remove the extra argument - | -LL | two_arg_diff(1, ""); - | ~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 4 arguments were supplied --> $DIR/extra_arguments.rs:18:3 | LL | two_arg_diff(1, 1, "", ""); - | ^^^^^^^^^^^^ - -- argument unexpected - | | - | argument of type `&str` unexpected + | ^^^^^^^^^^^^ - - -- -- supplied 4 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/extra_arguments.rs:4:4 | LL | fn two_arg_diff(_a: i32, _b: &str) {} | ^^^^^^^^^^^^ ------- -------- -help: remove the extra arguments - | -LL | two_arg_diff(1, ""); - | ~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 4 arguments were supplied --> $DIR/extra_arguments.rs:19:3 | LL | two_arg_diff(1, "", 1, ""); - | ^^^^^^^^^^^^ - -- argument unexpected - | | - | argument unexpected + | ^^^^^^^^^^^^ - -- - -- supplied 4 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/extra_arguments.rs:4:4 | LL | fn two_arg_diff(_a: i32, _b: &str) {} | ^^^^^^^^^^^^ ------- -------- -help: remove the extra arguments - | -LL | two_arg_diff(1, ""); - | ~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/extra_arguments.rs:22:3 | LL | two_arg_same(1, 1, ""); - | ^^^^^^^^^^^^ -- argument unexpected + | ^^^^^^^^^^^^ - - -- supplied 3 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/extra_arguments.rs:3:4 | LL | fn two_arg_same(_a: i32, _b: i32) {} | ^^^^^^^^^^^^ ------- ------- -help: remove the extra argument - | -LL | two_arg_same(1, 1); - | ~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/extra_arguments.rs:23:3 | LL | two_arg_diff(1, 1, ""); - | ^^^^^^^^^^^^ - argument of type `&str` unexpected + | ^^^^^^^^^^^^ - - -- supplied 3 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/extra_arguments.rs:4:4 | LL | fn two_arg_diff(_a: i32, _b: &str) {} | ^^^^^^^^^^^^ ------- -------- -help: remove the extra argument - | -LL | two_arg_diff(1, ""); - | ~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/extra_arguments.rs:24:3 | LL | two_arg_same( - | ^^^^^^^^^^^^ -... + | ^^^^^^^^^^^^ expected 2 arguments +LL | 1, + | - +LL | 1, + | - LL | "" - | -- argument unexpected + | -- supplied 3 arguments | note: function defined here --> $DIR/extra_arguments.rs:3:4 | LL | fn two_arg_same(_a: i32, _b: i32) {} | ^^^^^^^^^^^^ ------- ------- -help: remove the extra argument - | -LL | two_arg_same(1, 1); - | ~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/extra_arguments.rs:30:3 | LL | two_arg_diff( - | ^^^^^^^^^^^^ + | ^^^^^^^^^^^^ expected 2 arguments LL | 1, + | - LL | 1, - | - argument of type `&str` unexpected + | - +LL | "" + | -- supplied 3 arguments | note: function defined here --> $DIR/extra_arguments.rs:4:4 | LL | fn two_arg_diff(_a: i32, _b: &str) {} | ^^^^^^^^^^^^ ------- -------- -help: remove the extra argument - | -LL | two_arg_diff(1, ""); - | ~~~~~~~~~~~~~~~~~~~ error: aborting due to 14 previous errors diff --git a/src/test/ui/argument-suggestions/invalid_arguments.rs b/src/test/ui/argument-suggestions/invalid_arguments.rs index 53fbdd4b5da3e..aea445d945754 100644 --- a/src/test/ui/argument-suggestions/invalid_arguments.rs +++ b/src/test/ui/argument-suggestions/invalid_arguments.rs @@ -15,29 +15,50 @@ fn main() { // Providing one or two invalid arguments to a two parameter function two_arg_same(1, ""); //~ ERROR mismatched types two_arg_same("", 1); //~ ERROR mismatched types - two_arg_same("", ""); //~ ERROR arguments to this function are incorrect + two_arg_same("", ""); + //~^ ERROR mismatched types + //~| ERROR mismatched types two_arg_diff(1, ""); //~ ERROR mismatched types two_arg_diff("", 1.0); //~ ERROR mismatched types - two_arg_diff("", ""); //~ ERROR arguments to this function are incorrect - + two_arg_diff("", ""); + //~^ ERROR mismatched types + //~| ERROR mismatched types // Providing invalid arguments to a three parameter function three_arg_diff(X{}, 1.0, ""); //~ ERROR mismatched types three_arg_diff(1, X {}, ""); //~ ERROR mismatched types three_arg_diff(1, 1.0, X {}); //~ ERROR mismatched types - three_arg_diff(X {}, X {}, ""); //~ ERROR arguments to this function are incorrect - three_arg_diff(X {}, 1.0, X {}); //~ ERROR arguments to this function are incorrect - three_arg_diff(1, X {}, X {}); //~ ERROR arguments to this function are incorrect + three_arg_diff(X {}, X {}, ""); + //~^ ERROR mismatched types + //~| ERROR mismatched types + three_arg_diff(X {}, 1.0, X {}); + //~^ ERROR mismatched types + //~| ERROR mismatched types + three_arg_diff(1, X {}, X {}); + //~^ ERROR mismatched types + //~| ERROR mismatched types - three_arg_diff(X {}, X {}, X {}); //~ ERROR arguments to this function are incorrect + three_arg_diff(X {}, X {}, X {}); + //~^ ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types three_arg_repeat(X {}, 1, ""); //~ ERROR mismatched types three_arg_repeat(1, X {}, ""); //~ ERROR mismatched types three_arg_repeat(1, 1, X {}); //~ ERROR mismatched types - three_arg_repeat(X {}, X {}, ""); //~ ERROR arguments to this function are incorrect - three_arg_repeat(X {}, 1, X {}); //~ ERROR arguments to this function are incorrect - three_arg_repeat(1, X {}, X{}); //~ ERROR arguments to this function are incorrect + three_arg_repeat(X {}, X {}, ""); + //~^ ERROR mismatched types + //~| ERROR mismatched types + three_arg_repeat(X {}, 1, X {}); + //~^ ERROR mismatched types + //~| ERROR mismatched types + three_arg_repeat(1, X {}, X{}); + //~^ ERROR mismatched types + //~| ERROR mismatched types - three_arg_repeat(X {}, X {}, X {}); //~ ERROR arguments to this function are incorrect + three_arg_repeat(X {}, X {}, X {}); + //~^ ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types } diff --git a/src/test/ui/argument-suggestions/invalid_arguments.stderr b/src/test/ui/argument-suggestions/invalid_arguments.stderr index 33f27d48fec80..8d24e20431f06 100644 --- a/src/test/ui/argument-suggestions/invalid_arguments.stderr +++ b/src/test/ui/argument-suggestions/invalid_arguments.stderr @@ -2,298 +2,200 @@ error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:13:11 | LL | one_arg(1.0); - | ------- ^^^ expected `i32`, found floating-point number - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:5:4 - | -LL | fn one_arg(_a: i32) {} - | ^^^^^^^ ------- + | ^^^ expected `i32`, found floating-point number error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:16:19 | LL | two_arg_same(1, ""); - | ------------ ^^ expected `i32`, found `&str` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:6:4 - | -LL | fn two_arg_same(_a: i32, _b: i32) {} - | ^^^^^^^^^^^^ ------- ------- + | ^^ expected `i32`, found `&str` error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:17:16 | LL | two_arg_same("", 1); - | ------------ ^^ expected `i32`, found `&str` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:6:4 - | -LL | fn two_arg_same(_a: i32, _b: i32) {} - | ^^^^^^^^^^^^ ------- ------- + | ^^ expected `i32`, found `&str` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:18:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:18:16 | LL | two_arg_same("", ""); - | ^^^^^^^^^^^^ -- -- expected `i32`, found `&str` - | | - | expected `i32`, found `&str` - | -note: function defined here - --> $DIR/invalid_arguments.rs:6:4 + | ^^ expected `i32`, found `&str` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:18:20 | -LL | fn two_arg_same(_a: i32, _b: i32) {} - | ^^^^^^^^^^^^ ------- ------- +LL | two_arg_same("", ""); + | ^^ expected `i32`, found `&str` error[E0308]: mismatched types - --> $DIR/invalid_arguments.rs:19:19 + --> $DIR/invalid_arguments.rs:21:19 | LL | two_arg_diff(1, ""); - | ------------ ^^ expected `f32`, found `&str` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:7:4 - | -LL | fn two_arg_diff(_a: i32, _b: f32) {} - | ^^^^^^^^^^^^ ------- ------- + | ^^ expected `f32`, found `&str` error[E0308]: mismatched types - --> $DIR/invalid_arguments.rs:20:16 + --> $DIR/invalid_arguments.rs:22:16 | LL | two_arg_diff("", 1.0); - | ------------ ^^ expected `i32`, found `&str` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:7:4 - | -LL | fn two_arg_diff(_a: i32, _b: f32) {} - | ^^^^^^^^^^^^ ------- ------- + | ^^ expected `i32`, found `&str` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:21:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:23:16 | LL | two_arg_diff("", ""); - | ^^^^^^^^^^^^ -- -- expected `f32`, found `&str` - | | - | expected `i32`, found `&str` - | -note: function defined here - --> $DIR/invalid_arguments.rs:7:4 + | ^^ expected `i32`, found `&str` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:23:20 | -LL | fn two_arg_diff(_a: i32, _b: f32) {} - | ^^^^^^^^^^^^ ------- ------- +LL | two_arg_diff("", ""); + | ^^ expected `f32`, found `&str` error[E0308]: mismatched types - --> $DIR/invalid_arguments.rs:24:18 + --> $DIR/invalid_arguments.rs:27:18 | LL | three_arg_diff(X{}, 1.0, ""); - | -------------- ^^^ expected `i32`, found struct `X` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:8:4 - | -LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^ expected `i32`, found struct `X` error[E0308]: mismatched types - --> $DIR/invalid_arguments.rs:25:21 + --> $DIR/invalid_arguments.rs:28:21 | LL | three_arg_diff(1, X {}, ""); - | -------------- ^^^^ expected `f32`, found struct `X` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:8:4 - | -LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^ expected `f32`, found struct `X` error[E0308]: mismatched types - --> $DIR/invalid_arguments.rs:26:26 + --> $DIR/invalid_arguments.rs:29:26 | LL | three_arg_diff(1, 1.0, X {}); - | -------------- ^^^^ expected `&str`, found struct `X` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:8:4 - | -LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^ expected `&str`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:28:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:31:18 | LL | three_arg_diff(X {}, X {}, ""); - | ^^^^^^^^^^^^^^ ---- ---- expected `f32`, found struct `X` - | | - | expected `i32`, found struct `X` - | -note: function defined here - --> $DIR/invalid_arguments.rs:8:4 + | ^^^^ expected `i32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:31:24 | -LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- +LL | three_arg_diff(X {}, X {}, ""); + | ^^^^ expected `f32`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:29:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:34:18 | LL | three_arg_diff(X {}, 1.0, X {}); - | ^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X` - | | - | expected `i32`, found struct `X` - | -note: function defined here - --> $DIR/invalid_arguments.rs:8:4 + | ^^^^ expected `i32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:34:29 | -LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- +LL | three_arg_diff(X {}, 1.0, X {}); + | ^^^^ expected `&str`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:30:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:37:21 | LL | three_arg_diff(1, X {}, X {}); - | ^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X` - | | - | expected `f32`, found struct `X` - | -note: function defined here - --> $DIR/invalid_arguments.rs:8:4 + | ^^^^ expected `f32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:37:27 | -LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- +LL | three_arg_diff(1, X {}, X {}); + | ^^^^ expected `&str`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:32:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:41:18 | LL | three_arg_diff(X {}, X {}, X {}); - | ^^^^^^^^^^^^^^ ---- ---- ---- expected `&str`, found struct `X` - | | | - | | expected `f32`, found struct `X` - | expected `i32`, found struct `X` + | ^^^^ expected `i32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:41:24 | -note: function defined here - --> $DIR/invalid_arguments.rs:8:4 +LL | three_arg_diff(X {}, X {}, X {}); + | ^^^^ expected `f32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:41:30 | -LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- +LL | three_arg_diff(X {}, X {}, X {}); + | ^^^^ expected `&str`, found struct `X` error[E0308]: mismatched types - --> $DIR/invalid_arguments.rs:34:20 + --> $DIR/invalid_arguments.rs:46:20 | LL | three_arg_repeat(X {}, 1, ""); - | ---------------- ^^^^ expected `i32`, found struct `X` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:9:4 - | -LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^ expected `i32`, found struct `X` error[E0308]: mismatched types - --> $DIR/invalid_arguments.rs:35:23 + --> $DIR/invalid_arguments.rs:47:23 | LL | three_arg_repeat(1, X {}, ""); - | ---------------- ^^^^ expected `i32`, found struct `X` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:9:4 - | -LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^ expected `i32`, found struct `X` error[E0308]: mismatched types - --> $DIR/invalid_arguments.rs:36:26 + --> $DIR/invalid_arguments.rs:48:26 | LL | three_arg_repeat(1, 1, X {}); - | ---------------- ^^^^ expected `&str`, found struct `X` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/invalid_arguments.rs:9:4 - | -LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^ expected `&str`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:38:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:50:20 | LL | three_arg_repeat(X {}, X {}, ""); - | ^^^^^^^^^^^^^^^^ ---- ---- expected `i32`, found struct `X` - | | - | expected `i32`, found struct `X` - | -note: function defined here - --> $DIR/invalid_arguments.rs:9:4 + | ^^^^ expected `i32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:50:26 | -LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- +LL | three_arg_repeat(X {}, X {}, ""); + | ^^^^ expected `i32`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:39:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:53:20 | LL | three_arg_repeat(X {}, 1, X {}); - | ^^^^^^^^^^^^^^^^ ---- ---- expected `&str`, found struct `X` - | | - | expected `i32`, found struct `X` - | -note: function defined here - --> $DIR/invalid_arguments.rs:9:4 + | ^^^^ expected `i32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:53:29 | -LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- +LL | three_arg_repeat(X {}, 1, X {}); + | ^^^^ expected `&str`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:40:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:56:23 | LL | three_arg_repeat(1, X {}, X{}); - | ^^^^^^^^^^^^^^^^ ---- --- expected `&str`, found struct `X` - | | - | expected `i32`, found struct `X` - | -note: function defined here - --> $DIR/invalid_arguments.rs:9:4 + | ^^^^ expected `i32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:56:29 | -LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- +LL | three_arg_repeat(1, X {}, X{}); + | ^^^ expected `&str`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/invalid_arguments.rs:42:3 +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:60:20 | LL | three_arg_repeat(X {}, X {}, X {}); - | ^^^^^^^^^^^^^^^^ ---- ---- ---- expected `&str`, found struct `X` - | | | - | | expected `i32`, found struct `X` - | expected `i32`, found struct `X` + | ^^^^ expected `i32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:60:26 | -note: function defined here - --> $DIR/invalid_arguments.rs:9:4 +LL | three_arg_repeat(X {}, X {}, X {}); + | ^^^^ expected `i32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/invalid_arguments.rs:60:32 | -LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- +LL | three_arg_repeat(X {}, X {}, X {}); + | ^^^^ expected `&str`, found struct `X` -error: aborting due to 21 previous errors +error: aborting due to 33 previous errors For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/argument-suggestions/issue-96638.stderr b/src/test/ui/argument-suggestions/issue-96638.stderr index 35190e2ca0d82..dde7e5da5e941 100644 --- a/src/test/ui/argument-suggestions/issue-96638.stderr +++ b/src/test/ui/argument-suggestions/issue-96638.stderr @@ -2,17 +2,15 @@ error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> $DIR/issue-96638.rs:8:5 | LL | f(&x, ""); - | ^ -- an argument of type `usize` is missing + | ^ -- -- supplied 2 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/issue-96638.rs:1:4 | LL | fn f(_: usize, _: &usize, _: usize) {} | ^ -------- --------- -------- -help: provide the argument - | -LL | f({usize}, &x, {usize}); - | ~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to previous error diff --git a/src/test/ui/argument-suggestions/issue-97197.stderr b/src/test/ui/argument-suggestions/issue-97197.stderr index 10689d5095748..982186dc7821d 100644 --- a/src/test/ui/argument-suggestions/issue-97197.stderr +++ b/src/test/ui/argument-suggestions/issue-97197.stderr @@ -2,17 +2,15 @@ error[E0061]: this function takes 6 arguments but 2 arguments were supplied --> $DIR/issue-97197.rs:2:5 | LL | g((), ()); - | ^-------- multiple arguments are missing + | ^ -- -- supplied 2 arguments + | | + | expected 6 arguments | note: function defined here --> $DIR/issue-97197.rs:6:8 | LL | pub fn g(a1: (), a2: bool, a3: bool, a4: bool, a5: bool, a6: ()) -> () {} | ^ ------ -------- -------- -------- -------- ------ -help: provide the arguments - | -LL | g((), {bool}, {bool}, {bool}, {bool}, ()); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to previous error diff --git a/src/test/ui/argument-suggestions/missing_arguments.stderr b/src/test/ui/argument-suggestions/missing_arguments.stderr index 5236d15b94574..c9e379ef1bccc 100644 --- a/src/test/ui/argument-suggestions/missing_arguments.stderr +++ b/src/test/ui/argument-suggestions/missing_arguments.stderr @@ -2,308 +2,267 @@ error[E0061]: this function takes 1 argument but 0 arguments were supplied --> $DIR/missing_arguments.rs:10:3 | LL | one_arg(); - | ^^^^^^^-- an argument of type `i32` is missing + | ^^^^^^^-- supplied 0 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/missing_arguments.rs:1:4 | LL | fn one_arg(_a: i32) {} | ^^^^^^^ ------- -help: provide the argument - | -LL | one_arg({i32}); - | ~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 0 arguments were supplied --> $DIR/missing_arguments.rs:14:3 | LL | two_same( ); - | ^^^^^^^^----------------- two arguments of type `i32` and `i32` are missing + | ^^^^^^^^----------------- supplied 0 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/missing_arguments.rs:2:4 | LL | fn two_same(_a: i32, _b: i32) {} | ^^^^^^^^ ------- ------- -help: provide the arguments - | -LL | two_same({i32}, {i32}); - | ~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 1 argument was supplied --> $DIR/missing_arguments.rs:15:3 | LL | two_same( 1 ); - | ^^^^^^^^----------------- an argument of type `i32` is missing + | ^^^^^^^^ - supplied 1 argument + | | + | expected 2 arguments | note: function defined here --> $DIR/missing_arguments.rs:2:4 | LL | fn two_same(_a: i32, _b: i32) {} | ^^^^^^^^ ------- ------- -help: provide the argument - | -LL | two_same(1, {i32}); - | ~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 0 arguments were supplied --> $DIR/missing_arguments.rs:16:3 | LL | two_diff( ); - | ^^^^^^^^----------------- two arguments of type `i32` and `f32` are missing + | ^^^^^^^^----------------- supplied 0 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/missing_arguments.rs:3:4 | LL | fn two_diff(_a: i32, _b: f32) {} | ^^^^^^^^ ------- ------- -help: provide the arguments - | -LL | two_diff({i32}, {f32}); - | ~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 1 argument was supplied --> $DIR/missing_arguments.rs:17:3 | LL | two_diff( 1 ); - | ^^^^^^^^----------------- an argument of type `f32` is missing + | ^^^^^^^^ - supplied 1 argument + | | + | expected 2 arguments | note: function defined here --> $DIR/missing_arguments.rs:3:4 | LL | fn two_diff(_a: i32, _b: f32) {} | ^^^^^^^^ ------- ------- -help: provide the argument - | -LL | two_diff(1, {f32}); - | ~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 1 argument was supplied --> $DIR/missing_arguments.rs:18:3 | LL | two_diff( 1.0 ); - | ^^^^^^^^ --- an argument of type `i32` is missing + | ^^^^^^^^ --- supplied 1 argument + | | + | expected 2 arguments | note: function defined here --> $DIR/missing_arguments.rs:3:4 | LL | fn two_diff(_a: i32, _b: f32) {} | ^^^^^^^^ ------- ------- -help: provide the argument - | -LL | two_diff({i32}, 1.0); - | ~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 0 arguments were supplied --> $DIR/missing_arguments.rs:21:3 | LL | three_same( ); - | ^^^^^^^^^^------------------------- three arguments of type `i32`, `i32`, and `i32` are missing + | ^^^^^^^^^^------------------------- supplied 0 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:4:4 | LL | fn three_same(_a: i32, _b: i32, _c: i32) {} | ^^^^^^^^^^ ------- ------- ------- -help: provide the arguments - | -LL | three_same({i32}, {i32}, {i32}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 1 argument was supplied --> $DIR/missing_arguments.rs:22:3 | LL | three_same( 1 ); - | ^^^^^^^^^^------------------------- two arguments of type `i32` and `i32` are missing + | ^^^^^^^^^^ - supplied 1 argument + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:4:4 | LL | fn three_same(_a: i32, _b: i32, _c: i32) {} | ^^^^^^^^^^ ------- ------- ------- -help: provide the arguments - | -LL | three_same(1, {i32}, {i32}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> $DIR/missing_arguments.rs:23:3 | LL | three_same( 1, 1 ); - | ^^^^^^^^^^------------------------- an argument of type `i32` is missing + | ^^^^^^^^^^ - - supplied 2 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:4:4 | LL | fn three_same(_a: i32, _b: i32, _c: i32) {} | ^^^^^^^^^^ ------- ------- ------- -help: provide the argument - | -LL | three_same(1, 1, {i32}); - | ~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> $DIR/missing_arguments.rs:26:3 | LL | three_diff( 1.0, "" ); - | ^^^^^^^^^^ --- an argument of type `i32` is missing + | ^^^^^^^^^^ --- -- supplied 2 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:5:4 | LL | fn three_diff(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: provide the argument - | -LL | three_diff({i32}, 1.0, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> $DIR/missing_arguments.rs:27:3 | LL | three_diff( 1, "" ); - | ^^^^^^^^^^ -- an argument of type `f32` is missing + | ^^^^^^^^^^ - -- supplied 2 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:5:4 | LL | fn three_diff(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: provide the argument - | -LL | three_diff(1, {f32}, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> $DIR/missing_arguments.rs:28:3 | LL | three_diff( 1, 1.0 ); - | ^^^^^^^^^^------------------------- an argument of type `&str` is missing + | ^^^^^^^^^^ - --- supplied 2 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:5:4 | LL | fn three_diff(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: provide the argument - | -LL | three_diff(1, 1.0, {&str}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 1 argument was supplied --> $DIR/missing_arguments.rs:29:3 | LL | three_diff( "" ); - | ^^^^^^^^^^------------------------- two arguments of type `i32` and `f32` are missing + | ^^^^^^^^^^ -- supplied 1 argument + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:5:4 | LL | fn three_diff(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: provide the arguments - | -LL | three_diff({i32}, {f32}, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 1 argument was supplied --> $DIR/missing_arguments.rs:30:3 | LL | three_diff( 1.0 ); - | ^^^^^^^^^^------------------------- - | | | - | | an argument of type `i32` is missing - | an argument of type `&str` is missing + | ^^^^^^^^^^ --- supplied 1 argument + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:5:4 | LL | fn three_diff(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: provide the arguments - | -LL | three_diff({i32}, 1.0, {&str}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 1 argument was supplied --> $DIR/missing_arguments.rs:31:3 | LL | three_diff( 1 ); - | ^^^^^^^^^^------------------------- two arguments of type `f32` and `&str` are missing + | ^^^^^^^^^^ - supplied 1 argument + | | + | expected 3 arguments | note: function defined here --> $DIR/missing_arguments.rs:5:4 | LL | fn three_diff(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: provide the arguments - | -LL | three_diff(1, {f32}, {&str}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 4 arguments but 0 arguments were supplied --> $DIR/missing_arguments.rs:34:3 | LL | four_repeated( ); - | ^^^^^^^^^^^^^--------------------------------- multiple arguments are missing + | ^^^^^^^^^^^^^--------------------------------- supplied 0 arguments + | | + | expected 4 arguments | note: function defined here --> $DIR/missing_arguments.rs:6:4 | LL | fn four_repeated(_a: i32, _b: f32, _c: f32, _d: &str) {} | ^^^^^^^^^^^^^ ------- ------- ------- -------- -help: provide the arguments - | -LL | four_repeated({i32}, {f32}, {f32}, {&str}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 4 arguments but 2 arguments were supplied --> $DIR/missing_arguments.rs:35:3 | LL | four_repeated( 1, "" ); - | ^^^^^^^^^^^^^--------------------------------- two arguments of type `f32` and `f32` are missing + | ^^^^^^^^^^^^^ - -- supplied 2 arguments + | | + | expected 4 arguments | note: function defined here --> $DIR/missing_arguments.rs:6:4 | LL | fn four_repeated(_a: i32, _b: f32, _c: f32, _d: &str) {} | ^^^^^^^^^^^^^ ------- ------- ------- -------- -help: provide the arguments - | -LL | four_repeated(1, {f32}, {f32}, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 5 arguments but 0 arguments were supplied --> $DIR/missing_arguments.rs:38:3 | LL | complex( ); - | ^^^^^^^--------------------------------- multiple arguments are missing + | ^^^^^^^--------------------------------- supplied 0 arguments + | | + | expected 5 arguments | note: function defined here --> $DIR/missing_arguments.rs:7:4 | LL | fn complex(_a: i32, _b: f32, _c: i32, _d: f32, _e: &str) {} | ^^^^^^^ ------- ------- ------- ------- -------- -help: provide the arguments - | -LL | complex({i32}, {f32}, {i32}, {f32}, {&str}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 5 arguments but 2 arguments were supplied --> $DIR/missing_arguments.rs:39:3 | LL | complex( 1, "" ); - | ^^^^^^^--------------------------------- three arguments of type `f32`, `i32`, and `f32` are missing + | ^^^^^^^ - -- supplied 2 arguments + | | + | expected 5 arguments | note: function defined here --> $DIR/missing_arguments.rs:7:4 | LL | fn complex(_a: i32, _b: f32, _c: i32, _d: f32, _e: &str) {} | ^^^^^^^ ------- ------- ------- ------- -------- -help: provide the arguments - | -LL | complex(1, {f32}, {i32}, {f32}, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to 19 previous errors diff --git a/src/test/ui/argument-suggestions/mixed_cases.rs b/src/test/ui/argument-suggestions/mixed_cases.rs index 73678482b3025..0a6542ce24d0b 100644 --- a/src/test/ui/argument-suggestions/mixed_cases.rs +++ b/src/test/ui/argument-suggestions/mixed_cases.rs @@ -14,10 +14,15 @@ fn main() { three_args(1, X {}); //~ ERROR this function takes // Missing and Extra - three_args(1, "", X {}); //~ ERROR arguments to this function are incorrect + three_args(1, "", X {}); + //~^ ERROR mismatched types + //~| ERROR mismatched types // Swapped and Invalid - three_args("", X {}, 1); //~ ERROR arguments to this function are incorrect + three_args("", X {}, 1); + //~^ ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types // Swapped and missing three_args("", 1); //~ ERROR this function takes diff --git a/src/test/ui/argument-suggestions/mixed_cases.stderr b/src/test/ui/argument-suggestions/mixed_cases.stderr index 61da02f583789..fc4249f355bb1 100644 --- a/src/test/ui/argument-suggestions/mixed_cases.stderr +++ b/src/test/ui/argument-suggestions/mixed_cases.stderr @@ -2,116 +2,89 @@ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/mixed_cases.rs:10:3 | LL | two_args(1, "", X {}); - | ^^^^^^^^ -- ---- argument unexpected - | | - | expected `f32`, found `&str` + | ^^^^^^^^ - -- ---- supplied 3 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/mixed_cases.rs:5:4 | LL | fn two_args(_a: i32, _b: f32) {} | ^^^^^^^^ ------- ------- -help: remove the extra argument - | -LL | two_args(1, {f32}); - | ~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 4 arguments were supplied --> $DIR/mixed_cases.rs:11:3 | LL | three_args(1, "", X {}, ""); - | ^^^^^^^^^^ -- ---- -- argument unexpected - | | | - | | argument of type `&str` unexpected - | an argument of type `f32` is missing + | ^^^^^^^^^^ - -- ---- -- supplied 4 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/mixed_cases.rs:6:4 | LL | fn three_args(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: did you mean - | -LL | three_args(1, {f32}, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> $DIR/mixed_cases.rs:14:3 | LL | three_args(1, X {}); - | ^^^^^^^^^^--------- - | | | - | | expected `f32`, found struct `X` - | an argument of type `&str` is missing + | ^^^^^^^^^^ - ---- supplied 2 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/mixed_cases.rs:6:4 | LL | fn three_args(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: provide the argument - | -LL | three_args(1, {f32}, {&str}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -error[E0308]: arguments to this function are incorrect - --> $DIR/mixed_cases.rs:17:3 +error[E0308]: mismatched types + --> $DIR/mixed_cases.rs:17:17 | LL | three_args(1, "", X {}); - | ^^^^^^^^^^ -- ---- argument of type `&str` unexpected - | | - | an argument of type `f32` is missing - | -note: function defined here - --> $DIR/mixed_cases.rs:6:4 - | -LL | fn three_args(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^ ------- ------- -------- -help: did you mean + | ^^ expected `f32`, found `&str` + +error[E0308]: mismatched types + --> $DIR/mixed_cases.rs:17:21 | -LL | three_args(1, {f32}, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~ +LL | three_args(1, "", X {}); + | ^^^^ expected `&str`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/mixed_cases.rs:20:3 +error[E0308]: mismatched types + --> $DIR/mixed_cases.rs:22:14 | LL | three_args("", X {}, 1); - | ^^^^^^^^^^ -- ---- - expected `&str`,found `{integer}` - | | | - | | expected `f32`, found struct `X` - | expected `i32`,found `&'static str` - | -note: function defined here - --> $DIR/mixed_cases.rs:6:4 + | ^^ expected `i32`, found `&str` + +error[E0308]: mismatched types + --> $DIR/mixed_cases.rs:22:18 | -LL | fn three_args(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^ ------- ------- -------- -help: swap these arguments +LL | three_args("", X {}, 1); + | ^^^^ expected `f32`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/mixed_cases.rs:22:24 | -LL | three_args(1, {f32}, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~ +LL | three_args("", X {}, 1); + | ^ expected `&str`, found integer error[E0061]: this function takes 3 arguments but 2 arguments were supplied - --> $DIR/mixed_cases.rs:23:3 + --> $DIR/mixed_cases.rs:28:3 | LL | three_args("", 1); - | ^^^^^^^^^^ -- - - | | | - | | an argument of type `f32` is missing - | | expected `&str`,found `{integer}` - | expected `i32`,found `&'static str` + | ^^^^^^^^^^ -- - supplied 2 arguments + | | + | expected 3 arguments | note: function defined here --> $DIR/mixed_cases.rs:6:4 | LL | fn three_args(_a: i32, _b: f32, _c: &str) {} | ^^^^^^^^^^ ------- ------- -------- -help: did you mean - | -LL | three_args(1, {f32}, ""); - | ~~~~~~~~~~~~~~~~~~~~~~~~ -error: aborting due to 6 previous errors +error: aborting due to 9 previous errors Some errors have detailed explanations: E0061, E0308. For more information about an error, try `rustc --explain E0061`. diff --git a/src/test/ui/argument-suggestions/permuted_arguments.rs b/src/test/ui/argument-suggestions/permuted_arguments.rs index f512fde651cd9..236811a425094 100644 --- a/src/test/ui/argument-suggestions/permuted_arguments.rs +++ b/src/test/ui/argument-suggestions/permuted_arguments.rs @@ -7,7 +7,15 @@ fn many_args(_a: i32, _b: f32, _c: &str, _d: X, _e: Y) {} fn main() { // b, c, a - three_args(1.0, "", 1); //~ ERROR arguments to this function are incorrect + three_args(1.0, "", 1); + //~^ ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types // d, e, b, a, c - many_args(X {}, Y {}, 1, 1.0, ""); //~ ERROR arguments to this function are incorrect + many_args(X {}, Y {}, 1, 1.0, ""); + //~^ ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types } diff --git a/src/test/ui/argument-suggestions/permuted_arguments.stderr b/src/test/ui/argument-suggestions/permuted_arguments.stderr index 52890f4e6a50e..f90c8c73606ce 100644 --- a/src/test/ui/argument-suggestions/permuted_arguments.stderr +++ b/src/test/ui/argument-suggestions/permuted_arguments.stderr @@ -1,43 +1,51 @@ -error[E0308]: arguments to this function are incorrect - --> $DIR/permuted_arguments.rs:10:3 +error[E0308]: mismatched types + --> $DIR/permuted_arguments.rs:10:14 | LL | three_args(1.0, "", 1); - | ^^^^^^^^^^ --- -- - expected `&str`,found `{integer}` - | | | - | | expected `f32`,found `&'static str` - | expected `i32`,found `{float}` + | ^^^ expected `i32`, found floating-point number + +error[E0308]: mismatched types + --> $DIR/permuted_arguments.rs:10:19 | -note: function defined here - --> $DIR/permuted_arguments.rs:5:4 +LL | three_args(1.0, "", 1); + | ^^ expected `f32`, found `&str` + +error[E0308]: mismatched types + --> $DIR/permuted_arguments.rs:10:23 | -LL | fn three_args(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^ ------- ------- -------- -help: reorder these arguments +LL | three_args(1.0, "", 1); + | ^ expected `&str`, found integer + +error[E0308]: mismatched types + --> $DIR/permuted_arguments.rs:15:13 | -LL | three_args(1, 1.0, ""); - | ~~~~~~~~~~~~~~~~~~~~~~ +LL | many_args(X {}, Y {}, 1, 1.0, ""); + | ^^^^ expected `i32`, found struct `X` -error[E0308]: arguments to this function are incorrect - --> $DIR/permuted_arguments.rs:12:3 +error[E0308]: mismatched types + --> $DIR/permuted_arguments.rs:15:19 | 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` + | ^^^^ expected `f32`, found struct `Y` + +error[E0308]: mismatched types + --> $DIR/permuted_arguments.rs:15:25 | -note: function defined here - --> $DIR/permuted_arguments.rs:6:4 +LL | many_args(X {}, Y {}, 1, 1.0, ""); + | ^ expected `&str`, found integer + +error[E0308]: mismatched types + --> $DIR/permuted_arguments.rs:15:28 | -LL | fn many_args(_a: i32, _b: f32, _c: &str, _d: X, _e: Y) {} - | ^^^^^^^^^ ------- ------- -------- ----- ----- -help: reorder these arguments +LL | many_args(X {}, Y {}, 1, 1.0, ""); + | ^^^ expected struct `X`, found floating-point number + +error[E0308]: mismatched types + --> $DIR/permuted_arguments.rs:15:33 | -LL | many_args(1, 1.0, "", X {}, Y {}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +LL | many_args(X {}, Y {}, 1, 1.0, ""); + | ^^ expected struct `Y`, found `&str` -error: aborting due to 2 previous errors +error: aborting due to 8 previous errors For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/argument-suggestions/swapped_arguments.rs b/src/test/ui/argument-suggestions/swapped_arguments.rs index a21de610c6a13..4821b6e4db9c7 100644 --- a/src/test/ui/argument-suggestions/swapped_arguments.rs +++ b/src/test/ui/argument-suggestions/swapped_arguments.rs @@ -5,10 +5,21 @@ fn three_args(_a: i32, _b: f32, _c: &str) {} fn four_args(_a: i32, _b: f32, _c: &str, _d: X) {} fn main() { - two_args(1.0, 1); //~ ERROR arguments to this function are incorrect - three_args(1.0, 1, ""); //~ ERROR arguments to this function are incorrect - three_args( 1, "", 1.0); //~ ERROR arguments to this function are incorrect - three_args( "", 1.0, 1); //~ ERROR arguments to this function are incorrect - - four_args(1.0, 1, X {}, ""); //~ ERROR arguments to this function are incorrect + two_args(1.0, 1); + //~^ ERROR mismatched types + //~| ERROR mismatched types + three_args(1.0, 1, ""); + //~^ ERROR mismatched types + //~| ERROR mismatched types + three_args( 1, "", 1.0); + //~^ ERROR mismatched types + //~| ERROR mismatched types + three_args( "", 1.0, 1); + //~^ ERROR mismatched types + //~| ERROR mismatched types + four_args(1.0, 1, X {}, ""); + //~^ ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types + //~| ERROR mismatched types } diff --git a/src/test/ui/argument-suggestions/swapped_arguments.stderr b/src/test/ui/argument-suggestions/swapped_arguments.stderr index 672f0d5bb56a6..43dd419ed2e3b 100644 --- a/src/test/ui/argument-suggestions/swapped_arguments.stderr +++ b/src/test/ui/argument-suggestions/swapped_arguments.stderr @@ -1,95 +1,84 @@ -error[E0308]: arguments to this function are incorrect - --> $DIR/swapped_arguments.rs:8:3 +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:8:12 | LL | two_args(1.0, 1); - | ^^^^^^^^ --- - expected `f32`,found `{integer}` - | | - | expected `i32`,found `{float}` - | -note: function defined here - --> $DIR/swapped_arguments.rs:3:4 - | -LL | fn two_args(_a: i32, _b: f32) {} - | ^^^^^^^^ ------- ------- -help: swap these arguments + | ^^^ expected `i32`, found floating-point number + +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:8:17 | -LL | two_args(1, 1.0); - | ~~~~~~~~~~~~~~~~ +LL | two_args(1.0, 1); + | ^ + | | + | expected `f32`, found integer + | help: use a float literal: `1.0` -error[E0308]: arguments to this function are incorrect - --> $DIR/swapped_arguments.rs:9:3 +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:11:14 | LL | three_args(1.0, 1, ""); - | ^^^^^^^^^^ --- - expected `f32`,found `{integer}` - | | - | expected `i32`,found `{float}` - | -note: function defined here - --> $DIR/swapped_arguments.rs:4:4 - | -LL | fn three_args(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^ ------- ------- -------- -help: swap these arguments + | ^^^ expected `i32`, found floating-point number + +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:11:21 | -LL | three_args(1, 1.0, ""); - | ~~~~~~~~~~~~~~~~~~~~~~ +LL | three_args(1.0, 1, ""); + | ^ + | | + | expected `f32`, found integer + | help: use a float literal: `1.0` -error[E0308]: arguments to this function are incorrect - --> $DIR/swapped_arguments.rs:10:3 +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:14:20 | LL | three_args( 1, "", 1.0); - | ^^^^^^^^^^ -- --- expected `&str`,found `{float}` - | | - | expected `f32`,found `&'static str` - | -note: function defined here - --> $DIR/swapped_arguments.rs:4:4 - | -LL | fn three_args(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^ ------- ------- -------- -help: swap these arguments + | ^^ expected `f32`, found `&str` + +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:14:24 | -LL | three_args(1, 1.0, ""); - | ~~~~~~~~~~~~~~~~~~~~~~ +LL | three_args( 1, "", 1.0); + | ^^^ expected `&str`, found floating-point number -error[E0308]: arguments to this function are incorrect - --> $DIR/swapped_arguments.rs:11:3 +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:17:15 | LL | three_args( "", 1.0, 1); - | ^^^^^^^^^^ -- - expected `&str`,found `{integer}` - | | - | expected `i32`,found `&'static str` - | -note: function defined here - --> $DIR/swapped_arguments.rs:4:4 - | -LL | fn three_args(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^ ------- ------- -------- -help: swap these arguments + | ^^ expected `i32`, found `&str` + +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:17:26 | -LL | three_args(1, 1.0, ""); - | ~~~~~~~~~~~~~~~~~~~~~~ +LL | three_args( "", 1.0, 1); + | ^ expected `&str`, found integer -error[E0308]: arguments to this function are incorrect - --> $DIR/swapped_arguments.rs:13:3 +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:20:13 | LL | four_args(1.0, 1, X {}, ""); - | ^^^^^^^^^ --- - ---- -- expected `X`,found `&'static str` - | | | | - | | | expected `&str`,found `X` - | | expected `f32`,found `{integer}` - | expected `i32`,found `{float}` + | ^^^ expected `i32`, found floating-point number + +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:20:18 | -note: function defined here - --> $DIR/swapped_arguments.rs:5:4 +LL | four_args(1.0, 1, X {}, ""); + | ^ + | | + | expected `f32`, found integer + | help: use a float literal: `1.0` + +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:20:21 | -LL | fn four_args(_a: i32, _b: f32, _c: &str, _d: X) {} - | ^^^^^^^^^ ------- ------- -------- ----- -help: did you mean +LL | four_args(1.0, 1, X {}, ""); + | ^^^^ expected `&str`, found struct `X` + +error[E0308]: mismatched types + --> $DIR/swapped_arguments.rs:20:27 | -LL | four_args(1, 1.0, "", X {}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +LL | four_args(1.0, 1, X {}, ""); + | ^^ expected struct `X`, found `&str` -error: aborting due to 5 previous errors +error: aborting due to 12 previous errors For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr b/src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr index b904ad102e97e..07f207627f4df 100644 --- a/src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr +++ b/src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr @@ -2,57 +2,25 @@ error[E0308]: mismatched types --> $DIR/associated-type-projection-from-supertrait.rs:27:23 | LL | fn b() { dent(ModelT, Blue); } - | ---- ^^^^ expected struct `Black`, found struct `Blue` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/associated-type-projection-from-supertrait.rs:25:4 - | -LL | fn dent(c: C, color: C::Color) { c.chip_paint(color) } - | ^^^^ ---- --------------- + | ^^^^ expected struct `Black`, found struct `Blue` error[E0308]: mismatched types --> $DIR/associated-type-projection-from-supertrait.rs:28:23 | LL | fn c() { dent(ModelU, Black); } - | ---- ^^^^^ expected struct `Blue`, found struct `Black` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/associated-type-projection-from-supertrait.rs:25:4 - | -LL | fn dent(c: C, color: C::Color) { c.chip_paint(color) } - | ^^^^ ---- --------------- + | ^^^^^ expected struct `Blue`, found struct `Black` error[E0308]: mismatched types --> $DIR/associated-type-projection-from-supertrait.rs:32:28 | LL | fn f() { ModelT.chip_paint(Blue); } - | ---------- ^^^^ expected struct `Black`, found struct `Blue` - | | - | arguments to this function are incorrect - | -note: associated function defined here - --> $DIR/associated-type-projection-from-supertrait.rs:12:8 - | -LL | fn chip_paint(&self, c: Self::Color) { } - | ^^^^^^^^^^ ----- -------------- + | ^^^^ expected struct `Black`, found struct `Blue` error[E0308]: mismatched types --> $DIR/associated-type-projection-from-supertrait.rs:33:28 | LL | fn g() { ModelU.chip_paint(Black); } - | ---------- ^^^^^ expected struct `Blue`, found struct `Black` - | | - | arguments to this function are incorrect - | -note: associated function defined here - --> $DIR/associated-type-projection-from-supertrait.rs:12:8 - | -LL | fn chip_paint(&self, c: Self::Color) { } - | ^^^^^^^^^^ ----- -------------- + | ^^^^^ expected struct `Blue`, found struct `Black` error: aborting due to 4 previous errors diff --git a/src/test/ui/associated-types/associated-types-path-2.stderr b/src/test/ui/associated-types/associated-types-path-2.stderr index 1d0b84d31d410..2d8d513409d3a 100644 --- a/src/test/ui/associated-types/associated-types-path-2.stderr +++ b/src/test/ui/associated-types/associated-types-path-2.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/associated-types-path-2.rs:19:14 | LL | f1(2i32, 4i32); - | -- ^^^^ expected `u32`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/associated-types-path-2.rs:13:8 + | ^^^^ expected `u32`, found `i32` | -LL | pub fn f1(a: T, x: T::A) {} - | ^^ ---- ------- help: change the type of the numeric literal from `i32` to `u32` | LL | f1(2i32, 4u32); diff --git a/src/test/ui/async-await/dont-suggest-missing-await.stderr b/src/test/ui/async-await/dont-suggest-missing-await.stderr index 627bf05bba2d9..289a567209c49 100644 --- a/src/test/ui/async-await/dont-suggest-missing-await.stderr +++ b/src/test/ui/async-await/dont-suggest-missing-await.stderr @@ -2,9 +2,7 @@ error[E0308]: mismatched types --> $DIR/dont-suggest-missing-await.rs:14:18 | LL | take_u32(x) - | -------- ^ expected `u32`, found opaque type - | | - | arguments to this function are incorrect + | ^ expected `u32`, found opaque type | note: while checking the return type of the `async fn` --> $DIR/dont-suggest-missing-await.rs:7:24 @@ -13,11 +11,6 @@ LL | async fn make_u32() -> u32 { | ^^^ checked the `Output` of this `async fn`, found opaque type = note: expected type `u32` found opaque type `impl Future` -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) diff --git a/src/test/ui/async-await/generator-desc.stderr b/src/test/ui/async-await/generator-desc.stderr index 3be8c552063e7..3ebc4392f2c8d 100644 --- a/src/test/ui/async-await/generator-desc.stderr +++ b/src/test/ui/async-await/generator-desc.stderr @@ -2,27 +2,18 @@ error[E0308]: mismatched types --> $DIR/generator-desc.rs:10:25 | LL | fun(async {}, async {}); - | -- ^^ - | | | - | | expected `async` block, found a different `async` block - | | arguments to this function are incorrect + | -- ^^ expected `async` block, found a different `async` block + | | | the expected `async` block | = note: expected `async` block `[static generator@$DIR/generator-desc.rs:10:15: 10:17]` found `async` block `[static generator@$DIR/generator-desc.rs:10:25: 10:27]` -note: function defined here - --> $SRC_DIR/core/src/future/mod.rs:LL:COL - | -LL | pub const fn from_generator(gen: T) -> impl Future - | ^^^^^^^^^^^^^^ error[E0308]: mismatched types --> $DIR/generator-desc.rs:12:16 | LL | fun(one(), two()); - | --- ^^^^^ expected opaque type, found a different opaque type - | | - | arguments to this function are incorrect + | ^^^^^ expected opaque type, found a different opaque type | note: while checking the return type of the `async fn` --> $DIR/generator-desc.rs:5:16 @@ -38,20 +29,14 @@ LL | async fn two() {} found opaque type `impl Future` (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>(f1: F, f2: F) {} - | ^^^ ----- ----- error[E0308]: mismatched types --> $DIR/generator-desc.rs:14:26 | LL | fun((async || {})(), (async || {})()); - | --- -- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body - | | | - | | the expected `async` closure body - | arguments to this function are incorrect + | -- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body + | | + | the expected `async` closure body | ::: $SRC_DIR/core/src/future/mod.rs:LL:COL | @@ -63,11 +48,6 @@ LL | pub const fn from_generator(gen: T) -> impl Future | = note: expected opaque type `impl Future` (`async` closure body) found opaque type `impl Future` (`async` closure body) -note: function defined here - --> $DIR/generator-desc.rs:8:4 - | -LL | fn fun>(f1: F, f2: F) {} - | ^^^ ----- ----- error: aborting due to 3 previous errors diff --git a/src/test/ui/async-await/suggest-missing-await-closure.stderr b/src/test/ui/async-await/suggest-missing-await-closure.stderr index a5958baffbaf7..d951c8ed094e7 100644 --- a/src/test/ui/async-await/suggest-missing-await-closure.stderr +++ b/src/test/ui/async-await/suggest-missing-await-closure.stderr @@ -2,9 +2,7 @@ error[E0308]: mismatched types --> $DIR/suggest-missing-await-closure.rs:16:18 | LL | take_u32(x) - | -------- ^ expected `u32`, found opaque type - | | - | arguments to this function are incorrect + | ^ expected `u32`, found opaque type | note: while checking the return type of the `async fn` --> $DIR/suggest-missing-await-closure.rs:8:24 @@ -13,11 +11,6 @@ LL | async fn make_u32() -> u32 { | ^^^ checked the `Output` of this `async fn`, found opaque type = note: expected type `u32` found opaque type `impl Future` -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) diff --git a/src/test/ui/async-await/suggest-missing-await.stderr b/src/test/ui/async-await/suggest-missing-await.stderr index 1196601ace090..d70377d7107e5 100644 --- a/src/test/ui/async-await/suggest-missing-await.stderr +++ b/src/test/ui/async-await/suggest-missing-await.stderr @@ -2,9 +2,7 @@ error[E0308]: mismatched types --> $DIR/suggest-missing-await.rs:12:14 | LL | take_u32(x) - | -------- ^ expected `u32`, found opaque type - | | - | arguments to this function are incorrect + | ^ expected `u32`, found opaque type | note: while checking the return type of the `async fn` --> $DIR/suggest-missing-await.rs:5:24 @@ -13,11 +11,6 @@ LL | async fn make_u32() -> u32 { | ^^^ checked the `Output` of this `async fn`, found opaque type = note: expected type `u32` found opaque type `impl Future` -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) diff --git a/src/test/ui/c-variadic/variadic-ffi-1.stderr b/src/test/ui/c-variadic/variadic-ffi-1.stderr index 9acf1e93b0773..5b4e656d9dca1 100644 --- a/src/test/ui/c-variadic/variadic-ffi-1.stderr +++ b/src/test/ui/c-variadic/variadic-ffi-1.stderr @@ -8,33 +8,29 @@ error[E0060]: this function takes at least 2 arguments but 0 arguments were supp --> $DIR/variadic-ffi-1.rs:20:9 | LL | foo(); - | ^^^-- two arguments of type `isize` and `u8` are missing + | ^^^-- supplied 0 arguments + | | + | expected at least 2 arguments | note: function defined here --> $DIR/variadic-ffi-1.rs:13:8 | LL | fn foo(f: isize, x: u8, ...); | ^^^ -help: provide the arguments - | -LL | foo({isize}, {u8}); - | ~~~~~~~~~~~~~~~~~~ error[E0060]: this function takes at least 2 arguments but 1 argument was supplied --> $DIR/variadic-ffi-1.rs:21:9 | LL | foo(1); - | ^^^--- an argument of type `u8` is missing + | ^^^ - supplied 1 argument + | | + | expected at least 2 arguments | note: function defined here --> $DIR/variadic-ffi-1.rs:13:8 | LL | fn foo(f: isize, x: u8, ...); | ^^^ -help: provide the argument - | -LL | foo(1, {u8}); - | ~~~~~~~~~~~~ error[E0308]: mismatched types --> $DIR/variadic-ffi-1.rs:23:56 diff --git a/src/test/ui/cast/cast-int-to-char.stderr b/src/test/ui/cast/cast-int-to-char.stderr index ef606b6ae5fd4..55b9462db8df8 100644 --- a/src/test/ui/cast/cast-int-to-char.stderr +++ b/src/test/ui/cast/cast-int-to-char.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/cast-int-to-char.rs:4:16 | LL | foo::('0'); - | ---------- ^^^ expected `u32`, found `char` - | | - | arguments to this function are incorrect + | ^^^ expected `u32`, found `char` | -note: function defined here - --> $DIR/cast-int-to-char.rs:1:4 - | -LL | fn foo(_t: T) {} - | ^^^ ----- help: you can cast a `char` to a `u32`, since a `char` always occupies 4 bytes | LL | foo::('0' as u32); @@ -20,15 +13,8 @@ error[E0308]: mismatched types --> $DIR/cast-int-to-char.rs:5:16 | LL | foo::('0'); - | ---------- ^^^ expected `i32`, found `char` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/cast-int-to-char.rs:1:4 + | ^^^ expected `i32`, found `char` | -LL | fn foo(_t: T) {} - | ^^^ ----- help: you can cast a `char` to an `i32`, since a `char` always occupies 4 bytes | LL | foo::('0' as i32); @@ -38,15 +24,8 @@ error[E0308]: mismatched types --> $DIR/cast-int-to-char.rs:6:16 | LL | foo::('0'); - | ---------- ^^^ expected `u64`, found `char` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/cast-int-to-char.rs:1:4 + | ^^^ expected `u64`, found `char` | -LL | fn foo(_t: T) {} - | ^^^ ----- help: you can cast a `char` to a `u64`, since a `char` always occupies 4 bytes | LL | foo::('0' as u64); @@ -56,15 +35,8 @@ error[E0308]: mismatched types --> $DIR/cast-int-to-char.rs:7:16 | LL | foo::('0'); - | ---------- ^^^ expected `i64`, found `char` - | | - | arguments to this function are incorrect + | ^^^ expected `i64`, found `char` | -note: function defined here - --> $DIR/cast-int-to-char.rs:1:4 - | -LL | fn foo(_t: T) {} - | ^^^ ----- help: you can cast a `char` to an `i64`, since a `char` always occupies 4 bytes | LL | foo::('0' as i64); @@ -74,15 +46,7 @@ error[E0308]: mismatched types --> $DIR/cast-int-to-char.rs:8:17 | LL | foo::(0u32); - | ----------- ^^^^ expected `char`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/cast-int-to-char.rs:1:4 - | -LL | fn foo(_t: T) {} - | ^^^ ----- + | ^^^^ expected `char`, found `u32` error: aborting due to 5 previous errors diff --git a/src/test/ui/closures/closure-reform-bad.stderr b/src/test/ui/closures/closure-reform-bad.stderr index 534828ab348fd..37813879ce752 100644 --- a/src/test/ui/closures/closure-reform-bad.stderr +++ b/src/test/ui/closures/closure-reform-bad.stderr @@ -4,9 +4,7 @@ error[E0308]: mismatched types LL | let f = |s: &str| println!("{}{}", s, string); | ------------------------------------- the found closure LL | call_bare(f) - | --------- ^ expected fn pointer, found closure - | | - | arguments to this function are incorrect + | ^ expected fn pointer, found closure | = note: expected fn pointer `for<'r> fn(&'r str)` found closure `[closure@$DIR/closure-reform-bad.rs:10:13: 10:50]` @@ -15,11 +13,6 @@ note: closures can only be coerced to `fn` types if they do not capture any vari | LL | let f = |s: &str| println!("{}{}", s, string); | ^^^^^^ `string` captured here -note: function defined here - --> $DIR/closure-reform-bad.rs:4:4 - | -LL | fn call_bare(f: fn(&str)) { - | ^^^^^^^^^ ----------- error: aborting due to previous error diff --git a/src/test/ui/closures/issue-84128.stderr b/src/test/ui/closures/issue-84128.stderr index 09c44d261af0c..70d9273ddf7ce 100644 --- a/src/test/ui/closures/issue-84128.stderr +++ b/src/test/ui/closures/issue-84128.stderr @@ -2,20 +2,13 @@ error[E0308]: mismatched types --> $DIR/issue-84128.rs:13:13 | LL | Foo(()) - | --- ^^ expected integer, found `()` - | | - | arguments to this struct are incorrect + | ^^ expected integer, found `()` | note: return type inferred to be `{integer}` here --> $DIR/issue-84128.rs:10:20 | LL | return Foo(0); | ^^^^^^ -note: tuple struct defined here - --> $DIR/issue-84128.rs:5:8 - | -LL | struct Foo(T); - | ^^^ error: aborting due to previous error diff --git a/src/test/ui/closures/issue-87461.stderr b/src/test/ui/closures/issue-87461.stderr index b35fa2b8c9aba..a3cff2c12124a 100644 --- a/src/test/ui/closures/issue-87461.stderr +++ b/src/test/ui/closures/issue-87461.stderr @@ -2,25 +2,19 @@ error[E0308]: mismatched types --> $DIR/issue-87461.rs:10:8 | LL | Ok(()) - | -- ^^ expected `u16`, found `()` - | | - | arguments to this enum variant are incorrect + | ^^ expected `u16`, found `()` error[E0308]: mismatched types --> $DIR/issue-87461.rs:17:8 | LL | Ok(()) - | -- ^^ expected `u16`, found `()` - | | - | arguments to this enum variant are incorrect + | ^^ expected `u16`, found `()` error[E0308]: mismatched types --> $DIR/issue-87461.rs:26:12 | LL | Ok(()) - | -- ^^ expected `u16`, found `()` - | | - | arguments to this enum variant are incorrect + | ^^ expected `u16`, found `()` error: aborting due to 3 previous errors diff --git a/src/test/ui/coercion/coerce-mut.stderr b/src/test/ui/coercion/coerce-mut.stderr index 11a4f310154c5..2601ca5e91e5b 100644 --- a/src/test/ui/coercion/coerce-mut.stderr +++ b/src/test/ui/coercion/coerce-mut.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/coerce-mut.rs:5:7 | LL | f(&x); - | - ^^ types differ in mutability - | | - | arguments to this function are incorrect + | ^^ types differ in mutability | = note: expected mutable reference `&mut i32` found reference `&{integer}` -note: function defined here - --> $DIR/coerce-mut.rs:1:4 - | -LL | fn f(x: &mut i32) {} - | ^ ----------- error: aborting due to previous error diff --git a/src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr b/src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr index 36551e5afc6c6..59b0ec496f16f 100644 --- a/src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr +++ b/src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/coerce-reborrow-multi-arg-fail.rs:4:18 | LL | test(&mut 7, &7); - | ---- ^^ types differ in mutability - | | - | arguments to this function are incorrect + | ^^ types differ in mutability | = note: expected mutable reference `&mut {integer}` found reference `&{integer}` -note: function defined here - --> $DIR/coerce-reborrow-multi-arg-fail.rs:1:4 - | -LL | fn test(_a: T, _b: T) {} - | ^^^^ ----- ----- error: aborting due to previous error diff --git a/src/test/ui/coercion/coerce-to-bang.stderr b/src/test/ui/coercion/coerce-to-bang.stderr index add8f14cfa591..390aa7c692d18 100644 --- a/src/test/ui/coercion/coerce-to-bang.stderr +++ b/src/test/ui/coercion/coerce-to-bang.stderr @@ -2,81 +2,46 @@ error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:6:17 | LL | foo(return, 22, 44); - | --- ^^ expected `!`, found integer - | | - | arguments to this function are incorrect + | ^^ expected `!`, found integer | = note: expected type `!` found type `{integer}` -note: function defined here - --> $DIR/coerce-to-bang.rs:3:4 - | -LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:18:13 | LL | foo(22, 44, return); - | --- ^^ expected `!`, found integer - | | - | arguments to this function are incorrect + | ^^ expected `!`, found integer | = note: expected type `!` found type `{integer}` -note: function defined here - --> $DIR/coerce-to-bang.rs:3:4 - | -LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:26:12 | LL | foo(a, b, c); // ... and hence a reference to `a` is expected to diverge. - | --- ^ expected `!`, found integer - | | - | arguments to this function are incorrect + | ^ expected `!`, found integer | = note: expected type `!` found type `{integer}` -note: function defined here - --> $DIR/coerce-to-bang.rs:3:4 - | -LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:36:12 | LL | foo(a, b, c); - | --- ^ expected `!`, found integer - | | - | arguments to this function are incorrect + | ^ expected `!`, found integer | = note: expected type `!` found type `{integer}` -note: function defined here - --> $DIR/coerce-to-bang.rs:3:4 - | -LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:45:12 | LL | foo(a, b, c); - | --- ^ expected `!`, found integer - | | - | arguments to this function are incorrect + | ^ expected `!`, found integer | = note: expected type `!` found type `{integer}` -note: function defined here - --> $DIR/coerce-to-bang.rs:3:4 - | -LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:50:21 diff --git a/src/test/ui/const-generics/const-argument-cross-crate-mismatch.stderr b/src/test/ui/const-generics/const-argument-cross-crate-mismatch.stderr index 42f469d981781..aefd514f7a68e 100644 --- a/src/test/ui/const-generics/const-argument-cross-crate-mismatch.stderr +++ b/src/test/ui/const-generics/const-argument-cross-crate-mismatch.stderr @@ -2,17 +2,13 @@ error[E0308]: mismatched types --> $DIR/const-argument-cross-crate-mismatch.rs:6:67 | LL | let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8])); - | ------------------------- ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements - | | - | arguments to this struct are incorrect + | ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements error[E0308]: mismatched types --> $DIR/const-argument-cross-crate-mismatch.rs:8:65 | LL | let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]); - | ------------------------- ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements - | | - | arguments to this struct are incorrect + | ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements error: aborting due to 2 previous errors diff --git a/src/test/ui/const-generics/generic_const_exprs/issue-62504.min.stderr b/src/test/ui/const-generics/generic_const_exprs/issue-62504.min.stderr index 9bea4105d58b0..5d45e302888d4 100644 --- a/src/test/ui/const-generics/generic_const_exprs/issue-62504.min.stderr +++ b/src/test/ui/const-generics/generic_const_exprs/issue-62504.min.stderr @@ -1,26 +1,19 @@ -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` - | | - | arguments to this struct are incorrect + | ^^^^^^^^^^^^^^^ expected `X`, found `Self::SIZE` | = note: expected array `[u32; X]` found array `[u32; _]` -note: tuple struct defined here - --> $DIR/issue-62504.rs:14:8 + +error: constant expression depends on a generic parameter + --> $DIR/issue-62504.rs:18:25 | -LL | struct ArrayHolder([u32; X]); - | ^^^^^^^^^^^ +LL | ArrayHolder([0; Self::SIZE]) + | ^^^^^^^^^^ + | + = note: this may fail depending on what value the parameter takes error: aborting due to 2 previous errors diff --git a/src/test/ui/did_you_mean/issue-42764.stderr b/src/test/ui/did_you_mean/issue-42764.stderr index 95b572133c5f7..dbe46704b9320 100644 --- a/src/test/ui/did_you_mean/issue-42764.stderr +++ b/src/test/ui/did_you_mean/issue-42764.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-42764.rs:11:43 | LL | this_function_expects_a_double_option(n); - | ------------------------------------- ^ expected enum `DoubleOption`, found `usize` - | | - | arguments to this function are incorrect + | ^ expected enum `DoubleOption`, found `usize` | = note: expected enum `DoubleOption<_>` found type `usize` -note: function defined here - --> $DIR/issue-42764.rs:7:4 - | -LL | fn this_function_expects_a_double_option(d: DoubleOption) {} - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ------------------ help: try wrapping the expression in a variant of `DoubleOption` | LL | this_function_expects_a_double_option(DoubleOption::FirstSome(n)); diff --git a/src/test/ui/disambiguate-identical-names.stderr b/src/test/ui/disambiguate-identical-names.stderr index 42925cfed5507..0c6bd9379f753 100644 --- a/src/test/ui/disambiguate-identical-names.stderr +++ b/src/test/ui/disambiguate-identical-names.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/disambiguate-identical-names.rs:13:10 | LL | test(&v); - | ---- ^^ expected struct `std::vec::Vec`, found struct `HashMap` - | | - | arguments to this function are incorrect + | ^^ expected struct `std::vec::Vec`, found struct `HashMap` | = note: expected reference `&std::vec::Vec>` found reference `&HashMap` -note: function defined here - --> $DIR/disambiguate-identical-names.rs:6:4 - | -LL | fn test(_v: &Vec>) { - | ^^^^ ------------------ error: aborting due to previous error diff --git a/src/test/ui/error-codes/E0057.stderr b/src/test/ui/error-codes/E0057.stderr index 4b4d30a8387fe..31579e2828964 100644 --- a/src/test/ui/error-codes/E0057.stderr +++ b/src/test/ui/error-codes/E0057.stderr @@ -2,33 +2,17 @@ error[E0057]: this function takes 1 argument but 0 arguments were supplied --> $DIR/E0057.rs:3:13 | LL | let a = f(); - | ^-- an argument is missing - | -note: closure defined here - --> $DIR/E0057.rs:2:13 - | -LL | let f = |x| x * 3; - | ^^^ -help: provide the argument - | -LL | let a = f({_}); - | ~~~~~~ + | ^-- supplied 0 arguments + | | + | expected 1 argument error[E0057]: this function takes 1 argument but 2 arguments were supplied --> $DIR/E0057.rs:5:13 | LL | let c = f(2, 3); - | ^ - argument unexpected - | -note: closure defined here - --> $DIR/E0057.rs:2:13 - | -LL | let f = |x| x * 3; - | ^^^ -help: remove the extra argument - | -LL | let c = f(2); - | ~~~~ + | ^ - - supplied 2 arguments + | | + | expected 1 argument error: aborting due to 2 previous errors diff --git a/src/test/ui/error-codes/E0060.stderr b/src/test/ui/error-codes/E0060.stderr index 9dd649239e29f..c80014d14763b 100644 --- a/src/test/ui/error-codes/E0060.stderr +++ b/src/test/ui/error-codes/E0060.stderr @@ -2,17 +2,15 @@ error[E0060]: this function takes at least 1 argument but 0 arguments were suppl --> $DIR/E0060.rs:6:14 | LL | unsafe { printf(); } - | ^^^^^^-- an argument of type `*const u8` is missing + | ^^^^^^-- supplied 0 arguments + | | + | expected at least 1 argument | note: function defined here --> $DIR/E0060.rs:2:8 | LL | fn printf(_: *const u8, ...) -> u32; | ^^^^^^ -help: provide the argument - | -LL | unsafe { printf({*const u8}); } - | ~~~~~~~~~~~~~~~~~~~ error: aborting due to previous error diff --git a/src/test/ui/error-codes/E0061.stderr b/src/test/ui/error-codes/E0061.stderr index f92c548f2de1f..344c3b3bd6740 100644 --- a/src/test/ui/error-codes/E0061.stderr +++ b/src/test/ui/error-codes/E0061.stderr @@ -2,33 +2,29 @@ error[E0061]: this function takes 2 arguments but 1 argument was supplied --> $DIR/E0061.rs:6:5 | LL | f(0); - | ^--- an argument of type `&str` is missing + | ^ - supplied 1 argument + | | + | expected 2 arguments | note: function defined here --> $DIR/E0061.rs:1:4 | LL | fn f(a: u16, b: &str) {} | ^ ------ ------- -help: provide the argument - | -LL | f(0, {&str}); - | ~~~~~~~~~~~~ error[E0061]: this function takes 1 argument but 0 arguments were supplied --> $DIR/E0061.rs:9:5 | LL | f2(); - | ^^-- an argument of type `u16` is missing + | ^^-- supplied 0 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/E0061.rs:3:4 | LL | fn f2(a: u16) {} | ^^ ------ -help: provide the argument - | -LL | f2({u16}); - | ~~~~~~~~~ error: aborting due to 2 previous errors diff --git a/src/test/ui/fmt/ifmt-bad-arg.stderr b/src/test/ui/fmt/ifmt-bad-arg.stderr index c25da900951cc..3f1f1006713ba 100644 --- a/src/test/ui/fmt/ifmt-bad-arg.stderr +++ b/src/test/ui/fmt/ifmt-bad-arg.stderr @@ -296,36 +296,20 @@ error[E0308]: mismatched types --> $DIR/ifmt-bad-arg.rs:78:32 | LL | println!("{} {:.*} {}", 1, 3.2, 4); - | ---------------------------^^^---- - | | | - | | expected `usize`, found floating-point number - | arguments to this function are incorrect + | ^^^ expected `usize`, found floating-point number | = note: expected reference `&usize` found reference `&{float}` -note: associated function defined here - --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL - | -LL | pub fn from_usize(x: &usize) -> ArgumentV1<'_> { - | ^^^^^^^^^^ = note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info) error[E0308]: mismatched types --> $DIR/ifmt-bad-arg.rs:81:35 | LL | println!("{} {:07$.*} {}", 1, 3.2, 4); - | ------------------------------^^^---- - | | | - | | expected `usize`, found floating-point number - | arguments to this function are incorrect + | ^^^ expected `usize`, found floating-point number | = note: expected reference `&usize` found reference `&{float}` -note: associated function defined here - --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL - | -LL | pub fn from_usize(x: &usize) -> ArgumentV1<'_> { - | ^^^^^^^^^^ = note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to 36 previous errors diff --git a/src/test/ui/fn/fn-item-type.stderr b/src/test/ui/fn/fn-item-type.stderr index ecc6485d6d2b5..eccc65e1d84c5 100644 --- a/src/test/ui/fn/fn-item-type.stderr +++ b/src/test/ui/fn/fn-item-type.stderr @@ -2,95 +2,60 @@ error[E0308]: mismatched types --> $DIR/fn-item-type.rs:13:19 | LL | eq(foo::, bar::); - | -- ^^^^^^^^^ expected fn item, found a different fn item - | | - | arguments to this function are incorrect + | ^^^^^^^^^ expected fn item, found a different fn item | = note: expected fn item `fn(_) -> _ {foo::}` found fn item `fn(_) -> _ {bar::}` = 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:: as fn(isize) -> isize` -note: function defined here - --> $DIR/fn-item-type.rs:7:4 - | -LL | fn eq(x: T, y: T) { } - | ^^ ---- ---- error[E0308]: mismatched types --> $DIR/fn-item-type.rs:22:19 | LL | eq(foo::, foo::); - | -- ^^^^^^^^^ expected `u8`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^^^^^^ expected `u8`, found `i8` | = note: expected fn item `fn(_) -> _ {foo::}` found fn item `fn(_) -> _ {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(isize) -> isize` = help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo:: as fn(isize) -> isize` -note: function defined here - --> $DIR/fn-item-type.rs:7:4 - | -LL | fn eq(x: T, y: T) { } - | ^^ ---- ---- error[E0308]: mismatched types --> $DIR/fn-item-type.rs:29:23 | LL | eq(bar::, bar::>); - | -- ^^^^^^^^^^^^^^ expected struct `String`, found struct `Vec` - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^ expected struct `String`, found struct `Vec` | = note: expected fn item `fn(_) -> _ {bar::}` found fn item `fn(_) -> _ {bar::>}` = 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:: as fn(isize) -> isize` -note: function defined here - --> $DIR/fn-item-type.rs:7:4 - | -LL | fn eq(x: T, y: T) { } - | ^^ ---- ---- error[E0308]: mismatched types --> $DIR/fn-item-type.rs:38:26 | LL | eq(::foo, ::foo); - | -- ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16` | = note: expected fn item `fn() {::foo}` found fn item `fn() {::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: `::foo as fn()` -note: function defined here - --> $DIR/fn-item-type.rs:7:4 - | -LL | fn eq(x: T, y: T) { } - | ^^ ---- ---- error[E0308]: mismatched types --> $DIR/fn-item-type.rs:45:19 | LL | eq(foo::, bar:: as fn(isize) -> isize); - | -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer | = note: expected fn item `fn(_) -> _ {foo::}` 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:: as fn(isize) -> isize` -note: function defined here - --> $DIR/fn-item-type.rs:7:4 - | -LL | fn eq(x: T, y: T) { } - | ^^ ---- ---- error: aborting due to 5 previous errors diff --git a/src/test/ui/generic-associated-types/issue-68648-2.stderr b/src/test/ui/generic-associated-types/issue-68648-2.stderr index 06c1efcd80b0d..7a7d5a6c2313f 100644 --- a/src/test/ui/generic-associated-types/issue-68648-2.stderr +++ b/src/test/ui/generic-associated-types/issue-68648-2.stderr @@ -4,17 +4,10 @@ error[E0308]: mismatched types LL | fn bug<'a, T: Fun = T>>(t: T) -> T::F<'a> { | - this type parameter LL | T::identity(()) - | ----------- ^^ expected type parameter `T`, found `()` - | | - | arguments to this function are incorrect + | ^^ expected type parameter `T`, found `()` | = note: expected type parameter `T` found unit type `()` -note: associated function defined here - --> $DIR/issue-68648-2.rs:6:8 - | -LL | fn identity<'a>(t: Self::F<'a>) -> Self::F<'a> { t } - | ^^^^^^^^ -------------- error: aborting due to previous error diff --git a/src/test/ui/generic-associated-types/missing-bounds.stderr b/src/test/ui/generic-associated-types/missing-bounds.stderr index 5323ee172267f..bc87b2ee638a8 100644 --- a/src/test/ui/generic-associated-types/missing-bounds.stderr +++ b/src/test/ui/generic-associated-types/missing-bounds.stderr @@ -17,17 +17,10 @@ LL | impl Add for A where B: Add { | - this type parameter ... LL | A(self.0 + rhs.0) - | - ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type - | | - | arguments to this struct are incorrect + | ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type | = note: expected type parameter `B` found associated type `::Output` -note: tuple struct defined here - --> $DIR/missing-bounds.rs:3:8 - | -LL | struct A(B); - | ^ help: consider further restricting this bound | LL | impl Add for A where B: Add + Add { @@ -40,17 +33,10 @@ LL | impl Add for C { | - this type parameter ... LL | Self(self.0 + rhs.0) - | ---- ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type | = note: expected type parameter `B` found associated type `::Output` -note: tuple struct defined here - --> $DIR/missing-bounds.rs:13:8 - | -LL | struct C(B); - | ^ help: consider further restricting this bound | LL | impl> Add for C { @@ -76,17 +62,10 @@ LL | impl Add for E where ::Output = B { | - this type parameter ... LL | Self(self.0 + rhs.0) - | ---- ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^ expected type parameter `B`, found associated type | = note: expected type parameter `B` found associated type `::Output` -note: tuple struct defined here - --> $DIR/missing-bounds.rs:33:8 - | -LL | struct E(B); - | ^ help: consider further restricting this bound | LL | impl> Add for E where ::Output = B { diff --git a/src/test/ui/hrtb/issue-58451.stderr b/src/test/ui/hrtb/issue-58451.stderr index d2b3b1c2aa0e5..2cc1c7a2e7269 100644 --- a/src/test/ui/hrtb/issue-58451.stderr +++ b/src/test/ui/hrtb/issue-58451.stderr @@ -2,17 +2,15 @@ error[E0061]: this function takes 1 argument but 0 arguments were supplied --> $DIR/issue-58451.rs:12:9 | LL | f(&[f()]); - | ^-- an argument is missing + | ^-- supplied 0 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/issue-58451.rs:5:4 | LL | fn f(i: I) | ^ ---- -help: provide the argument - | -LL | f(&[f({_})]); - | ~~~~~~ error: aborting due to previous error diff --git a/src/test/ui/impl-trait/issues/issue-74282.stderr b/src/test/ui/impl-trait/issues/issue-74282.stderr index 0f855ef57927a..6e02a6b2b87b4 100644 --- a/src/test/ui/impl-trait/issues/issue-74282.stderr +++ b/src/test/ui/impl-trait/issues/issue-74282.stderr @@ -5,9 +5,7 @@ LL | type Closure = impl Fn() -> u64; | ---------------- the expected opaque type ... LL | Anonymous(|| { - | _____---------_^ - | | | - | | arguments to this struct are incorrect + | _______________^ LL | | 3 LL | | }) | |_____^ expected closure, found a different closure @@ -16,11 +14,6 @@ LL | | }) found closure `[closure@$DIR/issue-74282.rs:8:15: 10:6]` = note: no two closures, even if identical, have the same type = help: consider boxing your closure and/or using it as a trait object -note: tuple struct defined here - --> $DIR/issue-74282.rs:4:8 - | -LL | struct Anonymous(Closure); - | ^^^^^^^^^ error[E0308]: mismatched types --> $DIR/issue-74282.rs:8:5 diff --git a/src/test/ui/indexing-requires-a-uint.stderr b/src/test/ui/indexing-requires-a-uint.stderr index 0a24855a6a79c..dae11a702fb73 100644 --- a/src/test/ui/indexing-requires-a-uint.stderr +++ b/src/test/ui/indexing-requires-a-uint.stderr @@ -12,15 +12,8 @@ error[E0308]: mismatched types --> $DIR/indexing-requires-a-uint.rs:12:18 | LL | bar::(i); // i should not be re-coerced back to an isize - | ------------ ^ expected `isize`, found `usize` - | | - | arguments to this function are incorrect + | ^ expected `isize`, found `usize` | -note: function defined here - --> $DIR/indexing-requires-a-uint.rs:5:8 - | -LL | fn bar(_: T) {} - | ^^^ ---- help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit | LL | bar::(i.try_into().unwrap()); // i should not be re-coerced back to an isize diff --git a/src/test/ui/inference/deref-suggestion.stderr b/src/test/ui/inference/deref-suggestion.stderr index 8ba9dacb4b21d..28c9afaa52c22 100644 --- a/src/test/ui/inference/deref-suggestion.stderr +++ b/src/test/ui/inference/deref-suggestion.stderr @@ -2,30 +2,16 @@ error[E0308]: mismatched types --> $DIR/deref-suggestion.rs:8:9 | LL | foo(s); - | --- ^- help: try using a conversion method: `.to_string()` - | | | - | | expected struct `String`, found `&String` - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/deref-suggestion.rs:5:4 - | -LL | fn foo(_: String) {} - | ^^^ --------- + | ^- help: try using a conversion method: `.to_string()` + | | + | expected struct `String`, found `&String` error[E0308]: mismatched types --> $DIR/deref-suggestion.rs:14:10 | LL | foo3(u); - | ---- ^ expected `u32`, found `&u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/deref-suggestion.rs:12:4 + | ^ expected `u32`, found `&u32` | -LL | fn foo3(_: u32) {} - | ^^^^ ------ help: consider dereferencing the borrow | LL | foo3(*u); @@ -35,15 +21,8 @@ error[E0308]: mismatched types --> $DIR/deref-suggestion.rs:30:9 | LL | foo(&"aaa".to_owned()); - | --- ^^^^^^^^^^^^^^^^^ expected struct `String`, found `&String` - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^ expected struct `String`, found `&String` | -note: function defined here - --> $DIR/deref-suggestion.rs:5:4 - | -LL | fn foo(_: String) {} - | ^^^ --------- help: consider removing the borrow | LL - foo(&"aaa".to_owned()); @@ -54,15 +33,8 @@ error[E0308]: mismatched types --> $DIR/deref-suggestion.rs:32:9 | LL | foo(&mut "aaa".to_owned()); - | --- ^^^^^^^^^^^^^^^^^^^^^ expected struct `String`, found `&mut String` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/deref-suggestion.rs:5:4 + | ^^^^^^^^^^^^^^^^^^^^^ expected struct `String`, found `&mut String` | -LL | fn foo(_: String) {} - | ^^^ --------- help: consider removing the borrow | LL - foo(&mut "aaa".to_owned()); @@ -76,15 +48,8 @@ LL | ($x:expr) => { &$x } | ^^^ expected `u32`, found `&{integer}` ... LL | foo3(borrow!(0)); - | ---- ---------- in this macro invocation - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/deref-suggestion.rs:12:4 + | ---------- in this macro invocation | -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 diff --git a/src/test/ui/inference/tutorial-suffix-inference-test.stderr b/src/test/ui/inference/tutorial-suffix-inference-test.stderr index d83a1367dbfae..fbfbffbd24e2f 100644 --- a/src/test/ui/inference/tutorial-suffix-inference-test.stderr +++ b/src/test/ui/inference/tutorial-suffix-inference-test.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/tutorial-suffix-inference-test.rs:9:18 | LL | identity_u16(x); - | ------------ ^ expected `u16`, found `u8` - | | - | arguments to this function are incorrect + | ^ expected `u16`, found `u8` | -note: function defined here - --> $DIR/tutorial-suffix-inference-test.rs:6:8 - | -LL | fn identity_u16(n: u16) -> u16 { n } - | ^^^^^^^^^^^^ ------ help: you can convert a `u8` to a `u16` | LL | identity_u16(x.into()); @@ -20,15 +13,8 @@ error[E0308]: mismatched types --> $DIR/tutorial-suffix-inference-test.rs:12:18 | LL | identity_u16(y); - | ------------ ^ expected `u16`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/tutorial-suffix-inference-test.rs:6:8 + | ^ expected `u16`, found `i32` | -LL | fn identity_u16(n: u16) -> u16 { n } - | ^^^^^^^^^^^^ ------ help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit | LL | identity_u16(y.try_into().unwrap()); @@ -38,15 +24,8 @@ error[E0308]: mismatched types --> $DIR/tutorial-suffix-inference-test.rs:21:18 | LL | identity_u16(a); - | ------------ ^ expected `u16`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/tutorial-suffix-inference-test.rs:6:8 + | ^ expected `u16`, found `isize` | -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()); diff --git a/src/test/ui/issues/issue-10764.stderr b/src/test/ui/issues/issue-10764.stderr index 4d8a85a139715..b0bafc9942ee9 100644 --- a/src/test/ui/issues/issue-10764.stderr +++ b/src/test/ui/issues/issue-10764.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-10764.rs:4:15 | LL | fn main() { f(bar) } - | - ^^^ expected "Rust" fn, found "C" fn - | | - | arguments to this function are incorrect + | ^^^ expected "Rust" fn, found "C" fn | = note: expected fn pointer `fn()` found fn item `extern "C" fn() {bar}` -note: function defined here - --> $DIR/issue-10764.rs:1:4 - | -LL | fn f(_: extern "Rust" fn()) {} - | ^ --------------------- error: aborting due to previous error diff --git a/src/test/ui/issues/issue-11374.stderr b/src/test/ui/issues/issue-11374.stderr index 3a1d43310e2fc..d6a3e758de84a 100644 --- a/src/test/ui/issues/issue-11374.stderr +++ b/src/test/ui/issues/issue-11374.stderr @@ -2,19 +2,13 @@ error[E0308]: mismatched types --> $DIR/issue-11374.rs:26:15 | LL | c.read_to(v); - | ------- ^ - | | | - | | expected `&mut [u8]`, found struct `Vec` - | | help: consider mutably borrowing here: `&mut v` - | arguments to this function are incorrect + | ^ + | | + | expected `&mut [u8]`, found struct `Vec` + | help: consider mutably borrowing here: `&mut v` | = note: expected mutable reference `&mut [u8]` found struct `Vec<_>` -note: associated function defined here - --> $DIR/issue-11374.rs:13:12 - | -LL | pub fn read_to(&mut self, vec: &mut [u8]) { - | ^^^^^^^ --------- -------------- error: aborting due to previous error diff --git a/src/test/ui/issues/issue-12997-2.stderr b/src/test/ui/issues/issue-12997-2.stderr index 2a3d0e3457b03..3b89e8bc45151 100644 --- a/src/test/ui/issues/issue-12997-2.stderr +++ b/src/test/ui/issues/issue-12997-2.stderr @@ -4,16 +4,8 @@ error[E0308]: mismatched types LL | #[bench] | -------- in this procedural macro expansion LL | fn bar(x: isize) { } - | ^^^^^^^^^^^^^^^^^^^^ - | | - | expected `isize`, found `&mut Bencher` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `&mut Bencher` | -note: function defined here - --> $DIR/issue-12997-2.rs:8:4 - | -LL | fn bar(x: isize) { } - | ^^^ -------- = note: this error originates in the attribute macro `bench` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to previous error diff --git a/src/test/ui/issues/issue-13359.stderr b/src/test/ui/issues/issue-13359.stderr index fef63680a8676..075c92e65de82 100644 --- a/src/test/ui/issues/issue-13359.stderr +++ b/src/test/ui/issues/issue-13359.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/issue-13359.rs:6:9 | LL | foo(1*(1 as isize)); - | --- ^^^^^^^^^^^^^^ expected `i16`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^ expected `i16`, found `isize` | -note: function defined here - --> $DIR/issue-13359.rs:1:4 - | -LL | fn foo(_s: i16) { } - | ^^^ ------- help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit | LL | foo((1*(1 as isize)).try_into().unwrap()); @@ -20,15 +13,8 @@ error[E0308]: mismatched types --> $DIR/issue-13359.rs:10:9 | LL | bar(1*(1 as usize)); - | --- ^^^^^^^^^^^^^^ expected `u32`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/issue-13359.rs:3:4 + | ^^^^^^^^^^^^^^ expected `u32`, found `usize` | -LL | fn bar(_s: u32) { } - | ^^^ ------- help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit | LL | bar((1*(1 as usize)).try_into().unwrap()); diff --git a/src/test/ui/issues/issue-13853.stderr b/src/test/ui/issues/issue-13853.stderr index 657bda5f62b3f..527e0225eb976 100644 --- a/src/test/ui/issues/issue-13853.stderr +++ b/src/test/ui/issues/issue-13853.stderr @@ -20,19 +20,13 @@ error[E0308]: mismatched types --> $DIR/issue-13853.rs:37:13 | LL | iterate(graph); - | ------- ^^^^^ - | | | - | | expected reference, found struct `Vec` - | | help: consider borrowing here: `&graph` - | arguments to this function are incorrect + | ^^^^^ + | | + | expected reference, found struct `Vec` + | help: consider borrowing here: `&graph` | = note: expected reference `&_` found struct `Vec` -note: function defined here - --> $DIR/issue-13853.rs:26:4 - | -LL | fn iterate>(graph: &G) { - | ^^^^^^^ --------- error: aborting due to 3 previous errors diff --git a/src/test/ui/issues/issue-1448-2.stderr b/src/test/ui/issues/issue-1448-2.stderr index 203dd92c9fb02..da44566d075c4 100644 --- a/src/test/ui/issues/issue-1448-2.stderr +++ b/src/test/ui/issues/issue-1448-2.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/issue-1448-2.rs:6:24 | LL | println!("{}", foo(10i32)); - | --- ^^^^^ expected `u32`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u32`, found `i32` | -note: function defined here - --> $DIR/issue-1448-2.rs:3:4 - | -LL | fn foo(a: u32) -> u32 { a } - | ^^^ ------ help: change the type of the numeric literal from `i32` to `u32` | LL | println!("{}", foo(10u32)); diff --git a/src/test/ui/issues/issue-15783.stderr b/src/test/ui/issues/issue-15783.stderr index 660dfe9ed3d51..0b09751676e9c 100644 --- a/src/test/ui/issues/issue-15783.stderr +++ b/src/test/ui/issues/issue-15783.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-15783.rs:8:19 | LL | let msg = foo(x); - | --- ^ expected slice `[&str]`, found array `[&str; 1]` - | | - | arguments to this function are incorrect + | ^ expected slice `[&str]`, found array `[&str; 1]` | = note: expected enum `Option<&[&str]>` found enum `Option<&[&str; 1]>` -note: function defined here - --> $DIR/issue-15783.rs:1:8 - | -LL | pub fn foo(params: Option<&[&str]>) -> usize { - | ^^^ ----------------------- error: aborting due to previous error diff --git a/src/test/ui/issues/issue-16939.stderr b/src/test/ui/issues/issue-16939.stderr index 294524f0b6148..8e4237039fad7 100644 --- a/src/test/ui/issues/issue-16939.stderr +++ b/src/test/ui/issues/issue-16939.stderr @@ -2,17 +2,15 @@ error[E0057]: this function takes 0 arguments but 1 argument was supplied --> $DIR/issue-16939.rs:5:9 | LL | |t| f(t); - | ^ - argument unexpected + | ^ - supplied 1 argument + | | + | expected 0 arguments | note: associated function defined here --> $SRC_DIR/core/src/ops/function.rs:LL:COL | LL | extern "rust-call" fn call(&self, args: Args) -> Self::Output; | ^^^^ -help: remove the extra argument - | -LL | |t| f(); - | ~~~ error: aborting due to previous error diff --git a/src/test/ui/issues/issue-17033.stderr b/src/test/ui/issues/issue-17033.stderr index f26bee5ff45d0..518fc30142c94 100644 --- a/src/test/ui/issues/issue-17033.stderr +++ b/src/test/ui/issues/issue-17033.stderr @@ -2,11 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-17033.rs:2:10 | LL | (*p)(()) - | ---- ^^ - | | | - | | expected `&mut ()`, found `()` - | | help: consider mutably borrowing here: `&mut ()` - | arguments to this function are incorrect + | ^^ + | | + | expected `&mut ()`, found `()` + | help: consider mutably borrowing here: `&mut ()` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-18819.stderr b/src/test/ui/issues/issue-18819.stderr index db228fded6e40..b10d26abe3485 100644 --- a/src/test/ui/issues/issue-18819.stderr +++ b/src/test/ui/issues/issue-18819.stderr @@ -2,26 +2,15 @@ error[E0061]: this function takes 2 arguments but 1 argument was supplied --> $DIR/issue-18819.rs:16:5 | LL | print_x(X); - | ^^^^^^^--- - | || - | |expected reference, found struct `X` - | an argument of type `&str` is missing + | ^^^^^^^ - supplied 1 argument + | | + | expected 2 arguments | - = note: expected reference `&dyn Foo` - found struct `X` note: function defined here --> $DIR/issue-18819.rs:11:4 | LL | fn print_x(_: &dyn Foo, extra: &str) { | ^^^^^^^ ---------------------- ----------- -help: consider borrowing here - | -LL | print_x(&X); - | ~~ -help: provide the argument - | -LL | print_x({&dyn Foo}, {&str}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to previous error diff --git a/src/test/ui/issues/issue-24819.stderr b/src/test/ui/issues/issue-24819.stderr index 982a11fef80e8..2f931e59d5942 100644 --- a/src/test/ui/issues/issue-24819.stderr +++ b/src/test/ui/issues/issue-24819.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-24819.rs:5:9 | LL | foo(&mut v); - | --- ^^^^^^ expected struct `HashSet`, found struct `Vec` - | | - | arguments to this function are incorrect + | ^^^^^^ expected struct `HashSet`, found struct `Vec` | = note: expected mutable reference `&mut HashSet` found mutable reference `&mut Vec<_>` -note: function defined here - --> $DIR/issue-24819.rs:10:4 - | -LL | fn foo(h: &mut HashSet) { - | ^^^ -------------------- error: aborting due to previous error diff --git a/src/test/ui/issues/issue-26094.rs b/src/test/ui/issues/issue-26094.rs index 981c3abb4bae0..78fb0491d82dd 100644 --- a/src/test/ui/issues/issue-26094.rs +++ b/src/test/ui/issues/issue-26094.rs @@ -1,6 +1,6 @@ macro_rules! some_macro { ($other: expr) => ({ - $other(None) //~ NOTE argument unexpected + $other(None) //~ NOTE supplied 1 argument }) } @@ -9,5 +9,5 @@ fn some_function() {} //~ NOTE defined here fn main() { some_macro!(some_function); //~^ ERROR this function takes 0 arguments but 1 argument was supplied - //~| NOTE in this expansion of some_macro! + //~| NOTE expected 0 arguments } diff --git a/src/test/ui/issues/issue-26094.stderr b/src/test/ui/issues/issue-26094.stderr index 1013518e1dad3..a6f1ac9286cda 100644 --- a/src/test/ui/issues/issue-26094.stderr +++ b/src/test/ui/issues/issue-26094.stderr @@ -2,20 +2,16 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied --> $DIR/issue-26094.rs:10:17 | LL | $other(None) - | ---- argument unexpected + | ---- supplied 1 argument ... LL | some_macro!(some_function); - | ^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^ expected 0 arguments | note: function defined here --> $DIR/issue-26094.rs:7:4 | LL | fn some_function() {} | ^^^^^^^^^^^^^ -help: remove the extra argument - | -LL | some_function() - | ~~~~~~~~~~~~~~~ error: aborting due to previous error diff --git a/src/test/ui/issues/issue-3044.rs b/src/test/ui/issues/issue-3044.rs index 7363cae8370ab..81d76a90eb0ac 100644 --- a/src/test/ui/issues/issue-3044.rs +++ b/src/test/ui/issues/issue-3044.rs @@ -2,6 +2,5 @@ fn main() { let needlesArr: Vec = vec!['a', 'f']; needlesArr.iter().fold(|x, y| { }); - //~^^ ERROR mismatched types - //~| ERROR this function takes 2 arguments but 1 argument was supplied + //~^^ ERROR this function takes 2 arguments but 1 argument was supplied } diff --git a/src/test/ui/issues/issue-3044.stderr b/src/test/ui/issues/issue-3044.stderr index 5bb07cfda2142..b93aeade95e42 100644 --- a/src/test/ui/issues/issue-3044.stderr +++ b/src/test/ui/issues/issue-3044.stderr @@ -1,34 +1,19 @@ -error[E0308]: mismatched types - --> $DIR/issue-3044.rs:3:35 - | -LL | needlesArr.iter().fold(|x, y| { - | ___________________________________^ -LL | | }); - | |_____^ expected closure, found `()` - | - = note: expected closure `[closure@$DIR/issue-3044.rs:3:28: 4:6]` - found unit type `()` - error[E0061]: this function takes 2 arguments but 1 argument was supplied --> $DIR/issue-3044.rs:3:23 | LL | needlesArr.iter().fold(|x, y| { - | _______________________^^^^- + | _______________________^^^^_- + | | | + | | expected 2 arguments LL | | }); - | |______- an argument is missing + | |_____- supplied 1 argument | note: associated function defined here --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL | LL | fn fold(mut self, init: B, mut f: F) -> B | ^^^^ -help: provide the argument - | -LL ~ needlesArr.iter().fold(|x, y| { -LL ~ }, {_}); - | -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors have detailed explanations: E0061, E0308. -For more information about an error, try `rustc --explain E0061`. +For more information about this error, try `rustc --explain E0061`. diff --git a/src/test/ui/issues/issue-43420-no-over-suggest.stderr b/src/test/ui/issues/issue-43420-no-over-suggest.stderr index 58fd1121a6b99..77d52f6ecab11 100644 --- a/src/test/ui/issues/issue-43420-no-over-suggest.stderr +++ b/src/test/ui/issues/issue-43420-no-over-suggest.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-43420-no-over-suggest.rs:8:9 | LL | foo(&a); - | --- ^^ expected slice `[u16]`, found struct `Vec` - | | - | arguments to this function are incorrect + | ^^ expected slice `[u16]`, found struct `Vec` | = note: expected reference `&[u16]` found reference `&Vec` -note: function defined here - --> $DIR/issue-43420-no-over-suggest.rs:4:4 - | -LL | fn foo(b: &[u16]) {} - | ^^^ --------- error: aborting due to previous error diff --git a/src/test/ui/issues/issue-4517.stderr b/src/test/ui/issues/issue-4517.stderr index 70b4ca5ec496b..1ae97b69c6cac 100644 --- a/src/test/ui/issues/issue-4517.stderr +++ b/src/test/ui/issues/issue-4517.stderr @@ -2,15 +2,7 @@ error[E0308]: mismatched types --> $DIR/issue-4517.rs:5:9 | LL | bar(foo); - | --- ^^^ expected `usize`, found array `[u8; 4]` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/issue-4517.rs:1:4 - | -LL | fn bar(int_param: usize) {} - | ^^^ ---------------- + | ^^^ expected `usize`, found array `[u8; 4]` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-46756-consider-borrowing-cast-or-binexpr.stderr b/src/test/ui/issues/issue-46756-consider-borrowing-cast-or-binexpr.stderr index e874ded8ec54e..2d666e2b66c25 100644 --- a/src/test/ui/issues/issue-46756-consider-borrowing-cast-or-binexpr.stderr +++ b/src/test/ui/issues/issue-46756-consider-borrowing-cast-or-binexpr.stderr @@ -2,33 +2,19 @@ error[E0308]: mismatched types --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:12:42 | LL | light_flows_our_war_of_mocking_words(behold as usize); - | ------------------------------------ ^^^^^^^^^^^^^^^ - | | | - | | expected `&usize`, found `usize` - | | help: consider borrowing here: `&(behold as usize)` - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:5:4 - | -LL | fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ --------------- + | ^^^^^^^^^^^^^^^ + | | + | expected `&usize`, found `usize` + | help: consider borrowing here: `&(behold as usize)` error[E0308]: mismatched types --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:14:42 | LL | light_flows_our_war_of_mocking_words(with_tears + 4); - | ------------------------------------ ^^^^^^^^^^^^^^ - | | | - | | expected `&usize`, found `usize` - | | help: consider borrowing here: `&(with_tears + 4)` - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:5:4 - | -LL | fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ --------------- + | ^^^^^^^^^^^^^^ + | | + | expected `&usize`, found `usize` + | help: consider borrowing here: `&(with_tears + 4)` error: aborting due to 2 previous errors diff --git a/src/test/ui/issues/issue-48364.stderr b/src/test/ui/issues/issue-48364.stderr index 7fd36676df8c1..37a42d2382d6b 100644 --- a/src/test/ui/issues/issue-48364.stderr +++ b/src/test/ui/issues/issue-48364.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-48364.rs:2:21 | LL | b"".starts_with(stringify!(foo)) - | ----------- ^^^^^^^^^^^^^^^ expected slice `[u8]`, found `str` - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^ expected slice `[u8]`, found `str` | = note: expected reference `&[u8]` found reference `&'static str` -note: associated function defined here - --> $SRC_DIR/core/src/slice/mod.rs:LL:COL - | -LL | pub fn starts_with(&self, needle: &[T]) -> bool - | ^^^^^^^^^^^ = note: this error originates in the macro `stringify` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to previous error diff --git a/src/test/ui/issues/issue-4935.stderr b/src/test/ui/issues/issue-4935.stderr index b4cebe2a68b57..03b9b91edefb2 100644 --- a/src/test/ui/issues/issue-4935.stderr +++ b/src/test/ui/issues/issue-4935.stderr @@ -2,17 +2,15 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $DIR/issue-4935.rs:5:13 | LL | fn main() { foo(5, 6) } - | ^^^ - argument unexpected + | ^^^ - - supplied 2 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/issue-4935.rs:3:4 | LL | fn foo(a: usize) {} | ^^^ -------- -help: remove the extra argument - | -LL | fn main() { foo(5) } - | ~~~~~~ error: aborting due to previous error diff --git a/src/test/ui/issues/issue-51154.stderr b/src/test/ui/issues/issue-51154.stderr index f2cbc3e6feb78..3c3428f3096a8 100644 --- a/src/test/ui/issues/issue-51154.stderr +++ b/src/test/ui/issues/issue-51154.stderr @@ -4,18 +4,11 @@ error[E0308]: mismatched types LL | fn foo() { | - this type parameter LL | let _: Box = Box::new(|| ()); - | -------- ^^^^^ expected type parameter `F`, found closure - | | - | arguments to this function are incorrect + | ^^^^^ expected type parameter `F`, found closure | = note: expected type parameter `F` found closure `[closure@$DIR/issue-51154.rs:2:30: 2:35]` = help: every closure has a distinct type and so could not always match the caller-chosen type of parameter `F` -note: associated function defined here - --> $SRC_DIR/alloc/src/boxed.rs:LL:COL - | -LL | pub fn new(x: T) -> Self { - | ^^^ error: aborting due to previous error diff --git a/src/test/ui/issues/issue-5216.stderr b/src/test/ui/issues/issue-5216.stderr index 1afff28f0b4e1..29c95e4fb62b8 100644 --- a/src/test/ui/issues/issue-5216.stderr +++ b/src/test/ui/issues/issue-5216.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-5216.rs:3:21 | LL | pub static C: S = S(f); - | - ^ expected struct `Box`, found fn item - | | - | arguments to this struct are incorrect + | ^ expected struct `Box`, found fn item | = note: expected struct `Box<(dyn FnMut() + Sync + 'static)>` found fn item `fn() {f}` -note: tuple struct defined here - --> $DIR/issue-5216.rs:2:8 - | -LL | struct S(Box); - | ^ error[E0308]: mismatched types --> $DIR/issue-5216.rs:8:19 diff --git a/src/test/ui/issues/issue-61106.stderr b/src/test/ui/issues/issue-61106.stderr index 2bc09234116b1..2d841d28ee26d 100644 --- a/src/test/ui/issues/issue-61106.stderr +++ b/src/test/ui/issues/issue-61106.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-61106.rs:3:9 | LL | foo(x.clone()); - | --- ^^^^^^^^^ - | | | - | | expected `&str`, found struct `String` - | | help: consider borrowing here: `&x` - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/issue-61106.rs:6:4 - | -LL | fn foo(_: &str) {} - | ^^^ ------- + | ^^^^^^^^^ + | | + | expected `&str`, found struct `String` + | help: consider borrowing here: `&x` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-69306.stderr b/src/test/ui/issues/issue-69306.stderr index 61ec5d3180cc3..58e85ec700d2d 100644 --- a/src/test/ui/issues/issue-69306.stderr +++ b/src/test/ui/issues/issue-69306.stderr @@ -4,17 +4,10 @@ error[E0308]: mismatched types LL | impl S0 { | - this type parameter LL | const C: S0 = Self(0); - | ---- ^ expected type parameter `T`, found integer - | | - | arguments to this function are incorrect + | ^ expected type parameter `T`, found integer | = note: expected type parameter `T` found type `{integer}` -note: tuple struct defined here - --> $DIR/issue-69306.rs:3:8 - | -LL | struct S0(T); - | ^^ error[E0308]: mismatched types --> $DIR/issue-69306.rs:5:23 @@ -34,17 +27,10 @@ LL | impl S0 { | - this type parameter ... LL | Self(0); - | ---- ^ expected type parameter `T`, found integer - | | - | arguments to this function are incorrect + | ^ expected type parameter `T`, found integer | = note: expected type parameter `T` found type `{integer}` -note: tuple struct defined here - --> $DIR/issue-69306.rs:3:8 - | -LL | struct S0(T); - | ^^ error[E0308]: mismatched types --> $DIR/issue-69306.rs:27:14 @@ -53,17 +39,10 @@ LL | impl Foo for as Fun>::Out { | - this type parameter LL | fn foo() { LL | Self(0); - | ---- ^ expected type parameter `T`, found integer - | | - | arguments to this function are incorrect + | ^ expected type parameter `T`, found integer | = note: expected type parameter `T` found type `{integer}` -note: tuple struct defined here - --> $DIR/issue-69306.rs:3:8 - | -LL | struct S0(T); - | ^^ error[E0308]: mismatched types --> $DIR/issue-69306.rs:33:32 @@ -71,17 +50,10 @@ error[E0308]: mismatched types LL | impl S1 { | - this type parameter LL | const C: S1 = Self(0, 1); - | ---- ^ expected type parameter `T`, found integer - | | - | arguments to this function are incorrect + | ^ expected type parameter `T`, found integer | = note: expected type parameter `T` found type `{integer}` -note: tuple struct defined here - --> $DIR/issue-69306.rs:31:8 - | -LL | struct S1(T, U); - | ^^ error[E0308]: mismatched types --> $DIR/issue-69306.rs:33:27 @@ -102,19 +74,12 @@ LL | impl S2 { LL | fn map(x: U) -> S2 { | - found type parameter LL | Self(x) - | ---- ^ expected type parameter `T`, found type parameter `U` - | | - | arguments to this function are incorrect + | ^ expected type parameter `T`, found type parameter `U` | = note: expected type parameter `T` found type parameter `U` = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters -note: tuple struct defined here - --> $DIR/issue-69306.rs:38:8 - | -LL | struct S2(T); - | ^^ error[E0308]: mismatched types --> $DIR/issue-69306.rs:41:9 diff --git a/src/test/ui/macros/issue-29084.stderr b/src/test/ui/macros/issue-29084.stderr index f83e192130bdb..a973e23e29e4c 100644 --- a/src/test/ui/macros/issue-29084.stderr +++ b/src/test/ui/macros/issue-29084.stderr @@ -2,21 +2,11 @@ error[E0308]: mismatched types --> $DIR/issue-29084.rs:4:13 | LL | bar(&mut $d); - | --- ^^^^^^^ expected `u8`, found `&mut u8` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `u8`, found `&mut u8` ... LL | foo!(0u8); | --------- in this macro invocation | -note: function defined here - --> $DIR/issue-29084.rs:3:12 - | -LL | fn bar(d: u8) { } - | ^^^ ----- -... -LL | foo!(0u8); - | --------- in this macro invocation = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to previous error diff --git a/src/test/ui/methods/method-call-err-msg.stderr b/src/test/ui/methods/method-call-err-msg.stderr index 53e582f7f13a4..c410e076dde26 100644 --- a/src/test/ui/methods/method-call-err-msg.stderr +++ b/src/test/ui/methods/method-call-err-msg.stderr @@ -2,49 +2,43 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied --> $DIR/method-call-err-msg.rs:13:7 | LL | x.zero(0) - | ^^^^ - argument unexpected + | ^^^^ - supplied 1 argument + | | + | expected 0 arguments | note: associated function defined here --> $DIR/method-call-err-msg.rs:5:8 | LL | fn zero(self) -> Foo { self } | ^^^^ ---- -help: remove the extra argument - | -LL | x.zero() - | ~~~~~~ error[E0061]: this function takes 1 argument but 0 arguments were supplied --> $DIR/method-call-err-msg.rs:14:7 | LL | .one() - | ^^^-- an argument of type `isize` is missing + | ^^^- supplied 0 arguments + | | + | expected 1 argument | note: associated function defined here --> $DIR/method-call-err-msg.rs:6:8 | LL | fn one(self, _: isize) -> Foo { self } | ^^^ ---- -------- -help: provide the argument - | -LL | .one({isize}) - | ~~~~~~~~~~~~ error[E0061]: this function takes 2 arguments but 1 argument was supplied --> $DIR/method-call-err-msg.rs:15:7 | LL | .two(0); - | ^^^--- an argument of type `isize` is missing + | ^^^ - supplied 1 argument + | | + | expected 2 arguments | note: associated function defined here --> $DIR/method-call-err-msg.rs:7:8 | LL | fn two(self, _: isize, _: isize) -> Foo { self } | ^^^ ---- -------- -------- -help: provide the argument - | -LL | .two(0, {isize}); - | ~~~~~~~~~~~~~~~ error[E0599]: `Foo` is not an iterator --> $DIR/method-call-err-msg.rs:19:7 @@ -80,17 +74,15 @@ error[E0061]: this function takes 3 arguments but 0 arguments were supplied --> $DIR/method-call-err-msg.rs:21:7 | LL | y.three::(); - | ^^^^^^^^^^^^^^-- three arguments of type `usize`, `usize`, and `usize` are missing + | ^^^^^--------- supplied 0 arguments + | | + | expected 3 arguments | note: associated function defined here --> $DIR/method-call-err-msg.rs:8:8 | LL | fn three(self, _: T, _: T, _: T) -> Foo { self } | ^^^^^ ---- ---- ---- ---- -help: provide the arguments - | -LL | y.three::({usize}, {usize}, {usize}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to 5 previous errors diff --git a/src/test/ui/methods/method-self-arg-1.stderr b/src/test/ui/methods/method-self-arg-1.stderr index 01fec6fcaaeec..17ea61fc4bddb 100644 --- a/src/test/ui/methods/method-self-arg-1.stderr +++ b/src/test/ui/methods/method-self-arg-1.stderr @@ -2,33 +2,19 @@ error[E0308]: mismatched types --> $DIR/method-self-arg-1.rs:11:14 | LL | Foo::bar(x); - | -------- ^ - | | | - | | expected `&Foo`, found struct `Foo` - | | help: consider borrowing here: `&x` - | arguments to this function are incorrect - | -note: associated function defined here - --> $DIR/method-self-arg-1.rs:6:8 - | -LL | fn bar(&self) {} - | ^^^ ----- + | ^ + | | + | expected `&Foo`, found struct `Foo` + | help: consider borrowing here: `&x` error[E0308]: mismatched types --> $DIR/method-self-arg-1.rs:13:14 | LL | Foo::bar(&42); - | -------- ^^^ expected struct `Foo`, found integer - | | - | arguments to this function are incorrect + | ^^^ expected struct `Foo`, found integer | = note: expected reference `&Foo` found reference `&{integer}` -note: associated function defined here - --> $DIR/method-self-arg-1.rs:6:8 - | -LL | fn bar(&self) {} - | ^^^ ----- error: aborting due to 2 previous errors diff --git a/src/test/ui/mismatched_types/issue-26480.stderr b/src/test/ui/mismatched_types/issue-26480.stderr index ae10a00671e61..da8a976daaf1a 100644 --- a/src/test/ui/mismatched_types/issue-26480.stderr +++ b/src/test/ui/mismatched_types/issue-26480.stderr @@ -1,19 +1,12 @@ error[E0308]: mismatched types --> $DIR/issue-26480.rs:16:19 | -LL | write(stdout, $arr.as_ptr() as *const i8, - | ----- arguments to this function are incorrect LL | $arr.len() * size_of($arr[0])); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `u64`, found `usize` ... LL | write!(hello); | ------------- in this macro invocation | -note: function defined here - --> $DIR/issue-26480.rs:2:8 - | -LL | fn write(fildes: i32, buf: *const i8, nbyte: u64) -> i64; - | ^^^^^ = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info) help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit | diff --git a/src/test/ui/mismatched_types/issue-35030.stderr b/src/test/ui/mismatched_types/issue-35030.stderr index f0dea75001c2c..9f4e4398984ae 100644 --- a/src/test/ui/mismatched_types/issue-35030.stderr +++ b/src/test/ui/mismatched_types/issue-35030.stderr @@ -5,9 +5,7 @@ LL | impl Parser for bool { | ---- this type parameter LL | fn parse(text: &str) -> Option { LL | Some(true) - | ---- ^^^^ expected type parameter `bool`, found `bool` - | | - | arguments to this enum variant are incorrect + | ^^^^ expected type parameter `bool`, found `bool` | = note: expected type parameter `bool` (type parameter `bool`) found type `bool` (`bool`) diff --git a/src/test/ui/mismatched_types/numeric-literal-cast.stderr b/src/test/ui/mismatched_types/numeric-literal-cast.stderr index fcf3eccbcba2b..55e45a8f1625a 100644 --- a/src/test/ui/mismatched_types/numeric-literal-cast.stderr +++ b/src/test/ui/mismatched_types/numeric-literal-cast.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/numeric-literal-cast.rs:6:9 | LL | foo(1u8); - | --- ^^^ expected `u16`, found `u8` - | | - | arguments to this function are incorrect + | ^^^ expected `u16`, found `u8` | -note: function defined here - --> $DIR/numeric-literal-cast.rs:1:4 - | -LL | fn foo(_: u16) {} - | ^^^ ------ help: change the type of the numeric literal from `u8` to `u16` | LL | foo(1u16); @@ -20,15 +13,8 @@ error[E0308]: mismatched types --> $DIR/numeric-literal-cast.rs:8:10 | LL | foo1(2f32); - | ---- ^^^^ expected `f64`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-literal-cast.rs:2:4 + | ^^^^ expected `f64`, found `f32` | -LL | fn foo1(_: f64) {} - | ^^^^ ------ help: change the type of the numeric literal from `f32` to `f64` | LL | foo1(2f64); @@ -38,15 +24,8 @@ error[E0308]: mismatched types --> $DIR/numeric-literal-cast.rs:10:10 | LL | foo2(3i16); - | ---- ^^^^ expected `i32`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-literal-cast.rs:3:4 + | ^^^^ expected `i32`, found `i16` | -LL | fn foo2(_: i32) {} - | ^^^^ ------ help: change the type of the numeric literal from `i16` to `i32` | LL | foo2(3i32); diff --git a/src/test/ui/mismatched_types/overloaded-calls-bad.rs b/src/test/ui/mismatched_types/overloaded-calls-bad.rs index 902a6ec81d60b..9c07e83a2a159 100644 --- a/src/test/ui/mismatched_types/overloaded-calls-bad.rs +++ b/src/test/ui/mismatched_types/overloaded-calls-bad.rs @@ -21,13 +21,11 @@ impl FnOnce<(isize,)> for S { } fn main() { - let mut s = S { - x: 3, - y: 3, - }; - let ans = s("what"); //~ ERROR mismatched types + let mut s = S { x: 3, y: 3 }; + let ans = s("what"); //~ ERROR mismatched types let ans = s(); //~^ ERROR this function takes 1 argument but 0 arguments were supplied let ans = s("burma", "shave"); //~^ ERROR this function takes 1 argument but 2 arguments were supplied + //~| ERROR mismatched types } diff --git a/src/test/ui/mismatched_types/overloaded-calls-bad.stderr b/src/test/ui/mismatched_types/overloaded-calls-bad.stderr index a5742d6fe8c36..432c1b027a8cf 100644 --- a/src/test/ui/mismatched_types/overloaded-calls-bad.stderr +++ b/src/test/ui/mismatched_types/overloaded-calls-bad.stderr @@ -1,52 +1,44 @@ error[E0308]: mismatched types - --> $DIR/overloaded-calls-bad.rs:28:17 + --> $DIR/overloaded-calls-bad.rs:25:17 | LL | let ans = s("what"); - | - ^^^^^^ expected `isize`, found `&str` - | | - | arguments to this function are incorrect - | -note: associated function defined here - --> $SRC_DIR/core/src/ops/function.rs:LL:COL - | -LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; - | ^^^^^^^^ + | ^^^^^^ expected `isize`, found `&str` error[E0057]: this function takes 1 argument but 0 arguments were supplied - --> $DIR/overloaded-calls-bad.rs:29:15 + --> $DIR/overloaded-calls-bad.rs:26:15 | LL | let ans = s(); - | ^-- an argument of type `isize` is missing + | ^-- supplied 0 arguments + | | + | expected 1 argument | note: associated function defined here --> $SRC_DIR/core/src/ops/function.rs:LL:COL | LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; | ^^^^^^^^ -help: provide the argument + +error[E0308]: mismatched types + --> $DIR/overloaded-calls-bad.rs:28:17 | -LL | let ans = s({isize}); - | ~~~~~~~~~~ +LL | let ans = s("burma", "shave"); + | ^^^^^^^ expected `isize`, found `&str` error[E0057]: this function takes 1 argument but 2 arguments were supplied - --> $DIR/overloaded-calls-bad.rs:31:15 + --> $DIR/overloaded-calls-bad.rs:28:15 | LL | let ans = s("burma", "shave"); - | ^ ------- ------- argument unexpected - | | - | expected `isize`, found `&str` + | ^ ------- ------- supplied 2 arguments + | | + | expected 1 argument | note: associated function defined here --> $SRC_DIR/core/src/ops/function.rs:LL:COL | LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; | ^^^^^^^^ -help: remove the extra argument - | -LL | let ans = s({isize}); - | ~~~~~~~~~~ -error: aborting due to 3 previous errors +error: aborting due to 4 previous errors Some errors have detailed explanations: E0057, E0308. For more information about an error, try `rustc --explain E0057`. diff --git a/src/test/ui/mismatched_types/trait-bounds-cant-coerce.stderr b/src/test/ui/mismatched_types/trait-bounds-cant-coerce.stderr index 80aef7fcbe8e2..485fae6d4d9ff 100644 --- a/src/test/ui/mismatched_types/trait-bounds-cant-coerce.stderr +++ b/src/test/ui/mismatched_types/trait-bounds-cant-coerce.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/trait-bounds-cant-coerce.rs:13:7 | LL | a(x); - | - ^ expected trait `Foo + Send`, found trait `Foo` - | | - | arguments to this function are incorrect + | ^ expected trait `Foo + Send`, found trait `Foo` | = note: expected struct `Box<(dyn Foo + Send + 'static)>` found struct `Box<(dyn Foo + 'static)>` -note: function defined here - --> $DIR/trait-bounds-cant-coerce.rs:5:4 - | -LL | fn a(_x: Box) { - | ^ ----------------------- error: aborting due to previous error diff --git a/src/test/ui/mut/mut-cross-borrowing.stderr b/src/test/ui/mut/mut-cross-borrowing.stderr index ee739d6286a51..b77813f8af0b4 100644 --- a/src/test/ui/mut/mut-cross-borrowing.stderr +++ b/src/test/ui/mut/mut-cross-borrowing.stderr @@ -2,19 +2,13 @@ error[E0308]: mismatched types --> $DIR/mut-cross-borrowing.rs:7:7 | LL | f(x) - | - ^ - | | | - | | expected `&mut isize`, found struct `Box` - | | help: consider mutably borrowing here: `&mut x` - | arguments to this function are incorrect + | ^ + | | + | expected `&mut isize`, found struct `Box` + | help: consider mutably borrowing here: `&mut x` | = note: expected mutable reference `&mut isize` found struct `Box<{integer}>` -note: function defined here - --> $DIR/mut-cross-borrowing.rs:1:4 - | -LL | fn f(_: &mut isize) {} - | ^ ------------- error: aborting due to previous error diff --git a/src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr b/src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr index fa3db33c9606f..eacef1dc3302d 100644 --- a/src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr +++ b/src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/call-fn-never-arg-wrong-type.rs:10:9 | LL | foo("wow"); - | --- ^^^^^ expected `!`, found `&str` - | | - | arguments to this function are incorrect + | ^^^^^ expected `!`, found `&str` | = note: expected type `!` found reference `&'static str` -note: function defined here - --> $DIR/call-fn-never-arg-wrong-type.rs:5:4 - | -LL | fn foo(x: !) -> ! { - | ^^^ ---- error: aborting due to previous error diff --git a/src/test/ui/never_type/issue-96335.stderr b/src/test/ui/never_type/issue-96335.stderr index 168cf2f83535d..e9e8b5327c8b4 100644 --- a/src/test/ui/never_type/issue-96335.stderr +++ b/src/test/ui/never_type/issue-96335.stderr @@ -17,18 +17,10 @@ error[E0308]: mismatched types --> $DIR/issue-96335.rs:2:9 | LL | 0.....{loop{}1}; - | ----^^^^^^^^^^^ - | | | - | | expected integer, found struct `RangeTo` - | arguments to this function are incorrect + | ^^^^^^^^^^^ expected integer, found struct `RangeTo` | = note: expected type `{integer}` found struct `RangeTo<{integer}>` -note: associated function defined here - --> $SRC_DIR/core/src/ops/range.rs:LL:COL - | -LL | pub const fn new(start: Idx, end: Idx) -> Self { - | ^^^ error: aborting due to 2 previous errors diff --git a/src/test/ui/not-enough-arguments.stderr b/src/test/ui/not-enough-arguments.stderr index 4f502acc95cbe..df95783724148 100644 --- a/src/test/ui/not-enough-arguments.stderr +++ b/src/test/ui/not-enough-arguments.stderr @@ -2,23 +2,23 @@ error[E0061]: this function takes 4 arguments but 3 arguments were supplied --> $DIR/not-enough-arguments.rs:27:3 | LL | foo(1, 2, 3); - | ^^^--------- an argument of type `isize` is missing + | ^^^ - - - supplied 3 arguments + | | + | expected 4 arguments | note: function defined here --> $DIR/not-enough-arguments.rs:5:4 | LL | fn foo(a: isize, b: isize, c: isize, d:isize) { | ^^^ -------- -------- -------- ------- -help: provide the argument - | -LL | foo(1, 2, 3, {isize}); - | ~~~~~~~~~~~~~~~~~~~~~ error[E0061]: this function takes 6 arguments but 3 arguments were supplied --> $DIR/not-enough-arguments.rs:29:3 | LL | bar(1, 2, 3); - | ^^^--------- three arguments of type `i32`, `i32`, and `i32` are missing + | ^^^ - - - supplied 3 arguments + | | + | expected 6 arguments | note: function defined here --> $DIR/not-enough-arguments.rs:10:4 @@ -37,10 +37,6 @@ LL | e: i32, | ------ LL | f: i32, | ------ -help: provide the arguments - | -LL | bar(1, 2, 3, {i32}, {i32}, {i32}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to 2 previous errors diff --git a/src/test/ui/numeric/integer-literal-suffix-inference.stderr b/src/test/ui/numeric/integer-literal-suffix-inference.stderr index 5045f584c8977..4c29c4a1cb05c 100644 --- a/src/test/ui/numeric/integer-literal-suffix-inference.stderr +++ b/src/test/ui/numeric/integer-literal-suffix-inference.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:38:11 | LL | id_i8(a16); - | ----- ^^^ expected `i8`, found `i16` - | | - | arguments to this function are incorrect + | ^^^ expected `i8`, found `i16` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:15:8 - | -LL | fn id_i8(n: i8) -> i8 { n } - | ^^^^^ ----- help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit | LL | id_i8(a16.try_into().unwrap()); @@ -20,15 +13,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:41:11 | LL | id_i8(a32); - | ----- ^^^ expected `i8`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:15:8 + | ^^^ expected `i8`, found `i32` | -LL | fn id_i8(n: i8) -> i8 { n } - | ^^^^^ ----- help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit | LL | id_i8(a32.try_into().unwrap()); @@ -38,15 +24,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:44:11 | LL | id_i8(a64); - | ----- ^^^ expected `i8`, found `i64` - | | - | arguments to this function are incorrect + | ^^^ expected `i8`, found `i64` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:15:8 - | -LL | fn id_i8(n: i8) -> i8 { n } - | ^^^^^ ----- help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit | LL | id_i8(a64.try_into().unwrap()); @@ -56,15 +35,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:47:11 | LL | id_i8(asize); - | ----- ^^^^^ expected `i8`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:15:8 + | ^^^^^ expected `i8`, found `isize` | -LL | fn id_i8(n: i8) -> i8 { n } - | ^^^^^ ----- help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit | LL | id_i8(asize.try_into().unwrap()); @@ -74,15 +46,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:51:12 | LL | id_i16(a8); - | ------ ^^ expected `i16`, found `i8` - | | - | arguments to this function are incorrect + | ^^ expected `i16`, found `i8` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:16:8 - | -LL | fn id_i16(n: i16) -> i16 { n } - | ^^^^^^ ------ help: you can convert an `i8` to an `i16` | LL | id_i16(a8.into()); @@ -92,15 +57,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:55:12 | LL | id_i16(a32); - | ------ ^^^ expected `i16`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:16:8 + | ^^^ expected `i16`, found `i32` | -LL | fn id_i16(n: i16) -> i16 { n } - | ^^^^^^ ------ help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit | LL | id_i16(a32.try_into().unwrap()); @@ -110,15 +68,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:58:12 | LL | id_i16(a64); - | ------ ^^^ expected `i16`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:16:8 + | ^^^ expected `i16`, found `i64` | -LL | fn id_i16(n: i16) -> i16 { n } - | ^^^^^^ ------ help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit | LL | id_i16(a64.try_into().unwrap()); @@ -128,15 +79,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:61:12 | LL | id_i16(asize); - | ------ ^^^^^ expected `i16`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i16`, found `isize` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:16:8 - | -LL | fn id_i16(n: i16) -> i16 { n } - | ^^^^^^ ------ help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit | LL | id_i16(asize.try_into().unwrap()); @@ -146,15 +90,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:65:12 | LL | id_i32(a8); - | ------ ^^ expected `i32`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:17:8 + | ^^ expected `i32`, found `i8` | -LL | fn id_i32(n: i32) -> i32 { n } - | ^^^^^^ ------ help: you can convert an `i8` to an `i32` | LL | id_i32(a8.into()); @@ -164,15 +101,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:68:12 | LL | id_i32(a16); - | ------ ^^^ expected `i32`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:17:8 + | ^^^ expected `i32`, found `i16` | -LL | fn id_i32(n: i32) -> i32 { n } - | ^^^^^^ ------ help: you can convert an `i16` to an `i32` | LL | id_i32(a16.into()); @@ -182,15 +112,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:72:12 | LL | id_i32(a64); - | ------ ^^^ expected `i32`, found `i64` - | | - | arguments to this function are incorrect + | ^^^ expected `i32`, found `i64` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:17:8 - | -LL | fn id_i32(n: i32) -> i32 { n } - | ^^^^^^ ------ help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit | LL | id_i32(a64.try_into().unwrap()); @@ -200,15 +123,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:75:12 | LL | id_i32(asize); - | ------ ^^^^^ expected `i32`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:17:8 + | ^^^^^ expected `i32`, found `isize` | -LL | fn id_i32(n: i32) -> i32 { n } - | ^^^^^^ ------ help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit | LL | id_i32(asize.try_into().unwrap()); @@ -218,15 +134,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:79:12 | LL | id_i64(a8); - | ------ ^^ expected `i64`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:18:8 + | ^^ expected `i64`, found `i8` | -LL | fn id_i64(n: i64) -> i64 { n } - | ^^^^^^ ------ help: you can convert an `i8` to an `i64` | LL | id_i64(a8.into()); @@ -236,15 +145,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:82:12 | LL | id_i64(a16); - | ------ ^^^ expected `i64`, found `i16` - | | - | arguments to this function are incorrect + | ^^^ expected `i64`, found `i16` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:18:8 - | -LL | fn id_i64(n: i64) -> i64 { n } - | ^^^^^^ ------ help: you can convert an `i16` to an `i64` | LL | id_i64(a16.into()); @@ -254,15 +156,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:85:12 | LL | id_i64(a32); - | ------ ^^^ expected `i64`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:18:8 + | ^^^ expected `i64`, found `i32` | -LL | fn id_i64(n: i64) -> i64 { n } - | ^^^^^^ ------ help: you can convert an `i32` to an `i64` | LL | id_i64(a32.into()); @@ -272,15 +167,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:89:12 | LL | id_i64(asize); - | ------ ^^^^^ expected `i64`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i64`, found `isize` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:18:8 - | -LL | fn id_i64(n: i64) -> i64 { n } - | ^^^^^^ ------ help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit | LL | id_i64(asize.try_into().unwrap()); @@ -290,15 +178,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:93:14 | LL | id_isize(a8); - | -------- ^^ expected `isize`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:19:8 + | ^^ expected `isize`, found `i8` | -LL | fn id_isize(n: isize) -> isize { n } - | ^^^^^^^^ -------- help: you can convert an `i8` to an `isize` | LL | id_isize(a8.into()); @@ -308,15 +189,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:96:14 | LL | id_isize(a16); - | -------- ^^^ expected `isize`, found `i16` - | | - | arguments to this function are incorrect + | ^^^ expected `isize`, found `i16` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:19:8 - | -LL | fn id_isize(n: isize) -> isize { n } - | ^^^^^^^^ -------- help: you can convert an `i16` to an `isize` | LL | id_isize(a16.into()); @@ -326,15 +200,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:99:14 | LL | id_isize(a32); - | -------- ^^^ expected `isize`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:19:8 + | ^^^ expected `isize`, found `i32` | -LL | fn id_isize(n: isize) -> isize { n } - | ^^^^^^^^ -------- help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit | LL | id_isize(a32.try_into().unwrap()); @@ -344,15 +211,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:102:14 | LL | id_isize(a64); - | -------- ^^^ expected `isize`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:19:8 + | ^^^ expected `isize`, found `i64` | -LL | fn id_isize(n: isize) -> isize { n } - | ^^^^^^^^ -------- help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit | LL | id_isize(a64.try_into().unwrap()); @@ -362,15 +222,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:108:11 | LL | id_i8(c16); - | ----- ^^^ expected `i8`, found `i16` - | | - | arguments to this function are incorrect + | ^^^ expected `i8`, found `i16` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:15:8 - | -LL | fn id_i8(n: i8) -> i8 { n } - | ^^^^^ ----- help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit | LL | id_i8(c16.try_into().unwrap()); @@ -380,15 +233,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:111:11 | LL | id_i8(c32); - | ----- ^^^ expected `i8`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:15:8 + | ^^^ expected `i8`, found `i32` | -LL | fn id_i8(n: i8) -> i8 { n } - | ^^^^^ ----- help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit | LL | id_i8(c32.try_into().unwrap()); @@ -398,15 +244,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:114:11 | LL | id_i8(c64); - | ----- ^^^ expected `i8`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:15:8 + | ^^^ expected `i8`, found `i64` | -LL | fn id_i8(n: i8) -> i8 { n } - | ^^^^^ ----- help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit | LL | id_i8(c64.try_into().unwrap()); @@ -416,15 +255,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:118:12 | LL | id_i16(c8); - | ------ ^^ expected `i16`, found `i8` - | | - | arguments to this function are incorrect + | ^^ expected `i16`, found `i8` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:16:8 - | -LL | fn id_i16(n: i16) -> i16 { n } - | ^^^^^^ ------ help: you can convert an `i8` to an `i16` | LL | id_i16(c8.into()); @@ -434,15 +266,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:122:12 | LL | id_i16(c32); - | ------ ^^^ expected `i16`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:16:8 + | ^^^ expected `i16`, found `i32` | -LL | fn id_i16(n: i16) -> i16 { n } - | ^^^^^^ ------ help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit | LL | id_i16(c32.try_into().unwrap()); @@ -452,15 +277,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:125:12 | LL | id_i16(c64); - | ------ ^^^ expected `i16`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:16:8 + | ^^^ expected `i16`, found `i64` | -LL | fn id_i16(n: i16) -> i16 { n } - | ^^^^^^ ------ help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit | LL | id_i16(c64.try_into().unwrap()); @@ -470,15 +288,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:129:12 | LL | id_i32(c8); - | ------ ^^ expected `i32`, found `i8` - | | - | arguments to this function are incorrect + | ^^ expected `i32`, found `i8` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:17:8 - | -LL | fn id_i32(n: i32) -> i32 { n } - | ^^^^^^ ------ help: you can convert an `i8` to an `i32` | LL | id_i32(c8.into()); @@ -488,15 +299,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:132:12 | LL | id_i32(c16); - | ------ ^^^ expected `i32`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:17:8 + | ^^^ expected `i32`, found `i16` | -LL | fn id_i32(n: i32) -> i32 { n } - | ^^^^^^ ------ help: you can convert an `i16` to an `i32` | LL | id_i32(c16.into()); @@ -506,15 +310,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:136:12 | LL | id_i32(c64); - | ------ ^^^ expected `i32`, found `i64` - | | - | arguments to this function are incorrect + | ^^^ expected `i32`, found `i64` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:17:8 - | -LL | fn id_i32(n: i32) -> i32 { n } - | ^^^^^^ ------ help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit | LL | id_i32(c64.try_into().unwrap()); @@ -524,15 +321,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:140:12 | LL | id_i64(a8); - | ------ ^^ expected `i64`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:18:8 + | ^^ expected `i64`, found `i8` | -LL | fn id_i64(n: i64) -> i64 { n } - | ^^^^^^ ------ help: you can convert an `i8` to an `i64` | LL | id_i64(a8.into()); @@ -542,15 +332,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:143:12 | LL | id_i64(a16); - | ------ ^^^ expected `i64`, found `i16` - | | - | arguments to this function are incorrect + | ^^^ expected `i64`, found `i16` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:18:8 - | -LL | fn id_i64(n: i64) -> i64 { n } - | ^^^^^^ ------ help: you can convert an `i16` to an `i64` | LL | id_i64(a16.into()); @@ -560,15 +343,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:146:12 | LL | id_i64(a32); - | ------ ^^^ expected `i64`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:18:8 + | ^^^ expected `i64`, found `i32` | -LL | fn id_i64(n: i64) -> i64 { n } - | ^^^^^^ ------ help: you can convert an `i32` to an `i64` | LL | id_i64(a32.into()); @@ -578,15 +354,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:152:11 | LL | id_u8(b16); - | ----- ^^^ expected `u8`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:27:8 + | ^^^ expected `u8`, found `u16` | -LL | fn id_u8(n: u8) -> u8 { n } - | ^^^^^ ----- help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit | LL | id_u8(b16.try_into().unwrap()); @@ -596,15 +365,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:155:11 | LL | id_u8(b32); - | ----- ^^^ expected `u8`, found `u32` - | | - | arguments to this function are incorrect + | ^^^ expected `u8`, found `u32` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:27:8 - | -LL | fn id_u8(n: u8) -> u8 { n } - | ^^^^^ ----- help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit | LL | id_u8(b32.try_into().unwrap()); @@ -614,15 +376,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:158:11 | LL | id_u8(b64); - | ----- ^^^ expected `u8`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:27:8 + | ^^^ expected `u8`, found `u64` | -LL | fn id_u8(n: u8) -> u8 { n } - | ^^^^^ ----- help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit | LL | id_u8(b64.try_into().unwrap()); @@ -632,15 +387,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:161:11 | LL | id_u8(bsize); - | ----- ^^^^^ expected `u8`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:27:8 + | ^^^^^ expected `u8`, found `usize` | -LL | fn id_u8(n: u8) -> u8 { n } - | ^^^^^ ----- help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit | LL | id_u8(bsize.try_into().unwrap()); @@ -650,15 +398,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:165:12 | LL | id_u16(b8); - | ------ ^^ expected `u16`, found `u8` - | | - | arguments to this function are incorrect + | ^^ expected `u16`, found `u8` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:28:8 - | -LL | fn id_u16(n: u16) -> u16 { n } - | ^^^^^^ ------ help: you can convert a `u8` to a `u16` | LL | id_u16(b8.into()); @@ -668,15 +409,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:169:12 | LL | id_u16(b32); - | ------ ^^^ expected `u16`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:28:8 + | ^^^ expected `u16`, found `u32` | -LL | fn id_u16(n: u16) -> u16 { n } - | ^^^^^^ ------ help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit | LL | id_u16(b32.try_into().unwrap()); @@ -686,15 +420,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:172:12 | LL | id_u16(b64); - | ------ ^^^ expected `u16`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:28:8 + | ^^^ expected `u16`, found `u64` | -LL | fn id_u16(n: u16) -> u16 { n } - | ^^^^^^ ------ help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit | LL | id_u16(b64.try_into().unwrap()); @@ -704,15 +431,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:175:12 | LL | id_u16(bsize); - | ------ ^^^^^ expected `u16`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u16`, found `usize` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:28:8 - | -LL | fn id_u16(n: u16) -> u16 { n } - | ^^^^^^ ------ help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit | LL | id_u16(bsize.try_into().unwrap()); @@ -722,15 +442,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:179:12 | LL | id_u32(b8); - | ------ ^^ expected `u32`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:29:8 + | ^^ expected `u32`, found `u8` | -LL | fn id_u32(n: u32) -> u32 { n } - | ^^^^^^ ------ help: you can convert a `u8` to a `u32` | LL | id_u32(b8.into()); @@ -740,15 +453,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:182:12 | LL | id_u32(b16); - | ------ ^^^ expected `u32`, found `u16` - | | - | arguments to this function are incorrect + | ^^^ expected `u32`, found `u16` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:29:8 - | -LL | fn id_u32(n: u32) -> u32 { n } - | ^^^^^^ ------ help: you can convert a `u16` to a `u32` | LL | id_u32(b16.into()); @@ -758,15 +464,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:186:12 | LL | id_u32(b64); - | ------ ^^^ expected `u32`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:29:8 + | ^^^ expected `u32`, found `u64` | -LL | fn id_u32(n: u32) -> u32 { n } - | ^^^^^^ ------ help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit | LL | id_u32(b64.try_into().unwrap()); @@ -776,15 +475,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:189:12 | LL | id_u32(bsize); - | ------ ^^^^^ expected `u32`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u32`, found `usize` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:29:8 - | -LL | fn id_u32(n: u32) -> u32 { n } - | ^^^^^^ ------ help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit | LL | id_u32(bsize.try_into().unwrap()); @@ -794,15 +486,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:193:12 | LL | id_u64(b8); - | ------ ^^ expected `u64`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:30:8 + | ^^ expected `u64`, found `u8` | -LL | fn id_u64(n: u64) -> u64 { n } - | ^^^^^^ ------ help: you can convert a `u8` to a `u64` | LL | id_u64(b8.into()); @@ -812,15 +497,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:196:12 | LL | id_u64(b16); - | ------ ^^^ expected `u64`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:30:8 + | ^^^ expected `u64`, found `u16` | -LL | fn id_u64(n: u64) -> u64 { n } - | ^^^^^^ ------ help: you can convert a `u16` to a `u64` | LL | id_u64(b16.into()); @@ -830,15 +508,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:199:12 | LL | id_u64(b32); - | ------ ^^^ expected `u64`, found `u32` - | | - | arguments to this function are incorrect + | ^^^ expected `u64`, found `u32` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:30:8 - | -LL | fn id_u64(n: u64) -> u64 { n } - | ^^^^^^ ------ help: you can convert a `u32` to a `u64` | LL | id_u64(b32.into()); @@ -848,15 +519,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:203:12 | LL | id_u64(bsize); - | ------ ^^^^^ expected `u64`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:30:8 + | ^^^^^ expected `u64`, found `usize` | -LL | fn id_u64(n: u64) -> u64 { n } - | ^^^^^^ ------ help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit | LL | id_u64(bsize.try_into().unwrap()); @@ -866,15 +530,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:207:14 | LL | id_usize(b8); - | -------- ^^ expected `usize`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:31:8 + | ^^ expected `usize`, found `u8` | -LL | fn id_usize(n: usize) -> usize { n } - | ^^^^^^^^ -------- help: you can convert a `u8` to a `usize` | LL | id_usize(b8.into()); @@ -884,15 +541,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:210:14 | LL | id_usize(b16); - | -------- ^^^ expected `usize`, found `u16` - | | - | arguments to this function are incorrect + | ^^^ expected `usize`, found `u16` | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:31:8 - | -LL | fn id_usize(n: usize) -> usize { n } - | ^^^^^^^^ -------- help: you can convert a `u16` to a `usize` | LL | id_usize(b16.into()); @@ -902,15 +552,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:213:14 | LL | id_usize(b32); - | -------- ^^^ expected `usize`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:31:8 + | ^^^ expected `usize`, found `u32` | -LL | fn id_usize(n: usize) -> usize { n } - | ^^^^^^^^ -------- help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit | LL | id_usize(b32.try_into().unwrap()); @@ -920,15 +563,8 @@ error[E0308]: mismatched types --> $DIR/integer-literal-suffix-inference.rs:216:14 | LL | id_usize(b64); - | -------- ^^^ expected `usize`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/integer-literal-suffix-inference.rs:31:8 + | ^^^ expected `usize`, found `u64` | -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()); diff --git a/src/test/ui/numeric/len.stderr b/src/test/ui/numeric/len.stderr index 55a61b5e44379..6319c1ead24ee 100644 --- a/src/test/ui/numeric/len.stderr +++ b/src/test/ui/numeric/len.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/len.rs:3:10 | LL | test(array.len()); - | ---- ^^^^^^^^^^^ expected `u32`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^ expected `u32`, found `usize` | -note: function defined here - --> $DIR/len.rs:6:4 - | -LL | fn test(length: u32) { - | ^^^^ ----------- help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit | LL | test(array.len().try_into().unwrap()); diff --git a/src/test/ui/numeric/numeric-cast-without-suggestion.stderr b/src/test/ui/numeric/numeric-cast-without-suggestion.stderr index 581b548abcac4..a96518a34342d 100644 --- a/src/test/ui/numeric/numeric-cast-without-suggestion.stderr +++ b/src/test/ui/numeric/numeric-cast-without-suggestion.stderr @@ -2,295 +2,127 @@ error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:17:18 | LL | foo::(x_f64); - | ------------ ^^^^^ expected `usize`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `usize`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:18:18 | LL | foo::(x_f32); - | ------------ ^^^^^ expected `usize`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `usize`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:19:18 | LL | foo::(x_f64); - | ------------ ^^^^^ expected `isize`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `isize`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:20:18 | LL | foo::(x_f32); - | ------------ ^^^^^ expected `isize`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `isize`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:21:16 | LL | foo::(x_f64); - | ---------- ^^^^^ expected `u64`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `u64`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:22:16 | LL | foo::(x_f32); - | ---------- ^^^^^ expected `u64`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `u64`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:23:16 | LL | foo::(x_f64); - | ---------- ^^^^^ expected `i64`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `i64`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:24:16 | LL | foo::(x_f32); - | ---------- ^^^^^ expected `i64`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `i64`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:25:16 | LL | foo::(x_f64); - | ---------- ^^^^^ expected `u32`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `u32`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:26:16 | LL | foo::(x_f32); - | ---------- ^^^^^ expected `u32`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `u32`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:27:16 | LL | foo::(x_f64); - | ---------- ^^^^^ expected `i32`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `i32`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:28:16 | LL | foo::(x_f32); - | ---------- ^^^^^ expected `i32`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `i32`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:29:16 | LL | foo::(x_f64); - | ---------- ^^^^^ expected `u16`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `u16`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:30:16 | LL | foo::(x_f32); - | ---------- ^^^^^ expected `u16`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `u16`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:31:16 | LL | foo::(x_f64); - | ---------- ^^^^^ expected `i16`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `i16`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:32:16 | LL | foo::(x_f32); - | ---------- ^^^^^ expected `i16`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `i16`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:33:15 | LL | foo::(x_f64); - | --------- ^^^^^ expected `u8`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `u8`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:34:15 | LL | foo::(x_f32); - | --------- ^^^^^ expected `u8`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `u8`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:35:15 | LL | foo::(x_f64); - | --------- ^^^^^ expected `i8`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `i8`, found `f64` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:36:15 | LL | foo::(x_f32); - | --------- ^^^^^ expected `i8`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `i8`, found `f32` error[E0308]: mismatched types --> $DIR/numeric-cast-without-suggestion.rs:37:16 | LL | foo::(x_f64); - | ---------- ^^^^^ expected `f32`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast-without-suggestion.rs:1:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- + | ^^^^^ expected `f32`, found `f64` error: aborting due to 21 previous errors diff --git a/src/test/ui/numeric/numeric-cast.stderr b/src/test/ui/numeric/numeric-cast.stderr index d347875d5a947..b8f2d88ab4957 100644 --- a/src/test/ui/numeric/numeric-cast.stderr +++ b/src/test/ui/numeric/numeric-cast.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:23:18 | LL | foo::(x_u64); - | ------------ ^^^^^ expected `usize`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^ expected `usize`, found `u64` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -20,15 +13,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:25:18 | LL | foo::(x_u32); - | ------------ ^^^^^ expected `usize`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `usize`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit | LL | foo::(x_u32.try_into().unwrap()); @@ -38,15 +24,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:27:18 | LL | foo::(x_u16); - | ------------ ^^^^^ expected `usize`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `usize`, found `u16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to a `usize` | LL | foo::(x_u16.into()); @@ -56,15 +35,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:29:18 | LL | foo::(x_u8); - | ------------ ^^^^ expected `usize`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `usize`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to a `usize` | LL | foo::(x_u8.into()); @@ -74,15 +46,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:31:18 | LL | foo::(x_isize); - | ------------ ^^^^^^^ expected `usize`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `usize`, found `isize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -92,15 +57,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:33:18 | LL | foo::(x_i64); - | ------------ ^^^^^ expected `usize`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `usize`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to a `usize` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -110,15 +68,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:35:18 | LL | foo::(x_i32); - | ------------ ^^^^^ expected `usize`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `usize`, found `i32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit | LL | foo::(x_i32.try_into().unwrap()); @@ -128,15 +79,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:37:18 | LL | foo::(x_i16); - | ------------ ^^^^^ expected `usize`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `usize`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to a `usize` and panic if the converted value doesn't fit | LL | foo::(x_i16.try_into().unwrap()); @@ -146,15 +90,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:39:18 | LL | foo::(x_i8); - | ------------ ^^^^ expected `usize`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^ expected `usize`, found `i8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to a `usize` and panic if the converted value doesn't fit | LL | foo::(x_i8.try_into().unwrap()); @@ -164,15 +101,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:44:18 | LL | foo::(x_usize); - | ------------ ^^^^^^^ expected `isize`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `isize`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -182,15 +112,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:46:18 | LL | foo::(x_u64); - | ------------ ^^^^^ expected `isize`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^ expected `isize`, found `u64` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to an `isize` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -200,15 +123,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:48:18 | LL | foo::(x_u32); - | ------------ ^^^^^ expected `isize`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `isize`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to an `isize` and panic if the converted value doesn't fit | LL | foo::(x_u32.try_into().unwrap()); @@ -218,15 +134,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:50:18 | LL | foo::(x_u16); - | ------------ ^^^^^ expected `isize`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `isize`, found `u16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `isize` and panic if the converted value doesn't fit | LL | foo::(x_u16.try_into().unwrap()); @@ -236,15 +145,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:52:18 | LL | foo::(x_u8); - | ------------ ^^^^ expected `isize`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `isize`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `isize` | LL | foo::(x_u8.into()); @@ -254,15 +156,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:55:18 | LL | foo::(x_i64); - | ------------ ^^^^^ expected `isize`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `isize`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -272,15 +167,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:57:18 | LL | foo::(x_i32); - | ------------ ^^^^^ expected `isize`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `isize`, found `i32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit | LL | foo::(x_i32.try_into().unwrap()); @@ -290,15 +178,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:59:18 | LL | foo::(x_i16); - | ------------ ^^^^^ expected `isize`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `isize`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to an `isize` | LL | foo::(x_i16.into()); @@ -308,15 +189,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:61:18 | LL | foo::(x_i8); - | ------------ ^^^^ expected `isize`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^ expected `isize`, found `i8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `isize` | LL | foo::(x_i8.into()); @@ -326,15 +200,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:66:16 | LL | foo::(x_usize); - | ---------- ^^^^^^^ expected `u64`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `u64`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -344,15 +211,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:69:16 | LL | foo::(x_u32); - | ---------- ^^^^^ expected `u64`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u64`, found `u32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to a `u64` | LL | foo::(x_u32.into()); @@ -362,15 +222,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:71:16 | LL | foo::(x_u16); - | ---------- ^^^^^ expected `u64`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u64`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to a `u64` | LL | foo::(x_u16.into()); @@ -380,15 +233,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:73:16 | LL | foo::(x_u8); - | ---------- ^^^^ expected `u64`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `u64`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to a `u64` | LL | foo::(x_u8.into()); @@ -398,15 +244,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:75:16 | LL | foo::(x_isize); - | ---------- ^^^^^^^ expected `u64`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `u64`, found `isize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to a `u64` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -416,15 +255,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:77:16 | LL | foo::(x_i64); - | ---------- ^^^^^ expected `u64`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u64`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to a `u64` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -434,15 +266,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:79:16 | LL | foo::(x_i32); - | ---------- ^^^^^ expected `u64`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u64`, found `i32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit | LL | foo::(x_i32.try_into().unwrap()); @@ -452,15 +277,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:81:16 | LL | foo::(x_i16); - | ---------- ^^^^^ expected `u64`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u64`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to a `u64` and panic if the converted value doesn't fit | LL | foo::(x_i16.try_into().unwrap()); @@ -470,15 +288,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:83:16 | LL | foo::(x_i8); - | ---------- ^^^^ expected `u64`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^ expected `u64`, found `i8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to a `u64` and panic if the converted value doesn't fit | LL | foo::(x_i8.try_into().unwrap()); @@ -488,15 +299,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:88:16 | LL | foo::(x_usize); - | ---------- ^^^^^^^ expected `i64`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `i64`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to an `i64` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -506,15 +310,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:90:16 | LL | foo::(x_u64); - | ---------- ^^^^^ expected `i64`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i64`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to an `i64` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -524,15 +321,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:92:16 | LL | foo::(x_u32); - | ---------- ^^^^^ expected `i64`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i64`, found `u32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to an `i64` | LL | foo::(x_u32.into()); @@ -542,15 +332,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:94:16 | LL | foo::(x_u16); - | ---------- ^^^^^ expected `i64`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i64`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `i64` | LL | foo::(x_u16.into()); @@ -560,15 +343,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:96:16 | LL | foo::(x_u8); - | ---------- ^^^^ expected `i64`, found `u8` - | | - | arguments to this function are incorrect + | ^^^^ expected `i64`, found `u8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `i64` | LL | foo::(x_u8.into()); @@ -578,15 +354,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:98:16 | LL | foo::(x_isize); - | ---------- ^^^^^^^ expected `i64`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `i64`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -596,15 +365,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:101:16 | LL | foo::(x_i32); - | ---------- ^^^^^ expected `i64`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i64`, found `i32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to an `i64` | LL | foo::(x_i32.into()); @@ -614,15 +376,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:103:16 | LL | foo::(x_i16); - | ---------- ^^^^^ expected `i64`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i64`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to an `i64` | LL | foo::(x_i16.into()); @@ -632,15 +387,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:105:16 | LL | foo::(x_i8); - | ---------- ^^^^ expected `i64`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `i64`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `i64` | LL | foo::(x_i8.into()); @@ -650,15 +398,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:110:16 | LL | foo::(x_usize); - | ---------- ^^^^^^^ expected `u32`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `u32`, found `usize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -668,15 +409,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:112:16 | LL | foo::(x_u64); - | ---------- ^^^^^ expected `u32`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u32`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -686,15 +420,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:115:16 | LL | foo::(x_u16); - | ---------- ^^^^^ expected `u32`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u32`, found `u16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to a `u32` | LL | foo::(x_u16.into()); @@ -704,15 +431,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:117:16 | LL | foo::(x_u8); - | ---------- ^^^^ expected `u32`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `u32`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to a `u32` | LL | foo::(x_u8.into()); @@ -722,15 +442,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:119:16 | LL | foo::(x_isize); - | ---------- ^^^^^^^ expected `u32`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `u32`, found `isize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to a `u32` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -740,15 +453,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:121:16 | LL | foo::(x_i64); - | ---------- ^^^^^ expected `u32`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u32`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to a `u32` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -758,15 +464,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:123:16 | LL | foo::(x_i32); - | ---------- ^^^^^ expected `u32`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u32`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit | LL | foo::(x_i32.try_into().unwrap()); @@ -776,15 +475,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:125:16 | LL | foo::(x_i16); - | ---------- ^^^^^ expected `u32`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u32`, found `i16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to a `u32` and panic if the converted value doesn't fit | LL | foo::(x_i16.try_into().unwrap()); @@ -794,15 +486,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:127:16 | LL | foo::(x_i8); - | ---------- ^^^^ expected `u32`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `u32`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to a `u32` and panic if the converted value doesn't fit | LL | foo::(x_i8.try_into().unwrap()); @@ -812,15 +497,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:132:16 | LL | foo::(x_usize); - | ---------- ^^^^^^^ expected `i32`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `i32`, found `usize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to an `i32` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -830,15 +508,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:134:16 | LL | foo::(x_u64); - | ---------- ^^^^^ expected `i32`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i32`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to an `i32` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -848,15 +519,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:136:16 | LL | foo::(x_u32); - | ---------- ^^^^^ expected `i32`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i32`, found `u32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit | LL | foo::(x_u32.try_into().unwrap()); @@ -866,15 +530,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:138:16 | LL | foo::(x_u16); - | ---------- ^^^^^ expected `i32`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i32`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `i32` | LL | foo::(x_u16.into()); @@ -884,15 +541,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:140:16 | LL | foo::(x_u8); - | ---------- ^^^^ expected `i32`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `i32`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `i32` | LL | foo::(x_u8.into()); @@ -902,15 +552,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:142:16 | LL | foo::(x_isize); - | ---------- ^^^^^^^ expected `i32`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `i32`, found `isize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -920,15 +563,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:144:16 | LL | foo::(x_i64); - | ---------- ^^^^^ expected `i32`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i32`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -938,15 +574,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:147:16 | LL | foo::(x_i16); - | ---------- ^^^^^ expected `i32`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i32`, found `i16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to an `i32` | LL | foo::(x_i16.into()); @@ -956,15 +585,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:149:16 | LL | foo::(x_i8); - | ---------- ^^^^ expected `i32`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `i32`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `i32` | LL | foo::(x_i8.into()); @@ -974,15 +596,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:154:16 | LL | foo::(x_usize); - | ---------- ^^^^^^^ expected `u16`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `u16`, found `usize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -992,15 +607,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:156:16 | LL | foo::(x_u64); - | ---------- ^^^^^ expected `u16`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u16`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -1010,15 +618,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:158:16 | LL | foo::(x_u32); - | ---------- ^^^^^ expected `u16`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u16`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit | LL | foo::(x_u32.try_into().unwrap()); @@ -1028,15 +629,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:161:16 | LL | foo::(x_u8); - | ---------- ^^^^ expected `u16`, found `u8` - | | - | arguments to this function are incorrect + | ^^^^ expected `u16`, found `u8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to a `u16` | LL | foo::(x_u8.into()); @@ -1046,15 +640,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:163:16 | LL | foo::(x_isize); - | ---------- ^^^^^^^ expected `u16`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `u16`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -1064,15 +651,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:165:16 | LL | foo::(x_i64); - | ---------- ^^^^^ expected `u16`, found `i64` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u16`, found `i64` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to a `u16` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -1082,15 +662,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:167:16 | LL | foo::(x_i32); - | ---------- ^^^^^ expected `u16`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u16`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit | LL | foo::(x_i32.try_into().unwrap()); @@ -1100,15 +673,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:169:16 | LL | foo::(x_i16); - | ---------- ^^^^^ expected `u16`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u16`, found `i16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to a `u16` and panic if the converted value doesn't fit | LL | foo::(x_i16.try_into().unwrap()); @@ -1118,15 +684,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:171:16 | LL | foo::(x_i8); - | ---------- ^^^^ expected `u16`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `u16`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to a `u16` and panic if the converted value doesn't fit | LL | foo::(x_i8.try_into().unwrap()); @@ -1136,15 +695,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:176:16 | LL | foo::(x_usize); - | ---------- ^^^^^^^ expected `i16`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `i16`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to an `i16` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -1154,15 +706,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:178:16 | LL | foo::(x_u64); - | ---------- ^^^^^ expected `i16`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i16`, found `u64` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to an `i16` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -1172,15 +717,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:180:16 | LL | foo::(x_u32); - | ---------- ^^^^^ expected `i16`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i16`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to an `i16` and panic if the converted value doesn't fit | LL | foo::(x_u32.try_into().unwrap()); @@ -1190,15 +728,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:182:16 | LL | foo::(x_u16); - | ---------- ^^^^^ expected `i16`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i16`, found `u16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `i16` and panic if the converted value doesn't fit | LL | foo::(x_u16.try_into().unwrap()); @@ -1208,15 +739,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:184:16 | LL | foo::(x_u8); - | ---------- ^^^^ expected `i16`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `i16`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `i16` | LL | foo::(x_u8.into()); @@ -1226,15 +750,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:186:16 | LL | foo::(x_isize); - | ---------- ^^^^^^^ expected `i16`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `i16`, found `isize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -1244,15 +761,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:188:16 | LL | foo::(x_i64); - | ---------- ^^^^^ expected `i16`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i16`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -1262,15 +772,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:190:16 | LL | foo::(x_i32); - | ---------- ^^^^^ expected `i16`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i16`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit | LL | foo::(x_i32.try_into().unwrap()); @@ -1280,15 +783,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:193:16 | LL | foo::(x_i8); - | ---------- ^^^^ expected `i16`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^ expected `i16`, found `i8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `i16` | LL | foo::(x_i8.into()); @@ -1298,15 +794,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:198:15 | LL | foo::(x_usize); - | --------- ^^^^^^^ expected `u8`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `u8`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -1316,15 +805,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:200:15 | LL | foo::(x_u64); - | --------- ^^^^^ expected `u8`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u8`, found `u64` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -1334,15 +816,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:202:15 | LL | foo::(x_u32); - | --------- ^^^^^ expected `u8`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u8`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_u32.try_into().unwrap()); @@ -1352,15 +827,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:204:15 | LL | foo::(x_u16); - | --------- ^^^^^ expected `u8`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u8`, found `u16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_u16.try_into().unwrap()); @@ -1370,15 +838,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:207:15 | LL | foo::(x_isize); - | --------- ^^^^^^^ expected `u8`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `u8`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -1388,15 +849,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:209:15 | LL | foo::(x_i64); - | --------- ^^^^^ expected `u8`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u8`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -1406,15 +860,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:211:15 | LL | foo::(x_i32); - | --------- ^^^^^ expected `u8`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u8`, found `i32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_i32.try_into().unwrap()); @@ -1424,15 +871,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:213:15 | LL | foo::(x_i16); - | --------- ^^^^^ expected `u8`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `u8`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_i16.try_into().unwrap()); @@ -1442,15 +882,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:215:15 | LL | foo::(x_i8); - | --------- ^^^^ expected `u8`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^ expected `u8`, found `i8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to a `u8` and panic if the converted value doesn't fit | LL | foo::(x_i8.try_into().unwrap()); @@ -1460,15 +893,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:220:15 | LL | foo::(x_usize); - | --------- ^^^^^^^ expected `i8`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `i8`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `usize` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_usize.try_into().unwrap()); @@ -1478,15 +904,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:222:15 | LL | foo::(x_u64); - | --------- ^^^^^ expected `i8`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i8`, found `u64` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u64` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_u64.try_into().unwrap()); @@ -1496,15 +915,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:224:15 | LL | foo::(x_u32); - | --------- ^^^^^ expected `i8`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i8`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_u32.try_into().unwrap()); @@ -1514,15 +926,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:226:15 | LL | foo::(x_u16); - | --------- ^^^^^ expected `i8`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i8`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_u16.try_into().unwrap()); @@ -1532,15 +937,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:228:15 | LL | foo::(x_u8); - | --------- ^^^^ expected `i8`, found `u8` - | | - | arguments to this function are incorrect + | ^^^^ expected `i8`, found `u8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_u8.try_into().unwrap()); @@ -1550,15 +948,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:230:15 | LL | foo::(x_isize); - | --------- ^^^^^^^ expected `i8`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `i8`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_isize.try_into().unwrap()); @@ -1568,15 +959,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:232:15 | LL | foo::(x_i64); - | --------- ^^^^^ expected `i8`, found `i64` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i8`, found `i64` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_i64.try_into().unwrap()); @@ -1586,15 +970,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:234:15 | LL | foo::(x_i32); - | --------- ^^^^^ expected `i8`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i8`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_i32.try_into().unwrap()); @@ -1604,15 +981,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:236:15 | LL | foo::(x_i16); - | --------- ^^^^^ expected `i8`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i8`, found `i16` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit | LL | foo::(x_i16.try_into().unwrap()); @@ -1622,15 +992,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:242:16 | LL | foo::(x_usize); - | ---------- ^^^^^^^ expected `f64`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `f64`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can cast a `usize` to an `f64`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_usize as f64); @@ -1640,15 +1003,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:244:16 | LL | foo::(x_u64); - | ---------- ^^^^^ expected `f64`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f64`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can cast a `u64` to an `f64`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_u64 as f64); @@ -1658,15 +1014,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:246:16 | LL | foo::(x_u32); - | ---------- ^^^^^ expected `f64`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `f64`, found `u32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to an `f64`, producing the floating point representation of the integer | LL | foo::(x_u32.into()); @@ -1676,15 +1025,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:248:16 | LL | foo::(x_u16); - | ---------- ^^^^^ expected `f64`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f64`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `f64`, producing the floating point representation of the integer | LL | foo::(x_u16.into()); @@ -1694,15 +1036,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:250:16 | LL | foo::(x_u8); - | ---------- ^^^^ expected `f64`, found `u8` - | | - | arguments to this function are incorrect + | ^^^^ expected `f64`, found `u8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `f64`, producing the floating point representation of the integer | LL | foo::(x_u8.into()); @@ -1712,15 +1047,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:252:16 | LL | foo::(x_isize); - | ---------- ^^^^^^^ expected `f64`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^ expected `f64`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to an `f64`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_isize as f64); @@ -1730,15 +1058,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:254:16 | LL | foo::(x_i64); - | ---------- ^^^^^ expected `f64`, found `i64` - | | - | arguments to this function are incorrect + | ^^^^^ expected `f64`, found `i64` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to an `f64`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_i64 as f64); @@ -1748,15 +1069,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:256:16 | LL | foo::(x_i32); - | ---------- ^^^^^ expected `f64`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f64`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to an `f64`, producing the floating point representation of the integer | LL | foo::(x_i32.into()); @@ -1766,15 +1080,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:258:16 | LL | foo::(x_i16); - | ---------- ^^^^^ expected `f64`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f64`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to an `f64`, producing the floating point representation of the integer | LL | foo::(x_i16.into()); @@ -1784,15 +1091,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:260:16 | LL | foo::(x_i8); - | ---------- ^^^^ expected `f64`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^ expected `f64`, found `i8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `f64`, producing the floating point representation of the integer | LL | foo::(x_i8.into()); @@ -1802,15 +1102,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:263:16 | LL | foo::(x_f32); - | ---------- ^^^^^ expected `f64`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f64`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `f32` to an `f64` | LL | foo::(x_f32.into()); @@ -1820,15 +1113,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:266:16 | LL | foo::(x_usize); - | ---------- ^^^^^^^ expected `f32`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `f32`, found `usize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can cast a `usize` to an `f32`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_usize as f32); @@ -1838,15 +1124,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:268:16 | LL | foo::(x_u64); - | ---------- ^^^^^ expected `f32`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f32`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can cast a `u64` to an `f32`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_u64 as f32); @@ -1856,15 +1135,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:270:16 | LL | foo::(x_u32); - | ---------- ^^^^^ expected `f32`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `f32`, found `u32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can cast a `u32` to an `f32`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_u32 as f32); @@ -1874,15 +1146,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:272:16 | LL | foo::(x_u16); - | ---------- ^^^^^ expected `f32`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f32`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `f32`, producing the floating point representation of the integer | LL | foo::(x_u16.into()); @@ -1892,15 +1157,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:274:16 | LL | foo::(x_u8); - | ---------- ^^^^ expected `f32`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^ expected `f32`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `f32`, producing the floating point representation of the integer | LL | foo::(x_u8.into()); @@ -1910,15 +1168,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:276:16 | LL | foo::(x_isize); - | ---------- ^^^^^^^ expected `f32`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `f32`, found `isize` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `isize` to an `f32`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_isize as f32); @@ -1928,15 +1179,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:278:16 | LL | foo::(x_i64); - | ---------- ^^^^^ expected `f32`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f32`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i64` to an `f32`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_i64 as f32); @@ -1946,15 +1190,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:280:16 | LL | foo::(x_i32); - | ---------- ^^^^^ expected `f32`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `f32`, found `i32` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to an `f32`, producing the floating point representation of the integer, rounded if necessary | LL | foo::(x_i32 as f32); @@ -1964,15 +1201,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:282:16 | LL | foo::(x_i16); - | ---------- ^^^^^ expected `f32`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `f32`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to an `f32`, producing the floating point representation of the integer | LL | foo::(x_i16.into()); @@ -1982,15 +1212,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:284:16 | LL | foo::(x_i8); - | ---------- ^^^^ expected `f32`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^ expected `f32`, found `i8` | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `f32`, producing the floating point representation of the integer | LL | foo::(x_i8.into()); @@ -2000,15 +1223,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:289:16 | LL | foo::(x_u8 as u16); - | ---------- ^^^^^^^^^^^ expected `u32`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^^^^^^^ expected `u32`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to a `u32` | LL | foo::((x_u8 as u16).into()); @@ -2018,15 +1234,8 @@ error[E0308]: mismatched types --> $DIR/numeric-cast.rs:291:16 | LL | foo::(-x_i8); - | ---------- ^^^^^ expected `i32`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-cast.rs:6:4 + | ^^^^^ expected `i32`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `i32` | LL | foo::((-x_i8).into()); diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed index 6e8c54df4b607..7a78e11534334 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs index b47b0ed02e7c8..a054296ef2bad 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr index f4fb14e79923c..6d5a7188ddf1a 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr @@ -1,196 +1,119 @@ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:28:16 + --> $DIR/numeric-suffix-i32.rs:6:16 | LL | foo::(42_usize); - | ---------- ^^^^^^^^ expected `i32`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 + | ^^^^^^^^ expected `i32`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:32:16 + --> $DIR/numeric-suffix-i32.rs:9:16 | LL | foo::(42_u64); - | ---------- ^^^^^^ expected `i32`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i32`, found `u64` | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:36:16 + --> $DIR/numeric-suffix-i32.rs:12:16 | LL | foo::(42_u32); - | ---------- ^^^^^^ expected `i32`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 + | ^^^^^^ expected `i32`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:40:16 + --> $DIR/numeric-suffix-i32.rs:15:16 | LL | foo::(42_u16); - | ---------- ^^^^^^ expected `i32`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i32`, found `u16` | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:44:16 + --> $DIR/numeric-suffix-i32.rs:18:16 | LL | foo::(42_u8); - | ---------- ^^^^^ expected `i32`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 + | ^^^^^ expected `i32`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:48:16 + --> $DIR/numeric-suffix-i32.rs:21:16 | LL | foo::(42_isize); - | ---------- ^^^^^^^^ expected `i32`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 + | ^^^^^^^^ expected `i32`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:52:16 + --> $DIR/numeric-suffix-i32.rs:24:16 | LL | foo::(42_i64); - | ---------- ^^^^^^ expected `i32`, found `i64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i32`, found `i64` | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:57:16 + --> $DIR/numeric-suffix-i32.rs:28:16 | LL | foo::(42_i16); - | ---------- ^^^^^^ expected `i32`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 + | ^^^^^^ expected `i32`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:61:16 + --> $DIR/numeric-suffix-i32.rs:31:16 | LL | foo::(42_i8); - | ---------- ^^^^^ expected `i32`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i32`, found `i8` | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `i32` | LL | foo::(42_i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:65:16 + --> $DIR/numeric-suffix-i32.rs:34:16 | LL | foo::(42.0_f64); - | ---------- ^^^^^^^^ expected `i32`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 + | ^^^^^^^^ expected `i32`, found `f64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `i32` | LL | foo::(42i32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i32.rs:69:16 + --> $DIR/numeric-suffix-i32.rs:37:16 | LL | foo::(42.0_f32); - | ---------- ^^^^^^^^ expected `i32`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i32.rs:3:4 + | ^^^^^^^^ expected `i32`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `i32` | LL | foo::(42i32); diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed index 03821cd447057..9e843312e14d7 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs index 629fe7e742c3e..0f1702d8531a5 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr index 47efe9f08bbd2..3ab0bff337480 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr @@ -1,196 +1,119 @@ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:28:16 + --> $DIR/numeric-suffix-i64.rs:6:16 | LL | foo::(42_usize); - | ---------- ^^^^^^^^ expected `i64`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 + | ^^^^^^^^ expected `i64`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:32:16 + --> $DIR/numeric-suffix-i64.rs:9:16 | LL | foo::(42_u64); - | ---------- ^^^^^^ expected `i64`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i64`, found `u64` | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:36:16 + --> $DIR/numeric-suffix-i64.rs:12:16 | LL | foo::(42_u32); - | ---------- ^^^^^^ expected `i64`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 + | ^^^^^^ expected `i64`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:40:16 + --> $DIR/numeric-suffix-i64.rs:15:16 | LL | foo::(42_u16); - | ---------- ^^^^^^ expected `i64`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i64`, found `u16` | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:44:16 + --> $DIR/numeric-suffix-i64.rs:18:16 | LL | foo::(42_u8); - | ---------- ^^^^^ expected `i64`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 + | ^^^^^ expected `i64`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:48:16 + --> $DIR/numeric-suffix-i64.rs:21:16 | LL | foo::(42_isize); - | ---------- ^^^^^^^^ expected `i64`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 + | ^^^^^^^^ expected `i64`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:53:16 + --> $DIR/numeric-suffix-i64.rs:25:16 | LL | foo::(42_i32); - | ---------- ^^^^^^ expected `i64`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i64`, found `i32` | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:57:16 + --> $DIR/numeric-suffix-i64.rs:28:16 | LL | foo::(42_i16); - | ---------- ^^^^^^ expected `i64`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 + | ^^^^^^ expected `i64`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:61:16 + --> $DIR/numeric-suffix-i64.rs:31:16 | LL | foo::(42_i8); - | ---------- ^^^^^ expected `i64`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i64`, found `i8` | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `i64` | LL | foo::(42_i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:65:16 + --> $DIR/numeric-suffix-i64.rs:34:16 | LL | foo::(42.0_f64); - | ---------- ^^^^^^^^ expected `i64`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 + | ^^^^^^^^ expected `i64`, found `f64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `i64` | LL | foo::(42i64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-i64.rs:69:16 + --> $DIR/numeric-suffix-i64.rs:37:16 | LL | foo::(42.0_f32); - | ---------- ^^^^^^^^ expected `i64`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-i64.rs:3:4 + | ^^^^^^^^ expected `i64`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `i64` | LL | foo::(42i64); diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed index faed65ca410ed..ef6af58e7c336 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs index df0b4cb620435..cddcd2c616c7c 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr index 28b79413f68d0..60368c8f990cf 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr @@ -1,196 +1,119 @@ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:28:18 + --> $DIR/numeric-suffix-isize.rs:6:18 | LL | foo::(42_usize); - | ------------ ^^^^^^^^ expected `isize`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 + | ^^^^^^^^ expected `isize`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:32:18 + --> $DIR/numeric-suffix-isize.rs:9:18 | LL | foo::(42_u64); - | ------------ ^^^^^^ expected `isize`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `isize`, found `u64` | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:36:18 + --> $DIR/numeric-suffix-isize.rs:12:18 | LL | foo::(42_u32); - | ------------ ^^^^^^ expected `isize`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 + | ^^^^^^ expected `isize`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:40:18 + --> $DIR/numeric-suffix-isize.rs:15:18 | LL | foo::(42_u16); - | ------------ ^^^^^^ expected `isize`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `isize`, found `u16` | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:44:18 + --> $DIR/numeric-suffix-isize.rs:18:18 | LL | foo::(42_u8); - | ------------ ^^^^^ expected `isize`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 + | ^^^^^ expected `isize`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:49:18 + --> $DIR/numeric-suffix-isize.rs:22:18 | LL | foo::(42_i64); - | ------------ ^^^^^^ expected `isize`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 + | ^^^^^^ expected `isize`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:53:18 + --> $DIR/numeric-suffix-isize.rs:25:18 | LL | foo::(42_i32); - | ------------ ^^^^^^ expected `isize`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `isize`, found `i32` | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:57:18 + --> $DIR/numeric-suffix-isize.rs:28:18 | LL | foo::(42_i16); - | ------------ ^^^^^^ expected `isize`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 + | ^^^^^^ expected `isize`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:61:18 + --> $DIR/numeric-suffix-isize.rs:31:18 | LL | foo::(42_i8); - | ------------ ^^^^^ expected `isize`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `isize`, found `i8` | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `isize` | LL | foo::(42_isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:65:18 + --> $DIR/numeric-suffix-isize.rs:34:18 | LL | foo::(42.0_f64); - | ------------ ^^^^^^^^ expected `isize`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 + | ^^^^^^^^ expected `isize`, found `f64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `isize` | LL | foo::(42isize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-isize.rs:69:18 + --> $DIR/numeric-suffix-isize.rs:37:18 | LL | foo::(42.0_f32); - | ------------ ^^^^^^^^ expected `isize`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-isize.rs:3:4 + | ^^^^^^^^ expected `isize`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `isize` | LL | foo::(42isize); diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed index 5955829e72c2c..adc828699d92f 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.rs index 5c303036a79b8..3325616148a15 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.rs +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.rs @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.stderr index d966893a83b48..a190354685daf 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.stderr +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.stderr @@ -1,196 +1,119 @@ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:28:16 + --> $DIR/numeric-suffix-u32.rs:6:16 | LL | foo::(42_usize); - | ---------- ^^^^^^^^ expected `u32`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 + | ^^^^^^^^ expected `u32`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:32:16 + --> $DIR/numeric-suffix-u32.rs:9:16 | LL | foo::(42_u64); - | ---------- ^^^^^^ expected `u32`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u32`, found `u64` | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:37:16 + --> $DIR/numeric-suffix-u32.rs:13:16 | LL | foo::(42_u16); - | ---------- ^^^^^^ expected `u32`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u32`, found `u16` | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:41:16 + --> $DIR/numeric-suffix-u32.rs:16:16 | LL | foo::(42_u8); - | ---------- ^^^^^ expected `u32`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 + | ^^^^^ expected `u32`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:45:16 + --> $DIR/numeric-suffix-u32.rs:19:16 | LL | foo::(42_isize); - | ---------- ^^^^^^^^ expected `u32`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `u32`, found `isize` | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:49:16 + --> $DIR/numeric-suffix-u32.rs:22:16 | LL | foo::(42_i64); - | ---------- ^^^^^^ expected `u32`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 + | ^^^^^^ expected `u32`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:53:16 + --> $DIR/numeric-suffix-u32.rs:25:16 | LL | foo::(42_i32); - | ---------- ^^^^^^ expected `u32`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u32`, found `i32` | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:57:16 + --> $DIR/numeric-suffix-u32.rs:28:16 | LL | foo::(42_i16); - | ---------- ^^^^^^ expected `u32`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u32`, found `i16` | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:61:16 + --> $DIR/numeric-suffix-u32.rs:31:16 | LL | foo::(42_i8); - | ---------- ^^^^^ expected `u32`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 + | ^^^^^ expected `u32`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `u32` | LL | foo::(42_u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:65:16 + --> $DIR/numeric-suffix-u32.rs:34:16 | LL | foo::(42.0_f64); - | ---------- ^^^^^^^^ expected `u32`, found `f64` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `u32`, found `f64` | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `u32` | LL | foo::(42u32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u32.rs:69:16 + --> $DIR/numeric-suffix-u32.rs:37:16 | LL | foo::(42.0_f32); - | ---------- ^^^^^^^^ expected `u32`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u32.rs:3:4 + | ^^^^^^^^ expected `u32`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `u32` | LL | foo::(42u32); diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.fixed index 4623c211c1c0b..d19f441b92777 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.fixed +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.fixed @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.rs index 3e9995c7496ac..4bca5358e4158 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.rs +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.rs @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.stderr index ff332fa914dd0..051ff7fbacc5c 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.stderr +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.stderr @@ -1,196 +1,119 @@ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:28:16 + --> $DIR/numeric-suffix-u64.rs:6:16 | LL | foo::(42_usize); - | ---------- ^^^^^^^^ expected `u64`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 + | ^^^^^^^^ expected `u64`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:33:16 + --> $DIR/numeric-suffix-u64.rs:10:16 | LL | foo::(42_u32); - | ---------- ^^^^^^ expected `u64`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u64`, found `u32` | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:37:16 + --> $DIR/numeric-suffix-u64.rs:13:16 | LL | foo::(42_u16); - | ---------- ^^^^^^ expected `u64`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u64`, found `u16` | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:41:16 + --> $DIR/numeric-suffix-u64.rs:16:16 | LL | foo::(42_u8); - | ---------- ^^^^^ expected `u64`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 + | ^^^^^ expected `u64`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:45:16 + --> $DIR/numeric-suffix-u64.rs:19:16 | LL | foo::(42_isize); - | ---------- ^^^^^^^^ expected `u64`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `u64`, found `isize` | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:49:16 + --> $DIR/numeric-suffix-u64.rs:22:16 | LL | foo::(42_i64); - | ---------- ^^^^^^ expected `u64`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 + | ^^^^^^ expected `u64`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:53:16 + --> $DIR/numeric-suffix-u64.rs:25:16 | LL | foo::(42_i32); - | ---------- ^^^^^^ expected `u64`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u64`, found `i32` | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:57:16 + --> $DIR/numeric-suffix-u64.rs:28:16 | LL | foo::(42_i16); - | ---------- ^^^^^^ expected `u64`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u64`, found `i16` | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:61:16 + --> $DIR/numeric-suffix-u64.rs:31:16 | LL | foo::(42_i8); - | ---------- ^^^^^ expected `u64`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 + | ^^^^^ expected `u64`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `u64` | LL | foo::(42_u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:65:16 + --> $DIR/numeric-suffix-u64.rs:34:16 | LL | foo::(42.0_f64); - | ---------- ^^^^^^^^ expected `u64`, found `f64` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `u64`, found `f64` | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `u64` | LL | foo::(42u64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-u64.rs:69:16 + --> $DIR/numeric-suffix-u64.rs:37:16 | LL | foo::(42.0_f32); - | ---------- ^^^^^^^^ expected `u64`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-u64.rs:3:4 + | ^^^^^^^^ expected `u64`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `u64` | LL | foo::(42u64); diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.fixed index 6cb5243ca84dc..dffb47a4ab7f2 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.fixed +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.fixed @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_usize); foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.rs index a2304ba26c68a..9a9d72fe10dc7 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.rs +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.rs @@ -1,73 +1,40 @@ // run-rustfix fn foo(_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::(42_usize); foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.stderr index 4889abee69c2a..3713d6c973a0c 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.stderr +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.stderr @@ -1,196 +1,119 @@ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:29:18 + --> $DIR/numeric-suffix-usize.rs:7:18 | LL | foo::(42_u64); - | ------------ ^^^^^^ expected `usize`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `usize`, found `u64` | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:33:18 + --> $DIR/numeric-suffix-usize.rs:10:18 | LL | foo::(42_u32); - | ------------ ^^^^^^ expected `usize`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 + | ^^^^^^ expected `usize`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:37:18 + --> $DIR/numeric-suffix-usize.rs:13:18 | LL | foo::(42_u16); - | ------------ ^^^^^^ expected `usize`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 + | ^^^^^^ expected `usize`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:41:18 + --> $DIR/numeric-suffix-usize.rs:16:18 | LL | foo::(42_u8); - | ------------ ^^^^^ expected `usize`, found `u8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `usize`, found `u8` | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:45:18 + --> $DIR/numeric-suffix-usize.rs:19:18 | LL | foo::(42_isize); - | ------------ ^^^^^^^^ expected `usize`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 + | ^^^^^^^^ expected `usize`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:49:18 + --> $DIR/numeric-suffix-usize.rs:22:18 | LL | foo::(42_i64); - | ------------ ^^^^^^ expected `usize`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 + | ^^^^^^ expected `usize`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:53:18 + --> $DIR/numeric-suffix-usize.rs:25:18 | LL | foo::(42_i32); - | ------------ ^^^^^^ expected `usize`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `usize`, found `i32` | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:57:18 + --> $DIR/numeric-suffix-usize.rs:28:18 | LL | foo::(42_i16); - | ------------ ^^^^^^ expected `usize`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 + | ^^^^^^ expected `usize`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:61:18 + --> $DIR/numeric-suffix-usize.rs:31:18 | LL | foo::(42_i8); - | ------------ ^^^^^ expected `usize`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 + | ^^^^^ expected `usize`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `usize` | LL | foo::(42_usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:65:18 + --> $DIR/numeric-suffix-usize.rs:34:18 | LL | foo::(42.0_f64); - | ------------ ^^^^^^^^ expected `usize`, found `f64` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found `f64` | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `usize` | LL | foo::(42usize); | ~~~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix-usize.rs:69:18 + --> $DIR/numeric-suffix-usize.rs:37:18 | LL | foo::(42.0_f32); - | ------------ ^^^^^^^^ expected `usize`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix-usize.rs:3:4 + | ^^^^^^^^ expected `usize`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `usize` | LL | foo::(42usize); diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix.fixed index 69934db217b62..cf18e0070b4a2 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix.fixed +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix.fixed @@ -1,427 +1,223 @@ // run-rustfix fn foo(_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::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); foo::(42i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8.into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); foo::((42_u8 as u16).into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::((-42_i8).into()); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix.rs index dabf43f82046f..5228adf2fcf22 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix.rs +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix.rs @@ -1,427 +1,223 @@ // run-rustfix fn foo(_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::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); foo::(42.0_f32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_usize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_u8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_isize); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i32); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f64); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(42.0_f32); foo::(42_u8 as u16); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments foo::(-42_i8); //~^ ERROR mismatched types //~| NOTE expected - //~| NOTE arguments } diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix.stderr index e05913b9c621c..c6fd66c1f366f 100644 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix.stderr +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix.stderr @@ -1,1222 +1,746 @@ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:143:16 + --> $DIR/numeric-suffix.rs:7:16 | LL | foo::(42_usize); - | ---------- ^^^^^^^^ expected `u16`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `u16`, found `usize` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:147:16 + --> $DIR/numeric-suffix.rs:10:16 | LL | foo::(42_u64); - | ---------- ^^^^^^ expected `u16`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `u16`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:151:16 + --> $DIR/numeric-suffix.rs:13:16 | LL | foo::(42_u32); - | ---------- ^^^^^^ expected `u16`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u16`, found `u32` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:156:16 + --> $DIR/numeric-suffix.rs:17:16 | LL | foo::(42_u8); - | ---------- ^^^^^ expected `u16`, found `u8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u16`, found `u8` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:160:16 + --> $DIR/numeric-suffix.rs:20:16 | LL | foo::(42_isize); - | ---------- ^^^^^^^^ expected `u16`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `u16`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:164:16 + --> $DIR/numeric-suffix.rs:23:16 | LL | foo::(42_i64); - | ---------- ^^^^^^ expected `u16`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `u16`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:168:16 + --> $DIR/numeric-suffix.rs:26:16 | LL | foo::(42_i32); - | ---------- ^^^^^^ expected `u16`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `u16`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:172:16 + --> $DIR/numeric-suffix.rs:29:16 | LL | foo::(42_i16); - | ---------- ^^^^^^ expected `u16`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u16`, found `i16` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:176:16 + --> $DIR/numeric-suffix.rs:32:16 | LL | foo::(42_i8); - | ---------- ^^^^^ expected `u16`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^ expected `u16`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `u16` | LL | foo::(42_u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:180:16 + --> $DIR/numeric-suffix.rs:35:16 | LL | foo::(42.0_f64); - | ---------- ^^^^^^^^ expected `u16`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `u16`, found `f64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `u16` | LL | foo::(42u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:184:16 + --> $DIR/numeric-suffix.rs:38:16 | LL | foo::(42.0_f32); - | ---------- ^^^^^^^^ expected `u16`, found `f32` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `u16`, found `f32` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `u16` | LL | foo::(42u16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:189:16 + --> $DIR/numeric-suffix.rs:42:16 | LL | foo::(42_usize); - | ---------- ^^^^^^^^ expected `i16`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `i16`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:193:16 + --> $DIR/numeric-suffix.rs:45:16 | LL | foo::(42_u64); - | ---------- ^^^^^^ expected `i16`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i16`, found `u64` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:197:16 + --> $DIR/numeric-suffix.rs:48:16 | LL | foo::(42_u32); - | ---------- ^^^^^^ expected `i16`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `i16`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:201:16 + --> $DIR/numeric-suffix.rs:51:16 | LL | foo::(42_u16); - | ---------- ^^^^^^ expected `i16`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i16`, found `u16` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:205:16 + --> $DIR/numeric-suffix.rs:54:16 | LL | foo::(42_u8); - | ---------- ^^^^^ expected `i16`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^ expected `i16`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:209:16 + --> $DIR/numeric-suffix.rs:57:16 | LL | foo::(42_isize); - | ---------- ^^^^^^^^ expected `i16`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `i16`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:213:16 + --> $DIR/numeric-suffix.rs:60:16 | LL | foo::(42_i64); - | ---------- ^^^^^^ expected `i16`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `i16`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:217:16 + --> $DIR/numeric-suffix.rs:63:16 | LL | foo::(42_i32); - | ---------- ^^^^^^ expected `i16`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `i16`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:222:16 + --> $DIR/numeric-suffix.rs:67:16 | LL | foo::(42_i8); - | ---------- ^^^^^ expected `i16`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i16`, found `i8` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `i16` | LL | foo::(42_i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:226:16 + --> $DIR/numeric-suffix.rs:70:16 | LL | foo::(42.0_f64); - | ---------- ^^^^^^^^ expected `i16`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `i16`, found `f64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `i16` | LL | foo::(42i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:230:16 + --> $DIR/numeric-suffix.rs:73:16 | LL | foo::(42.0_f32); - | ---------- ^^^^^^^^ expected `i16`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `i16`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `i16` | LL | foo::(42i16); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:235:15 + --> $DIR/numeric-suffix.rs:77:15 | LL | foo::(42_usize); - | --------- ^^^^^^^^ expected `u8`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `u8`, found `usize` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:239:15 + --> $DIR/numeric-suffix.rs:80:15 | LL | foo::(42_u64); - | --------- ^^^^^^ expected `u8`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `u8`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:243:15 + --> $DIR/numeric-suffix.rs:83:15 | LL | foo::(42_u32); - | --------- ^^^^^^ expected `u8`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u8`, found `u32` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:247:15 + --> $DIR/numeric-suffix.rs:86:15 | LL | foo::(42_u16); - | --------- ^^^^^^ expected `u8`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `u8`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:252:15 + --> $DIR/numeric-suffix.rs:90:15 | LL | foo::(42_isize); - | --------- ^^^^^^^^ expected `u8`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `u8`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:256:15 + --> $DIR/numeric-suffix.rs:93:15 | LL | foo::(42_i64); - | --------- ^^^^^^ expected `u8`, found `i64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u8`, found `i64` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:260:15 + --> $DIR/numeric-suffix.rs:96:15 | LL | foo::(42_i32); - | --------- ^^^^^^ expected `u8`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `u8`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:264:15 + --> $DIR/numeric-suffix.rs:99:15 | LL | foo::(42_i16); - | --------- ^^^^^^ expected `u8`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `u8`, found `i16` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:268:15 + --> $DIR/numeric-suffix.rs:102:15 | LL | foo::(42_i8); - | --------- ^^^^^ expected `u8`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^ expected `u8`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i8` to `u8` | LL | foo::(42_u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:272:15 + --> $DIR/numeric-suffix.rs:105:15 | LL | foo::(42.0_f64); - | --------- ^^^^^^^^ expected `u8`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `u8`, found `f64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `u8` | LL | foo::(42u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:276:15 + --> $DIR/numeric-suffix.rs:108:15 | LL | foo::(42.0_f32); - | --------- ^^^^^^^^ expected `u8`, found `f32` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `u8`, found `f32` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `u8` | LL | foo::(42u8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:281:15 + --> $DIR/numeric-suffix.rs:112:15 | LL | foo::(42_usize); - | --------- ^^^^^^^^ expected `i8`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `i8`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:285:15 + --> $DIR/numeric-suffix.rs:115:15 | LL | foo::(42_u64); - | --------- ^^^^^^ expected `i8`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i8`, found `u64` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:289:15 + --> $DIR/numeric-suffix.rs:118:15 | LL | foo::(42_u32); - | --------- ^^^^^^ expected `i8`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `i8`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:293:15 + --> $DIR/numeric-suffix.rs:121:15 | LL | foo::(42_u16); - | --------- ^^^^^^ expected `i8`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `i8`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u16` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:297:15 + --> $DIR/numeric-suffix.rs:124:15 | LL | foo::(42_u8); - | --------- ^^^^^ expected `i8`, found `u8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `i8`, found `u8` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u8` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:301:15 + --> $DIR/numeric-suffix.rs:127:15 | LL | foo::(42_isize); - | --------- ^^^^^^^^ expected `i8`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `i8`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:305:15 + --> $DIR/numeric-suffix.rs:130:15 | LL | foo::(42_i64); - | --------- ^^^^^^ expected `i8`, found `i64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `i8`, found `i64` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:309:15 + --> $DIR/numeric-suffix.rs:133:15 | LL | foo::(42_i32); - | --------- ^^^^^^ expected `i8`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `i8`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:313:15 + --> $DIR/numeric-suffix.rs:136:15 | LL | foo::(42_i16); - | --------- ^^^^^^ expected `i8`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `i8`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i16` to `i8` | LL | foo::(42_i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:318:15 + --> $DIR/numeric-suffix.rs:140:15 | LL | foo::(42.0_f64); - | --------- ^^^^^^^^ expected `i8`, found `f64` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `i8`, found `f64` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `i8` | LL | foo::(42i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:322:15 + --> $DIR/numeric-suffix.rs:143:15 | LL | foo::(42.0_f32); - | --------- ^^^^^^^^ expected `i8`, found `f32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `i8`, found `f32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `i8` | LL | foo::(42i8); | ~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:327:16 + --> $DIR/numeric-suffix.rs:147:16 | LL | foo::(42_usize); - | ---------- ^^^^^^^^ expected `f64`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `f64`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `f64` | LL | foo::(42_f64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:331:16 + --> $DIR/numeric-suffix.rs:150:16 | LL | foo::(42_u64); - | ---------- ^^^^^^ expected `f64`, found `u64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `f64`, found `u64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `f64` | LL | foo::(42_f64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:335:16 + --> $DIR/numeric-suffix.rs:153:16 | LL | foo::(42_u32); - | ---------- ^^^^^^ expected `f64`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `f64`, found `u32` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u32` to an `f64`, producing the floating point representation of the integer | LL | foo::(42_u32.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:339:16 + --> $DIR/numeric-suffix.rs:156:16 | LL | foo::(42_u16); - | ---------- ^^^^^^ expected `f64`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `f64`, found `u16` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `f64`, producing the floating point representation of the integer | LL | foo::(42_u16.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:343:16 + --> $DIR/numeric-suffix.rs:159:16 | LL | foo::(42_u8); - | ---------- ^^^^^ expected `f64`, found `u8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^ expected `f64`, found `u8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `f64`, producing the floating point representation of the integer | LL | foo::(42_u8.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:347:16 + --> $DIR/numeric-suffix.rs:162:16 | LL | foo::(42_isize); - | ---------- ^^^^^^^^ expected `f64`, found `isize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `f64`, found `isize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `f64` | LL | foo::(42_f64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:351:16 + --> $DIR/numeric-suffix.rs:165:16 | LL | foo::(42_i64); - | ---------- ^^^^^^ expected `f64`, found `i64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `f64`, found `i64` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `f64` | LL | foo::(42_f64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:355:16 + --> $DIR/numeric-suffix.rs:168:16 | LL | foo::(42_i32); - | ---------- ^^^^^^ expected `f64`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `f64`, found `i32` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i32` to an `f64`, producing the floating point representation of the integer | LL | foo::(42_i32.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:359:16 + --> $DIR/numeric-suffix.rs:171:16 | LL | foo::(42_i16); - | ---------- ^^^^^^ expected `f64`, found `i16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `f64`, found `i16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to an `f64`, producing the floating point representation of the integer | LL | foo::(42_i16.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:363:16 + --> $DIR/numeric-suffix.rs:174:16 | LL | foo::(42_i8); - | ---------- ^^^^^ expected `f64`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^ expected `f64`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `f64`, producing the floating point representation of the integer | LL | foo::(42_i8.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:368:16 + --> $DIR/numeric-suffix.rs:178:16 | LL | foo::(42.0_f32); - | ---------- ^^^^^^^^ expected `f64`, found `f32` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `f64`, found `f32` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f32` to `f64` | LL | foo::(42.0_f64); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:373:16 + --> $DIR/numeric-suffix.rs:182:16 | LL | foo::(42_usize); - | ---------- ^^^^^^^^ expected `f32`, found `usize` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `f32`, found `usize` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `usize` to `f32` | LL | foo::(42_f32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:377:16 + --> $DIR/numeric-suffix.rs:185:16 | LL | foo::(42_u64); - | ---------- ^^^^^^ expected `f32`, found `u64` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `f32`, found `u64` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u64` to `f32` | LL | foo::(42_f32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:381:16 + --> $DIR/numeric-suffix.rs:188:16 | LL | foo::(42_u32); - | ---------- ^^^^^^ expected `f32`, found `u32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `f32`, found `u32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `u32` to `f32` | LL | foo::(42_f32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:385:16 + --> $DIR/numeric-suffix.rs:191:16 | LL | foo::(42_u16); - | ---------- ^^^^^^ expected `f32`, found `u16` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `f32`, found `u16` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to an `f32`, producing the floating point representation of the integer | LL | foo::(42_u16.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:389:16 + --> $DIR/numeric-suffix.rs:194:16 | LL | foo::(42_u8); - | ---------- ^^^^^ expected `f32`, found `u8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `f32`, found `u8` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u8` to an `f32`, producing the floating point representation of the integer | LL | foo::(42_u8.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:393:16 + --> $DIR/numeric-suffix.rs:197:16 | LL | foo::(42_isize); - | ---------- ^^^^^^^^ expected `f32`, found `isize` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `f32`, found `isize` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `isize` to `f32` | LL | foo::(42_f32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:397:16 + --> $DIR/numeric-suffix.rs:200:16 | LL | foo::(42_i64); - | ---------- ^^^^^^ expected `f32`, found `i64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `f32`, found `i64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i64` to `f32` | LL | foo::(42_f32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:401:16 + --> $DIR/numeric-suffix.rs:203:16 | LL | foo::(42_i32); - | ---------- ^^^^^^ expected `f32`, found `i32` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `f32`, found `i32` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `i32` to `f32` | LL | foo::(42_f32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:405:16 + --> $DIR/numeric-suffix.rs:206:16 | LL | foo::(42_i16); - | ---------- ^^^^^^ expected `f32`, found `i16` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `f32`, found `i16` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i16` to an `f32`, producing the floating point representation of the integer | LL | foo::(42_i16.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:409:16 + --> $DIR/numeric-suffix.rs:209:16 | LL | foo::(42_i8); - | ---------- ^^^^^ expected `f32`, found `i8` - | | - | arguments to this function are incorrect + | ^^^^^ expected `f32`, found `i8` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `f32`, producing the floating point representation of the integer | LL | foo::(42_i8.into()); | +++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:413:16 + --> $DIR/numeric-suffix.rs:212:16 | LL | foo::(42.0_f64); - | ---------- ^^^^^^^^ expected `f32`, found `f64` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^^^ expected `f32`, found `f64` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: change the type of the numeric literal from `f64` to `f32` | LL | foo::(42.0_f32); | ~~~ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:419:16 + --> $DIR/numeric-suffix.rs:217:16 | LL | foo::(42_u8 as u16); - | ---------- ^^^^^^^^^^^^ expected `u32`, found `u16` - | | - | arguments to this function are incorrect + | ^^^^^^^^^^^^ expected `u32`, found `u16` | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 - | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert a `u16` to a `u32` | LL | foo::((42_u8 as u16).into()); | + ++++++++ error[E0308]: mismatched types - --> $DIR/numeric-suffix.rs:423:16 + --> $DIR/numeric-suffix.rs:220:16 | LL | foo::(-42_i8); - | ---------- ^^^^^^ expected `i32`, found `i8` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/numeric-suffix.rs:3:4 + | ^^^^^^ expected `i32`, found `i8` | -LL | fn foo(_x: N) {} - | ^^^ ----- help: you can convert an `i8` to an `i32` | LL | foo::((-42_i8).into()); diff --git a/src/test/ui/parser/fn-arg-doc-comment.rs b/src/test/ui/parser/fn-arg-doc-comment.rs index 21d753ad03725..7cb5d37536722 100644 --- a/src/test/ui/parser/fn-arg-doc-comment.rs +++ b/src/test/ui/parser/fn-arg-doc-comment.rs @@ -1,30 +1,26 @@ -pub fn f( //~ NOTE function defined here +pub fn f( /// 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 arguments to this function are incorrect + //~^ ERROR mismatched types + //~| ERROR mismatched types //~| NOTE expected `u8`, found `&str` //~| NOTE expected `u8`, found `&str` bar(""); //~^ ERROR mismatched types - //~| NOTE arguments to this function are incorrect //~| NOTE expected `i32`, found `&str` } diff --git a/src/test/ui/parser/fn-arg-doc-comment.stderr b/src/test/ui/parser/fn-arg-doc-comment.stderr index c8d7e2efe799d..41f2c080b9465 100644 --- a/src/test/ui/parser/fn-arg-doc-comment.stderr +++ b/src/test/ui/parser/fn-arg-doc-comment.stderr @@ -1,5 +1,5 @@ error: attributes cannot be applied to a function parameter's type - --> $DIR/fn-arg-doc-comment.rs:14:12 + --> $DIR/fn-arg-doc-comment.rs:12:12 | LL | fn bar(id: #[allow(dead_code)] i32) {} | ^^^^^^^^^^^^^^^^^^^ attributes are not allowed here @@ -11,51 +11,29 @@ LL | /// Comment | ^^^^^^^^^^^ doc comments are not allowed here error: documentation comments cannot be applied to function parameters - --> $DIR/fn-arg-doc-comment.rs:7:5 + --> $DIR/fn-arg-doc-comment.rs:6:5 | LL | /// Other | ^^^^^^^^^ doc comments are not allowed here -error[E0308]: arguments to this function are incorrect - --> $DIR/fn-arg-doc-comment.rs:22:5 +error[E0308]: mismatched types + --> $DIR/fn-arg-doc-comment.rs:18:7 | LL | f("", ""); - | ^ -- -- expected `u8`, found `&str` - | | - | expected `u8`, found `&str` - | -note: function defined here - --> $DIR/fn-arg-doc-comment.rs:1:8 + | ^^ expected `u8`, found `&str` + +error[E0308]: mismatched types + --> $DIR/fn-arg-doc-comment.rs:18:11 | -LL | pub fn f( - | ^ -LL | / /// Comment -LL | | -LL | | -LL | | -LL | | id: u8, - | |__________- -LL | / /// Other -LL | | -LL | | -LL | | -LL | | a: u8, - | |_________- +LL | f("", ""); + | ^^ expected `u8`, found `&str` error[E0308]: mismatched types - --> $DIR/fn-arg-doc-comment.rs:26:9 + --> $DIR/fn-arg-doc-comment.rs:23:9 | LL | bar(""); - | --- ^^ 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) {} - | ^^^ --------------------------- + | ^^ expected `i32`, found `&str` -error: aborting due to 5 previous errors +error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/pattern/pattern-error-continue.stderr b/src/test/ui/pattern/pattern-error-continue.stderr index 4c2eff63ab5e8..c800afdae2afb 100644 --- a/src/test/ui/pattern/pattern-error-continue.stderr +++ b/src/test/ui/pattern/pattern-error-continue.stderr @@ -46,15 +46,7 @@ error[E0308]: mismatched types --> $DIR/pattern-error-continue.rs:28:7 | LL | f(true); - | - ^^^^ 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) {} - | ^ -------- + | ^^^^ expected `char`, found `bool` error: aborting due to 5 previous errors diff --git a/src/test/ui/proc-macro/signature.stderr b/src/test/ui/proc-macro/signature.stderr index 262a64acc544c..80a459c41257f 100644 --- a/src/test/ui/proc-macro/signature.stderr +++ b/src/test/ui/proc-macro/signature.stderr @@ -9,11 +9,6 @@ LL | | } | = 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 diff --git a/src/test/ui/range/issue-54505-no-literals.stderr b/src/test/ui/range/issue-54505-no-literals.stderr index 4cbf8869d0c59..065e16a8227ca 100644 --- a/src/test/ui/range/issue-54505-no-literals.stderr +++ b/src/test/ui/range/issue-54505-no-literals.stderr @@ -2,217 +2,145 @@ error[E0308]: mismatched types --> $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 }` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `std::ops::Range` + | help: consider borrowing here: `&std::ops::Range { start: 0, end: 1 }` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 }` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `std::ops::Range` + | help: consider borrowing here: `&::std::ops::Range { start: 0, end: 1 }` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 }` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeFrom` + | help: consider borrowing here: `&std::ops::RangeFrom { start: 1 }` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 }` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeFrom` + | help: consider borrowing here: `&::std::ops::RangeFrom { start: 1 }` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 {}` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeFull` + | help: consider borrowing here: `&std::ops::RangeFull {}` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 {}` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeFull` + | help: consider borrowing here: `&::std::ops::RangeFull {}` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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)` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeInclusive` + | help: consider borrowing here: `&std::ops::RangeInclusive::new(0, 1)` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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)` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeInclusive` + | help: consider borrowing here: `&::std::ops::RangeInclusive::new(0, 1)` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 }` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeTo` + | help: consider borrowing here: `&std::ops::RangeTo { end: 5 }` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 }` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeTo` + | help: consider borrowing here: `&::std::ops::RangeTo { end: 5 }` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 }` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeToInclusive` + | help: consider borrowing here: `&std::ops::RangeToInclusive { end: 5 }` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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 }` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `RangeToInclusive` + | help: consider borrowing here: `&::std::ops::RangeToInclusive { end: 5 }` | = 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) {} - | ^^^^^^^^^^ ------------------------- error: aborting due to 12 previous errors diff --git a/src/test/ui/range/issue-54505-no-std.stderr b/src/test/ui/range/issue-54505-no-std.stderr index c4e36b0b15950..73507f4836b23 100644 --- a/src/test/ui/range/issue-54505-no-std.stderr +++ b/src/test/ui/range/issue-54505-no-std.stderr @@ -4,109 +4,73 @@ error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:27:16 | LL | take_range(0..1); - | ---------- ^^^^ - | | | - | | expected reference, found struct `Range` - | | help: consider borrowing here: `&(0..1)` - | arguments to this function are incorrect + | ^^^^ + | | + | expected reference, found struct `Range` + | help: consider borrowing here: `&(0..1)` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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..)` - | arguments to this function are incorrect + | ^^^ + | | + | expected reference, found struct `RangeFrom` + | help: consider borrowing here: `&(1..)` | = 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) {} - | ^^^^^^^^^^ ------------------------- error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:37:16 | LL | take_range(..); - | ---------- ^^ - | | | - | | expected reference, found struct `RangeFull` - | | help: consider borrowing here: `&(..)` - | arguments to this function are incorrect + | ^^ + | | + | expected reference, found struct `RangeFull` + | help: consider borrowing here: `&(..)` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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)` - | arguments to this function are incorrect + | ^^^^^ + | | + | expected reference, found struct `RangeInclusive` + | help: consider borrowing here: `&(0..=1)` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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)` - | arguments to this function are incorrect + | ^^^ + | | + | expected reference, found struct `RangeTo` + | help: consider borrowing here: `&(..5)` | = 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) {} - | ^^^^^^^^^^ ------------------------- 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)` - | arguments to this function are incorrect + | ^^^^^ + | | + | expected reference, found struct `RangeToInclusive` + | help: consider borrowing here: `&(..=42)` | = 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) {} - | ^^^^^^^^^^ ------------------------- error: aborting due to 7 previous errors diff --git a/src/test/ui/range/issue-54505.stderr b/src/test/ui/range/issue-54505.stderr index 38df6e14496a6..121af29834d87 100644 --- a/src/test/ui/range/issue-54505.stderr +++ b/src/test/ui/range/issue-54505.stderr @@ -2,109 +2,73 @@ error[E0308]: mismatched types --> $DIR/issue-54505.rs:14:16 | LL | take_range(0..1); - | ---------- ^^^^ - | | | - | | expected reference, found struct `std::ops::Range` - | | help: consider borrowing here: `&(0..1)` - | arguments to this function are incorrect + | ^^^^ + | | + | expected reference, found struct `std::ops::Range` + | help: consider borrowing here: `&(0..1)` | = 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) {} - | ^^^^^^^^^^ ------------------------- error[E0308]: mismatched types --> $DIR/issue-54505.rs:19:16 | LL | take_range(1..); - | ---------- ^^^ - | | | - | | expected reference, found struct `RangeFrom` - | | help: consider borrowing here: `&(1..)` - | arguments to this function are incorrect + | ^^^ + | | + | expected reference, found struct `RangeFrom` + | help: consider borrowing here: `&(1..)` | = note: expected reference `&_` found struct `RangeFrom<{integer}>` -note: function defined here - --> $DIR/issue-54505.rs:10:4 - | -LL | fn take_range(_r: &impl RangeBounds) {} - | ^^^^^^^^^^ ------------------------- error[E0308]: mismatched types --> $DIR/issue-54505.rs:24:16 | LL | take_range(..); - | ---------- ^^ - | | | - | | expected reference, found struct `RangeFull` - | | help: consider borrowing here: `&(..)` - | arguments to this function are incorrect + | ^^ + | | + | expected reference, found struct `RangeFull` + | help: consider borrowing here: `&(..)` | = note: expected reference `&_` found struct `RangeFull` -note: function defined here - --> $DIR/issue-54505.rs:10:4 - | -LL | fn take_range(_r: &impl RangeBounds) {} - | ^^^^^^^^^^ ------------------------- 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)` - | arguments to this function are incorrect + | ^^^^^ + | | + | expected reference, found struct `RangeInclusive` + | help: consider borrowing here: `&(0..=1)` | = note: expected reference `&_` found struct `RangeInclusive<{integer}>` -note: function defined here - --> $DIR/issue-54505.rs:10:4 - | -LL | fn take_range(_r: &impl RangeBounds) {} - | ^^^^^^^^^^ ------------------------- error[E0308]: mismatched types --> $DIR/issue-54505.rs:34:16 | LL | take_range(..5); - | ---------- ^^^ - | | | - | | expected reference, found struct `RangeTo` - | | help: consider borrowing here: `&(..5)` - | arguments to this function are incorrect + | ^^^ + | | + | expected reference, found struct `RangeTo` + | help: consider borrowing here: `&(..5)` | = note: expected reference `&_` found struct `RangeTo<{integer}>` -note: function defined here - --> $DIR/issue-54505.rs:10:4 - | -LL | fn take_range(_r: &impl RangeBounds) {} - | ^^^^^^^^^^ ------------------------- error[E0308]: mismatched types --> $DIR/issue-54505.rs:39:16 | LL | take_range(..=42); - | ---------- ^^^^^ - | | | - | | expected reference, found struct `RangeToInclusive` - | | help: consider borrowing here: `&(..=42)` - | arguments to this function are incorrect + | ^^^^^ + | | + | expected reference, found struct `RangeToInclusive` + | help: consider borrowing here: `&(..=42)` | = note: expected reference `&_` found struct `RangeToInclusive<{integer}>` -note: function defined here - --> $DIR/issue-54505.rs:10:4 - | -LL | fn take_range(_r: &impl RangeBounds) {} - | ^^^^^^^^^^ ------------------------- error: aborting due to 6 previous errors diff --git a/src/test/ui/range/issue-73553-misinterp-range-literal.stderr b/src/test/ui/range/issue-73553-misinterp-range-literal.stderr index 6badd998f9617..5167b87fd27b8 100644 --- a/src/test/ui/range/issue-73553-misinterp-range-literal.stderr +++ b/src/test/ui/range/issue-73553-misinterp-range-literal.stderr @@ -2,37 +2,25 @@ error[E0308]: mismatched types --> $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))` - | arguments to this function are incorrect + | ^^^^^^^^^^^^^^^^^ + | | + | expected reference, found struct `std::ops::Range` + | help: consider borrowing here: `&(tell(1)..tell(10))` | = note: expected reference `&std::ops::Range` found struct `std::ops::Range` -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)` - | arguments to this function are incorrect + | ^^^^^ + | | + | expected reference, found struct `std::ops::Range` + | help: consider borrowing here: `&(1..10)` | = note: expected reference `&std::ops::Range` 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 diff --git a/src/test/ui/resolve/resolve-primitive-fallback.stderr b/src/test/ui/resolve/resolve-primitive-fallback.stderr index fcbc28475f998..22f5d740015a5 100644 --- a/src/test/ui/resolve/resolve-primitive-fallback.stderr +++ b/src/test/ui/resolve/resolve-primitive-fallback.stderr @@ -24,17 +24,15 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied --> $DIR/resolve-primitive-fallback.rs:3:5 | LL | std::mem::size_of(u16); - | ^^^^^^^^^^^^^^^^^ --- argument unexpected + | ^^^^^^^^^^^^^^^^^ --- supplied 1 argument + | | + | expected 0 arguments | note: function defined here --> $SRC_DIR/core/src/mem/mod.rs:LL:COL | LL | pub const fn size_of() -> usize { | ^^^^^^^ -help: remove the extra argument - | -LL | std::mem::size_of(); - | ~~~~~~~~~~~~~~~~~~~ error: aborting due to 3 previous errors diff --git a/src/test/ui/self/issue-61882.stderr b/src/test/ui/self/issue-61882.stderr index dd7194dc2e840..09ffe8e64b1b1 100644 --- a/src/test/ui/self/issue-61882.stderr +++ b/src/test/ui/self/issue-61882.stderr @@ -2,15 +2,7 @@ error[E0308]: mismatched types --> $DIR/issue-61882.rs:4:27 | LL | const B: A = Self(0); - | ---- ^ 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); - | ^ + | ^ expected `bool`, found integer error[E0308]: mismatched types --> $DIR/issue-61882.rs:4:22 diff --git a/src/test/ui/span/coerce-suggestions.stderr b/src/test/ui/span/coerce-suggestions.stderr index db784d5fe6cfc..5a964c5d5cc66 100644 --- a/src/test/ui/span/coerce-suggestions.stderr +++ b/src/test/ui/span/coerce-suggestions.stderr @@ -20,33 +20,19 @@ error[E0308]: mismatched types --> $DIR/coerce-suggestions.rs:12:10 | LL | test(&y); - | ---- ^^ types differ in mutability - | | - | arguments to this function are incorrect + | ^^ types differ in mutability | = 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 - | | - | arguments to this function are incorrect + | ^^ types differ in mutability | = 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 diff --git a/src/test/ui/span/issue-34264.stderr b/src/test/ui/span/issue-34264.stderr index 68da9f0dc88ba..8d26ca4ac7a74 100644 --- a/src/test/ui/span/issue-34264.stderr +++ b/src/test/ui/span/issue-34264.stderr @@ -54,47 +54,35 @@ error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/issue-34264.rs:7:5 | LL | foo(Some(42), 2, ""); - | ^^^ -- argument unexpected + | ^^^ -------- - -- supplied 3 arguments + | | + | expected 2 arguments | note: function defined here --> $DIR/issue-34264.rs:1:4 | LL | fn foo(Option, 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` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/issue-34264.rs:3:4 - | -LL | fn bar(x, y: usize) {} - | ^^^ - -------- + | ^^ expected `usize`, found `&str` error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/issue-34264.rs:10:5 | LL | bar(1, 2, 3); - | ^^^ - argument unexpected + | ^^^ - - - supplied 3 arguments + | | + | expected 2 arguments | 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 diff --git a/src/test/ui/span/missing-unit-argument.stderr b/src/test/ui/span/missing-unit-argument.stderr index c8e1a23288751..7f1507bd6ff8f 100644 --- a/src/test/ui/span/missing-unit-argument.stderr +++ b/src/test/ui/span/missing-unit-argument.stderr @@ -2,92 +2,79 @@ error[E0061]: this enum variant takes 1 argument but 0 arguments were supplied --> $DIR/missing-unit-argument.rs:11:33 | LL | let _: Result<(), String> = Ok(); - | ^^-- an argument of type `()` is missing - | -help: provide the argument - | -LL | let _: Result<(), String> = Ok(()); - | ~~~~~~ + | ^^-- supplied 0 arguments + | | + | expected 1 argument error[E0061]: this function takes 2 arguments but 0 arguments were supplied --> $DIR/missing-unit-argument.rs:12:5 | LL | foo(); - | ^^^-- two arguments of type `()` and `()` are missing + | ^^^-- supplied 0 arguments + | | + | expected 2 arguments | 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(()); - | ^^^---- an argument of type `()` is missing + | ^^^ -- supplied 1 argument + | | + | expected 2 arguments | 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(); - | ^^^-- an argument of type `()` is missing + | ^^^-- supplied 0 arguments + | | + | expected 1 argument | note: function defined here --> $DIR/missing-unit-argument.rs:2:4 | LL | fn bar(():()) {} | ^^^ ----- -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(); - | ^^^-- an argument of type `()` is missing + | ^^^- supplied 0 arguments + | | + | expected 1 argument | note: associated function defined here --> $DIR/missing-unit-argument.rs:6:8 | LL | fn baz(self, (): ()) { } | ^^^ ---- ------ -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::<()>(); - | ^^^^^^^^^^^^^-- an argument of type `()` is missing + | ^^^^^^^------ supplied 0 arguments + | | + | expected 1 argument | note: associated function defined here --> $DIR/missing-unit-argument.rs:7:8 | LL | fn generic(self, _: T) { } | ^^^^^^^ ---- ---- -help: provide the argument - | -LL | S.generic::<()>(()); - | ~~~~~~~~~~~~~~~~~ error: aborting due to 6 previous errors diff --git a/src/test/ui/suggestions/args-instead-of-tuple-errors.stderr b/src/test/ui/suggestions/args-instead-of-tuple-errors.stderr index 991dde30629e9..ddcdfb1c3b344 100644 --- a/src/test/ui/suggestions/args-instead-of-tuple-errors.stderr +++ b/src/test/ui/suggestions/args-instead-of-tuple-errors.stderr @@ -2,55 +2,37 @@ error[E0061]: this enum variant takes 1 argument but 2 arguments were supplied --> $DIR/args-instead-of-tuple-errors.rs:6:34 | LL | let _: Option<(i32, bool)> = Some(1, 2); - | ^^^^ - - 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)}); - | ~~~~~~~~~~~~~~~~~~~ + | ^^^^ - - supplied 2 arguments + | | + | expected 1 argument 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); - | ^^^^^^^^ - - argument unexpected - | | - | expected tuple, found integer + | ^^^^^^^^ - - supplied 2 arguments + | | + | expected 1 argument | - = 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(); - | ^^^^-- an argument of type `(i8,)` is missing - | -help: provide the argument - | -LL | let _: Option<(i8,)> = Some({(i8,)}); - | ~~~~~~~~~~~~~ + | ^^^^-- supplied 0 arguments + | | + | expected 1 argument error[E0308]: mismatched types --> $DIR/args-instead-of-tuple-errors.rs:14:34 | LL | let _: Option<(i32,)> = Some(5_usize); - | ---- ^^^^^^^ expected tuple, found `usize` - | | - | arguments to this enum variant are incorrect + | ^^^^^^^ expected tuple, found `usize` | = note: expected tuple `(i32,)` found type `usize` @@ -59,9 +41,7 @@ error[E0308]: mismatched types --> $DIR/args-instead-of-tuple-errors.rs:17:34 | LL | let _: Option<(i32,)> = Some((5_usize)); - | ---- ^^^^^^^^^ expected tuple, found `usize` - | | - | arguments to this enum variant are incorrect + | ^^^^^^^^^ expected tuple, found `usize` | = note: expected tuple `(i32,)` found type `usize` diff --git a/src/test/ui/suggestions/args-instead-of-tuple.fixed b/src/test/ui/suggestions/args-instead-of-tuple.fixed deleted file mode 100644 index 66e53f9ce2c80..0000000000000 --- a/src/test/ui/suggestions/args-instead-of-tuple.fixed +++ /dev/null @@ -1,33 +0,0 @@ -// Test suggesting tuples where bare arguments may have been passed -// See issue #86481 for details. - -// run-rustfix - -fn main() { - let _: Result<(i32, i8), ()> = Ok((1, 2)); - //~^ ERROR this enum variant takes 1 argument but 2 arguments were supplied - let _: Option<(i32, i8, &'static str)> = Some((1, 2, "hi")); - //~^ ERROR this enum variant takes 1 argument but 3 arguments were supplied - let _: Option<()> = Some(()); - //~^ ERROR this enum variant takes 1 argument but 0 arguments were supplied - - let _: Option<(i32,)> = Some((3,)); - //~^ ERROR mismatched types - - let _: Option<(i32,)> = Some((3,)); - //~^ ERROR mismatched types - - two_ints((1, 2)); //~ ERROR this function takes 1 argument - - with_generic((3, 4)); //~ ERROR this function takes 1 argument -} - -fn two_ints(_: (i32, i32)) { -} - -fn with_generic((a, b): (i32, T)) { - if false { - // test generics/bound handling - with_generic((a, b)); //~ ERROR this function takes 1 argument - } -} diff --git a/src/test/ui/suggestions/args-instead-of-tuple.rs b/src/test/ui/suggestions/args-instead-of-tuple.rs index a15bff07ebfe6..743143cced649 100644 --- a/src/test/ui/suggestions/args-instead-of-tuple.rs +++ b/src/test/ui/suggestions/args-instead-of-tuple.rs @@ -1,8 +1,6 @@ // Test suggesting tuples where bare arguments may have been passed // See issue #86481 for details. -// run-rustfix - fn main() { let _: Result<(i32, i8), ()> = Ok(1, 2); //~^ ERROR this enum variant takes 1 argument but 2 arguments were supplied diff --git a/src/test/ui/suggestions/args-instead-of-tuple.stderr b/src/test/ui/suggestions/args-instead-of-tuple.stderr index 7ec10e88142c1..e354a9ea0f384 100644 --- a/src/test/ui/suggestions/args-instead-of-tuple.stderr +++ b/src/test/ui/suggestions/args-instead-of-tuple.stderr @@ -1,8 +1,8 @@ error[E0061]: this enum variant takes 1 argument but 2 arguments were supplied - --> $DIR/args-instead-of-tuple.rs:7:36 + --> $DIR/args-instead-of-tuple.rs:5:36 | LL | let _: Result<(i32, i8), ()> = Ok(1, 2); - | ^^ + | ^^ - - supplied 2 arguments | help: use parentheses to construct a tuple | @@ -10,10 +10,10 @@ LL | let _: Result<(i32, i8), ()> = Ok((1, 2)); | + + error[E0061]: this enum variant takes 1 argument but 3 arguments were supplied - --> $DIR/args-instead-of-tuple.rs:9:46 + --> $DIR/args-instead-of-tuple.rs:7:46 | LL | let _: Option<(i32, i8, &'static str)> = Some(1, 2, "hi"); - | ^^^^ + | ^^^^ - - ---- supplied 3 arguments | help: use parentheses to construct a tuple | @@ -21,23 +21,18 @@ LL | let _: Option<(i32, i8, &'static str)> = Some((1, 2, "hi")); | + + error[E0061]: this enum variant takes 1 argument but 0 arguments were supplied - --> $DIR/args-instead-of-tuple.rs:11:25 + --> $DIR/args-instead-of-tuple.rs:9:25 | LL | let _: Option<()> = Some(); - | ^^^^-- an argument of type `()` is missing - | -help: provide the argument - | -LL | let _: Option<()> = Some(()); - | ~~~~~~~~ + | ^^^^-- supplied 0 arguments + | | + | expected 1 argument error[E0308]: mismatched types - --> $DIR/args-instead-of-tuple.rs:14:34 + --> $DIR/args-instead-of-tuple.rs:12:34 | LL | let _: Option<(i32,)> = Some(3); - | ---- ^ expected tuple, found integer - | | - | arguments to this enum variant are incorrect + | ^ expected tuple, found integer | = note: expected tuple `(i32,)` found type `{integer}` @@ -47,12 +42,10 @@ LL | let _: Option<(i32,)> = Some((3,)); | + ++ error[E0308]: mismatched types - --> $DIR/args-instead-of-tuple.rs:17:34 + --> $DIR/args-instead-of-tuple.rs:15:34 | LL | let _: Option<(i32,)> = Some((3)); - | ---- ^^^ expected tuple, found integer - | | - | arguments to this enum variant are incorrect + | ^^^ expected tuple, found integer | = note: expected tuple `(i32,)` found type `{integer}` @@ -62,13 +55,13 @@ LL | let _: Option<(i32,)> = Some((3,)); | + error[E0061]: this function takes 1 argument but 2 arguments were supplied - --> $DIR/args-instead-of-tuple.rs:20:5 + --> $DIR/args-instead-of-tuple.rs:18: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:23:4 | LL | fn two_ints(_: (i32, i32)) { | ^^^^^^^^ ------------- @@ -78,13 +71,13 @@ LL | two_ints((1, 2)); | + + error[E0061]: this function takes 1 argument but 2 arguments were supplied - --> $DIR/args-instead-of-tuple.rs:22:5 + --> $DIR/args-instead-of-tuple.rs:20: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:26:4 | LL | fn with_generic((a, b): (i32, T)) { | ^^^^^^^^^^^^ ---------------- @@ -94,13 +87,13 @@ LL | with_generic((3, 4)); | + + error[E0061]: this function takes 1 argument but 2 arguments were supplied - --> $DIR/args-instead-of-tuple.rs:31:9 + --> $DIR/args-instead-of-tuple.rs:29:9 | LL | with_generic(a, b); - | ^^^^^^^^^^^^ + | ^^^^^^^^^^^^ - - supplied 2 arguments | note: function defined here - --> $DIR/args-instead-of-tuple.rs:28:4 + --> $DIR/args-instead-of-tuple.rs:26:4 | LL | fn with_generic((a, b): (i32, T)) { | ^^^^^^^^^^^^ ---------------- diff --git a/src/test/ui/suggestions/as-ref.stderr b/src/test/ui/suggestions/as-ref.stderr index 1efd1b317b7da..8d93ac5079667 100644 --- a/src/test/ui/suggestions/as-ref.stderr +++ b/src/test/ui/suggestions/as-ref.stderr @@ -2,61 +2,33 @@ error[E0308]: mismatched types --> $DIR/as-ref.rs:7:29 | LL | opt.map(|arg| takes_ref(arg)); - | --- --------- ^^^ expected `&Foo`, found struct `Foo` - | | | - | | arguments to this function are incorrect + | --- ^^^ expected `&Foo`, found struct `Foo` + | | | 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` - | | | - | | arguments to this function are incorrect + | -------- ^^^ expected `&Foo`, found struct `Foo` + | | | 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` - | | | - | | arguments to this function are incorrect + | --- ^^^ expected `&Foo`, found struct `Foo` + | | | 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` - | | | - | | arguments to this function are incorrect + | -------- ^^^ expected `&Foo`, found struct `Foo` + | | | 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 diff --git a/src/test/ui/suggestions/boxed-variant-field.stderr b/src/test/ui/suggestions/boxed-variant-field.stderr index 6dfb73480a2b8..9a31dc89197e3 100644 --- a/src/test/ui/suggestions/boxed-variant-field.stderr +++ b/src/test/ui/suggestions/boxed-variant-field.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/boxed-variant-field.rs:9:31 | LL | Ty::List(elem) => foo(elem), - | --- ^^^^ expected enum `Ty`, found struct `Box` - | | - | arguments to this function are incorrect + | ^^^^ expected enum `Ty`, found struct `Box` | = note: expected enum `Ty` found struct `Box` -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), diff --git a/src/test/ui/suggestions/expected-boxed-future-isnt-pinned.stderr b/src/test/ui/suggestions/expected-boxed-future-isnt-pinned.stderr index 71facf57e8d65..7ef4895249cec 100644 --- a/src/test/ui/suggestions/expected-boxed-future-isnt-pinned.stderr +++ b/src/test/ui/suggestions/expected-boxed-future-isnt-pinned.stderr @@ -34,16 +34,10 @@ LL | fn baz + Send + 'static>(x: F) -> BoxFuture<'static, 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 + 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

{ - | ^^^ error[E0277]: `dyn Future + Send` cannot be unpinned --> $DIR/expected-boxed-future-isnt-pinned.rs:19:5 diff --git a/src/test/ui/suggestions/issue-86100-tuple-paren-comma.stderr b/src/test/ui/suggestions/issue-86100-tuple-paren-comma.stderr index 8c9a41a202767..0016f19284250 100644 --- a/src/test/ui/suggestions/issue-86100-tuple-paren-comma.stderr +++ b/src/test/ui/suggestions/issue-86100-tuple-paren-comma.stderr @@ -17,17 +17,10 @@ error[E0308]: mismatched types --> $DIR/issue-86100-tuple-paren-comma.rs:13:9 | LL | foo((Some(3))); - | --- ^^^^^^^^^ expected tuple, found enum `Option` - | | - | arguments to this function are incorrect + | ^^^^^^^^^ expected tuple, found enum `Option` | = 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,)) {} - | ^^^ -------- help: use a trailing comma to create a tuple with one element | LL | foo((Some(3),)); diff --git a/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr b/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr index 611f7d5ddda78..c15b772b79ca4 100644 --- a/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr +++ b/src/test/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr @@ -2,18 +2,11 @@ error[E0308]: mismatched types --> $DIR/issue-90213-expected-boxfuture-self-ice.rs:9:19 | LL | Self::foo(None) - | --------- ^^^^ expected struct `Box`, found enum `Option` - | | - | arguments to this function are incorrect + | ^^^^ expected struct `Box`, found enum `Option` | = note: expected struct `Box>` 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>) {} - | ^^^ ----------------- help: store this in the heap by calling `Box::new` | LL | Self::foo(Box::new(None)) diff --git a/src/test/ui/suggestions/recover-from-semicolon-trailing-item.stderr b/src/test/ui/suggestions/recover-from-semicolon-trailing-item.stderr index 9588eedc98b4a..aa621111c00c5 100644 --- a/src/test/ui/suggestions/recover-from-semicolon-trailing-item.stderr +++ b/src/test/ui/suggestions/recover-from-semicolon-trailing-item.stderr @@ -38,15 +38,7 @@ error[E0308]: mismatched types --> $DIR/recover-from-semicolon-trailing-item.rs:14:9 | LL | foo(""); - | --- ^^ 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) {}; - | ^^^ -------- + | ^^ expected `usize`, found `&str` error: aborting due to 6 previous errors diff --git a/src/test/ui/suggestions/suggest-ref-macro.stderr b/src/test/ui/suggestions/suggest-ref-macro.stderr index b0ac770c06f0f..5c05810e5868d 100644 --- a/src/test/ui/suggestions/suggest-ref-macro.stderr +++ b/src/test/ui/suggestions/suggest-ref-macro.stderr @@ -2,60 +2,31 @@ error[E0308]: mismatched types --> $DIR/suggest-ref-macro.rs:15:11 | LL | x(123); - | - ^^^ - | | | - | | expected `&mut i32`, found integer - | | help: consider mutably borrowing here: `&mut 123` - | arguments to this function are incorrect + | ^^^ + | | + | expected `&mut i32`, found integer + | help: consider mutably borrowing here: `&mut 123` ... 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 - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/suggest-ref-macro.rs:8:1 + | ^^^^^^^^ expected `&mut i32`, found integer | -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 diff --git a/src/test/ui/suggestions/trait-with-missing-associated-type-restriction-fixable.stderr b/src/test/ui/suggestions/trait-with-missing-associated-type-restriction-fixable.stderr index ac839ff7eb966..19fc772544d59 100644 --- a/src/test/ui/suggestions/trait-with-missing-associated-type-restriction-fixable.stderr +++ b/src/test/ui/suggestions/trait-with-missing-associated-type-restriction-fixable.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:13:13 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `::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 `::A` to `usize` | LL | fn foo<'a, T: Trait + 'a>(&self, _: impl Trait, x: impl Trait, _: T) { @@ -22,17 +15,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:17:13 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `::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 `::A` to `usize` | LL | fn ban(x: T) where T: Trait { @@ -42,17 +28,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:22:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `::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 `::A` to `usize` | LL | fn foo<'a, T: Trait + 'a>(_: impl Trait, x: impl Trait, _: T) { @@ -62,17 +41,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:26:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `::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 `::A` to `usize` | LL | fn bar>(x: T) { @@ -82,17 +54,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:30:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type ` 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 ` as Trait>::A` to `usize` | LL | fn foo2(x: impl Trait) { @@ -102,17 +67,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:34:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `>::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 `>::A` to `usize` | LL | fn bar2>(x: T) { @@ -122,17 +80,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction-fixable.rs:38:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `::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 `::A` to `usize` | LL | fn ban(x: T) where T: Trait { diff --git a/src/test/ui/suggestions/trait-with-missing-associated-type-restriction.stderr b/src/test/ui/suggestions/trait-with-missing-associated-type-restriction.stderr index 7583c875a1a37..943cbcbc81a22 100644 --- a/src/test/ui/suggestions/trait-with-missing-associated-type-restriction.stderr +++ b/src/test/ui/suggestions/trait-with-missing-associated-type-restriction.stderr @@ -16,17 +16,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction.rs:14:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `::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 `::A` to `usize` | LL | fn foo(_: impl Trait, x: impl Trait) { @@ -36,17 +29,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction.rs:18:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `::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 `::A` to `usize` | LL | fn bar>(x: T) { @@ -56,17 +42,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction.rs:22:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type ` 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 ` as Trait>::A` to `usize` | LL | fn foo2(x: impl Trait) { @@ -76,9 +55,7 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction.rs:26:12 | LL | x.funk(3); - | ---- ^ expected associated type, found integer - | | - | arguments to this function are incorrect + | ^ expected associated type, found integer | = note: expected associated type `>::A` found type `{integer}` @@ -90,11 +67,6 @@ LL | fn func(&self) -> Self::A; 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 `>::A` to `{integer}` | LL | fn bar2>(x: T) { @@ -104,17 +76,10 @@ error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction.rs:27:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `>::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 `>::A` to `usize` | LL | fn bar2>(x: T) { @@ -126,47 +91,25 @@ error[E0308]: mismatched types LL | fn baz>(x: T) { | - this type parameter LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found type parameter `D` - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found type parameter `D` | = 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 `()` - | | - | arguments to this function are incorrect - | -note: function defined here - --> $DIR/trait-with-missing-associated-type-restriction.rs:42:4 - | -LL | fn qux(_: usize) {} - | ^^^ -------- + | ^^^^^^^^ expected `usize`, found `()` error[E0308]: mismatched types --> $DIR/trait-with-missing-associated-type-restriction.rs:39:9 | LL | qux(x.func()) - | --- ^^^^^^^^ expected `usize`, found associated type - | | - | arguments to this function are incorrect + | ^^^^^^^^ expected `usize`, found associated type | = note: expected type `usize` found associated type `::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 `::A` to `usize` | LL | fn ban(x: T) where T: Trait { diff --git a/src/test/ui/terr-in-field.stderr b/src/test/ui/terr-in-field.stderr index d2fda09c0767f..5c6859a0efe98 100644 --- a/src/test/ui/terr-in-field.stderr +++ b/src/test/ui/terr-in-field.stderr @@ -2,15 +2,7 @@ error[E0308]: mismatched types --> $DIR/terr-in-field.rs:13:14 | LL | want_foo(b); - | -------- ^ 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) {} - | ^^^^^^^^ ------ + | ^ expected struct `Foo`, found struct `Bar` error: aborting due to previous error diff --git a/src/test/ui/terr-sorts.stderr b/src/test/ui/terr-sorts.stderr index 5a61a2fab1265..34d4d9eaded8a 100644 --- a/src/test/ui/terr-sorts.stderr +++ b/src/test/ui/terr-sorts.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/terr-sorts.rs:10:14 | LL | want_foo(b); - | -------- ^ expected struct `Foo`, found struct `Box` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found struct `Box` | = note: expected struct `Foo` found struct `Box` -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); diff --git a/src/test/ui/traits/bound/sugar.stderr b/src/test/ui/traits/bound/sugar.stderr index b67648c7b04da..feb0c73a09d3d 100644 --- a/src/test/ui/traits/bound/sugar.stderr +++ b/src/test/ui/traits/bound/sugar.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/sugar.rs:12:7 | LL | a(x); - | - ^ expected trait `Foo + Send`, found trait `Foo + Sync` - | | - | arguments to this function are incorrect + | ^ expected trait `Foo + Send`, found trait `Foo + Sync` | = 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) { - | ^ ----------------------- error: aborting due to previous error diff --git a/src/test/ui/traits/issue-52893.stderr b/src/test/ui/traits/issue-52893.stderr index 0ee44921bf5f8..bf732e2491566 100644 --- a/src/test/ui/traits/issue-52893.stderr +++ b/src/test/ui/traits/issue-52893.stderr @@ -5,17 +5,10 @@ LL | impl AddClass for Class

| - this type parameter ... LL | builder.push(output); - | ---- ^^^^^^ expected type parameter `F`, found struct `Class` - | | - | arguments to this function are incorrect + | ^^^^^^ expected type parameter `F`, found struct `Class` | = note: expected type parameter `F` found struct `Class

` -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 diff --git a/src/test/ui/traits/multidispatch-bad.stderr b/src/test/ui/traits/multidispatch-bad.stderr index 8b6e610067be1..6caa23d8f4997 100644 --- a/src/test/ui/traits/multidispatch-bad.stderr +++ b/src/test/ui/traits/multidispatch-bad.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/multidispatch-bad.rs:19:17 | LL | test(22i32, 44i32); - | ---- ^^^^^ expected `u32`, found `i32` - | | - | arguments to this function are incorrect + | ^^^^^ expected `u32`, found `i32` | -note: function defined here - --> $DIR/multidispatch-bad.rs:13:4 - | -LL | fn test(_: T, _: U) - | ^^^^ ---- ---- help: change the type of the numeric literal from `i32` to `u32` | LL | test(22i32, 44u32); diff --git a/src/test/ui/tuple/tuple-arity-mismatch.stderr b/src/test/ui/tuple/tuple-arity-mismatch.stderr index fff7be987f2e8..10bcedaf4aa9a 100644 --- a/src/test/ui/tuple/tuple-arity-mismatch.stderr +++ b/src/test/ui/tuple/tuple-arity-mismatch.stderr @@ -2,33 +2,19 @@ error[E0308]: mismatched types --> $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 - | | - | arguments to this function are incorrect + | ^^^^^^^^^ expected a tuple with 2 elements, found one with 3 elements | = 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 - | | - | arguments to this function are incorrect + | ^^^^ expected a tuple with 2 elements, found one with 1 element | = 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 diff --git a/src/test/ui/tuple/wrong_argument_ice-2.stderr b/src/test/ui/tuple/wrong_argument_ice-2.stderr index c704ae9934b1c..ddafc9763e79a 100644 --- a/src/test/ui/tuple/wrong_argument_ice-2.stderr +++ b/src/test/ui/tuple/wrong_argument_ice-2.stderr @@ -2,7 +2,7 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $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 diff --git a/src/test/ui/tuple/wrong_argument_ice-3.stderr b/src/test/ui/tuple/wrong_argument_ice-3.stderr index 6ea6e670fd600..f0d64d2a4e18d 100644 --- a/src/test/ui/tuple/wrong_argument_ice-3.stderr +++ b/src/test/ui/tuple/wrong_argument_ice-3.stderr @@ -2,21 +2,15 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $DIR/wrong_argument_ice-3.rs:9:16 | LL | groups.push(new_group, vec![process]); - | ^^^^ --------- ------------- argument unexpected - | | - | expected tuple, found struct `Vec` + | ^^^^ --------- ------------- supplied 2 arguments + | | + | expected 1 argument | - = note: expected tuple `(Vec, Vec)` - found struct `Vec` 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, Vec)}); - | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to previous error diff --git a/src/test/ui/tuple/wrong_argument_ice-4.stderr b/src/test/ui/tuple/wrong_argument_ice-4.stderr index f8dfc4cd043cd..fef5dca856db3 100644 --- a/src/test/ui/tuple/wrong_argument_ice-4.stderr +++ b/src/test/ui/tuple/wrong_argument_ice-4.stderr @@ -3,20 +3,12 @@ error[E0057]: this function takes 0 arguments but 1 argument was supplied | LL | (|| {})(|| { | _____^^^^^^^_- + | | | + | | expected 0 arguments LL | | LL | | let b = 1; LL | | }); - | |_____- argument unexpected - | -note: closure defined here - --> $DIR/wrong_argument_ice-4.rs:2:6 - | -LL | (|| {})(|| { - | ^^ -help: remove the extra argument - | -LL | (|| {})(); - | ~~~~~~~~~ + | |_____- supplied 1 argument error: aborting due to previous error diff --git a/src/test/ui/tuple/wrong_argument_ice.stderr b/src/test/ui/tuple/wrong_argument_ice.stderr index 2b4cb669f5c7d..e96a957350b2f 100644 --- a/src/test/ui/tuple/wrong_argument_ice.stderr +++ b/src/test/ui/tuple/wrong_argument_ice.stderr @@ -2,7 +2,7 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $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 diff --git a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr index 115ecb013766d..a384d5f561c94 100644 --- a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr +++ b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr @@ -5,17 +5,10 @@ LL | impl Enum { | - this type parameter LL | fn ts_variant() { LL | Self::TSVariant(()); - | --------------- ^^ expected type parameter `T`, found `()` - | | - | arguments to this function are incorrect + | ^^ expected type parameter `T`, found `()` | = note: expected type parameter `T` found unit type `()` -note: tuple variant defined here - --> $DIR/enum-variant-generic-args.rs:7:16 - | -LL | enum Enum { TSVariant(T), SVariant { v: T }, UVariant } - | ^^^^^^^^^ error[E0109]: type arguments are not allowed for this type --> $DIR/enum-variant-generic-args.rs:15:27 @@ -36,17 +29,10 @@ LL | impl Enum { | - this type parameter ... LL | Self::<()>::TSVariant(()); - | --------------------- ^^ expected type parameter `T`, found `()` - | | - | arguments to this function are incorrect + | ^^ expected type parameter `T`, found `()` | = note: expected type parameter `T` found unit type `()` -note: tuple variant defined here - --> $DIR/enum-variant-generic-args.rs:7:16 - | -LL | enum Enum { TSVariant(T), SVariant { v: T }, UVariant } - | ^^^^^^^^^ error[E0109]: type arguments are not allowed for this type --> $DIR/enum-variant-generic-args.rs:20:16 diff --git a/src/test/ui/type-alias-enum-variants/enum-variant-priority-higher-than-other-inherent.stderr b/src/test/ui/type-alias-enum-variants/enum-variant-priority-higher-than-other-inherent.stderr index 3fc5a3594d852..37543c137f66f 100644 --- a/src/test/ui/type-alias-enum-variants/enum-variant-priority-higher-than-other-inherent.stderr +++ b/src/test/ui/type-alias-enum-variants/enum-variant-priority-higher-than-other-inherent.stderr @@ -2,17 +2,15 @@ error[E0061]: this function takes 1 argument but 0 arguments were supplied --> $DIR/enum-variant-priority-higher-than-other-inherent.rs:21:5 | LL | ::V(); - | ^^^^^^-- an argument of type `u8` is missing + | ^^^^^^-- supplied 0 arguments + | | + | expected 1 argument | note: tuple variant defined here --> $DIR/enum-variant-priority-higher-than-other-inherent.rs:5:5 | LL | V(u8) | ^ -help: provide the argument - | -LL | ::V({u8}); - | ~~~~~~~~~~~~ error[E0308]: mismatched types --> $DIR/enum-variant-priority-higher-than-other-inherent.rs:22:17 diff --git a/src/test/ui/type/type-ascription-instead-of-initializer.stderr b/src/test/ui/type/type-ascription-instead-of-initializer.stderr index 18ed4986f8931..e5666d4fe4f4b 100644 --- a/src/test/ui/type/type-ascription-instead-of-initializer.stderr +++ b/src/test/ui/type/type-ascription-instead-of-initializer.stderr @@ -11,17 +11,15 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $DIR/type-ascription-instead-of-initializer.rs:2:12 | LL | let x: Vec::with_capacity(10, 20); - | ^^^^^^^^^^^^^^^^^^ -- argument unexpected + | ^^^^^^^^^^^^^^^^^^ -- -- supplied 2 arguments + | | + | expected 1 argument | 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 diff --git a/src/test/ui/type/type-mismatch-same-crate-name.stderr b/src/test/ui/type/type-mismatch-same-crate-name.stderr index 783f747fa6db6..49d40ebed130c 100644 --- a/src/test/ui/type/type-mismatch-same-crate-name.stderr +++ b/src/test/ui/type/type-mismatch-same-crate-name.stderr @@ -2,33 +2,19 @@ error[E0308]: mismatched types --> $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` - | | - | arguments to this function are incorrect + | ^^^^ expected struct `main::a::Foo`, found a different struct `main::a::Foo` | = 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` - | | - | arguments to this function are incorrect + | ^^^^ expected trait `main::a::Bar`, found a different trait `main::a::Bar` | = note: expected struct `Box<(dyn main::a::Bar + 'static)>` found struct `Box` = 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){} - | ^^^^^^^ error: aborting due to 2 previous errors diff --git a/src/test/ui/type/type-mismatch.stderr b/src/test/ui/type/type-mismatch.stderr index 6c187bad0725c..24c71c63103d3 100644 --- a/src/test/ui/type/type-mismatch.stderr +++ b/src/test/ui/type/type-mismatch.stderr @@ -2,749 +2,418 @@ error[E0308]: mismatched types --> $DIR/type-mismatch.rs:17:17 | LL | want::(f); - | ----------- ^ 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) {} - | ^^^^ ---- + | ^ expected struct `foo`, found `usize` error[E0308]: mismatched types --> $DIR/type-mismatch.rs:18:17 | LL | want::(f); - | ----------- ^ 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) {} - | ^^^^ ---- + | ^ expected struct `bar`, found `usize` error[E0308]: mismatched types --> $DIR/type-mismatch.rs:19:24 | LL | want::>(f); - | ------------------ ^ expected struct `Foo`, found `usize` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found `usize` | = note: expected struct `Foo` found type `usize` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:20:27 | LL | want::>(f); - | --------------------- ^ expected struct `Foo`, found `usize` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found `usize` | = note: expected struct `Foo` found type `usize` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:21:22 | LL | want::>(f); - | ---------------- ^ expected struct `Foo`, found `usize` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found `usize` | = note: expected struct `Foo` found type `usize` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:22:25 | LL | want::>(f); - | ------------------- ^ expected struct `Foo`, found `usize` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found `usize` | = note: expected struct `Foo` found type `usize` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:23:22 | LL | want::>(f); - | ---------------- ^ expected struct `Foo`, found `usize` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found `usize` | = note: expected struct `Foo` found type `usize` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:24:25 | LL | want::>(f); - | ------------------- ^ expected struct `Foo`, found `usize` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found `usize` | = note: expected struct `Foo` found type `usize` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:28:19 | LL | want::(f); - | ------------- ^ 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) {} - | ^^^^ ---- + | ^ expected `usize`, found struct `foo` error[E0308]: mismatched types --> $DIR/type-mismatch.rs:29:17 | LL | want::(f); - | ----------- ^ 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) {} - | ^^^^ ---- + | ^ expected struct `bar`, found struct `foo` error[E0308]: mismatched types --> $DIR/type-mismatch.rs:30:24 | LL | want::>(f); - | ------------------ ^ expected struct `Foo`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found struct `foo` | = note: expected struct `Foo` found struct `foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:31:27 | LL | want::>(f); - | --------------------- ^ expected struct `Foo`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found struct `foo` | = note: expected struct `Foo` found struct `foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:32:22 | LL | want::>(f); - | ---------------- ^ expected struct `Foo`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found struct `foo` | = note: expected struct `Foo` found struct `foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:33:25 | LL | want::>(f); - | ------------------- ^ expected struct `Foo`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found struct `foo` | = note: expected struct `Foo` found struct `foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:34:22 | LL | want::>(f); - | ---------------- ^ expected struct `Foo`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found struct `foo` | = note: expected struct `Foo` found struct `foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:35:25 | LL | want::>(f); - | ------------------- ^ expected struct `Foo`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `Foo`, found struct `foo` | = note: expected struct `Foo` found struct `foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:39:19 | LL | want::(f); - | ------------- ^ expected `usize`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `Foo` | = note: expected type `usize` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:40:17 | LL | want::(f); - | ----------- ^ expected struct `foo`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected struct `foo`, found struct `Foo` | = note: expected struct `foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:41:17 | LL | want::(f); - | ----------- ^ expected struct `bar`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `Foo` | = note: expected struct `bar` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:42:24 | LL | want::>(f); - | ------------------ ^ expected `usize`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:43:27 | LL | want::>(f); - | --------------------- ^ expected `usize`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:44:25 | LL | want::>(f); - | ------------------- ^ expected struct `B`, found struct `A` - | | - | arguments to this function are incorrect + | ^ expected struct `B`, found struct `A` | = note: expected struct `Foo<_, B>` found struct `Foo<_, A>` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:45:22 | LL | want::>(f); - | ---------------- ^ expected struct `bar`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:46:25 | LL | want::>(f); - | ------------------- ^ expected struct `bar`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:47:23 | LL | want::<&Foo>(f); - | ----------------- ^ - | | | - | | expected `&Foo`, found struct `Foo` - | | help: consider borrowing here: `&f` - | arguments to this function are incorrect + | ^ + | | + | expected `&Foo`, found struct `Foo` + | help: consider borrowing here: `&f` | = note: expected reference `&Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:48:26 | LL | want::<&Foo>(f); - | -------------------- ^ expected `&Foo`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected `&Foo`, found struct `Foo` | = note: expected reference `&Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:52:19 | LL | want::(f); - | ------------- ^ expected `usize`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `Foo` | = note: expected type `usize` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:53:17 | LL | want::(f); - | ----------- ^ expected struct `foo`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected struct `foo`, found struct `Foo` | = note: expected struct `foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:54:17 | LL | want::(f); - | ----------- ^ expected struct `bar`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `Foo` | = note: expected struct `bar` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:55:24 | LL | want::>(f); - | ------------------ ^ expected `usize`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:56:27 | LL | want::>(f); - | --------------------- ^ expected `usize`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:57:22 | LL | want::>(f); - | ---------------- ^ expected struct `A`, found struct `B` - | | - | arguments to this function are incorrect + | ^ expected struct `A`, found struct `B` | = note: expected struct `Foo<_, A>` found struct `Foo<_, B>` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:58:22 | LL | want::>(f); - | ---------------- ^ expected struct `bar`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:59:25 | LL | want::>(f); - | ------------------- ^ expected struct `bar`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:60:23 | LL | want::<&Foo>(f); - | ----------------- ^ expected `&Foo`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected `&Foo`, found struct `Foo` | = note: expected reference `&Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:61:26 | LL | want::<&Foo>(f); - | -------------------- ^ - | | | - | | expected `&Foo`, found struct `Foo` - | | help: consider borrowing here: `&f` - | arguments to this function are incorrect + | ^ + | | + | expected `&Foo`, found struct `Foo` + | help: consider borrowing here: `&f` | = note: expected reference `&Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:65:19 | LL | want::(f); - | ------------- ^ expected `usize`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `Foo` | = note: expected type `usize` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:66:17 | LL | want::(f); - | ----------- ^ expected struct `foo`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected struct `foo`, found struct `Foo` | = note: expected struct `foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:67:17 | LL | want::(f); - | ----------- ^ expected struct `bar`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `Foo` | = note: expected struct `bar` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:68:24 | LL | want::>(f); - | ------------------ ^ expected `usize`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:69:27 | LL | want::>(f); - | --------------------- ^ expected `usize`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected `usize`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:70:22 | LL | want::>(f); - | ---------------- ^ expected struct `A`, found struct `B` - | | - | arguments to this function are incorrect + | ^ expected struct `A`, found struct `B` | = 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) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:71:25 | LL | want::>(f); - | ------------------- ^ expected struct `B`, found struct `A` - | | - | arguments to this function are incorrect + | ^ expected struct `B`, found struct `A` | = note: expected struct `Foo<_, _, B>` found struct `Foo<_, _, A>` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:72:22 | LL | want::>(f); - | ---------------- ^ expected struct `bar`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:73:25 | LL | want::>(f); - | ------------------- ^ expected struct `bar`, found struct `foo` - | | - | arguments to this function are incorrect + | ^ expected struct `bar`, found struct `foo` | = note: expected struct `Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:74:23 | LL | want::<&Foo>(f); - | ----------------- ^ expected `&Foo`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected `&Foo`, found struct `Foo` | = note: expected reference `&Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error[E0308]: mismatched types --> $DIR/type-mismatch.rs:75:26 | LL | want::<&Foo>(f); - | -------------------- ^ expected `&Foo`, found struct `Foo` - | | - | arguments to this function are incorrect + | ^ expected `&Foo`, found struct `Foo` | = note: expected reference `&Foo` found struct `Foo` -note: function defined here - --> $DIR/type-mismatch.rs:14:4 - | -LL | fn want(t: T) {} - | ^^^^ ---- error: aborting due to 47 previous errors diff --git a/src/test/ui/typeck/issue-46112.stderr b/src/test/ui/typeck/issue-46112.stderr index 9346150750128..39bff88e7f81a 100644 --- a/src/test/ui/typeck/issue-46112.stderr +++ b/src/test/ui/typeck/issue-46112.stderr @@ -2,9 +2,7 @@ error[E0308]: mismatched types --> $DIR/issue-46112.rs:9:21 | LL | fn main() { test(Ok(())); } - | -- ^^ expected enum `Option`, found `()` - | | - | arguments to this enum variant are incorrect + | ^^ expected enum `Option`, found `()` | = note: expected enum `Option<()>` found unit type `()` diff --git a/src/test/ui/typeck/issue-84768.stderr b/src/test/ui/typeck/issue-84768.stderr index 04dc0e36520b4..0a79d539ea962 100644 --- a/src/test/ui/typeck/issue-84768.stderr +++ b/src/test/ui/typeck/issue-84768.stderr @@ -8,17 +8,10 @@ error[E0308]: mismatched types --> $DIR/issue-84768.rs:7:42 | LL | ::call_once(f, 1) - | --------------------------------- ^ expected tuple, found integer - | | - | arguments to this function are incorrect + | ^ expected tuple, found integer | = 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 diff --git a/src/test/ui/typeck/issue-89856.stderr b/src/test/ui/typeck/issue-89856.stderr index 5fa1ae1a54f72..4cb46a34a07a1 100644 --- a/src/test/ui/typeck/issue-89856.stderr +++ b/src/test/ui/typeck/issue-89856.stderr @@ -2,17 +2,10 @@ error[E0308]: mismatched types --> $DIR/issue-89856.rs:6:20 | LL | take_str_maybe(option); - | -------------- ^^^^^^ expected `str`, found struct `String` - | | - | arguments to this function are incorrect + | ^^^^^^ expected `str`, found struct `String` | = 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)); diff --git a/src/test/ui/typeck/remove-extra-argument.fixed b/src/test/ui/typeck/remove-extra-argument.fixed deleted file mode 100644 index a9338c76cdc88..0000000000000 --- a/src/test/ui/typeck/remove-extra-argument.fixed +++ /dev/null @@ -1,9 +0,0 @@ -// run-rustfix -// Check that the HELP suggestion is `l(vec![])` instead of `l($crate::vec::Vec::new())` -fn l(_a: Vec) {} - -fn main() { - l(vec![]) - //~^ ERROR this function takes 1 argument but 2 arguments were supplied - //~| HELP remove the extra argument -} diff --git a/src/test/ui/typeck/remove-extra-argument.rs b/src/test/ui/typeck/remove-extra-argument.rs index 659cb8b267fd5..bbe333f89b811 100644 --- a/src/test/ui/typeck/remove-extra-argument.rs +++ b/src/test/ui/typeck/remove-extra-argument.rs @@ -1,9 +1,7 @@ -// run-rustfix // Check that the HELP suggestion is `l(vec![])` instead of `l($crate::vec::Vec::new())` fn l(_a: Vec) {} fn main() { l(vec![], vec![]) //~^ ERROR this function takes 1 argument but 2 arguments were supplied - //~| HELP remove the extra argument } diff --git a/src/test/ui/typeck/remove-extra-argument.stderr b/src/test/ui/typeck/remove-extra-argument.stderr index 815297765c18c..923e80b48f095 100644 --- a/src/test/ui/typeck/remove-extra-argument.stderr +++ b/src/test/ui/typeck/remove-extra-argument.stderr @@ -1,18 +1,16 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied - --> $DIR/remove-extra-argument.rs:6:5 + --> $DIR/remove-extra-argument.rs:5:5 | LL | l(vec![], vec![]) - | ^ ------ argument unexpected + | ^ ------ ------ supplied 2 arguments + | | + | expected 1 argument | note: function defined here - --> $DIR/remove-extra-argument.rs:3:4 + --> $DIR/remove-extra-argument.rs:2:4 | LL | fn l(_a: Vec) {} | ^ ----------- -help: remove the extra argument - | -LL | l(vec![]) - | error: aborting due to previous error diff --git a/src/test/ui/typeck/struct-enum-wrong-args.stderr b/src/test/ui/typeck/struct-enum-wrong-args.stderr index 721b2c821efec..6e99feed33f9c 100644 --- a/src/test/ui/typeck/struct-enum-wrong-args.stderr +++ b/src/test/ui/typeck/struct-enum-wrong-args.stderr @@ -2,116 +2,95 @@ error[E0061]: this enum variant takes 1 argument but 2 arguments were supplied --> $DIR/struct-enum-wrong-args.rs:6:13 | LL | let _ = Some(3, 2); - | ^^^^ - argument unexpected - | -help: remove the extra argument - | -LL | let _ = Some(3); - | ~~~~~~~ + | ^^^^ - - supplied 2 arguments + | | + | expected 1 argument 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); - | ^^ - - argument unexpected - | | - | argument unexpected - | -help: remove the extra arguments - | -LL | let _ = Ok(3); - | ~~~~~ + | ^^ - - - supplied 3 arguments + | | + | expected 1 argument error[E0061]: this enum variant takes 1 argument but 0 arguments were supplied --> $DIR/struct-enum-wrong-args.rs:8:13 | LL | let _ = Ok(); - | ^^-- an argument is missing - | -help: provide the argument - | -LL | let _ = Ok({_}); - | ~~~~~~~ + | ^^-- supplied 0 arguments + | | + | expected 1 argument error[E0061]: this struct takes 1 argument but 0 arguments were supplied --> $DIR/struct-enum-wrong-args.rs:9:13 | LL | let _ = Wrapper(); - | ^^^^^^^-- an argument of type `i32` is missing + | ^^^^^^^-- supplied 0 arguments + | | + | expected 1 argument | 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); - | ^^^^^^^ - argument unexpected + | ^^^^^^^ - - supplied 2 arguments + | | + | expected 1 argument | 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(); - | ^^^^^^^^^^^^^-- two arguments of type `i32` and `i32` are missing + | ^^^^^^^^^^^^^-- supplied 0 arguments + | | + | expected 2 arguments | 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); - | ^^^^^^^^^^^^^--- an argument of type `i32` is missing + | ^^^^^^^^^^^^^ - supplied 1 argument + | | + | expected 2 arguments | 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); - | ^^^^^^^^^^^^^ - argument unexpected + | ^^^^^^^^^^^^^ - - - supplied 3 arguments + | | + | expected 2 arguments | 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 diff --git a/src/test/ui/ufcs/ufcs-qpath-self-mismatch.stderr b/src/test/ui/ufcs/ufcs-qpath-self-mismatch.stderr index c6f9b3661a232..74766d9fdd1b1 100644 --- a/src/test/ui/ufcs/ufcs-qpath-self-mismatch.stderr +++ b/src/test/ui/ufcs/ufcs-qpath-self-mismatch.stderr @@ -20,15 +20,8 @@ error[E0308]: mismatched types --> $DIR/ufcs-qpath-self-mismatch.rs:6:28 | LL | >::add(1u32, 2); - | ---------------------- ^^^^ expected `i32`, found `u32` - | | - | arguments to this function are incorrect + | ^^^^ expected `i32`, found `u32` | -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 | >::add(1i32, 2); @@ -38,15 +31,8 @@ error[E0308]: mismatched types --> $DIR/ufcs-qpath-self-mismatch.rs:8:31 | LL | >::add(1, 2u32); - | ---------------------- ^^^^ expected `i32`, found `u32` - | | - | arguments to this function are incorrect - | -note: associated function defined here - --> $SRC_DIR/core/src/ops/arith.rs:LL:COL + | ^^^^ expected `i32`, found `u32` | -LL | fn add(self, rhs: Rhs) -> Self::Output; - | ^^^ help: change the type of the numeric literal from `u32` to `i32` | LL | >::add(1, 2i32); diff --git a/src/test/ui/unboxed-closures/unboxed-closures-type-mismatch.stderr b/src/test/ui/unboxed-closures/unboxed-closures-type-mismatch.stderr index 3241c9f8521c0..f791ea62ceb65 100644 --- a/src/test/ui/unboxed-closures/unboxed-closures-type-mismatch.stderr +++ b/src/test/ui/unboxed-closures/unboxed-closures-type-mismatch.stderr @@ -2,15 +2,8 @@ error[E0308]: mismatched types --> $DIR/unboxed-closures-type-mismatch.rs:5:15 | LL | let z = f(1_usize, 2); - | - ^^^^^^^ expected `isize`, found `usize` - | | - | arguments to this function are incorrect + | ^^^^^^^ expected `isize`, found `usize` | -note: closure defined here - --> $DIR/unboxed-closures-type-mismatch.rs:4:17 - | -LL | let mut f = |x: isize, y: isize| -> isize { x + y }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: change the type of the numeric literal from `usize` to `isize` | LL | let z = f(1_isize, 2);