Auto merge of #146637 - lcnr:yeet-unnecessary-resolve, r=<try>

remove unnecessary `structurally_resolve_type`

Author: rust-bors[bot]

compiler/rustc_hir_typeck/src/method/confirm.rs

@@ -172,7 +172,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
         // Commit the autoderefs by calling `autoderef` again, but this
         // time writing the results into the various typeck results.
         let mut autoderef = self.autoderef(self.call_expr.span, unadjusted_self_ty);
-        let Some((ty, n)) = autoderef.nth(pick.autoderefs) else {
+        let Some((mut target, n)) = autoderef.nth(pick.autoderefs) else {
             return Ty::new_error_with_message(
                 self.tcx,
                 DUMMY_SP,
@@ -182,7 +182,6 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
         assert_eq!(n, pick.autoderefs);
 
         let mut adjustments = self.adjust_steps(&autoderef);
-        let mut target = self.structurally_resolve_type(autoderef.span(), ty);
 
         match pick.autoref_or_ptr_adjustment {
             Some(probe::AutorefOrPtrAdjustment::Autoref { mutbl, unsize }) => {

compiler/rustc_hir_typeck/src/place_op.rs

@@ -72,7 +72,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         ty: Ty<'tcx>,
         span: Span,
         base_expr: &hir::Expr<'_>,
-    ) -> Option<(Ty<'tcx>, Ty<'tcx>)> {
+    ) -> (Ty<'tcx>, Ty<'tcx>) {
         let ty = self.resolve_vars_if_possible(ty);
         let mut err = self.dcx().struct_span_err(
             span,
@@ -92,8 +92,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Applicability::MachineApplicable,
             );
         }
-        let reported = err.emit();
-        Some((Ty::new_error(self.tcx, reported), Ty::new_error(self.tcx, reported)))
+        let guar = err.emit();
+        (Ty::new_error(self.tcx, guar), Ty::new_error(self.tcx, guar))
     }
 
     /// To type-check `base_expr[index_expr]`, we progressively autoderef
@@ -109,7 +109,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         index_ty: Ty<'tcx>,
         index_expr: &hir::Expr<'_>,
     ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
-        let adjusted_ty = self.structurally_resolve_type(autoderef.span(), autoderef.final_ty());
+        let adjusted_ty = autoderef.final_ty();
         debug!(
             "try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
              index_ty={:?})",
@@ -126,10 +126,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         {
             match adjusted_ty.kind() {
                 ty::Adt(def, _) if self.tcx.is_diagnostic_item(sym::Vec, def.did()) => {
-                    return self.negative_index(adjusted_ty, index_expr.span, base_expr);
+                    return Some(self.negative_index(adjusted_ty, index_expr.span, base_expr));
                 }
                 ty::Slice(_) | ty::Array(_, _) => {
-                    return self.negative_index(adjusted_ty, index_expr.span, base_expr);
+                    return Some(self.negative_index(adjusted_ty, index_expr.span, base_expr));
                 }
                 _ => {}
             }