Skip to content

Commit ee8c9d3

Browse files
borsbors
committedOct 14, 2023
Auto merge of rust-lang#116737 - matthiaskrgr:rollup-jftlnmt, r=matthiaskrgr
Rollup of 6 pull requests Successful merges: - rust-lang#115439 (rustdoc: hide `#[repr(transparent)]` if it isn't part of the public ABI) - rust-lang#116591 (Don't accidentally detect the commit hash as an `fadd` instruction) - rust-lang#116603 (Reorganize `bootstrap/Cargo.toml`) - rust-lang#116715 (Prevent more spurious unreachable pattern lints) - rust-lang#116723 (Fix broken build on ESP-IDF caused by rust-lang#115108) - rust-lang#116730 (Add some unsoundness tests for opaques capturing hidden regions not in substs) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 8de6f99 + 77b578f commit ee8c9d3

35 files changed

+434
-161
lines changed
 

‎compiler/rustc_middle/src/thir.rs

+26-5
Original file line numberDiff line numberDiff line change
@@ -19,11 +19,12 @@ use rustc_middle::middle::region;
1919
use rustc_middle::mir::interpret::AllocId;
2020
use rustc_middle::mir::{self, BinOp, BorrowKind, FakeReadCause, Mutability, UnOp};
2121
use rustc_middle::ty::adjustment::PointerCoercion;
22-
use rustc_middle::ty::GenericArgsRef;
23-
use rustc_middle::ty::{self, AdtDef, FnSig, List, Ty, UpvarArgs};
24-
use rustc_middle::ty::{CanonicalUserType, CanonicalUserTypeAnnotation};
22+
use rustc_middle::ty::{
23+
self, AdtDef, CanonicalUserType, CanonicalUserTypeAnnotation, FnSig, GenericArgsRef, List, Ty,
24+
UpvarArgs,
25+
};
2526
use rustc_span::def_id::LocalDefId;
26-
use rustc_span::{sym, Span, Symbol, DUMMY_SP};
27+
use rustc_span::{sym, ErrorGuaranteed, Span, Symbol, DUMMY_SP};
2728
use rustc_target::abi::{FieldIdx, VariantIdx};
2829
use rustc_target::asm::InlineAsmRegOrRegClass;
2930
use std::fmt;
@@ -632,7 +633,7 @@ impl<'tcx> Pat<'tcx> {
632633

633634
use PatKind::*;
634635
match &self.kind {
635-
Wild | Range(..) | Binding { subpattern: None, .. } | Constant { .. } => {}
636+
Wild | Range(..) | Binding { subpattern: None, .. } | Constant { .. } | Error(_) => {}
636637
AscribeUserType { subpattern, .. }
637638
| Binding { subpattern: Some(subpattern), .. }
638639
| Deref { subpattern } => subpattern.walk_(it),
@@ -647,6 +648,21 @@ impl<'tcx> Pat<'tcx> {
647648
}
648649
}
649650

651+
/// Whether the pattern has a `PatKind::Error` nested within.
652+
pub fn pat_error_reported(&self) -> Result<(), ErrorGuaranteed> {
653+
let mut error = None;
654+
self.walk(|pat| {
655+
if let PatKind::Error(e) = pat.kind && error.is_none() {
656+
error = Some(e);
657+
}
658+
error.is_none()
659+
});
660+
match error {
661+
None => Ok(()),
662+
Some(e) => Err(e),
663+
}
664+
}
665+
650666
/// Walk the pattern in left-to-right order.
651667
///
652668
/// If you always want to recurse, prefer this method over `walk`.
@@ -771,6 +787,10 @@ pub enum PatKind<'tcx> {
771787
Or {
772788
pats: Box<[Box<Pat<'tcx>>]>,
773789
},
790+
791+
/// An error has been encountered during lowering. We probably shouldn't report more lints
792+
/// related to this pattern.
793+
Error(ErrorGuaranteed),
774794
}
775795

776796
#[derive(Clone, Debug, PartialEq, HashStable, TypeVisitable)]
@@ -934,6 +954,7 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
934954
}
935955
Ok(())
936956
}
957+
PatKind::Error(_) => write!(f, "<error>"),
937958
}
938959
}
939960
}

‎compiler/rustc_middle/src/thir/visit.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -226,7 +226,7 @@ pub fn walk_pat<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, pat: &Pat<'
226226
is_primary: _,
227227
name: _,
228228
} => visitor.visit_pat(&subpattern),
229-
Binding { .. } | Wild => {}
229+
Binding { .. } | Wild | Error(_) => {}
230230
Variant { subpatterns, adt_def: _, args: _, variant_index: _ } | Leaf { subpatterns } => {
231231
for subpattern in subpatterns {
232232
visitor.visit_pat(&subpattern.pattern);

‎compiler/rustc_mir_build/src/build/matches/mod.rs

+4-1
Original file line numberDiff line numberDiff line change
@@ -814,7 +814,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
814814
}
815815
}
816816

817-
PatKind::Constant { .. } | PatKind::Range { .. } | PatKind::Wild => {}
817+
PatKind::Constant { .. }
818+
| PatKind::Range { .. }
819+
| PatKind::Wild
820+
| PatKind::Error(_) => {}
818821

819822
PatKind::Deref { ref subpattern } => {
820823
self.visit_primary_bindings(subpattern, pattern_user_ty.deref(), f);

‎compiler/rustc_mir_build/src/build/matches/simplify.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -168,7 +168,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
168168
Ok(())
169169
}
170170

171-
PatKind::Wild => {
171+
PatKind::Wild | PatKind::Error(_) => {
172172
// nothing left to do
173173
Ok(())
174174
}

‎compiler/rustc_mir_build/src/build/matches/test.rs

+4-2
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
7777
| PatKind::Wild
7878
| PatKind::Binding { .. }
7979
| PatKind::Leaf { .. }
80-
| PatKind::Deref { .. } => self.error_simplifiable(match_pair),
80+
| PatKind::Deref { .. }
81+
| PatKind::Error(_) => self.error_simplifiable(match_pair),
8182
}
8283
}
8384

@@ -111,7 +112,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
111112
| PatKind::Binding { .. }
112113
| PatKind::AscribeUserType { .. }
113114
| PatKind::Leaf { .. }
114-
| PatKind::Deref { .. } => {
115+
| PatKind::Deref { .. }
116+
| PatKind::Error(_) => {
115117
// don't know how to add these patterns to a switch
116118
false
117119
}

‎compiler/rustc_mir_build/src/check_unsafety.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -224,7 +224,8 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
224224
PatKind::Wild |
225225
// these just wrap other patterns
226226
PatKind::Or { .. } |
227-
PatKind::AscribeUserType { .. } => {}
227+
PatKind::AscribeUserType { .. } |
228+
PatKind::Error(_) => {}
228229
}
229230
};
230231

‎compiler/rustc_mir_build/src/thir/pattern/check_match.rs

