Auto merge of #150923 - matthiaskrgr:rollup-6NslXw7, r=matthiaskrgr

Rollup of 11 pull requests

Successful merges:

 - #148196 (Implement create_dir_all() to operate iteratively instead of recursively)
 - #150494 ( Fix dso_local for external statics with linkage)
 - #150788 (THIR patterns: Replace `AscribeUserType` and `ExpandedConstant` wrappers with per-node data)
 - #150799 (Fix ICE: can't type-check body of DefId  for issue #148729)
 - #150804 (Remove std_detect_file_io and std_detect_dlsym_getauxval features)
 - #150852 (std: sys: fs: uefi: Implement File::write)
 - #150871 (Use f64 NaN in documentation instead of sqrt(-1.0))
 - #150878 (Emit an error for linking staticlibs on BPF)
 - #150911 (Add missing documentation for globs feature)
 - #150913 (compiler: Forward attributes to eii-expanded macros)
 - #150916 (Once again, reorganize the EII tests a bit)

r? @ghost

Author: rust-bors[bot]

compiler/rustc_builtin_macros/src/eii.rs

@@ -133,6 +133,7 @@ fn eii_(
         macro_name,
         foreign_item_name,
         impl_unsafe,
+        &attrs_from_decl,
     )));
 
     return_items.into_iter().map(wrap_item).collect()
@@ -416,9 +417,14 @@ fn generate_attribute_macro_to_implement(
     macro_name: Ident,
     foreign_item_name: Ident,
     impl_unsafe: bool,
+    attrs_from_decl: &[Attribute],
 ) -> ast::Item {
     let mut macro_attrs = ThinVec::new();
 
+    // To avoid e.g. `error: attribute macro has missing stability attribute`
+    // errors for eii's in std.
+    macro_attrs.extend_from_slice(attrs_from_decl);
+
     // #[builtin_macro(eii_shared_macro)]
     macro_attrs.push(ecx.attr_nested_word(sym::rustc_builtin_macro, sym::eii_shared_macro, span));
 

compiler/rustc_codegen_llvm/src/consts.rs

@@ -187,6 +187,10 @@ fn check_and_apply_linkage<'ll, 'tcx>(
         };
         llvm::set_linkage(g1, base::linkage_to_llvm(linkage));
 
+        // Normally this is done in `get_static_inner`, but when as we generate an internal global,
+        // it will apply the dso_local to the internal global instead, so do it here, too.
+        cx.assume_dso_local(g1, true);
+
         // Declare an internal global `extern_with_linkage_foo` which
         // is initialized with the address of `foo`. If `foo` is
         // discarded during linking (for example, if `foo` has weak

compiler/rustc_codegen_ssa/messages.ftl

@@ -10,6 +10,8 @@ codegen_ssa_archive_build_failure = failed to build archive at `{$path}`: {$erro
 
 codegen_ssa_binary_output_to_tty = option `-o` or `--emit` is used to write binary output type `{$shorthand}` to stdout, but stdout is a tty
 
+codegen_ssa_bpf_staticlib_not_supported = linking static libraries is not supported for BPF
+
 codegen_ssa_cgu_not_recorded =
     CGU-reuse for `{$cgu_user_name}` is (mangled: `{$cgu_name}`) was not recorded
 

compiler/rustc_codegen_ssa/src/back/archive.rs

@@ -22,10 +22,11 @@ use tracing::trace;
 
 use super::metadata::{create_compressed_metadata_file, search_for_section};
 use crate::common;
-// Re-exporting for rustc_codegen_llvm::back::archive
-pub use crate::errors::{ArchiveBuildFailure, ExtractBundledLibsError, UnknownArchiveKind};
+// Public for ArchiveBuilderBuilder::extract_bundled_libs
+pub use crate::errors::ExtractBundledLibsError;
 use crate::errors::{
-    DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary, ErrorWritingDEFFile,
+    ArchiveBuildFailure, DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary,
+    ErrorWritingDEFFile, UnknownArchiveKind,
 };
 
 /// An item to be included in an import library.

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -2075,7 +2075,7 @@ impl<'a> Linker for BpfLinker<'a> {
     }
 
     fn link_staticlib_by_name(&mut self, _name: &str, _verbatim: bool, _whole_archive: bool) {
-        panic!("staticlibs not supported")
+        self.sess.dcx().emit_fatal(errors::BpfStaticlibNotSupported)
     }
 
     fn link_staticlib_by_path(&mut self, path: &Path, _whole_archive: bool) {

compiler/rustc_codegen_ssa/src/errors.rs

@@ -661,7 +661,7 @@ pub(crate) struct RlibArchiveBuildFailure {
 }
 
 #[derive(Diagnostic)]
-// Public for rustc_codegen_llvm::back::archive
+// Public for ArchiveBuilderBuilder::extract_bundled_libs
 pub enum ExtractBundledLibsError<'a> {
     #[diag(codegen_ssa_extract_bundled_libs_open_file)]
     OpenFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
@@ -700,19 +700,21 @@ pub(crate) struct UnsupportedLinkSelfContained;
 
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_archive_build_failure)]
-// Public for rustc_codegen_llvm::back::archive
-pub struct ArchiveBuildFailure {
+pub(crate) struct ArchiveBuildFailure {
     pub path: PathBuf,
     pub error: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_unknown_archive_kind)]
-// Public for rustc_codegen_llvm::back::archive
-pub struct UnknownArchiveKind<'a> {
+pub(crate) struct UnknownArchiveKind<'a> {
     pub kind: &'a str,
 }
 
