Rollup of 4 pull requests

compiler/rustc_ast/src/lib.rs

@@ -5,7 +5,6 @@
 //! This API is completely unstable and subject to change.
 
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(array_windows))]
 #![doc(test(attr(deny(warnings), allow(internal_features))))]
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -1,4 +1,8 @@
-use rustc_hir::attrs::WindowsSubsystemKind;
+use rustc_hir::attrs::{CrateType, WindowsSubsystemKind};
+use rustc_hir::lints::AttributeLintKind;
+use rustc_session::lint::builtin::UNKNOWN_CRATE_TYPES;
+use rustc_span::Symbol;
+use rustc_span::edit_distance::find_best_match_for_name;
 
 use super::prelude::*;
 
@@ -26,6 +30,56 @@ impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
     }
 }
 
+pub(crate) struct CrateTypeParser;
+
+impl<S: Stage> CombineAttributeParser<S> for CrateTypeParser {
+    const PATH: &[Symbol] = &[sym::crate_type];
+    type Item = CrateType;
+    const CONVERT: ConvertFn<Self::Item> = |items, _| AttributeKind::CrateType(items);
+
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+
+    const TEMPLATE: AttributeTemplate =
+        template!(NameValueStr: "crate type", "https://doc.rust-lang.org/reference/linkage.html");
+
+    fn extend(
+        cx: &mut AcceptContext<'_, '_, S>,
+        args: &ArgParser,
+    ) -> impl IntoIterator<Item = Self::Item> {
+        let ArgParser::NameValue(n) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        let Some(crate_type) = n.value_as_str() else {
+            cx.expected_string_literal(n.value_span, Some(n.value_as_lit()));
+            return None;
+        };
+
+        let Ok(crate_type) = crate_type.try_into() else {
+            // We don't error on invalid `#![crate_type]` when not applied to a crate
+            if cx.shared.target == Target::Crate {
+                let candidate = find_best_match_for_name(
+                    &CrateType::all_stable().iter().map(|(name, _)| *name).collect::<Vec<_>>(),
+                    crate_type,
+                    None,
+                );
+                cx.emit_lint(
+                    UNKNOWN_CRATE_TYPES,
+                    AttributeLintKind::CrateTypeUnknown {
+                        span: n.value_span,
+                        suggested: candidate,
+                    },
+                    n.value_span,
+                );
+            }
+            return None;
+        };
+
+        Some(crate_type)
+    }
+}
+
 pub(crate) struct RecursionLimitParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -28,10 +28,10 @@ use crate::attributes::codegen_attrs::{
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
-    CrateNameParser, MoveSizeLimitParser, NeedsPanicRuntimeParser, NoBuiltinsParser, NoCoreParser,
-    NoMainParser, NoStdParser, PanicRuntimeParser, PatternComplexityLimitParser,
-    ProfilerRuntimeParser, RecursionLimitParser, RustcCoherenceIsCoreParser, TypeLengthLimitParser,
-    WindowsSubsystemParser,
+    CrateNameParser, CrateTypeParser, MoveSizeLimitParser, NeedsPanicRuntimeParser,
+    NoBuiltinsParser, NoCoreParser, NoMainParser, NoStdParser, PanicRuntimeParser,
+    PatternComplexityLimitParser, ProfilerRuntimeParser, RecursionLimitParser,
+    RustcCoherenceIsCoreParser, TypeLengthLimitParser, WindowsSubsystemParser,
 };
 use crate::attributes::debugger::DebuggerViualizerParser;
 use crate::attributes::deprecation::DeprecationParser;
