Enum rustc_middle::thir::PatKind
source · pub enum PatKind<'tcx> {
Wild,
AscribeUserType {
ascription: Ascription<'tcx>,
subpattern: Box<Pat<'tcx>>,
},
Binding {
mutability: Mutability,
name: Symbol,
mode: BindingMode,
var: LocalVarId,
ty: Ty<'tcx>,
subpattern: Option<Box<Pat<'tcx>>>,
is_primary: bool,
},
Variant {
adt_def: AdtDef<'tcx>,
args: GenericArgsRef<'tcx>,
variant_index: VariantIdx,
subpatterns: Vec<FieldPat<'tcx>>,
},
Leaf {
subpatterns: Vec<FieldPat<'tcx>>,
},
Deref {
subpattern: Box<Pat<'tcx>>,
},
Constant {
value: Const<'tcx>,
},
Range(Box<PatRange<'tcx>>),
Slice {
prefix: Box<[Box<Pat<'tcx>>]>,
slice: Option<Box<Pat<'tcx>>>,
suffix: Box<[Box<Pat<'tcx>>]>,
},
Array {
prefix: Box<[Box<Pat<'tcx>>]>,
slice: Option<Box<Pat<'tcx>>>,
suffix: Box<[Box<Pat<'tcx>>]>,
},
Or {
pats: Box<[Box<Pat<'tcx>>]>,
},
}
Variants§
Wild
A wildcard pattern: _
.
AscribeUserType
Binding
x
, ref x
, x @ P
, etc.
Variant
Foo(...)
or Foo{...}
or Foo
, where Foo
is a variant name from an ADT with
multiple variants.
Leaf
(...)
, Foo(...)
, Foo{...}
, or Foo
, where Foo
is a variant name from an ADT with
a single variant.
Deref
box P
, &P
, &mut P
, etc.
Constant
One of the following:
&str
(represented as a valtree), which will be handled as a string pattern and thus exhaustiveness checking will detect if you use the same string twice in different patterns.- integer, bool, char or float (represented as a valtree), which will be handled by
exhaustiveness to cover exactly its own value, similar to
&str
, but these values are much simpler. - Opaque constants (represented as
mir::ConstValue
), that must not be matched structurally. So anything that does not derivePartialEq
andEq
.
These are always compared with the matched place using (the semantics of) PartialEq
.
Range(Box<PatRange<'tcx>>)
Slice
Matches against a slice, checking the length and extracting elements.
irrefutable when there is a slice pattern and both prefix
and suffix
are empty.
e.g., &[ref xs @ ..]
.
Array
Fixed match against an array; irrefutable.
Or
An or-pattern, e.g. p | q
.
Invariant: pats.len() >= 2
.
Trait Implementations§
source§impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for PatKind<'tcx>
impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for PatKind<'tcx>
fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )
Auto Trait Implementations§
impl<'tcx> !RefUnwindSafe for PatKind<'tcx>
impl<'tcx> !Send for PatKind<'tcx>
impl<'tcx> !Sync for PatKind<'tcx>
impl<'tcx> Unpin for PatKind<'tcx>
impl<'tcx> !UnwindSafe for PatKind<'tcx>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
source§impl<Tcx, T> DepNodeParams<Tcx> for Twhere
Tcx: DepContext,
T: for<'a> HashStable<StableHashingContext<'a>> + Debug,
impl<Tcx, T> DepNodeParams<Tcx> for Twhere Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,
default fn fingerprint_style() -> FingerprintStyle
source§default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_debug_str(&self, _: Tcx) -> String
source§default fn recover(_: Tcx, _: &DepNode) -> Option<T>
default fn recover(_: Tcx, _: &DepNode) -> Option<T>
DepNode
,
something which is needed when forcing DepNode
s during red-green
evaluation. The query system will only call this method if
fingerprint_style()
is not FingerprintStyle::Opaque
.
It is always valid to return None
here, in which case incremental
compilation will treat the query as having changed instead of forcing it.source§impl<P> IntoQueryParam<P> for P
impl<P> IntoQueryParam<P> for P
fn into_query_param(self) -> P
source§impl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
source§impl<'tcx, T> ToPredicate<'tcx, T> for T
impl<'tcx, T> ToPredicate<'tcx, T> for T
fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> T
source§impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
impl<Tcx, T> Value<Tcx> for Twhere Tcx: DepContext,
default fn from_cycle_error( tcx: Tcx, cycle: &[QueryInfo], _guar: ErrorGuaranteed ) -> T
Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 48 bytes
Size for each variant:
Wild
: 0 bytesAscribeUserType
: 47 bytesBinding
: 31 bytesVariant
: 47 bytesLeaf
: 31 bytesDeref
: 15 bytesConstant
: 47 bytesRange
: 15 bytesSlice
: 47 bytesArray
: 47 bytesOr
: 23 bytes