+#[derive(Diagnostic)]
+#[diag(codegen_ssa_bpf_staticlib_not_supported)]
+pub(crate) struct BpfStaticlibNotSupported;
+
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_multiple_main_functions)]
 #[help]

compiler/rustc_const_eval/src/check_consts/qualifs.rs

@@ -6,9 +6,7 @@
 // having basically only two use-cases that act in different ways.
 
 use rustc_errors::ErrorGuaranteed;
-use rustc_hir::attrs::AttributeKind;
-use rustc_hir::def::DefKind;
-use rustc_hir::{LangItem, find_attr};
+use rustc_hir::LangItem;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, AdtDef, Ty};
@@ -366,14 +364,10 @@ where
         // check performed after the promotion. Verify that with an assertion.
         assert!(promoted.is_none() || Q::ALLOW_PROMOTED);
 
-        // Avoid looking at attrs of anon consts as that will ICE
-        let is_type_const_item =
-            matches!(cx.tcx.def_kind(def), DefKind::Const | DefKind::AssocConst)
-                && find_attr!(cx.tcx.get_all_attrs(def), AttributeKind::TypeConst(_));
-
         // Don't peak inside trait associated constants, also `#[type_const] const` items
         // don't have bodies so there's nothing to look at
-        if promoted.is_none() && cx.tcx.trait_of_assoc(def).is_none() && !is_type_const_item {
+        if promoted.is_none() && cx.tcx.trait_of_assoc(def).is_none() && !cx.tcx.is_type_const(def)
+        {
             let qualifs = cx.tcx.at(constant.span).mir_const_qualif(def);
 
             if !Q::in_qualifs(&qualifs) {

compiler/rustc_feature/src/accepted.rs

@@ -235,7 +235,7 @@ declare_features! (
     (accepted, generic_param_attrs, "1.27.0", Some(48848)),
     /// Allows the `#[global_allocator]` attribute.
     (accepted, global_allocator, "1.28.0", Some(27389)),
-    // FIXME: explain `globs`.
+    /// Allows globs imports (`use module::*;`) to import all public items from a module.
     (accepted, globs, "1.0.0", None),
     /// Allows using `..=X` as a pattern.
     (accepted, half_open_range_patterns, "1.66.0", Some(67264)),

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -420,7 +420,22 @@ fn infer_placeholder_type<'tcx>(
     kind: &'static str,
 ) -> Ty<'tcx> {
     let tcx = cx.tcx();
-    let ty = tcx.typeck(def_id).node_type(hir_id);
+    // If the type is omitted on a #[type_const] we can't run
+    // type check on since that requires the const have a body
+    // which type_consts don't.
+    let ty = if tcx.is_type_const(def_id.to_def_id()) {
+        if let Some(trait_item_def_id) = tcx.trait_item_of(def_id.to_def_id()) {
+            tcx.type_of(trait_item_def_id).instantiate_identity()
+        } else {
+            Ty::new_error_with_message(
+                tcx,
+                ty_span,
+                "constant with #[type_const] requires an explicit type",
+            )
+        }
+    } else {
+        tcx.typeck(def_id).node_type(hir_id)
+    };
 
     // If this came from a free `const` or `static mut?` item,
     // then the user may have written e.g. `const A = 42;`.

compiler/rustc_middle/src/thir.rs

@@ -643,10 +643,26 @@ pub struct FieldPat<'tcx> {
     pub pattern: Pat<'tcx>,
 }
 
+/// Additional per-node data that is not present on most THIR pattern nodes.
+#[derive(Clone, Debug, Default, HashStable, TypeVisitable)]
+pub struct PatExtra<'tcx> {
+    /// If present, this node represents a named constant that was lowered to
+    /// a pattern using `const_to_pat`.
+    ///
+    /// This is used by some diagnostics for non-exhaustive matches, to map
+    /// the pattern node back to the `DefId` of its original constant.
+    pub expanded_const: Option<DefId>,
+
+    /// User-written types that must be preserved into MIR so that they can be
+    /// checked.
+    pub ascriptions: Vec<Ascription<'tcx>>,
+}
+
 #[derive(Clone, Debug, HashStable, TypeVisitable)]
 pub struct Pat<'tcx> {
     pub ty: Ty<'tcx>,
     pub span: Span,
+    pub extra: Option<Box<PatExtra<'tcx>>>,
     pub kind: PatKind<'tcx>,
 }
 
