a37fa37281
Add the `min_exhaustive_patterns` feature gate ## Motivation Pattern-matching on empty types is tricky around unsafe code. For that reason, current stable rust conservatively requires arms for empty types in all but the simplest case. It has long been the intention to allow omitting empty arms when it's safe to do so. The [`exhaustive_patterns`](https://github.com/rust-lang/rust/issues/51085) feature allows the omission of all empty arms, but hasn't been stabilized because that was deemed dangerous around unsafe code. ## Proposal This feature aims to stabilize an uncontroversial subset of exhaustive_patterns. Namely: when `min_exhaustive_patterns` is enabled and the data we're matching on is guaranteed to be valid by rust's operational semantics, then we allow empty arms to be omitted. E.g.: ```rust let x: Result<T, !> = foo(); match x { // ok Ok(y) => ..., } let Ok(y) = x; // ok ``` If the place is not guaranteed to hold valid data (namely ptr dereferences, ref dereferences (conservatively) and union field accesses), then we keep stable behavior i.e. we (usually) require arms for the empty cases. ```rust unsafe { let ptr: *const Result<u32, !> = ...; match *ptr { Ok(x) => { ... } Err(_) => { ... } // still required } } let foo: Result<u32, &!> = ...; match foo { Ok(x) => { ... } Err(&_) => { ... } // still required because of the dereference } unsafe { let ptr: *const ! = ...; match *ptr {} // already allowed on stable } ``` Note that we conservatively consider that a valid reference can point to invalid data, hence we don't allow arms of type `&!` and similar cases to be omitted. This could eventually change depending on [opsem decisions](https://github.com/rust-lang/unsafe-code-guidelines/issues/413). Whenever opsem is undecided on a case, we conservatively keep today's stable behavior. I proposed this behavior in the [`never_patterns`](https://github.com/rust-lang/rust/issues/118155) feature gate but it makes sense on its own and could be stabilized more quickly. The two proposals nicely complement each other. ## Unresolved Questions Part of the question is whether this requires an RFC. I'd argue this doesn't need one since there is no design question beyond the intent to omit unreachable patterns, but I'm aware the problem can be framed in ways that require design (I'm thinking of the [original never patterns proposal](https://smallcultfollowing.com/babysteps/blog/2018/08/13/never-patterns-exhaustive-matching-and-uninhabited-types-oh-my/), which would frame this behavior as "auto-nevering" happening). EDIT: I initially proposed a future-compatibility lint as part of this feature, I don't anymore.
946 lines
43 KiB
Rust
946 lines
43 KiB
Rust
use smallvec::SmallVec;
|
|
use std::fmt;
|
|
use std::iter::once;
|
|
|
|
use rustc_arena::{DroplessArena, TypedArena};
|
|
use rustc_hir::def_id::DefId;
|
|
use rustc_hir::HirId;
|
|
use rustc_index::{Idx, IndexVec};
|
|
use rustc_middle::middle::stability::EvalResult;
|
|
use rustc_middle::mir::interpret::Scalar;
|
|
use rustc_middle::mir::{self, Const};
|
|
use rustc_middle::thir::{FieldPat, Pat, PatKind, PatRange, PatRangeBoundary};
|
|
use rustc_middle::ty::layout::IntegerExt;
|
|
use rustc_middle::ty::{self, OpaqueTypeKey, Ty, TyCtxt, TypeVisitableExt, VariantDef};
|
|
use rustc_session::lint;
|
|
use rustc_span::{ErrorGuaranteed, Span, DUMMY_SP};
|
|
use rustc_target::abi::{FieldIdx, Integer, VariantIdx, FIRST_VARIANT};
|
|
|
|
use crate::constructor::{
|
|
IntRange, MaybeInfiniteInt, OpaqueId, RangeEnd, Slice, SliceKind, VariantVisibility,
|
|
};
|
|
use crate::{errors, Captures, TypeCx};
|
|
|
|
use crate::constructor::Constructor::*;
|
|
|
|
// Re-export rustc-specific versions of all these types.
|
|
pub type Constructor<'p, 'tcx> = crate::constructor::Constructor<RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub type ConstructorSet<'p, 'tcx> =
|
|
crate::constructor::ConstructorSet<RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub type DeconstructedPat<'p, 'tcx> =
|
|
crate::pat::DeconstructedPat<'p, RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub type MatchArm<'p, 'tcx> = crate::MatchArm<'p, RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub type MatchCtxt<'a, 'p, 'tcx> = crate::MatchCtxt<'a, RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub(crate) type PlaceCtxt<'a, 'p, 'tcx> =
|
|
crate::usefulness::PlaceCtxt<'a, RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub(crate) type SplitConstructorSet<'p, 'tcx> =
|
|
crate::constructor::SplitConstructorSet<RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub type Usefulness<'p, 'tcx> = crate::usefulness::Usefulness<'p, RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub type UsefulnessReport<'p, 'tcx> =
|
|
crate::usefulness::UsefulnessReport<'p, RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
pub type WitnessPat<'p, 'tcx> = crate::pat::WitnessPat<RustcMatchCheckCtxt<'p, 'tcx>>;
|
|
|
|
/// A type which has gone through `cx.reveal_opaque_ty`, i.e. if it was opaque it was replaced by
|
|
/// the hidden type if allowed in the current body. This ensures we consistently inspect the hidden
|
|
/// types when we should.
|
|
///
|
|
/// Use `.inner()` or deref to get to the `Ty<'tcx>`.
|
|
#[repr(transparent)]
|
|
#[derive(derivative::Derivative)]
|
|
#[derive(Clone, Copy)]
|
|
#[derivative(Debug = "transparent")]
|
|
pub struct RevealedTy<'tcx>(Ty<'tcx>);
|
|
|
|
impl<'tcx> std::ops::Deref for RevealedTy<'tcx> {
|
|
type Target = Ty<'tcx>;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
impl<'tcx> RevealedTy<'tcx> {
|
|
pub fn inner(self) -> Ty<'tcx> {
|
|
self.0
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct RustcMatchCheckCtxt<'p, 'tcx> {
|
|
pub tcx: TyCtxt<'tcx>,
|
|
pub typeck_results: &'tcx ty::TypeckResults<'tcx>,
|
|
/// The module in which the match occurs. This is necessary for
|
|
/// checking inhabited-ness of types because whether a type is (visibly)
|
|
/// inhabited can depend on whether it was defined in the current module or
|
|
/// not. E.g., `struct Foo { _private: ! }` cannot be seen to be empty
|
|
/// outside its module and should not be matchable with an empty match statement.
|
|
pub module: DefId,
|
|
pub param_env: ty::ParamEnv<'tcx>,
|
|
/// To allocate lowered patterns
|
|
pub pattern_arena: &'p TypedArena<DeconstructedPat<'p, 'tcx>>,
|
|
/// To allocate the result of `self.ctor_sub_tys()`
|
|
pub dropless_arena: &'p DroplessArena,
|
|
/// Lint level at the match.
|
|
pub match_lint_level: HirId,
|
|
/// The span of the whole match, if applicable.
|
|
pub whole_match_span: Option<Span>,
|
|
/// Span of the scrutinee.
|
|
pub scrut_span: Span,
|
|
/// Only produce `NON_EXHAUSTIVE_OMITTED_PATTERNS` lint on refutable patterns.
|
|
pub refutable: bool,
|
|
/// Whether the data at the scrutinee is known to be valid. This is false if the scrutinee comes
|
|
/// from a union field, a pointer deref, or a reference deref (pending opsem decisions).
|
|
pub known_valid_scrutinee: bool,
|
|
}
|
|
|
|
impl<'p, 'tcx> fmt::Debug for RustcMatchCheckCtxt<'p, 'tcx> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("RustcMatchCheckCtxt").finish()
|
|
}
|
|
}
|
|
|
|
impl<'p, 'tcx> RustcMatchCheckCtxt<'p, 'tcx> {
|
|
/// Type inference occasionally gives us opaque types in places where corresponding patterns
|
|
/// have more specific types. To avoid inconsistencies as well as detect opaque uninhabited
|
|
/// types, we use the corresponding concrete type if possible.
|
|
#[inline]
|
|
pub fn reveal_opaque_ty(&self, ty: Ty<'tcx>) -> RevealedTy<'tcx> {
|
|
fn reveal_inner<'tcx>(
|
|
cx: &RustcMatchCheckCtxt<'_, 'tcx>,
|
|
ty: Ty<'tcx>,
|
|
) -> RevealedTy<'tcx> {
|
|
let ty::Alias(ty::Opaque, alias_ty) = *ty.kind() else { bug!() };
|
|
if let Some(local_def_id) = alias_ty.def_id.as_local() {
|
|
let key = ty::OpaqueTypeKey { def_id: local_def_id, args: alias_ty.args };
|
|
if let Some(ty) = cx.reveal_opaque_key(key) {
|
|
return RevealedTy(ty);
|
|
}
|
|
}
|
|
RevealedTy(ty)
|
|
}
|
|
if let ty::Alias(ty::Opaque, _) = ty.kind() {
|
|
reveal_inner(self, ty)
|
|
} else {
|
|
RevealedTy(ty)
|
|
}
|
|
}
|
|
|
|
/// Returns the hidden type corresponding to this key if the body under analysis is allowed to
|
|
/// know it.
|
|
fn reveal_opaque_key(&self, key: OpaqueTypeKey<'tcx>) -> Option<Ty<'tcx>> {
|
|
self.typeck_results.concrete_opaque_types.get(&key).map(|x| x.ty)
|
|
}
|
|
// This can take a non-revealed `Ty` because it reveals opaques itself.
|
|
pub fn is_uninhabited(&self, ty: Ty<'tcx>) -> bool {
|
|
!ty.inhabited_predicate(self.tcx).apply_revealing_opaque(
|
|
self.tcx,
|
|
self.param_env,
|
|
self.module,
|
|
&|key| self.reveal_opaque_key(key),
|
|
)
|
|
}
|
|
|
|
/// Returns whether the given type is an enum from another crate declared `#[non_exhaustive]`.
|
|
pub fn is_foreign_non_exhaustive_enum(&self, ty: RevealedTy<'tcx>) -> bool {
|
|
match ty.kind() {
|
|
ty::Adt(def, ..) => {
|
|
def.is_enum() && def.is_variant_list_non_exhaustive() && !def.did().is_local()
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
/// Whether the range denotes the fictitious values before `isize::MIN` or after
|
|
/// `usize::MAX`/`isize::MAX` (see doc of [`IntRange::split`] for why these exist).
|
|
pub fn is_range_beyond_boundaries(&self, range: &IntRange, ty: RevealedTy<'tcx>) -> bool {
|
|
ty.is_ptr_sized_integral() && {
|
|
// The two invalid ranges are `NegInfinity..isize::MIN` (represented as
|
|
// `NegInfinity..0`), and `{u,i}size::MAX+1..PosInfinity`. `hoist_pat_range_bdy`
|
|
// converts `MAX+1` to `PosInfinity`, and we couldn't have `PosInfinity` in `range.lo`
|
|
// otherwise.
|
|
let lo = self.hoist_pat_range_bdy(range.lo, ty);
|
|
matches!(lo, PatRangeBoundary::PosInfinity)
|
|
|| matches!(range.hi, MaybeInfiniteInt::Finite(0))
|
|
}
|
|
}
|
|
|
|
// In the cases of either a `#[non_exhaustive]` field list or a non-public field, we hide
|
|
// uninhabited fields in order not to reveal the uninhabitedness of the whole variant.
|
|
// This lists the fields we keep along with their types.
|
|
pub(crate) fn list_variant_nonhidden_fields(
|
|
&self,
|
|
ty: RevealedTy<'tcx>,
|
|
variant: &'tcx VariantDef,
|
|
) -> impl Iterator<Item = (FieldIdx, RevealedTy<'tcx>)> + Captures<'p> + Captures<'_> {
|
|
let cx = self;
|
|
let ty::Adt(adt, args) = ty.kind() else { bug!() };
|
|
// Whether we must not match the fields of this variant exhaustively.
|
|
let is_non_exhaustive = variant.is_field_list_non_exhaustive() && !adt.did().is_local();
|
|
|
|
variant.fields.iter().enumerate().filter_map(move |(i, field)| {
|
|
let ty = field.ty(cx.tcx, args);
|
|
// `field.ty()` doesn't normalize after substituting.
|
|
let ty = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
|
|
let is_visible = adt.is_enum() || field.vis.is_accessible_from(cx.module, cx.tcx);
|
|
let is_uninhabited = (cx.tcx.features().exhaustive_patterns
|
|
|| cx.tcx.features().min_exhaustive_patterns)
|
|
&& cx.is_uninhabited(ty);
|
|
|
|
if is_uninhabited && (!is_visible || is_non_exhaustive) {
|
|
None
|
|
} else {
|
|
let ty = cx.reveal_opaque_ty(ty);
|
|
Some((FieldIdx::new(i), ty))
|
|
}
|
|
})
|
|
}
|
|
|
|
pub(crate) fn variant_index_for_adt(
|
|
ctor: &Constructor<'p, 'tcx>,
|
|
adt: ty::AdtDef<'tcx>,
|
|
) -> VariantIdx {
|
|
match *ctor {
|
|
Variant(idx) => idx,
|
|
Struct | UnionField => {
|
|
assert!(!adt.is_enum());
|
|
FIRST_VARIANT
|
|
}
|
|
_ => bug!("bad constructor {:?} for adt {:?}", ctor, adt),
|
|
}
|
|
}
|
|
|
|
/// Returns the types of the fields for a given constructor. The result must have a length of
|
|
/// `ctor.arity()`.
|
|
#[instrument(level = "trace", skip(self))]
|
|
pub(crate) fn ctor_sub_tys<'a>(
|
|
&'a self,
|
|
ctor: &'a Constructor<'p, 'tcx>,
|
|
ty: RevealedTy<'tcx>,
|
|
) -> impl Iterator<Item = RevealedTy<'tcx>> + ExactSizeIterator + Captures<'a> {
|
|
fn reveal_and_alloc<'a, 'tcx>(
|
|
cx: &'a RustcMatchCheckCtxt<'_, 'tcx>,
|
|
iter: impl Iterator<Item = Ty<'tcx>>,
|
|
) -> &'a [RevealedTy<'tcx>] {
|
|
cx.dropless_arena.alloc_from_iter(iter.map(|ty| cx.reveal_opaque_ty(ty)))
|
|
}
|
|
let cx = self;
|
|
let slice = match ctor {
|
|
Struct | Variant(_) | UnionField => match ty.kind() {
|
|
ty::Tuple(fs) => reveal_and_alloc(cx, fs.iter()),
|
|
ty::Adt(adt, args) => {
|
|
if adt.is_box() {
|
|
// The only legal patterns of type `Box` (outside `std`) are `_` and box
|
|
// patterns. If we're here we can assume this is a box pattern.
|
|
reveal_and_alloc(cx, once(args.type_at(0)))
|
|
} else {
|
|
let variant =
|
|
&adt.variant(RustcMatchCheckCtxt::variant_index_for_adt(&ctor, *adt));
|
|
let tys = cx.list_variant_nonhidden_fields(ty, variant).map(|(_, ty)| ty);
|
|
cx.dropless_arena.alloc_from_iter(tys)
|
|
}
|
|
}
|
|
_ => bug!("Unexpected type for constructor `{ctor:?}`: {ty:?}"),
|
|
},
|
|
Ref => match ty.kind() {
|
|
ty::Ref(_, rty, _) => reveal_and_alloc(cx, once(*rty)),
|
|
_ => bug!("Unexpected type for `Ref` constructor: {ty:?}"),
|
|
},
|
|
Slice(slice) => match *ty.kind() {
|
|
ty::Slice(ty) | ty::Array(ty, _) => {
|
|
let arity = slice.arity();
|
|
reveal_and_alloc(cx, (0..arity).map(|_| ty))
|
|
}
|
|
_ => bug!("bad slice pattern {:?} {:?}", ctor, ty),
|
|
},
|
|
Bool(..)
|
|
| IntRange(..)
|
|
| F32Range(..)
|
|
| F64Range(..)
|
|
| Str(..)
|
|
| Opaque(..)
|
|
| NonExhaustive
|
|
| Hidden
|
|
| Missing { .. }
|
|
| Wildcard => &[],
|
|
Or => {
|
|
bug!("called `Fields::wildcards` on an `Or` ctor")
|
|
}
|
|
};
|
|
slice.iter().copied()
|
|
}
|
|
|
|
/// The number of fields for this constructor.
|
|
pub(crate) fn ctor_arity(&self, ctor: &Constructor<'p, 'tcx>, ty: RevealedTy<'tcx>) -> usize {
|
|
match ctor {
|
|
Struct | Variant(_) | UnionField => match ty.kind() {
|
|
ty::Tuple(fs) => fs.len(),
|
|
ty::Adt(adt, ..) => {
|
|
if adt.is_box() {
|
|
// The only legal patterns of type `Box` (outside `std`) are `_` and box
|
|
// patterns. If we're here we can assume this is a box pattern.
|
|
1
|
|
} else {
|
|
let variant =
|
|
&adt.variant(RustcMatchCheckCtxt::variant_index_for_adt(&ctor, *adt));
|
|
self.list_variant_nonhidden_fields(ty, variant).count()
|
|
}
|
|
}
|
|
_ => bug!("Unexpected type for constructor `{ctor:?}`: {ty:?}"),
|
|
},
|
|
Ref => 1,
|
|
Slice(slice) => slice.arity(),
|
|
Bool(..)
|
|
| IntRange(..)
|
|
| F32Range(..)
|
|
| F64Range(..)
|
|
| Str(..)
|
|
| Opaque(..)
|
|
| NonExhaustive
|
|
| Hidden
|
|
| Missing { .. }
|
|
| Wildcard => 0,
|
|
Or => bug!("The `Or` constructor doesn't have a fixed arity"),
|
|
}
|
|
}
|
|
|
|
/// Creates a set that represents all the constructors of `ty`.
|
|
///
|
|
/// See [`crate::constructor`] for considerations of emptiness.
|
|
#[instrument(level = "debug", skip(self), ret)]
|
|
pub fn ctors_for_ty(
|
|
&self,
|
|
ty: RevealedTy<'tcx>,
|
|
) -> Result<ConstructorSet<'p, 'tcx>, ErrorGuaranteed> {
|
|
let cx = self;
|
|
let make_uint_range = |start, end| {
|
|
IntRange::from_range(
|
|
MaybeInfiniteInt::new_finite_uint(start),
|
|
MaybeInfiniteInt::new_finite_uint(end),
|
|
RangeEnd::Included,
|
|
)
|
|
};
|
|
// Abort on type error.
|
|
ty.error_reported()?;
|
|
// This determines the set of all possible constructors for the type `ty`. For numbers,
|
|
// arrays and slices we use ranges and variable-length slices when appropriate.
|
|
Ok(match ty.kind() {
|
|
ty::Bool => ConstructorSet::Bool,
|
|
ty::Char => {
|
|
// The valid Unicode Scalar Value ranges.
|
|
ConstructorSet::Integers {
|
|
range_1: make_uint_range('\u{0000}' as u128, '\u{D7FF}' as u128),
|
|
range_2: Some(make_uint_range('\u{E000}' as u128, '\u{10FFFF}' as u128)),
|
|
}
|
|
}
|
|
&ty::Int(ity) => {
|
|
let range = if ty.is_ptr_sized_integral() {
|
|
// The min/max values of `isize` are not allowed to be observed.
|
|
IntRange {
|
|
lo: MaybeInfiniteInt::NegInfinity,
|
|
hi: MaybeInfiniteInt::PosInfinity,
|
|
}
|
|
} else {
|
|
let size = Integer::from_int_ty(&cx.tcx, ity).size().bits();
|
|
let min = 1u128 << (size - 1);
|
|
let max = min - 1;
|
|
let min = MaybeInfiniteInt::new_finite_int(min, size);
|
|
let max = MaybeInfiniteInt::new_finite_int(max, size);
|
|
IntRange::from_range(min, max, RangeEnd::Included)
|
|
};
|
|
ConstructorSet::Integers { range_1: range, range_2: None }
|
|
}
|
|
&ty::Uint(uty) => {
|
|
let range = if ty.is_ptr_sized_integral() {
|
|
// The max value of `usize` is not allowed to be observed.
|
|
let lo = MaybeInfiniteInt::new_finite_uint(0);
|
|
IntRange { lo, hi: MaybeInfiniteInt::PosInfinity }
|
|
} else {
|
|
let size = Integer::from_uint_ty(&cx.tcx, uty).size();
|
|
let max = size.truncate(u128::MAX);
|
|
make_uint_range(0, max)
|
|
};
|
|
ConstructorSet::Integers { range_1: range, range_2: None }
|
|
}
|
|
ty::Slice(sub_ty) => ConstructorSet::Slice {
|
|
array_len: None,
|
|
subtype_is_empty: cx.is_uninhabited(*sub_ty),
|
|
},
|
|
ty::Array(sub_ty, len) => {
|
|
// We treat arrays of a constant but unknown length like slices.
|
|
ConstructorSet::Slice {
|
|
array_len: len.try_eval_target_usize(cx.tcx, cx.param_env).map(|l| l as usize),
|
|
subtype_is_empty: cx.is_uninhabited(*sub_ty),
|
|
}
|
|
}
|
|
ty::Adt(def, args) if def.is_enum() => {
|
|
let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive_enum(ty);
|
|
if def.variants().is_empty() && !is_declared_nonexhaustive {
|
|
ConstructorSet::NoConstructors
|
|
} else {
|
|
let mut variants =
|
|
IndexVec::from_elem(VariantVisibility::Visible, def.variants());
|
|
for (idx, v) in def.variants().iter_enumerated() {
|
|
let variant_def_id = def.variant(idx).def_id;
|
|
// Visibly uninhabited variants.
|
|
let is_inhabited = v
|
|
.inhabited_predicate(cx.tcx, *def)
|
|
.instantiate(cx.tcx, args)
|
|
.apply_revealing_opaque(cx.tcx, cx.param_env, cx.module, &|key| {
|
|
cx.reveal_opaque_key(key)
|
|
});
|
|
// Variants that depend on a disabled unstable feature.
|
|
let is_unstable = matches!(
|
|
cx.tcx.eval_stability(variant_def_id, None, DUMMY_SP, None),
|
|
EvalResult::Deny { .. }
|
|
);
|
|
// Foreign `#[doc(hidden)]` variants.
|
|
let is_doc_hidden =
|
|
cx.tcx.is_doc_hidden(variant_def_id) && !variant_def_id.is_local();
|
|
let visibility = if !is_inhabited {
|
|
// FIXME: handle empty+hidden
|
|
VariantVisibility::Empty
|
|
} else if is_unstable || is_doc_hidden {
|
|
VariantVisibility::Hidden
|
|
} else {
|
|
VariantVisibility::Visible
|
|
};
|
|
variants[idx] = visibility;
|
|
}
|
|
|
|
ConstructorSet::Variants { variants, non_exhaustive: is_declared_nonexhaustive }
|
|
}
|
|
}
|
|
ty::Adt(def, _) if def.is_union() => ConstructorSet::Union,
|
|
ty::Adt(..) | ty::Tuple(..) => {
|
|
ConstructorSet::Struct { empty: cx.is_uninhabited(ty.inner()) }
|
|
}
|
|
ty::Ref(..) => ConstructorSet::Ref,
|
|
ty::Never => ConstructorSet::NoConstructors,
|
|
// This type is one for which we cannot list constructors, like `str` or `f64`.
|
|
// FIXME(Nadrieril): which of these are actually allowed?
|
|
ty::Float(_)
|
|
| ty::Str
|
|
| ty::Foreign(_)
|
|
| ty::RawPtr(_)
|
|
| ty::FnDef(_, _)
|
|
| ty::FnPtr(_)
|
|
| ty::Dynamic(_, _, _)
|
|
| ty::Closure(_, _)
|
|
| ty::Coroutine(_, _)
|
|
| ty::Alias(_, _)
|
|
| ty::Param(_)
|
|
| ty::Error(_) => ConstructorSet::Unlistable,
|
|
ty::CoroutineWitness(_, _) | ty::Bound(_, _) | ty::Placeholder(_) | ty::Infer(_) => {
|
|
bug!("Encountered unexpected type in `ConstructorSet::for_ty`: {ty:?}")
|
|
}
|
|
})
|
|
}
|
|
|
|
pub(crate) fn lower_pat_range_bdy(
|
|
&self,
|
|
bdy: PatRangeBoundary<'tcx>,
|
|
ty: RevealedTy<'tcx>,
|
|
) -> MaybeInfiniteInt {
|
|
match bdy {
|
|
PatRangeBoundary::NegInfinity => MaybeInfiniteInt::NegInfinity,
|
|
PatRangeBoundary::Finite(value) => {
|
|
let bits = value.eval_bits(self.tcx, self.param_env);
|
|
match *ty.kind() {
|
|
ty::Int(ity) => {
|
|
let size = Integer::from_int_ty(&self.tcx, ity).size().bits();
|
|
MaybeInfiniteInt::new_finite_int(bits, size)
|
|
}
|
|
_ => MaybeInfiniteInt::new_finite_uint(bits),
|
|
}
|
|
}
|
|
PatRangeBoundary::PosInfinity => MaybeInfiniteInt::PosInfinity,
|
|
}
|
|
}
|
|
|
|
/// Note: the input patterns must have been lowered through
|
|
/// `rustc_mir_build::thir::pattern::check_match::MatchVisitor::lower_pattern`.
|
|
pub fn lower_pat(&self, pat: &'p Pat<'tcx>) -> DeconstructedPat<'p, 'tcx> {
|
|
let singleton = |pat| std::slice::from_ref(self.pattern_arena.alloc(pat));
|
|
let cx = self;
|
|
let ty = cx.reveal_opaque_ty(pat.ty);
|
|
let ctor;
|
|
let fields: &[_];
|
|
match &pat.kind {
|
|
PatKind::AscribeUserType { subpattern, .. }
|
|
| PatKind::InlineConstant { subpattern, .. } => return self.lower_pat(subpattern),
|
|
PatKind::Binding { subpattern: Some(subpat), .. } => return self.lower_pat(subpat),
|
|
PatKind::Binding { subpattern: None, .. } | PatKind::Wild => {
|
|
ctor = Wildcard;
|
|
fields = &[];
|
|
}
|
|
PatKind::Deref { subpattern } => {
|
|
fields = singleton(self.lower_pat(subpattern));
|
|
ctor = match ty.kind() {
|
|
// This is a box pattern.
|
|
ty::Adt(adt, ..) if adt.is_box() => Struct,
|
|
ty::Ref(..) => Ref,
|
|
_ => bug!("pattern has unexpected type: pat: {:?}, ty: {:?}", pat, ty),
|
|
};
|
|
}
|
|
PatKind::Leaf { subpatterns } | PatKind::Variant { subpatterns, .. } => {
|
|
match ty.kind() {
|
|
ty::Tuple(fs) => {
|
|
ctor = Struct;
|
|
let mut wilds: SmallVec<[_; 2]> = fs
|
|
.iter()
|
|
.map(|ty| cx.reveal_opaque_ty(ty))
|
|
.map(|ty| DeconstructedPat::wildcard(ty))
|
|
.collect();
|
|
for pat in subpatterns {
|
|
wilds[pat.field.index()] = self.lower_pat(&pat.pattern);
|
|
}
|
|
fields = cx.pattern_arena.alloc_from_iter(wilds);
|
|
}
|
|
ty::Adt(adt, args) if adt.is_box() => {
|
|
// The only legal patterns of type `Box` (outside `std`) are `_` and box
|
|
// patterns. If we're here we can assume this is a box pattern.
|
|
// FIXME(Nadrieril): A `Box` can in theory be matched either with `Box(_,
|
|
// _)` or a box pattern. As a hack to avoid an ICE with the former, we
|
|
// ignore other fields than the first one. This will trigger an error later
|
|
// anyway.
|
|
// See https://github.com/rust-lang/rust/issues/82772,
|
|
// explanation: https://github.com/rust-lang/rust/pull/82789#issuecomment-796921977
|
|
// The problem is that we can't know from the type whether we'll match
|
|
// normally or through box-patterns. We'll have to figure out a proper
|
|
// solution when we introduce generalized deref patterns. Also need to
|
|
// prevent mixing of those two options.
|
|
let pattern = subpatterns.into_iter().find(|pat| pat.field.index() == 0);
|
|
let pat = if let Some(pat) = pattern {
|
|
self.lower_pat(&pat.pattern)
|
|
} else {
|
|
DeconstructedPat::wildcard(self.reveal_opaque_ty(args.type_at(0)))
|
|
};
|
|
ctor = Struct;
|
|
fields = singleton(pat);
|
|
}
|
|
ty::Adt(adt, _) => {
|
|
ctor = match pat.kind {
|
|
PatKind::Leaf { .. } if adt.is_union() => UnionField,
|
|
PatKind::Leaf { .. } => Struct,
|
|
PatKind::Variant { variant_index, .. } => Variant(variant_index),
|
|
_ => bug!(),
|
|
};
|
|
let variant =
|
|
&adt.variant(RustcMatchCheckCtxt::variant_index_for_adt(&ctor, *adt));
|
|
// For each field in the variant, we store the relevant index into `self.fields` if any.
|
|
let mut field_id_to_id: Vec<Option<usize>> =
|
|
(0..variant.fields.len()).map(|_| None).collect();
|
|
let tys = cx.list_variant_nonhidden_fields(ty, variant).enumerate().map(
|
|
|(i, (field, ty))| {
|
|
field_id_to_id[field.index()] = Some(i);
|
|
ty
|
|
},
|
|
);
|
|
let mut wilds: SmallVec<[_; 2]> =
|
|
tys.map(|ty| DeconstructedPat::wildcard(ty)).collect();
|
|
for pat in subpatterns {
|
|
if let Some(i) = field_id_to_id[pat.field.index()] {
|
|
wilds[i] = self.lower_pat(&pat.pattern);
|
|
}
|
|
}
|
|
fields = cx.pattern_arena.alloc_from_iter(wilds);
|
|
}
|
|
_ => bug!("pattern has unexpected type: pat: {:?}, ty: {:?}", pat, ty),
|
|
}
|
|
}
|
|
PatKind::Constant { value } => {
|
|
match ty.kind() {
|
|
ty::Bool => {
|
|
ctor = match value.try_eval_bool(cx.tcx, cx.param_env) {
|
|
Some(b) => Bool(b),
|
|
None => Opaque(OpaqueId::new()),
|
|
};
|
|
fields = &[];
|
|
}
|
|
ty::Char | ty::Int(_) | ty::Uint(_) => {
|
|
ctor = match value.try_eval_bits(cx.tcx, cx.param_env) {
|
|
Some(bits) => {
|
|
let x = match *ty.kind() {
|
|
ty::Int(ity) => {
|
|
let size = Integer::from_int_ty(&cx.tcx, ity).size().bits();
|
|
MaybeInfiniteInt::new_finite_int(bits, size)
|
|
}
|
|
_ => MaybeInfiniteInt::new_finite_uint(bits),
|
|
};
|
|
IntRange(IntRange::from_singleton(x))
|
|
}
|
|
None => Opaque(OpaqueId::new()),
|
|
};
|
|
fields = &[];
|
|
}
|
|
ty::Float(ty::FloatTy::F32) => {
|
|
ctor = match value.try_eval_bits(cx.tcx, cx.param_env) {
|
|
Some(bits) => {
|
|
use rustc_apfloat::Float;
|
|
let value = rustc_apfloat::ieee::Single::from_bits(bits);
|
|
F32Range(value, value, RangeEnd::Included)
|
|
}
|
|
None => Opaque(OpaqueId::new()),
|
|
};
|
|
fields = &[];
|
|
}
|
|
ty::Float(ty::FloatTy::F64) => {
|
|
ctor = match value.try_eval_bits(cx.tcx, cx.param_env) {
|
|
Some(bits) => {
|
|
use rustc_apfloat::Float;
|
|
let value = rustc_apfloat::ieee::Double::from_bits(bits);
|
|
F64Range(value, value, RangeEnd::Included)
|
|
}
|
|
None => Opaque(OpaqueId::new()),
|
|
};
|
|
fields = &[];
|
|
}
|
|
ty::Ref(_, t, _) if t.is_str() => {
|
|
// We want a `&str` constant to behave like a `Deref` pattern, to be compatible
|
|
// with other `Deref` patterns. This could have been done in `const_to_pat`,
|
|
// but that causes issues with the rest of the matching code.
|
|
// So here, the constructor for a `"foo"` pattern is `&` (represented by
|
|
// `Ref`), and has one field. That field has constructor `Str(value)` and no
|
|
// subfields.
|
|
// Note: `t` is `str`, not `&str`.
|
|
let ty = self.reveal_opaque_ty(*t);
|
|
let subpattern = DeconstructedPat::new(Str(*value), &[], ty, pat);
|
|
ctor = Ref;
|
|
fields = singleton(subpattern)
|
|
}
|
|
// All constants that can be structurally matched have already been expanded
|
|
// into the corresponding `Pat`s by `const_to_pat`. Constants that remain are
|
|
// opaque.
|
|
_ => {
|
|
ctor = Opaque(OpaqueId::new());
|
|
fields = &[];
|
|
}
|
|
}
|
|
}
|
|
PatKind::Range(patrange) => {
|
|
let PatRange { lo, hi, end, .. } = patrange.as_ref();
|
|
let end = match end {
|
|
rustc_hir::RangeEnd::Included => RangeEnd::Included,
|
|
rustc_hir::RangeEnd::Excluded => RangeEnd::Excluded,
|
|
};
|
|
ctor = match ty.kind() {
|
|
ty::Char | ty::Int(_) | ty::Uint(_) => {
|
|
let lo = cx.lower_pat_range_bdy(*lo, ty);
|
|
let hi = cx.lower_pat_range_bdy(*hi, ty);
|
|
IntRange(IntRange::from_range(lo, hi, end))
|
|
}
|
|
ty::Float(fty) => {
|
|
use rustc_apfloat::Float;
|
|
let lo = lo.as_finite().map(|c| c.eval_bits(cx.tcx, cx.param_env));
|
|
let hi = hi.as_finite().map(|c| c.eval_bits(cx.tcx, cx.param_env));
|
|
match fty {
|
|
ty::FloatTy::F32 => {
|
|
use rustc_apfloat::ieee::Single;
|
|
let lo = lo.map(Single::from_bits).unwrap_or(-Single::INFINITY);
|
|
let hi = hi.map(Single::from_bits).unwrap_or(Single::INFINITY);
|
|
F32Range(lo, hi, end)
|
|
}
|
|
ty::FloatTy::F64 => {
|
|
use rustc_apfloat::ieee::Double;
|
|
let lo = lo.map(Double::from_bits).unwrap_or(-Double::INFINITY);
|
|
let hi = hi.map(Double::from_bits).unwrap_or(Double::INFINITY);
|
|
F64Range(lo, hi, end)
|
|
}
|
|
}
|
|
}
|
|
_ => bug!("invalid type for range pattern: {}", ty.inner()),
|
|
};
|
|
fields = &[];
|
|
}
|
|
PatKind::Array { prefix, slice, suffix } | PatKind::Slice { prefix, slice, suffix } => {
|
|
let array_len = match ty.kind() {
|
|
ty::Array(_, length) => {
|
|
Some(length.eval_target_usize(cx.tcx, cx.param_env) as usize)
|
|
}
|
|
ty::Slice(_) => None,
|
|
_ => span_bug!(pat.span, "bad ty {:?} for slice pattern", ty),
|
|
};
|
|
let kind = if slice.is_some() {
|
|
SliceKind::VarLen(prefix.len(), suffix.len())
|
|
} else {
|
|
SliceKind::FixedLen(prefix.len() + suffix.len())
|
|
};
|
|
ctor = Slice(Slice::new(array_len, kind));
|
|
fields = cx.pattern_arena.alloc_from_iter(
|
|
prefix.iter().chain(suffix.iter()).map(|p| self.lower_pat(&*p)),
|
|
)
|
|
}
|
|
PatKind::Or { .. } => {
|
|
ctor = Or;
|
|
let pats = expand_or_pat(pat);
|
|
fields =
|
|
cx.pattern_arena.alloc_from_iter(pats.into_iter().map(|p| self.lower_pat(p)))
|
|
}
|
|
PatKind::Never => {
|
|
// FIXME(never_patterns): handle `!` in exhaustiveness. This is a sane default
|
|
// in the meantime.
|
|
ctor = Wildcard;
|
|
fields = &[];
|
|
}
|
|
PatKind::Error(_) => {
|
|
ctor = Opaque(OpaqueId::new());
|
|
fields = &[];
|
|
}
|
|
}
|
|
DeconstructedPat::new(ctor, fields, ty, pat)
|
|
}
|
|
|
|
/// Convert back to a `thir::PatRangeBoundary` for diagnostic purposes.
|
|
/// Note: it is possible to get `isize/usize::MAX+1` here, as explained in the doc for
|
|
/// [`IntRange::split`]. This cannot be represented as a `Const`, so we represent it with
|
|
/// `PosInfinity`.
|
|
pub(crate) fn hoist_pat_range_bdy(
|
|
&self,
|
|
miint: MaybeInfiniteInt,
|
|
ty: RevealedTy<'tcx>,
|
|
) -> PatRangeBoundary<'tcx> {
|
|
use MaybeInfiniteInt::*;
|
|
let tcx = self.tcx;
|
|
match miint {
|
|
NegInfinity => PatRangeBoundary::NegInfinity,
|
|
Finite(_) => {
|
|
let size = ty.primitive_size(tcx);
|
|
let bits = match *ty.kind() {
|
|
ty::Int(_) => miint.as_finite_int(size.bits()).unwrap(),
|
|
_ => miint.as_finite_uint().unwrap(),
|
|
};
|
|
match Scalar::try_from_uint(bits, size) {
|
|
Some(scalar) => {
|
|
let value = mir::Const::from_scalar(tcx, scalar, ty.inner());
|
|
PatRangeBoundary::Finite(value)
|
|
}
|
|
// The value doesn't fit. Since `x >= 0` and 0 always encodes the minimum value
|
|
// for a type, the problem isn't that the value is too small. So it must be too
|
|
// large.
|
|
None => PatRangeBoundary::PosInfinity,
|
|
}
|
|
}
|
|
JustAfterMax | PosInfinity => PatRangeBoundary::PosInfinity,
|
|
}
|
|
}
|
|
|
|
/// Convert back to a `thir::Pat` for diagnostic purposes.
|
|
pub(crate) fn hoist_pat_range(&self, range: &IntRange, ty: RevealedTy<'tcx>) -> Pat<'tcx> {
|
|
use MaybeInfiniteInt::*;
|
|
let cx = self;
|
|
let kind = if matches!((range.lo, range.hi), (NegInfinity, PosInfinity)) {
|
|
PatKind::Wild
|
|
} else if range.is_singleton() {
|
|
let lo = cx.hoist_pat_range_bdy(range.lo, ty);
|
|
let value = lo.as_finite().unwrap();
|
|
PatKind::Constant { value }
|
|
} else {
|
|
// We convert to an inclusive range for diagnostics.
|
|
let mut end = rustc_hir::RangeEnd::Included;
|
|
let mut lo = cx.hoist_pat_range_bdy(range.lo, ty);
|
|
if matches!(lo, PatRangeBoundary::PosInfinity) {
|
|
// The only reason to get `PosInfinity` here is the special case where
|
|
// `hoist_pat_range_bdy` found `{u,i}size::MAX+1`. So the range denotes the
|
|
// fictitious values after `{u,i}size::MAX` (see [`IntRange::split`] for why we do
|
|
// this). We show this to the user as `usize::MAX..` which is slightly incorrect but
|
|
// probably clear enough.
|
|
let c = ty.numeric_max_val(cx.tcx).unwrap();
|
|
let value = mir::Const::from_ty_const(c, cx.tcx);
|
|
lo = PatRangeBoundary::Finite(value);
|
|
}
|
|
let hi = if matches!(range.hi, Finite(0)) {
|
|
// The range encodes `..ty::MIN`, so we can't convert it to an inclusive range.
|
|
end = rustc_hir::RangeEnd::Excluded;
|
|
range.hi
|
|
} else {
|
|
range.hi.minus_one()
|
|
};
|
|
let hi = cx.hoist_pat_range_bdy(hi, ty);
|
|
PatKind::Range(Box::new(PatRange { lo, hi, end, ty: ty.inner() }))
|
|
};
|
|
|
|
Pat { ty: ty.inner(), span: DUMMY_SP, kind }
|
|
}
|
|
/// Convert back to a `thir::Pat` for diagnostic purposes. This panics for patterns that don't
|
|
/// appear in diagnostics, like float ranges.
|
|
pub fn hoist_witness_pat(&self, pat: &WitnessPat<'p, 'tcx>) -> Pat<'tcx> {
|
|
let cx = self;
|
|
let is_wildcard = |pat: &Pat<'_>| matches!(pat.kind, PatKind::Wild);
|
|
let mut subpatterns = pat.iter_fields().map(|p| Box::new(cx.hoist_witness_pat(p)));
|
|
let kind = match pat.ctor() {
|
|
Bool(b) => PatKind::Constant { value: mir::Const::from_bool(cx.tcx, *b) },
|
|
IntRange(range) => return self.hoist_pat_range(range, *pat.ty()),
|
|
Struct | Variant(_) | UnionField => match pat.ty().kind() {
|
|
ty::Tuple(..) => PatKind::Leaf {
|
|
subpatterns: subpatterns
|
|
.enumerate()
|
|
.map(|(i, pattern)| FieldPat { field: FieldIdx::new(i), pattern })
|
|
.collect(),
|
|
},
|
|
ty::Adt(adt_def, _) if adt_def.is_box() => {
|
|
// Without `box_patterns`, the only legal pattern of type `Box` is `_` (outside
|
|
// of `std`). So this branch is only reachable when the feature is enabled and
|
|
// the pattern is a box pattern.
|
|
PatKind::Deref { subpattern: subpatterns.next().unwrap() }
|
|
}
|
|
ty::Adt(adt_def, args) => {
|
|
let variant_index =
|
|
RustcMatchCheckCtxt::variant_index_for_adt(&pat.ctor(), *adt_def);
|
|
let variant = &adt_def.variant(variant_index);
|
|
let subpatterns = cx
|
|
.list_variant_nonhidden_fields(*pat.ty(), variant)
|
|
.zip(subpatterns)
|
|
.map(|((field, _ty), pattern)| FieldPat { field, pattern })
|
|
.collect();
|
|
|
|
if adt_def.is_enum() {
|
|
PatKind::Variant { adt_def: *adt_def, args, variant_index, subpatterns }
|
|
} else {
|
|
PatKind::Leaf { subpatterns }
|
|
}
|
|
}
|
|
_ => bug!("unexpected ctor for type {:?} {:?}", pat.ctor(), *pat.ty()),
|
|
},
|
|
// Note: given the expansion of `&str` patterns done in `expand_pattern`, we should
|
|
// be careful to reconstruct the correct constant pattern here. However a string
|
|
// literal pattern will never be reported as a non-exhaustiveness witness, so we
|
|
// ignore this issue.
|
|
Ref => PatKind::Deref { subpattern: subpatterns.next().unwrap() },
|
|
Slice(slice) => {
|
|
match slice.kind {
|
|
SliceKind::FixedLen(_) => PatKind::Slice {
|
|
prefix: subpatterns.collect(),
|
|
slice: None,
|
|
suffix: Box::new([]),
|
|
},
|
|
SliceKind::VarLen(prefix, _) => {
|
|
let mut subpatterns = subpatterns.peekable();
|
|
let mut prefix: Vec<_> = subpatterns.by_ref().take(prefix).collect();
|
|
if slice.array_len.is_some() {
|
|
// Improves diagnostics a bit: if the type is a known-size array, instead
|
|
// of reporting `[x, _, .., _, y]`, we prefer to report `[x, .., y]`.
|
|
// This is incorrect if the size is not known, since `[_, ..]` captures
|
|
// arrays of lengths `>= 1` whereas `[..]` captures any length.
|
|
while !prefix.is_empty() && is_wildcard(prefix.last().unwrap()) {
|
|
prefix.pop();
|
|
}
|
|
while subpatterns.peek().is_some()
|
|
&& is_wildcard(subpatterns.peek().unwrap())
|
|
{
|
|
subpatterns.next();
|
|
}
|
|
}
|
|
let suffix: Box<[_]> = subpatterns.collect();
|
|
let wild = Pat::wildcard_from_ty(pat.ty().inner());
|
|
PatKind::Slice {
|
|
prefix: prefix.into_boxed_slice(),
|
|
slice: Some(Box::new(wild)),
|
|
suffix,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
&Str(value) => PatKind::Constant { value },
|
|
Wildcard | NonExhaustive | Hidden => PatKind::Wild,
|
|
Missing { .. } => bug!(
|
|
"trying to convert a `Missing` constructor into a `Pat`; this is probably a bug,
|
|
`Missing` should have been processed in `apply_constructors`"
|
|
),
|
|
F32Range(..) | F64Range(..) | Opaque(..) | Or => {
|
|
bug!("can't convert to pattern: {:?}", pat)
|
|
}
|
|
};
|
|
|
|
Pat { ty: pat.ty().inner(), span: DUMMY_SP, kind }
|
|
}
|
|
}
|
|
|
|
impl<'p, 'tcx> TypeCx for RustcMatchCheckCtxt<'p, 'tcx> {
|
|
type Ty = RevealedTy<'tcx>;
|
|
type Error = ErrorGuaranteed;
|
|
type VariantIdx = VariantIdx;
|
|
type StrLit = Const<'tcx>;
|
|
type ArmData = HirId;
|
|
type PatData = &'p Pat<'tcx>;
|
|
|
|
fn is_exhaustive_patterns_feature_on(&self) -> bool {
|
|
self.tcx.features().exhaustive_patterns
|
|
}
|
|
fn is_min_exhaustive_patterns_feature_on(&self) -> bool {
|
|
self.tcx.features().min_exhaustive_patterns
|
|
}
|
|
|
|
fn ctor_arity(&self, ctor: &crate::constructor::Constructor<Self>, ty: &Self::Ty) -> usize {
|
|
self.ctor_arity(ctor, *ty)
|
|
}
|
|
fn ctor_sub_tys<'a>(
|
|
&'a self,
|
|
ctor: &'a crate::constructor::Constructor<Self>,
|
|
ty: &'a Self::Ty,
|
|
) -> impl Iterator<Item = Self::Ty> + ExactSizeIterator + Captures<'a> {
|
|
self.ctor_sub_tys(ctor, *ty)
|
|
}
|
|
fn ctors_for_ty(
|
|
&self,
|
|
ty: &Self::Ty,
|
|
) -> Result<crate::constructor::ConstructorSet<Self>, Self::Error> {
|
|
self.ctors_for_ty(*ty)
|
|
}
|
|
|
|
fn write_variant_name(
|
|
f: &mut fmt::Formatter<'_>,
|
|
pat: &crate::pat::DeconstructedPat<'_, Self>,
|
|
) -> fmt::Result {
|
|
if let ty::Adt(adt, _) = pat.ty().kind() {
|
|
if adt.is_box() {
|
|
write!(f, "Box")?
|
|
} else {
|
|
let variant = adt.variant(Self::variant_index_for_adt(pat.ctor(), *adt));
|
|
write!(f, "{}", variant.name)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn bug(&self, fmt: fmt::Arguments<'_>) -> ! {
|
|
span_bug!(self.scrut_span, "{}", fmt)
|
|
}
|
|
|
|
fn lint_overlapping_range_endpoints(
|
|
&self,
|
|
pat: &crate::pat::DeconstructedPat<'_, Self>,
|
|
overlaps_on: IntRange,
|
|
overlaps_with: &[&crate::pat::DeconstructedPat<'_, Self>],
|
|
) {
|
|
let overlap_as_pat = self.hoist_pat_range(&overlaps_on, *pat.ty());
|
|
let overlaps: Vec<_> = overlaps_with
|
|
.iter()
|
|
.map(|pat| pat.data().unwrap().span)
|
|
.map(|span| errors::Overlap { range: overlap_as_pat.clone(), span })
|
|
.collect();
|
|
let pat_span = pat.data().unwrap().span;
|
|
self.tcx.emit_node_span_lint(
|
|
lint::builtin::OVERLAPPING_RANGE_ENDPOINTS,
|
|
self.match_lint_level,
|
|
pat_span,
|
|
errors::OverlappingRangeEndpoints { overlap: overlaps, range: pat_span },
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Recursively expand this pattern into its subpatterns. Only useful for or-patterns.
|
|
fn expand_or_pat<'p, 'tcx>(pat: &'p Pat<'tcx>) -> Vec<&'p Pat<'tcx>> {
|
|
fn expand<'p, 'tcx>(pat: &'p Pat<'tcx>, vec: &mut Vec<&'p Pat<'tcx>>) {
|
|
if let PatKind::Or { pats } = &pat.kind {
|
|
for pat in pats.iter() {
|
|
expand(pat, vec);
|
|
}
|
|
} else {
|
|
vec.push(pat)
|
|
}
|
|
}
|
|
|
|
let mut pats = Vec::new();
|
|
expand(pat, &mut pats);
|
|
pats
|
|
}
|