Auto merge of #147838 - matthiaskrgr:rollup-r8r148d, r=matthiaskrgr

Rollup of 8 pull requests
Successful merges:
- #140153 (Implement `Debug` for `EncodeWide`)
- #145724 (the `#[track_caller]` shim should not inherit `#[no_mangle]`)
- #147258 (iter repeat: panic on last)
- #147454 (Fix backtraces with `-C panic=abort` on qnx; emit unwind tables by default)
- #147468 (Implement fs api set_times and set_times_nofollow)
- #147764 (Undo CopyForDeref assertion in const qualif)
- #147805 (use module_child index as disambiguator for external items)
- #147824 (docs: update Motor OS target docs)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_codegen_cranelift/src/abi/mod.rs

@@ -467,7 +467,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
 true
 }else{
  instance.is_some_and(|inst| {
- fx.tcx.codegen_fn_attrs(inst.def_id()).flags.contains(CodegenFnAttrFlags::COLD)
+ fx.tcx.codegen_instance_attrs(inst.def).flags.contains(CodegenFnAttrFlags::COLD)
 })
 };
 if is_cold {

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -200,10 +200,11 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
 let fn_ty = bx.fn_decl_backend_type(fn_abi);
 
 let fn_attrs = if bx.tcx().def_kind(fx.instance.def_id()).has_codegen_attrs(){
-Some(bx.tcx().codegen_fn_attrs(fx.instance.def_id()))
+Some(bx.tcx().codegen_instance_attrs(fx.instance.def))
 }else{
 None
 };
+let fn_attrs = fn_attrs.as_deref();
 
 if !fn_abi.can_unwind{
  unwind = mir::UnwindAction::Unreachable;

compiler/rustc_const_eval/src/check_consts/qualifs.rs

@@ -234,7 +234,7 @@ where
 
 Rvalue::Discriminant(place) => in_place::<Q,_>(cx, in_local, place.as_ref()),
 
-Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
+Rvalue::CopyForDeref(place) => in_place::<Q,_>(cx, in_local, place.as_ref()),
 
 Rvalue::Use(operand)
  | Rvalue::Repeat(operand, _)

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -13,6 +13,8 @@ impl<'tcx> TyCtxt<'tcx> {
 self,
 instance_kind:InstanceKind<'_>,
 ) -> Cow<'tcx,CodegenFnAttrs>{
+// NOTE: we try to not clone the `CodegenFnAttrs` when that is not needed.
+// The `to_mut` method used below clones the inner value.
 letmut attrs = Cow::Borrowed(self.codegen_fn_attrs(instance_kind.def_id()));
 
 // Drop the `#[naked]` attribute on non-item `InstanceKind`s, like the shims that
@@ -23,6 +25,28 @@ impl<'tcx> TyCtxt<'tcx> {
 }
 }
 
+// A shim created by `#[track_caller]` should not inherit any attributes
+// that modify the symbol name. Failing to remove these attributes from
+// the shim leads to errors like `symbol `foo` is already defined`.
+//
+// A `ClosureOnceShim` with the track_caller attribute does not have a symbol,
+// and therefore can be skipped here.
+ifletInstanceKind::ReifyShim(_, _) = instance_kind
+ && attrs.flags.contains(CodegenFnAttrFlags::TRACK_CALLER)
+{
+if attrs.flags.contains(CodegenFnAttrFlags::NO_MANGLE){
+ attrs.to_mut().flags.remove(CodegenFnAttrFlags::NO_MANGLE);
+}
+
+if attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL){
+ attrs.to_mut().flags.remove(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL);
+}
+
+if attrs.symbol_name.is_some(){
+ attrs.to_mut().symbol_name = None;
+}
+}
+
  attrs
 }
 }

compiler/rustc_mir_transform/src/inline.rs