+26-8
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ use rustc_hir::HirId;
1919
use rustc_middle::thir::visit::{self, Visitor};
2020
use rustc_middle::thir::*;
2121
use rustc_middle::ty::print::with_no_trimmed_paths;
22-
use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeVisitableExt};
22+
use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
2323
use rustc_session::lint::builtin::{
2424
BINDINGS_WITH_VARIANT_NAME, IRREFUTABLE_LET_PATTERNS, UNREACHABLE_PATTERNS,
2525
};
@@ -231,6 +231,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
231231
if let LetSource::None = source {
232232
return;
233233
}
234+
if let Err(err) = pat.pat_error_reported() {
235+
self.error = Err(err);
236+
return;
237+
}
234238
self.check_patterns(pat, Refutable);
235239
let mut cx = self.new_cx(self.lint_level, true);
236240
let tpat = self.lower_pattern(&mut cx, pat);
@@ -252,6 +256,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
252256
self.with_lint_level(arm.lint_level, |this| {
253257
this.check_patterns(&arm.pattern, Refutable);
254258
});
259+
if let Err(err) = arm.pattern.pat_error_reported() {
260+
self.error = Err(err);
261+
return;
262+
}
255263
}
256264

257265
let tarms: Vec<_> = arms
@@ -334,7 +342,8 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
334342
// and record chain members that aren't let exprs.
335343
let mut chain_refutabilities = Vec::new();
336344

