From 96379e1659eb18daeaf7f86e9c8b69332a22b534 Mon Sep 17 00:00:00 2001 From: varkor Date: Tue, 26 Jun 2018 20:24:13 +0100 Subject: [PATCH] Refactor mod/check (part iii) --- src/librustc_typeck/check/mod.rs | 85 ++++++++++++++------------------ 1 file changed, 36 insertions(+), 49 deletions(-) diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 4b16cbbf750..98ec101c274 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -5001,7 +5001,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // FIXME(varkor): Separating out the parameters is messy. let mut lifetimes_type_seg = vec![]; let mut types_type_seg = vec![]; - let mut infer_types_type_seg = true; + let mut _infer_types_type_seg = true; if let Some((seg, _)) = type_segment { if let Some(ref data) = seg.args { for (i, arg) in data.args.iter().enumerate() { @@ -5011,12 +5011,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { } } } - infer_types_type_seg = seg.infer_types; + _infer_types_type_seg = seg.infer_types; } let mut lifetimes_fn_seg = vec![]; let mut types_fn_seg = vec![]; - let mut infer_types_fn_seg = true; + let mut _infer_types_fn_seg = true; if let Some((seg, _)) = fn_segment { if let Some(ref data) = seg.args { for (i, arg) in data.args.iter().enumerate() { @@ -5026,7 +5026,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { } } } - infer_types_fn_seg = seg.infer_types; + _infer_types_fn_seg = seg.infer_types; } let defs = self.tcx.generics_of(def.def_id()); @@ -5045,74 +5045,61 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { while let Some(def_id) = stack.pop() { let defs = self.tcx.generics_of(def_id); Substs::fill_single(&mut substs, defs, &mut |param: &ty::GenericParamDef, substs| { - let mut i = param.index as usize; - - let (lifetimes, types, infer_types) = if i < fn_start { + let lifetimes = if (param.index as usize) < fn_start { if let GenericParamDefKind::Type { .. } = param.kind { // Handle Self first, so we can adjust the index to match the AST. - if has_self && i == 0 { + if has_self && param.index == 0 { return opt_self_ty.map(|ty| ty.into()).unwrap_or_else(|| { self.var_for_def(span, param) }); } } - i -= has_self as usize; - (&lifetimes_type_seg, &types_type_seg, infer_types_type_seg) + &lifetimes_type_seg } else { - i -= fn_start; - (&lifetimes_fn_seg, &types_fn_seg, infer_types_fn_seg) + &lifetimes_fn_seg }; let mut pi = param.index as usize - has_self as usize; - let segment = if let Some(&PathSeg(_, ind)) = path_segs.iter().find(|&PathSeg(di, _)| *di == def_id) { + let (_segment, infer_types) = if let Some(&PathSeg(_, ind)) = path_segs.iter().find(|&PathSeg(di, _)| *di == def_id) { let seg = &segments[ind]; if lifetimes.len() == 0 { pi -= defs.own_counts().lifetimes; } - Some((seg, defs)) + if let Some(ref data) = seg.args { + if let Some(arg) = data.args.get(pi) { + return match param.kind { + GenericParamDefKind::Lifetime => { + let lt = match arg { + GenericArg::Lifetime(lt) => lt, + _ => bug!("should be a lifetime"), + }; + AstConv::ast_region_to_region(self, lt, Some(param)).into() + } + GenericParamDefKind::Type { .. } => { + // A provided type parameter. + let ty = match arg { + GenericArg::Type(ty) => ty, + _ => bug!("should be a type"), + }; + self.to_ty(ty).into() + } + }; + } + } + + (Some((seg, defs)), seg.infer_types) } else { - None + (None, true) }; - // eprintln!("{:?} {:?} {:?}", param.index, i, segment); - - - match param.kind { GenericParamDefKind::Lifetime => { - if let Some((z, lt)) = lifetimes.get(i) { - eprintln!("lifetime {:?} {:?} {:?}", pi, z, has_self); - if pi != *z { - eprintln!("error {:?} {:?} {:?} {:?} {:?} {:?}", pi, z, i, segment, fn_start, has_self); - bug!("uh oh") - } - AstConv::ast_region_to_region(self, lt, Some(param)).into() - } else { - self.re_infer(span, Some(param)).unwrap().into() - } + self.re_infer(span, Some(param)).unwrap().into() } - GenericParamDefKind::Type { .. } => { - // Skip over the lifetimes in the same segment. - if let Some((_, generics)) = segment { - i -= generics.own_counts().lifetimes; - } - - let has_default = match param.kind { - GenericParamDefKind::Type { has_default, .. } => has_default, - _ => unreachable!() - }; - - if let Some((z, ty)) = types.get(i) { - eprintln!("type {:?} {:?} {:?}", pi, z, has_self); - if pi != *z { - eprintln!("error {:?} {:?} {:?} {:?} {:?} {:?}", pi, z, i, segment, fn_start, has_self); - bug!("uh oh") - } - // A provided type parameter. - self.to_ty(ty).into() - } else if !infer_types && has_default { + GenericParamDefKind::Type { has_default, .. } => { + if !infer_types && has_default { // No type parameter provided, but a default exists. let default = self.tcx.type_of(param.def_id); self.normalize_ty(