bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rustc: remove fmt::{Debug,Display} from ty::TyKind.

Browse source
This commit is contained in:
Eduard-Mihai Burtescu 2018-12-07 19:14:30 +02:00
parent 0b3ab4018b
commit 01fa283d6f
22 changed files with 73 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

17
src/librustc/middle/mem_categorization.rs
View file

@ -786,7 +786,8 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// FnMut | copied -> &'env mut | upvar -> &'env mut -> &'up bk
// FnOnce | copied | upvar -> &'up bk
let kind = match self.node_ty(fn_hir_id)?.sty {
let ty = self.node_ty(fn_hir_id)?;
let kind = match ty.sty {
ty::Generator(..) => ty::ClosureKind::FnOnce,
ty::Closure(closure_def_id, closure_substs) => {
match self.infcx {
@ -803,7 +804,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
.closure_kind(closure_def_id, self.tcx.global_tcx()),
}
}
ref t => span_bug!(span, "unexpected type for fn in mem_categorization: {:?}", t),
_ => span_bug!(span, "unexpected type for fn in mem_categorization: {:?}", ty),
};
let closure_expr_def_id = self.tcx.hir().local_def_id(fn_node_id);
@ -1064,7 +1065,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
let bk = ty::BorrowKind::from_mutbl(mutbl);
BorrowedPtr(bk, r)
}
ref ty => bug!("unexpected type in cat_deref: {:?}", ty)
_ => bug!("unexpected type in cat_deref: {:?}", base_cmt.ty)
};
let ret = cmt_ {
hir_id: node.hir_id(),
@ -1279,11 +1280,12 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
self.tcx.adt_def(enum_def).variant_with_id(def_id).fields.len())
}
Def::StructCtor(_, CtorKind::Fn) | Def::SelfCtor(..) => {
match self.pat_ty_unadjusted(&pat)?.sty {
let ty = self.pat_ty_unadjusted(&pat)?;
match ty.sty {
ty::Adt(adt_def, _) => {
(cmt, adt_def.non_enum_variant().fields.len())
}
ref ty => {
_ => {
span_bug!(pat.span,
"tuple struct pattern unexpected type {:?}", ty);
}
@ -1334,9 +1336,10 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
PatKind::Tuple(ref subpats, ddpos) => {
// (p1, ..., pN)
let expected_len = match self.pat_ty_unadjusted(&pat)?.sty {
let ty = self.pat_ty_unadjusted(&pat)?;
let expected_len = match ty.sty {
ty::Tuple(ref tys) => tys.len(),
ref ty => span_bug!(pat.span, "tuple pattern unexpected type {:?}", ty),
_ => span_bug!(pat.span, "tuple pattern unexpected type {:?}", ty),
};
for (i, subpat) in subpats.iter().enumerate_and_adjust(expected_len, ddpos) {
let subpat_ty = self.pat_ty_adjusted(&subpat)?; // see (*2)

9
src/librustc/traits/error_reporting.rs
View file

@ -854,10 +854,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
_ => vec![ArgKind::empty()],
};
let expected = match expected_trait_ref.skip_binder().substs.type_at(1).sty {
let expected_ty = expected_trait_ref.skip_binder().substs.type_at(1);
let expected = match expected_ty.sty {
ty::Tuple(ref tys) => tys.iter()
.map(|t| ArgKind::from_expected_ty(t, Some(span))).collect(),
ref sty => vec![ArgKind::Arg("_".to_owned(), sty.to_string())],
_ => vec![ArgKind::Arg("_".to_owned(), expected_ty.to_string())],
};
if found.len() == expected.len() {
@ -1686,10 +1687,10 @@ impl ArgKind {
ty::Tuple(ref tys) => ArgKind::Tuple(
span,
tys.iter()
.map(|ty| ("_".to_owned(), ty.sty.to_string()))
.map(|ty| ("_".to_owned(), ty.to_string()))
.collect::<Vec<_>>()
),
_ => ArgKind::Arg("_".to_owned(), t.sty.to_string()),
_ => ArgKind::Arg("_".to_owned(), t.to_string()),
}
}
}

6
src/librustc/ty/relate.rs
View file

@ -351,10 +351,8 @@ pub fn super_relate_tys<'a, 'gcx, 'tcx, R>(relation: &mut R,
where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'a+'tcx, 'tcx: 'a
{
let tcx = relation.tcx();
let a_sty = &a.sty;
let b_sty = &b.sty;
debug!("super_relate_tys: a_sty={:?} b_sty={:?}", a_sty, b_sty);
match (a_sty, b_sty) {
debug!("super_relate_tys: a={:?} b={:?}", a, b);
match (&a.sty, &b.sty) {
(&ty::Infer(_), _) |
(_, &ty::Infer(_)) =>
{

7
src/librustc/ty/sty.rs
View file

@ -84,7 +84,7 @@ impl BoundRegion {
/// N.B., if you change this, you'll probably want to change the corresponding
/// AST structure in `libsyntax/ast.rs` as well.
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug,
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
RustcEncodable, RustcDecodable, HashStable)]
pub enum TyKind<'tcx> {
/// The primitive boolean type. Written as `bool`.
@ -383,9 +383,10 @@ impl<'tcx> ClosureSubsts<'tcx> {
///
/// If you have an inference context, use `infcx.closure_sig()`.
pub fn closure_sig(self, def_id: DefId, tcx: TyCtxt<'_, 'tcx, 'tcx>) -> ty::PolyFnSig<'tcx> {
match self.closure_sig_ty(def_id, tcx).sty {
let ty = self.closure_sig_ty(def_id, tcx);
match ty.sty {
ty::FnPtr(sig) => sig,
ref t => bug!("closure_sig_ty is not a fn-ptr: {:?}", t),
_ => bug!("closure_sig_ty is not a fn-ptr: {:?}", ty),
}
}
}

14
src/librustc/util/ppaux.rs
View file

@ -1124,9 +1124,9 @@ define_print! {
}
define_print! {
('tcx) ty::TyKind<'tcx>, (self, f, cx) {
('tcx) ty::TyS<'tcx>, (self, f, cx) {
display {
match *self {
match self.sty {
Bool => write!(f, "bool"),
Char => write!(f, "char"),
Int(t) => write!(f, "{}", t.ty_to_string()),
@ -1376,16 +1376,8 @@ define_print! {
}
}
}
}
}
define_print! {
('tcx) ty::TyS<'tcx>, (self, f, cx) {
display {
self.sty.print(f, cx)
}
debug {
self.sty.print_display(f, cx)
self.print_display(f, cx)
}
}
}

23
src/librustc_codegen_llvm/intrinsic.rs
View file

@ -513,8 +513,7 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
},
"fadd_fast" | "fsub_fast" | "fmul_fast" | "fdiv_fast" | "frem_fast" => {
let sty = &arg_tys[0].sty;
match float_type_width(sty) {
match float_type_width(arg_tys[0]) {
Some(_width) =>
match name {
"fadd_fast" => self.fadd_fast(args[0].immediate(), args[1].immediate()),
@ -528,7 +527,7 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
span_invalid_monomorphization_error(
tcx.sess, span,
&format!("invalid monomorphization of `{}` intrinsic: \
expected basic float type, found `{}`", name, sty));
expected basic float type, found `{}`", name, arg_tys[0]));
return;
}
}
@ -1473,8 +1472,8 @@ fn generic_simd_intrinsic(
require!(false, "expected element type `{}` of second argument `{}` \
to be a pointer to the element type `{}` of the first \
argument `{}`, found `{}` != `*_ {}`",
arg_tys[1].simd_type(tcx).sty, arg_tys[1], in_elem, in_ty,
arg_tys[1].simd_type(tcx).sty, in_elem);
arg_tys[1].simd_type(tcx), arg_tys[1], in_elem, in_ty,
arg_tys[1].simd_type(tcx), in_elem);
unreachable!();
}
};
@ -1488,7 +1487,7 @@ fn generic_simd_intrinsic(
_ => {
require!(false, "expected element type `{}` of third argument `{}` \
to be a signed integer type",
arg_tys[2].simd_type(tcx).sty, arg_tys[2]);
arg_tys[2].simd_type(tcx), arg_tys[2]);
}
}
@ -1573,8 +1572,8 @@ fn generic_simd_intrinsic(
require!(false, "expected element type `{}` of second argument `{}` \
to be a pointer to the element type `{}` of the first \
argument `{}`, found `{}` != `*mut {}`",
arg_tys[1].simd_type(tcx).sty, arg_tys[1], in_elem, in_ty,
arg_tys[1].simd_type(tcx).sty, in_elem);
arg_tys[1].simd_type(tcx), arg_tys[1], in_elem, in_ty,
arg_tys[1].simd_type(tcx), in_elem);
unreachable!();
}
};
@ -1588,7 +1587,7 @@ fn generic_simd_intrinsic(
_ => {
require!(false, "expected element type `{}` of third argument `{}` \
to be a signed integer type",
arg_tys[2].simd_type(tcx).sty, arg_tys[2]);
arg_tys[2].simd_type(tcx), arg_tys[2]);
}
}
@ -1954,10 +1953,10 @@ fn int_type_width_signed(ty: Ty<'_>, cx: &CodegenCx<'_, '_>) -> Option<(u64, boo
}
}
// Returns the width of a float TypeVariant
// Returns the width of a float Ty
// Returns None if the type is not a float
fn float_type_width<'tcx>(sty: &ty::TyKind<'tcx>) -> Option<u64> {
match *sty {
fn float_type_width(ty: Ty) -> Option<u64> {
match ty.sty {
ty::Float(t) => Some(t.bit_width() as u64),
_ => None,
}

2
src/librustc_codegen_ssa/mir/constant.rs
View file

@ -53,7 +53,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
let field_ty = c.ty.builtin_index().unwrap();
let fields = match c.ty.sty {
ty::Array(_, n) => n.unwrap_usize(bx.tcx()),
ref other => bug!("invalid simd shuffle type: {}", other),
_ => bug!("invalid simd shuffle type: {}", c.ty),
};
let values: Vec<_> = (0..fields).map(|field| {
let field = const_field(

2
src/librustc_codegen_ssa/traits/type_.rs
View file

@ -148,7 +148,7 @@ pub trait DerivedTypeMethods<'tcx>: BaseTypeMethods<'tcx> + MiscMethods<'tcx> {
match tail.sty {
ty::Foreign(..) => false,
ty::Str | ty::Slice(..) | ty::Dynamic(..) => true,
_ => bug!("unexpected unsized tail: {:?}", tail.sty),
_ => bug!("unexpected unsized tail: {:?}", tail),
}
}
}

2
src/librustc_mir/borrow_check/error_reporting.rs
View file

@ -1799,7 +1799,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
// (https://github.com/rust-lang/rfcs/pull/1546)
bug!(
"End-user description not implemented for field access on `{:?}`",
ty.sty
ty
);
}
}

5
src/librustc_mir/hair/cx/expr.rs
View file

@ -955,7 +955,8 @@ fn convert_path_expr<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
let user_provided_types = cx.tables.user_provided_types();
let user_provided_type = user_provided_types.get(expr.hir_id).map(|u_ty| *u_ty);
debug!("convert_path_expr: user_provided_type={:?}", user_provided_type);
match cx.tables().node_type(expr.hir_id).sty {
let ty = cx.tables().node_type(expr.hir_id);
match ty.sty {
// A unit struct/variant which is used as a value.
// We return a completely different ExprKind here to account for this special case.
ty::Adt(adt_def, substs) => {
@ -968,7 +969,7 @@ fn convert_path_expr<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
base: None,
}
}
ref sty => bug!("unexpected sty: {:?}", sty),
_ => bug!("unexpected ty: {:?}", ty),
}
}

10
src/librustc_mir/hair/pattern/mod.rs
View file

@ -529,11 +529,11 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
ty::Error => { // Avoid ICE
return Pattern { span: pat.span, ty, kind: Box::new(PatternKind::Wild) };
}
ref sty =>
_ =>
span_bug!(
pat.span,
"unexpanded type for vector pattern: {:?}",
sty),
ty),
}
}
@ -554,7 +554,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
ty::Error => { // Avoid ICE (#50577)
return Pattern { span: pat.span, ty, kind: Box::new(PatternKind::Wild) };
}
ref sty => span_bug!(pat.span, "unexpected type for tuple pattern: {:?}", sty),
_ => span_bug!(pat.span, "unexpected type for tuple pattern: {:?}", ty),
}
}
@ -608,7 +608,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
}
_ => span_bug!(pat.span,
"tuple struct pattern not applied to an ADT {:?}",
ty.sty),
ty),
};
let variant_def = adt_def.variant_of_def(def);
@ -744,7 +744,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
ty::Error => { // Avoid ICE (#50585)
return PatternKind::Wild;
}
_ => bug!("inappropriate type for def: {:?}", ty.sty),
_ => bug!("inappropriate type for def: {:?}", ty),
};
PatternKind::Variant {
adt_def,

10
src/librustc_mir/hair/util.rs
View file

@ -16,7 +16,8 @@ crate trait UserAnnotatedTyHelpers<'gcx: 'tcx, 'tcx> {
let user_provided_types = self.tables().user_provided_types();
let mut user_ty = *user_provided_types.get(hir_id)?;
debug!("user_subts_applied_to_ty_of_hir_id: user_ty={:?}", user_ty);
match &self.tables().node_type(hir_id).sty {
let ty = self.tables().node_type(hir_id);
match ty.sty {
ty::Adt(adt_def, ..) => {
if let UserType::TypeOf(ref mut did, _) = &mut user_ty.value {
*did = adt_def.did;
@ -24,8 +25,11 @@ crate trait UserAnnotatedTyHelpers<'gcx: 'tcx, 'tcx> {
Some(user_ty)
}
ty::FnDef(..) => Some(user_ty),
sty =>
bug!("sty: {:?} should not have user provided type {:?} recorded ", sty, user_ty),
_ => bug!(
"ty: {:?} should not have user provided type {:?} recorded ",
ty,
user_ty
),
}
}
}

6
src/librustc_mir/interpret/cast.rs
View file

@ -90,7 +90,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
let fn_ptr = self.memory.create_fn_alloc(instance?).with_default_tag();
self.write_scalar(Scalar::Ptr(fn_ptr.into()), dest)?;
}
ref other => bug!("reify fn pointer on {:?}", other),
_ => bug!("reify fn pointer on {:?}", src.layout.ty),
}
}
@ -101,7 +101,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
// No change to value
self.write_immediate(*src, dest)?;
}
ref other => bug!("fn to unsafe fn cast on {:?}", other),
_ => bug!("fn to unsafe fn cast on {:?}", dest.layout.ty),
}
}
@ -120,7 +120,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
let val = Immediate::Scalar(Scalar::Ptr(fn_ptr.into()).into());
self.write_immediate(val, dest)?;
}
ref other => bug!("closure fn pointer on {:?}", other),
_ => bug!("closure fn pointer on {:?}", src.layout.ty),
}
}
}

