bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Review refactoring

Browse source
This commit is contained in:
varkor 2018-05-11 01:56:05 +01:00
parent fd8e284a20
commit fe1f651e4c
5 changed files with 48 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -380,7 +380,6 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
}
for param in generics.params.iter() {
let name = param.name.to_string();
let value = match param.kind {
GenericParamDefKind::Type(_) => {
let ty = trait_ref.substs.type_for_def(&param);
@ -388,6 +387,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
},
GenericParamDefKind::Lifetime => continue,
};
let name = param.name.to_string();
flags.push((name.clone(), Some(value.clone())));
}

11
src/librustc/traits/on_unimplemented.rs
View file

@ -288,13 +288,14 @@ 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| {
match param.kind {
let value = match param.kind {
GenericParamDefKind::Type(_) => {
Some((param.name.to_string(),
trait_ref.substs.type_for_def(&param).to_string()))
trait_ref.substs.type_for_def(&param).to_string()
},
GenericParamDefKind::Lifetime => None
}
GenericParamDefKind::Lifetime => return None
};
let name = param.name.to_string();
Some((name, value))
}).collect::<FxHashMap<String, String>>();
let parser = Parser::new(&self.0);

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

@ -25,7 +25,6 @@ use util::nodemap::FxHashSet;
use std::cell::Cell;
use std::fmt;
use std::usize;
use std::iter;
use rustc_data_structures::indexed_vec::Idx;
use rustc_target::spec::abi::Abi;
@ -342,23 +341,22 @@ impl PrintContext {
GenericParamDefKind::Type(ty) => Some((param.def_id, ty.has_default)),
GenericParamDefKind::Lifetime => None,
}
});
if let Some(last_ty) = type_params.next() {
let (_, has_default) = last_ty;
if has_default {
if let Some(substs) = tcx.lift(&substs) {
let mut types = substs.types().rev().skip(child_types);
let zipped = iter::once((last_ty, types.next().unwrap()))
.chain(type_params.zip(types));
for ((def_id, has_default), actual) in zipped {
if !has_default {
break;
}
if tcx.type_of(def_id).subst(tcx, substs) != actual {
break;
}
num_supplied_defaults += 1;
}).peekable();
let has_default = {
let has_default = type_params.peek().map(|(_, has_default)| has_default);
*has_default.unwrap_or(&false)
};
if has_default {
if let Some(substs) = tcx.lift(&substs) {
let mut types = substs.types().rev().skip(child_types);
for ((def_id, has_default), actual) in type_params.zip(types) {
if !has_default {
break;
}
if tcx.type_of(def_id).subst(tcx, substs) != actual {
break;
}
num_supplied_defaults += 1;
}
}
}

21
src/librustc_typeck/collect.rs
View file

@ -886,8 +886,10 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
generics.parent_count + generics.params.len()
});
let mut params: Vec<_> = opt_self.into_iter().collect();
let early_lifetimes = early_bound_lifetimes_from_generics(tcx, ast_generics);
let lifetimes = early_lifetimes.enumerate().map(|(i, l)| {
params.extend(early_lifetimes.enumerate().map(|(i, l)| {
ty::GenericParamDef {
name: l.lifetime.name.name().as_interned_str(),
index: own_start + i as u32,
@ -895,14 +897,14 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
pure_wrt_drop: l.pure_wrt_drop,
kind: ty::GenericParamDefKind::Lifetime,
}
}).collect::<Vec<_>>();
}));
let hir_id = tcx.hir.node_to_hir_id(node_id);
let object_lifetime_defaults = tcx.object_lifetime_defaults(hir_id);
// Now create the real type parameters.
let type_start = own_start + lifetimes.len() as u32;
let mut types: Vec<_> = ast_generics.ty_params().enumerate().map(|(i, p)| {
let type_start = params.len() as u32;
params.extend(ast_generics.ty_params().enumerate().map(|(i, p)| {
if p.name == keywords::SelfType.name() {
span_bug!(p.span, "`Self` should not be the name of a regular parameter");
}
@ -930,7 +932,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
synthetic: p.synthetic,
}),
}
}).collect();
}));
// provide junk type parameter defs - the only place that
// cares about anything but the length is instantiation,
@ -943,7 +945,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
};
for (i, &arg) in dummy_args.iter().enumerate() {
types.push(ty::GenericParamDef {
params.push(ty::GenericParamDef {
index: type_start + i as u32,
name: Symbol::intern(arg).as_interned_str(),
def_id,
@ -957,7 +959,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
}
tcx.with_freevars(node_id, |fv| {
types.extend(fv.iter().zip((dummy_args.len() as u32)..).map(|(_, i)| {
params.extend(fv.iter().zip((dummy_args.len() as u32)..).map(|(_, i)| {
ty::GenericParamDef {
index: type_start + i,
name: Symbol::intern("<upvar>").as_interned_str(),
@ -973,11 +975,6 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
});
}
let params: Vec<_> = opt_self.into_iter()
.chain(lifetimes)
.chain(types)
.collect();
let param_def_id_to_index = params.iter()
.map(|param| (param.def_id, param.index))
.collect();

34
src/librustc_typeck/impl_wf_check.rs
View file

@ -72,10 +72,9 @@ struct ImplWfCheck<'a, 'tcx: 'a> {
impl<'a, 'tcx> ItemLikeVisitor<'tcx> for ImplWfCheck<'a, 'tcx> {
fn visit_item(&mut self, item: &'tcx hir::Item) {
match item.node {
hir::ItemImpl(.., ref generics, _, _, ref impl_item_refs) => {
hir::ItemImpl(.., _, _, _, ref impl_item_refs) => {
let impl_def_id = self.tcx.hir.local_def_id(item.id);
enforce_impl_params_are_constrained(self.tcx,
generics,
impl_def_id,
impl_item_refs);
enforce_impl_items_are_distinct(self.tcx, impl_item_refs);
@ -90,7 +89,6 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for ImplWfCheck<'a, 'tcx> {
}
fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
impl_hir_generics: &hir::Generics,
impl_def_id: DefId,
impl_item_refs: &[hir::ImplItemRef])
{
@ -115,26 +113,28 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
ctp::parameters_for(&tcx.type_of(def_id), true)
}).collect();
for (ty_param, hir_param) in impl_generics.params.iter()
.zip(impl_hir_generics.params.iter()) {
match (&ty_param.kind, hir_param) {
for param in &impl_generics.params {
match param.kind {
// Disallow ANY unconstrained type parameters.
(&ty::GenericParamDefKind::Type(_), hir::GenericParam::Type(hir_ty)) => {
let param_ty = ty::ParamTy::for_def(ty_param);
ty::GenericParamDefKind::Type(_) => {
let param_ty = ty::ParamTy::for_def(param);
if !input_parameters.contains(&ctp::Parameter::from(param_ty)) {
report_unused_parameter(tcx, hir_ty.span, "type", &param_ty.to_string());
report_unused_parameter(tcx,
tcx.def_span(param.def_id),
"type",
&param_ty.to_string());
}
}
(&ty::GenericParamDefKind::Lifetime, hir::GenericParam::Lifetime(hir_lt)) => {
let param = ctp::Parameter::from(ty_param.to_early_bound_region_data());
if lifetimes_in_associated_types.contains(&param) && // (*)
!input_parameters.contains(&param) {
report_unused_parameter(tcx, hir_lt.lifetime.span,
"lifetime", &hir_lt.lifetime.name.name().to_string());
ty::GenericParamDefKind::Lifetime => {
let param_lt = ctp::Parameter::from(param.to_early_bound_region_data());
if lifetimes_in_associated_types.contains(&param_lt) && // (*)
!input_parameters.contains(&param_lt) {
report_unused_parameter(tcx,
tcx.def_span(param.def_id),
"lifetime",
&param.name.to_string());
}
}
(&ty::GenericParamDefKind::Type(_), _) => continue,
(&ty::GenericParamDefKind::Lifetime, _) => continue,
}
}