diff --git a/Cargo.lock b/Cargo.lock index 8d462a143abc8c3279a38a998b5588c662c34c81..f0c6e371c38be197f77023de408fbc9422962a69 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -318,7 +318,7 @@ dependencies = [ [[package]] name = "cargo" -version = "0.61.0" +version = "0.62.0" dependencies = [ "anyhow", "atty", diff --git a/compiler/rustc_typeck/src/check/demand.rs b/compiler/rustc_typeck/src/check/demand.rs index e164eff75502e340599173b19de029992b9d955c..3b644099ecf04a0b43ec16fa36a1f8cd301a065c 100644 --- a/compiler/rustc_typeck/src/check/demand.rs +++ b/compiler/rustc_typeck/src/check/demand.rs @@ -470,7 +470,7 @@ fn can_use_as_ref(&self, expr: &hir::Expr<'_>) -> Option<(Span, &'static str, St return None; }; - let self_ty = self.typeck_results.borrow().node_type(method_expr[0].hir_id); + let self_ty = self.typeck_results.borrow().expr_ty(&method_expr[0]); let self_ty = format!("{:?}", self_ty); let name = method_path.ident.name; let is_as_ref_able = (self_ty.starts_with("&std::option::Option") diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index f3aa40b9ad11e9f5a86fa56202c0c63ca41abe58..a8c9c699ceb54acd9e6e7ccebe28f4981194c308 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -1517,7 +1517,7 @@ fn check_expr_struct_fields( } } else { self.check_expr_has_type_or_error(base_expr, adt_ty, |_| { - let base_ty = self.typeck_results.borrow().node_type(base_expr.hir_id); + let base_ty = self.typeck_results.borrow().expr_ty(*base_expr); let same_adt = match (adt_ty.kind(), base_ty.kind()) { (ty::Adt(adt, _), ty::Adt(base_adt, _)) if adt == base_adt => true, _ => false, diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs index 5cb1fe8cd94ee97b23569f67995af738c4bc6ce1..2c81745836cdb385fae943901d40b08950b3588b 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs @@ -313,15 +313,6 @@ pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec> ) => { // A reborrow has no effect before a dereference. } - // Catch cases which have Deref(None) - // having them slip to bug! causes ICE - // see #94291 for more info - (&[Adjustment { kind: Adjust::Deref(None), .. }], _) => { - self.tcx.sess.delay_span_bug( - DUMMY_SP, - &format!("Can't compose Deref(None) expressions"), - ) - } // FIXME: currently we never try to compose autoderefs // and ReifyFnPointer/UnsafeFnPointer, but we could. _ => bug!( diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs index f5d110903e6e37e811c23f1616f42652e7ab2aec..3dfee99b83599f0e97edbe82f2c45a13b2148107 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs @@ -133,7 +133,8 @@ pub(in super::super) fn check_argument_types( let expected_arg_count = formal_input_tys.len(); // expected_count, arg_count, error_code, sugg_unit, sugg_tuple_wrap_args - let mut error: Option<(usize, usize, &str, bool, Option>)> = None; + let mut arg_count_error: Option<(usize, usize, &str, bool, Option>)> = + 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 { @@ -143,7 +144,8 @@ pub(in super::super) fn check_argument_types( ty::Tuple(arg_types) => { // Argument length differs if arg_types.len() != provided_args.len() { - error = Some((arg_types.len(), provided_args.len(), "E0057", false, None)); + arg_count_error = + Some((arg_types.len(), provided_args.len(), "E0057", false, None)); } let expected_input_tys = match expected_input_tys.get(0) { Some(&ty) => match ty.kind() { @@ -174,7 +176,8 @@ pub(in super::super) fn check_argument_types( if supplied_arg_count >= expected_arg_count { (formal_input_tys.to_vec(), expected_input_tys) } else { - error = Some((expected_arg_count, supplied_arg_count, "E0060", false, None)); + arg_count_error = + Some((expected_arg_count, supplied_arg_count, "E0060", false, None)); (self.err_args(supplied_arg_count), vec![]) } } else { @@ -198,7 +201,7 @@ pub(in super::super) fn check_argument_types( let sugg_tuple_wrap_args = self.suggested_tuple_wrap(expected_input_tys, provided_args); - error = Some(( + arg_count_error = Some(( expected_arg_count, supplied_arg_count, "E0061", @@ -231,6 +234,11 @@ pub(in super::super) fn check_argument_types( // This is more complicated than just checking type equality, as arguments could be coerced // This version writes those types back so further type checking uses the narrowed types let demand_compatible = |idx, final_arg_types: &mut Vec, Ty<'tcx>)>>| { + // Do not check argument compatibility if the number of args do not match + if arg_count_error.is_some() { + return; + } + let formal_input_ty: Ty<'tcx> = formal_input_tys[idx]; let expected_input_ty: Ty<'tcx> = expected_input_tys[idx]; let provided_arg = &provided_args[idx]; @@ -328,7 +336,8 @@ pub(in super::super) fn check_argument_types( } // If there was an error in parameter count, emit that here - if let Some((expected_count, arg_count, err_code, sugg_unit, sugg_tuple_wrap_args)) = error + if let Some((expected_count, arg_count, err_code, sugg_unit, sugg_tuple_wrap_args)) = + arg_count_error { let (span, start_span, args, ctor_of) = match &call_expr.kind { hir::ExprKind::Call( diff --git a/src/test/ui/mismatched_types/overloaded-calls-bad.rs b/src/test/ui/mismatched_types/overloaded-calls-bad.rs index d62625faaaa083b1bf6a907ecfb645c72768c263..902a6ec81d60b9cd87d328c50e1a3c89f6495382 100644 --- a/src/test/ui/mismatched_types/overloaded-calls-bad.rs +++ b/src/test/ui/mismatched_types/overloaded-calls-bad.rs @@ -30,5 +30,4 @@ fn main() { //~^ ERROR this function takes 1 argument but 0 arguments were supplied let ans = s("burma", "shave"); //~^ ERROR this function takes 1 argument but 2 arguments were supplied - //~| ERROR mismatched types } diff --git a/src/test/ui/mismatched_types/overloaded-calls-bad.stderr b/src/test/ui/mismatched_types/overloaded-calls-bad.stderr index 9ae9c474162d94c4c221b4b312260253a781af40..264d7cbb9b1cb9c2fa7b1765ebf353751479a98e 100644 --- a/src/test/ui/mismatched_types/overloaded-calls-bad.stderr +++ b/src/test/ui/mismatched_types/overloaded-calls-bad.stderr @@ -18,12 +18,6 @@ note: associated function defined here LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; | ^^^^^^^^ -error[E0308]: mismatched types - --> $DIR/overloaded-calls-bad.rs:31:17 - | -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 | @@ -38,7 +32,7 @@ note: associated function defined here LL | extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; | ^^^^^^^^ -error: aborting due to 4 previous errors +error: aborting due to 3 previous errors Some errors have detailed explanations: E0057, E0308. For more information about an error, try `rustc --explain E0057`. diff --git a/src/test/ui/tuple/wrong_argument_ice-2.rs b/src/test/ui/tuple/wrong_argument_ice-2.rs new file mode 100644 index 0000000000000000000000000000000000000000..b0f814616f2ecc492f9114042f59380140eb2d87 --- /dev/null +++ b/src/test/ui/tuple/wrong_argument_ice-2.rs @@ -0,0 +1,17 @@ +fn test(t: (i32, i32)) {} + +struct Foo; + +impl Foo { + fn qux(&self) -> i32 { + 0 + } +} + +fn bar() { + let x = Foo; + test(x.qux(), x.qux()); + //~^ ERROR this function takes 1 argument but 2 arguments were supplied +} + +fn main() {} diff --git a/src/test/ui/tuple/wrong_argument_ice-2.stderr b/src/test/ui/tuple/wrong_argument_ice-2.stderr new file mode 100644 index 0000000000000000000000000000000000000000..ddafc9763e79a6db7fcac23f37b9201b40def36a --- /dev/null +++ b/src/test/ui/tuple/wrong_argument_ice-2.stderr @@ -0,0 +1,19 @@ +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 + | +LL | fn test(t: (i32, i32)) {} + | ^^^^ ------------- +help: use parentheses to construct a tuple + | +LL | test((x.qux(), x.qux())); + | + + + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0061`. diff --git a/src/tools/cargo b/src/tools/cargo index d6cdde584a1f15ea086bae922e20fd27f7165431..3d6970d50e30e797b8e26b2b9b1bdf92dc381f34 160000 --- a/src/tools/cargo +++ b/src/tools/cargo @@ -1 +1 @@ -Subproject commit d6cdde584a1f15ea086bae922e20fd27f7165431 +Subproject commit 3d6970d50e30e797b8e26b2b9b1bdf92dc381f34