@@ -762,11 +778,6 @@ pub enum PatKind<'tcx> {
     /// A wildcard pattern: `_`.
     Wild,
 
-    AscribeUserType {
-        ascription: Ascription<'tcx>,
-        subpattern: Box<Pat<'tcx>>,
-    },
-
     /// `x`, `ref x`, `x @ P`, etc.
     Binding {
         name: Symbol,
@@ -831,21 +842,6 @@ pub enum PatKind<'tcx> {
         value: ty::Value<'tcx>,
     },
 
-    /// Wrapper node representing a named constant that was lowered to a pattern
-    /// using `const_to_pat`.
-    ///
-    /// This is used by some diagnostics for non-exhaustive matches, to map
-    /// the pattern node back to the `DefId` of its original constant.
-    ///
-    /// FIXME(#150498): Can we make this an `Option<DefId>` field on `Pat`
-    /// instead, so that non-diagnostic code can ignore it more easily?
-    ExpandedConstant {
-        /// [DefId] of the constant item.
-        def_id: DefId,
-        /// The pattern that the constant lowered to.
-        subpattern: Box<Pat<'tcx>>,
-    },
-
     Range(Arc<PatRange<'tcx>>),
 
     /// Matches against a slice, checking the length and extracting elements.
@@ -1119,7 +1115,7 @@ mod size_asserts {
     static_assert_size!(Block, 48);
     static_assert_size!(Expr<'_>, 64);
     static_assert_size!(ExprKind<'_>, 40);
-    static_assert_size!(Pat<'_>, 64);
+    static_assert_size!(Pat<'_>, 72);
     static_assert_size!(PatKind<'_>, 48);
     static_assert_size!(Stmt<'_>, 48);
     static_assert_size!(StmtKind<'_>, 48);