Rollup of 10 pull requests

compiler/rustc_ast_lowering/src/expr.rs

@@ -230,7 +230,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let old_attrs =
                         self.curr_owner.attrs.get(&ex.hir_id.local_id).copied().unwrap_or(&[]);
                     let new_attrs = self
-                        .lower_attrs_vec(&e.attrs, e.span, ex.hir_id, Target::from_expr(e))
+                        .lower_attrs_vec(&e.attrs, e.span, ex.hir_id, Target::from_expr(e), None)
                         .into_iter()
                         .chain(old_attrs.iter().cloned());
                     let new_attrs = &*self.arena.alloc_from_iter(new_attrs);

compiler/rustc_ast_lowering/src/item.rs

@@ -215,6 +215,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             &i.attrs,
             i.span,
             Target::from_ast_item(i),
+            Some(i),
             &extra_hir_attributes,
         );
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -1182,7 +1182,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         target_span: Span,
         target: Target,
     ) -> &'hir [hir::Attribute] {
-        self.lower_attrs_with_extra(id, attrs, target_span, target, &[])
+        self.lower_attrs_with_extra(id, attrs, target_span, target, None, &[])
     }
 
     fn lower_attrs_with_extra(
@@ -1191,13 +1191,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
         attrs: &[Attribute],
         target_span: Span,
         target: Target,
+        target_item: Option<&ast::Item>,
         extra_hir_attributes: &[hir::Attribute],
     ) -> &'hir [hir::Attribute] {
         if attrs.is_empty() && extra_hir_attributes.is_empty() {
             &[]
         } else {
             let mut lowered_attrs =
-                self.lower_attrs_vec(attrs, self.lower_span(target_span), id, target);
+                self.lower_attrs_vec(attrs, self.lower_span(target_span), id, target, target_item);
             lowered_attrs.extend(extra_hir_attributes.iter().cloned());
 
             assert_eq!(id.owner, self.curr_owner.owner_id);
@@ -1224,12 +1225,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
         target_span: Span,
         target_hir_id: HirId,
         target: Target,
+        target_item: Option<&ast::Item>,
     ) -> Vec<hir::Attribute> {
         let l = self.span_lowerer();
         self.attribute_parser.parse_attribute_list(
             attrs,
             target_span,
             target,
+            target_item,
             |s| l.lower(s),
             |lint_id, span, kind| {
                 self.curr_owner.delayed_lints.push(DelayedLint {
@@ -2685,7 +2688,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         match (body, kind) {
             (body, ConstItemKind::Body) => {
                 let is_direct = |body| {
-                    if self.tcx.features().macroless_generic_const_args() {
+                    if self.tcx.features().macroless_const_item_generic_const_args() {
                         self.can_lower_expr_to_const_arg_direct(
                             body,
                             DirectConstArgContext::MacrolessMinGenericConstArgs,

compiler/rustc_attr_parsing/src/attributes/doc.rs

@@ -705,16 +705,7 @@ impl DocParser {
 
     fn accept_single_doc_attr(&mut self, cx: &mut AcceptContext<'_, '_>, args: &ArgParser) {
         match args {
-            ArgParser::NoArgs => {
-                let suggestions = cx.adcx().suggestions();
-                let span = cx.inner_span;
-                cx.emit_lint(
-                    INVALID_DOC_ATTRIBUTES,
-                    IllFormedAttributeInput::new(&suggestions, None, None),
-                    span,
-                );
-            }
-            ArgParser::List(items) => {
+            ArgParser::List(items) if !items.is_empty() => {
                 for i in items.mixed() {
                     match i {
                         MetaItemOrLitParser::MetaItemParser(mip) => {
@@ -739,6 +730,15 @@ impl DocParser {
                     );
                 }
             }
+            _ => {
+                let suggestions = cx.adcx().suggestions();
+                let span = cx.inner_span;
+                cx.emit_lint(
+                    INVALID_DOC_ATTRIBUTES,
+                    IllFormedAttributeInput::new(&suggestions, None, None),
+                    span,
+                );
+            }
         }
     }
 }
@@ -749,7 +749,6 @@ impl AttributeParser for DocParser {
         template!(
             List: &[
                 "alias",
-                "attribute",
                 "hidden",
                 "html_favicon_url",
                 "html_logo_url",
@@ -762,19 +761,10 @@ impl AttributeParser for DocParser {
                 "masked",
                 "cfg",
                 "notable_trait",
-                "keyword",
-                "fake_variadic",
-                "search_unbox",
-                "rust_logo",
                 "auto_cfg",
                 "test",
-                "spotlight",
-                "include",
-                "no_default_passes",
-                "passes",
-                "plugins",
             ],
-            NameValueStr: "string"
+            NameValueStr: "doc comment"
         ),
         AttributeStability::Stable, // Some parts of the attribute are unstable, manually checked in parser
         |this, cx, args| {

compiler/rustc_attr_parsing/src/attributes/non_exhaustive.rs

@@ -1,11 +1,8 @@
-use rustc_attr_ir::AttributeKind;
-use rustc_attr_ir::target::Target;
+use rustc_ast::{ItemKind, VariantData};
 use rustc_feature::AttributeStability;
-use rustc_span::{Span, Symbol, sym};
 
-use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
-use crate::target_checking::AllowedTargets;
-use crate::target_checking::Policy::{Allow, Warn};
+use super::prelude::*;
+use crate::diagnostics::NonExhaustiveWithDefaultFieldValues;
 
 pub(crate) struct NonExhaustiveParser;
 
@@ -23,4 +20,23 @@ impl NoArgsAttributeParser for NonExhaustiveParser {
     ]);
     const STABILITY: AttributeStability = AttributeStability::Stable;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NonExhaustive;
+
+    fn finalize_check(cx: &FinalizeCheckContext<'_, '_>, attr_span: Span) {
+        if cx.target != Target::Struct {
+            return;
+        }
+
+        let item = cx.target_item.expect("missing AST target item for Target::Struct");
+        let ItemKind::Struct(_, _, data) = &item.kind else {
+            panic!("expected struct AST target item for Target::Struct");
+        };
+        if let VariantData::Struct { fields, .. } = data
+            && fields.iter().any(|f| f.default_value().is_some())
+        {
+            cx.emit_err(NonExhaustiveWithDefaultFieldValues {
+                attr_span,
+                defn_span: cx.target_span,
+            });
+        }
+    }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -833,6 +833,10 @@ pub(crate) struct FinalizeCheckContext<'p, 'sess> {
     ///
     /// Unlike [`all_attrs`](Self::all_attrs), this contains the fully parsed attributes.
     pub(crate) parsed_attrs: &'p [Attribute],
+
+    /// The AST item these attributes were applied to, when the target is an item.
+    /// Used by `finalize_check` to inspect item structure that is not encoded in [`Target`].
+    pub(crate) target_item: Option<&'p rustc_ast::ast::Item>,
 }
 
 impl<'p, 'sess: 'p> Deref for FinalizeCheckContext<'p, 'sess> {

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -1169,6 +1169,15 @@ pub(crate) struct DeprecatedAnnotationHasNoEffect {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("`#[non_exhaustive]` can't be used to annotate items with default field values")]
+pub(crate) struct NonExhaustiveWithDefaultFieldValues {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label("this struct has default field values")]
+    pub defn_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("expected single version literal")]
 pub(crate) struct ExpectedSingleVersionLiteral {

compiler/rustc_attr_parsing/src/interface.rs

@@ -161,6 +161,7 @@ impl<'sess> AttributeParser<'sess> {
             attrs,
             target_span,
             target,
+            None,
             std::convert::identity,
             |lint_id, span, kind| {
                 sess.psess.dyn_buffer_lint_sess(lint_id.lint, span, target_node_id, kind.0)
@@ -315,6 +316,7 @@ impl<'sess> AttributeParser<'sess> {
         attrs: &[ast::Attribute],
         target_span: Span,
         target: Target,
+        target_item: Option<&ast::Item>,
         lower_span: impl Copy + Fn(Span) -> Span,
         mut emit_lint: impl FnMut(LintId, MultiSpan, EmitAttribute),
     ) -> Vec<Attribute> {
@@ -521,6 +523,7 @@ impl<'sess> AttributeParser<'sess> {
                     },
                     all_attrs: &attr_paths,
                     parsed_attrs: &attributes,
+                    target_item,
                 },
                 attr_span,
             );

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -954,7 +954,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
             tcx,
             self.infcx.typing_env(self.infcx.param_env),
             fn_did,
-            self.infcx.resolve_vars_if_possible(args.no_bound_vars().unwrap()),
+            self.infcx.deeply_resolve_ignoring_regions(args.no_bound_vars().unwrap()),
         ) else {
             return;
         };

compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs

@@ -73,7 +73,7 @@ pub(crate) fn clone_and_resolve_opaque_types<'tcx>(
     let opaque_types = opaque_types
         .into_iter()
         .map(|entry| {
-            fold_regions(infcx.tcx, infcx.resolve_vars_if_possible(entry), |r, _| {
+            fold_regions(infcx.tcx, infcx.deeply_resolve_ignoring_regions(entry), |r, _| {
                 let vid = if let ty::RePlaceholder(placeholder) = r.kind() {
                     constraints.placeholder_region(infcx, placeholder).as_var()
                 } else {

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -157,7 +157,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
 
             GenericArgKind::Type(mut t1) => {
                 // Scraped constraints may have had inference vars.
-                t1 = self.infcx.resolve_vars_if_possible(t1);
+                t1 = self.infcx.deeply_resolve_ignoring_regions(t1);
 
                 let implicit_region_bound =
                     ty::Region::new_var(tcx, universal_regions.implicit_region_bound());

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -145,7 +145,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
                 ty,
             )?;
             let new_var =
-                infcx.resolve_vars_if_possible(Ty::new_infer(infcx.tcx, ty::TyVar(ty_vid)));
+                infcx.deeply_resolve_ignoring_regions(Ty::new_infer(infcx.tcx, ty::TyVar(ty_vid)));
 
             // Any regions in this new type must be live everywhere, so we mark them as such.
             // (It may be that it only needs to be live where the opaque type itself is - which

compiler/rustc_builtin_macros/src/deriving/clone.rs

@@ -1,6 +1,6 @@
 use rustc_ast::{self as ast, Generics, ItemKind, MetaItem, Safety, VariantData};
 use rustc_data_structures::fx::FxHashSet;
-use rustc_expand::base::{Annotatable, ExtCtxt};
+use rustc_expand::base::ExtCtxt;
 use rustc_span::{DUMMY_SP, Ident, Span, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 
@@ -12,8 +12,8 @@ pub(crate) fn expand_deriving_clone(
     cx: &ExtCtxt<'_>,
     span: Span,
     mitem: &MetaItem,
-    item: &Annotatable,
-    push: &mut dyn FnMut(Annotatable),
+    item: &ast::Item,
+    push: &mut dyn FnMut(Box<ast::Item>),
     is_const: bool,
 ) {
     // The simple form is `fn clone(&self) -> Self { *self }`, possibly with
@@ -32,35 +32,30 @@ pub(crate) fn expand_deriving_clone(
     let bounds;
     let substructure;
     let is_simple;
-    match item {
-        Annotatable::Item(annitem) => match &annitem.kind {
-            ItemKind::Struct(_, Generics { params, .. }, _)
-            | ItemKind::Enum(_, Generics { params, .. }, _) => {
-                let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
-                let has_derive_copy = cx.resolver.has_derive_copy(container_id);
-                bounds = smallvec![];
-                if has_derive_copy
-                    && !params
-                        .iter()
-                        .any(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
-                {
-                    is_simple = true;
-                    substructure =
-                        combine_substructure(|c, s, sub| cs_clone_simple(c, s, sub, false));
-                } else {
-                    is_simple = false;
-                    substructure = combine_substructure(cs_clone);
-                }
-            }
-            ItemKind::Union(..) => {
-                bounds = smallvec![Path(path_std!(marker::Copy))];
+    match &item.kind {
+        ItemKind::Struct(_, Generics { params, .. }, _)
+        | ItemKind::Enum(_, Generics { params, .. }, _) => {
+            let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
+            let has_derive_copy = cx.resolver.has_derive_copy(container_id);
+            bounds = smallvec![];
+            if has_derive_copy
+                && !params
+                    .iter()
+                    .any(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
+            {
                 is_simple = true;
-                substructure = combine_substructure(|c, s, sub| cs_clone_simple(c, s, sub, true));
+                substructure = combine_substructure(|c, s, sub| cs_clone_simple(c, s, sub, false));
+            } else {
+                is_simple = false;
+                substructure = combine_substructure(cs_clone);
             }
-            _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
-        },
-
-        _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on trait item or impl item"),
+        }
+        ItemKind::Union(..) => {
+            bounds = smallvec![Path(path_std!(marker::Copy))];
+            is_simple = true;
+            substructure = combine_substructure(|c, s, sub| cs_clone_simple(c, s, sub, true));
+        }
+        _ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
     }
 
     // If the clone method is just copying the value, also mark the type as
@@ -82,7 +77,7 @@ pub(crate) fn expand_deriving_clone(
             document: false,
         };
 
-        trivial_def.expand_ext(cx, mitem, item, push, true);
+        trivial_def.expand(cx, mitem, item, push);
     }
 
     let trait_def = TraitDef {