@@ -193,6 +193,7 @@ attribute_parsers!(
         // tidy-alphabetical-start
         Combine<AllowConstFnUnstableParser>,
         Combine<AllowInternalUnstableParser>,
+        Combine<CrateTypeParser>,
         Combine<DebuggerViualizerParser>,
         Combine<ForceTargetFeatureParser>,
         Combine<LinkParser>,

compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs

@@ -92,7 +92,7 @@ pub(crate) fn needs_gdb_debug_scripts_section(cx: &CodegenCx<'_, '_>) -> bool {
         CrateType::Executable
         | CrateType::Dylib
         | CrateType::Cdylib
-        | CrateType::Staticlib
+        | CrateType::StaticLib
         | CrateType::Sdylib => {
             // These are crate types for which we will embed pretty printers since they
             // are treated as leaf crates.

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -136,7 +136,7 @@ pub fn link_binary(
                     )
                     .build(&out_filename);
                 }
-                CrateType::Staticlib => {
+                CrateType::StaticLib => {
                     link_staticlib(
                         sess,
                         archive_builder_builder,
@@ -474,7 +474,7 @@ fn link_staticlib(
 
     let res = each_linked_rlib(
         &codegen_results.crate_info,
-        Some(CrateType::Staticlib),
+        Some(CrateType::StaticLib),
         &mut |cnum, path| {
             let lto = are_upstream_rust_objects_already_included(sess)
                 && !ignored_for_lto(sess, &codegen_results.crate_info, cnum);
@@ -532,7 +532,7 @@ fn link_staticlib(
     let fmts = codegen_results
         .crate_info
         .dependency_formats
-        .get(&CrateType::Staticlib)
+        .get(&CrateType::StaticLib)
         .expect("no dependency formats for staticlib");
 
     let mut all_rust_dylibs = vec![];
@@ -1210,7 +1210,7 @@ fn add_sanitizer_libraries(
         return;
     }
 
-    if matches!(crate_type, CrateType::Rlib | CrateType::Staticlib) {
+    if matches!(crate_type, CrateType::Rlib | CrateType::StaticLib) {
         return;
     }
 

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -1857,7 +1857,7 @@ pub(crate) fn linked_symbols(
         | CrateType::Cdylib
         | CrateType::Dylib
         | CrateType::Sdylib => (),
-        CrateType::Staticlib | CrateType::Rlib => {
+        CrateType::StaticLib | CrateType::Rlib => {
             // These are not linked, so no need to generate symbols.o for them.
             return Vec::new();
         }

compiler/rustc_codegen_ssa/src/back/lto.rs

@@ -67,7 +67,7 @@ fn crate_type_allows_lto(crate_type: CrateType) -> bool {
     match crate_type {
         CrateType::Executable
         | CrateType::Dylib
-        | CrateType::Staticlib
+        | CrateType::StaticLib
         | CrateType::Cdylib
         | CrateType::ProcMacro
         | CrateType::Sdylib => true,

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -28,7 +28,7 @@ fn threshold(tcx: TyCtxt<'_>) -> SymbolExportLevel {
 
 fn crate_export_threshold(crate_type: CrateType) -> SymbolExportLevel {
     match crate_type {
-        CrateType::Executable | CrateType::Staticlib | CrateType::ProcMacro | CrateType::Cdylib => {
+        CrateType::Executable | CrateType::StaticLib | CrateType::ProcMacro | CrateType::Cdylib => {
             SymbolExportLevel::C
         }
         CrateType::Rlib | CrateType::Dylib | CrateType::Sdylib => SymbolExportLevel::Rust,

compiler/rustc_codegen_ssa/src/base.rs

@@ -1009,7 +1009,7 @@ impl CrateInfo {
             info.linked_symbols
                 .iter_mut()
                 .filter(|(crate_type, _)| {
-                    !matches!(crate_type, CrateType::Rlib | CrateType::Staticlib)
+                    !matches!(crate_type, CrateType::Rlib | CrateType::StaticLib)
                 })
                 .for_each(|(_, linked_symbols)| {
                     let mut symbols = missing_weak_lang_items
@@ -1041,7 +1041,7 @@ impl CrateInfo {
                 // this is a rare use case and we don't want to slow down the common case.
                 false
             }
-            CrateType::Staticlib | CrateType::Rlib => {
+            CrateType::StaticLib | CrateType::Rlib => {
                 // We don't invoke the linker for these, so we don't need to collect the NatVis for
                 // them.
                 false

compiler/rustc_codegen_ssa/src/traits/backend.rs

@@ -67,7 +67,7 @@ pub trait CodegenBackend {
             CrateType::Executable,
             CrateType::Dylib,
             CrateType::Rlib,
-            CrateType::Staticlib,
+            CrateType::StaticLib,
             CrateType::Cdylib,
             CrateType::ProcMacro,
             CrateType::Sdylib,

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -66,6 +66,14 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
                             variant
                         }
+                        ty::Slice(ty) => {
+                            let (variant, variant_place) = downcast(sym::Slice)?;
+                            let slice_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+
+                            self.write_slice_type_info(slice_place, *ty)?;
+
+                            variant
+                        }
                         ty::Bool => {
                             let (variant, _variant_place) = downcast(sym::Bool)?;
                             variant
@@ -124,7 +132,6 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         ty::Adt(_, _)
                         | ty::Foreign(_)
                         | ty::Pat(_, _)
-                        | ty::Slice(_)
                         | ty::FnDef(..)
                         | ty::FnPtr(..)
                         | ty::UnsafeBinder(..)
@@ -254,6 +261,27 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         interp_ok(())
     }
 
+    pub(crate) fn write_slice_type_info(
+        &mut self,
+        place: impl Writeable<'tcx, CtfeProvenance>,
+        ty: Ty<'tcx>,
+    ) -> InterpResult<'tcx> {
+        // Iterate over all fields of `type_info::Slice`.
+        for (field_idx, field) in
+            place.layout().ty.ty_adt_def().unwrap().non_enum_variant().fields.iter_enumerated()
+        {
+            let field_place = self.project_field(&place, field_idx)?;
+
+            match field.name {
+                // Write the `TypeId` of the slice's elements to the `element_ty` field.
+                sym::element_ty => self.write_type_id(ty, &field_place)?,
+                other => span_bug!(self.tcx.def_span(field.did), "unimplemented field {other}"),
+            }
+        }
+
+        interp_ok(())
+    }
+
     fn write_int_type_info(
         &mut self,
         place: impl Writeable<'tcx, CtfeProvenance>,

compiler/rustc_data_structures/src/lib.rs

@@ -10,7 +10,6 @@
 #![allow(internal_features)]
 #![allow(rustc::default_hash_types)]
 #![allow(rustc::potential_query_instability)]
-#![cfg_attr(bootstrap, feature(array_windows))]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![feature(allocator_api)]
 #![feature(ascii_char)]

compiler/rustc_driver_impl/src/lib.rs

@@ -42,6 +42,7 @@ use rustc_feature::find_gated_cfg;
 // `rust_index` isn't used in this crate's code, but it must be named in the
 // `Cargo.toml` for the `rustc_randomized_layouts` feature.
 use rustc_index as _;
+use rustc_interface::passes::collect_crate_types;
 use rustc_interface::util::{self, get_codegen_backend};
 use rustc_interface::{Linker, create_and_enter_global_ctxt, interface, passes};
 use rustc_lint::unerased_lint_store;
@@ -56,10 +57,10 @@ use rustc_session::config::{
 };
 use rustc_session::getopts::{self, Matches};
 use rustc_session::lint::{Lint, LintId};
-use rustc_session::output::{CRATE_TYPES, collect_crate_types, invalid_output_for_target};
+use rustc_session::output::invalid_output_for_target;
 use rustc_session::{EarlyDiagCtxt, Session, config};
-use rustc_span::FileName;
 use rustc_span::def_id::LOCAL_CRATE;
+use rustc_span::{DUMMY_SP, FileName};
 use rustc_target::json::ToJson;
 use rustc_target::spec::{Target, TargetTuple};
 use tracing::trace;
@@ -698,6 +699,7 @@ fn print_crate_info(
                     &codegen_backend.supported_crate_types(sess),
                     codegen_backend.name(),
                     attrs,
+                    DUMMY_SP,
                 );
                 for &style in &crate_types {
                     let fname = rustc_session::output::filename_for_input(
@@ -849,7 +851,7 @@ fn print_crate_info(
                 }
             }
             SupportedCrateTypes => {
-                let supported_crate_types = CRATE_TYPES
+                let supported_crate_types = CrateType::all()
                     .iter()
                     .filter(|(_, crate_type)| !invalid_output_for_target(sess, *crate_type))
                     .filter(|(_, crate_type)| *crate_type != CrateType::Sdylib)

compiler/rustc_errors/src/lib.rs

@@ -5,7 +5,6 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::direct_use_of_rustc_type_ir)]
-#![cfg_attr(bootstrap, feature(array_windows))]
 #![feature(assert_matches)]
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]

compiler/rustc_expand/src/lib.rs

@@ -1,6 +1,5 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(array_windows))]
 #![feature(associated_type_defaults)]
 #![feature(if_let_guard)]
 #![feature(macro_metavar_expr)]

compiler/rustc_feature/src/removed.rs

@@ -61,7 +61,7 @@ declare_features! (
     /// Allows a test to fail without failing the whole suite.
     (removed, allow_fail, "1.60.0", Some(46488), Some("removed due to no clear use cases"), 93416),
     /// Allows users to enforce equality of associated constants `TraitImpl<AssocConst=3>`.
-    (removed, associated_const_equality, "CURRENT_RUSTC_VERSION", Some(92827),
+    (removed, associated_const_equality, "1.94.0", Some(92827),
      Some("merged into `min_generic_const_args`")),
     (removed, await_macro, "1.38.0", Some(50547),
      Some("subsumed by `.await` syntax"), 62293),
@@ -275,7 +275,7 @@ declare_features! (
     (removed, static_nobundle, "1.63.0", Some(37403),
      Some(r#"subsumed by `#[link(kind = "static", modifiers = "-bundle", ...)]`"#), 95818),
     /// Allows string patterns to dereference values to match them.
-    (removed, string_deref_patterns, "CURRENT_RUSTC_VERSION", Some(87121), Some("superseded by `deref_patterns`"), 150530),
+    (removed, string_deref_patterns, "1.94.0", Some(87121), Some("superseded by `deref_patterns`"), 150530),
     (removed, struct_inherit, "1.0.0", None, None),
     (removed, test_removed_feature, "1.0.0", None, None),
     /// Allows using items which are missing stability attributes

compiler/rustc_feature/src/unstable.rs

@@ -222,7 +222,7 @@ declare_features! (
     /// Allows writing custom MIR
     (internal, custom_mir, "1.65.0", None),
     /// Implementation details of externally implementable items
-    (internal, eii_internals, "CURRENT_RUSTC_VERSION", None),
+    (internal, eii_internals, "1.94.0", None),
     /// Outputs useful `assert!` messages
     (unstable, generic_assert, "1.63.0", None),
     /// Allows using the #[rustc_intrinsic] attribute.
@@ -477,7 +477,7 @@ declare_features! (
     /// Allows using `#[export_stable]` which indicates that an item is exportable.
     (incomplete, export_stable, "1.88.0", Some(139939)),
     /// Externally implementable items
-    (unstable, extern_item_impls, "CURRENT_RUSTC_VERSION", Some(125418)),
+    (unstable, extern_item_impls, "1.94.0", Some(125418)),
     /// Allows defining `extern type`s.
     (unstable, extern_types, "1.23.0", Some(43467)),
     /// Allow using 128-bit (quad precision) floating point numbers.
@@ -667,7 +667,7 @@ declare_features! (
     /// Allows using `try {...}` expressions.
     (unstable, try_blocks, "1.29.0", Some(31436)),
     /// Allows using `try bikeshed TargetType {...}` expressions.
-    (unstable, try_blocks_heterogeneous, "CURRENT_RUSTC_VERSION", Some(149488)),
+    (unstable, try_blocks_heterogeneous, "1.94.0", Some(149488)),
     /// Allows `impl Trait` to be used inside type aliases (RFC 2515).
     (unstable, type_alias_impl_trait, "1.38.0", Some(63063)),
     /// Allows creation of instances of a struct by moving fields that have

compiler/rustc_fluent_macro/src/fluent.rs

@@ -8,10 +8,7 @@ use fluent_syntax::ast::{
     Attribute, Entry, Expression, Identifier, InlineExpression, Message, Pattern, PatternElement,
 };
 use fluent_syntax::parser::ParserError;
-#[cfg(not(bootstrap))]
 use proc_macro::tracked::path;
-#[cfg(bootstrap)]
-use proc_macro::tracked_path::path;
 use proc_macro::{Diagnostic, Level, Span};
 use proc_macro2::TokenStream;
 use quote::quote;

compiler/rustc_fluent_macro/src/lib.rs

@@ -1,8 +1,7 @@
 // tidy-alphabetical-start
 #![allow(rustc::default_hash_types)]
-#![cfg_attr(bootstrap, feature(track_path))]
-#![cfg_attr(not(bootstrap), feature(proc_macro_tracked_path))]
 #![feature(proc_macro_diagnostic)]
+#![feature(proc_macro_tracked_path)]
 // tidy-alphabetical-end
 
 use proc_macro::TokenStream;