lower_field_path: don't query the type of the last field

Author: BennoLossin

compiler/rustc_hir_analysis/src/collect.rs

@@ -363,7 +363,7 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
 
         let mut field_indices = Vec::with_capacity(fields.len());
         let mut current_container = container;
-        let mut fields = fields.into_iter();
+        let mut fields = fields.into_iter().peekable();
         let mut infcx = None;
         let infcx = self.infcx().unwrap_or_else(|| {
             assert!(!container.has_infer());
@@ -375,6 +375,7 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
         let ty_ch_cx = RefCell::new(<dyn TraitEngine<'_, FulfillmentError<'tcx>>>::new(&infcx));
 
         while let Some(&field) = fields.next() {
+            let last = fields.peek().is_none();
             let result =
                 at.structurally_normalize_ty(current_container, &mut **ty_ch_cx.borrow_mut());
             let container = match result {
@@ -392,8 +393,6 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
                         .iter_enumerated()
                         .find(|(_, f)| f.ident(self.tcx).normalize_to_macros_2_0() == ident)
                     {
-                        let field_ty = field.ty(self.tcx, args);
-
                         if field.vis.is_accessible_from(def_scope, self.tcx) {
                             self.tcx.check_stability(field.did, Some(hir_id), span, None);
                         } else {
@@ -411,7 +410,10 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
                         }
 
                         field_indices.push((FIRST_VARIANT, index));
-                        current_container = field_ty;
+                        if !last {
+                            let field_ty = field.ty(self.tcx, args);
+                            current_container = field_ty;
+                        }
 
                         continue;
                     }

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -282,9 +282,10 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
 
         let mut field_indices = Vec::with_capacity(fields.len());
         let mut current_container = container;
-        let mut fields = fields.into_iter();
+        let mut fields = fields.into_iter().peekable();
 
         while let Some(&field) = fields.next() {
+            let last = fields.peek().is_none();
             let container = self.structurally_resolve_type(span, current_container);
 
             match container.kind() {
@@ -351,30 +352,33 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
                             .emit_unless_delay(container.references_error()));
                     };
 
-                    let field_ty = self.field_ty(span, field, args);
-
-                    // Enums are anyway always sized. But just to safeguard against future
-                    // language extensions, let's double-check.
-                    self.require_type_is_sized(
-                        field_ty,
-                        span,
-                        ObligationCauseCode::FieldSized {
-                            adt_kind: AdtKind::Enum,
-                            span: self.tcx.def_span(field.did),
-                            last: false,
-                        },
-                    );
-
-                    if field.vis.is_accessible_from(sub_def_scope, self.tcx) {
-                        self.tcx.check_stability(field.did, Some(hir_id), span, None);
-                    } else {
-                        self.private_field_err(ident, container_def.did()).emit();
-                    }
-
                     // Save the index of all fields regardless of their visibility in case
                     // of error recovery.
                     field_indices.push((index, subindex));
-                    current_container = field_ty;
+
+                    if !last {
+                        let field_ty = self.field_ty(span, field, args);
+
+                        // Enums are anyway always sized. But just to safeguard against future
+                        // language extensions, let's double-check.
+                        self.require_type_is_sized(
+                            field_ty,
+                            span,
+                            ObligationCauseCode::FieldSized {
+                                adt_kind: AdtKind::Enum,
+                                span: self.tcx.def_span(field.did),
+                                last: false,
+                            },
+                        );
+
+                        if field.vis.is_accessible_from(sub_def_scope, self.tcx) {
+                            self.tcx.check_stability(field.did, Some(hir_id), span, None);
+                        } else {
+                            self.private_field_err(ident, container_def.did()).emit();
+                        }
+
+                        current_container = field_ty;
+                    }
 
                     continue;
                 }
@@ -388,37 +392,40 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
                         .iter_enumerated()
                         .find(|(_, f)| f.ident(self.tcx).normalize_to_macros_2_0() == ident)
                     {
-                        let field_ty = self.field_ty(span, field, args);
+                        // Save the index of all fields regardless of their visibility in case
+                        // of error recovery.
+                        field_indices.push((FIRST_VARIANT, index));
+
+                        if !last {
+                            let field_ty = self.field_ty(span, field, args);
 
-                        match field_path_kind {
-                            FieldPathKind::OffsetOf => {
-                                if self.tcx.features().offset_of_slice() {
-                                    self.require_type_has_static_alignment(field_ty, span);
-                                } else {
-                                    self.require_type_is_sized(
-                                        field_ty,
-                                        span,
-                                        ObligationCauseCode::Misc,
-                                    );
+                            match field_path_kind {
+                                FieldPathKind::OffsetOf => {
+                                    if self.tcx.features().offset_of_slice() {
+                                        self.require_type_has_static_alignment(field_ty, span);
+                                    } else {
+                                        self.require_type_is_sized(
+                                            field_ty,
+                                            span,
+                                            ObligationCauseCode::Misc,
+                                        );
+                                    }
+                                }
+                                FieldPathKind::FieldOf => {
+                                    // A field type always exists regardless of weather it is aligned or
+                                    // not.
                                 }
                             }
-                            FieldPathKind::FieldOf => {
-                                // A field type always exists regardless of weather it is aligned or
-                                // not.
+
+                            if field.vis.is_accessible_from(def_scope, self.tcx) {
+                                self.tcx.check_stability(field.did, Some(hir_id), span, None);
+                            } else {
+                                self.private_field_err(ident, container_def.did()).emit();
                             }
-                        }
 
-                        if field.vis.is_accessible_from(def_scope, self.tcx) {
-                            self.tcx.check_stability(field.did, Some(hir_id), span, None);
-                        } else {
-                            self.private_field_err(ident, container_def.did()).emit();
+                            current_container = field_ty;
                         }
 
-                        // Save the index of all fields regardless of their visibility in case
-                        // of error recovery.
-                        field_indices.push((FIRST_VARIANT, index));
-                        current_container = field_ty;
-
                         continue;
                     }
                 }