From 5e89312a22993c946f462aff0d0fa0447210762d Mon Sep 17 00:00:00 2001 From: varkor Date: Wed, 18 Apr 2018 17:54:05 +0100 Subject: [PATCH] Inline get_type --- src/librustc/middle/resolve_lifetime.rs | 7 +++++-- src/librustc/traits/error_reporting.rs | 9 +++++++-- src/librustc/traits/on_unimplemented.rs | 16 ++++++++-------- src/librustc/ty/mod.rs | 14 ++++++-------- src/librustc/ty/subst.rs | 8 ++------ src/librustc/util/ppaux.rs | 9 +++++++-- src/librustc_traits/dropck_outlives.rs | 8 ++++++-- src/librustc_typeck/check/compare_method.rs | 16 +++++++++++++--- src/librustdoc/clean/auto_trait.rs | 2 +- src/librustdoc/clean/mod.rs | 7 +++---- src/librustdoc/html/render.rs | 7 +++++-- 11 files changed, 63 insertions(+), 40 deletions(-) diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index f6d13c2a72f..a45e2f98310 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -20,7 +20,7 @@ use hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; use hir::map::Map; use hir::ItemLocalId; use hir::LifetimeName; -use ty::{self, TyCtxt}; +use ty::{self, TyCtxt, GenericParamDef}; use errors::DiagnosticBuilder; use rustc::lint; @@ -1662,7 +1662,10 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { .params .iter() .filter_map(|param| { - param.get_type().and_then(|ty| Some(ty.object_lifetime_default)) + match *param { + GenericParamDef::Type(ty) => Some(ty.object_lifetime_default), + GenericParamDef::Lifetime(_) => None, + } }) .collect() }) diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index d0166393f01..ccaecdafa01 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -35,7 +35,7 @@ use infer::type_variable::TypeVariableOrigin; use std::fmt; use syntax::ast; use session::DiagnosticMessageId; -use ty::{self, AdtKind, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable}; +use ty::{self, AdtKind, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable, GenericParamDef}; use ty::error::ExpectedFound; use ty::fast_reject; use ty::fold::TypeFolder; @@ -378,7 +378,12 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { flags.push(("_Self".to_string(), Some(self.tcx.type_of(def.did).to_string()))); } - for param in generics.params.iter().filter_map(|param| param.get_type()) { + for param in generics.params.iter().filter_map(|param| { + match *param { + GenericParamDef::Type(ty) => Some(ty), + GenericParamDef::Lifetime(_) => None, + } + }) { let name = param.name.to_string(); let ty = trait_ref.substs.type_for_def(¶m); let ty_str = ty.to_string(); diff --git a/src/librustc/traits/on_unimplemented.rs b/src/librustc/traits/on_unimplemented.rs index 9fdbac49496..c84e03e35f4 100644 --- a/src/librustc/traits/on_unimplemented.rs +++ b/src/librustc/traits/on_unimplemented.rs @@ -254,10 +254,9 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString { Position::ArgumentNamed(s) if s == name => (), // So is `{A}` if A is a type parameter Position::ArgumentNamed(s) => match generics.params.iter().find(|param| { - if let GenericParamDef::Type(ty) = param { - ty.name == s - } else { - false + match *param { + GenericParamDef::Type(ty) => ty.name == s, + GenericParamDef::Lifetime(_) => false, } }) { Some(_) => (), @@ -292,10 +291,11 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString { let trait_str = tcx.item_path_str(trait_ref.def_id); let generics = tcx.generics_of(trait_ref.def_id); let generic_map = generics.params.iter().filter_map(|param| { - if let Some(ty) = param.get_type() { - Some((ty.name.to_string(), trait_ref.substs.type_for_def(&ty).to_string())) - } else { - None + match *param { + GenericParamDef::Type(ty) => { + Some((ty.name.to_string(), trait_ref.substs.type_for_def(&ty).to_string())) + }, + GenericParamDef::Lifetime(_) => None } }).collect::>(); diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 635713a7866..37a6533fb61 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -777,13 +777,6 @@ impl GenericParamDef { GenericParamDef::Type(ty) => ty.def_id, } } - - pub fn get_type(&self) -> Option { - match *self { - GenericParamDef::Type(ty) => Some(ty), - _ => None, - } - } } pub struct GenericParamCount { @@ -834,7 +827,12 @@ impl<'a, 'gcx, 'tcx> Generics { } pub fn requires_monomorphization(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> bool { - if self.params.iter().any(|p| p.get_type().is_some()) { + if self.params.iter().any(|param| { + match *param { + GenericParamDef::Type(_) => true, + GenericParamDef::Lifetime(_) => false + } + }) { return true; } if let Some(parent_def_id) = self.parent { diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs index 0808cc84bf7..4f69776721e 100644 --- a/src/librustc/ty/subst.rs +++ b/src/librustc/ty/subst.rs @@ -243,12 +243,8 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> { FT: FnMut(&ty::TypeParamDef, &[Kind<'tcx>]) -> Ty<'tcx> { for def in &defs.params { let param = match def { - ty::GenericParamDef::Lifetime(ref lt) => { - mk_region(lt, substs).into() - } - ty::GenericParamDef::Type(ref ty) => { - mk_type(ty, substs).into() - } + ty::GenericParamDef::Lifetime(ref lt) => mk_region(lt, substs).into(), + ty::GenericParamDef::Type(ref ty) => mk_type(ty, substs).into(), }; assert_eq!(def.index() as usize, substs.len()); substs.push(param); diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index ba869460252..603e6e03246 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -19,7 +19,7 @@ use ty::{TyError, TyStr, TyArray, TySlice, TyFloat, TyFnDef, TyFnPtr}; use ty::{TyParam, TyRawPtr, TyRef, TyNever, TyTuple}; use ty::{TyClosure, TyGenerator, TyGeneratorWitness, TyForeign, TyProjection, TyAnon}; use ty::{TyDynamic, TyInt, TyUint, TyInfer}; -use ty::{self, Ty, TyCtxt, TypeFoldable, GenericParamCount}; +use ty::{self, Ty, TyCtxt, TypeFoldable, GenericParamCount, GenericParamDef}; use util::nodemap::FxHashSet; use std::cell::Cell; @@ -337,7 +337,12 @@ impl PrintContext { if !verbose { let mut type_params = - generics.params.iter().rev().filter_map(|param| param.get_type()); + generics.params.iter().rev().filter_map(|param| { + match *param { + GenericParamDef::Type(ty) => Some(ty), + GenericParamDef::Lifetime(_) => None, + } + }); if let Some(last_ty) = type_params.next() { if last_ty.has_default { if let Some(substs) = tcx.lift(&substs) { diff --git a/src/librustc_traits/dropck_outlives.rs b/src/librustc_traits/dropck_outlives.rs index f3339688292..da38081a602 100644 --- a/src/librustc_traits/dropck_outlives.rs +++ b/src/librustc_traits/dropck_outlives.rs @@ -13,7 +13,7 @@ use rustc::hir::def_id::DefId; use rustc::traits::{FulfillmentContext, Normalized, ObligationCause}; use rustc::traits::query::{CanonicalTyGoal, NoSolution}; use rustc::traits::query::dropck_outlives::{DtorckConstraint, DropckOutlivesResult}; -use rustc::ty::{self, ParamEnvAnd, Ty, TyCtxt}; +use rustc::ty::{self, ParamEnvAnd, Ty, TyCtxt, GenericParamDef}; use rustc::ty::subst::Subst; use rustc::util::nodemap::FxHashSet; use rustc_data_structures::sync::Lrc; @@ -278,9 +278,13 @@ crate fn adt_dtorck_constraint<'a, 'tcx>( debug!("dtorck_constraint: {:?}", def); if def.is_phantom_data() { + let type_param = match tcx.generics_of(def_id).params[0] { + GenericParamDef::Type(ty) => ty, + GenericParamDef::Lifetime(_) => unreachable!(), + }; let result = DtorckConstraint { outlives: vec![], - dtorck_types: vec![tcx.mk_param_from_def(&tcx.generics_of(def_id).params[0].get_type().unwrap())], + dtorck_types: vec![tcx.mk_param_from_def(&type_param)], overflows: vec![], }; debug!("dtorck_constraint: {:?} => {:?}", def, result); diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index c2c250249ad..d1978ceb30b 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -10,7 +10,7 @@ use rustc::hir::{self, ImplItemKind, TraitItemKind}; use rustc::infer::{self, InferOk}; -use rustc::ty::{self, TyCtxt}; +use rustc::ty::{self, TyCtxt, GenericParamDef}; use rustc::ty::util::ExplicitSelf; use rustc::traits::{self, ObligationCause, ObligationCauseCode, Reveal}; use rustc::ty::error::{ExpectedFound, TypeError}; @@ -728,8 +728,18 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let mut error_found = false; let impl_m_generics = tcx.generics_of(impl_m.def_id); let trait_m_generics = tcx.generics_of(trait_m.def_id); - let impl_m_type_params = impl_m_generics.params.iter().filter_map(|param| param.get_type()); - let trait_m_type_params = trait_m_generics.params.iter().filter_map(|param| param.get_type()); + let impl_m_type_params = impl_m_generics.params.iter().filter_map(|param| { + match *param { + GenericParamDef::Type(ty) => Some(ty), + GenericParamDef::Lifetime(_) => None, + } + }); + let trait_m_type_params = trait_m_generics.params.iter().filter_map(|param| { + match *param { + GenericParamDef::Type(ty) => Some(ty), + GenericParamDef::Lifetime(_) => None, + } + }); for (impl_ty, trait_ty) in impl_m_type_params.zip(trait_m_type_params) { if impl_ty.synthetic != trait_ty.synthetic { let impl_node_id = tcx.hir.as_local_node_id(impl_ty.def_id).unwrap(); diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index b1981c06504..dc49cfcbc2b 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -860,7 +860,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> { ty.bounds.insert(0, TyParamBound::maybe_sized(self.cx)); } } - _ => {} + GenericParamDef::Lifetime(_) => {} } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 5146a29d4e3..cb48d790f60 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1725,10 +1725,9 @@ pub enum GenericParamDef { impl GenericParamDef { pub fn is_synthetic_type_param(&self) -> bool { - if let GenericParamDef::Type(ref t) = *self { - t.synthetic.is_some() - } else { - false + match self { + GenericParamDef::Type(ty) => ty.synthetic.is_some(), + GenericParamDef::Lifetime(_) => false, } } } diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 5be9000d2a5..21851e7b9dc 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1437,8 +1437,11 @@ impl DocFolder for Cache { impl<'a> Cache { fn generics(&mut self, generics: &clean::Generics) { for param in &generics.params { - if let clean::GenericParamDef::Type(ref typ) = *param { - self.typarams.insert(typ.did, typ.name.clone()); + match *param { + clean::GenericParamDef::Type(ref typ) => { + self.typarams.insert(typ.did, typ.name.clone()); + } + clean::GenericParamDef::Lifetime(_) => {} } } }