@@ -245,7 +245,7 @@ impl<'tcx> Inliner<'tcx> for ForceInliner<'tcx> {
 fnon_inline_failure(&self,callsite:&CallSite<'tcx>,reason:&'staticstr){
 let tcx = self.tcx();
 letInlineAttr::Force{ attr_span,reason: justification } =
- tcx.codegen_fn_attrs(callsite.callee.def_id()).inline
+ tcx.codegen_instance_attrs(callsite.callee.def).inline
 else{
 bug!("called on item without required inlining");
 };
@@ -603,7 +603,8 @@ fn try_inlining<'tcx, I: Inliner<'tcx>>(
 let tcx = inliner.tcx();
 check_mir_is_available(inliner, caller_body, callsite.callee)?;
 
-let callee_attrs = tcx.codegen_fn_attrs(callsite.callee.def_id());
+let callee_attrs = tcx.codegen_instance_attrs(callsite.callee.def);
+let callee_attrs = callee_attrs.as_ref();
  check_inline::is_inline_valid_on_fn(tcx, callsite.callee.def_id())?;
 check_codegen_attributes(inliner, callsite, callee_attrs)?;
  inliner.check_codegen_attributes_extra(callee_attrs)?;

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -77,6 +77,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 parent:Module<'ra>,
 ident:Ident,
 ns:Namespace,
+child_index:usize,
 res:Res,
 vis:Visibility<DefId>,
 span:Span,
@@ -86,10 +87,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 // Even if underscore names cannot be looked up, we still need to add them to modules,
 // because they can be fetched by glob imports from those modules, and bring traits
 // into scope both directly and through glob imports.
-let key = BindingKey::new_disambiguated(ident, ns, || {
- parent.underscore_disambiguator.update_unchecked(|d| d + 1);
- parent.underscore_disambiguator.get()
-});
+let key =
+BindingKey::new_disambiguated(ident, ns, || (child_index + 1).try_into().unwrap());// 0 indicates no underscore
 ifself
 .resolution_or_default(parent, key)
 .borrow_mut_unchecked()
@@ -233,9 +232,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 }
 
 pub(crate)fnbuild_reduced_graph_external(&self,module:Module<'ra>){
-for child inself.tcx.module_children(module.def_id()){
+for(i,child)inself.tcx.module_children(module.def_id()).into_iter().enumerate(){
 let parent_scope = ParentScope::module(module,self.arenas);
-self.build_reduced_graph_for_external_crate_res(child, parent_scope)
+self.build_reduced_graph_for_external_crate_res(child, parent_scope, i)
 }
 }
 
@@ -244,6 +243,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 &self,
 child:&ModChild,
 parent_scope:ParentScope<'ra>,
+child_index:usize,
 ){
 let parent = parent_scope.module;
 letModChild{ ident, res, vis,ref reexport_chain } = *child;
@@ -272,7 +272,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
  _,
 )
  | Res::PrimTy(..)
- | Res::ToolMod => self.define_extern(parent, ident,TypeNS, res, vis, span, expansion),
+ | Res::ToolMod => {
+self.define_extern(parent, ident,TypeNS, child_index, res, vis, span, expansion)
+}
 Res::Def(
 DefKind::Fn
  | DefKind::AssocFn
@@ -281,9 +283,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
  | DefKind::AssocConst
  | DefKind::Ctor(..),
  _,
-) => self.define_extern(parent, ident,ValueNS, res, vis, span, expansion),
+) => self.define_extern(parent, ident,ValueNS,child_index,res, vis, span, expansion),
 Res::Def(DefKind::Macro(..), _) | Res::NonMacroAttr(..) => {
-self.define_extern(parent, ident,MacroNS, res, vis, span, expansion)
+self.define_extern(parent, ident,MacroNS,child_index,res, vis, span, expansion)
 }
 Res::Def(
 DefKind::TyParam

compiler/rustc_target/src/spec/base/nto_qnx.rs

@@ -12,6 +12,9 @@ pub(crate) fn opts() -> TargetOptions {
 has_thread_local:false,
 linker:Some("qcc".into()),
 os:"nto".into(),
+// We want backtraces to work by default and they rely on unwind tables
+// (regardless of `-C panic` strategy).
+default_uwtable:true,
 position_independent_executables:true,
 static_position_independent_executables:true,
 relro_level:RelroLevel::Full,

library/alloc/src/wtf8/tests.rs

@@ -579,6 +579,17 @@ fn wtf8_encode_wide_size_hint() {
 assert!(iter.next().is_none());
 }
 
+#[test]
+fnwtf8_encode_wide_debug(){
+letmut string = Wtf8Buf::from_str("aé ");
+ string.push(CodePoint::from_u32(0xD83D).unwrap());
+ string.push_char('💩');
+assert_eq!(
+ format!("{:?}", string.encode_wide()),
+r#"EncodeWide(['a', 'é', ' ', 0xD83D, 0xD83D, 0xDCA9])"#
+);
+}
+
 #[test]
 fnwtf8_clone_into(){
 letmut string = Wtf8Buf::new();

library/core/src/iter/sources/repeat.rs

@@ -101,8 +101,9 @@ impl<A: Clone> Iterator for Repeat<A> {
 Some(self.element.clone())
 }
 
+#[track_caller]
 fnlast(self) -> Option<A>{
-Some(self.element)
+panic!("iterator is infinite");
 }
 
 #[track_caller]

library/core/src/wtf8.rs

@@ -562,15 +562,36 @@ impl Iterator for EncodeWide<'_> {
 }
 }
 
+#[stable(feature = "encode_wide_fused_iterator", since = "1.62.0")]
+implFusedIteratorforEncodeWide<'_>{}
+
+#[stable(feature = "encode_wide_debug", since = "CURRENT_RUSTC_VERSION")]
 impl fmt::DebugforEncodeWide<'_>{
 fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
- f.debug_struct("EncodeWide").finish_non_exhaustive()
+structCodeUnit(u16);
+impl fmt::DebugforCodeUnit{
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+// This output attempts to balance readability with precision.
+// Render characters which take only one WTF-16 code unit using
+// `char` syntax and everything else as code units with hex
+// integer syntax (including paired and unpaired surrogate
+// halves). Since Rust has no `char`-like type for WTF-16, this
+// isn't perfect, so if this output isn't suitable, it is open
+// to being changed (see #140153).
+match char::from_u32(self.0asu32){
+Some(c) => write!(f,"{c:?}"),
+None => write!(f,"0x{:04X}",self.0),
+}
+}
+}
+
+write!(f,"EncodeWide(")?;
+ f.debug_list().entries(self.clone().map(CodeUnit)).finish()?;
+write!(f,")")?;
+Ok(())
 }
 }
 
-#[stable(feature = "encode_wide_fused_iterator", since = "1.62.0")]
-implFusedIteratorforEncodeWide<'_>{}
-
 implHashforCodePoint{
 #[inline]
 fnhash<H:Hasher>(&self,state:&mutH){