Recover from struct literals with placeholder path

Based on earlier work by León Orell Valerian Liehr.

Co-authored-by: León Orell Valerian Liehr <me@fmease.dev>
Signed-off-by: Usman Akinyemi <uniqueusman@archlinux>

Author: Unique-Usman

compiler/rustc_errors/src/lib.rs

@@ -660,6 +660,7 @@ pub enum StashKey {
     /// it's a method call without parens. If later on in `hir_typeck` we find out that this is
     /// the case we suppress this message and we give a better suggestion.
     GenericInFieldExpr,
+    StructLitNoType,
 }
 
 fn default_track_diagnostic<R>(diag: DiagInner, f: &mut dyn FnMut(DiagInner) -> R) -> R {

compiler/rustc_hir_typeck/src/expr.rs

@@ -12,8 +12,8 @@ use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::unord::UnordMap;
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Applicability, Diag, ErrorGuaranteed, MultiSpan, StashKey, Subdiagnostic, listify, pluralize,
-    struct_span_code_err,
+    Applicability, Diag, ErrorGuaranteed, MultiSpan, StashKey, Subdiagnostic, Suggestions, listify,
+    pluralize, struct_span_code_err,
 };
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{CtorKind, DefKind, Res};
@@ -1830,6 +1830,40 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         fields: &'tcx [hir::ExprField<'tcx>],
         base_expr: &'tcx hir::StructTailExpr<'tcx>,
     ) -> Ty<'tcx> {
