bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Inline the constructor-specific split functions

Browse source
This commit is contained in:
Nadrieril 2020-12-20 14:22:53 +00:00
parent 3141f2d78c
commit 8b38b6859a
1 changed files with 19 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

53
compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs
View file

@ -183,14 +183,6 @@ impl IntRange {
Pat { ty, span: DUMMY_SP, kind: Box::new(kind) } Pat { ty, span: DUMMY_SP, kind: Box::new(kind) }
} }
/// Split this range, as described at the top of the file.
fn split<'p, 'tcx>(&self, pcx: PatCtxt<'_, 'p, 'tcx>) -> SmallVec<[Constructor<'tcx>; 1]> {
let mut split_range = SplitIntRange::new(self.clone());
let intranges = pcx.matrix.head_ctors(pcx.cx).filter_map(|ctor| ctor.as_int_range());
split_range.split(intranges.cloned());
split_range.iter().map(IntRange).collect()
}
/// Lint on likely incorrect range patterns (#63987) /// Lint on likely incorrect range patterns (#63987)
pub(super) fn lint_overlapping_range_endpoints(&self, pcx: PatCtxt<'_, '_, '_>, hir_id: HirId) { pub(super) fn lint_overlapping_range_endpoints(&self, pcx: PatCtxt<'_, '_, '_>, hir_id: HirId) {
if self.is_singleton() { if self.is_singleton() {
@ -403,19 +395,6 @@ impl Slice {
self.kind.arity() self.kind.arity()
} }
/// Split this slice, as described at the top of the file.
fn split<'p, 'tcx>(self, pcx: PatCtxt<'_, 'p, 'tcx>) -> SmallVec<[Constructor<'tcx>; 1]> {
let (self_prefix, self_suffix) = match self.kind {
VarLen(self_prefix, self_suffix) => (self_prefix, self_suffix),
_ => return smallvec![Slice(self)],
};
let mut split_self = SplitVarLenSlice::new(self_prefix, self_suffix, self.array_len);
let slices = pcx.matrix.head_ctors(pcx.cx).filter_map(|c| c.as_slice()).map(|s| s.kind);
split_self.split(slices);
split_self.iter().map(Slice).collect()
}
/// See `Constructor::is_covered_by` /// See `Constructor::is_covered_by`
fn is_covered_by(self, other: Self) -> bool { fn is_covered_by(self, other: Self) -> bool {
other.kind.covers_length(self.arity()) other.kind.covers_length(self.arity())
@ -680,26 +659,32 @@ impl<'tcx> Constructor<'tcx> {
debug!("Constructor::split({:#?}, {:#?})", self, pcx.matrix); debug!("Constructor::split({:#?}, {:#?})", self, pcx.matrix);
match self { match self {
Wildcard => Constructor::split_wildcard(pcx), Wildcard => {
let mut split_wildcard = SplitWildcard::new(pcx);
split_wildcard.split(pcx);
split_wildcard.into_ctors(pcx)
}
// Fast-track if the range is trivial. In particular, we don't do the overlapping // Fast-track if the range is trivial. In particular, we don't do the overlapping
// ranges check. // ranges check.
IntRange(ctor_range) if !ctor_range.is_singleton() => ctor_range.split(pcx), IntRange(ctor_range) if !ctor_range.is_singleton() => {
Slice(slice @ Slice { kind: VarLen(..), .. }) => slice.split(pcx), let mut split_range = SplitIntRange::new(ctor_range.clone());
let intranges =
pcx.matrix.head_ctors(pcx.cx).filter_map(|ctor| ctor.as_int_range());
split_range.split(intranges.cloned());
split_range.iter().map(IntRange).collect()
}
&Slice(Slice { kind: VarLen(self_prefix, self_suffix), array_len }) => {
let mut split_self = SplitVarLenSlice::new(self_prefix, self_suffix, array_len);
let slices =
pcx.matrix.head_ctors(pcx.cx).filter_map(|c| c.as_slice()).map(|s| s.kind);
split_self.split(slices);
split_self.iter().map(Slice).collect()
}
// Any other constructor can be used unchanged. // Any other constructor can be used unchanged.
_ => smallvec![self.clone()], _ => smallvec![self.clone()],
} }
} }
/// For wildcards, there are two groups of constructors: there are the constructors actually
/// present in the matrix (`head_ctors`), and the constructors not present (`missing_ctors`).
/// Two constructors that are not in the matrix will either both be caught (by a wildcard), or
/// both not be caught. Therefore we can keep the missing constructors grouped together.
fn split_wildcard<'p>(pcx: PatCtxt<'_, 'p, 'tcx>) -> SmallVec<[Self; 1]> {
let mut split_wildcard = SplitWildcard::new(pcx);
split_wildcard.split(pcx);
split_wildcard.into_ctors(pcx)
}
/// Returns whether `self` is covered by `other`, i.e. whether `self` is a subset of `other`. /// Returns whether `self` is covered by `other`, i.e. whether `self` is a subset of `other`.
/// For the simple cases, this is simply checking for equality. For the "grouped" constructors, /// For the simple cases, this is simply checking for equality. For the "grouped" constructors,
/// this checks for inclusion. /// this checks for inclusion.