bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Change ty.kind to a method

Browse source
This commit is contained in:
LeSeulArtichaut 2020-08-03 00:49:11 +02:00
parent ef55a0a92f
commit 3e14b684dd
189 changed files with 947 additions and 899 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_middle/src/mir/mod.rs
View file

@ -2482,7 +2482,7 @@ impl<'tcx> Debug for Constant<'tcx> {
impl<'tcx> Display for Constant<'tcx> {
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
match self.literal.ty.kind {
match self.literal.ty.kind() {
ty::FnDef(..) => {}
_ => write!(fmt, "const ")?,
}

4
compiler/rustc_middle/src/mir/tcx.rs
View file

@ -33,7 +33,7 @@ impl<'tcx> PlaceTy<'tcx> {
///
/// Note that the resulting type has not been normalized.
pub fn field_ty(self, tcx: TyCtxt<'tcx>, f: &Field) -> Ty<'tcx> {
let answer = match self.ty.kind {
let answer = match self.ty.kind() {
ty::Adt(adt_def, substs) => {
let variant_def = match self.variant_index {
None => adt_def.non_enum_variant(),
@ -90,7 +90,7 @@ impl<'tcx> PlaceTy<'tcx> {
PlaceTy::from_ty(self.ty.builtin_index().unwrap())
}
ProjectionElem::Subslice { from, to, from_end } => {
PlaceTy::from_ty(match self.ty.kind {
PlaceTy::from_ty(match self.ty.kind() {
ty::Slice(..) => self.ty,
ty::Array(inner, _) if !from_end => tcx.mk_array(inner, (to - from) as u64),
ty::Array(inner, size) if from_end => {

2
compiler/rustc_middle/src/traits/query.rs
View file

@ -202,7 +202,7 @@ impl<'tcx> FromIterator<DtorckConstraint<'tcx>> for DtorckConstraint<'tcx> {
/// Note also that `needs_drop` requires a "global" type (i.e., one
/// with erased regions), but this function does not.
pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
match ty.kind {
match ty.kind() {
// None of these types have a destructor and hence they do not
// require anything in particular to outlive the dtor's
// execution.

2
compiler/rustc_middle/src/ty/_match.rs
View file

@ -67,7 +67,7 @@ impl TypeRelation<'tcx> for Match<'tcx> {
return Ok(a);
}
match (&a.kind, &b.kind) {
match (a.kind(), b.kind()) {
(
_,
&ty::Infer(ty::FreshTy(_))

2
compiler/rustc_middle/src/ty/cast.rs
View file

@ -50,7 +50,7 @@ impl<'tcx> CastTy<'tcx> {
/// Returns `Some` for integral/pointer casts.
/// casts like unsizing casts will return `None`
pub fn from_ty(t: Ty<'tcx>) -> Option<CastTy<'tcx>> {
match t.kind {
match *t.kind() {
ty::Bool => Some(CastTy::Int(IntTy::Bool)),
ty::Char => Some(CastTy::Int(IntTy::Char)),
ty::Int(_) => Some(CastTy::Int(IntTy::I)),

4
compiler/rustc_middle/src/ty/codec.rs
View file

@ -36,8 +36,10 @@ pub trait EncodableWithShorthand<'tcx, E: TyEncoder<'tcx>>: Copy + Eq + Hash {
#[allow(rustc::usage_of_ty_tykind)]
impl<'tcx, E: TyEncoder<'tcx>> EncodableWithShorthand<'tcx, E> for Ty<'tcx> {
type Variant = ty::TyKind<'tcx>;
#[inline]
fn variant(&self) -> &Self::Variant {
&self.kind
self.kind()
}
}

16
compiler/rustc_middle/src/ty/context.rs
View file

@ -759,10 +759,10 @@ impl CanonicalUserType<'tcx> {
user_substs.substs.iter().zip(BoundVar::new(0)..).all(|(kind, cvar)| {
match kind.unpack() {
GenericArgKind::Type(ty) => match ty.kind {
GenericArgKind::Type(ty) => match ty.kind() {
ty::Bound(debruijn, b) => {
// We only allow a `ty::INNERMOST` index in substitutions.
assert_eq!(debruijn, ty::INNERMOST);
assert_eq!(*debruijn, ty::INNERMOST);
cvar == b.var
}
_ => false,
@ -1498,7 +1498,7 @@ impl<'tcx> TyCtxt<'tcx> {
}
let ret_ty = self.type_of(scope_def_id);
match ret_ty.kind {
match ret_ty.kind() {
ty::FnDef(_, _) => {
let sig = ret_ty.fn_sig(*self);
let output = self.erase_late_bound_regions(&sig.output());
@ -1822,7 +1822,7 @@ macro_rules! sty_debug_print {
let shards = tcx.interners.type_.lock_shards();
let types = shards.iter().flat_map(|shard| shard.keys());
for &Interned(t) in types {
let variant = match t.kind {
let variant = match t.kind() {
ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) |
ty::Float(..) | ty::Str | ty::Never => continue,
ty::Error(_) => /* unimportant */ continue,
@ -1931,7 +1931,7 @@ impl<'tcx, T: 'tcx + ?Sized> IntoPointer for Interned<'tcx, T> {
// N.B., an `Interned<Ty>` compares and hashes as a `TyKind`.
impl<'tcx> PartialEq for Interned<'tcx, TyS<'tcx>> {
fn eq(&self, other: &Interned<'tcx, TyS<'tcx>>) -> bool {
self.0.kind == other.0.kind
self.0.kind() == other.0.kind()
}
}
@ -1939,14 +1939,14 @@ impl<'tcx> Eq for Interned<'tcx, TyS<'tcx>> {}
impl<'tcx> Hash for Interned<'tcx, TyS<'tcx>> {
fn hash<H: Hasher>(&self, s: &mut H) {
self.0.kind.hash(s)
self.0.kind().hash(s)
}
}
#[allow(rustc::usage_of_ty_tykind)]
impl<'tcx> Borrow<TyKind<'tcx>> for Interned<'tcx, TyS<'tcx>> {
fn borrow<'a>(&'a self) -> &'a TyKind<'tcx> {
&self.0.kind
&self.0.kind()
}
}
// N.B., an `Interned<PredicateInner>` compares and hashes as a `PredicateKind`.
@ -2086,7 +2086,7 @@ impl<'tcx> TyCtxt<'tcx> {
unsafety: hir::Unsafety,
) -> PolyFnSig<'tcx> {
sig.map_bound(|s| {
let params_iter = match s.inputs()[0].kind {
let params_iter = match s.inputs()[0].kind() {
ty::Tuple(params) => params.into_iter().map(|k| k.expect_ty()),
_ => bug!(),
};

8
compiler/rustc_middle/src/ty/diagnostics.rs
View file

@ -11,7 +11,7 @@ use rustc_hir::{QPath, TyKind, WhereBoundPredicate, WherePredicate};
impl<'tcx> TyS<'tcx> {
/// Similar to `TyS::is_primitive`, but also considers inferred numeric values to be primitive.
pub fn is_primitive_ty(&self) -> bool {
match self.kind {
match self.kind() {
Bool
| Char
| Str
@ -31,7 +31,7 @@ impl<'tcx> TyS<'tcx> {
/// Whether the type is succinctly representable as a type instead of just referred to with a
/// description in error messages. This is used in the main error message.
pub fn is_simple_ty(&self) -> bool {
match self.kind {
match self.kind() {
Bool
| Char
| Str
@ -55,7 +55,7 @@ impl<'tcx> TyS<'tcx> {
/// `is_simple_ty` includes, it also accepts ADTs with no type arguments and references to
/// ADTs with no type arguments.
pub fn is_simple_text(&self) -> bool {
match self.kind {
match self.kind() {
Adt(_, substs) => substs.types().next().is_none(),
Ref(_, ty, _) => ty.is_simple_text(),
_ => self.is_simple_ty(),
@ -64,7 +64,7 @@ impl<'tcx> TyS<'tcx> {
/// Whether the type can be safely suggested during error recovery.
pub fn is_suggestable(&self) -> bool {
match self.kind {
match self.kind() {
Opaque(..) | FnDef(..) | FnPtr(..) | Dynamic(..) | Closure(..) | Infer(..)
| Projection(..) => false,
_ => true,

17
compiler/rustc_middle/src/ty/error.rs
View file

@ -218,7 +218,7 @@ impl<'tcx> TypeError<'tcx> {
impl<'tcx> ty::TyS<'tcx> {
pub fn sort_string(&self, tcx: TyCtxt<'_>) -> Cow<'static, str> {
match self.kind {
match *self.kind() {
ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str | ty::Never => {
format!("`{}`", self).into()
}
@ -282,7 +282,7 @@ impl<'tcx> ty::TyS<'tcx> {
}
pub fn prefix_string(&self) -> Cow<'static, str> {
match self.kind {
match *self.kind() {
ty::Infer(_)
| ty::Error(_)
| ty::Bool
@ -351,7 +351,7 @@ impl<'tcx> TyCtxt<'tcx> {
);
}
}
match (&values.expected.kind, &values.found.kind) {
match (values.expected.kind(), values.found.kind()) {
(ty::Float(_), ty::Infer(ty::IntVar(_))) => {
if let Ok(
// Issue #53280
@ -512,7 +512,10 @@ impl<T> Trait<T> for X {
}
debug!(
"note_and_explain_type_err expected={:?} ({:?}) found={:?} ({:?})",
values.expected, values.expected.kind, values.found, values.found.kind,
values.expected,
values.expected.kind(),
values.found,
values.found.kind(),
);
}
CyclicTy(ty) => {
@ -556,7 +559,7 @@ impl<T> Trait<T> for X {
if let Some(hir_generics) = item.generics() {
// Get the `DefId` for the type parameter corresponding to `A` in `<A as T>::Foo`.
// This will also work for `impl Trait`.
let def_id = if let ty::Param(param_ty) = proj_ty.self_ty().kind {
let def_id = if let ty::Param(param_ty) = proj_ty.self_ty().kind() {
let generics = self.generics_of(body_owner_def_id);
generics.type_param(&param_ty, *self).def_id
} else {
@ -680,7 +683,7 @@ impl<T> Trait<T> for X {
}
}
if let ty::Opaque(def_id, _) = proj_ty.self_ty().kind {
if let ty::Opaque(def_id, _) = *proj_ty.self_ty().kind() {
// When the expected `impl Trait` is not defined in the current item, it will come from
// a return type. This can occur when dealing with `TryStream` (#71035).
if self.constrain_associated_type_structured_suggestion(
@ -750,7 +753,7 @@ fn foo(&self) -> Self::T { String::new() }
})
.filter_map(|(_, item)| {
let method = self.fn_sig(item.def_id);
match method.output().skip_binder().kind {
match *method.output().skip_binder().kind() {
ty::Projection(ty::ProjectionTy { item_def_id, .. })
if item_def_id == proj_ty_item_def_id =>
{

2
compiler/rustc_middle/src/ty/fast_reject.rs
View file

@ -60,7 +60,7 @@ pub fn simplify_type(
ty: Ty<'_>,
can_simplify_params: bool,
) -> Option<SimplifiedType> {
match ty.kind {
match *ty.kind() {
ty::Bool => Some(BoolSimplifiedType),
ty::Char => Some(CharSimplifiedType),
ty::Int(int_type) => Some(IntSimplifiedType(int_type)),

6
compiler/rustc_middle/src/ty/fold.rs
View file

@ -471,7 +471,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for BoundVarReplacer<'a, 'tcx> {
}
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
match t.kind {
match *t.kind() {
ty::Bound(debruijn, bound_ty) => {
if debruijn == self.current_index {
let fld_t = &mut self.fld_t;
@ -771,7 +771,7 @@ impl TypeFolder<'tcx> for Shifter<'tcx> {
}
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
match ty.kind {
match *ty.kind() {
ty::Bound(debruijn, bound_ty) => {
if self.amount == 0 || debruijn < self.current_index {
ty
@ -987,7 +987,7 @@ impl<'tcx> TypeVisitor<'tcx> for LateBoundRegionsCollector {
// ignore the inputs to a projection, as they may not appear
// in the normalized form
if self.just_constrained {
if let ty::Projection(..) | ty::Opaque(..) = t.kind {
if let ty::Projection(..) | ty::Opaque(..) = t.kind() {
return false;
}
}

2
compiler/rustc_middle/src/ty/inhabitedness/mod.rs
View file

@ -196,7 +196,7 @@ impl<'tcx> FieldDef {
impl<'tcx> TyS<'tcx> {
/// Calculates the forest of `DefId`s from which this type is visibly uninhabited.
fn uninhabited_from(&self, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> DefIdForest {
match self.kind {
match *self.kind() {
Adt(def, substs) => {
ensure_sufficient_stack(|| def.uninhabited_from(tcx, substs, param_env))
}

30
compiler/rustc_middle/src/ty/layout.rs
View file

@ -495,7 +495,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
};
debug_assert!(!ty.has_infer_types_or_consts());
Ok(match ty.kind {
Ok(match *ty.kind() {
// Basic scalars.
ty::Bool => tcx.intern_layout(Layout::scalar(
self,
@ -540,7 +540,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
}
let unsized_part = tcx.struct_tail_erasing_lifetimes(pointee, param_env);
let metadata = match unsized_part.kind {
let metadata = match unsized_part.kind() {
ty::Foreign(..) => {
return Ok(tcx.intern_layout(Layout::scalar(self, data_ptr)));
}
@ -1624,7 +1624,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
);
};
let adt_def = match layout.ty.kind {
let adt_def = match *layout.ty.kind() {
ty::Adt(ref adt_def, _) => {
debug!("print-type-size t: `{:?}` process adt", layout.ty);
adt_def
@ -1767,11 +1767,11 @@ impl<'tcx> SizeSkeleton<'tcx> {
Err(err) => err,
};
match ty.kind {
match *ty.kind() {
ty::Ref(_, pointee, _) | ty::RawPtr(ty::TypeAndMut { ty: pointee, .. }) => {
let non_zero = !ty.is_unsafe_ptr();
let tail = tcx.struct_tail_erasing_lifetimes(pointee, param_env);
match tail.kind {
match tail.kind() {
ty::Param(_) | ty::Projection(_) => {
debug_assert!(tail.has_param_types_or_consts());
Ok(SizeSkeleton::Pointer { non_zero, tail: tcx.erase_regions(&tail) })
@ -2018,7 +2018,7 @@ where
assert_eq!(original_layout.variants, Variants::Single { index });
}
let fields = match this.ty.kind {
let fields = match this.ty.kind() {
ty::Adt(def, _) if def.variants.is_empty() =>
bug!("for_variant called on zero-variant enum"),
ty::Adt(def, _) => def.variants[variant_index].fields.len(),
@ -2056,7 +2056,7 @@ where
}))
};
cx.layout_of(match this.ty.kind {
cx.layout_of(match *this.ty.kind() {
ty::Bool
| ty::Char
| ty::Int(_)
@ -2092,7 +2092,7 @@ where
));
}
match tcx.struct_tail_erasing_lifetimes(pointee, cx.param_env()).kind {
match tcx.struct_tail_erasing_lifetimes(pointee, cx.param_env()).kind() {
ty::Slice(_) | ty::Str => tcx.types.usize,
ty::Dynamic(_, _) => {
tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_array(tcx.types.usize, 3))
@ -2170,7 +2170,7 @@ where
if ty.is_fn() { cx.data_layout().instruction_address_space } else { AddressSpace::DATA }
};
let pointee_info = match this.ty.kind {
let pointee_info = match *this.ty.kind() {
ty::RawPtr(mt) if offset.bytes() == 0 => {
cx.layout_of(mt.ty).to_result().ok().map(|layout| PointeeInfo {
size: layout.size,
@ -2286,7 +2286,7 @@ where
// FIXME(eddyb) This should be for `ptr::Unique<T>`, not `Box<T>`.
if let Some(ref mut pointee) = result {
if let ty::Adt(def, _) = this.ty.kind {
if let ty::Adt(def, _) = this.ty.kind() {
if def.is_box() && offset.bytes() == 0 {
pointee.safe = Some(PointerKind::UniqueOwned);
}
@ -2299,7 +2299,9 @@ where
debug!(
"pointee_info_at (offset={:?}, type kind: {:?}) => {:?}",
offset, this.ty.kind, pointee_info
offset,
this.ty.kind(),
pointee_info
);
pointee_info
@ -2326,14 +2328,14 @@ impl<'tcx> ty::Instance<'tcx> {
fn fn_sig_for_fn_abi(&self, tcx: TyCtxt<'tcx>) -> ty::PolyFnSig<'tcx> {
// FIXME(davidtwco,eddyb): A `ParamEnv` should be passed through to this function.
let ty = self.ty(tcx, ty::ParamEnv::reveal_all());
match ty.kind {
match *ty.kind() {
ty::FnDef(..) => {
// HACK(davidtwco,eddyb): This is a workaround for polymorphization considering
// parameters unused if they show up in the signature, but not in the `mir::Body`
// (i.e. due to being inside a projection that got normalized, see
// `src/test/ui/polymorphization/normalized_sig_types.rs`), and codegen not keeping
// track of a polymorphization `ParamEnv` to allow normalizing later.
let mut sig = match ty.kind {
let mut sig = match *ty.kind() {
ty::FnDef(def_id, substs) => tcx
.normalize_erasing_regions(tcx.param_env(def_id), tcx.fn_sig(def_id))
.subst(tcx, substs),
@ -2596,7 +2598,7 @@ where
assert!(!sig.c_variadic && extra_args.is_empty());
if let Some(input) = sig.inputs().last() {
if let ty::Tuple(tupled_arguments) = input.kind {
if let ty::Tuple(tupled_arguments) = input.kind() {
inputs = &sig.inputs()[0..sig.inputs().len() - 1];
tupled_arguments.iter().map(|k| k.expect_ty()).collect()
} else {

8
compiler/rustc_middle/src/ty/mod.rs
View file

@ -580,7 +580,9 @@ bitflags! {
#[allow(rustc::usage_of_ty_tykind)]
pub struct TyS<'tcx> {
pub kind: TyKind<'tcx>,
/// This field shouldn't be used directly and may be removed in the future.
/// Use `TyS::kind()` instead.
kind: TyKind<'tcx>,
pub flags: TypeFlags,
/// This is a kind of confusing thing: it stores the smallest
@ -609,13 +611,13 @@ static_assert_size!(TyS<'_>, 32);
impl<'tcx> Ord for TyS<'tcx> {
fn cmp(&self, other: &TyS<'tcx>) -> Ordering {
self.kind.cmp(&other.kind)
self.kind().cmp(other.kind())
}
}
impl<'tcx> PartialOrd for TyS<'tcx> {
fn partial_cmp(&self, other: &TyS<'tcx>) -> Option<Ordering> {
Some(self.kind.cmp(&other.kind))
Some(self.kind().cmp(other.kind()))
}
}

2
compiler/rustc_middle/src/ty/outlives.rs
View file

@ -61,7 +61,7 @@ fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Compo
// with `collect()` because of the need to sometimes skip subtrees
// in the `subtys` iterator (e.g., when encountering a
// projection).
match ty.kind {
match *ty.kind() {
ty::FnDef(_, substs) => {
// HACK(eddyb) ignore lifetimes found shallowly in `substs`.
// This is inconsistent with `ty::Adt` (including all substs)

2
compiler/rustc_middle/src/ty/print/mod.rs
View file

@ -264,7 +264,7 @@ pub trait Printer<'tcx>: Sized {
/// type. It's just a heuristic so it makes some questionable
/// decisions and we may want to adjust it later.
pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
match ty.kind {
match *ty.kind() {
ty::Adt(adt_def, _) => Some(adt_def.did),
ty::Dynamic(data, ..) => data.principal_def_id(),

12
compiler/rustc_middle/src/ty/print/pretty.rs
View file

@ -457,7 +457,7 @@ pub trait PrettyPrinter<'tcx>:
// Inherent impls. Try to print `Foo::bar` for an inherent
// impl on `Foo`, but fallback to `<Foo>::bar` if self-type is
// anything other than a simple path.
match self_ty.kind {
match self_ty.kind() {
ty::Adt(..)
| ty::Foreign(_)
| ty::Bool
@ -508,7 +508,7 @@ pub trait PrettyPrinter<'tcx>:
fn pretty_print_type(mut self, ty: Ty<'tcx>) -> Result<Self::Type, Self::Error> {
define_scoped_cx!(self);
match ty.kind {
match *ty.kind() {
ty::Bool => p!(write("bool")),
ty::Char => p!(write("char")),
ty::Int(t) => p!(write("{}", t.name_str())),
@ -797,7 +797,7 @@ pub trait PrettyPrinter<'tcx>:
// Special-case `Fn(...) -> ...` and resugar it.
let fn_trait_kind = self.tcx().fn_trait_kind_from_lang_item(principal.def_id);
if !self.tcx().sess.verbose() && fn_trait_kind.is_some() {
if let ty::Tuple(ref args) = principal.substs.type_at(0).kind {
if let ty::Tuple(ref args) = principal.substs.type_at(0).kind() {
let mut projections = predicates.projection_bounds();
if let (Some(proj), None) = (projections.next(), projections.next()) {
let tys: Vec<_> = args.iter().map(|k| k.expect_ty()).collect();
@ -976,7 +976,7 @@ pub trait PrettyPrinter<'tcx>:
) -> Result<Self::Const, Self::Error> {
define_scoped_cx!(self);
match (scalar, &ty.kind) {
match (scalar, &ty.kind()) {
// Byte strings (&[u8; N])
(
Scalar::Ptr(ptr),
@ -1136,7 +1136,7 @@ pub trait PrettyPrinter<'tcx>:
let u8_type = self.tcx().types.u8;
match (ct, &ty.kind) {
match (ct, ty.kind()) {
// Byte/string slices, printed as (byte) string literals.
(
ConstValue::Slice { data, start, end },
@ -1189,7 +1189,7 @@ pub trait PrettyPrinter<'tcx>:
);
let fields = contents.fields.iter().copied();
match ty.kind {
match *ty.kind() {
ty::Array(..) => {
p!(write("["), comma_sep(fields), write("]"));
}

6
compiler/rustc_middle/src/ty/relate.rs
View file

@ -325,7 +325,7 @@ pub fn super_relate_tys<R: TypeRelation<'tcx>>(
) -> RelateResult<'tcx, Ty<'tcx>> {
let tcx = relation.tcx();
debug!("super_relate_tys: a={:?} b={:?}", a, b);
match (&a.kind, &b.kind) {
match (a.kind(), b.kind()) {
(&ty::Infer(_), _) | (_, &ty::Infer(_)) => {
// The caller should handle these cases!
bug!("var types encountered in super_relate_tys")
@ -516,7 +516,7 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
(ConstValue::Scalar(a_val), ConstValue::Scalar(b_val)) if a.ty == b.ty => {
if a_val == b_val {
Ok(ConstValue::Scalar(a_val))
} else if let ty::FnPtr(_) = a.ty.kind {
} else if let ty::FnPtr(_) = a.ty.kind() {
let a_instance = tcx.global_alloc(a_val.assert_ptr().alloc_id).unwrap_fn();
let b_instance = tcx.global_alloc(b_val.assert_ptr().alloc_id).unwrap_fn();
if a_instance == b_instance {
@ -540,7 +540,7 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
}
(ConstValue::ByRef { .. }, ConstValue::ByRef { .. }) => {
match a.ty.kind {
match a.ty.kind() {
ty::Array(..) | ty::Adt(..) | ty::Tuple(..) => {
let a_destructured = tcx.destructure_const(relation.param_env().and(a));
let b_destructured = tcx.destructure_const(relation.param_env().and(b));

18
compiler/rustc_middle/src/ty/structural_impls.rs
View file

@ -923,25 +923,25 @@ impl<'tcx> TypeFoldable<'tcx> for interpret::GlobalId<'tcx> {
impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
let kind = match self.kind {
let kind = match self.kind() {
ty::RawPtr(tm) => ty::RawPtr(tm.fold_with(folder)),
ty::Array(typ, sz) => ty::Array(typ.fold_with(folder), sz.fold_with(folder)),
ty::Slice(typ) => ty::Slice(typ.fold_with(folder)),
ty::Adt(tid, substs) => ty::Adt(tid, substs.fold_with(folder)),
ty::Adt(tid, substs) => ty::Adt(*tid, substs.fold_with(folder)),
ty::Dynamic(ref trait_ty, ref region) => {
ty::Dynamic(trait_ty.fold_with(folder), region.fold_with(folder))
}
ty::Tuple(ts) => ty::Tuple(ts.fold_with(folder)),
ty::FnDef(def_id, substs) => ty::FnDef(def_id, substs.fold_with(folder)),
ty::FnDef(def_id, substs) => ty::FnDef(*def_id, substs.fold_with(folder)),
ty::FnPtr(f) => ty::FnPtr(f.fold_with(folder)),
ty::Ref(ref r, ty, mutbl) => ty::Ref(r.fold_with(folder), ty.fold_with(folder), mutbl),
ty::Ref(ref r, ty, mutbl) => ty::Ref(r.fold_with(folder), ty.fold_with(folder), *mutbl),
ty::Generator(did, substs, movability) => {
ty::Generator(did, substs.fold_with(folder), movability)
ty::Generator(*did, substs.fold_with(folder), *movability)
}
ty::GeneratorWitness(types) => ty::GeneratorWitness(types.fold_with(folder)),
ty::Closure(did, substs) => ty::Closure(did, substs.fold_with(folder)),
ty::Closure(did, substs) => ty::Closure(*did, substs.fold_with(folder)),
ty::Projection(ref data) => ty::Projection(data.fold_with(folder)),
ty::Opaque(did, substs) => ty::Opaque(did, substs.fold_with(folder)),
ty::Opaque(did, substs) => ty::Opaque(*did, substs.fold_with(folder)),
ty::Bool
| ty::Char
@ -958,7 +958,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
| ty::Foreign(..) => return self,
};
if self.kind == kind { self } else { folder.tcx().mk_ty(kind) }
if *self.kind() == kind { self } else { folder.tcx().mk_ty(kind) }
}
fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
@ -966,7 +966,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
}
fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
match self.kind {
match self.kind() {
ty::RawPtr(ref tm) => tm.visit_with(visitor),
ty::Array(typ, sz) => typ.visit_with(visitor) || sz.visit_with(visitor),
ty::Slice(typ) => typ.visit_with(visitor),

151
compiler/rustc_middle/src/ty/sty.rs
View file

@ -367,7 +367,8 @@ impl<'tcx> ClosureSubsts<'tcx> {
/// Used primarily by `ty::print::pretty` to be able to handle closure
/// types that haven't had their synthetic types substituted in.
pub fn is_valid(self) -> bool {
self.substs.len() >= 3 && matches!(self.split().tupled_upvars_ty.expect_ty().kind, Tuple(_))
self.substs.len() >= 3
&& matches!(self.split().tupled_upvars_ty.expect_ty().kind(), Tuple(_))
}
/// Returns the substitutions of the closure's parent.
@ -414,9 +415,9 @@ impl<'tcx> ClosureSubsts<'tcx> {
/// Extracts the signature from the closure.
pub fn sig(self) -> ty::PolyFnSig<'tcx> {
let ty = self.sig_as_fn_ptr_ty();
match ty.kind {
ty::FnPtr(sig) => sig,
_ => bug!("closure_sig_as_fn_ptr_ty is not a fn-ptr: {:?}", ty.kind),
match ty.kind() {
ty::FnPtr(sig) => *sig,
_ => bug!("closure_sig_as_fn_ptr_ty is not a fn-ptr: {:?}", ty.kind()),
}
}
}
@ -484,7 +485,8 @@ impl<'tcx> GeneratorSubsts<'tcx> {
/// Used primarily by `ty::print::pretty` to be able to handle generator
/// types that haven't had their synthetic types substituted in.
pub fn is_valid(self) -> bool {
self.substs.len() >= 5 && matches!(self.split().tupled_upvars_ty.expect_ty().kind, Tuple(_))
self.substs.len() >= 5
&& matches!(self.split().tupled_upvars_ty.expect_ty().kind(), Tuple(_))
}
/// Returns the substitutions of the generator's parent.
@ -1741,9 +1743,14 @@ impl RegionKind {
/// Type utilities
impl<'tcx> TyS<'tcx> {
#[inline(always)]
pub fn kind(&self) -> &TyKind<'tcx> {
&self.kind
}
#[inline]
pub fn is_unit(&self) -> bool {
match self.kind {
match self.kind() {
Tuple(ref tys) => tys.is_empty(),
_ => false,
}
@ -1751,7 +1758,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_never(&self) -> bool {
match self.kind {
match self.kind() {
Never => true,
_ => false,
}
@ -1766,7 +1773,7 @@ impl<'tcx> TyS<'tcx> {
pub fn conservative_is_privately_uninhabited(&self, tcx: TyCtxt<'tcx>) -> bool {
// FIXME(varkor): we can make this less conversative by substituting concrete
// type arguments.
match self.kind {
match self.kind() {
ty::Never => true,
ty::Adt(def, _) if def.is_union() => {
// For now, `union`s are never considered uninhabited.
@ -1806,12 +1813,28 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_primitive(&self) -> bool {
self.kind.is_primitive()
self.kind().is_primitive()
}
#[inline]
pub fn is_adt(&self) -> bool {
match self.kind() {
Adt(..) => true,
_ => false,
}
}
#[inline]
pub fn is_ref(&self) -> bool {
match self.kind() {
Ref(..) => true,
_ => false,
}
}
#[inline]
pub fn is_ty_var(&self) -> bool {
match self.kind {
match self.kind() {
Infer(TyVar(_)) => true,
_ => false,
}
@ -1819,7 +1842,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_ty_infer(&self) -> bool {
match self.kind {
match self.kind() {
Infer(_) => true,
_ => false,
}
@ -1827,23 +1850,23 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_phantom_data(&self) -> bool {
if let Adt(def, _) = self.kind { def.is_phantom_data() } else { false }
if let Adt(def, _) = self.kind() { def.is_phantom_data() } else { false }
}
#[inline]
pub fn is_bool(&self) -> bool {
self.kind == Bool
*self.kind() == Bool
}
/// Returns `true` if this type is a `str`.
#[inline]
pub fn is_str(&self) -> bool {
self.kind == Str
*self.kind() == Str
}
#[inline]
pub fn is_param(&self, index: u32) -> bool {
match self.kind {
match self.kind() {
ty::Param(ref data) => data.index == index,
_ => false,
}
@ -1851,8 +1874,8 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_slice(&self) -> bool {
match self.kind {
RawPtr(TypeAndMut { ty, .. }) | Ref(_, ty, _) => match ty.kind {
match self.kind() {
RawPtr(TypeAndMut { ty, .. }) | Ref(_, ty, _) => match ty.kind() {
Slice(_) | Str => true,
_ => false,
},
@ -1860,16 +1883,24 @@ impl<'tcx> TyS<'tcx> {
}
}
#[inline]
pub fn is_array(&self) -> bool {
match self.kind() {
Array(..) => true,
_ => false,
}
}
#[inline]
pub fn is_simd(&self) -> bool {
match self.kind {
match self.kind() {
Adt(def, _) => def.repr.simd(),
_ => false,
}
}
pub fn sequence_element_type(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
match self.kind {
match self.kind() {
Array(ty, _) | Slice(ty) => ty,
Str => tcx.mk_mach_uint(ast::UintTy::U8),
_ => bug!("`sequence_element_type` called on non-sequence value: {}", self),
@ -1877,7 +1908,7 @@ impl<'tcx> TyS<'tcx> {
}
pub fn simd_type(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
match self.kind {
match self.kind() {
Adt(def, substs) => def.non_enum_variant().fields[0].ty(tcx, substs),
_ => bug!("`simd_type` called on invalid type"),
}
@ -1886,14 +1917,14 @@ impl<'tcx> TyS<'tcx> {
pub fn simd_size(&self, _tcx: TyCtxt<'tcx>) -> u64 {
// Parameter currently unused, but probably needed in the future to
// allow `#[repr(simd)] struct Simd<T, const N: usize>([T; N]);`.
match self.kind {
match self.kind() {
Adt(def, _) => def.non_enum_variant().fields.len() as u64,
_ => bug!("`simd_size` called on invalid type"),
}
}
pub fn simd_size_and_type(&self, tcx: TyCtxt<'tcx>) -> (u64, Ty<'tcx>) {
match self.kind {
match self.kind() {
Adt(def, substs) => {
let variant = def.non_enum_variant();
(variant.fields.len() as u64, variant.fields[0].ty(tcx, substs))
@ -1904,7 +1935,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_region_ptr(&self) -> bool {
match self.kind {
match self.kind() {
Ref(..) => true,
_ => false,
}
@ -1912,7 +1943,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_mutable_ptr(&self) -> bool {
match self.kind {
match self.kind() {
RawPtr(TypeAndMut { mutbl: hir::Mutability::Mut, .. })
| Ref(_, _, hir::Mutability::Mut) => true,
_ => false,
@ -1921,7 +1952,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_unsafe_ptr(&self) -> bool {
match self.kind {
match self.kind() {
RawPtr(_) => true,
_ => false,
}
@ -1935,7 +1966,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_box(&self) -> bool {
match self.kind {
match self.kind() {
Adt(def, _) => def.is_box(),
_ => false,
}
@ -1943,7 +1974,7 @@ impl<'tcx> TyS<'tcx> {
/// Panics if called on any type other than `Box<T>`.
pub fn boxed_ty(&self) -> Ty<'tcx> {
match self.kind {
match self.kind() {
Adt(def, substs) if def.is_box() => substs.type_at(0),
_ => bug!("`boxed_ty` is called on non-box type {:?}", self),
}
@ -1954,7 +1985,7 @@ impl<'tcx> TyS<'tcx> {
/// contents are abstract to rustc.)
#[inline]
pub fn is_scalar(&self) -> bool {
match self.kind {
match self.kind() {
Bool
| Char
| Int(_)
@ -1971,7 +2002,7 @@ impl<'tcx> TyS<'tcx> {
/// Returns `true` if this type is a floating point type.
#[inline]
pub fn is_floating_point(&self) -> bool {
match self.kind {
match self.kind() {
Float(_) | Infer(FloatVar(_)) => true,
_ => false,
}
@ -1979,7 +2010,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_trait(&self) -> bool {
match self.kind {
match self.kind() {
Dynamic(..) => true,
_ => false,
}
@ -1987,7 +2018,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_enum(&self) -> bool {
match self.kind {
match self.kind() {
Adt(adt_def, _) => adt_def.is_enum(),
_ => false,
}
@ -1995,7 +2026,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_closure(&self) -> bool {
match self.kind {
match self.kind() {
Closure(..) => true,
_ => false,
}
@ -2003,7 +2034,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_generator(&self) -> bool {
match self.kind {
match self.kind() {
Generator(..) => true,
_ => false,
}
@ -2011,7 +2042,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_integral(&self) -> bool {
match self.kind {
match self.kind() {
Infer(IntVar(_)) | Int(_) | Uint(_) => true,
_ => false,
}
@ -2019,7 +2050,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_fresh_ty(&self) -> bool {
match self.kind {
match self.kind() {
Infer(FreshTy(_)) => true,
_ => false,
}
@ -2027,7 +2058,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_fresh(&self) -> bool {
match self.kind {
match self.kind() {
Infer(FreshTy(_)) => true,
Infer(FreshIntTy(_)) => true,
Infer(FreshFloatTy(_)) => true,
@ -2037,7 +2068,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_char(&self) -> bool {
match self.kind {
match self.kind() {
Char => true,
_ => false,
}
@ -2050,7 +2081,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_signed(&self) -> bool {
match self.kind {
match self.kind() {
Int(_) => true,
_ => false,
}
@ -2058,7 +2089,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_ptr_sized_integral(&self) -> bool {
match self.kind {
match self.kind() {
Int(ast::IntTy::Isize) | Uint(ast::UintTy::Usize) => true,
_ => false,
}
@ -2066,7 +2097,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_machine(&self) -> bool {
match self.kind {
match self.kind() {
Int(..) | Uint(..) | Float(..) => true,
_ => false,
}
@ -2074,7 +2105,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn has_concrete_skeleton(&self) -> bool {
match self.kind {
match self.kind() {
Param(_) | Infer(_) | Error(_) => false,
_ => true,
}
@ -2085,28 +2116,28 @@ impl<'tcx> TyS<'tcx> {
/// The parameter `explicit` indicates if this is an *explicit* dereference.
/// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.
pub fn builtin_deref(&self, explicit: bool) -> Option<TypeAndMut<'tcx>> {
match self.kind {
match self.kind() {
Adt(def, _) if def.is_box() => {
Some(TypeAndMut { ty: self.boxed_ty(), mutbl: hir::Mutability::Not })
}
Ref(_, ty, mutbl) => Some(TypeAndMut { ty, mutbl }),
RawPtr(mt) if explicit => Some(mt),
Ref(_, ty, mutbl) => Some(TypeAndMut { ty, mutbl: *mutbl }),
RawPtr(mt) if explicit => Some(*mt),
_ => None,
}
}
/// Returns the type of `ty[i]`.
pub fn builtin_index(&self) -> Option<Ty<'tcx>> {
match self.kind {
match self.kind() {
Array(ty, _) | Slice(ty) => Some(ty),
_ => None,
}
}
pub fn fn_sig(&self, tcx: TyCtxt<'tcx>) -> PolyFnSig<'tcx> {
match self.kind {
FnDef(def_id, substs) => tcx.fn_sig(def_id).subst(tcx, substs),
FnPtr(f) => f,
match self.kind() {
FnDef(def_id, substs) => tcx.fn_sig(*def_id).subst(tcx, substs),
FnPtr(f) => *f,
Error(_) => {
// ignore errors (#54954)
ty::Binder::dummy(FnSig::fake())
@ -2120,7 +2151,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_fn(&self) -> bool {
match self.kind {
match self.kind() {
FnDef(..) | FnPtr(_) => true,
_ => false,
}
@ -2128,7 +2159,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_fn_ptr(&self) -> bool {
match self.kind {
match self.kind() {
FnPtr(_) => true,
_ => false,
}
@ -2136,7 +2167,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn is_impl_trait(&self) -> bool {
match self.kind {
match self.kind() {
Opaque(..) => true,
_ => false,
}
@ -2144,7 +2175,7 @@ impl<'tcx> TyS<'tcx> {
#[inline]
pub fn ty_adt_def(&self) -> Option<&'tcx AdtDef> {
match self.kind {
match self.kind() {
Adt(adt, _) => Some(adt),
_ => None,
}
@ -2153,7 +2184,7 @@ impl<'tcx> TyS<'tcx> {
/// Iterates over tuple fields.
/// Panics when called on anything but a tuple.
pub fn tuple_fields(&self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> {
match self.kind {
match self.kind() {
Tuple(substs) => substs.iter().map(|field| field.expect_ty()),
_ => bug!("tuple_fields called on non-tuple"),
}
@ -2164,10 +2195,10 @@ impl<'tcx> TyS<'tcx> {
// FIXME: This requires the optimized MIR in the case of generators.
#[inline]
pub fn variant_range(&self, tcx: TyCtxt<'tcx>) -> Option<Range<VariantIdx>> {
match self.kind {
match self.kind() {
TyKind::Adt(adt, _) => Some(adt.variant_range()),
TyKind::Generator(def_id, substs, _) => {
Some(substs.as_generator().variant_range(def_id, tcx))
Some(substs.as_generator().variant_range(*def_id, tcx))
}
_ => None,
}
@ -2183,7 +2214,7 @@ impl<'tcx> TyS<'tcx> {
tcx: TyCtxt<'tcx>,
variant_index: VariantIdx,
) -> Option<Discr<'tcx>> {
match self.kind {
match self.kind() {
TyKind::Adt(adt, _) if adt.variants.is_empty() => {
bug!("discriminant_for_variant called on zero variant enum");
}
@ -2191,7 +2222,7 @@ impl<'tcx> TyS<'tcx> {
Some(adt.discriminant_for_variant(tcx, variant_index))
}
TyKind::Generator(def_id, substs, _) => {
Some(substs.as_generator().discriminant_for_variant(def_id, tcx, variant_index))
Some(substs.as_generator().discriminant_for_variant(*def_id, tcx, variant_index))
}
_ => None,
}
@ -2199,7 +2230,7 @@ impl<'tcx> TyS<'tcx> {
/// Returns the type of the discriminant of this type.
pub fn discriminant_ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
match self.kind {
match self.kind() {
ty::Adt(adt, _) if adt.is_enum() => adt.repr.discr_type().to_ty(tcx),
ty::Generator(_, substs, _) => substs.as_generator().discr_ty(tcx),
_ => {
@ -2222,7 +2253,7 @@ impl<'tcx> TyS<'tcx> {
/// inferred. Once upvar inference (in `src/librustc_typeck/check/upvar.rs`)
/// is complete, that type variable will be unified.
pub fn to_opt_closure_kind(&self) -> Option<ty::ClosureKind> {
match self.kind {
match self.kind() {
Int(int_ty) => match int_ty {
ast::IntTy::I8 => Some(ty::ClosureKind::Fn),
ast::IntTy::I16 => Some(ty::ClosureKind::FnMut),
@ -2245,7 +2276,7 @@ impl<'tcx> TyS<'tcx> {
/// Returning true means the type is known to be sized. Returning
/// `false` means nothing -- could be sized, might not be.
pub fn is_trivially_sized(&self, tcx: TyCtxt<'tcx>) -> bool {
match self.kind {
match self.kind() {
ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
| ty::Uint(_)
| ty::Int(_)

2
compiler/rustc_middle/src/ty/subst.rs
View file

@ -486,7 +486,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
return t;
}
match t.kind {
match *t.kind() {
ty::Param(p) => self.ty_for_param(p, t),
_ => t.super_fold_with(self),
}

40
compiler/rustc_middle/src/ty/util.rs
View file

@ -33,7 +33,7 @@ pub struct Discr<'tcx> {
impl<'tcx> fmt::Display for Discr<'tcx> {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.ty.kind {
match *self.ty.kind() {
ty::Int(ity) => {
let size = ty::tls::with(|tcx| Integer::from_attr(&tcx, SignedInt(ity)).size());
let x = self.val;
@ -59,7 +59,7 @@ fn unsigned_max(size: Size) -> u128 {
}
fn int_size_and_signed<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> (Size, bool) {
let (int, signed) = match ty.kind {
let (int, signed) = match *ty.kind() {
Int(ity) => (Integer::from_attr(&tcx, SignedInt(ity)), true),
Uint(uty) => (Integer::from_attr(&tcx, UnsignedInt(uty)), false),
_ => bug!("non integer discriminant"),
@ -174,10 +174,10 @@ impl<'tcx> TyCtxt<'tcx> {
impl<'tcx> TyCtxt<'tcx> {
pub fn has_error_field(self, ty: Ty<'tcx>) -> bool {
if let ty::Adt(def, substs) = ty.kind {
if let ty::Adt(def, substs) = *ty.kind() {
for field in def.all_fields() {
let field_ty = field.ty(self, substs);
if let Error(_) = field_ty.kind {
if let Error(_) = field_ty.kind() {
return true;
}
}
@ -225,7 +225,7 @@ impl<'tcx> TyCtxt<'tcx> {
normalize: impl Fn(Ty<'tcx>) -> Ty<'tcx>,
) -> Ty<'tcx> {
loop {
match ty.kind {
match *ty.kind() {
ty::Adt(def, substs) => {
if !def.is_struct() {
break;
@ -298,7 +298,7 @@ impl<'tcx> TyCtxt<'tcx> {
) -> (Ty<'tcx>, Ty<'tcx>) {
let (mut a, mut b) = (source, target);
loop {
match (&a.kind, &b.kind) {
match (&a.kind(), &b.kind()) {
(&Adt(a_def, a_substs), &Adt(b_def, b_substs))
if a_def == b_def && a_def.is_struct() =>
{
@ -401,12 +401,12 @@ impl<'tcx> TyCtxt<'tcx> {
// <P1, P2, P0>, and then look up which of the impl substs refer to
// parameters marked as pure.
let impl_substs = match self.type_of(impl_def_id).kind {
let impl_substs = match *self.type_of(impl_def_id).kind() {
ty::Adt(def_, substs) if def_ == def => substs,
_ => bug!(),
};
let item_substs = match self.type_of(def.did).kind {
let item_substs = match *self.type_of(def.did).kind() {
ty::Adt(def_, substs) if def_ == def => substs,
_ => bug!(),
};
@ -640,7 +640,7 @@ impl<'tcx> ty::TyS<'tcx> {
/// Returns the maximum value for the given numeric type (including `char`s)
/// or returns `None` if the type is not numeric.
pub fn numeric_max_val(&'tcx self, tcx: TyCtxt<'tcx>) -> Option<&'tcx ty::Const<'tcx>> {
let val = match self.kind {
let val = match self.kind() {
ty::Int(_) | ty::Uint(_) => {
let (size, signed) = int_size_and_signed(tcx, self);
let val = if signed { signed_max(size) as u128 } else { unsigned_max(size) };
@ -659,7 +659,7 @@ impl<'tcx> ty::TyS<'tcx> {
/// Returns the minimum value for the given numeric type (including `char`s)
/// or returns `None` if the type is not numeric.
pub fn numeric_min_val(&'tcx self, tcx: TyCtxt<'tcx>) -> Option<&'tcx ty::Const<'tcx>> {
let val = match self.kind {
let val = match self.kind() {
ty::Int(_) | ty::Uint(_) => {
let (size, signed) = int_size_and_signed(tcx, self);
let val = if signed { truncate(signed_min(size) as u128, size) } else { 0 };
@ -717,7 +717,7 @@ impl<'tcx> ty::TyS<'tcx> {
/// Returning true means the type is known to be `Freeze`. Returning
/// `false` means nothing -- could be `Freeze`, might not be.
fn is_trivially_freeze(&self) -> bool {
match self.kind {
match self.kind() {
ty::Int(_)
| ty::Uint(_)
| ty::Float(_)
@ -793,7 +793,7 @@ impl<'tcx> ty::TyS<'tcx> {
/// down, you will need to use a type visitor.
#[inline]
pub fn is_structural_eq_shallow(&'tcx self, tcx: TyCtxt<'tcx>) -> bool {
match self.kind {
match self.kind() {
// Look for an impl of both `PartialStructuralEq` and `StructuralEq`.
Adt(..) => tcx.has_structural_eq_impls(self),
@ -828,7 +828,7 @@ impl<'tcx> ty::TyS<'tcx> {
}
pub fn same_type(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
match (&a.kind, &b.kind) {
match (&a.kind(), &b.kind()) {
(&Adt(did_a, substs_a), &Adt(did_b, substs_b)) => {
if did_a != did_b {
return false;
@ -860,7 +860,7 @@ impl<'tcx> ty::TyS<'tcx> {
representable_cache: &mut FxHashMap<Ty<'tcx>, Representability>,
ty: Ty<'tcx>,
) -> Representability {
match ty.kind {
match ty.kind() {
Tuple(..) => {
// Find non representable
fold_repr(ty.tuple_fields().map(|ty| {
@ -909,7 +909,7 @@ impl<'tcx> ty::TyS<'tcx> {
}
fn same_struct_or_enum<'tcx>(ty: Ty<'tcx>, def: &'tcx ty::AdtDef) -> bool {
match ty.kind {
match *ty.kind() {
Adt(ty_def, _) => ty_def == def,
_ => false,
}
@ -947,7 +947,7 @@ impl<'tcx> ty::TyS<'tcx> {
representable_cache: &mut FxHashMap<Ty<'tcx>, Representability>,
ty: Ty<'tcx>,
) -> Representability {
match ty.kind {
match ty.kind() {
Adt(def, _) => {
{
// Iterate through stack of previously seen types.
@ -962,7 +962,7 @@ impl<'tcx> ty::TyS<'tcx> {
// struct Bar<T> { x: Bar<Foo> }
if let Some(&seen_type) = iter.next() {
if same_struct_or_enum(seen_type, def) {
if same_struct_or_enum(seen_type, *def) {
debug!("SelfRecursive: {:?} contains {:?}", seen_type, ty);
return Representability::SelfRecursive(vec![sp]);
}
@ -1024,7 +1024,7 @@ impl<'tcx> ty::TyS<'tcx> {
/// - `&'a *const &'b u8 -> *const &'b u8`
pub fn peel_refs(&'tcx self) -> Ty<'tcx> {
let mut ty = self;
while let Ref(_, inner_ty, _) = ty.kind {
while let Ref(_, inner_ty, _) = ty.kind() {
ty = inner_ty;
}
ty
@ -1070,7 +1070,7 @@ impl<'tcx> ExplicitSelf<'tcx> {
{
use self::ExplicitSelf::*;
match self_arg_ty.kind {
match *self_arg_ty.kind() {
_ if is_self_ty(self_arg_ty) => ByValue,
ty::Ref(region, ty, mutbl) if is_self_ty(ty) => ByReference(region, mutbl),
ty::RawPtr(ty::TypeAndMut { ty, mutbl }) if is_self_ty(ty) => ByRawPointer(mutbl),
@ -1087,7 +1087,7 @@ pub fn needs_drop_components(
ty: Ty<'tcx>,
target_layout: &TargetDataLayout,
) -> Result<SmallVec<[Ty<'tcx>; 2]>, AlwaysRequiresDrop> {
match ty.kind {
match ty.kind() {
ty::Infer(ty::FreshIntTy(_))
| ty::Infer(ty::FreshFloatTy(_))
| ty::Bool

2
compiler/rustc_middle/src/ty/walk.rs
View file

@ -98,7 +98,7 @@ impl<'tcx> super::TyS<'tcx> {
// types as they are written).
fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>) {
match parent.unpack() {
GenericArgKind::Type(parent_ty) => match parent_ty.kind {
GenericArgKind::Type(parent_ty) => match *parent_ty.kind() {
ty::Bool
| ty::Char
| ty::Int(_)