Rollup of 11 pull requests

compiler/rustc_ast/src/ast.rs

@@ -2902,6 +2902,17 @@ pub struct AttrItem {
  pub tokens: Option<LazyAttrTokenStream>,
 }
 
+impl AttrItem {
+ pub fn is_valid_for_outer_style(&self) -> bool {
+ self.path == sym::cfg_attr
+ || self.path == sym::cfg
+ || self.path == sym::forbid
+ || self.path == sym::warn
+ || self.path == sym::allow
+ || self.path == sym::deny
+ }
+}
+
 /// `TraitRef`s appear in impls.
 ///
 /// Resolution maps each `TraitRef`'s `ref_id` to its defining trait; that's all

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1317,11 +1317,9 @@ fn link_sanitizer_runtime(
  name: &str,
 ) {
  fn find_sanitizer_runtime(sess: &Session, filename: &str) -> PathBuf {
- let session_tlib =
- filesearch::make_target_lib_path(&sess.sysroot, sess.opts.target_triple.triple());
- let path = session_tlib.join(filename);
+ let path = sess.target_tlib_path.dir.join(filename);
  if path.exists() {
- return session_tlib;
+ return sess.target_tlib_path.dir.clone();
  } else {
  let default_sysroot =
  filesearch::get_or_default_sysroot().expect("Failed finding sysroot");
@@ -1612,19 +1610,18 @@ fn print_native_static_libs(
 }
 
 fn get_object_file_path(sess: &Session, name: &str, self_contained: bool) -> PathBuf {
- let fs = sess.target_filesearch(PathKind::Native);
- let file_path = fs.get_lib_path().join(name);
+ let file_path = sess.target_tlib_path.dir.join(name);
  if file_path.exists() {
  return file_path;
  }
  // Special directory with objects used only in self-contained linkage mode
  if self_contained {
- let file_path = fs.get_self_contained_lib_path().join(name);
+ let file_path = sess.target_tlib_path.dir.join("self-contained").join(name);
  if file_path.exists() {
  return file_path;
  }
  }
- for search_path in fs.search_paths() {
+ for search_path in sess.target_filesearch(PathKind::Native).search_paths() {
  let file_path = search_path.dir.join(name);
  if file_path.exists() {
  return file_path;
@@ -2131,7 +2128,7 @@ fn add_library_search_dirs(
  | LinkSelfContainedComponents::UNWIND
  | LinkSelfContainedComponents::MINGW,
  ) {
- let lib_path = sess.target_filesearch(PathKind::Native).get_self_contained_lib_path();
+ let lib_path = sess.target_tlib_path.dir.join("self-contained");
  cmd.include_path(&fix_windows_verbatim_for_gcc(&lib_path));
  }
 
@@ -2146,8 +2143,7 @@ fn add_library_search_dirs(
  || sess.target.os == "fuchsia"
  || sess.target.is_like_osx && !sess.opts.unstable_opts.sanitizer.is_empty()
  {
- let lib_path = sess.target_filesearch(PathKind::Native).get_lib_path();
- cmd.include_path(&fix_windows_verbatim_for_gcc(&lib_path));
+ 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
@@ -2859,15 +2855,14 @@ fn add_upstream_native_libraries(
 //
 // The returned path will always have `fix_windows_verbatim_for_gcc()` applied to it.
 fn rehome_sysroot_lib_dir(sess: &Session, lib_dir: &Path) -> PathBuf {
- let sysroot_lib_path = sess.target_filesearch(PathKind::All).get_lib_path();
+ let sysroot_lib_path = &sess.target_tlib_path.dir;
  let canonical_sysroot_lib_path =
- { try_canonicalize(&sysroot_lib_path).unwrap_or_else(|_| sysroot_lib_path.clone()) };
+ { try_canonicalize(sysroot_lib_path).unwrap_or_else(|_| sysroot_lib_path.clone()) };
 
  let canonical_lib_dir = try_canonicalize(lib_dir).unwrap_or_else(|_| lib_dir.to_path_buf());
  if canonical_lib_dir == canonical_sysroot_lib_path {
- // This path, returned by `target_filesearch().get_lib_path()`, has
- // already had `fix_windows_verbatim_for_gcc()` applied if needed.
- sysroot_lib_path
+ // This path already had `fix_windows_verbatim_for_gcc()` applied if needed.
+ sysroot_lib_path.clone()
  } else {
  fix_windows_verbatim_for_gcc(lib_dir)
  }

compiler/rustc_hir_analysis/src/variance/dump.rs

@@ -1,18 +1,36 @@
+use std::fmt::Write;
+
 use rustc_hir::def::DefKind;
-use rustc_hir::def_id::CRATE_DEF_ID;
-use rustc_middle::ty::TyCtxt;
+use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID};
+use rustc_middle::ty::{GenericArgs, TyCtxt};
 use rustc_span::symbol::sym;
 
+fn format_variances(tcx: TyCtxt<'_>, def_id: LocalDefId) -> String {
+ let variances = tcx.variances_of(def_id);
+ let generics = GenericArgs::identity_for_item(tcx, def_id);
+ // 7 = 2-letter parameter + ": " + 1-letter variance + ", "
+ let mut ret = String::with_capacity(2 + 7 * variances.len());
+ ret.push('[');
+ for (arg, variance) in generics.iter().zip(variances.iter()) {
+ write!(ret, "{arg}: {variance:?}, ").unwrap();
+ }
+ // Remove trailing `, `.
+ if !variances.is_empty() {
+ ret.pop();
+ ret.pop();
+ }
+ ret.push(']');
+ ret
+}
+
 pub(crate) fn variances(tcx: TyCtxt<'_>) {
  if tcx.has_attr(CRATE_DEF_ID, sym::rustc_variance_of_opaques) {
  for id in tcx.hir().items() {
  let DefKind::OpaqueTy = tcx.def_kind(id.owner_id) else { continue };
 
- let variances = tcx.variances_of(id.owner_id);
-
  tcx.dcx().emit_err(crate::errors::VariancesOf {
  span: tcx.def_span(id.owner_id),
- variances: format!("{variances:?}"),
+ variances: format_variances(tcx, id.owner_id.def_id),
  });
  }
  }
@@ -22,11 +40,9 @@ pub(crate) fn variances(tcx: TyCtxt<'_>) {
  continue;
  }
 
- let variances = tcx.variances_of(id.owner_id);
-
  tcx.dcx().emit_err(crate::errors::VariancesOf {
  span: tcx.def_span(id.owner_id),
- variances: format!("{variances:?}"),
+ variances: format_variances(tcx, id.owner_id.def_id),
  });
  }
 }

compiler/rustc_hir_typeck/src/expr.rs

@@ -841,13 +841,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let ret_ty = ret_coercion.borrow().expected_ty();
  let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty);
  let mut span = return_expr.span;
+ let mut hir_id = return_expr.hir_id;
  // Use the span of the trailing expression for our cause,
  // not the span of the entire function
  if !explicit_return
  && let ExprKind::Block(body, _) = return_expr.kind
  && let Some(last_expr) = body.expr
  {
  span = last_expr.span;
+ hir_id = last_expr.hir_id;
  }
  ret_coercion.borrow_mut().coerce(
  self,
@@ -864,6 +866,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  self.select_obligations_where_possible(|errors| {
  self.point_at_return_for_opaque_ty_error(
  errors,
+ hir_id,
  span,
  return_expr_ty,
  return_expr.span,
@@ -921,6 +924,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  fn point_at_return_for_opaque_ty_error(
  &self,
  errors: &mut Vec<traits::FulfillmentError<'tcx>>,
+ hir_id: HirId,
  span: Span,
  return_expr_ty: Ty<'tcx>,
  return_span: Span,
@@ -935,7 +939,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let new_cause = ObligationCause::new(
  cause.span,
  cause.body_id,
- ObligationCauseCode::OpaqueReturnType(Some((return_expr_ty, span))),
+ ObligationCauseCode::OpaqueReturnType(Some((return_expr_ty, hir_id))),
  );
  *cause = new_cause;
  }

compiler/rustc_lint/messages.ftl

@@ -361,6 +361,11 @@ lint_improper_ctypes_box = box cannot be represented as a single pointer
 lint_improper_ctypes_char_help = consider using `u32` or `libc::wchar_t` instead
 
 lint_improper_ctypes_char_reason = the `char` type has no C equivalent
+
+lint_improper_ctypes_cstr_help =
+ consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+lint_improper_ctypes_cstr_reason = `CStr`/`CString` do not have a guaranteed layout
+
 lint_improper_ctypes_dyn = trait objects have no C equivalent
 
 lint_improper_ctypes_enum_repr_help =

compiler/rustc_lint/src/types.rs

@@ -985,6 +985,14 @@ struct ImproperCTypesVisitor<'a, 'tcx> {
  mode: CItemKind,
 }
 
+/// Accumulator for recursive ffi type checking
+struct CTypesVisitorState<'tcx> {
+ cache: FxHashSet<Ty<'tcx>>,
+ /// The original type being checked, before we recursed
+ /// to any other types it contains.
+ base_ty: Ty<'tcx>,
+}
+
 enum FfiResult<'tcx> {
  FfiSafe,
  FfiPhantom(Ty<'tcx>),
@@ -1213,7 +1221,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  /// Checks if the given field's type is "ffi-safe".
  fn check_field_type_for_ffi(
  &self,
- cache: &mut FxHashSet<Ty<'tcx>>,
+ acc: &mut CTypesVisitorState<'tcx>,
  field: &ty::FieldDef,
  args: GenericArgsRef<'tcx>,
  ) -> FfiResult<'tcx> {
@@ -1223,13 +1231,13 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  .tcx
  .try_normalize_erasing_regions(self.cx.param_env, field_ty)
  .unwrap_or(field_ty);
- self.check_type_for_ffi(cache, field_ty)
+ self.check_type_for_ffi(acc, field_ty)
  }
 
  /// Checks if the given `VariantDef`'s field types are "ffi-safe".
  fn check_variant_for_ffi(
  &self,
- cache: &mut FxHashSet<Ty<'tcx>>,
+ acc: &mut CTypesVisitorState<'tcx>,
  ty: Ty<'tcx>,
  def: ty::AdtDef<'tcx>,
  variant: &ty::VariantDef,
@@ -1239,7 +1247,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  let transparent_with_all_zst_fields = if def.repr().transparent() {
  if let Some(field) = transparent_newtype_field(self.cx.tcx, variant) {
  // Transparent newtypes have at most one non-ZST field which needs to be checked..
- match self.check_field_type_for_ffi(cache, field, args) {
+ match self.check_field_type_for_ffi(acc, field, args) {
  FfiUnsafe { ty, .. } if ty.is_unit() => (),
  r => return r,
  }
@@ -1257,7 +1265,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  // We can't completely trust `repr(C)` markings, so make sure the fields are actually safe.
  let mut all_phantom = !variant.fields.is_empty();
  for field in &variant.fields {
- all_phantom &= match self.check_field_type_for_ffi(cache, field, args) {
+ all_phantom &= match self.check_field_type_for_ffi(acc, field, args) {
  FfiSafe => false,
  // `()` fields are FFI-safe!
  FfiUnsafe { ty, .. } if ty.is_unit() => false,
@@ -1277,7 +1285,11 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
  /// Checks if the given type is "ffi-safe" (has a stable, well-defined
  /// representation which can be exported to C code).
- fn check_type_for_ffi(&self, cache: &mut FxHashSet<Ty<'tcx>>, ty: Ty<'tcx>) -> FfiResult<'tcx> {
+ fn check_type_for_ffi(
+ &self,
+ acc: &mut CTypesVisitorState<'tcx>,
+ ty: Ty<'tcx>,
+ ) -> FfiResult<'tcx> {
  use FfiResult::*;
 
  let tcx = self.cx.tcx;
@@ -1286,7 +1298,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  // `struct S(*mut S);`.
  // FIXME: A recursion limit is necessary as well, for irregular
  // recursive types.
- if !cache.insert(ty) {
+ if !acc.cache.insert(ty) {
  return FfiSafe;
  }
 
@@ -1308,6 +1320,17 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  }
  match def.adt_kind() {
  AdtKind::Struct | AdtKind::Union => {
+ if let Some(sym::cstring_type | sym::cstr_type) =
+ tcx.get_diagnostic_name(def.did())
+ && !acc.base_ty.is_mutable_ptr()
+ {
+ return FfiUnsafe {
+ ty,
+ reason: fluent::lint_improper_ctypes_cstr_reason,
+ help: Some(fluent::lint_improper_ctypes_cstr_help),
+ };
+ }
+
  if !def.repr().c() && !def.repr().transparent() {
  return FfiUnsafe {
  ty,
@@ -1354,7 +1377,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  };
  }
 
- self.check_variant_for_ffi(cache, ty, def, def.non_enum_variant(), args)
+ self.check_variant_for_ffi(acc, ty, def, def.non_enum_variant(), args)
  }
  AdtKind::Enum => {
  if def.variants().is_empty() {
@@ -1378,7 +1401,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  if let Some(ty) =
  repr_nullable_ptr(self.cx.tcx, self.cx.param_env, ty, self.mode)
  {
- return self.check_type_for_ffi(cache, ty);
+ return self.check_type_for_ffi(acc, ty);
  }
 
  return FfiUnsafe {
@@ -1399,7 +1422,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  };
  }
 
- match self.check_variant_for_ffi(cache, ty, def, variant, args) {
+ match self.check_variant_for_ffi(acc, ty, def, variant, args) {
  FfiSafe => (),
  r => return r,
  }
@@ -1469,9 +1492,9 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  FfiSafe
  }
 
- ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.check_type_for_ffi(cache, ty),
+ ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.check_type_for_ffi(acc, ty),
 
- ty::Array(inner_ty, _) => self.check_type_for_ffi(cache, inner_ty),
+ ty::Array(inner_ty, _) => self.check_type_for_ffi(acc, inner_ty),
 
  ty::FnPtr(sig_tys, hdr) => {
  let sig = sig_tys.with(hdr);
@@ -1485,7 +1508,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
  let sig = tcx.instantiate_bound_regions_with_erased(sig);
  for arg in sig.inputs() {
- match self.check_type_for_ffi(cache, *arg) {
+ match self.check_type_for_ffi(acc, *arg) {
  FfiSafe => {}
  r => return r,
  }
@@ -1496,7 +1519,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  return FfiSafe;
  }
 
- self.check_type_for_ffi(cache, ret_ty)
+ self.check_type_for_ffi(acc, ret_ty)
  }
 
  ty::Foreign(..) => FfiSafe,
@@ -1619,7 +1642,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
  return;
  }
 
- match self.check_type_for_ffi(&mut FxHashSet::default(), ty) {
+ let mut acc = CTypesVisitorState { cache: FxHashSet::default(), base_ty: ty };
+ match self.check_type_for_ffi(&mut acc, ty) {
  FfiResult::FfiSafe => {}
  FfiResult::FfiPhantom(ty) => {
  self.emit_ffi_unsafe_type_lint(

compiler/rustc_middle/src/traits/mod.rs

@@ -353,7 +353,7 @@ pub enum ObligationCauseCode<'tcx> {
  ReturnValue(HirId),
 
  /// Opaque return type of this function
- OpaqueReturnType(Option<(Ty<'tcx>, Span)>),
+ OpaqueReturnType(Option<(Ty<'tcx>, HirId)>),
 
  /// Block implicit return
  BlockTailExpression(HirId, hir::MatchSource),