+        // FIXME(fmease): Move this into separate method.
+        // FIXME(fmease): This doesn't get called given `(_ { x: () }).x` (`hir::Field`).
+        //                Figure out why.
+        if let QPath::Resolved(None, hir::Path { res: Res::Err, segments, .. }) = qpath
+            && let [segment] = segments
+            && segment.ident.name == kw::EmptyStructType
+            && let Expectation::ExpectHasType(ty) = expected
+            && ty.is_adt()
+            && let Some(guar) = self.dcx().try_steal_modify_and_emit_err(
+                expr.span,
+                StashKey::StructLitNoType,
+                |err| {
+                    // The parser provided a sub-optimal `HasPlaceholders` suggestion for the type.
+                    // We are typeck and have the real type, so remove that and suggest the actual type.
+                    if let Suggestions::Enabled(suggestions) = &mut err.suggestions {
+                        suggestions.clear();
+                    }
+
+                    err.span_suggestion(
+                        qpath.span(),
+                        // FIXME(fmease): Make this translatable.
+                        "replace it with the correct type",
+                        // FIXME(fmease): This doesn't qualify paths within the type appropriately.
+                        // FIXME(fmease): This doesn't use turbofish when emitting generic args.
+                        // FIXME(fmease): Make the type suggestable.
+                        ty.to_string(),
+                        Applicability::MaybeIncorrect,
+                    );
+                },
+            )
+        {
+            return Ty::new_error(self.tcx, guar);
+        }
+
         // Find the relevant variant
         let (variant, adt_ty) = match self.check_struct_path(qpath, expr.hir_id) {
             Ok(data) => data,

compiler/rustc_parse/messages.ftl

@@ -822,9 +822,19 @@ parse_struct_literal_body_without_path =
     struct literal body without path
     .suggestion = you might have forgotten to add the struct literal inside the block
 
+parse_struct_literal_body_without_path_late =
+    struct literal body without path
+    .label = absent of struct name for this struct literal
+    .suggestion = replace it with an appropriate type
+
 parse_struct_literal_not_allowed_here = struct literals are not allowed here
     .suggestion = surround the struct literal with parentheses
 
+parse_struct_literal_placeholder_path =
+    the placeholder `_` is not allowed for the path in struct literals
+    .label = not allowed in struct literals
+    .suggestion = replace it with an appropriate type
+
 parse_suffixed_literal_in_attribute = suffixed literals are not allowed in attributes
     .help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
 

compiler/rustc_parse/src/errors.rs

@@ -3684,3 +3684,21 @@ pub(crate) struct ImplReuseInherentImpl {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(parse_struct_literal_placeholder_path)]
+pub(crate) struct StructLiteralPlaceholderPath {
+    #[primary_span]
+    #[label]
+    #[suggestion(applicability = "has-placeholders", code = "/*Type*/")]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_struct_literal_body_without_path_late)]
+pub(crate) struct StructLiteralWithoutPathLate {
+    #[primary_span]
+    #[label]
+    #[suggestion(applicability = "has-placeholders", code = "/*Type*/")]
+    pub span: Span,
+}

compiler/rustc_parse/src/parser/expr.rs

@@ -1468,6 +1468,9 @@ impl<'a> Parser<'a> {
             } else if this.check(exp!(OpenParen)) {
                 this.parse_expr_tuple_parens(restrictions)
             } else if this.check(exp!(OpenBrace)) {
+                if let Some(expr) = this.maybe_recover_bad_struct_literal_path(false)? {
+                    return Ok(expr);
+                }
                 this.parse_expr_block(None, lo, BlockCheckMode::Default)
             } else if this.check(exp!(Or)) || this.check(exp!(OrOr)) {
                 this.parse_expr_closure().map_err(|mut err| {
@@ -1542,6 +1545,9 @@ impl<'a> Parser<'a> {
             } else if this.check_keyword(exp!(Let)) {
                 this.parse_expr_let(restrictions)
             } else if this.eat_keyword(exp!(Underscore)) {
+                if let Some(expr) = this.maybe_recover_bad_struct_literal_path(true)? {
+                    return Ok(expr);
+                }
                 Ok(this.mk_expr(this.prev_token.span, ExprKind::Underscore))
             } else if this.token_uninterpolated_span().at_least_rust_2018() {
                 // `Span::at_least_rust_2018()` is somewhat expensive; don't get it repeatedly.
@@ -3698,6 +3704,46 @@ impl<'a> Parser<'a> {
         }
     }
 
+    fn maybe_recover_bad_struct_literal_path(
+        &mut self,
+        is_underscore_entry_point: bool,
+    ) -> PResult<'a, Option<Box<Expr>>> {
+        if self.may_recover()
+            && self.check_noexpect(&token::OpenBrace)
+            && (!self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL)
+                && self.is_likely_struct_lit())
+        {
+            let span = if is_underscore_entry_point {
+                self.prev_token.span
+            } else {
+                self.prev_token.span.shrink_to_hi()
+            };
+
+            // { consumed
+            self.bump();
+
+            let expr = self.parse_expr_struct(
+                None,
+                Path::from_ident(Ident::new(kw::EmptyStructType, span)),
+                false,
+            )?;
+
+            if is_underscore_entry_point {
+                self.dcx()
+                    .create_err(errors::StructLiteralPlaceholderPath { span: expr.span })
+                    .stash(expr.span, StashKey::StructLitNoType);
+            } else {
+                self.dcx()
+                    .create_err(errors::StructLiteralWithoutPathLate { span: expr.span })
+                    .stash(expr.span, StashKey::StructLitNoType);
+            }
+
+            Ok(Some(expr))
+        } else {
+            Ok(None)
+        }
+    }
+
     pub(super) fn parse_struct_fields(
         &mut self,
         pth: ast::Path,

compiler/rustc_resolve/src/late.rs

@@ -5016,6 +5016,21 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             }
 
             ExprKind::Struct(ref se) => {
+                // Skip resolution for recovered struct literals with a placeholder or missing path.
+                // This handles both `_ { ... }` and `{ ... }` forms. Since we already stashed
+                // a diagnostic for this expression during parsing, we don’t attempt name resolution here.
+                // Resolving an empty path would produce redundant or confusing diagnostics; later phases
+                // (e.g., typeck) will produce a more accurate error and suggestion.
+                // Used delay span error
+                if se.path == kw::EmptyStructType {
+                    if self.r.dcx().has_stashed_diagnostic(expr.span, StashKey::StructLitNoType) {
+                        return;
+                    }
+                    self.r.dcx().span_delayed_bug(expr.span,
+                    "skipped name resolution for struct literal with empty path but no stashed diagnostic was present",
+                    );
+                }
+
                 self.smart_resolve_path(expr.id, &se.qself, &se.path, PathSource::Struct(parent));
                 // This is the same as `visit::walk_expr(self, expr);`, but we want to pass the
                 // parent in for accurate suggestions when encountering `Foo { bar }` that should

compiler/rustc_span/src/symbol.rs

@@ -138,6 +138,8 @@ symbols! {
         Union:              "union",
         Yeet:               "yeet",
         // tidy-alphabetical-end
+
+        EmptyStructType:              "empty_struct_type",
     }
 
     // Pre-interned symbols that can be referred to with `rustc_span::sym::*`.

tests/ui/parser/bare-struct-body.stderr

@@ -14,22 +14,6 @@ LL |     val: (),
 LL ~ } }
    |
 
-error: struct literal body without path
-  --> $DIR/bare-struct-body.rs:12:13
-   |
-LL |       let x = {
-   |  _____________^
-LL | |         val: (),
-LL | |     };
-   | |_____^
-   |
-help: you might have forgotten to add the struct literal inside the block
-   |
-LL ~     let x = { SomeStruct {
-LL |         val: (),
-LL ~     } };
-   |
-
 error[E0308]: mismatched types
   --> $DIR/bare-struct-body.rs:11:14
    |
@@ -38,6 +22,18 @@ LL |     x.val == 42;
    |     |
    |     expected because this is `()`
 
+error: struct literal body without path
+  --> $DIR/bare-struct-body.rs:12:12
+   |
+LL |       let x = {
+   |  ____________^
+LL | |         val: (),
+LL | |     };
+   | |     ^
+   | |     |
+   | |_____absent of struct name for this struct literal
+   |       help: replace it with an appropriate type: `/*Type*/`
+
 error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0308`.

tests/ui/suggestions/struct-lit-placeholder-path.rs

@@ -0,0 +1,21 @@
+// Regression test for issue #98282.
+
+mod blah {
+    pub struct Stuff { x: i32 }
+    pub fn do_stuff(_: Stuff) {}
+}
+
+fn main() {
+    blah::do_stuff(_ { x: 10 });
+    //~^ ERROR the placeholder `_` is not allowed for the path in struct literals
+    //~| NOTE not allowed in struct literals
+    //~| HELP replace it with the correct type
+}
+
+#[cfg(FALSE)]
+fn disabled() {
+    blah::do_stuff(_ { x: 10 });
+    //~^ ERROR the placeholder `_` is not allowed for the path in struct literals
+    //~| NOTE not allowed in struct literals
+    //~| HELP replace it with an appropriate type
+}

tests/ui/suggestions/struct-lit-placeholder-path.stderr

@@ -0,0 +1,20 @@
+error: the placeholder `_` is not allowed for the path in struct literals
+  --> $DIR/struct-lit-placeholder-path.rs:9:20
+   |
+LL |     blah::do_stuff(_ { x: 10 });
+   |                    -^^^^^^^^^^
+   |                    |
+   |                    not allowed in struct literals
+   |                    help: replace it with the correct type: `Stuff`
+
+error: the placeholder `_` is not allowed for the path in struct literals
+  --> $DIR/struct-lit-placeholder-path.rs:17:20
+   |
+LL |     blah::do_stuff(_ { x: 10 });
+   |                    ^^^^^^^^^^^
+   |                    |
+   |                    not allowed in struct literals
+   |                    help: replace it with an appropriate type: `/*Type*/`
+
+error: aborting due to 2 previous errors
+