fix rustc_mir_transform validator

Author: BennoLossin

compiler/rustc_mir_transform/src/validate.rs

@@ -1341,55 +1341,57 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     }
                 }
             }
-            Rvalue::NullaryOp(NullOp::FieldOffset, ty) => {
-                let ty::Field(container, field_path) = ty.kind() else {
-                    span_bug!(
-                        self.body.span,
-                        "FIXME(field_projections): expected ty::Field, found {ty:?}"
-                    )
-                };
-                let fail_out_of_bounds = |this: &mut Self, location, field, ty| {
-                    this.fail(location, format!("Out of bounds field {field:?} for {ty}"));
-                };
-
-                let mut current_ty = *container;
-
-                for (variant, field) in field_path.iter() {
-                    match current_ty.kind() {
-                        ty::Tuple(fields) => {
-                            if variant != FIRST_VARIANT {
+            Rvalue::NullaryOp(NullOp::FieldOffset, ty) => match ty.kind() {
+                ty::Alias(..) | ty::Param(_) | ty::Placeholder(_) | ty::Infer(_) => {}
+                ty::Field(container, field_path) => {
+                    let fail_out_of_bounds = |this: &mut Self, location, field, ty| {
+                        this.fail(location, format!("Out of bounds field {field:?} for {ty}"));
+                    };
+
+                    let mut current_ty = *container;
+
+                    for (variant, field) in field_path.iter() {
+                        match current_ty.kind() {
+                            ty::Tuple(fields) => {
+                                if variant != FIRST_VARIANT {
+                                    self.fail(
+                                        location,
+                                        format!("tried to get variant {variant:?} of tuple"),
+                                    );
+                                    return;
+                                }
+                                let Some(&f_ty) = fields.get(field.as_usize()) else {
+                                    fail_out_of_bounds(self, location, field, current_ty);
+                                    return;
+                                };
+
+                                current_ty =
+                                    self.tcx.normalize_erasing_regions(self.typing_env, f_ty);
+                            }
+                            ty::Adt(adt_def, args) => {
+                                let Some(field) = adt_def.variant(variant).fields.get(field) else {
+                                    fail_out_of_bounds(self, location, field, current_ty);
+                                    return;
+                                };
+
+                                let f_ty = field.ty(self.tcx, args);
+                                current_ty =
+                                    self.tcx.normalize_erasing_regions(self.typing_env, f_ty);
+                            }
+                            _ => {
                                 self.fail(
-                                    location,
-                                    format!("tried to get variant {variant:?} of tuple"),
-                                );
+                                            location,
+                                            format!("Cannot get offset ({variant:?}, {field:?}) from type {current_ty}"),
+                                        );
                                 return;
                             }
-                            let Some(&f_ty) = fields.get(field.as_usize()) else {
-                                fail_out_of_bounds(self, location, field, current_ty);
-                                return;
-                            };
-
-                            current_ty = self.tcx.normalize_erasing_regions(self.typing_env, f_ty);
-                        }
-                        ty::Adt(adt_def, args) => {
-                            let Some(field) = adt_def.variant(variant).fields.get(field) else {
-                                fail_out_of_bounds(self, location, field, current_ty);
-                                return;
-                            };
-
-                            let f_ty = field.ty(self.tcx, args);
-                            current_ty = self.tcx.normalize_erasing_regions(self.typing_env, f_ty);
-                        }
-                        _ => {
-                            self.fail(
-                                location,
-                                format!("Cannot get offset ({variant:?}, {field:?}) from type {current_ty}"),
-                            );
-                            return;
                         }
                     }
                 }
-            }
+                _ => {
+                    span_bug!(self.body.span, "expected `ty::Field` or generic type, found {ty:?}")
+                }
+            },
             Rvalue::Repeat(_, _)
             | Rvalue::ThreadLocalRef(_)
             | Rvalue::RawPtr(_, _)