337-
let add = |expr: ExprId, mut local_lint_level| {
345+
let mut error = Ok(());
346+
let mut add = |expr: ExprId, mut local_lint_level| {
338347
// `local_lint_level` is the lint level enclosing the pattern inside `expr`.
339348
let mut expr = &self.thir[expr];
340349
debug!(?expr, ?local_lint_level, "add");
@@ -348,6 +357,10 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
348357
debug!(?expr, ?local_lint_level, "after scopes");
349358
match expr.kind {
350359
ExprKind::Let { box ref pat, expr: _ } => {
360+
if let Err(err) = pat.pat_error_reported() {
361+
error = Err(err);
362+
return None;
363+
}
351364
let mut ncx = self.new_cx(local_lint_level, true);
352365
let tpat = self.lower_pattern(&mut ncx, pat);
353366
let refutable = !is_let_irrefutable(&mut ncx, local_lint_level, tpat);
@@ -380,6 +393,11 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
380393
debug!(?chain_refutabilities);
381394
chain_refutabilities.reverse();
382395

396+
if error.is_err() {
397+
self.error = error;
398+
return;
399+
}
400+
383401
// Third, emit the actual warnings.
384402
if chain_refutabilities.iter().all(|r| matches!(*r, Some((_, false)))) {
385403
// The entire chain is made up of irrefutable `let` statements
@@ -426,6 +444,12 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
426444

427445
#[instrument(level = "trace", skip(self))]
428446
fn check_irrefutable(&mut self, pat: &Pat<'tcx>, origin: &str, sp: Option<Span>) {
447+
// If we got errors while lowering, don't emit anything more.
448+
if let Err(err) = pat.pat_error_reported() {
449+
self.error = Err(err);
450+
return;
451+
}
452+
429453
let mut cx = self.new_cx(self.lint_level, false);
430454

431455
let pattern = self.lower_pattern(&mut cx, pat);
@@ -682,12 +706,6 @@ fn non_exhaustive_match<'p, 'tcx>(
682706
arms: &[ArmId],
683707
expr_span: Span,
684708
) -> ErrorGuaranteed {
685-
for &arm in arms {
686-
if let Err(err) = thir[arm].pattern.error_reported() {
687-
return err;
688-
}
689-
}
690-
691709
let is_empty_match = arms.is_empty();
692710
let non_empty_enum = match scrut_ty.kind() {
693711
ty::Adt(def, _) => def.is_enum() && !def.variants().is_empty(),

‎compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs

+7-15
Original file line numberDiff line numberDiff line change
@@ -196,9 +196,7 @@ impl<'tcx> ConstToPat<'tcx> {
196196
};
197197
// All branches above emitted an error. Don't print any more lints.
198198
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
199-
let kind = PatKind::Constant {
200-
value: mir::Const::Ty(ty::Const::new_error(self.tcx(), e, cv.ty())),
201-
};
199+
let kind = PatKind::Error(e);
202200
return Box::new(Pat { span: self.span, ty: cv.ty(), kind });
203201
} else if !self.saw_const_match_lint.get() {
204202
if let Some(mir_structural_match_violation) = mir_structural_match_violation {
@@ -351,15 +349,15 @@ impl<'tcx> ConstToPat<'tcx> {
351349
let e = tcx.sess.emit_err(InvalidPattern { span, non_sm_ty: ty });
352350
self.saw_const_match_error.set(Some(e));
353351
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
354-
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
352+
PatKind::Error(e)
355353
}
356354
ty::Adt(adt_def, _) if !self.type_marked_structural(ty) => {
357355
debug!("adt_def {:?} has !type_marked_structural for cv.ty: {:?}", adt_def, ty,);
358356
let err = TypeNotStructural { span, non_sm_ty: ty };
359357
let e = tcx.sess.emit_err(err);
360358
self.saw_const_match_error.set(Some(e));
361359
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
362-
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
360+
PatKind::Error(e)
363361
}
364362
ty::Adt(adt_def, args) if adt_def.is_enum() => {
365363
let (&variant_index, fields) = cv.unwrap_branch().split_first().unwrap();
@@ -434,17 +432,13 @@ impl<'tcx> ConstToPat<'tcx> {
434432
} else {
435433
if let Some(e) = self.saw_const_match_error.get() {
436434
// We already errored. Signal that in the pattern, so that follow up errors can be silenced.
437-
PatKind::Constant {
438-
value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
439-
}
435+
PatKind::Error(e)
440436
} else {
441437
let err = TypeNotStructural { span, non_sm_ty: *pointee_ty };
442438
let e = tcx.sess.emit_err(err);
443439
self.saw_const_match_error.set(Some(e));
444440
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
445-
PatKind::Constant {
446-
value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
447-
}
441+
PatKind::Error(e)
448442
}
449443
}
450444
}
@@ -456,9 +450,7 @@ impl<'tcx> ConstToPat<'tcx> {
456450
let err = UnsizedPattern { span, non_sm_ty: *pointee_ty };
457451
let e = tcx.sess.emit_err(err);
458452
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
459-
PatKind::Constant {
460-
value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
461-
}
453+
PatKind::Error(e)
462454
} else {
463455
let old = self.behind_reference.replace(true);
464456
// `b"foo"` produces a `&[u8; 3]`, but you can't use constants of array type when
@@ -489,7 +481,7 @@ impl<'tcx> ConstToPat<'tcx> {
489481
let e = tcx.sess.emit_err(err);
490482
self.saw_const_match_error.set(Some(e));
491483
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
492-
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
484+
PatKind::Error(e)
493485
}
494486
};
495487

‎compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs

+4
Original file line numberDiff line numberDiff line change
@@ -1525,6 +1525,10 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {
15251525
let pats = expand_or_pat(pat);
15261526
fields = Fields::from_iter(cx, pats.into_iter().map(mkpat));
15271527
}
1528+
PatKind::Error(_) => {
1529+
ctor = Opaque;
1530+
fields = Fields::empty();
1531+
}
15281532
}
15291533
DeconstructedPat::new(ctor, fields, pat.ty, pat.span)
15301534
}

‎compiler/rustc_mir_build/src/thir/pattern/mod.rs

+20-22
Original file line numberDiff line numberDiff line change
@@ -252,10 +252,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
252252

253253
hir::PatKind::Range(ref lo_expr, ref hi_expr, end) => {
254254
let (lo_expr, hi_expr) = (lo_expr.as_deref(), hi_expr.as_deref());
255-
// FIXME?: returning `_` can cause inaccurate "unreachable" warnings. This can be
256-
// fixed by returning `PatKind::Const(ConstKind::Error(...))` if #115937 gets
257-
// merged.
258-
self.lower_pattern_range(lo_expr, hi_expr, end, ty, span).unwrap_or(PatKind::Wild)
255+
self.lower_pattern_range(lo_expr, hi_expr, end, ty, span)
256+
.unwrap_or_else(PatKind::Error)
259257
}
260258

261259
hir::PatKind::Path(ref qpath) => {
@@ -423,9 +421,9 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
423421
if adt_def.is_enum() {
424422
let args = match ty.kind() {
425423
ty::Adt(_, args) | ty::FnDef(_, args) => args,
426-
ty::Error(_) => {
424+
ty::Error(e) => {
427425
// Avoid ICE (#50585)
428-
return PatKind::Wild;
426+
return PatKind::Error(*e);
429427
}
430428
_ => bug!("inappropriate type for def: {:?}", ty),
431429
};
@@ -452,7 +450,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
452450
| Res::SelfTyAlias { .. }
453451
| Res::SelfCtor(..) => PatKind::Leaf { subpatterns },
454452
_ => {
455-
match res {
453+
let e = match res {
456454
Res::Def(DefKind::ConstParam, _) => {
457455
self.tcx.sess.emit_err(ConstParamInPattern { span })
458456
}
@@ -461,7 +459,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
461459
}
462460
_ => self.tcx.sess.emit_err(NonConstPath { span }),
463461
};
464-
PatKind::Wild
462+
PatKind::Error(e)
465463
}
466464
};
467465

@@ -513,14 +511,13 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
513511
// It should be assoc consts if there's no error but we cannot resolve it.
514512
debug_assert!(is_associated_const);
515513

516-
self.tcx.sess.emit_err(AssocConstInPattern { span });
517-
518-
return pat_from_kind(PatKind::Wild);
514+
let e = self.tcx.sess.emit_err(AssocConstInPattern { span });
515+
return pat_from_kind(PatKind::Error(e));
519516
}
520517

521518
Err(_) => {
522-
self.tcx.sess.emit_err(CouldNotEvalConstPattern { span });
523-
return pat_from_kind(PatKind::Wild);
519+
let e = self.tcx.sess.emit_err(CouldNotEvalConstPattern { span });
520+
return pat_from_kind(PatKind::Error(e));
524521
}
525522
};
526523

@@ -574,12 +571,12 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
574571
Err(ErrorHandled::TooGeneric(_)) => {
575572
// While `Reported | Linted` cases will have diagnostics emitted already
576573
// it is not true for TooGeneric case, so we need to give user more information.
577-
self.tcx.sess.emit_err(ConstPatternDependsOnGenericParameter { span });
578-
pat_from_kind(PatKind::Wild)
574+
let e = self.tcx.sess.emit_err(ConstPatternDependsOnGenericParameter { span });
575+
pat_from_kind(PatKind::Error(e))
579576
}
580577
Err(_) => {
581-
self.tcx.sess.emit_err(CouldNotEvalConstPattern { span });
582-
pat_from_kind(PatKind::Wild)
578+
let e = self.tcx.sess.emit_err(CouldNotEvalConstPattern { span });
579+
pat_from_kind(PatKind::Error(e))
583580
}
584581
}
585582
}
@@ -629,7 +626,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
629626
let uneval = mir::UnevaluatedConst { def: def_id.to_def_id(), args, promoted: None };
630627
debug_assert!(!args.has_free_regions());
631628

632-
let ct = ty::UnevaluatedConst { def: def_id.to_def_id(), args: args };
629+
let ct = ty::UnevaluatedConst { def: def_id.to_def_id(), args };
633630
// First try using a valtree in order to destructure the constant into a pattern.
634631
// FIXME: replace "try to do a thing, then fall back to another thing"
635632
// but something more principled, like a trait query checking whether this can be turned into a valtree.
@@ -649,10 +646,10 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
649646
Ok(val) => self.const_to_pat(mir::Const::Val(val, ty), id, span, None).kind,
650647
Err(ErrorHandled::TooGeneric(_)) => {
651648
// If we land here it means the const can't be evaluated because it's `TooGeneric`.
652-
self.tcx.sess.emit_err(ConstPatternDependsOnGenericParameter { span });
653-
PatKind::Wild
649+
let e = self.tcx.sess.emit_err(ConstPatternDependsOnGenericParameter { span });
650+
PatKind::Error(e)
654651
}
655-
Err(ErrorHandled::Reported(..)) => PatKind::Wild,
652+
Err(ErrorHandled::Reported(err, ..)) => PatKind::Error(err.into()),
656653
}
657654
}
658655
}
@@ -685,7 +682,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
685682
Ok(constant) => {
686683
self.const_to_pat(Const::Ty(constant), expr.hir_id, lit.span, None).kind
687684
}
688-
Err(LitToConstError::Reported(_)) => PatKind::Wild,
685+
Err(LitToConstError::Reported(e)) => PatKind::Error(e),
689686
Err(LitToConstError::TypeError) => bug!("lower_lit: had type error"),
690687
}
691688
}
@@ -791,6 +788,7 @@ impl<'tcx> PatternFoldable<'tcx> for PatKind<'tcx> {
791788
fn super_fold_with<F: PatternFolder<'tcx>>(&self, folder: &mut F) -> Self {
792789
match *self {
793790
PatKind::Wild => PatKind::Wild,
791+
PatKind::Error(e) => PatKind::Error(e),
794792
PatKind::AscribeUserType {
795793
ref subpattern,
796794
ascription: Ascription { ref annotation, variance },

‎compiler/rustc_mir_build/src/thir/print.rs

+3
Original file line numberDiff line numberDiff line change
@@ -757,6 +757,9 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
757757
print_indented!(self, "]", depth_lvl + 2);
758758
print_indented!(self, "}", depth_lvl + 1);
759759
}
760+
PatKind::Error(_) => {
761+
print_indented!(self, "Error", depth_lvl + 1);
762+
}
760763
}
761764

762765
print_indented!(self, "}", depth_lvl);

‎library/std/src/sys/unix/process/mod.rs

+6-2
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,9 @@ pub use crate::sys_common::process::CommandEnvs;
66
#[cfg_attr(any(target_os = "espidf", target_os = "horizon"), allow(unused))]
77
mod process_common;
88

