Rollup of 5 pull requests

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -184,3 +184,39 @@ impl<S: Stage> SingleAttributeParser<S> for WindowsSubsystemParser {
         Some(AttributeKind::WindowsSubsystem(kind, cx.attr_span))
     }
 }
+
+pub(crate) struct PanicRuntimeParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for PanicRuntimeParser {
+    const PATH: &[Symbol] = &[sym::panic_runtime];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::PanicRuntime;
+}
+
+pub(crate) struct NeedsPanicRuntimeParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for NeedsPanicRuntimeParser {
+    const PATH: &[Symbol] = &[sym::needs_panic_runtime];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::NeedsPanicRuntime;
+}
+
+pub(crate) struct ProfilerRuntimeParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for ProfilerRuntimeParser {
+    const PATH: &[Symbol] = &[sym::profiler_runtime];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::ProfilerRuntime;
+}
+
+pub(crate) struct NoBuiltinsParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for NoBuiltinsParser {
+    const PATH: &[Symbol] = &[sym::no_builtins];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::NoBuiltins;
+}

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -665,3 +665,12 @@ impl<S: Stage> NoArgsAttributeParser<S> for NeedsAllocatorParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::NeedsAllocator;
 }
+
+pub(crate) struct CompilerBuiltinsParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for CompilerBuiltinsParser {
+    const PATH: &[Symbol] = &[sym::compiler_builtins];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::CompilerBuiltins;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -28,9 +28,10 @@ use crate::attributes::codegen_attrs::{
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
-    CrateNameParser, MoveSizeLimitParser, NoCoreParser, NoMainParser, NoStdParser,
-    PatternComplexityLimitParser, RecursionLimitParser, RustcCoherenceIsCoreParser,
-    TypeLengthLimitParser, WindowsSubsystemParser,
+    CrateNameParser, MoveSizeLimitParser, NeedsPanicRuntimeParser, NoBuiltinsParser, NoCoreParser,
+    NoMainParser, NoStdParser, PanicRuntimeParser, PatternComplexityLimitParser,
+    ProfilerRuntimeParser, RecursionLimitParser, RustcCoherenceIsCoreParser, TypeLengthLimitParser,
+    WindowsSubsystemParser,
 };
 use crate::attributes::debugger::DebuggerViualizerParser;
 use crate::attributes::deprecation::DeprecationParser;
@@ -40,8 +41,9 @@ use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
 use crate::attributes::instruction_set::InstructionSetParser;
 use crate::attributes::link_attrs::{
-    ExportStableParser, FfiConstParser, FfiPureParser, LinkNameParser, LinkOrdinalParser,
-    LinkParser, LinkSectionParser, LinkageParser, NeedsAllocatorParser, StdInternalSymbolParser,
+    CompilerBuiltinsParser, ExportStableParser, FfiConstParser, FfiPureParser, LinkNameParser,
+    LinkOrdinalParser, LinkParser, LinkSectionParser, LinkageParser, NeedsAllocatorParser,
+    StdInternalSymbolParser,
 };
 use crate::attributes::lint_helpers::{
     AsPtrParser, AutomaticallyDerivedParser, PassByValueParser, PubTransparentParser,
@@ -251,6 +253,7 @@ attribute_parsers!(
         Single<WithoutArgs<AutomaticallyDerivedParser>>,
         Single<WithoutArgs<CoinductiveParser>>,
         Single<WithoutArgs<ColdParser>>,
+        Single<WithoutArgs<CompilerBuiltinsParser>>,
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<CoroutineParser>>,
@@ -266,19 +269,23 @@ attribute_parsers!(
         Single<WithoutArgs<MarkerParser>>,
         Single<WithoutArgs<MayDangleParser>>,
         Single<WithoutArgs<NeedsAllocatorParser>>,
+        Single<WithoutArgs<NeedsPanicRuntimeParser>>,
+        Single<WithoutArgs<NoBuiltinsParser>>,
         Single<WithoutArgs<NoCoreParser>>,
         Single<WithoutArgs<NoImplicitPreludeParser>>,
         Single<WithoutArgs<NoLinkParser>>,
         Single<WithoutArgs<NoMainParser>>,
         Single<WithoutArgs<NoMangleParser>>,
         Single<WithoutArgs<NoStdParser>>,
         Single<WithoutArgs<NonExhaustiveParser>>,
+        Single<WithoutArgs<PanicRuntimeParser>>,
         Single<WithoutArgs<ParenSugarParser>>,
         Single<WithoutArgs<PassByValueParser>>,
         Single<WithoutArgs<PinV2Parser>>,
         Single<WithoutArgs<PointeeParser>>,
         Single<WithoutArgs<ProcMacroAttributeParser>>,
         Single<WithoutArgs<ProcMacroParser>>,
+        Single<WithoutArgs<ProfilerRuntimeParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<RustcAllocatorParser>>,
         Single<WithoutArgs<RustcAllocatorZeroedParser>>,

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -6,7 +6,6 @@ use std::sync::mpsc::{Receiver, Sender, channel};
 use std::{fs, io, mem, str, thread};
 
 use rustc_abi::Size;
-use rustc_ast::attr;
 use rustc_data_structures::assert_matches;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::jobserver::{self, Acquired};
@@ -19,6 +18,8 @@ use rustc_errors::{
     Level, MultiSpan, Style, Suggestions, catch_fatal_errors,
 };
 use rustc_fs_util::link_or_copy;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::find_attr;
 use rustc_incremental::{
     copy_cgu_workproduct_to_incr_comp_cache_dir, in_incr_comp_dir, in_incr_comp_dir_sess,
 };
@@ -31,7 +32,7 @@ use rustc_session::config::{
     self, CrateType, Lto, OutFileName, OutputFilenames, OutputType, Passes, SwitchWithOptPath,
 };
 use rustc_span::source_map::SourceMap;
-use rustc_span::{FileName, InnerSpan, Span, SpanData, sym};
+use rustc_span::{FileName, InnerSpan, Span, SpanData};
 use rustc_target::spec::{MergeFunctions, SanitizerSet};
 use tracing::debug;
 
@@ -453,7 +454,7 @@ pub(crate) fn start_async_codegen<B: ExtraBackendMethods>(
     let (coordinator_send, coordinator_receive) = channel();
 
     let crate_attrs = tcx.hir_attrs(rustc_hir::CRATE_HIR_ID);
-    let no_builtins = attr::contains_name(crate_attrs, sym::no_builtins);
+    let no_builtins = find_attr!(crate_attrs, AttributeKind::NoBuiltins);
 
     let crate_info = CrateInfo::new(tcx, target_cpu);
 

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use rustc_abi::{Align, ExternAbi};
 use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
-use rustc_ast::{LitKind, MetaItem, MetaItemInner, attr};
+use rustc_ast::{LitKind, MetaItem, MetaItemInner};
 use rustc_hir::attrs::{
     AttributeKind, EiiImplResolution, InlineAttr, Linkage, RtsanSetting, UsedBy,
 };
@@ -353,7 +353,7 @@ fn apply_overrides(tcx: TyCtxt<'_>, did: LocalDefId, codegen_fn_attrs: &mut Code
     // When `no_builtins` is applied at the crate level, we should add the
     // `no-builtins` attribute to each function to ensure it takes effect in LTO.
     let crate_attrs = tcx.hir_attrs(rustc_hir::CRATE_HIR_ID);
-    let no_builtins = attr::contains_name(crate_attrs, sym::no_builtins);
+    let no_builtins = find_attr!(crate_attrs, AttributeKind::NoBuiltins);
     if no_builtins {
         codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_BUILTINS;
     }

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -687,6 +687,9 @@ pub enum AttributeKind {
     /// Represents `#[collapse_debuginfo]`.
     CollapseDebugInfo(CollapseMacroDebuginfo),
 
+    /// Represents `#[compiler_builtins]`.
+    CompilerBuiltins,
+
     /// Represents `#[rustc_confusables]`.
     Confusables {
         symbols: ThinVec<Symbol>,
@@ -843,6 +846,12 @@ pub enum AttributeKind {
     /// Represents `#[needs_allocator]`
     NeedsAllocator,
 
+    /// Represents `#[needs_panic_runtime]`
+    NeedsPanicRuntime,
+
+    /// Represents `#[no_builtins]`
+    NoBuiltins,
+
     /// Represents `#[no_core]`
     NoCore(Span),
 
@@ -873,6 +882,9 @@ pub enum AttributeKind {
     /// Represents `#[optimize(size|speed)]`
     Optimize(OptimizeAttr, Span),
 
+    /// Represents `#[panic_runtime]`
+    PanicRuntime,
+
     /// Represents `#[rustc_paren_sugar]`.
     ParenSugar(Span),
 
@@ -903,6 +915,9 @@ pub enum AttributeKind {
     /// Represents `#[proc_macro_derive]`
     ProcMacroDerive { trait_name: Symbol, helper_attrs: ThinVec<Symbol>, span: Span },
 
+    /// Represents `#[profiler_runtime]`
+    ProfilerRuntime,
+
     /// Represents `#[rustc_pub_transparent]` (used by the `repr_transparent_external_private_fields` lint).
     PubTransparent(Span),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -32,6 +32,7 @@ impl AttributeKind {
             Coinductive(..) => No,
             Cold(..) => No,
             CollapseDebugInfo(..) => Yes,
+            CompilerBuiltins => No,
             Confusables { .. } => Yes,
             ConstContinue(..) => No,
             ConstStability { .. } => Yes,
@@ -76,6 +77,8 @@ impl AttributeKind {
             MustUse { .. } => Yes,
             Naked(..) => No,
             NeedsAllocator => No,
+            NeedsPanicRuntime => No,
+            NoBuiltins => Yes,
             NoCore(..) => No,
             NoImplicitPrelude(..) => No,
             NoLink => No,
@@ -86,6 +89,7 @@ impl AttributeKind {
             ObjcClass { .. } => No,
             ObjcSelector { .. } => No,
             Optimize(..) => No,
+            PanicRuntime => No,
             ParenSugar(..) => No,
             PassByValue(..) => Yes,
             PatchableFunctionEntry { .. } => Yes,
@@ -96,6 +100,7 @@ impl AttributeKind {
             ProcMacro(..) => No,
             ProcMacroAttribute(..) => No,
             ProcMacroDerive { .. } => No,
+            ProfilerRuntime => No,
             PubTransparent(..) => Yes,
             RecursionLimit { .. } => No,
             Repr { .. } => No,

compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs

@@ -627,13 +627,10 @@ pub(crate) fn prohibit_explicit_late_bound_lifetimes(
     position: GenericArgPosition,
 ) -> ExplicitLateBound {
     let param_counts = def.own_counts();
-    let infer_lifetimes = position != GenericArgPosition::Type && !args.has_lifetime_params();
 
-    if infer_lifetimes {
-        return ExplicitLateBound::No;
-    }
-
-    if let Some(span_late) = def.has_late_bound_regions {
+    if let Some(span_late) = def.has_late_bound_regions
+        && args.has_lifetime_params()
+    {
         let msg = "cannot specify lifetime arguments explicitly \
                        if late bound lifetime parameters are present";
         let note = "the late bound lifetime parameter is introduced here";

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -741,12 +741,12 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 externally_implementable_items,
                 proc_macro_data,
                 debugger_visualizers,
-                compiler_builtins: ast::attr::contains_name(attrs, sym::compiler_builtins),
+                compiler_builtins: find_attr!(attrs, AttributeKind::CompilerBuiltins),
                 needs_allocator: find_attr!(attrs, AttributeKind::NeedsAllocator),
-                needs_panic_runtime: ast::attr::contains_name(attrs, sym::needs_panic_runtime),
-                no_builtins: ast::attr::contains_name(attrs, sym::no_builtins),
-                panic_runtime: ast::attr::contains_name(attrs, sym::panic_runtime),
-                profiler_runtime: ast::attr::contains_name(attrs, sym::profiler_runtime),
+                needs_panic_runtime: find_attr!(attrs, AttributeKind::NeedsPanicRuntime),
+                no_builtins: find_attr!(attrs, AttributeKind::NoBuiltins),
+                panic_runtime: find_attr!(attrs, AttributeKind::PanicRuntime),
+                profiler_runtime: find_attr!(attrs, AttributeKind::ProfilerRuntime),
                 symbol_mangling_version: tcx.sess.opts.get_symbol_mangling_version(),
 
                 crate_deps,

compiler/rustc_middle/src/ty/context.rs

@@ -38,7 +38,7 @@ use rustc_hir::definitions::{DefPathData, Definitions, DisambiguatorState};
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::limit::Limit;
-use rustc_hir::{self as hir, Attribute, HirId, Node, TraitCandidate, find_attr};
+use rustc_hir::{self as hir, HirId, Node, TraitCandidate, find_attr};
 use rustc_index::IndexVec;
 use rustc_query_system::cache::WithDepNode;
 use rustc_query_system::dep_graph::DepNodeIndex;
@@ -49,7 +49,7 @@ use rustc_session::config::CrateType;
 use rustc_session::cstore::{CrateStoreDyn, Untracked};
 use rustc_session::lint::Lint;
 use rustc_span::def_id::{CRATE_DEF_ID, DefPathHash, StableCrateId};
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw};
 use rustc_type_ir::TyKind::*;
 use rustc_type_ir::lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem};
 pub use rustc_type_ir::lift::Lift;
@@ -3560,16 +3560,12 @@ impl<'tcx> TyCtxt<'tcx> {
 
 pub fn provide(providers: &mut Providers) {
     providers.is_panic_runtime =
-        |tcx, LocalCrate| contains_name(tcx.hir_krate_attrs(), sym::panic_runtime);
+        |tcx, LocalCrate| find_attr!(tcx.hir_krate_attrs(), AttributeKind::PanicRuntime);
     providers.is_compiler_builtins =
-        |tcx, LocalCrate| contains_name(tcx.hir_krate_attrs(), sym::compiler_builtins);
+        |tcx, LocalCrate| find_attr!(tcx.hir_krate_attrs(), AttributeKind::CompilerBuiltins);
     providers.has_panic_handler = |tcx, LocalCrate| {
         // We want to check if the panic handler was defined in this crate
         tcx.lang_items().panic_impl().is_some_and(|did| did.is_local())
     };
     providers.source_span = |tcx, def_id| tcx.untracked.source_span.get(def_id).unwrap_or(DUMMY_SP);
 }
-
-pub fn contains_name(attrs: &[Attribute], name: Symbol) -> bool {
-    attrs.iter().any(|x| x.has_name(name))
-}

compiler/rustc_passes/src/check_attr.rs

@@ -299,6 +299,11 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::NoCore { .. }
                     | AttributeKind::NoStd { .. }
                     | AttributeKind::NoMain
+                    | AttributeKind::CompilerBuiltins
+                    | AttributeKind::PanicRuntime
+                    | AttributeKind::NeedsPanicRuntime
+                    | AttributeKind::ProfilerRuntime
+                    | AttributeKind::NoBuiltins
                     | AttributeKind::ObjcClass { .. }
                     | AttributeKind::ObjcSelector { .. }
                     | AttributeKind::RustcCoherenceIsCore(..)
@@ -397,13 +402,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::rustc_no_implicit_bounds
                             | sym::test_runner
                             | sym::reexport_test_harness_main
-                            | sym::no_main
-                            | sym::no_builtins
                             | sym::crate_type
-                            | sym::compiler_builtins
-                            | sym::profiler_runtime
-                            | sym::needs_panic_runtime
-                            | sym::panic_runtime
                             | sym::rustc_preserve_ub_checks,
                             ..
                         ] => {}

library/std/src/sys/os_str/bytes.rs

@@ -4,8 +4,8 @@
 use core::clone::CloneToUninit;
 
 use crate::borrow::Cow;
+use crate::bstr::ByteStr;
 use crate::collections::TryReserveError;
-use crate::fmt::Write;
 use crate::rc::Rc;
 use crate::sync::Arc;
 use crate::sys::{AsInner, FromInner, IntoInner};
@@ -64,25 +64,7 @@ impl fmt::Debug for Slice {
 
 impl fmt::Display for Slice {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // If we're the empty string then our iterator won't actually yield
-        // anything, so perform the formatting manually
-        if self.inner.is_empty() {
-            return "".fmt(f);
-        }
-
-        for chunk in self.inner.utf8_chunks() {
-            let valid = chunk.valid();
-            // If we successfully decoded the whole chunk as a valid string then
-            // we can return a direct formatting of the string which will also
-            // respect various formatting flags if possible.
-            if chunk.invalid().is_empty() {
-                return valid.fmt(f);
-            }
-
-            f.write_str(valid)?;
-            f.write_char(char::REPLACEMENT_CHARACTER)?;
-        }
-        Ok(())
+        fmt::Display::fmt(ByteStr::new(&self.inner), f)
     }
 }
 

src/bootstrap/src/core/build_steps/dist.rs

@@ -30,7 +30,7 @@ use crate::core::build_steps::tool::{
 use crate::core::build_steps::vendor::{VENDOR_DIR, Vendor};
 use crate::core::build_steps::{compile, llvm};
 use crate::core::builder::{Builder, Kind, RunConfig, ShouldRun, Step, StepMetadata};
-use crate::core::config::TargetSelection;
+use crate::core::config::{GccCiMode, TargetSelection};
 use crate::utils::build_stamp::{self, BuildStamp};
 use crate::utils::channel::{self, Info};
 use crate::utils::exec::{BootstrapCommand, command};
@@ -3084,6 +3084,14 @@ impl Step for Gcc {
             return None;
         }
 
+        if builder.config.is_running_on_ci {
+            assert_eq!(
+                builder.config.gcc_ci_mode,
+                GccCiMode::BuildLocally,
+                "Cannot use gcc.download-ci-gcc when distributing GCC on CI"
+            );
+        }
+
         // We need the GCC sources to build GCC and also to add its license and README
         // files to the tarball
         builder.require_submodule(