Skip to content

Commit 8b8d328

Browse files
borsbors
committed
Auto merge of #122778 - GuillaumeGomez:rollup-u5ipoai, r=GuillaumeGomez
Rollup of 8 pull requests Successful merges: - #122494 (Simplify key-based thread locals) - #122644 (pattern analysis: add a custom test harness) - #122723 (Use same file permissions for ar_archive_writer as the LLVM archive writer) - #122729 (Relax SeqCst ordering in standard library.) - #122740 (use more accurate terminology) - #122764 (coverage: Remove incorrect assertions from counter allocation) - #122765 (Add `usize::MAX` arg tests for Vec) - #122776 (Rename `hir::Let` into `hir::LetExpr`) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 94b72d6 + dd0d8cd commit 8b8d328

File tree

53 files changed

+1039
-316
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

53 files changed

+1039
-316
lines changed

Diff for: ‎Cargo.lock

+2
Original file line numberDiff line numberDiff line change
@@ -4440,6 +4440,8 @@ dependencies = [
44404440
"rustc_target",
44414441
"smallvec",
44424442
"tracing",
4443+
"tracing-subscriber",
4444+
"tracing-tree",
44434445
]
44444446

44454447
[[package]]

Diff for: ‎compiler/rustc_ast_lowering/src/expr.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -157,7 +157,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
157157
hir::ExprKind::AddrOf(*k, *m, ohs)
158158
}
159159
ExprKind::Let(pat, scrutinee, span, is_recovered) => {
160-
hir::ExprKind::Let(self.arena.alloc(hir::Let {
160+
hir::ExprKind::Let(self.arena.alloc(hir::LetExpr {
161161
span: self.lower_span(*span),
162162
pat: self.lower_pat(pat),
163163
ty: None,

Diff for: ‎compiler/rustc_codegen_ssa/src/back/archive.rs

+21-16
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ use object::read::macho::FatArch;
1313
use tempfile::Builder as TempFileBuilder;
1414

1515
use std::error::Error;
16-
use std::fs::File;
16+
use std::fs::{self, File};
1717
use std::io::{self, Write};
1818
use std::path::{Path, PathBuf};
1919

@@ -276,29 +276,34 @@ impl<'a> ArArchiveBuilder<'a> {
276276
// This prevents programs (including rustc) from attempting to read a partial archive.
277277
// It also enables writing an archive with the same filename as a dependency on Windows as
278278
// required by a test.
279-
let mut archive_tmpfile = TempFileBuilder::new()
279+
// The tempfile crate currently uses 0o600 as mode for the temporary files and directories
280+
// it creates. We need it to be the default mode for back compat reasons however. (See
281+
// #107495) To handle this we are telling tempfile to create a temporary directory instead
282+
// and then inside this directory create a file using File::create.
283+
let archive_tmpdir = TempFileBuilder::new()
280284
.suffix(".temp-archive")
281-
.tempfile_in(output.parent().unwrap_or_else(|| Path::new("")))
282-
.map_err(|err| io_error_context("couldn't create a temp file", err))?;
283-
284-
write_archive_to_stream(
285-
archive_tmpfile.as_file_mut(),
286-
&entries,
287-
true,
288-
archive_kind,
289-
true,
290-
false,
291-
)?;
285+
.tempdir_in(output.parent().unwrap_or_else(|| Path::new("")))
286+
.map_err(|err| {
287+
io_error_context("couldn't create a directory for the temp file", err)
288+
})?;
289+
let archive_tmpfile_path = archive_tmpdir.path().join("tmp.a");
290+
let mut archive_tmpfile = File::create_new(&archive_tmpfile_path)
291+
.map_err(|err| io_error_context("couldn't create the temp file", err))?;
292+
293+
write_archive_to_stream(&mut archive_tmpfile, &entries, true, archive_kind, true, false)?;
294+
drop(archive_tmpfile);
292295

293296
let any_entries = !entries.is_empty();
294297
drop(entries);
295298
// Drop src_archives to unmap all input archives, which is necessary if we want to write the
296299
// output archive to the same location as an input archive on Windows.
297300
drop(self.src_archives);
298301

299-
archive_tmpfile
300-
.persist(output)
301-
.map_err(|err| io_error_context("failed to rename archive file", err.error))?;
302+
fs::rename(archive_tmpfile_path, output)
303+
.map_err(|err| io_error_context("failed to rename archive file", err))?;
304+
archive_tmpdir
305+
.close()
306+
.map_err(|err| io_error_context("failed to remove temporary directory", err))?;
302307

303308
Ok(any_entries)
304309
}

Diff for: ‎compiler/rustc_hir/src/hir.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1259,7 +1259,7 @@ pub struct Arm<'hir> {
12591259
/// In an `if let`, imagine it as `if (let <pat> = <expr>) { ... }`; in a let-else, it is part of
12601260
/// the desugaring to if-let. Only let-else supports the type annotation at present.
12611261
#[derive(Debug, Clone, Copy, HashStable_Generic)]
1262-
pub struct Let<'hir> {
1262+
pub struct LetExpr<'hir> {
12631263
pub span: Span,
12641264
pub pat: &'hir Pat<'hir>,
12651265
pub ty: Option<&'hir Ty<'hir>>,
@@ -1852,7 +1852,7 @@ pub enum ExprKind<'hir> {
18521852
///
18531853
/// These are not `Local` and only occur as expressions.
18541854
/// The `let Some(x) = foo()` in `if let Some(x) = foo()` is an example of `Let(..)`.
1855-
Let(&'hir Let<'hir>),
1855+
Let(&'hir LetExpr<'hir>),
18561856
/// An `if` block, with an optional else block.
18571857
///
18581858
/// I.e., `if <expr> { <expr> } else { <expr> }`.

Diff for: ‎compiler/rustc_hir/src/intravisit.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -753,7 +753,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
753753
ExprKind::DropTemps(ref subexpression) => {
754754
try_visit!(visitor.visit_expr(subexpression));
755755
}
756-
ExprKind::Let(Let { span: _, pat, ty, init, is_recovered: _ }) => {
756+
ExprKind::Let(LetExpr { span: _, pat, ty, init, is_recovered: _ }) => {
757757
// match the visit order in walk_local
758758
try_visit!(visitor.visit_expr(init));
759759
try_visit!(visitor.visit_pat(pat));

Diff for: ‎compiler/rustc_hir_pretty/src/lib.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1387,7 +1387,7 @@ impl<'a> State<'a> {
13871387
// Print `}`:
13881388
self.bclose_maybe_open(expr.span, true);
13891389
}
1390-
hir::ExprKind::Let(&hir::Let { pat, ty, init, .. }) => {
1390+
hir::ExprKind::Let(&hir::LetExpr { pat, ty, init, .. }) => {
13911391
self.print_let(pat, ty, init);
13921392
}
13931393
hir::ExprKind::If(test, blk, elseopt) => {

Diff for: ‎compiler/rustc_hir_typeck/src/_match.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -317,7 +317,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
317317
err.note("`if` expressions without `else` evaluate to `()`");
318318
err.help("consider adding an `else` block that evaluates to the expected type");
319319
*error = true;
320-
if let ExprKind::Let(hir::Let { span, pat, init, .. }) = cond_expr.kind
320+
if let ExprKind::Let(hir::LetExpr { span, pat, init, .. }) = cond_expr.kind
321321
&& let ExprKind::Block(block, _) = then_expr.kind
322322
// Refutability checks occur on the MIR, so we approximate it here by checking
323323
// if we have an enum with a single variant or a struct in the pattern.

Diff for: ‎compiler/rustc_hir_typeck/src/expr.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -1261,7 +1261,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
12611261
}
12621262
}
12631263

1264-
pub(super) fn check_expr_let(&self, let_expr: &'tcx hir::Let<'tcx>, hir_id: HirId) -> Ty<'tcx> {
1264+
pub(super) fn check_expr_let(
1265+
&self,
1266+
let_expr: &'tcx hir::LetExpr<'tcx>,
1267+
hir_id: HirId,
1268+
) -> Ty<'tcx> {
12651269
// for let statements, this is done in check_stmt
12661270
let init = let_expr.init;
12671271
self.warn_if_unreachable(init.hir_id, init.span, "block in `let` expression");

Diff for: ‎compiler/rustc_hir_typeck/src/expr_use_visitor.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -245,7 +245,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
245245
}
246246
}
247247

248-
hir::ExprKind::Let(hir::Let { pat, init, .. }) => {
248+
hir::ExprKind::Let(hir::LetExpr { pat, init, .. }) => {
249249
self.walk_local(init, pat, None, |t| t.borrow_expr(init, ty::ImmBorrow))
250250
}
251251

Diff for: ‎compiler/rustc_hir_typeck/src/gather_locals.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ impl<'a> DeclOrigin<'a> {
2929
}
3030
}
3131

32-
/// A declaration is an abstraction of [hir::Local] and [hir::Let].
32+
/// A declaration is an abstraction of [hir::Local] and [hir::LetExpr].
3333
///
3434
/// It must have a hir_id, as this is how we connect gather_locals to the check functions.
3535
pub(super) struct Declaration<'a> {
@@ -48,9 +48,9 @@ impl<'a> From<&'a hir::Local<'a>> for Declaration<'a> {
4848
}
4949
}
5050

51-
impl<'a> From<(&'a hir::Let<'a>, hir::HirId)> for Declaration<'a> {
52-
fn from((let_expr, hir_id): (&'a hir::Let<'a>, hir::HirId)) -> Self {
53-
let hir::Let { pat, ty, span, init, is_recovered: _ } = *let_expr;
51+
impl<'a> From<(&'a hir::LetExpr<'a>, hir::HirId)> for Declaration<'a> {
52+
fn from((let_expr, hir_id): (&'a hir::LetExpr<'a>, hir::HirId)) -> Self {
53+
let hir::LetExpr { pat, ty, span, init, is_recovered: _ } = *let_expr;
5454
Declaration { hir_id, pat, ty, span, init: Some(init), origin: DeclOrigin::LetExpr }
5555
}
5656
}

Diff for: ‎compiler/rustc_mir_transform/src/coverage/counters.rs

+4-35
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,12 @@
1+
use std::fmt::{self, Debug};
2+
13
use rustc_data_structures::captures::Captures;
24
use rustc_data_structures::fx::FxHashMap;
35
use rustc_data_structures::graph::WithNumNodes;
4-
use rustc_index::bit_set::BitSet;
56
use rustc_index::IndexVec;
6-
use rustc_middle::mir::coverage::*;
7+
use rustc_middle::mir::coverage::{CounterId, CovTerm, Expression, ExpressionId, Op};
78

8-
use super::graph::{BasicCoverageBlock, CoverageGraph, TraverseCoverageGraphWithLoops};
9-
10-
use std::fmt::{self, Debug};
9+
use crate::coverage::graph::{BasicCoverageBlock, CoverageGraph, TraverseCoverageGraphWithLoops};
1110

1211
/// The coverage counter or counter expression associated with a particular
1312
/// BCB node or BCB edge.
@@ -18,10 +17,6 @@ pub(super) enum BcbCounter {
1817
}
1918

2019
impl BcbCounter {
21-
fn is_expression(&self) -> bool {
22-
matches!(self, Self::Expression { .. })
23-
}
24-
2520
pub(super) fn as_term(&self) -> CovTerm {
2621
match *self {
2722
BcbCounter::Counter { id, .. } => CovTerm::Counter(id),
@@ -60,10 +55,6 @@ pub(super) struct CoverageCounters {
6055
/// We currently don't iterate over this map, but if we do in the future,
6156
/// switch it back to `FxIndexMap` to avoid query stability hazards.
6257
bcb_edge_counters: FxHashMap<(BasicCoverageBlock, BasicCoverageBlock), BcbCounter>,
63-
/// Tracks which BCBs have a counter associated with some incoming edge.
64-
/// Only used by assertions, to verify that BCBs with incoming edge
65-
/// counters do not have their own physical counters (expressions are allowed).
66-
bcb_has_incoming_edge_counters: BitSet<BasicCoverageBlock>,
6758
/// Table of expression data, associating each expression ID with its
6859
/// corresponding operator (+ or -) and its LHS/RHS operands.
6960
expressions: IndexVec<ExpressionId, Expression>,
@@ -83,7 +74,6 @@ impl CoverageCounters {
8374
counter_increment_sites: IndexVec::new(),
8475
bcb_counters: IndexVec::from_elem_n(None, num_bcbs),
8576
bcb_edge_counters: FxHashMap::default(),
86-
bcb_has_incoming_edge_counters: BitSet::new_empty(num_bcbs),
8777
expressions: IndexVec::new(),
8878
};
8979

@@ -122,14 +112,6 @@ impl CoverageCounters {
122112
}
123113

124114
fn set_bcb_counter(&mut self, bcb: BasicCoverageBlock, counter_kind: BcbCounter) -> BcbCounter {
125-
assert!(
126-
// If the BCB has an edge counter (to be injected into a new `BasicBlock`), it can also
127-
// have an expression (to be injected into an existing `BasicBlock` represented by this
128-
// `BasicCoverageBlock`).
129-
counter_kind.is_expression() || !self.bcb_has_incoming_edge_counters.contains(bcb),
130-
"attempt to add a `Counter` to a BCB target with existing incoming edge counters"
131-
);
132-
133115
if let Some(replaced) = self.bcb_counters[bcb].replace(counter_kind) {
134116
bug!(
135117
"attempt to set a BasicCoverageBlock coverage counter more than once; \
@@ -146,19 +128,6 @@ impl CoverageCounters {
146128
to_bcb: BasicCoverageBlock,
147129
counter_kind: BcbCounter,
148130
) -> BcbCounter {
149-
// If the BCB has an edge counter (to be injected into a new `BasicBlock`), it can also
150-
// have an expression (to be injected into an existing `BasicBlock` represented by this
151-
// `BasicCoverageBlock`).
152-
if let Some(node_counter) = self.bcb_counter(to_bcb)
153-
&& !node_counter.is_expression()
154-
{
155-
bug!(
156-
"attempt to add an incoming edge counter from {from_bcb:?} \
157-
when the target BCB already has {node_counter:?}"
158-
);
159-
}
160-
161-
self.bcb_has_incoming_edge_counters.insert(to_bcb);
162131
if let Some(replaced) = self.bcb_edge_counters.insert((from_bcb, to_bcb), counter_kind) {
163132
bug!(
164133
"attempt to set an edge counter more than once; from_bcb: \

Diff for: ‎compiler/rustc_pattern_analysis/Cargo.toml

+4
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,10 @@ smallvec = { version = "1.8.1", features = ["union"] }
2222
tracing = "0.1"
2323
# tidy-alphabetical-end
2424

25+
[dev-dependencies]
26+
tracing-subscriber = { version = "0.3.3", default-features = false, features = ["fmt", "env-filter", "ansi"] }
27+
tracing-tree = "0.2.0"
28+
2529
[features]
2630
default = ["rustc"]
2731
rustc = [

Diff for: ‎compiler/rustc_pattern_analysis/src/constructor.rs

+75
Original file line numberDiff line numberDiff line change
@@ -819,6 +819,81 @@ impl<Cx: PatCx> Constructor<Cx> {
819819
}
820820
})
821821
}
822+
823+
pub(crate) fn fmt_fields(
824+
&self,
825+
f: &mut fmt::Formatter<'_>,
826+
ty: &Cx::Ty,
827+
mut fields: impl Iterator<Item = impl fmt::Debug>,
828+
) -> fmt::Result {
829+
let mut first = true;
830+
let mut start_or_continue = |s| {
831+
if first {
832+
first = false;
833+
""
834+
} else {
835+
s
836+
}
837+
};
838+
let mut start_or_comma = || start_or_continue(", ");
839+
840+
match self {
841+
Struct | Variant(_) | UnionField => {
842+
Cx::write_variant_name(f, self, ty)?;
843+
// Without `cx`, we can't know which field corresponds to which, so we can't
844+
// get the names of the fields. Instead we just display everything as a tuple
845+
// struct, which should be good enough.
846+
write!(f, "(")?;
847+
for p in fields {
848+
write!(f, "{}{:?}", start_or_comma(), p)?;
849+
}
850+
write!(f, ")")?;
851+
}
852+
// Note: given the expansion of `&str` patterns done in `expand_pattern`, we should
853+
// be careful to detect strings here. However a string literal pattern will never
854+
// be reported as a non-exhaustiveness witness, so we can ignore this issue.
855+
Ref => {
856+
write!(f, "&{:?}", &fields.next().unwrap())?;
857+
}
858+
Slice(slice) => {
859+
write!(f, "[")?;
860+
match slice.kind {
861+
SliceKind::FixedLen(_) => {
862+
for p in fields {
863+
write!(f, "{}{:?}", start_or_comma(), p)?;
864+
}
865+
}
866+
SliceKind::VarLen(prefix_len, _) => {
867+
for p in fields.by_ref().take(prefix_len) {
868+
write!(f, "{}{:?}", start_or_comma(), p)?;
869+
}
870+
write!(f, "{}..", start_or_comma())?;
871+
for p in fields {
872+
write!(f, "{}{:?}", start_or_comma(), p)?;
873+
}
874+
}
875+
}
876+
write!(f, "]")?;
877+
}
878+
Bool(b) => write!(f, "{b}")?,
879+
// Best-effort, will render signed ranges incorrectly
880+
IntRange(range) => write!(f, "{range:?}")?,
881+
F32Range(lo, hi, end) => write!(f, "{lo}{end}{hi}")?,
882+
F64Range(lo, hi, end) => write!(f, "{lo}{end}{hi}")?,
883+
Str(value) => write!(f, "{value:?}")?,
884+
Opaque(..) => write!(f, "<constant pattern>")?,
885+
Or => {
886+
for pat in fields {
887+
write!(f, "{}{:?}", start_or_continue(" | "), pat)?;
888+
}
889+
}
890+
Never => write!(f, "!")?,
891+
Wildcard | Missing | NonExhaustive | Hidden | PrivateUninhabited => {
892+
write!(f, "_ : {:?}", ty)?
893+
}
894+
}
895+
Ok(())
896+
}
822897
}
823898

824899
#[derive(Debug, Clone, Copy)]

Diff for: ‎compiler/rustc_pattern_analysis/src/lib.rs

+8-1
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,12 @@ pub mod index {
4949
}
5050
}
5151

52+
impl<V> FromIterator<V> for IdxContainer<usize, V> {
53+
fn from_iter<T: IntoIterator<Item = V>>(iter: T) -> Self {
54+
Self(iter.into_iter().enumerate().collect())
55+
}
56+
}
57+
5258
#[derive(Debug)]
5359
pub struct IdxSet<T>(pub rustc_hash::FxHashSet<T>);
5460
impl<T: Idx> IdxSet<T> {
@@ -120,7 +126,8 @@ pub trait PatCx: Sized + fmt::Debug {
120126
/// `DeconstructedPat`. Only invoqued when `pat.ctor()` is `Struct | Variant(_) | UnionField`.
121127
fn write_variant_name(
122128
f: &mut fmt::Formatter<'_>,
123-
pat: &crate::pat::DeconstructedPat<Self>,
129+
ctor: &crate::constructor::Constructor<Self>,
130+
ty: &Self::Ty,
124131
) -> fmt::Result;
125132

126133
/// Raise a bug.

0 commit comments

Comments
 (0)