Rollup of 11 pull requests

compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs

@@ -11,7 +11,6 @@ use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::symbol::{sym, Ident};
 use rustc_span::{Span, Symbol};
-use smallvec::{smallvec, SmallVec};
 use thin_vec::{thin_vec, ThinVec};
 
 macro_rules! path {
@@ -68,43 +67,63 @@ pub(crate) fn expand_deriving_smart_ptr(
  };
 
  // Convert generic parameters (from the struct) into generic args.
- let mut pointee_param = None;
- let mut multiple_pointee_diag: SmallVec<[_; 2]> = smallvec![];
- let self_params = generics
+ let self_params: Vec<_> = generics
  .params
  .iter()
- .enumerate()
- .map(|(idx, p)| match p.kind {
+ .map(|p| match p.kind {
  GenericParamKind::Lifetime => GenericArg::Lifetime(cx.lifetime(p.span(), p.ident)),
- GenericParamKind::Type { .. } => {
- if p.attrs().iter().any(|attr| attr.has_name(sym::pointee)) {
- if pointee_param.is_some() {
- multiple_pointee_diag.push(cx.dcx().struct_span_err(
- p.span(),
- "`SmartPointer` can only admit one type as pointee",
- ));
- } else {
- pointee_param = Some(idx);
- }
- }
- GenericArg::Type(cx.ty_ident(p.span(), p.ident))
- }
+ GenericParamKind::Type { .. } => GenericArg::Type(cx.ty_ident(p.span(), p.ident)),
  GenericParamKind::Const { .. } => GenericArg::Const(cx.const_ident(p.span(), p.ident)),
  })
- .collect::<Vec<_>>();
- let Some(pointee_param_idx) = pointee_param else {
+ .collect();
+ let type_params: Vec<_> = generics
+ .params
+ .iter()
+ .enumerate()
+ .filter_map(|(idx, p)| {
+ if let GenericParamKind::Type { .. } = p.kind {
+ Some((idx, p.span(), p.attrs().iter().any(|attr| attr.has_name(sym::pointee))))
+ } else {
+ None
+ }
+ })
+ .collect();
+
+ let pointee_param_idx = if type_params.is_empty() {
+ // `#[derive(SmartPointer)]` requires at least one generic type on the target `struct`
  cx.dcx().struct_span_err(
  span,
- "At least one generic type should be designated as `#[pointee]` in order to derive `SmartPointer` traits",
+ "`SmartPointer` can only be derived on `struct`s that are generic over at least one type",
  ).emit();
  return;
- };
- if !multiple_pointee_diag.is_empty() {
- for diag in multiple_pointee_diag {
- diag.emit();
+ } else if type_params.len() == 1 {
+ // Regardless of the only type param being designed as `#[pointee]` or not, we can just use it as such
+ type_params[0].0
+ } else {
+ let mut pointees = type_params
+ .iter()
+ .filter_map(|&(idx, span, is_pointee)| is_pointee.then_some((idx, span)))
+ .fuse();
+ match (pointees.next(), pointees.next()) {
+ (Some((idx, _span)), None) => idx,
+ (None, _) => {
+ cx.dcx().struct_span_err(
+ span,
+ "exactly one generic type parameter must be marked as #[pointee] to derive SmartPointer traits",
+ ).emit();
+ return;
+ }
+ (Some((_, one)), Some((_, another))) => {
+ cx.dcx()
+ .struct_span_err(
+ vec![one, another],
+ "only one type parameter can be marked as `#[pointee]` when deriving SmartPointer traits",
+ )
+ .emit();
+ return;
+ }
  }
- return;
- }
+ };
 
  // Create the type of `self`.
  let path = cx.path_all(span, false, vec![name_ident], self_params.clone());

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeSet;
 use std::ffi::OsString;
 use std::fs::{read, File, OpenOptions};
 use std::io::{BufWriter, Write};
-use std::ops::Deref;
+use std::ops::{ControlFlow, Deref};
 use std::path::{Path, PathBuf};
 use std::process::{ExitStatus, Output, Stdio};
 use std::{env, fmt, fs, io, mem, str};
@@ -18,8 +18,8 @@ use rustc_data_structures::temp_dir::MaybeTempDir;
 use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, FatalError};
 use rustc_fs_util::{fix_windows_verbatim_for_gcc, try_canonicalize};
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
-use rustc_metadata::find_native_static_library;
 use rustc_metadata::fs::{copy_to_stdout, emit_wrapper_file, METADATA_FILENAME};
+use rustc_metadata::{find_native_static_library, walk_native_lib_search_dirs};
 use rustc_middle::bug;
 use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::middle::dependency_format::Linkage;
@@ -2110,50 +2110,19 @@ fn add_library_search_dirs(
  return;
  }
 
- // Library search paths explicitly supplied by user (`-L` on the command line).
- for search_path in sess.target_filesearch(PathKind::Native).cli_search_paths() {
- cmd.include_path(&fix_windows_verbatim_for_gcc(&search_path.dir));
- }
- for search_path in sess.target_filesearch(PathKind::Framework).cli_search_paths() {
- // Contrary to the `-L` docs only framework-specific paths are considered here.
- if search_path.kind != PathKind::All {
- cmd.framework_path(&search_path.dir);
- }
- }
-
- // The toolchain ships some native library components and self-contained linking was enabled.
- // Add the self-contained library directory to search paths.
- if self_contained_components.intersects(
- LinkSelfContainedComponents::LIBC
- | LinkSelfContainedComponents::UNWIND
- | LinkSelfContainedComponents::MINGW,
- ) {
- let lib_path = sess.target_tlib_path.dir.join("self-contained");
- cmd.include_path(&fix_windows_verbatim_for_gcc(&lib_path));
- }
-
- // Toolchains for some targets may ship `libunwind.a`, but place it into the main sysroot
- // library directory instead of the self-contained directories.
- // Sanitizer libraries have the same issue and are also linked by name on Apple targets.
- // The targets here should be in sync with `copy_third_party_objects` in bootstrap.
- // FIXME: implement `-Clink-self-contained=+/-unwind,+/-sanitizers`, move the shipped libunwind
- // and sanitizers to self-contained directory, and stop adding this search path.
- if sess.target.vendor == "fortanix"
- || sess.target.os == "linux"
- || sess.target.os == "fuchsia"
- || sess.target.is_like_osx && !sess.opts.unstable_opts.sanitizer.is_empty()
- {
- cmd.include_path(&fix_windows_verbatim_for_gcc(&sess.target_tlib_path.dir));
- }
-
- // Mac Catalyst uses the macOS SDK, but to link to iOS-specific frameworks
- // we must have the support library stubs in the library search path (#121430).
- if let Some(sdk_root) = apple_sdk_root
- && sess.target.llvm_target.contains("macabi")
- {
- cmd.include_path(&sdk_root.join("System/iOSSupport/usr/lib"));
- cmd.framework_path(&sdk_root.join("System/iOSSupport/System/Library/Frameworks"));
- }
+ walk_native_lib_search_dirs(
+ sess,
+ self_contained_components,
+ apple_sdk_root,
+ |dir, is_framework| {
+ if is_framework {
+ cmd.framework_path(dir);
+ } else {
+ cmd.include_path(&fix_windows_verbatim_for_gcc(dir));
+ }
+ ControlFlow::<()>::Continue(())
+ },
+ );
 }
 
 /// Add options making relocation sections in the produced ELF files read-only

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -7,7 +7,7 @@ use std::{env, iter, mem, str};
 
 use cc::windows_registry;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
-use rustc_metadata::find_native_static_library;
+use rustc_metadata::{find_native_static_library, try_find_native_static_library};
 use rustc_middle::bug;
 use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::middle::exported_symbols;
@@ -891,9 +891,15 @@ impl<'a> Linker for MsvcLinker<'a> {
  }
 
  fn link_staticlib_by_name(&mut self, name: &str, verbatim: bool, whole_archive: bool) {
- let prefix = if whole_archive { "/WHOLEARCHIVE:" } else { "" };
- let suffix = if verbatim { "" } else { ".lib" };
- self.link_arg(format!("{prefix}{name}{suffix}"));
+ // On MSVC-like targets rustc supports static libraries using alternative naming
+ // scheme (`libfoo.a`) unsupported by linker, search for such libraries manually.
+ if let Some(path) = try_find_native_static_library(self.sess, name, verbatim) {
+ self.link_staticlib_by_path(&path, whole_archive);
+ } else {
+ let prefix = if whole_archive { "/WHOLEARCHIVE:" } else { "" };
+ let suffix = if verbatim { "" } else { ".lib" };
+ self.link_arg(format!("{prefix}{name}{suffix}"));
+ }
  }
 
  fn link_staticlib_by_path(&mut self, path: &Path, whole_archive: bool) {

compiler/rustc_lint/src/foreign_modules.rs

@@ -265,8 +265,6 @@ fn structurally_same_type_impl<'tcx>(
  } else {
  // Do a full, depth-first comparison between the two.
  use rustc_type_ir::TyKind::*;
- let a_kind = a.kind();
- let b_kind = b.kind();
 
  let compare_layouts = |a, b| -> Result<bool, &'tcx LayoutError<'tcx>> {
  debug!("compare_layouts({:?}, {:?})", a, b);
@@ -281,12 +279,11 @@ fn structurally_same_type_impl<'tcx>(
  Ok(a_layout == b_layout)
  };
 
- #[allow(rustc::usage_of_ty_tykind)]
  let is_primitive_or_pointer =
- |kind: &ty::TyKind<'_>| kind.is_primitive() || matches!(kind, RawPtr(..) | Ref(..));
+ |ty: Ty<'tcx>| ty.is_primitive() || matches!(ty.kind(), RawPtr(..) | Ref(..));
 
  ensure_sufficient_stack(|| {
- match (a_kind, b_kind) {
+ match (a.kind(), b.kind()) {
  (Adt(a_def, _), Adt(b_def, _)) => {
  // We can immediately rule out these types as structurally same if
  // their layouts differ.
@@ -382,17 +379,21 @@ fn structurally_same_type_impl<'tcx>(
 
  // An Adt and a primitive or pointer type. This can be FFI-safe if non-null
  // enum layout optimisation is being applied.
- (Adt(..), other_kind) | (other_kind, Adt(..))
- if is_primitive_or_pointer(other_kind) =>
- {
- let (primitive, adt) =
- if is_primitive_or_pointer(a.kind()) { (a, b) } else { (b, a) };
- if let Some(ty) = types::repr_nullable_ptr(tcx, param_env, adt, ckind) {
- ty == primitive
+ (Adt(..), _) if is_primitive_or_pointer(b) => {
+ if let Some(ty) = types::repr_nullable_ptr(tcx, param_env, a, ckind) {
+ ty == b
  } else {
  compare_layouts(a, b).unwrap_or(false)
  }
  }
+ (_, Adt(..)) if is_primitive_or_pointer(a) => {
+ if let Some(ty) = types::repr_nullable_ptr(tcx, param_env, b, ckind) {
+ ty == a
+ } else {
+ compare_layouts(a, b).unwrap_or(false)
+ }
+ }
+
  // Otherwise, just compare the layouts. This may fail to lint for some
  // incompatible types, but at the very least, will stop reads into
  // uninitialised memory.

compiler/rustc_metadata/src/lib.rs

@@ -3,6 +3,7 @@
 #![allow(rustc::potential_query_instability)]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
+#![feature(control_flow_enum)]
 #![feature(coroutines)]
 #![feature(decl_macro)]
 #![feature(error_iter)]
@@ -34,7 +35,9 @@ pub mod locator;
 
 pub use creader::{load_symbol_from_dylib, DylibError};
 pub use fs::{emit_wrapper_file, METADATA_FILENAME};
-pub use native_libs::find_native_static_library;
+pub use native_libs::{
+ find_native_static_library, try_find_native_static_library, walk_native_lib_search_dirs,
+};
 pub use rmeta::{encode_metadata, rendered_const, EncodedMetadata, METADATA_HEADER};
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }

compiler/rustc_metadata/src/native_libs.rs

@@ -1,4 +1,5 @@
-use std::path::PathBuf;
+use std::ops::ControlFlow;
+use std::path::{Path, PathBuf};
 
 use rustc_ast::{NestedMetaItem, CRATE_NODE_ID};
 use rustc_attr as attr;
@@ -16,10 +17,68 @@ use rustc_session::Session;
 use rustc_span::def_id::{DefId, LOCAL_CRATE};
 use rustc_span::symbol::{sym, Symbol};
 use rustc_target::spec::abi::Abi;
+use rustc_target::spec::LinkSelfContainedComponents;
 
 use crate::{errors, fluent_generated};
 
-pub fn find_native_static_library(name: &str, verbatim: bool, sess: &Session) -> PathBuf {
+pub fn walk_native_lib_search_dirs<R>(
+ sess: &Session,
+ self_contained_components: LinkSelfContainedComponents,
+ apple_sdk_root: Option<&Path>,
+ mut f: impl FnMut(&Path, bool /*is_framework*/) -> ControlFlow<R>,
+) -> ControlFlow<R> {
+ // Library search paths explicitly supplied by user (`-L` on the command line).
+ for search_path in sess.target_filesearch(PathKind::Native).cli_search_paths() {
+ f(&search_path.dir, false)?;
+ }
+ for search_path in sess.target_filesearch(PathKind::Framework).cli_search_paths() {
+ // Frameworks are looked up strictly in framework-specific paths.
+ if search_path.kind != PathKind::All {
+ f(&search_path.dir, true)?;
+ }
+ }
+
+ // The toolchain ships some native library components and self-contained linking was enabled.
+ // Add the self-contained library directory to search paths.
+ if self_contained_components.intersects(
+ LinkSelfContainedComponents::LIBC
+ | LinkSelfContainedComponents::UNWIND
+ | LinkSelfContainedComponents::MINGW,
+ ) {
+ f(&sess.target_tlib_path.dir.join("self-contained"), false)?;
+ }
+
+ // Toolchains for some targets may ship `libunwind.a`, but place it into the main sysroot
+ // library directory instead of the self-contained directories.
+ // Sanitizer libraries have the same issue and are also linked by name on Apple targets.
+ // The targets here should be in sync with `copy_third_party_objects` in bootstrap.
+ // FIXME: implement `-Clink-self-contained=+/-unwind,+/-sanitizers`, move the shipped libunwind
+ // and sanitizers to self-contained directory, and stop adding this search path.
+ if sess.target.vendor == "fortanix"
+ || sess.target.os == "linux"
+ || sess.target.os == "fuchsia"
+ || sess.target.is_like_osx && !sess.opts.unstable_opts.sanitizer.is_empty()
+ {
+ f(&sess.target_tlib_path.dir, false)?;
+ }
+
+ // Mac Catalyst uses the macOS SDK, but to link to iOS-specific frameworks
+ // we must have the support library stubs in the library search path (#121430).
+ if let Some(sdk_root) = apple_sdk_root
+ && sess.target.llvm_target.contains("macabi")
+ {
+ f(&sdk_root.join("System/iOSSupport/usr/lib"), false)?;
+ f(&sdk_root.join("System/iOSSupport/System/Library/Frameworks"), true)?;
+ }
+
+ ControlFlow::Continue(())
+}
+
+pub fn try_find_native_static_library(
+ sess: &Session,
+ name: &str,
+ verbatim: bool,
+) -> Option<PathBuf> {
  let formats = if verbatim {
  vec![("".into(), "".into())]
  } else {
@@ -30,16 +89,29 @@ pub fn find_native_static_library(name: &str, verbatim: bool, sess: &Session) ->
  if os == unix { vec![os] } else { vec![os, unix] }
  };
 
- for path in sess.target_filesearch(PathKind::Native).search_paths() {
- for (prefix, suffix) in &formats {
- let test = path.dir.join(format!("{prefix}{name}{suffix}"));
- if test.exists() {
- return test;
+ // FIXME: Account for self-contained linking settings and Apple SDK.
+ walk_native_lib_search_dirs(
+ sess,
+ LinkSelfContainedComponents::empty(),
+ None,
+ |dir, is_framework| {
+ if !is_framework {
+ for (prefix, suffix) in &formats {
+ let test = dir.join(format!("{prefix}{name}{suffix}"));
+ if test.exists() {
+ return ControlFlow::Break(test);
+ }
+ }
  }
- }
- }
+ ControlFlow::Continue(())
+ },
+ )
+ .break_value()
+}
 
- sess.dcx().emit_fatal(errors::MissingNativeLibrary::new(name, verbatim));
+pub fn find_native_static_library(name: &str, verbatim: bool, sess: &Session) -> PathBuf {
+ try_find_native_static_library(sess, name, verbatim)
+ .unwrap_or_else(|| sess.dcx().emit_fatal(errors::MissingNativeLibrary::new(name, verbatim)))
 }
 
 fn find_bundled_library(