Auto merge of #160227 - Amanieu:edition-redirects, r=<try>

Add #[rustc_edition_redirect]

Author: bors

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -2,13 +2,15 @@ use std::path::PathBuf;
 
 use rustc_ast::{LitIntType, LitKind, MetaItemLit};
 use rustc_feature::AttributeStability;
-use rustc_hir::LangItem;
 use rustc_hir::attrs::{
     BorrowckGraphvizFormatKind, CguFields, CguKind, DivergingBlockBehavior,
-    DivergingFallbackBehavior, RustcCleanAttribute, RustcCleanQueries, RustcMirKind,
+    DivergingFallbackBehavior, EditionRedirect, RustcCleanAttribute, RustcCleanQueries,
+    RustcMirKind,
 };
 use rustc_hir::target::GenericParamKind;
+use rustc_hir::{LangItem, find_attr};
 use rustc_span::Symbol;
+use rustc_span::edition::Edition;
 
 use super::prelude::*;
 use super::util::parse_single_integer;
@@ -329,6 +331,118 @@ impl AttributeParser for RustcCguTestAttributeParser {
     }
 }
 
+pub(crate) struct RustcEditionRedirectParser;
+
+impl CombineAttributeParser for RustcEditionRedirectParser {
+    const PATH: &[Symbol] = &[sym::rustc_edition_redirect];
+    type Item = EditionRedirect;
+    const CONVERT: ConvertFn<Self::Item> = |items, _| AttributeKind::RustcEditionRedirect(items);
+    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
+        Allow(Target::Const),
+        Allow(Target::Enum),
+        Allow(Target::ExternCrate),
+        Allow(Target::Fn),
+        Allow(Target::MacroDef),
+        Allow(Target::Mod),
+        Allow(Target::Static),
+        Allow(Target::Struct),
+        Allow(Target::Trait),
+        Allow(Target::TraitAlias),
+        Allow(Target::TyAlias),
+        Allow(Target::Union),
+        Allow(Target::Use),
+    ]);
+    const TEMPLATE: AttributeTemplate =
+        template!(List: &[r#"before = "2024", target(path::to::item)"#]);
+    const STABILITY: AttributeStability = unstable!(edition_redirect);
+
+    fn extend(
+        cx: &mut AcceptContext<'_, '_>,
+        args: &ArgParser,
+    ) -> impl IntoIterator<Item = Self::Item> {
+        let list = cx.expect_list(args, cx.attr_span)?;
+        let mut before = None;
+        let mut target = None;
+
+        for item in list.mixed() {
+            let Some(meta) = item.meta_item() else {
+                cx.adcx().expected_identifier(item.span());
+                return None;
+            };
+            let Some(name) = meta.path().word() else {
+                cx.adcx()
+                    .expected_specific_argument(meta.path().span(), &[sym::before, sym::target]);
+                return None;
+            };
+            match name.name {
+                sym::before if before.is_none() => {
+                    let Some(value) =
+                        cx.expect_name_value(meta.args(), item.span(), Some(sym::before))
+                    else {
+                        return None;
+                    };
+                    let Some(value) = cx.expect_string_literal(value) else { return None };
+                    before = Some(value);
+                }
+                sym::target if target.is_none() => {
+                    let Some(single) = cx.expect_single_element_list(meta.args(), item.span())
+                    else {
+                        return None;
+                    };
+                    let Some(target_path) = single.meta_item_no_args() else {
+                        cx.adcx().expected_not_literal(single.span());
+                        return None;
+                    };
+                    target = Some(target_path.path().0.clone());
+                }
+                sym::before | sym::target => {
+                    cx.adcx().duplicate_key(item.span(), name.name);
+                    return None;
+                }
+                _ => {
+                    cx.adcx().expected_specific_argument(item.span(), &[sym::before, sym::target]);
+                    return None;
+                }
+            }
+        }
+
+        let Some(before) = before else {
+            cx.dcx().span_err(cx.attr_span, "missing `before` argument");
+            return None;
+        };
+        let Some(target) = target else {
+            cx.dcx().span_err(cx.attr_span, "missing `target` argument");
+            return None;
+        };
+        let before = match before.as_str().parse::<Edition>() {
+            Ok(before) => before,
+            Err(()) => {
+                cx.dcx().span_err(cx.attr_span, "invalid edition in edition redirect");
+                return None;
+            }
+        };
+
+        Some(EditionRedirect { before, target, span: cx.attr_span })
+    }
+
+    fn finalize_check(cx: &FinalizeCheckContext<'_, '_>, _attr_span: Span) {
+        let redirects = find_attr!(
+            cx.parsed_attrs,
+            RustcEditionRedirect(redirects) => redirects
+        )
+        .unwrap();
+
+        for (index, redirect) in redirects.iter().enumerate() {
+            if redirects[..index].iter().any(|existing| existing.before == redirect.before) {
+                cx.emit_err(diagnostics::MultipleEditionRedirects {
+                    span: redirect.span,
+                    edition: redirect.before.to_string(),
+                });
+            }
+        }
+    }
+}
+
 pub(crate) struct RustcDeprecatedSafe2024Parser;
 
 impl SingleAttributeParser for RustcDeprecatedSafe2024Parser {

compiler/rustc_attr_parsing/src/context.rs

@@ -193,6 +193,7 @@ attribute_parsers!(
         Combine<RustcAllowConstFnUnstableParser>,
         Combine<RustcCleanParser>,
         Combine<RustcDumpLayoutParser>,
+        Combine<RustcEditionRedirectParser>,
         Combine<RustcMirParser>,
         Combine<RustcThenThisWouldNeedParser>,
         Combine<TargetFeatureParser>,

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -52,6 +52,14 @@ pub(crate) struct UnreachableCfgSelectPredicateWildcard {
     pub wildcard_span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("multiple edition redirects before edition {$edition}")]
+pub(crate) struct MultipleEditionRedirects {
+    #[primary_span]
+    pub span: Span,
+    pub edition: String,
+}
+
 #[derive(Diagnostic)]
 #[diag("must be a name of an associated function")]
 pub(crate) struct MustBeNameOfAssociatedFunction {

compiler/rustc_feature/src/builtin_attrs.rs

@@ -246,6 +246,7 @@ pub static BUILTIN_ATTRIBUTES: &[Symbol] = &[
     sym::rustc_eii_foreign_item,
     sym::rustc_allowed_through_unstable_modules,
     sym::rustc_deprecated_safe_2024,
+    sym::rustc_edition_redirect,
     sym::rustc_pub_transparent,
 
     // ==========================================================================

compiler/rustc_feature/src/unstable.rs

@@ -262,6 +262,8 @@ declare_features! (
     (internal, const_param_ty_unchecked, "1.97.0", None),
     /// Allows writing custom MIR
     (internal, custom_mir, "1.65.0", None),
+    /// Allows defining edition redirects and preserving redirects on re-exports.
+    (internal, edition_redirect, "CURRENT_RUSTC_VERSION", None),
     /// Implementation details of externally implementable items
     (internal, eii_internals, "1.94.0", None),
     /// Implementation details of field representing types.

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -15,6 +15,7 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_error_messages::{DiagArgValue, IntoDiagArg};
 use rustc_macros::{Decodable, Encodable, PrintAttribute, StableHash};
 use rustc_span::def_id::DefId;
+use rustc_span::edition::Edition;
 use rustc_span::hygiene::Transparency;
 use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
 pub use rustc_target::spec::SanitizerSet;
@@ -152,6 +153,13 @@ pub enum InstrumentFnAttr {
     Off,
 }
 
+#[derive(Clone, Debug, StableHash, Encodable, Decodable, PrintAttribute)]
+pub struct EditionRedirect {
+    pub before: Edition,
+    pub target: Path,
+    pub span: Span,
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Default, PrintAttribute)]
 #[derive(Encodable, Decodable, StableHash)]
 pub enum OptimizeAttr {
@@ -1477,6 +1485,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_dyn_incompatible_trait]`.
     RustcDynIncompatibleTrait(Span),
 
+    /// Represents `#[rustc_edition_redirect(before = "...", target(...))]`.
+    RustcEditionRedirect(ThinVec<EditionRedirect>),
+
     /// Represents `#[rustc_effective_visibility]`.
     RustcEffectiveVisibility,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -144,6 +144,7 @@ impl AttributeKind {
             RustcDumpVariancesOfOpaques => No,
             RustcDumpVtable(..) => No,
             RustcDynIncompatibleTrait(..) => No,
+            RustcEditionRedirect(..) => No,
             RustcEffectiveVisibility => Yes,
             RustcEiiForeignItem => No,
             RustcEvaluateWhereClauses => Yes,

compiler/rustc_hir/src/attrs/pretty_printing.rs

@@ -13,6 +13,7 @@ use rustc_ast_pretty::pp::Printer;
 use rustc_data_structures::Limit;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_span::def_id::DefId;
+use rustc_span::edition::Edition;
 use rustc_span::hygiene::Transparency;
 use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
 use rustc_target::spec::SanitizerSet;
@@ -191,7 +192,7 @@ macro_rules! print_tup {
 
 print_tup!(A B C D E F G H);
 print_skip!(Span, (), ErrorGuaranteed, AttrId);
-print_disp!(u8, u16, u32, u128, usize, bool, NonZero<u32>, Limit);
+print_disp!(u8, u16, u32, u128, usize, bool, NonZero<u32>, Edition, Limit);
 print_debug!(
     Symbol,
     Ident,

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1313,7 +1313,14 @@ impl CrateMetadata {
         let res = Res::Def(self.def_kind(id), self.local_def_id(id));
         let vis = self.get_visibility(tcx, id);
 
-        ModChild { ident, res, vis, reexport_chain: Default::default() }
+        ModChild {
+            ident,
+            res,
+            vis,
+            reexport_chain: Default::default(),
+            // Children with redirects are encoded as full `ModChild`s.
+            edition_redirects: Default::default(),
+        }
     }
 
     /// Iterates over all named children of the given module,

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1736,11 +1736,13 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             let module_children = tcx.module_children_local(local_def_id);
 
             record_array!(self.tables.module_children_non_reexports[def_id] <-
-                module_children.iter().filter(|child| child.reexport_chain.is_empty())
+                module_children.iter().filter(|child| child.reexport_chain.is_empty()
+                    && child.edition_redirects.is_empty())
                     .map(|child| child.res.def_id().index));
 
             record_defaulted_array!(self.tables.module_children_reexports[def_id] <-
-                module_children.iter().filter(|child| !child.reexport_chain.is_empty()));
+                module_children.iter().filter(|child| !child.reexport_chain.is_empty()
+                    || !child.edition_redirects.is_empty()));
 
             let ambig_module_children = tcx
                 .resolutions(())