2
src/librustc_mir/interpret/operator.rs
View file

@ -336,7 +336,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
let layout = val.layout;
let val = val.to_scalar()?;
trace!("Running unary op {:?}: {:?} ({:?})", un_op, val, layout.ty.sty);
trace!("Running unary op {:?}: {:?} ({:?})", un_op, val, layout.ty);
match layout.ty.sty {
ty::Bool => {

2
src/librustc_mir/interpret/place.rs
View file

@ -354,7 +354,7 @@ where
ty::Ref(_, _, mutbl) => Some(mutbl),
ty::Adt(def, _) if def.is_box() => Some(hir::MutMutable),
ty::RawPtr(_) => None,
_ => bug!("Unexpected pointer type {}", val.layout.ty.sty),
_ => bug!("Unexpected pointer type {}", val.layout.ty),
};
place.mplace.ptr = M::tag_dereference(self, place, mutbl)?;
Ok(place)

2
src/librustc_mir/monomorphize/collector.rs
View file

@ -836,7 +836,7 @@ fn find_vtable_types_for_unsizing<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
match tail.sty {
ty::Foreign(..) => false,
ty::Str | ty::Slice(..) | ty::Dynamic(..) => true,
_ => bug!("unexpected unsized tail: {:?}", tail.sty),
_ => bug!("unexpected unsized tail: {:?}", tail),
}
};
if type_has_metadata(inner_source) {

4
src/librustc_typeck/astconv.rs
View file

@ -959,7 +959,9 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o {
/// removing the dummy `Self` type (`TRAIT_OBJECT_DUMMY_SELF`).
fn trait_ref_to_existential(&self, trait_ref: ty::TraitRef<'tcx>)
-> ty::ExistentialTraitRef<'tcx> {
assert_eq!(trait_ref.self_ty().sty, TRAIT_OBJECT_DUMMY_SELF);
if trait_ref.self_ty().sty != TRAIT_OBJECT_DUMMY_SELF {
bug!("trait_ref_to_existential called on {:?} with non-dummy Self", trait_ref);
}
ty::ExistentialTraitRef::erase_self_ty(self.tcx(), trait_ref)
}

4
src/librustc_typeck/check/_match.rs
View file

@ -88,7 +88,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// See the examples in `run-pass/match-defbm*.rs`.
let mut pat_adjustments = vec![];
while let ty::Ref(_, inner_ty, inner_mutability) = exp_ty.sty {
debug!("inspecting {:?} with type {:?}", exp_ty, exp_ty.sty);
debug!("inspecting {:?}", exp_ty);
debug!("current discriminant is Ref, inserting implicit deref");
// Preserve the reference type. We'll need it later during HAIR lowering.
@ -894,7 +894,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
subpats.len() < variant.fields.len() && ddpos.is_some() {
let substs = match pat_ty.sty {
ty::Adt(_, substs) => substs,
ref ty => bug!("unexpected pattern type {:?}", ty),
_ => bug!("unexpected pattern type {:?}", pat_ty),
};
for (i, subpat) in subpats.iter().enumerate_and_adjust(variant.fields.len(), ddpos) {
let field_ty = self.field_ty(subpat.span, &variant.fields[i], substs);

6
src/librustc_typeck/check/mod.rs
View file

@ -3885,7 +3885,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
ty::Adt(adt, substs) => {
Some((adt.variant_of_def(def), adt.did, substs))
}
_ => bug!("unexpected type: {:?}", ty.sty)
_ => bug!("unexpected type: {:?}", ty)
}
}
Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
@ -5226,8 +5226,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
let sp = ty.span;
let ty = AstConv::ast_ty_to_ty(self, ty);
debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
debug!("suggest_missing_return_type: return type {:?}", ty);
debug!("suggest_missing_return_type: expected type {:?}", ty);
if ty.sty == expected.sty {
err.span_label(sp, format!("expected `{}` because of return type",
expected));

7
src/librustc_typeck/check/upvar.rs
View file

@ -93,19 +93,20 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
);
// Extract the type of the closure.
let (closure_def_id, substs) = match self.node_ty(closure_hir_id).sty {
let ty = self.node_ty(closure_hir_id);
let (closure_def_id, substs) = match ty.sty {
ty::Closure(def_id, substs) => (def_id, UpvarSubsts::Closure(substs)),
ty::Generator(def_id, substs, _) => (def_id, UpvarSubsts::Generator(substs)),
ty::Error => {
// #51714: skip analysis when we have already encountered type errors
return;
}
ref t => {
_ => {
span_bug!(
span,
"type of closure expr {:?} is not a closure {:?}",
closure_hir_id,
t
ty
);
}
};

2
src/librustc_typeck/check/wfcheck.rs
View file

@ -618,7 +618,7 @@ fn check_existential_types<'a, 'fcx, 'gcx, 'tcx>(
span: Span,
ty: Ty<'tcx>,
) -> Vec<ty::Predicate<'tcx>> {
trace!("check_existential_types: {:?}, {:?}", ty, ty.sty);
trace!("check_existential_types: {:?}", ty);
let mut substituted_predicates = Vec::new();
ty.fold_with(&mut ty::fold::BottomUpFolder {
tcx: fcx.tcx,

2
src/librustc_typeck/check/writeback.rs
View file

@ -472,7 +472,7 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
instantiated_ty.fold_with(&mut BottomUpFolder {
tcx: self.tcx().global_tcx(),
fldop: |ty| {
trace!("checking type {:?}: {:#?}", ty, ty.sty);
trace!("checking type {:?}", ty);
// find a type parameter
if let ty::Param(..) = ty.sty {
// look it up in the substitution list