9+
#[cfg(any(target_os = "espidf", target_os = "horizon", target_os = "vita"))]
10+
mod process_unsupported;
11+
912
cfg_if::cfg_if! {
1013
if #[cfg(target_os = "fuchsia")] {
1114
#[path = "process_fuchsia.rs"]
@@ -15,8 +18,9 @@ cfg_if::cfg_if! {
1518
#[path = "process_vxworks.rs"]
1619
mod process_inner;
1720
} else if #[cfg(any(target_os = "espidf", target_os = "horizon", target_os = "vita"))] {
18-
#[path = "process_unsupported.rs"]
19-
mod process_inner;
21+
mod process_inner {
22+
pub use super::process_unsupported::*;
23+
}
2024
} else {
2125
#[path = "process_unix.rs"]
2226
mod process_inner;

‎library/std/src/sys/unix/process/process_unsupported.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -63,12 +63,12 @@ pub struct ExitStatusError(NonZero_c_int);
6363

6464
impl Into<ExitStatus> for ExitStatusError {
6565
fn into(self) -> ExitStatus {
66-
ExitStatus(self.0.into())
66+
ExitStatus::from(c_int::from(self.0))
6767
}
6868
}
6969

7070
impl ExitStatusError {
7171
pub fn code(self) -> Option<NonZeroI32> {
72-
ExitStatus(self.0.into()).code().map(|st| st.try_into().unwrap())
72+
ExitStatus::from(c_int::from(self.0)).code().map(|st| st.try_into().unwrap())
7373
}
7474
}

‎library/std/src/sys/unix/process/process_unsupported/wait_status.rs

+16
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,13 @@
11
//! Emulated wait status for non-Unix #[cfg(unix) platforms
22
//!
33
//! Separate module to facilitate testing against a real Unix implementation.
4+
use core::ffi::NonZero_c_int;
45

56
use crate::ffi::c_int;
67
use crate::fmt;
78

9+
use super::ExitStatusError;
10+
811
/// Emulated wait status for use by `process_unsupported.rs`
912
///
1013
/// Uses the "traditional unix" encoding. For use on platfors which are `#[cfg(unix)]`
@@ -40,6 +43,19 @@ impl ExitStatus {
4043
if (w & 0x7f) == 0 { Some((w & 0xff00) >> 8) } else { None }
4144
}
4245

46+
#[allow(unused)]
47+
pub fn exit_ok(&self) -> Result<(), ExitStatusError> {
48+
// This assumes that WIFEXITED(status) && WEXITSTATUS==0 corresponds to status==0. This is
49+
// true on all actual versions of Unix, is widely assumed, and is specified in SuS
50+
// https://pubs.opengroup.org/onlinepubs/9699919799/functions/wait.html. If it is not
51+
// true for a platform pretending to be Unix, the tests (our doctests, and also
52+
// process_unix/tests.rs) will spot it. `ExitStatusError::code` assumes this too.
53+
match NonZero_c_int::try_from(self.wait_status) {
54+
/* was nonzero */ Ok(failure) => Err(ExitStatusError(failure)),
55+
/* was zero, couldn't convert */ Err(_) => Ok(()),
56+
}
57+
}
58+
4359
pub fn signal(&self) -> Option<i32> {
4460
let signal = self.wait_status & 0x007f;
4561
if signal > 0 && signal < 0x7f { Some(signal) } else { None }

‎src/bootstrap/Cargo.toml

+12-12
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,9 @@ edition = "2021"
55
build = "build.rs"
66
default-run = "bootstrap"
77

8+
[features]
9+
build-metrics = ["sysinfo"]
10+
811
[lib]
912
path = "lib.rs"
1013
doctest = false
@@ -31,12 +34,18 @@ test = false
3134

3235
[dependencies]
3336
build_helper = { path = "../tools/build_helper" }
37+
cc = "1.0.69"
38+
clap = { version = "4.2.4", default-features = false, features = ["std", "usage", "help", "derive", "error-context"] }
39+
clap_complete = "4.2.2"
3440
cmake = "0.1.38"
3541
filetime = "0.2"
36-
cc = "1.0.69"
37-
libc = "0.2"
3842
hex = "0.4"
43+
ignore = "0.4.10"
44+
libc = "0.2"
3945
object = { version = "0.32.0", default-features = false, features = ["archive", "coff", "read_core", "unaligned"] }
46+
once_cell = "1.7.2"
47+
opener = "0.5"
48+
semver = "1.0.17"
4049
serde = "1.0.137"
4150
# Directly use serde_derive rather than through the derive feature of serde to allow building both
4251
# in parallel and to allow serde_json and toml to start building as soon as serde has been built.
@@ -46,17 +55,11 @@ sha2 = "0.10"
4655
tar = "0.4"
4756
termcolor = "1.2.0"
4857
toml = "0.5"
49-
ignore = "0.4.10"
50-
opener = "0.5"
51-
once_cell = "1.7.2"
52-
xz2 = "0.1"
5358
walkdir = "2"
59+
xz2 = "0.1"
5460

5561
# Dependencies needed by the build-metrics feature
5662
sysinfo = { version = "0.26.0", optional = true }
57-
clap = { version = "4.2.4", default-features = false, features = ["std", "usage", "help", "derive", "error-context"] }
58-
clap_complete = "4.2.2"
59-
semver = "1.0.17"
6063

6164
# Solaris doesn't support flock() and thus fd-lock is not option now
6265
[target.'cfg(not(target_os = "solaris"))'.dependencies]
@@ -80,9 +83,6 @@ features = [
8083
[dev-dependencies]
8184
pretty_assertions = "1.4"
8285

83-
[features]
84-
build-metrics = ["sysinfo"]
85-
8686
# We care a lot about bootstrap's compile times, so don't include debuginfo for
8787
# dependencies, only bootstrap itself.
8888
[profile.dev]

‎src/doc/rustdoc/src/advanced-features.md

+20
Original file line numberDiff line numberDiff line change
@@ -110,3 +110,23 @@ https://doc.rust-lang.org/stable/std/?search=%s&go_to_first=true
110110

111111
This URL adds the `go_to_first=true` query parameter which can be appended to any `rustdoc` search URL
112112
to automatically go to the first result.
113+
114+
## `#[repr(transparent)]`: Documenting the transparent representation
115+
116+
You can read more about `#[repr(transparent)]` itself in the [Rust Reference][repr-trans-ref] and
117+
in the [Rustonomicon][repr-trans-nomicon].
118+
119+
Since this representation is only considered part of the public ABI if the single field with non-trivial
120+
size or alignment is public and if the documentation does not state otherwise, Rustdoc helpfully displays
121+
the attribute if and only if the non-1-ZST field is public or at least one field is public in case all
122+
fields are 1-ZST fields. The term *1-ZST* refers to types that are one-aligned and zero-sized.
123+
124+
It would seem that one can manually hide the attribute with `#[cfg_attr(not(doc), repr(transparent))]`
125+
if one wishes to declare the representation as private even if the non-1-ZST field is public.
126+
However, due to [current limitations][cross-crate-cfg-doc], this method is not always guaranteed to work.
127+
Therefore, if you would like to do so, you should always write it down in prose independently of whether
128+
you use `cfg_attr` or not.
129+
130+
[repr-trans-ref]: https://doc.rust-lang.org/reference/type-layout.html#the-transparent-representation
131+
[repr-trans-nomicon]: https://doc.rust-lang.org/nomicon/other-reprs.html#reprtransparent
132+
[cross-crate-cfg-doc]: https://github.com/rust-lang/rust/issues/114952

‎src/librustdoc/clean/types.rs

+36-15
Original file line numberDiff line numberDiff line change
@@ -713,12 +713,16 @@ impl Item {
713713
Some(tcx.visibility(def_id))
714714
}
715715

716-
pub(crate) fn attributes(&self, tcx: TyCtxt<'_>, keep_as_is: bool) -> Vec<String> {
716+
pub(crate) fn attributes(
717+
&self,
718+
tcx: TyCtxt<'_>,
719+
cache: &Cache,
720+
keep_as_is: bool,
721+
) -> Vec<String> {
717722
const ALLOWED_ATTRIBUTES: &[Symbol] =
718-
&[sym::export_name, sym::link_section, sym::no_mangle, sym::repr, sym::non_exhaustive];
723+
&[sym::export_name, sym::link_section, sym::no_mangle, sym::non_exhaustive];
719724

720725
use rustc_abi::IntegerType;
721-
use rustc_middle::ty::ReprFlags;
722726

723727
let mut attrs: Vec<String> = self
724728
.attrs
@@ -739,20 +743,38 @@ impl Item {
739743
}
740744
})
741745
.collect();
742-
if let Some(def_id) = self.def_id() &&
743-
!def_id.is_local() &&
744-
// This check is needed because `adt_def` will panic if not a compatible type otherwise...
745-
matches!(self.type_(), ItemType::Struct | ItemType::Enum | ItemType::Union)
746+
if !keep_as_is
747+
&& let Some(def_id) = self.def_id()
748+
&& let ItemType::Struct | ItemType::Enum | ItemType::Union = self.type_()
746749
{
747-
let repr = tcx.adt_def(def_id).repr();
750+
let adt = tcx.adt_def(def_id);
751+
let repr = adt.repr();
748752
let mut out = Vec::new();
749-
if repr.flags.contains(ReprFlags::IS_C) {
753+
if repr.c() {
750754
out.push("C");
751755
}
752-
if repr.flags.contains(ReprFlags::IS_TRANSPARENT) {
753-
out.push("transparent");
756+
if repr.transparent() {
757+
// Render `repr(transparent)` iff the non-1-ZST field is public or at least one
758+
// field is public in case all fields are 1-ZST fields.
759+
let render_transparent = cache.document_private
760+
|| adt
761+
.all_fields()
762+
.find(|field| {
763+
let ty =
764+
field.ty(tcx, ty::GenericArgs::identity_for_item(tcx, field.did));
765+
tcx.layout_of(tcx.param_env(field.did).and(ty))
766+
.is_ok_and(|layout| !layout.is_1zst())
767+
})
768+
.map_or_else(
769+
|| adt.all_fields().any(|field| field.vis.is_public()),
770+
|field| field.vis.is_public(),
771+
);
772+
773+
if render_transparent {
774+
out.push("transparent");
775+
}
754776
}
755-
if repr.flags.contains(ReprFlags::IS_SIMD) {
777+
if repr.simd() {
756778
out.push("simd");
757779
}
758780
let pack_s;
@@ -777,10 +799,9 @@ impl Item {
777799
};
778800
out.push(&int_s);
779801
}
780-
if out.is_empty() {
781-
return Vec::new();
802+
if !out.is_empty() {
803+
attrs.push(format!("#[repr({})]", out.join(", ")));
782804
}
783-
attrs.push(format!("#[repr({})]", out.join(", ")));
784805
}
785806
attrs
786807
}

‎src/librustdoc/html/render/mod.rs

+8-8
Original file line numberDiff line numberDiff line change
@@ -868,10 +868,10 @@ fn assoc_method(
868868
let (indent, indent_str, end_newline) = if parent == ItemType::Trait {
869869
header_len += 4;
870870
let indent_str = " ";
871-
write!(w, "{}", render_attributes_in_pre(meth, indent_str, tcx));
871+
write!(w, "{}", render_attributes_in_pre(meth, indent_str, cx));
872872
(4, indent_str, Ending::NoNewline)
873873
} else {
874-
render_attributes_in_code(w, meth, tcx);
874+
render_attributes_in_code(w, meth, cx);
875875
(0, "", Ending::Newline)
876876
};
877877
w.reserve(header_len + "<a href=\"\" class=\"fn\">{".len() + "</a>".len());
@@ -1047,13 +1047,13 @@ fn render_assoc_item(
10471047

10481048
// When an attribute is rendered inside a `<pre>` tag, it is formatted using
10491049
// a whitespace prefix and newline.
1050-
fn render_attributes_in_pre<'a, 'b: 'a>(
1050+
fn render_attributes_in_pre<'a, 'tcx: 'a>(
10511051
it: &'a clean::Item,
10521052
prefix: &'a str,
1053-
tcx: TyCtxt<'b>,
1054-
) -> impl fmt::Display + Captures<'a> + Captures<'b> {
1053+
cx: &'a Context<'tcx>,
1054+
) -> impl fmt::Display + Captures<'a> + Captures<'tcx> {
10551055
crate::html::format::display_fn(move |f| {
1056-
for a in it.attributes(tcx, false) {
1056+
for a in it.attributes(cx.tcx(), cx.cache(), false) {
10571057
writeln!(f, "{prefix}{a}")?;
10581058
}
10591059
Ok(())
@@ -1062,8 +1062,8 @@ fn render_attributes_in_pre<'a, 'b: 'a>(
10621062

10631063
// When an attribute is rendered inside a <code> tag, it is formatted using
10641064
// a div to produce a newline after it.
1065-
fn render_attributes_in_code(w: &mut impl fmt::Write, it: &clean::Item, tcx: TyCtxt<'_>) {
1066-
for attr in it.attributes(tcx, false) {
1065+
fn render_attributes_in_code(w: &mut impl fmt::Write, it: &clean::Item, cx: &Context<'_>) {
1066+
for attr in it.attributes(cx.tcx(), cx.cache(), false) {
10671067
write!(w, "<div class=\"code-attribute\">{attr}</div>").unwrap();
10681068
}
10691069
}

‎src/librustdoc/html/render/print_item.rs

+11-12
Original file line numberDiff line numberDiff line change
@@ -120,8 +120,7 @@ macro_rules! item_template_methods {
120120
fn render_attributes_in_pre<'b>(&'b self) -> impl fmt::Display + Captures<'a> + 'b + Captures<'cx> {
121121
display_fn(move |f| {
122122
let (item, cx) = self.item_and_mut_cx();
123-
let tcx = cx.tcx();
124-
let v = render_attributes_in_pre(item, "", tcx);
123+
let v = render_attributes_in_pre(item, "", &cx);
125124
write!(f, "{v}")
126125
})
127126
}
@@ -659,7 +658,7 @@ fn item_function(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, f: &cle
659658
w,
660659
"{attrs}{vis}{constness}{asyncness}{unsafety}{abi}fn \
661660
{name}{generics}{decl}{notable_traits}{where_clause}",
662-
attrs = render_attributes_in_pre(it, "", tcx),
661+
attrs = render_attributes_in_pre(it, "", cx),
663662
vis = visibility,
664663
constness = constness,
665664
asyncness = asyncness,
@@ -694,7 +693,7 @@ fn item_trait(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean:
694693
write!(
695694
w,
696695
"{attrs}{vis}{unsafety}{is_auto}trait {name}{generics}{bounds}",
697-
attrs = render_attributes_in_pre(it, "", tcx),
696+
attrs = render_attributes_in_pre(it, "", cx),
698697
vis = visibility_print_with_space(it.visibility(tcx), it.item_id, cx),
699698
unsafety = t.unsafety(tcx).print_with_space(),
700699
is_auto = if t.is_auto(tcx) { "auto " } else { "" },
@@ -1173,7 +1172,7 @@ fn item_trait_alias(
11731172
write!(
11741173
w,
11751174
"{attrs}trait {name}{generics}{where_b} = {bounds};",
1176-
attrs = render_attributes_in_pre(it, "", cx.tcx()),
1175+
attrs = render_attributes_in_pre(it, "", cx),
11771176
name = it.name.unwrap(),
11781177
generics = t.generics.print(cx),
11791178
where_b = print_where_clause(&t.generics, cx, 0, Ending::Newline),
@@ -1201,7 +1200,7 @@ fn item_opaque_ty(
12011200
write!(
12021201
w,
12031202
"{attrs}type {name}{generics}{where_clause} = impl {bounds};",
1204-
attrs = render_attributes_in_pre(it, "", cx.tcx()),
1203+
attrs = render_attributes_in_pre(it, "", cx),
12051204
name = it.name.unwrap(),
12061205
generics = t.generics.print(cx),
12071206
where_clause = print_where_clause(&t.generics, cx, 0, Ending::Newline),
@@ -1226,7 +1225,7 @@ fn item_type_alias(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &c
12261225
write!(
12271226
w,
12281227
"{attrs}{vis}type {name}{generics}{where_clause} = {type_};",
1229-
attrs = render_attributes_in_pre(it, "", cx.tcx()),
1228+
attrs = render_attributes_in_pre(it, "", cx),
12301229
vis = visibility_print_with_space(it.visibility(cx.tcx()), it.item_id, cx),
12311230
name = it.name.unwrap(),
12321231
generics = t.generics.print(cx),
@@ -1415,7 +1414,7 @@ fn item_enum(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, e: &clean::
14151414
let tcx = cx.tcx();
14161415
let count_variants = e.variants().count();
14171416
wrap_item(w, |w| {
1418-
render_attributes_in_code(w, it, tcx);
1417+
render_attributes_in_code(w, it, cx);
14191418
write!(
14201419
w,
14211420
"{}enum {}{}",
@@ -1734,7 +1733,7 @@ fn item_primitive(w: &mut impl fmt::Write, cx: &mut Context<'_>, it: &clean::Ite
17341733
fn item_constant(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, c: &clean::Constant) {
17351734
wrap_item(w, |w| {
17361735
let tcx = cx.tcx();
1737-
render_attributes_in_code(w, it, tcx);
1736+
render_attributes_in_code(w, it, cx);
17381737

17391738
write!(
17401739
w,
@@ -1783,7 +1782,7 @@ fn item_constant(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, c: &cle
17831782

17841783
fn item_struct(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, s: &clean::Struct) {
17851784
wrap_item(w, |w| {
1786-
render_attributes_in_code(w, it, cx.tcx());
1785+
render_attributes_in_code(w, it, cx);
17871786
render_struct(w, it, Some(&s.generics), s.ctor_kind, &s.fields, "", true, cx);
17881787
});
17891788

@@ -1843,7 +1842,7 @@ fn item_fields(
18431842

18441843
fn item_static(w: &mut impl fmt::Write, cx: &mut Context<'_>, it: &clean::Item, s: &clean::Static) {
18451844
wrap_item(w, |buffer| {
1846-
render_attributes_in_code(buffer, it, cx.tcx());
1845+
render_attributes_in_code(buffer, it, cx);
18471846
write!(
18481847
buffer,
18491848
"{vis}static {mutability}{name}: {typ}",
@@ -1861,7 +1860,7 @@ fn item_static(w: &mut impl fmt::Write, cx: &mut Context<'_>, it: &clean::Item,
18611860
fn item_foreign_type(w: &mut impl fmt::Write, cx: &mut Context<'_>, it: &clean::Item) {
18621861
wrap_item(w, |buffer| {
18631862
buffer.write_str("extern {\n").unwrap();
1864-
render_attributes_in_code(buffer, it, cx.tcx());
1863+
render_attributes_in_code(buffer, it, cx);
18651864
write!(
18661865
buffer,
18671866
" {}type {};\n}}",

‎src/librustdoc/json/conversions.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@ use rustdoc_json_types::*;
1818

1919
use crate::clean::{self, ItemId};
2020
use crate::formats::item_type::ItemType;
21+
use crate::formats::FormatRenderer;
2122
use crate::json::JsonRenderer;
2223
use crate::passes::collect_intra_doc_links::UrlFragment;
2324

@@ -41,7 +42,7 @@ impl JsonRenderer<'_> {
4142
})
4243
.collect();
4344
let docs = item.opt_doc_value();
44-
let attrs = item.attributes(self.tcx, true);
45+
let attrs = item.attributes(self.tcx, self.cache(), true);
4546
let span = item.span(self.tcx);
4647
let visibility = item.visibility(self.tcx);
4748
let clean::Item { name, item_id, .. } = item;

‎tests/codegen/target-feature-inline-closure.rs

+4
Original file line numberDiff line numberDiff line change
@@ -31,3 +31,7 @@ unsafe fn without_avx(x: __m256) -> __m256 {
3131
};
3232
add(x, x)
3333
}
34+
35+
// Don't allow the above CHECK-NOT to accidentally match a commit hash in the
36+
// compiler version.
37+
// CHECK-LABEL: rustc version

‎tests/rustdoc/inline_cross/attributes.rs

+7
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
// aux-crate:attributes=attributes.rs
2+
// edition:2021
3+
#![crate_name = "user"]
4+
5+
// @has 'user/struct.NonExhaustive.html'
6+
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[non_exhaustive]'
7+
pub use attributes::NonExhaustive;

‎tests/rustdoc/inline_cross/auxiliary/attributes.rs

+2
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
#[non_exhaustive]
2+
pub struct NonExhaustive;

‎tests/rustdoc/inline_cross/auxiliary/repr.rs

+21-1
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ pub struct ReprSimd {
1010
}
1111
#[repr(transparent)]
1212
pub struct ReprTransparent {
13-
field: u8,
13+
pub field: u8,
1414
}
1515
#[repr(isize)]
1616
pub enum ReprIsize {
@@ -20,3 +20,23 @@ pub enum ReprIsize {
2020
pub enum ReprU8 {
2121
Bla,
2222
}
23+
24+
#[repr(transparent)] // private
25+
pub struct ReprTransparentPrivField {
26+
field: u32, // non-1-ZST field
27+
}
28+
29+
#[repr(transparent)] // public
30+
pub struct ReprTransparentPriv1ZstFields {
31+
marker0: Marker,
32+
pub main: u64, // non-1-ZST field
33+
marker1: Marker,
34+
}
35+
36+
#[repr(transparent)] // private
37+
pub struct ReprTransparentPrivFieldPub1ZstFields {
38+
main: [u16; 0], // non-1-ZST field
39+
pub marker: Marker,
40+
}
41+
42+
pub struct Marker; // 1-ZST

‎tests/rustdoc/inline_cross/repr.rs

+16-5
Original file line numberDiff line numberDiff line change
@@ -9,21 +9,32 @@ extern crate repr;
99

1010
// @has 'foo/struct.ReprC.html'
1111
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(C, align(8))]'
12-
#[doc(inline)]
1312
pub use repr::ReprC;
1413
// @has 'foo/struct.ReprSimd.html'
1514
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(simd, packed(2))]'
16-
#[doc(inline)]
1715
pub use repr::ReprSimd;
1816
// @has 'foo/struct.ReprTransparent.html'
1917
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
20-
#[doc(inline)]
2118
pub use repr::ReprTransparent;
2219
// @has 'foo/enum.ReprIsize.html'
2320
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(isize)]'
24-
#[doc(inline)]
2521
pub use repr::ReprIsize;
2622
// @has 'foo/enum.ReprU8.html'
2723
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(u8)]'
28-
#[doc(inline)]
2924
pub use repr::ReprU8;
25+
26+
// Regression test for <https://github.com/rust-lang/rust/issues/90435>.
27+
// Check that we show `#[repr(transparent)]` iff the non-1-ZST field is public or at least one
28+
// field is public in case all fields are 1-ZST fields.
29+
30+
// @has 'foo/struct.ReprTransparentPrivField.html'
31+
// @!has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
32+
pub use repr::ReprTransparentPrivField;
33+
34+
// @has 'foo/struct.ReprTransparentPriv1ZstFields.html'
35+
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
36+
pub use repr::ReprTransparentPriv1ZstFields;
37+
38+
// @has 'foo/struct.ReprTransparentPrivFieldPub1ZstFields.html'
39+
// @!has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
40+
pub use repr::ReprTransparentPrivFieldPub1ZstFields;

‎tests/rustdoc/repr.rs

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
// Regression test for <https://github.com/rust-lang/rust/issues/90435>.
2+
// Check that we show `#[repr(transparent)]` iff the non-1-ZST field is public or at least one
3+
// field is public in case all fields are 1-ZST fields.
4+
5+
// @has 'repr/struct.ReprTransparentPrivField.html'
6+
// @!has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
7+
#[repr(transparent)] // private
8+
pub struct ReprTransparentPrivField {
9+
field: u32, // non-1-ZST field
10+
}
11+
12+
// @has 'repr/struct.ReprTransparentPriv1ZstFields.html'
13+
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
14+
#[repr(transparent)] // public
15+
pub struct ReprTransparentPriv1ZstFields {
16+
marker0: Marker,
17+
pub main: u64, // non-1-ZST field
18+
marker1: Marker,
19+
}
20+
21+
// @has 'repr/struct.ReprTransparentPub1ZstField.html'
22+
// @has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
23+
#[repr(transparent)] // public
24+
pub struct ReprTransparentPub1ZstField {
25+
marker0: Marker,
26+
pub marker1: Marker,
27+
}
28+
29+
struct Marker; // 1-ZST

‎tests/ui/const-generics/generic_const_exprs/typeid-equality-by-subtyping.stderr

+1-13
Original file line numberDiff line numberDiff line change
@@ -7,17 +7,5 @@ LL | WHAT_A_TYPE => 0,
77
= note: the traits must be derived, manual `impl`s are not sufficient
88
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
99

10-
error[E0015]: cannot match on `TypeId` in constant functions
11-
--> $DIR/typeid-equality-by-subtyping.rs:18:9
12-
|
13-
LL | WHAT_A_TYPE => 0,
14-
| ^^^^^^^^^^^
15-
|
16-
= note: `TypeId` cannot be compared in compile-time, and therefore cannot be used in `match`es
17-
note: impl defined here, but it is not `const`
18-
--> $SRC_DIR/core/src/any.rs:LL:COL
19-
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
20-
21-
error: aborting due to 2 previous errors
10+
error: aborting due to previous error
2211

23-
For more information about this error, try `rustc --explain E0015`.

‎tests/ui/impl-trait/alias-liveness/rpit-hidden-erased-unsoundness.rs

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
// This test should never pass!
2+
3+
#![feature(type_alias_impl_trait)]
4+
5+
trait Captures<'a> {}
6+
impl<T> Captures<'_> for T {}
7+
8+
struct MyTy<'a, 'b>(Option<*mut &'a &'b ()>);
9+
unsafe impl Send for MyTy<'_, 'static> {}
10+
11+
fn step1<'a, 'b: 'a>() -> impl Sized + Captures<'b> + 'a {
12+
MyTy::<'a, 'b>(None)
13+
}
14+
15+
fn step2<'a, 'b: 'a>() -> impl Sized + 'a {
16+
step1::<'a, 'b>()
17+
//~^ ERROR hidden type for `impl Sized + 'a` captures lifetime that does not appear in bounds
18+
}
19+
20+
fn step3<'a, 'b: 'a>() -> impl Send + 'a {
21+
step2::<'a, 'b>()
22+
// This should not be Send unless `'b: 'static`
23+
}
24+
25+
fn main() {}

‎tests/ui/impl-trait/alias-liveness/rpit-hidden-erased-unsoundness.stderr

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
error[E0700]: hidden type for `impl Sized + 'a` captures lifetime that does not appear in bounds
2+
--> $DIR/rpit-hidden-erased-unsoundness.rs:16:5
3+
|
4+
LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a {
5+
| -- --------------- opaque type defined here
6+
| |
7+
| hidden type `impl Captures<'b> + 'a` captures the lifetime `'b` as defined here
8+
LL | step1::<'a, 'b>()
9+
| ^^^^^^^^^^^^^^^^^
10+
|
11+
help: to declare that `impl Sized + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
12+
|
13+
LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a + 'b {
14+
| ++++
15+
16+
error: aborting due to previous error
17+
18+
For more information about this error, try `rustc --explain E0700`.

‎tests/ui/impl-trait/alias-liveness/rpit-hide-lifetime-for-swap.rs

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
// This test should never pass!
2+
3+
use std::cell::RefCell;
4+
use std::rc::Rc;
5+
6+
trait Swap: Sized {
7+
fn swap(self, other: Self);
8+
}
9+
10+
impl<T> Swap for Rc<RefCell<T>> {
11+
fn swap(self, other: Self) {
12+
<RefCell<T>>::swap(&self, &other);
13+
}
14+
}
15+
16+
fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a {
17+
x
18+
//~^ ERROR hidden type for `impl Swap + 'a` captures lifetime that does not appear in bounds
19+
}
20+
21+
fn dangle() -> &'static [i32; 3] {
22+
let long = Rc::new(RefCell::new(&[4, 5, 6]));
23+
let x = [1, 2, 3];
24+
let short = Rc::new(RefCell::new(&x));
25+
hide(long.clone()).swap(hide(short));
26+
let res: &'static [i32; 3] = *long.borrow();
27+
res
28+
}
29+
30+
fn main() {
31+
println!("{:?}", dangle());
32+
}

‎tests/ui/impl-trait/alias-liveness/rpit-hide-lifetime-for-swap.stderr

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
error[E0700]: hidden type for `impl Swap + 'a` captures lifetime that does not appear in bounds
2+
--> $DIR/rpit-hide-lifetime-for-swap.rs:17:5
3+
|
4+
LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a {
5+
| -- -------------- opaque type defined here
6+
| |
7+
| hidden type `Rc<RefCell<&'b T>>` captures the lifetime `'b` as defined here
8+
LL | x
9+
| ^
10+
|
11+
help: to declare that `impl Swap + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
12+
|
13+
LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + 'b {
14+
| ++++
15+
16+
error: aborting due to previous error
17+
18+
For more information about this error, try `rustc --explain E0700`.

‎tests/ui/impl-trait/alias-liveness/tait-hidden-erased-unsoundness.rs

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
// This test should never pass!
2+
3+
#![feature(type_alias_impl_trait)]
4+
5+
trait Captures<'a> {}
6+
impl<T> Captures<'_> for T {}
7+
8+
struct MyTy<'a, 'b>(Option<*mut &'a &'b ()>);
9+
unsafe impl Send for MyTy<'_, 'static> {}
10+
11+
fn step1<'a, 'b: 'a>() -> impl Sized + Captures<'b> + 'a {
12+
MyTy::<'a, 'b>(None)
13+
}
14+
15+
mod tait {
16+
type Tait<'a> = impl Sized + 'a;
17+
pub(super) fn step2<'a, 'b: 'a>() -> Tait<'a> {
18+
super::step1::<'a, 'b>()
19+
//~^ ERROR hidden type for `Tait<'a>` captures lifetime that does not appear in bounds
20+
}
21+
}
22+
23+
fn step3<'a, 'b: 'a>() -> impl Send + 'a {
24+
tait::step2::<'a, 'b>()
25+
// This should not be Send unless `'b: 'static`
26+
}
27+
28+
fn main() {}

‎tests/ui/impl-trait/alias-liveness/tait-hidden-erased-unsoundness.stderr

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
error[E0700]: hidden type for `Tait<'a>` captures lifetime that does not appear in bounds
2+
--> $DIR/tait-hidden-erased-unsoundness.rs:18:9
3+
|
4+
LL | type Tait<'a> = impl Sized + 'a;
5+
| --------------- opaque type defined here
6+
LL | pub(super) fn step2<'a, 'b: 'a>() -> Tait<'a> {
7+
| -- hidden type `impl Captures<'b> + 'a` captures the lifetime `'b` as defined here
8+
LL | super::step1::<'a, 'b>()
9+
| ^^^^^^^^^^^^^^^^^^^^^^^^
10+
11+
error: aborting due to previous error
12+
13+
For more information about this error, try `rustc --explain E0700`.

‎tests/ui/pattern/usefulness/consts-opaque.rs

-2
Original file line numberDiff line numberDiff line change
@@ -52,15 +52,13 @@ fn main() {
5252
BAR => {}
5353
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
5454
_ => {}
55-
//~^ ERROR unreachable pattern
5655
}
5756

5857
match BAR {
5958
BAR => {}
6059
//~^ ERROR must be annotated with `#[derive(PartialEq, Eq)]`
6160
Bar => {}
6261
_ => {}
63-
//~^ ERROR unreachable pattern
6462
}
6563

6664
match BAR {

‎tests/ui/pattern/usefulness/consts-opaque.stderr

+9-32
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ LL | BAR => {}
3838
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
3939

4040
error: to use a constant of type `Bar` in a pattern, `Bar` must be annotated with `#[derive(PartialEq, Eq)]`
41-
--> $DIR/consts-opaque.rs:59:9
41+
--> $DIR/consts-opaque.rs:58:9
4242
|
4343
LL | BAR => {}
4444
| ^^^
@@ -47,7 +47,7 @@ LL | BAR => {}
4747
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
4848

4949
error: to use a constant of type `Bar` in a pattern, `Bar` must be annotated with `#[derive(PartialEq, Eq)]`
50-
--> $DIR/consts-opaque.rs:67:9
50+
--> $DIR/consts-opaque.rs:65:9
5151
|
5252
LL | BAR => {}
5353
| ^^^
@@ -56,7 +56,7 @@ LL | BAR => {}
5656
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
5757

5858
error: to use a constant of type `Bar` in a pattern, `Bar` must be annotated with `#[derive(PartialEq, Eq)]`
59-
--> $DIR/consts-opaque.rs:69:9
59+
--> $DIR/consts-opaque.rs:67:9
6060
|
6161
LL | BAR => {}
6262
| ^^^
@@ -65,7 +65,7 @@ LL | BAR => {}
6565
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
6666

6767
error: to use a constant of type `Baz` in a pattern, `Baz` must be annotated with `#[derive(PartialEq, Eq)]`
68-
--> $DIR/consts-opaque.rs:75:9
68+
--> $DIR/consts-opaque.rs:73:9
6969
|
7070
LL | BAZ => {}
7171
| ^^^
@@ -74,7 +74,7 @@ LL | BAZ => {}
7474
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
7575

7676
error: to use a constant of type `Baz` in a pattern, `Baz` must be annotated with `#[derive(PartialEq, Eq)]`
77-
--> $DIR/consts-opaque.rs:83:9
77+
--> $DIR/consts-opaque.rs:81:9
7878
|
7979
LL | BAZ => {}
8080
| ^^^
@@ -83,45 +83,22 @@ LL | BAZ => {}
8383
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
8484

8585
error: to use a constant of type `Baz` in a pattern, `Baz` must be annotated with `#[derive(PartialEq, Eq)]`
86-
--> $DIR/consts-opaque.rs:89:9
86+
--> $DIR/consts-opaque.rs:87:9
8787
|
8888
LL | BAZ => {}
8989
| ^^^
9090
|
9191
= note: the traits must be derived, manual `impl`s are not sufficient
9292
= note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
9393

94-
error: unreachable pattern
95-
--> $DIR/consts-opaque.rs:54:9
96-
|
97-
LL | Bar => {}
98-
| --- matches any value
99-
...
100-
LL | _ => {}
101-
| ^ unreachable pattern
102-
|
103-
note: the lint level is defined here
104-
--> $DIR/consts-opaque.rs:6:9
105-
|
106-
LL | #![deny(unreachable_patterns)]
107-
| ^^^^^^^^^^^^^^^^^^^^
108-
109-
error: unreachable pattern
110-
--> $DIR/consts-opaque.rs:62:9
111-
|
112-
LL | Bar => {}
113-
| --- matches any value
114-
LL | _ => {}
115-
| ^ unreachable pattern
116-
11794
error[E0004]: non-exhaustive patterns: `Wrap(_)` not covered
118-
--> $DIR/consts-opaque.rs:124:11
95+
--> $DIR/consts-opaque.rs:122:11
11996
|
12097
LL | match WRAPQUUX {
12198
| ^^^^^^^^ pattern `Wrap(_)` not covered
12299
|
123100
note: `Wrap<fn(usize, usize) -> usize>` defined here
124-
--> $DIR/consts-opaque.rs:106:12
101+
--> $DIR/consts-opaque.rs:104:12
125102
|
126103
LL | struct Wrap<T>(T);
127104
| ^^^^
@@ -132,6 +109,6 @@ LL ~ WRAPQUUX => {},
132109
LL + Wrap(_) => todo!()
133110
|
134111

135-
error: aborting due to 12 previous errors; 1 warning emitted
112+
error: aborting due to 10 previous errors; 1 warning emitted
136113

137114
For more information about this error, try `rustc --explain E0004`.

0 commit comments

Comments
 (0)
Please sign in to comment.