Skip to content

Commit 8243436

Browse files
committed
Store Place instead of PlaceBuilder in MatchPair
1 parent fc05ee0 commit 8243436

File tree

3 files changed

+33
-28
lines changed

3 files changed

+33
-28
lines changed

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

+11-7
Original file line numberDiff line numberDiff line change
@@ -1122,7 +1122,10 @@ impl<'pat, 'tcx> TestCase<'pat, 'tcx> {
11221122
#[derive(Debug, Clone)]
11231123
pub(crate) struct MatchPair<'pat, 'tcx> {
11241124
/// This place...
1125-
place: PlaceBuilder<'tcx>,
1125+
// This can be `None` if it referred to a non-captured place in a closure.
1126+
// Invariant: place.is_none() => test_case is Irrefutable
1127+
// In other words this must be `Some(_)` after simplification.
1128+
place: Option<Place<'tcx>>,
11261129

11271130
/// ... must pass this test...
11281131
// Invariant: after creation and simplification in `Candidate::new()`, this must not be
@@ -1605,11 +1608,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
16051608
fn pick_test(
16061609
&mut self,
16071610
candidates: &mut [&mut Candidate<'_, 'tcx>],
1608-
) -> (PlaceBuilder<'tcx>, Test<'tcx>) {
1611+
) -> (Place<'tcx>, Test<'tcx>) {
16091612
// Extract the match-pair from the highest priority candidate
16101613
let match_pair = &candidates.first().unwrap().match_pairs[0];
16111614
let test = self.test(match_pair);
1612-
let match_place = match_pair.place.clone();
1615+
// Unwrap is ok after simplification.
1616+
let match_place = match_pair.place.unwrap();
16131617
debug!(?test, ?match_pair);
16141618

16151619
(match_place, test)
@@ -1650,7 +1654,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
16501654
/// - candidate 1 becomes `[y @ false]` since we know that `x` was `false`.
16511655
fn sort_candidates<'b, 'c, 'pat>(
16521656
&mut self,
1653-
match_place: &PlaceBuilder<'tcx>,
1657+
match_place: Place<'tcx>,
16541658
test: &Test<'tcx>,
16551659
mut candidates: &'b mut [&'c mut Candidate<'pat, 'tcx>],
16561660
) -> (
@@ -1668,7 +1672,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
16681672
// sorting.
16691673
while let Some(candidate) = candidates.first_mut() {
16701674
let Some(branch) =
1671-
self.sort_candidate(&match_place, test, candidate, &target_candidates)
1675+
self.sort_candidate(match_place, test, candidate, &target_candidates)
16721676
else {
16731677
break;
16741678
};
@@ -1796,7 +1800,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
17961800
// For each of the N possible test outcomes, build the vector of candidates that applies if
17971801
// the test has that particular outcome.
17981802
let (remaining_candidates, target_candidates) =
1799-
self.sort_candidates(&match_place, &test, candidates);
1803+
self.sort_candidates(match_place, &test, candidates);
18001804

18011805
// The block that we should branch to if none of the
18021806
// `target_candidates` match.
@@ -1836,7 +1840,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
18361840
scrutinee_span,
18371841
start_block,
18381842
remainder_start,
1839-
&match_place,
1843+
match_place,
18401844
&test,
18411845
target_blocks,
18421846
);

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

+9-8
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@
55
// identify what tests are needed, perform the tests, and then filter
66
// the candidates based on the result.
77

8-
use crate::build::expr::as_place::PlaceBuilder;
98
use crate::build::matches::{Candidate, MatchPair, Test, TestBranch, TestCase, TestKind};
109
use crate::build::Builder;
1110
use rustc_data_structures::fx::FxIndexMap;
@@ -55,18 +54,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
5554
Test { span: match_pair.pattern.span, kind }
5655
}
5756

58-
#[instrument(skip(self, target_blocks, place_builder), level = "debug")]
57+
#[instrument(skip(self, target_blocks, place), level = "debug")]
5958
pub(super) fn perform_test(
6059
&mut self,
6160
match_start_span: Span,
6261
scrutinee_span: Span,
6362
block: BasicBlock,
6463
otherwise_block: BasicBlock,
65-
place_builder: &PlaceBuilder<'tcx>,
64+
place: Place<'tcx>,
6665
test: &Test<'tcx>,
6766
target_blocks: FxIndexMap<TestBranch<'tcx>, BasicBlock>,
6867
) {
69-
let place = place_builder.to_place(self);
7068
let place_ty = place.ty(&self.local_decls, self.tcx);
7169
debug!(?place, ?place_ty);
7270
let target_block = |branch| target_blocks.get(&branch).copied().unwrap_or(otherwise_block);
@@ -475,7 +473,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
475473
/// tighter match code if we do something a bit different.
476474
pub(super) fn sort_candidate(
477475
&mut self,
478-
test_place: &PlaceBuilder<'tcx>,
476+
test_place: Place<'tcx>,
479477
test: &Test<'tcx>,
480478
candidate: &mut Candidate<'_, 'tcx>,
481479
sorted_candidates: &FxIndexMap<TestBranch<'tcx>, Vec<&mut Candidate<'_, 'tcx>>>,
@@ -486,8 +484,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
486484
// than one, but it'd be very unusual to have two sides that
487485
// both require tests; you'd expect one side to be simplified
488486
// away.)
489-
let (match_pair_index, match_pair) =
490-
candidate.match_pairs.iter().enumerate().find(|&(_, mp)| mp.place == *test_place)?;
487+
let (match_pair_index, match_pair) = candidate
488+
.match_pairs
489+
.iter()
490+
.enumerate()
491+
.find(|&(_, mp)| mp.place == Some(test_place))?;
491492

492493
let fully_matched;
493494
let ret = match (&test.kind, &match_pair.test_case) {
@@ -521,7 +522,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
521522
candidate
522523
.match_pairs
523524
.iter()
524-
.any(|mp| mp.place == *test_place && is_covering_range(&mp.test_case))
525+
.any(|mp| mp.place == Some(test_place) && is_covering_range(&mp.test_case))
525526
};
526527
if sorted_candidates
527528
.get(&TestBranch::Failure)

compiler/rustc_mir_build/src/build/matches/util.rs

+13-13
Original file line numberDiff line numberDiff line change
@@ -119,6 +119,7 @@ impl<'pat, 'tcx> MatchPair<'pat, 'tcx> {
119119
place_builder = place_builder.project(ProjectionElem::OpaqueCast(pattern.ty));
120120
}
121121

122+
let place = place_builder.try_to_place(cx);
122123
let default_irrefutable = || TestCase::Irrefutable { binding: None, ascription: None };
123124
let mut subpairs = Vec::new();
124125
let test_case = match pattern.kind {
@@ -146,13 +147,13 @@ impl<'pat, 'tcx> MatchPair<'pat, 'tcx> {
146147
..
147148
} => {
148149
// Apply the type ascription to the value at `match_pair.place`
149-
let ascription = place_builder.try_to_place(cx).map(|source| super::Ascription {
150+
let ascription = place.map(|source| super::Ascription {
150151
annotation: annotation.clone(),
151152
source,
152153
variance,
153154
});
154155

155-
subpairs.push(MatchPair::new(place_builder.clone(), subpattern, cx));
156+
subpairs.push(MatchPair::new(place_builder, subpattern, cx));
156157
TestCase::Irrefutable { ascription, binding: None }
157158
}
158159

@@ -165,7 +166,7 @@ impl<'pat, 'tcx> MatchPair<'pat, 'tcx> {
165166
ref subpattern,
166167
is_primary: _,
167168
} => {
168-
let binding = place_builder.try_to_place(cx).map(|source| super::Binding {
169+
let binding = place.map(|source| super::Binding {
169170
span: pattern.span,
170171
source,
171172
var_id: var,
@@ -174,14 +175,14 @@ impl<'pat, 'tcx> MatchPair<'pat, 'tcx> {
174175

175176
if let Some(subpattern) = subpattern.as_ref() {
176177
// this is the `x @ P` case; have to keep matching against `P` now
177-
subpairs.push(MatchPair::new(place_builder.clone(), subpattern, cx));
178+
subpairs.push(MatchPair::new(place_builder, subpattern, cx));
178179
}
179180
TestCase::Irrefutable { ascription: None, binding }
180181
}
181182

182183
PatKind::InlineConstant { subpattern: ref pattern, def, .. } => {
183184
// Apply a type ascription for the inline constant to the value at `match_pair.place`
184-
let ascription = place_builder.try_to_place(cx).map(|source| {
185+
let ascription = place.map(|source| {
185186
let span = pattern.span;
186187
let parent_id = cx.tcx.typeck_root_def_id(cx.def_id.to_def_id());
187188
let args = ty::InlineConstArgs::new(
@@ -207,7 +208,7 @@ impl<'pat, 'tcx> MatchPair<'pat, 'tcx> {
207208
super::Ascription { annotation, source, variance: ty::Contravariant }
208209
});
209210

210-
subpairs.push(MatchPair::new(place_builder.clone(), pattern, cx));
211+
subpairs.push(MatchPair::new(place_builder, pattern, cx));
211212
TestCase::Irrefutable { ascription, binding: None }
212213
}
213214

@@ -229,7 +230,7 @@ impl<'pat, 'tcx> MatchPair<'pat, 'tcx> {
229230
}
230231

231232
PatKind::Variant { adt_def, variant_index, args, ref subpatterns } => {
232-
let downcast_place = place_builder.clone().downcast(adt_def, variant_index); // `(x as Variant)`
233+
let downcast_place = place_builder.downcast(adt_def, variant_index); // `(x as Variant)`
233234
subpairs = cx.field_match_pairs(downcast_place, subpatterns);
234235

235236
let irrefutable = adt_def.variants().iter_enumerated().all(|(i, v)| {
@@ -251,18 +252,17 @@ impl<'pat, 'tcx> MatchPair<'pat, 'tcx> {
251252
}
252253

253254
PatKind::Leaf { ref subpatterns } => {
254-
subpairs = cx.field_match_pairs(place_builder.clone(), subpatterns);
255+
subpairs = cx.field_match_pairs(place_builder, subpatterns);
255256
default_irrefutable()
256257
}
257258

258259
PatKind::Deref { ref subpattern } => {
259-
let place_builder = place_builder.clone().deref();
260-
subpairs.push(MatchPair::new(place_builder, subpattern, cx));
260+
subpairs.push(MatchPair::new(place_builder.deref(), subpattern, cx));
261261
default_irrefutable()
262262
}
263263
};
264264

265-
MatchPair { place: place_builder, test_case, subpairs, pattern }
265+
MatchPair { place, test_case, subpairs, pattern }
266266
}
267267

268268
/// Whether this recursively contains no bindings or ascriptions.
@@ -314,8 +314,8 @@ impl<'a, 'b, 'tcx> FakeBorrowCollector<'a, 'b, 'tcx> {
314314
}
315315
} else {
316316
// Insert a Shallow borrow of any place that is switched on.
317-
if let Some(resolved_place) = match_pair.place.try_to_place(self.cx) {
318-
self.fake_borrows.insert(resolved_place);
317+
if let Some(place) = match_pair.place {
318+
self.fake_borrows.insert(place);
319319
}
320320

321321
for subpair in &match_pair.subpairs {

0 commit comments

Comments
 (0)