Skip to content

Commit 991efa4

Browse files
varkorvarkor
committed
Address various comments
1 parent 91712bc commit 991efa4

File tree

8 files changed

+103
-97
lines changed

8 files changed

+103
-97
lines changed

‎src/librustc/hir/lowering.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -379,15 +379,15 @@ impl<'a> LoweringContext<'a> {
379379
});
380380

381381
if item_lowered {
382-
let item_lifetimes = match self.lctx.items.get(&item.id).unwrap().node {
382+
let item_generics = match self.lctx.items.get(&item.id).unwrap().node {
383383
hir::Item_::ItemImpl(_, _, _, ref generics, ..)
384384
| hir::Item_::ItemTrait(_, _, ref generics, ..) => {
385385
generics.params.clone()
386386
}
387387
_ => HirVec::new(),
388388
};
389389

390-
self.lctx.with_parent_impl_lifetime_defs(&item_lifetimes, |this| {
390+
self.lctx.with_parent_impl_lifetime_defs(&item_generics, |this| {
391391
let this = &mut ItemLowerer { lctx: this };
392392
if let ItemKind::Impl(_, _, _, _, ref opt_trait_ref, _, _) = item.node {
393393
this.with_trait_impl_ref(opt_trait_ref, |this| {

‎src/librustc/middle/resolve_lifetime.rs‎

Lines changed: 21 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -49,11 +49,16 @@ pub enum LifetimeDefOrigin {
4949
}
5050

5151
impl LifetimeDefOrigin {
52-
fn from_is_in_band(is_in_band: bool) -> Self {
53-
if is_in_band {
54-
LifetimeDefOrigin::InBand
55-
} else {
56-
LifetimeDefOrigin::Explicit
52+
fn from_param(param: &GenericParam) -> Self {
53+
match param.kind {
54+
GenericParamKind::Lifetime { in_band } => {
55+
if in_band {
56+
LifetimeDefOrigin::InBand
57+
} else {
58+
LifetimeDefOrigin::Explicit
59+
}
60+
}
61+
_ => bug!("expected a lifetime param"),
5762
}
5863
}
5964
}
@@ -82,29 +87,20 @@ pub enum Region {
8287
Free(DefId, /* lifetime decl */ DefId),
8388
}
8489

85-
fn new_region(hir_map: &Map, param: &GenericParam) -> (DefId, LifetimeDefOrigin) {
86-
let def_id = hir_map.local_def_id(param.id);
87-
let origin = match param.kind {
88-
GenericParamKind::Lifetime { in_band, .. } => {
89-
LifetimeDefOrigin::from_is_in_band(in_band)
90-
}
91-
_ => bug!("expected a lifetime param"),
92-
};
93-
(def_id, origin)
94-
}
95-
9690
impl Region {
9791
fn early(hir_map: &Map, index: &mut u32, param: &GenericParam) -> (ParamName, Region) {
9892
let i = *index;
9993
*index += 1;
100-
let (def_id, origin) = new_region(hir_map, param);
94+
let def_id = hir_map.local_def_id(param.id);
95+
let origin = LifetimeDefOrigin::from_param(param);
10196
debug!("Region::early: index={} def_id={:?}", i, def_id);
10297
(param.name, Region::EarlyBound(i, def_id, origin))
10398
}
10499

105100
fn late(hir_map: &Map, param: &GenericParam) -> (ParamName, Region) {
106101
let depth = ty::INNERMOST;
107-
let (def_id, origin) = new_region(hir_map, param);
102+
let def_id = hir_map.local_def_id(param.id);
103+
let origin = LifetimeDefOrigin::from_param(param);
108104
debug!(
109105
"Region::late: param={:?} depth={:?} def_id={:?} origin={:?}",
110106
param,
@@ -1300,16 +1296,19 @@ fn object_lifetime_defaults_for_item(
13001296
Set1::One(Region::Static)
13011297
} else {
13021298
generics.params.iter().filter_map(|param| match param.kind {
1303-
GenericParamKind::Lifetime { in_band } => {
1304-
Some((param.id, hir::LifetimeName::Param(param.name), in_band))
1299+
GenericParamKind::Lifetime { .. } => {
1300+
Some((
1301+
param.id,
1302+
hir::LifetimeName::Param(param.name),
1303+
LifetimeDefOrigin::from_param(param),
1304+
))
13051305
}
13061306
_ => None,
13071307
})
13081308
.enumerate()
13091309
.find(|&(_, (_, lt_name, _))| lt_name == name)
1310-
.map_or(Set1::Many, |(i, (id, _, in_band))| {
1310+
.map_or(Set1::Many, |(i, (id, _, origin))| {
13111311
let def_id = tcx.hir.local_def_id(id);
1312-
let origin = LifetimeDefOrigin::from_is_in_band(in_band);
13131312
Set1::One(Region::EarlyBound(i as u32, def_id, origin))
13141313
})
13151314
}

‎src/librustc_lint/types.rs‎

Lines changed: 44 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -821,43 +821,50 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences {
821821
let item_def_id = cx.tcx.hir.local_def_id(it.id);
822822
let t = cx.tcx.type_of(item_def_id);
823823
let ty = cx.tcx.erase_regions(&t);
824-
let layout = cx.layout_of(ty).unwrap_or_else(|e| {
825-
bug!("failed to get layout for `{}`: {}", t, e)
826-
});
827-
828-
if let layout::Variants::Tagged { ref variants, ref tag, .. } = layout.variants {
829-
let discr_size = tag.value.size(cx.tcx).bytes();
830-
831-
debug!("enum `{}` is {} bytes large with layout:\n{:#?}",
832-
t, layout.size.bytes(), layout);
833-
834-
let (largest, slargest, largest_index) = enum_definition.variants
835-
.iter()
836-
.zip(variants)
837-
.map(|(variant, variant_layout)| {
838-
// Subtract the size of the enum discriminant.
839-
let bytes = variant_layout.size.bytes().saturating_sub(discr_size);
840-
841-
debug!("- variant `{}` is {} bytes large", variant.node.name, bytes);
842-
bytes
843-
})
844-
.enumerate()
845-
.fold((0, 0, 0), |(l, s, li), (idx, size)| if size > l {
846-
(size, l, idx)
847-
} else if size > s {
848-
(l, size, li)
849-
} else {
850-
(l, s, li)
851-
});
852-
853-
// We only warn if the largest variant is at least thrice as large as
854-
// the second-largest.
855-
if largest > slargest * 3 && slargest > 0 {
856-
cx.span_lint(VARIANT_SIZE_DIFFERENCES,
857-
enum_definition.variants[largest_index].span,
858-
&format!("enum variant is more than three times larger \
859-
({} bytes) than the next largest",
860-
largest));
824+
match cx.layout_of(ty) {
825+
Ok(layout) => {
826+
let variants = &layout.variants;
827+
if let layout::Variants::Tagged { ref variants, ref tag, .. } = variants {
828+
let discr_size = tag.value.size(cx.tcx).bytes();
829+
830+
debug!("enum `{}` is {} bytes large with layout:\n{:#?}",
831+
t, layout.size.bytes(), layout);
832+
833+
let (largest, slargest, largest_index) = enum_definition.variants
834+
.iter()
835+
.zip(variants)
836+
.map(|(variant, variant_layout)| {
837+
// Subtract the size of the enum discriminant.
838+
let bytes = variant_layout.size.bytes().saturating_sub(discr_size);
839+
840+
debug!("- variant `{}` is {} bytes large",
841+
variant.node.name,
842+
bytes);
843+
bytes
844+
})
845+
.enumerate()
846+
.fold((0, 0, 0), |(l, s, li), (idx, size)| if size > l {
847+
(size, l, idx)
848+
} else if size > s {
849+
(l, size, li)
850+
} else {
851+
(l, s, li)
852+
});
853+
854+
// We only warn if the largest variant is at least thrice as large as
855+
// the second-largest.
856+
if largest > slargest * 3 && slargest > 0 {
857+
cx.span_lint(VARIANT_SIZE_DIFFERENCES,
858+
enum_definition.variants[largest_index].span,
859+
&format!("enum variant is more than three times \
860+
larger ({} bytes) than the next largest",
861+
largest));
862+
}
863+
}
864+
}
865+
Err(ty::layout::LayoutError::Unknown(_)) => return,
866+
Err(err @ ty::layout::LayoutError::SizeOverflow(_)) => {
867+
bug!("failed to get layout for `{}`: {}", t, err);
861868
}
862869
}
863870
}

‎src/librustc_resolve/lib.rs‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -2208,26 +2208,26 @@ impl<'a> Resolver<'a> {
22082208
let mut function_type_rib = Rib::new(rib_kind);
22092209
let mut seen_bindings = FxHashMap();
22102210
generics.params.iter().for_each(|param| match param.kind {
2211-
GenericParamKind::Type { .. } => {
2212-
let ident = param.ident.modern();
2213-
debug!("with_type_parameter_rib: {}", param.id);
2214-
2215-
if seen_bindings.contains_key(&ident) {
2216-
let span = seen_bindings.get(&ident).unwrap();
2217-
let err = ResolutionError::NameAlreadyUsedInTypeParameterList(
2218-
ident.name,
2219-
span,
2220-
);
2221-
resolve_error(self, param.ident.span, err);
2222-
}
2223-
seen_bindings.entry(ident).or_insert(param.ident.span);
2224-
2225-
// Plain insert (no renaming).
2226-
let def = Def::TyParam(self.definitions.local_def_id(param.id));
2227-
function_type_rib.bindings.insert(ident, def);
2228-
self.record_def(param.id, PathResolution::new(def));
2211+
GenericParamKind::Lifetime { .. } => {}
2212+
GenericParamKind::Type { .. } => {
2213+
let ident = param.ident.modern();
2214+
debug!("with_type_parameter_rib: {}", param.id);
2215+
2216+
if seen_bindings.contains_key(&ident) {
2217+
let span = seen_bindings.get(&ident).unwrap();
2218+
let err = ResolutionError::NameAlreadyUsedInTypeParameterList(
2219+
ident.name,
2220+
span,
2221+
);
2222+
resolve_error(self, param.ident.span, err);
22292223
}
2230-
_ => {}
2224+
seen_bindings.entry(ident).or_insert(param.ident.span);
2225+
2226+
// Plain insert (no renaming).
2227+
let def = Def::TyParam(self.definitions.local_def_id(param.id));
2228+
function_type_rib.bindings.insert(ident, def);
2229+
self.record_def(param.id, PathResolution::new(def));
2230+
}
22312231
});
22322232
self.ribs[TypeNS].push(function_type_rib);
22332233
}

‎src/librustc_typeck/astconv.rs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -379,7 +379,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
379379
self_ty: Ty<'tcx>)
380380
-> ty::TraitRef<'tcx>
381381
{
382-
self.prohibit_type_params(trait_ref.path.segments.split_last().unwrap().1);
382+
self.prohibit_generics(trait_ref.path.segments.split_last().unwrap().1);
383383

384384
let trait_def_id = self.trait_def_id(trait_ref);
385385
self.ast_path_to_mono_trait_ref(trait_ref.path.span,
@@ -413,7 +413,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
413413

414414
debug!("ast_path_to_poly_trait_ref({:?}, def_id={:?})", trait_ref, trait_def_id);
415415

416-
self.prohibit_type_params(trait_ref.path.segments.split_last().unwrap().1);
416+
self.prohibit_generics(trait_ref.path.segments.split_last().unwrap().1);
417417

418418
let (substs, assoc_bindings) =
419419
self.create_substs_for_ast_trait_ref(trait_ref.path.span,
@@ -891,7 +891,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
891891

892892
debug!("associated_path_def_to_ty: {:?}::{}", ty, assoc_name);
893893

894-
self.prohibit_type_params(slice::from_ref(item_segment));
894+
self.prohibit_generics(slice::from_ref(item_segment));
895895

896896
// Find the type of the associated item, and the trait where the associated
897897
// item is declared.
@@ -968,7 +968,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
968968
let tcx = self.tcx();
969969
let trait_def_id = tcx.parent_def_id(item_def_id).unwrap();
970970

971-
self.prohibit_type_params(slice::from_ref(item_segment));
971+
self.prohibit_generics(slice::from_ref(item_segment));
972972

973973
let self_ty = if let Some(ty) = opt_self_ty {
974974
ty
@@ -993,7 +993,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
993993
self.normalize_ty(span, tcx.mk_projection(item_def_id, trait_ref.substs))
994994
}
995995

996-
pub fn prohibit_type_params(&self, segments: &[hir::PathSegment]) {
996+
pub fn prohibit_generics(&self, segments: &[hir::PathSegment]) {
997997
for segment in segments {
998998
segment.with_generic_args(|generic_args| {
999999
let (mut err_for_lt, mut err_for_ty) = (false, false);
@@ -1053,21 +1053,21 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
10531053
Def::Enum(did) | Def::TyAlias(did) | Def::Struct(did) |
10541054
Def::Union(did) | Def::TyForeign(did) => {
10551055
assert_eq!(opt_self_ty, None);
1056-
self.prohibit_type_params(path.segments.split_last().unwrap().1);
1056+
self.prohibit_generics(path.segments.split_last().unwrap().1);
10571057
self.ast_path_to_ty(span, did, path.segments.last().unwrap())
10581058
}
10591059
Def::Variant(did) if permit_variants => {
10601060
// Convert "variant type" as if it were a real type.
10611061
// The resulting `Ty` is type of the variant's enum for now.
10621062
assert_eq!(opt_self_ty, None);
1063-
self.prohibit_type_params(path.segments.split_last().unwrap().1);
1063+
self.prohibit_generics(path.segments.split_last().unwrap().1);
10641064
self.ast_path_to_ty(span,
10651065
tcx.parent_def_id(did).unwrap(),
10661066
path.segments.last().unwrap())
10671067
}
10681068
Def::TyParam(did) => {
10691069
assert_eq!(opt_self_ty, None);
1070-
self.prohibit_type_params(&path.segments);
1070+
self.prohibit_generics(&path.segments);
10711071

10721072
let node_id = tcx.hir.as_local_node_id(did).unwrap();
10731073
let item_id = tcx.hir.get_parent_node(node_id);
@@ -1080,18 +1080,18 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
10801080
// Self in impl (we know the concrete type).
10811081

10821082
assert_eq!(opt_self_ty, None);
1083-
self.prohibit_type_params(&path.segments);
1083+
self.prohibit_generics(&path.segments);
10841084

10851085
tcx.at(span).type_of(def_id)
10861086
}
10871087
Def::SelfTy(Some(_), None) => {
10881088
// Self in trait.
10891089
assert_eq!(opt_self_ty, None);
1090-
self.prohibit_type_params(&path.segments);
1090+
self.prohibit_generics(&path.segments);
10911091
tcx.mk_self_type()
10921092
}
10931093
Def::AssociatedTy(def_id) => {
1094-
self.prohibit_type_params(&path.segments[..path.segments.len()-2]);
1094+
self.prohibit_generics(&path.segments[..path.segments.len()-2]);
10951095
self.qpath_to_ty(span,
10961096
opt_self_ty,
10971097
def_id,
@@ -1100,7 +1100,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
11001100
}
11011101
Def::PrimTy(prim_ty) => {
11021102
assert_eq!(opt_self_ty, None);
1103-
self.prohibit_type_params(&path.segments);
1103+
self.prohibit_generics(&path.segments);
11041104
match prim_ty {
11051105
hir::TyBool => tcx.types.bool,
11061106
hir::TyChar => tcx.types.char,

‎src/librustc_typeck/check/mod.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4782,7 +4782,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
47824782
// errors if type parameters are provided in an inappropriate place.
47834783
let poly_segments = type_segment.is_some() as usize +
47844784
fn_segment.is_some() as usize;
4785-
AstConv::prohibit_type_params(self, &segments[..segments.len() - poly_segments]);
4785+
AstConv::prohibit_generics(self, &segments[..segments.len() - poly_segments]);
47864786

47874787
match def {
47884788
Def::Local(nid) | Def::Upvar(nid, ..) => {

‎src/librustc_typeck/check/wfcheck.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -602,8 +602,8 @@ fn check_method_receiver<'fcx, 'gcx, 'tcx>(fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
602602
}
603603

604604
fn check_variances_for_type_defn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
605-
item: &hir::Item,
606-
ast_generics: &hir::Generics)
605+
item: &hir::Item,
606+
hir_generics: &hir::Generics)
607607
{
608608
let item_def_id = tcx.hir.local_def_id(item.id);
609609
let ty = tcx.type_of(item_def_id);
@@ -631,7 +631,7 @@ fn check_variances_for_type_defn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
631631
continue;
632632
}
633633

634-
let param = &ast_generics.params[index];
634+
let param = &hir_generics.params[index];
635635
report_bivariance(tcx, param.span, param.name.name());
636636
}
637637
}

‎src/librustc_typeck/collect.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CollectItemTypesVisitor<'a, 'tcx> {
117117
for param in &generics.params {
118118
match param.kind {
119119
hir::GenericParamKind::Lifetime { .. } => {}
120-
hir::GenericParamKind::Type { ref default, .. } if default.is_some() => {
120+
hir::GenericParamKind::Type { default: Some(_), .. } => {
121121
let def_id = self.tcx.hir.local_def_id(param.id);
122122
self.tcx.type_of(def_id);
123123
}

0 commit comments

Comments
 (0)