diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 4e3310d3fb097..5831636a81b2c 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -7,7 +7,7 @@ use rustc_hir::Attribute;
 use rustc_hir::attrs::AttributeKind;
 use rustc_session::Session;
 use rustc_session::parse::{feature_err, feature_warn};
-use rustc_span::{DUMMY_SP, Span, Spanned, Symbol, sym};
+use rustc_span::{Span, Spanned, Symbol, sym};
 use thin_vec::ThinVec;
 
 use crate::errors;
@@ -646,14 +646,7 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
     let mut errored = false;
 
     if let Some(Attribute::Parsed(AttributeKind::Feature(feature_idents, first_span))) =
-        AttributeParser::parse_limited(
-            sess,
-            &krate.attrs,
-            &[sym::feature],
-            DUMMY_SP,
-            krate.id,
-            Some(&features),
-        )
+        AttributeParser::parse_limited(sess, &krate.attrs, &[sym::feature])
     {
         // `feature(...)` used on non-nightly. This is definitely an error.
         let mut err = errors::FeatureOnNonNightly {
diff --git a/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs b/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs
index 913ebe3e9604d..a5364f968b219 100644
--- a/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs
@@ -16,7 +16,9 @@ impl OnUnknownParser {
         args: &ArgParser,
         mode: Mode,
     ) {
-        if !cx.features().diagnostic_on_unknown() {
+        if let Some(features) = cx.features
+            && !features.diagnostic_on_unknown()
+        {
             // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
             return;
         }
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index be89d836e3a19..0dfa67951e629 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -2,7 +2,7 @@ use std::convert::identity;
 
 use rustc_ast as ast;
 use rustc_ast::token::DocFragmentKind;
-use rustc_ast::{AttrItemKind, AttrStyle, NodeId, Safety};
+use rustc_ast::{AttrItemKind, AttrStyle, CRATE_NODE_ID, NodeId, Safety};
 use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_errors::{Diag, DiagCtxtHandle, Level, MultiSpan};
 use rustc_feature::{AttributeTemplate, Features};
@@ -62,18 +62,16 @@ impl<'sess> AttributeParser<'sess, Early> {
         sess: &'sess Session,
         attrs: &[ast::Attribute],
         sym: &'static [Symbol],
-        target_span: Span,
-        target_node_id: NodeId,
-        features: Option<&'sess Features>,
     ) -> Option<Attribute> {
         Self::parse_limited_should_emit(
             sess,
             attrs,
             sym,
-            target_span,
-            target_node_id,
-            Target::Crate, // Does not matter, we're not going to emit errors anyways
-            features,
+            // Because we're not emitting warnings/errors, the target should not matter
+            DUMMY_SP,
+            CRATE_NODE_ID,
+            Target::Crate,
+            None,
             ShouldEmit::Nothing,
         )
     }
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index ae0078523adbc..ace4048af26c1 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -493,7 +493,7 @@ impl<'a> TraitDef<'a> {
         match item {
             Annotatable::Item(item) => {
                 let is_packed = matches!(
-                    AttributeParser::parse_limited(cx.sess, &item.attrs, &[sym::repr], item.span, item.id, None),
+                    AttributeParser::parse_limited(cx.sess, &item.attrs, &[sym::repr]),
                     Some(Attribute::Parsed(AttributeKind::Repr { reprs, .. })) if reprs.iter().any(|(x, _)| matches!(x, ReprPacked(..)))
                 );
 
diff --git a/compiler/rustc_builtin_macros/src/proc_macro_harness.rs b/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
index 84f2a8e35b02c..aa936b46eec20 100644
--- a/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
+++ b/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
@@ -1,7 +1,7 @@
 use std::{mem, slice};
 
 use rustc_ast::visit::{self, Visitor};
-use rustc_ast::{self as ast, HasNodeId, NodeId, attr};
+use rustc_ast::{self as ast, NodeId, attr};
 use rustc_ast_pretty::pprust;
 use rustc_attr_parsing::AttributeParser;
 use rustc_errors::DiagCtxtHandle;
@@ -109,9 +109,6 @@ impl<'a> CollectProcMacros<'a> {
             self.session,
             slice::from_ref(attr),
             &[sym::proc_macro_derive],
-            item.span,
-            item.node_id(),
-            None,
         )
         else {
             return;
diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
index 071b807109b71..1b761614f3e6d 100644
--- a/compiler/rustc_builtin_macros/src/test.rs
+++ b/compiler/rustc_builtin_macros/src/test.rs
@@ -3,7 +3,7 @@
 
 use std::{assert_matches, iter};
 
-use rustc_ast::{self as ast, GenericParamKind, HasNodeId, attr, join_path_idents};
+use rustc_ast::{self as ast, GenericParamKind, attr, join_path_idents};
 use rustc_ast_pretty::pprust;
 use rustc_attr_parsing::AttributeParser;
 use rustc_errors::{Applicability, Diag, Level};
@@ -480,14 +480,7 @@ fn should_ignore_message(i: &ast::Item) -> Option<Symbol> {
 
 fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
     if let Some(Attribute::Parsed(AttributeKind::ShouldPanic { reason, .. })) =
-        AttributeParser::parse_limited(
-            cx.sess,
-            &i.attrs,
-            &[sym::should_panic],
-            i.span,
-            i.node_id(),
-            None,
-        )
+        AttributeParser::parse_limited(cx.sess, &i.attrs, &[sym::should_panic])
     {
         ShouldPanic::Yes(reason)
     } else {
diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
index 1c947ea07d1a9..adcf4086fb1e4 100644
--- a/compiler/rustc_builtin_macros/src/test_harness.rs
+++ b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -61,7 +61,7 @@ pub fn inject(
 
     // Do this here so that the test_runner crate attribute gets marked as used
     // even in non-test builds
-    let test_runner = get_test_runner(sess, features, krate);
+    let test_runner = get_test_runner(sess, krate);
 
     if sess.is_test_crate() {
         let panic_strategy = match (panic_strategy, sess.opts.unstable_opts.panic_abort_tests) {
@@ -387,15 +387,8 @@ fn get_test_name(i: &ast::Item) -> Option<Symbol> {
     attr::first_attr_value_str_by_name(&i.attrs, sym::rustc_test_marker)
 }
 
-fn get_test_runner(sess: &Session, features: &Features, krate: &ast::Crate) -> Option<ast::Path> {
-    match AttributeParser::parse_limited(
-        sess,
-        &krate.attrs,
-        &[sym::test_runner],
-        krate.spans.inner_span,
-        krate.id,
-        Some(features),
-    ) {
+fn get_test_runner(sess: &Session, krate: &ast::Crate) -> Option<ast::Path> {
+    match AttributeParser::parse_limited(sess, &krate.attrs, &[sym::test_runner]) {
         Some(rustc_hir::Attribute::Parsed(AttributeKind::TestRunner(path))) => Some(path),
         _ => None,
     }
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index bb9c63d224327..c15c3c229398c 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -712,8 +712,7 @@ fn print_crate_info(
                 let crate_name = passes::get_crate_name(sess, attrs);
                 let lint_store = crate::unerased_lint_store(sess);
                 let features = rustc_expand::config::features(sess, attrs, crate_name);
-                let registered_tools =
-                    rustc_resolve::registered_tools_ast(sess.dcx(), attrs, sess, &features);
+                let registered_tools = rustc_resolve::registered_tools_ast(sess.dcx(), attrs, sess);
                 let lint_levels = rustc_lint::LintLevelsBuilder::crate_root(
                     sess,
                     &features,
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index f7ab7957b4e50..b5f85536d9cac 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -7,8 +7,8 @@ use rustc_ast::tokenstream::{
     AttrTokenStream, AttrTokenTree, LazyAttrTokenStream, Spacing, TokenTree,
 };
 use rustc_ast::{
-    self as ast, AttrItemKind, AttrKind, AttrStyle, Attribute, DUMMY_NODE_ID, EarlyParsedAttribute,
-    HasAttrs, HasTokens, MetaItem, MetaItemInner, NodeId, NormalAttr,
+    self as ast, AttrItemKind, AttrKind, AttrStyle, Attribute, EarlyParsedAttribute, HasAttrs,
+    HasTokens, MetaItem, MetaItemInner, NodeId, NormalAttr,
 };
 use rustc_attr_parsing::parser::AllowExprMetavar;
 use rustc_attr_parsing::{
@@ -28,7 +28,7 @@ use rustc_hir::{
 use rustc_parse::parser::Recovery;
 use rustc_session::Session;
 use rustc_session::parse::feature_err;
-use rustc_span::{DUMMY_SP, STDLIB_STABLE_CRATES, Span, Symbol, sym};
+use rustc_span::{STDLIB_STABLE_CRATES, Span, Symbol, sym};
 use tracing::instrument;
 
 use crate::errors::{
@@ -51,14 +51,7 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
     let mut features = Features::default();
 
     if let Some(hir::Attribute::Parsed(AttributeKind::Feature(feature_idents, _))) =
-        AttributeParser::parse_limited(
-            sess,
-            krate_attrs,
-            &[sym::feature],
-            DUMMY_SP,
-            DUMMY_NODE_ID,
-            Some(&features),
-        )
+        AttributeParser::parse_limited(sess, krate_attrs, &[sym::feature])
     {
         for feature_ident in feature_idents {
             // If the enabled feature has been removed, issue an error.
diff --git a/compiler/rustc_hir_typeck/src/intrinsicck.rs b/compiler/rustc_hir_typeck/src/intrinsicck.rs
index 7567f8ba34883..c757e8a2387db 100644
--- a/compiler/rustc_hir_typeck/src/intrinsicck.rs
+++ b/compiler/rustc_hir_typeck/src/intrinsicck.rs
@@ -55,9 +55,6 @@ fn skeleton_string<'tcx>(
                 bug!("{:?} overflow for u128", size)
             }
         }
-        Ok(SizeSkeleton::Generic(size)) => {
-            format!("generic size {size}")
-        }
         Err(LayoutError::TooGeneric(bad)) => {
             if *bad == ty {
                 "this type does not have a fixed size".to_owned()
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 66082d782e0bb..ff08898fe93a0 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -313,9 +313,6 @@ impl EarlyLintPass for UnsafeCode {
                         cx.builder.sess(),
                         &it.attrs,
                         &[sym::allow_internal_unsafe],
-                        it.span,
-                        DUMMY_NODE_ID,
-                        Some(cx.builder.features()),
                     )
                 {
                     self.report_unsafe(cx, span, BuiltinUnsafe::AllowInternalUnsafe);
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index 297dfac4a5f78..f5f057c9f3eca 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -145,7 +145,7 @@ impl NonCamelCaseTypes {
 impl EarlyLintPass for NonCamelCaseTypes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {
         let has_repr_c = matches!(
-            AttributeParser::parse_limited(cx.sess(), &it.attrs, &[sym::repr], it.span, it.id, None),
+            AttributeParser::parse_limited(cx.sess(), &it.attrs, &[sym::repr]),
             Some(Attribute::Parsed(AttributeKind::Repr { reprs, ..})) if reprs.iter().any(|(r, _)| r == &ReprAttr::ReprC)
         );
 
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index f04b4873f395c..4554900285d32 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -317,12 +317,6 @@ pub enum SizeSkeleton<'tcx> {
     /// Alignment can be `None` if unknown.
     Known(Size, Option<Align>),
 
-    /// This is a generic const expression (i.e. N * 2), which may contain some parameters.
-    /// It must be of type usize, and represents the size of a type in bytes.
-    /// It is not required to be evaluatable to a concrete value, but can be used to check
-    /// that another SizeSkeleton is of equal size.
-    Generic(ty::Const<'tcx>),
-
     /// A potentially-wide pointer.
     Pointer {
         /// If true, this pointer is never null.
@@ -426,7 +420,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
                         }
                         Err(err)
                     }
-                    SizeSkeleton::Pointer { .. } | SizeSkeleton::Generic(_) => Err(err),
+                    SizeSkeleton::Pointer { .. } => Err(err),
                 }
             }
 
@@ -460,9 +454,6 @@ impl<'tcx> SizeSkeleton<'tcx> {
                                 }
                                 ptr = Some(field);
                             }
-                            SizeSkeleton::Generic(_) => {
-                                return Err(err);
-                            }
                         }
                     }
                     Ok(ptr)
@@ -516,7 +507,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
                     // But in the case of `!null` patterns we need to note that in the
                     // raw pointer.
                     ty::PatternKind::NotNull => match base? {
-                        SizeSkeleton::Known(..) | SizeSkeleton::Generic(_) => base,
+                        SizeSkeleton::Known(..) => base,
                         SizeSkeleton::Pointer { non_zero: _, tail } => {
                             Ok(SizeSkeleton::Pointer { non_zero: true, tail })
                         }
@@ -534,9 +525,6 @@ impl<'tcx> SizeSkeleton<'tcx> {
             (SizeSkeleton::Pointer { tail: a, .. }, SizeSkeleton::Pointer { tail: b, .. }) => {
                 a == b
             }
-            // constants are always pre-normalized into a canonical form so this
-            // only needs to check if their pointers are identical.
-            (SizeSkeleton::Generic(a), SizeSkeleton::Generic(b)) => a == b,
             _ => false,
         }
     }
diff --git a/compiler/rustc_passes/src/debugger_visualizer.rs b/compiler/rustc_passes/src/debugger_visualizer.rs
index 828ba698e0f2f..1f27384d4e7ca 100644
--- a/compiler/rustc_passes/src/debugger_visualizer.rs
+++ b/compiler/rustc_passes/src/debugger_visualizer.rs
@@ -1,7 +1,6 @@
 //! Detecting usage of the `#[debugger_visualizer]` attribute.
 
-use rustc_ast::ast::NodeId;
-use rustc_ast::{HasNodeId, ItemKind, ast};
+use rustc_ast::{ItemKind, ast};
 use rustc_attr_parsing::AttributeParser;
 use rustc_expand::base::resolve_path;
 use rustc_hir::Attribute;
@@ -10,26 +9,14 @@ use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::query::{LocalCrate, Providers};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
-use rustc_span::{DUMMY_SP, Span, sym};
+use rustc_span::sym;
 
 use crate::errors::DebugVisualizerUnreadable;
 
 impl DebuggerVisualizerCollector<'_> {
-    fn check_for_debugger_visualizer(
-        &mut self,
-        attrs: &[ast::Attribute],
-        span: Span,
-        node_id: NodeId,
-    ) {
+    fn check_for_debugger_visualizer(&mut self, attrs: &[ast::Attribute]) {
         if let Some(Attribute::Parsed(AttributeKind::DebuggerVisualizer(visualizers))) =
-            AttributeParser::parse_limited(
-                &self.sess,
-                attrs,
-                &[sym::debugger_visualizer],
-                span,
-                node_id,
-                None,
-            )
+            AttributeParser::parse_limited(&self.sess, attrs, &[sym::debugger_visualizer])
         {
             for DebugVisualizer { span, visualizer_type, path } in visualizers {
                 let file = match resolve_path(&self.sess, path.as_str(), span) {
@@ -69,12 +56,12 @@ struct DebuggerVisualizerCollector<'a> {
 impl<'ast> rustc_ast::visit::Visitor<'ast> for DebuggerVisualizerCollector<'_> {
     fn visit_item(&mut self, item: &'ast rustc_ast::Item) -> Self::Result {
         if let ItemKind::Mod(..) = item.kind {
-            self.check_for_debugger_visualizer(&item.attrs, item.span, item.node_id());
+            self.check_for_debugger_visualizer(&item.attrs);
         }
         rustc_ast::visit::walk_item(self, item);
     }
     fn visit_crate(&mut self, krate: &'ast ast::Crate) -> Self::Result {
-        self.check_for_debugger_visualizer(&krate.attrs, DUMMY_SP, krate.id);
+        self.check_for_debugger_visualizer(&krate.attrs);
         rustc_ast::visit::walk_crate(self, krate);
     }
 }
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 9ec27fb175e27..237f69eb534e7 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -1127,14 +1127,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         let mut import_all = None;
         let mut single_imports = ThinVec::new();
         if let Some(Attribute::Parsed(AttributeKind::MacroUse { span, arguments })) =
-            AttributeParser::parse_limited(
-                self.r.tcx.sess,
-                &item.attrs,
-                &[sym::macro_use],
-                item.span,
-                item.id,
-                None,
-            )
+            AttributeParser::parse_limited(self.r.tcx.sess, &item.attrs, &[sym::macro_use])
         {
             if self.parent_scope.module.parent.is_some() {
                 self.r
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index b4f03db96e6ea..067dbd06d7b02 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -149,17 +149,15 @@ pub(crate) struct OnUnknownData {
 
 impl OnUnknownData {
     pub(crate) fn from_attrs<'tcx>(tcx: TyCtxt<'tcx>, item: &Item) -> Option<OnUnknownData> {
-        if let Some(Attribute::Parsed(AttributeKind::OnUnknown { directive, .. })) =
-            AttributeParser::parse_limited(
-                tcx.sess,
-                &item.attrs,
-                &[sym::diagnostic, sym::on_unknown],
-                item.span,
-                item.id,
-                Some(tcx.features()),
-            )
+        if tcx.features().diagnostic_on_unknown()
+            && let Some(Attribute::Parsed(AttributeKind::OnUnknown { directive, .. })) =
+                AttributeParser::parse_limited(
+                    tcx.sess,
+                    &item.attrs,
+                    &[sym::diagnostic, sym::on_unknown],
+                )
         {
-            Some(Self { directive: Box::new(*directive?) })
+            Some(Self { directive: directive? })
         } else {
             None
         }
@@ -216,6 +214,8 @@ pub(crate) struct ImportData<'ra> {
     /// A `#[diagnostic::on_unknown]` attribute applied
     /// to the given import. This allows crates to specify
     /// custom error messages for a specific import
+    ///
+    /// This is `None` if the feature flag for `diagnostic::on_unknown` is disabled.
     pub on_unknown_attr: Option<OnUnknownData>,
 }
 
@@ -845,24 +845,24 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             .collect::<Vec<_>>();
         let default_message =
             format!("unresolved import{} {}", pluralize!(paths.len()), paths.join(", "),);
-        let (message, label, notes) = if self.tcx.features().diagnostic_on_unknown()
-            && let Some(directive) = errors[0].1.on_unknown_attr.as_ref().map(|a| &a.directive)
-        {
-            let args = FormatArgs {
-                this: paths.join(", "),
-                // Unused
-                this_sugared: String::new(),
-                // Unused
-                item_context: "",
-                // Unused
-                generic_args: Vec::new(),
-            };
-            let CustomDiagnostic { message, label, notes, .. } = directive.eval(None, &args);
+        let (message, label, notes) =
+            // Feature gating for `on_unknown_attr` happens initialization of the field
+            if let Some(directive) = errors[0].1.on_unknown_attr.as_ref().map(|a| &a.directive) {
+                let args = FormatArgs {
+                    this: paths.join(", "),
+                    // Unused
+                    this_sugared: String::new(),
+                    // Unused
+                    item_context: "",
+                    // Unused
+                    generic_args: Vec::new(),
+                };
+                let CustomDiagnostic { message, label, notes, .. } = directive.eval(None, &args);
 
-            (message, label, notes)
-        } else {
-            (None, None, Vec::new())
-        };
+                (message, label, notes)
+            } else {
+                (None, None, Vec::new())
+            };
         let has_custom_message = message.is_some();
         let message = message.as_deref().unwrap_or(default_message.as_str());
 
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 2de4e21b1e96a..a5024f5ef694c 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -4,7 +4,7 @@
 use std::mem;
 use std::sync::Arc;
 
-use rustc_ast::{self as ast, Crate, DUMMY_NODE_ID, DelegationSuffixes, NodeId};
+use rustc_ast::{self as ast, Crate, DelegationSuffixes, NodeId};
 use rustc_ast_pretty::pprust;
 use rustc_attr_parsing::AttributeParser;
 use rustc_errors::{Applicability, DiagCtxtHandle, StashKey};
@@ -16,7 +16,6 @@ use rustc_expand::compile_declarative_macro;
 use rustc_expand::expand::{
     AstFragment, AstFragmentKind, Invocation, InvocationKind, SupportsMacroExpansion,
 };
-use rustc_feature::Features;
 use rustc_hir::attrs::{AttributeKind, CfgEntry, StrippedCfgItem};
 use rustc_hir::def::{DefKind, MacroKinds, Namespace, NonMacroAttrKind};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
@@ -123,26 +122,18 @@ fn fast_print_path(path: &ast::Path) -> Symbol {
 
 pub(crate) fn registered_tools(tcx: TyCtxt<'_>, (): ()) -> RegisteredTools {
     let (_, pre_configured_attrs) = &*tcx.crate_for_resolver(()).borrow();
-    registered_tools_ast(tcx.dcx(), pre_configured_attrs, tcx.sess, tcx.features())
+    registered_tools_ast(tcx.dcx(), pre_configured_attrs, tcx.sess)
 }
 
 pub fn registered_tools_ast(
     dcx: DiagCtxtHandle<'_>,
     pre_configured_attrs: &[ast::Attribute],
     sess: &Session,
-    features: &Features,
 ) -> RegisteredTools {
     let mut registered_tools = RegisteredTools::default();
 
     if let Some(Attribute::Parsed(AttributeKind::RegisterTool(tools, _))) =
-        AttributeParser::parse_limited(
-            sess,
-            pre_configured_attrs,
-            &[sym::register_tool],
-            DUMMY_SP,
-            DUMMY_NODE_ID,
-            Some(features),
-        )
+        AttributeParser::parse_limited(sess, pre_configured_attrs, &[sym::register_tool])
     {
         for tool in tools {
             if let Some(old_tool) = registered_tools.replace(tool) {
diff --git a/library/Cargo.lock b/library/Cargo.lock
index d7227def0461d..834babacdb96f 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -344,8 +344,8 @@ dependencies = [
  "std_detect",
  "unwind",
  "vex-sdk",
- "wasi 0.11.1+wasi-snapshot-preview1",
- "wasi 0.14.4+wasi-0.2.4",
+ "wasip1",
+ "wasip2",
  "windows-link 0.0.0",
 ]
 
@@ -407,20 +407,20 @@ dependencies = [
 ]
 
 [[package]]
-name = "wasi"
-version = "0.11.1+wasi-snapshot-preview1"
+name = "wasip1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+checksum = "b5e26842486624357dbeb8f0381cf1fb42f022291fd787d4a816768fec8cc760"
 dependencies = [
  "rustc-std-workspace-alloc",
  "rustc-std-workspace-core",
 ]
 
 [[package]]
-name = "wasi"
-version = "0.14.4+wasi-0.2.4"
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88a5f4a424faf49c3c2c344f166f0662341d470ea185e939657aaff130f0ec4a"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
 dependencies = [
  "rustc-std-workspace-alloc",
  "rustc-std-workspace-core",
@@ -513,9 +513,9 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "wit-bindgen"
-version = "0.45.1"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c573471f125075647d03df72e026074b7203790d41351cd6edc96f46bcccd36"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 dependencies = [
  "rustc-std-workspace-alloc",
  "rustc-std-workspace-core",
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 2c95f199e3c4e..ef7422302d974 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -1287,6 +1287,7 @@ impl<T: ?Sized> Box<T> {
     /// The raw pointer must point to a block of memory allocated by the global allocator.
     ///
     /// The safety conditions are described in the [memory layout] section.
+    /// Note that the [considerations for unsafe code] apply to all `Box<T>` values.
     ///
     /// # Examples
     ///
@@ -1312,6 +1313,7 @@ impl<T: ?Sized> Box<T> {
     /// ```
     ///
     /// [memory layout]: self#memory-layout
+    /// [considerations for unsafe code]: self#considerations-for-unsafe-code
     #[stable(feature = "box_raw", since = "1.4.0")]
     #[inline]
     #[must_use = "call `drop(Box::from_raw(ptr))` if you intend to drop the `Box`"]
@@ -1336,6 +1338,7 @@ impl<T: ?Sized> Box<T> {
     /// The non-null pointer must point to a block of memory allocated by the global allocator.
     ///
     /// The safety conditions are described in the [memory layout] section.
+    /// Note that the [considerations for unsafe code] apply to all `Box<T>` values.
     ///
     /// # Examples
     ///
@@ -1366,6 +1369,7 @@ impl<T: ?Sized> Box<T> {
     /// ```
     ///
     /// [memory layout]: self#memory-layout
+    /// [considerations for unsafe code]: self#considerations-for-unsafe-code
     #[unstable(feature = "box_vec_non_null", issue = "130364")]
     #[inline]
     #[must_use = "call `drop(Box::from_non_null(ptr))` if you intend to drop the `Box`"]
@@ -1509,6 +1513,9 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// The raw pointer must point to a block of memory allocated by `alloc`.
     ///
+    /// The safety conditions are described in the [memory layout] section.
+    /// Note that the [considerations for unsafe code] apply to all `Box<T, A>` values.
+    ///
     /// # Examples
     ///
     /// Recreate a `Box` which was previously converted to a raw pointer
@@ -1540,6 +1547,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     /// ```
     ///
     /// [memory layout]: self#memory-layout
+    /// [considerations for unsafe code]: self#considerations-for-unsafe-code
     #[unstable(feature = "allocator_api", issue = "32838")]
     #[inline]
     pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self {
@@ -1562,6 +1570,9 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// The non-null pointer must point to a block of memory allocated by `alloc`.
     ///
+    /// The safety conditions are described in the [memory layout] section.
+    /// Note that the [considerations for unsafe code] apply to all `Box<T, A>` values.
+    ///
     /// # Examples
     ///
     /// Recreate a `Box` which was previously converted to a `NonNull` pointer
@@ -1592,6 +1603,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     /// ```
     ///
     /// [memory layout]: self#memory-layout
+    /// [considerations for unsafe code]: self#considerations-for-unsafe-code
     #[unstable(feature = "allocator_api", issue = "32838")]
     // #[unstable(feature = "box_vec_non_null", issue = "130364")]
     #[inline]
diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index fc540e2d20dd2..12883e252ca86 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -11,7 +11,7 @@ use crate::convert::Infallible;
 use crate::error::Error;
 use crate::hash::{self, Hash};
 use crate::intrinsics::transmute_unchecked;
-use crate::iter::{UncheckedIterator, repeat_n};
+use crate::iter::{TrustedLen, UncheckedIterator, repeat_n};
 use crate::marker::Destruct;
 use crate::mem::{self, ManuallyDrop, MaybeUninit};
 use crate::ops::{
@@ -1010,19 +1010,66 @@ impl<T: [const] Destruct> const Drop for Guard<'_, T> {
 pub(crate) const fn iter_next_chunk<T, const N: usize>(
     iter: &mut impl [const] Iterator<Item = T>,
 ) -> Result<[T; N], IntoIter<T, N>> {
-    let mut array = [const { MaybeUninit::uninit() }; N];
-    let r = iter_next_chunk_erased(&mut array, iter);
-    match r {
-        Ok(()) => {
-            // SAFETY: All elements of `array` were populated.
-            Ok(unsafe { MaybeUninit::array_assume_init(array) })
+    iter.spec_next_chunk()
+}
+
+pub(crate) const trait SpecNextChunk<T, const N: usize>: Iterator<Item = T> {
+    fn spec_next_chunk(&mut self) -> Result<[T; N], IntoIter<T, N>>;
+}
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+impl<I: [const] Iterator<Item = T>, T, const N: usize> const SpecNextChunk<T, N> for I {
+    #[inline]
+    default fn spec_next_chunk(&mut self) -> Result<[T; N], IntoIter<T, N>> {
+        let mut array = [const { MaybeUninit::uninit() }; N];
+        let r = iter_next_chunk_erased(&mut array, self);
+        match r {
+            Ok(()) => {
+                // SAFETY: All elements of `array` were populated.
+                Ok(unsafe { MaybeUninit::array_assume_init(array) })
+            }
+            Err(initialized) => {
+                // SAFETY: Only the first `initialized` elements were populated
+                Err(unsafe { IntoIter::new_unchecked(array, 0..initialized) })
+            }
         }
-        Err(initialized) => {
-            // SAFETY: Only the first `initialized` elements were populated
-            Err(unsafe { IntoIter::new_unchecked(array, 0..initialized) })
+    }
+}
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+impl<I: [const] Iterator<Item = T> + TrustedLen, T, const N: usize> const SpecNextChunk<T, N>
+    for I
+{
+    fn spec_next_chunk(&mut self) -> Result<[T; N], IntoIter<T, N>> {
+        let len = (*self).size_hint().0;
+        let mut array = [const { MaybeUninit::uninit() }; N];
+        if len < N {
+            // SAFETY: `TrustedLen`, an unsafe trait, requires that i can get len items out of it.
+            unsafe { write(&mut array, self, len) };
+            // SAFETY: Only the first `len` elements were populated
+            Err(unsafe { IntoIter::new_unchecked(array, 0..len) })
+        } else {
+            // SAFETY: `TrustedLen`, an unsafe trait, requires that i can get N items out of it.
+            unsafe { write(&mut array, self, N) };
+            // SAFETY: All N items were populated
+            Ok(unsafe { MaybeUninit::array_assume_init(array) })
         }
     }
 }
+// SAFETY: `from` must have len items, and len items must be < N.
+#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
+const unsafe fn write<T, const N: usize>(
+    to: &mut [MaybeUninit<T>; N],
+    from: &mut impl [const] Iterator<Item = T>,
+    len: usize,
+) {
+    let mut guard = Guard { array_mut: to, initialized: 0 };
+    while guard.initialized < len {
+        // SAFETY: caller has guaranteed, from has len items.
+        let item = unsafe { from.next().unwrap_unchecked() };
+        // SAFETY: guard.initialized < len < N
+        unsafe { guard.push_unchecked(item) };
+    }
+    crate::mem::forget(guard);
+}
 
 /// Version of [`iter_next_chunk`] using a passed-in slice in order to avoid
 /// needing to monomorphize for every array length.
diff --git a/library/coretests/tests/iter/traits/iterator.rs b/library/coretests/tests/iter/traits/iterator.rs
index 5ef1f797ae55d..386946461e9fe 100644
--- a/library/coretests/tests/iter/traits/iterator.rs
+++ b/library/coretests/tests/iter/traits/iterator.rs
@@ -619,6 +619,23 @@ fn test_next_chunk() {
     assert_eq!(it.next_chunk::<0>().unwrap(), []);
 }
 
+#[test]
+fn test_next_chunk_untrusted() {
+    struct Untrusted<I: Iterator>(I);
+    impl<I: Iterator> Iterator for Untrusted<I> {
+        type Item = I::Item;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.0.next()
+        }
+    }
+    let mut it = Untrusted(0..12);
+    assert_eq!(it.next_chunk().unwrap(), [0, 1, 2, 3]);
+    assert_eq!(it.next_chunk().unwrap(), []);
+    assert_eq!(it.next_chunk().unwrap(), [4, 5, 6, 7, 8, 9]);
+    assert_eq!(it.next_chunk::<4>().unwrap_err().as_slice(), &[10, 11]);
+}
+
 #[test]
 fn test_collect_into_tuples() {
     let a = vec![(1, 2, 3), (4, 5, 6), (7, 8, 9)];
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index a22ef6c6689c8..ebd09f31e25ab 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -79,19 +79,19 @@ hermit-abi = { version = "0.5.0", features = [
 ], public = true }
 
 [target.'cfg(all(target_os = "wasi", target_env = "p1"))'.dependencies]
-wasi = { version = "0.11.0", features = [
+wasip1 = { version = "1.0.0", features = [
     'rustc-dep-of-std',
 ], default-features = false }
 
 [target.'cfg(all(target_os = "wasi", target_env = "p2"))'.dependencies]
-wasip2 = { version = '0.14.4', features = [
+wasip2 = { version = '1.0.2', features = [
     'rustc-dep-of-std',
-], default-features = false, package = 'wasi' }
+], default-features = false }
 
 [target.'cfg(all(target_os = "wasi", target_env = "p3"))'.dependencies]
-wasip2 = { version = '0.14.4', features = [
+wasip2 = { version = '1.0.2', features = [
     'rustc-dep-of-std',
-], default-features = false, package = 'wasi' }
+], default-features = false }
 
 [target.'cfg(target_os = "uefi")'.dependencies]
 r-efi = { version = "5.2.0", features = ['rustc-dep-of-std'] }
diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs
index 4192254f6c824..4d190d90ca73d 100644
--- a/library/std/src/collections/hash/map.rs
+++ b/library/std/src/collections/hash/map.rs
@@ -20,7 +20,7 @@ use crate::ops::Index;
 /// reasonable best-effort is made to generate this seed from a high quality,
 /// secure source of randomness provided by the host without blocking the
 /// program. Because of this, the randomness of the seed depends on the output
-/// quality of the system's random number coroutine when the seed is created.
+/// quality of the system's random number generator when the seed is created.
 /// In particular, seeds generated when the system's entropy pool is abnormally
 /// low such as during system boot may be of a lower quality.
 ///
diff --git a/library/std/src/net/tcp.rs b/library/std/src/net/tcp.rs
index dac568e419f3f..a8046a5541c51 100644
--- a/library/std/src/net/tcp.rs
+++ b/library/std/src/net/tcp.rs
@@ -582,8 +582,8 @@ impl TcpStream {
     /// to be retried, an error with kind [`io::ErrorKind::WouldBlock`] is
     /// returned.
     ///
-    /// On Unix platforms, calling this method corresponds to calling `fcntl`
-    /// `FIONBIO`. On Windows calling this method corresponds to calling
+    /// On most Unix platforms, calling this method corresponds to calling `ioctl`
+    /// `FIONBIO`. On Windows, calling this method corresponds to calling
     /// `ioctlsocket` `FIONBIO`.
     ///
     /// # Examples
@@ -988,8 +988,8 @@ impl TcpListener {
     /// IO operation could not be completed and needs to be retried, an error
     /// with kind [`io::ErrorKind::WouldBlock`] is returned.
     ///
-    /// On Unix platforms, calling this method corresponds to calling `fcntl`
-    /// `FIONBIO`. On Windows calling this method corresponds to calling
+    /// On most Unix platforms, calling this method corresponds to calling `ioctl`
+    /// `FIONBIO`. On Windows, calling this method corresponds to calling
     /// `ioctlsocket` `FIONBIO`.
     ///
     /// # Examples
diff --git a/library/std/src/net/udp.rs b/library/std/src/net/udp.rs
index 5da6b38037f0e..cd925b9bdfdf8 100644
--- a/library/std/src/net/udp.rs
+++ b/library/std/src/net/udp.rs
@@ -786,8 +786,8 @@ impl UdpSocket {
     /// and needs to be retried, an error with kind
     /// [`io::ErrorKind::WouldBlock`] is returned.
     ///
-    /// On Unix platforms, calling this method corresponds to calling `fcntl`
-    /// `FIONBIO`. On Windows calling this method corresponds to calling
+    /// On most Unix platforms, calling this method corresponds to calling `ioctl`
+    /// `FIONBIO`. On Windows, calling this method corresponds to calling
     /// `ioctlsocket` `FIONBIO`.
     ///
     /// # Examples
diff --git a/library/std/src/os/wasi/fs.rs b/library/std/src/os/wasi/fs.rs
index 248112cb369dc..ffc8737df16f2 100644
--- a/library/std/src/os/wasi/fs.rs
+++ b/library/std/src/os/wasi/fs.rs
@@ -246,13 +246,15 @@ impl FileExt for File {
 
     #[cfg(target_env = "p1")]
     fn fdstat_set_flags(&self, flags: u16) -> io::Result<()> {
-        unsafe { wasi::fd_fdstat_set_flags(self.as_raw_fd() as wasi::Fd, flags).map_err(err2io) }
+        unsafe {
+            wasip1::fd_fdstat_set_flags(self.as_raw_fd() as wasip1::Fd, flags).map_err(err2io)
+        }
     }
 
     #[cfg(target_env = "p1")]
     fn fdstat_set_rights(&self, rights: u64, inheriting: u64) -> io::Result<()> {
         unsafe {
-            wasi::fd_fdstat_set_rights(self.as_raw_fd() as wasi::Fd, rights, inheriting)
+            wasip1::fd_fdstat_set_rights(self.as_raw_fd() as wasip1::Fd, rights, inheriting)
                 .map_err(err2io)
         }
     }
@@ -260,12 +262,12 @@ impl FileExt for File {
     #[cfg(target_env = "p1")]
     fn advise(&self, offset: u64, len: u64, advice: u8) -> io::Result<()> {
         let advice = match advice {
-            a if a == wasi::ADVICE_NORMAL.raw() => wasi::ADVICE_NORMAL,
-            a if a == wasi::ADVICE_SEQUENTIAL.raw() => wasi::ADVICE_SEQUENTIAL,
-            a if a == wasi::ADVICE_RANDOM.raw() => wasi::ADVICE_RANDOM,
-            a if a == wasi::ADVICE_WILLNEED.raw() => wasi::ADVICE_WILLNEED,
-            a if a == wasi::ADVICE_DONTNEED.raw() => wasi::ADVICE_DONTNEED,
-            a if a == wasi::ADVICE_NOREUSE.raw() => wasi::ADVICE_NOREUSE,
+            a if a == wasip1::ADVICE_NORMAL.raw() => wasip1::ADVICE_NORMAL,
+            a if a == wasip1::ADVICE_SEQUENTIAL.raw() => wasip1::ADVICE_SEQUENTIAL,
+            a if a == wasip1::ADVICE_RANDOM.raw() => wasip1::ADVICE_RANDOM,
+            a if a == wasip1::ADVICE_WILLNEED.raw() => wasip1::ADVICE_WILLNEED,
+            a if a == wasip1::ADVICE_DONTNEED.raw() => wasip1::ADVICE_DONTNEED,
+            a if a == wasip1::ADVICE_NOREUSE.raw() => wasip1::ADVICE_NOREUSE,
             _ => {
                 return Err(io::const_error!(
                     io::ErrorKind::InvalidInput,
@@ -275,31 +277,35 @@ impl FileExt for File {
         };
 
         unsafe {
-            wasi::fd_advise(self.as_raw_fd() as wasi::Fd, offset, len, advice).map_err(err2io)
+            wasip1::fd_advise(self.as_raw_fd() as wasip1::Fd, offset, len, advice).map_err(err2io)
         }
     }
 
     #[cfg(target_env = "p1")]
     fn allocate(&self, offset: u64, len: u64) -> io::Result<()> {
-        unsafe { wasi::fd_allocate(self.as_raw_fd() as wasi::Fd, offset, len).map_err(err2io) }
+        unsafe { wasip1::fd_allocate(self.as_raw_fd() as wasip1::Fd, offset, len).map_err(err2io) }
     }
 
     #[cfg(target_env = "p1")]
     fn create_directory<P: AsRef<Path>>(&self, dir: P) -> io::Result<()> {
         let path = osstr2str(dir.as_ref().as_ref())?;
-        unsafe { wasi::path_create_directory(self.as_raw_fd() as wasi::Fd, path).map_err(err2io) }
+        unsafe {
+            wasip1::path_create_directory(self.as_raw_fd() as wasip1::Fd, path).map_err(err2io)
+        }
     }
 
     #[cfg(target_env = "p1")]
     fn remove_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
         let path = osstr2str(path.as_ref().as_ref())?;
-        unsafe { wasi::path_unlink_file(self.as_raw_fd() as wasi::Fd, path).map_err(err2io) }
+        unsafe { wasip1::path_unlink_file(self.as_raw_fd() as wasip1::Fd, path).map_err(err2io) }
     }
 
     #[cfg(target_env = "p1")]
     fn remove_directory<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
         let path = osstr2str(path.as_ref().as_ref())?;
-        unsafe { wasi::path_remove_directory(self.as_raw_fd() as wasi::Fd, path).map_err(err2io) }
+        unsafe {
+            wasip1::path_remove_directory(self.as_raw_fd() as wasip1::Fd, path).map_err(err2io)
+        }
     }
 }
 
@@ -388,11 +394,11 @@ pub fn link<P: AsRef<Path>, U: AsRef<Path>>(
     new_path: U,
 ) -> io::Result<()> {
     unsafe {
-        wasi::path_link(
-            old_fd.as_raw_fd() as wasi::Fd,
+        wasip1::path_link(
+            old_fd.as_raw_fd() as wasip1::Fd,
             old_flags,
             osstr2str(old_path.as_ref().as_ref())?,
-            new_fd.as_raw_fd() as wasi::Fd,
+            new_fd.as_raw_fd() as wasip1::Fd,
             osstr2str(new_path.as_ref().as_ref())?,
         )
         .map_err(err2io)
@@ -411,10 +417,10 @@ pub fn rename<P: AsRef<Path>, U: AsRef<Path>>(
     new_path: U,
 ) -> io::Result<()> {
     unsafe {
-        wasi::path_rename(
-            old_fd.as_raw_fd() as wasi::Fd,
+        wasip1::path_rename(
+            old_fd.as_raw_fd() as wasip1::Fd,
             osstr2str(old_path.as_ref().as_ref())?,
-            new_fd.as_raw_fd() as wasi::Fd,
+            new_fd.as_raw_fd() as wasip1::Fd,
             osstr2str(new_path.as_ref().as_ref())?,
         )
         .map_err(err2io)
@@ -432,9 +438,9 @@ pub fn symlink<P: AsRef<Path>, U: AsRef<Path>>(
     new_path: U,
 ) -> io::Result<()> {
     unsafe {
-        wasi::path_symlink(
+        wasip1::path_symlink(
             osstr2str(old_path.as_ref().as_ref())?,
-            fd.as_raw_fd() as wasi::Fd,
+            fd.as_raw_fd() as wasip1::Fd,
             osstr2str(new_path.as_ref().as_ref())?,
         )
         .map_err(err2io)
diff --git a/library/std/src/os/wasi/net/mod.rs b/library/std/src/os/wasi/net/mod.rs
index 9430cd3b05eee..fd5889bf9b7b5 100644
--- a/library/std/src/os/wasi/net/mod.rs
+++ b/library/std/src/os/wasi/net/mod.rs
@@ -18,6 +18,6 @@ pub trait TcpListenerExt {
 
 impl TcpListenerExt for net::TcpListener {
     fn sock_accept(&self, flags: u16) -> io::Result<u32> {
-        unsafe { wasi::sock_accept(self.as_raw_fd() as wasi::Fd, flags).map_err(err2io) }
+        unsafe { wasip1::sock_accept(self.as_raw_fd() as wasip1::Fd, flags).map_err(err2io) }
     }
 }
diff --git a/library/std/src/sys/alloc/windows.rs b/library/std/src/sys/alloc/windows.rs
index 90da0b7e9965c..9336a6ec085aa 100644
--- a/library/std/src/sys/alloc/windows.rs
+++ b/library/std/src/sys/alloc/windows.rs
@@ -118,6 +118,9 @@ unsafe fn allocate(layout: Layout, zeroed: bool) -> *mut u8 {
         process_heap_alloc(MaybeUninit::uninit(), flags, layout.size()) as *mut u8
     } else {
         // Allocate extra padding in order to be able to satisfy the alignment.
+        // This addition does not overflow due to `Layout` type invariants,
+        // `size()` is at most `isize::MAX` while
+        // `align()` is at most `1 << (bits in usize - 2)` if `size()` is non-zero.
         let total = layout.align() + layout.size();
 
         let ptr = process_heap_alloc(MaybeUninit::uninit(), flags, total) as *mut u8;
diff --git a/library/std/src/sys/args/wasip1.rs b/library/std/src/sys/args/wasip1.rs
index 72063a87dc9f5..c09175a23f50f 100644
--- a/library/std/src/sys/args/wasip1.rs
+++ b/library/std/src/sys/args/wasip1.rs
@@ -11,10 +11,10 @@ pub fn args() -> Args {
 
 fn maybe_args() -> Option<Vec<OsString>> {
     unsafe {
-        let (argc, buf_size) = wasi::args_sizes_get().ok()?;
+        let (argc, buf_size) = wasip1::args_sizes_get().ok()?;
         let mut argv = Vec::with_capacity(argc);
         let mut buf = Vec::with_capacity(buf_size);
-        wasi::args_get(argv.as_mut_ptr(), buf.as_mut_ptr()).ok()?;
+        wasip1::args_get(argv.as_mut_ptr(), buf.as_mut_ptr()).ok()?;
         argv.set_len(argc);
         let mut ret = Vec::with_capacity(argc);
         for ptr in argv {
diff --git a/library/std/src/sys/fs/uefi.rs b/library/std/src/sys/fs/uefi.rs
index 8135519317a02..ef523a9807f1c 100644
--- a/library/std/src/sys/fs/uefi.rs
+++ b/library/std/src/sys/fs/uefi.rs
@@ -588,6 +588,11 @@ mod uefi_fs {
         path: crate::path::PathBuf,
     }
 
+    // SAFETY: UEFI has no regular threads, and as per <https://github.com/rust-lang/rust/issues/133604>
+    // std does not support being invoked from "irregular threads" such as interrupt handlers or other
+    // CPU cores that run outside the scope of UEFI.
+    unsafe impl Send for File {}
+
     impl File {
         pub(crate) fn from_path(path: &Path, open_mode: u64, attr: u64) -> io::Result<Self> {
             let absolute = crate::path::absolute(path)?;
diff --git a/library/std/src/sys/net/connection/wasip1.rs b/library/std/src/sys/net/connection/wasip1.rs
index 95a4ab2fbf0fd..d6c7e023e865d 100644
--- a/library/std/src/sys/net/connection/wasip1.rs
+++ b/library/std/src/sys/net/connection/wasip1.rs
@@ -125,12 +125,12 @@ impl TcpStream {
 
     pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
         let wasi_how = match how {
-            Shutdown::Read => wasi::SDFLAGS_RD,
-            Shutdown::Write => wasi::SDFLAGS_WR,
-            Shutdown::Both => wasi::SDFLAGS_RD | wasi::SDFLAGS_WR,
+            Shutdown::Read => wasip1::SDFLAGS_RD,
+            Shutdown::Write => wasip1::SDFLAGS_WR,
+            Shutdown::Both => wasip1::SDFLAGS_RD | wasip1::SDFLAGS_WR,
         };
 
-        unsafe { wasi::sock_shutdown(self.socket().as_raw_fd() as _, wasi_how).map_err(err2io) }
+        unsafe { wasip1::sock_shutdown(self.socket().as_raw_fd() as _, wasi_how).map_err(err2io) }
     }
 
     pub fn duplicate(&self) -> io::Result<TcpStream> {
@@ -167,19 +167,20 @@ impl TcpStream {
 
     pub fn set_nonblocking(&self, state: bool) -> io::Result<()> {
         let fdstat = unsafe {
-            wasi::fd_fdstat_get(self.socket().as_inner().as_raw_fd() as wasi::Fd).map_err(err2io)?
+            wasip1::fd_fdstat_get(self.socket().as_inner().as_raw_fd() as wasip1::Fd)
+                .map_err(err2io)?
         };
 
         let mut flags = fdstat.fs_flags;
 
         if state {
-            flags |= wasi::FDFLAGS_NONBLOCK;
+            flags |= wasip1::FDFLAGS_NONBLOCK;
         } else {
-            flags &= !wasi::FDFLAGS_NONBLOCK;
+            flags &= !wasip1::FDFLAGS_NONBLOCK;
         }
 
         unsafe {
-            wasi::fd_fdstat_set_flags(self.socket().as_inner().as_raw_fd() as wasi::Fd, flags)
+            wasip1::fd_fdstat_set_flags(self.socket().as_inner().as_raw_fd() as wasip1::Fd, flags)
                 .map_err(err2io)
         }
     }
@@ -221,7 +222,7 @@ impl TcpListener {
 
     pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
         let fd = unsafe {
-            wasi::sock_accept(self.as_inner().as_inner().as_raw_fd() as _, 0).map_err(err2io)?
+            wasip1::sock_accept(self.as_inner().as_inner().as_raw_fd() as _, 0).map_err(err2io)?
         };
 
         Ok((
@@ -258,19 +259,20 @@ impl TcpListener {
 
     pub fn set_nonblocking(&self, state: bool) -> io::Result<()> {
         let fdstat = unsafe {
-            wasi::fd_fdstat_get(self.socket().as_inner().as_raw_fd() as wasi::Fd).map_err(err2io)?
+            wasip1::fd_fdstat_get(self.socket().as_inner().as_raw_fd() as wasip1::Fd)
+                .map_err(err2io)?
         };
 
         let mut flags = fdstat.fs_flags;
 
         if state {
-            flags |= wasi::FDFLAGS_NONBLOCK;
+            flags |= wasip1::FDFLAGS_NONBLOCK;
         } else {
-            flags &= !wasi::FDFLAGS_NONBLOCK;
+            flags &= !wasip1::FDFLAGS_NONBLOCK;
         }
 
         unsafe {
-            wasi::fd_fdstat_set_flags(self.socket().as_inner().as_raw_fd() as wasi::Fd, flags)
+            wasip1::fd_fdstat_set_flags(self.socket().as_inner().as_raw_fd() as wasip1::Fd, flags)
                 .map_err(err2io)
         }
     }
diff --git a/library/std/src/sys/pal/wasi/mod.rs b/library/std/src/sys/pal/wasi/mod.rs
index 6f60993509253..8ea26faca7e70 100644
--- a/library/std/src/sys/pal/wasi/mod.rs
+++ b/library/std/src/sys/pal/wasi/mod.rs
@@ -29,7 +29,7 @@ pub fn abort_internal() -> ! {
 
 #[inline]
 #[cfg(target_env = "p1")]
-pub(crate) fn err2io(err: wasi::Errno) -> crate::io::Error {
+pub(crate) fn err2io(err: wasip1::Errno) -> crate::io::Error {
     crate::io::Error::from_raw_os_error(err.raw().into())
 }
 
diff --git a/library/std/src/sys/random/wasip1.rs b/library/std/src/sys/random/wasip1.rs
index d41da3751fc04..cb91575fe30ef 100644
--- a/library/std/src/sys/random/wasip1.rs
+++ b/library/std/src/sys/random/wasip1.rs
@@ -1,5 +1,5 @@
 pub fn fill_bytes(bytes: &mut [u8]) {
     unsafe {
-        wasi::random_get(bytes.as_mut_ptr(), bytes.len()).expect("failed to generate random data")
+        wasip1::random_get(bytes.as_mut_ptr(), bytes.len()).expect("failed to generate random data")
     }
 }
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index b0730de771395..11569837fbfa6 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -539,7 +539,8 @@ const PERMITTED_STDLIB_DEPENDENCIES: &[&str] = &[
     "shlex",
     "unwinding",
     "vex-sdk",
-    "wasi",
+    "wasip1",
+    "wasip2",
     "windows-link",
     "windows-sys",
     "windows-targets",
@@ -881,10 +882,7 @@ fn check_runtime_no_duplicate_dependencies(metadata: &Metadata, check: &mut Runn
             continue;
         }
 
-        // Skip the `wasi` crate here which the standard library explicitly
-        // depends on two version of (one for the `wasm32-wasip1` target and
-        // another for the `wasm32-wasip2` target).
-        if pkg.name.to_string() != "wasi" && !seen_pkgs.insert(&*pkg.name) {
+        if !seen_pkgs.insert(&*pkg.name) {
             check.error(format!(
                 "duplicate package `{}` is not allowed for the standard library",
                 pkg.name
diff --git a/tests/ui/issues/issue-45425.rs b/tests/ui/higher-ranked/binop-lhs-hrtb-subtyping.rs
similarity index 69%
rename from tests/ui/issues/issue-45425.rs
rename to tests/ui/higher-ranked/binop-lhs-hrtb-subtyping.rs
index fad8284caf5ba..9408bc120e1c7 100644
--- a/tests/ui/issues/issue-45425.rs
+++ b/tests/ui/higher-ranked/binop-lhs-hrtb-subtyping.rs
@@ -1,3 +1,4 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/45425>
 //@ check-pass
 #![allow(dead_code)]
 use std::ops::Add;
diff --git a/tests/ui/issues/auxiliary/issue-2316-a.rs b/tests/ui/issues/auxiliary/issue-2316-a.rs
deleted file mode 100644
index 418ddc0b06926..0000000000000
--- a/tests/ui/issues/auxiliary/issue-2316-a.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-enum cat {
-  tabby, calico, tortoiseshell
-}
diff --git a/tests/ui/issues/auxiliary/issue-2316-b.rs b/tests/ui/issues/auxiliary/issue-2316-b.rs
deleted file mode 100644
index 550c2d6eb226d..0000000000000
--- a/tests/ui/issues/auxiliary/issue-2316-b.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(unused_imports)]
-
-extern crate issue_2316_a;
-
-pub mod cloth {
-    use issue_2316_a::*;
-
-    pub enum fabric {
-        gingham, flannel, calico
-    }
-}
diff --git a/tests/ui/issues/issue-2316-c.rs b/tests/ui/issues/issue-2316-c.rs
deleted file mode 100644
index f800d4723ffd2..0000000000000
--- a/tests/ui/issues/issue-2316-c.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-pass
-//@ aux-build:issue-2316-a.rs
-//@ aux-build:issue-2316-b.rs
-
-
-extern crate issue_2316_b;
-use issue_2316_b::cloth;
-
-pub fn main() {
-  let _c: cloth::fabric = cloth::fabric::calico;
-}
diff --git a/tests/ui/issues/issue-32008.rs b/tests/ui/overloaded/subtyping-both-lhs-and-rhs-in-add-impl.rs
similarity index 89%
rename from tests/ui/issues/issue-32008.rs
rename to tests/ui/overloaded/subtyping-both-lhs-and-rhs-in-add-impl.rs
index 9075085bab746..7ec43607c2bca 100644
--- a/tests/ui/issues/issue-32008.rs
+++ b/tests/ui/overloaded/subtyping-both-lhs-and-rhs-in-add-impl.rs
@@ -1,3 +1,4 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/32008>
 //@ run-pass
 #![allow(dead_code)]
 #![allow(unused_variables)]
diff --git a/tests/ui/reborrow/reborrow-mutable-reference.rs b/tests/ui/reborrow/reborrow-mutable-reference.rs
new file mode 100644
index 0000000000000..a66e4de34bcb0
--- /dev/null
+++ b/tests/ui/reborrow/reborrow-mutable-reference.rs
@@ -0,0 +1,15 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/28839>
+//@ run-pass
+
+pub struct Foo;
+
+pub fn get_foo2<'a>(foo: &'a mut Option<&'a mut Foo>) -> &'a mut Foo {
+    match foo {
+        // Ensure that this is not considered a move, but rather a reborrow.
+        &mut Some(ref mut x) => *x,
+        &mut None => panic!(),
+    }
+}
+
+fn main() {
+}
diff --git a/tests/ui/resolve/auxiliary/resolve-conflict-local-vs-glob-import-a.rs b/tests/ui/resolve/auxiliary/resolve-conflict-local-vs-glob-import-a.rs
new file mode 100644
index 0000000000000..3ce7e5f30836c
--- /dev/null
+++ b/tests/ui/resolve/auxiliary/resolve-conflict-local-vs-glob-import-a.rs
@@ -0,0 +1,4 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/2316>
+enum cat {
+  tabby, calico, tortoiseshell
+}
diff --git a/tests/ui/resolve/auxiliary/resolve-conflict-local-vs-glob-import-b.rs b/tests/ui/resolve/auxiliary/resolve-conflict-local-vs-glob-import-b.rs
new file mode 100644
index 0000000000000..64fc45e21faf1
--- /dev/null
+++ b/tests/ui/resolve/auxiliary/resolve-conflict-local-vs-glob-import-b.rs
@@ -0,0 +1,12 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/2316>
+#![allow(unused_imports)]
+
+extern crate resolve_conflict_local_vs_glob_import_a;
+
+pub mod cloth {
+    use resolve_conflict_local_vs_glob_import_a::*;
+
+    pub enum fabric {
+        gingham, flannel, calico
+    }
+}
diff --git a/tests/ui/resolve/resolve-conflict-local-vs-glob-import.rs b/tests/ui/resolve/resolve-conflict-local-vs-glob-import.rs
new file mode 100644
index 0000000000000..eebab6509d738
--- /dev/null
+++ b/tests/ui/resolve/resolve-conflict-local-vs-glob-import.rs
@@ -0,0 +1,12 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/2316>
+//@ run-pass
+//@ aux-build:resolve-conflict-local-vs-glob-import-a.rs
+//@ aux-build:resolve-conflict-local-vs-glob-import-b.rs
+
+
+extern crate resolve_conflict_local_vs_glob_import_b;
+use resolve_conflict_local_vs_glob_import_b::cloth;
+
+pub fn main() {
+  let _c: cloth::fabric = cloth::fabric::calico;
+}