Auto merge of rust-lang#127575 - chenyukang:yukang-fix-struct-fields-ice, r=<try>

Avoid no field error and ice no recovered struct variant

Fixes rust-lang#126744
Fixes rust-lang#126344, a more general fix compared with rust-lang#127426

r? `@oli-obk`

From `@compiler-errors` 's comment rust-lang#127502 (comment)
Seems most of the ADTs don't have taint, so maybe it's not proper to change `TyCtxt::type_of` query.

Author: bors

compiler/rustc_hir_analysis/src/collect.rs

@@ -1125,7 +1125,10 @@ fn lower_variant(
             vis: tcx.visibility(f.def_id),
         })
         .collect();
-    let recovered = matches!(def, hir::VariantData::Struct { recovered: Recovered::Yes(_), .. });
+    let recovered = match def {
+        hir::VariantData::Struct { recovered: Recovered::Yes(guard), .. } => Some(guard).copied(),
+        _ => None,
+    };
     ty::VariantDef::new(
         ident.name,
         variant_did.map(LocalDefId::to_def_id),

compiler/rustc_hir_typeck/src/expr.rs

@@ -2177,11 +2177,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         skip_fields: &[hir::ExprField<'_>],
         kind_name: &str,
     ) -> ErrorGuaranteed {
-        if variant.is_recovered() {
-            let guar =
-                self.dcx().span_delayed_bug(expr.span, "parser recovered but no error was emitted");
-            self.set_tainted_by_errors(guar);
-            return guar;
+        if let Some(guaranteed) = variant.has_errors() {
+            return guaranteed;
         }
         let mut err = self.err_ctxt().type_error_struct_with_diag(
             field.ident.span,
@@ -2547,6 +2544,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             "ban_nonexisting_field: field={:?}, base={:?}, expr={:?}, base_ty={:?}",
             ident, base, expr, base_ty
         );
+
+        for (ty, _) in self.autoderef(expr.span, base_ty) {
+            if let ty::Adt(def, _) = ty.kind()
+                && !def.is_enum()
+            {
+                let variant = def.non_enum_variant();
+                if let Some(taint) = variant.has_errors() {
+                    return taint;
+                }
+            }
+        }
+
         let mut err = self.no_such_field_err(ident, base_ty, base.hir_id);
 
         match *base_ty.peel_refs().kind() {

compiler/rustc_hir_typeck/src/pat.rs

@@ -1531,9 +1531,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .filter(|(_, ident)| !used_fields.contains_key(ident))
             .collect::<Vec<_>>();
 
-        let inexistent_fields_err = if !(inexistent_fields.is_empty() || variant.is_recovered())
+        let inexistent_fields_err = if !inexistent_fields.is_empty()
             && !inexistent_fields.iter().any(|field| field.ident.name == kw::Underscore)
         {
+            if let Some(guard) = variant.has_errors() {
+                return Err(guard);
+            }
             Some(self.error_inexistent_fields(
                 adt.variant_descr(),
                 &inexistent_fields,
@@ -1812,6 +1815,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return Ok(());
             }
 
+            if let Some(guaranteed) = variant.has_errors() {
+                return Err(guaranteed);
+            }
+
             let path = rustc_hir_pretty::qpath_to_string(&self.tcx, qpath);
             let mut err = struct_span_code_err!(
                 self.dcx(),

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1133,7 +1133,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
                     .collect(),
                 adt_kind,
                 parent_did,
-                false,
+                None,
                 data.is_non_exhaustive,
                 // FIXME: unnamed fields in crate metadata is unimplemented yet.
                 false,

compiler/rustc_middle/src/ty/mod.rs

@@ -1183,6 +1183,8 @@ pub struct VariantDef {
     pub discr: VariantDiscr,
     /// Fields of this variant.
     pub fields: IndexVec<FieldIdx, FieldDef>,
+    /// The error guarantees from parser, if any.
+    tainted: Option<ErrorGuaranteed>,
     /// Flags of the variant (e.g. is field list non-exhaustive)?
     flags: VariantFlags,
 }
@@ -1212,7 +1214,7 @@ impl VariantDef {
         fields: IndexVec<FieldIdx, FieldDef>,
         adt_kind: AdtKind,
         parent_did: DefId,
-        recovered: bool,
+        recover_tainted: Option<ErrorGuaranteed>,
         is_field_list_non_exhaustive: bool,
         has_unnamed_fields: bool,
     ) -> Self {
@@ -1227,15 +1229,23 @@ impl VariantDef {
             flags |= VariantFlags::IS_FIELD_LIST_NON_EXHAUSTIVE;
         }
 
-        if recovered {
+        if recover_tainted.is_some() {
             flags |= VariantFlags::IS_RECOVERED;
         }
 
         if has_unnamed_fields {
             flags |= VariantFlags::HAS_UNNAMED_FIELDS;
         }
 
-        VariantDef { def_id: variant_did.unwrap_or(parent_did), ctor, name, discr, fields, flags }
+        VariantDef {
+            def_id: variant_did.unwrap_or(parent_did),
+            ctor,
+            name,
+            discr,
+            fields,
+            flags,
+            tainted: recover_tainted,
+        }
     }
 
     /// Is this field list non-exhaustive?
@@ -1244,12 +1254,6 @@ impl VariantDef {
         self.flags.intersects(VariantFlags::IS_FIELD_LIST_NON_EXHAUSTIVE)
     }
 
-    /// Was this variant obtained as part of recovering from a syntactic error?
-    #[inline]
-    pub fn is_recovered(&self) -> bool {
-        self.flags.intersects(VariantFlags::IS_RECOVERED)
-    }
-
     /// Does this variant contains unnamed fields
     #[inline]
     pub fn has_unnamed_fields(&self) -> bool {
@@ -1261,6 +1265,11 @@ impl VariantDef {
         Ident::new(self.name, tcx.def_ident_span(self.def_id).unwrap())
     }
 
+    /// Was this variant obtained as part of recovering from a syntactic error?
+    pub fn has_errors(&self) -> Option<ErrorGuaranteed> {
+        self.tainted
+    }
+
     #[inline]
     pub fn ctor_kind(&self) -> Option<CtorKind> {
         self.ctor.map(|(kind, _)| kind)
@@ -1308,8 +1317,24 @@ impl PartialEq for VariantDef {
         // definition of `VariantDef` changes, a compile-error will be produced,
         // reminding us to revisit this assumption.
 
-        let Self { def_id: lhs_def_id, ctor: _, name: _, discr: _, fields: _, flags: _ } = &self;
-        let Self { def_id: rhs_def_id, ctor: _, name: _, discr: _, fields: _, flags: _ } = other;
+        let Self {
+            def_id: lhs_def_id,
+            ctor: _,
+            name: _,
+            discr: _,
+            fields: _,
+            flags: _,
+            tainted: _,
+        } = &self;
+        let Self {
+            def_id: rhs_def_id,
+            ctor: _,
+            name: _,
+            discr: _,
+            fields: _,
+            flags: _,
+            tainted: _,
+        } = other;
 
         let res = lhs_def_id == rhs_def_id;
 
@@ -1339,7 +1364,7 @@ impl Hash for VariantDef {
         // of `VariantDef` changes, a compile-error will be produced, reminding
         // us to revisit this assumption.
 
-        let Self { def_id, ctor: _, name: _, discr: _, fields: _, flags: _ } = &self;
+        let Self { def_id, ctor: _, name: _, discr: _, fields: _, flags: _, tainted: _ } = &self;
         def_id.hash(s)
     }
 }

tests/ui/pattern/struct-parser-recovery-issue-126344.rs

@@ -0,0 +1,42 @@
+struct Wrong {
+    x: i32; //~ ERROR struct fields are separated by `,`
+    y: i32,
+    z: i32,
+    h: i32,
+}
+
+fn oops(w: &Wrong) {
+    w.x;
+}
+
+fn foo(w: &Wrong) {
+    w.y;
+}
+
+fn haha(w: &Wrong) {
+    w.z;
+}
+
+struct WrongWithType {
+    x: 1, //~ ERROR expected type, found `1`
+    y: i32,
+    z: i32,
+    h: i32,
+}
+
+fn oops_type(w: &WrongWithType) {
+    w.x;
+}
+
+fn foo_type(w: &WrongWithType) {
+    w.y;
+}
+
+fn haha_type(w: &WrongWithType) {
+    w.z;
+}
+
+fn main() {
+    let v = Wrong { x: 1, y: 2, z: 3, h: 4 };
+    let x = WrongWithType { x: 1, y: 2, z: 3, h: 4 };
+}

tests/ui/pattern/struct-parser-recovery-issue-126344.stderr

@@ -0,0 +1,18 @@
+error: struct fields are separated by `,`
+  --> $DIR/struct-parser-recovery-issue-126344.rs:2:11
+   |
+LL | struct Wrong {
+   |        ----- while parsing this struct
+LL |     x: i32;
+   |           ^ help: replace `;` with `,`
+
+error: expected type, found `1`
+  --> $DIR/struct-parser-recovery-issue-126344.rs:21:8
+   |
+LL | struct WrongWithType {
+   |        ------------- while parsing this struct
+LL |     x: 1,
+   |        ^ expected type
+
+error: aborting due to 2 previous errors
+

tests/ui/typeck/struct-index-err-ice-issue-126744.rs

@@ -0,0 +1,7 @@
+struct X {,} //~ ERROR expected identifier, found `,`
+
+fn main() {
+    || {
+        if let X { x: 1,} = (X {}) {}
+    };
+}

tests/ui/typeck/struct-index-err-ice-issue-126744.stderr

@@ -0,0 +1,10 @@
+error: expected identifier, found `,`
+  --> $DIR/struct-index-err-ice-issue-126744.rs:1:11
+   |
+LL | struct X {,}
+   |        -  ^ expected identifier
+   |        |
+   |        while parsing this struct
+
+error: aborting due to 1 previous error
+