From 31a07b0ce662e95119a76cce8dcfc29d2055f738 Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Mon, 2 May 2016 18:07:47 +0300 Subject: [PATCH] rustc_typeck: Generalize over 'tcx != 'gcx. --- src/librustc/infer/mod.rs | 2 +- .../infer/region_inference/graphviz.rs | 28 +- src/librustc/infer/region_inference/mod.rs | 30 +- src/librustc/middle/astconv_util.rs | 2 +- src/librustc/middle/expr_use_visitor.rs | 20 +- src/librustc/middle/free_region.rs | 10 +- src/librustc/middle/mem_categorization.rs | 30 +- src/librustc/ty/context.rs | 39 +- src/librustc/ty/mod.rs | 6 +- src/librustc/ty/structural_impls.rs | 77 +- src/librustc/ty/util.rs | 2 +- src/librustc_typeck/astconv.rs | 999 +++++++++--------- src/librustc_typeck/check/_match.rs | 29 +- src/librustc_typeck/check/assoc.rs | 13 +- src/librustc_typeck/check/callee.rs | 32 +- src/librustc_typeck/check/cast.rs | 30 +- src/librustc_typeck/check/closure.rs | 25 +- src/librustc_typeck/check/coercion.rs | 16 +- src/librustc_typeck/check/demand.rs | 14 +- src/librustc_typeck/check/dropck.rs | 24 +- src/librustc_typeck/check/intrinsic.rs | 1 - src/librustc_typeck/check/method/confirm.rs | 18 +- src/librustc_typeck/check/method/mod.rs | 6 +- src/librustc_typeck/check/method/probe.rs | 10 +- src/librustc_typeck/check/method/suggest.rs | 2 +- src/librustc_typeck/check/mod.rs | 160 ++- src/librustc_typeck/check/op.rs | 30 +- src/librustc_typeck/check/regionck.rs | 14 +- src/librustc_typeck/check/upvar.rs | 18 +- src/librustc_typeck/check/wfcheck.rs | 6 +- src/librustc_typeck/check/writeback.rs | 42 +- src/librustc_typeck/collect.rs | 40 +- src/librustc_typeck/lib.rs | 51 +- 33 files changed, 940 insertions(+), 886 deletions(-) diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs index fdb4c3500c6..e6d9db20ece 100644 --- a/src/librustc/infer/mod.rs +++ b/src/librustc/infer/mod.rs @@ -89,7 +89,7 @@ pub struct InferCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { float_unification_table: RefCell>, // For region variables. - region_vars: RegionVarBindings<'a, 'tcx>, + region_vars: RegionVarBindings<'a, 'gcx, 'tcx>, pub parameter_environment: ty::ParameterEnvironment<'gcx>, diff --git a/src/librustc/infer/region_inference/graphviz.rs b/src/librustc/infer/region_inference/graphviz.rs index 5c39e39bee0..c9037d6b12a 100644 --- a/src/librustc/infer/region_inference/graphviz.rs +++ b/src/librustc/infer/region_inference/graphviz.rs @@ -53,8 +53,10 @@ graphs will be printed. \n\ "); } -pub fn maybe_print_constraints_for<'a, 'tcx>(region_vars: &RegionVarBindings<'a, 'tcx>, - subject_node: ast::NodeId) { +pub fn maybe_print_constraints_for<'a, 'gcx, 'tcx>( + region_vars: &RegionVarBindings<'a, 'gcx, 'tcx>, + subject_node: ast::NodeId) +{ let tcx = region_vars.tcx; if !region_vars.tcx.sess.opts.debugging_opts.print_region_graph { @@ -118,8 +120,8 @@ pub fn maybe_print_constraints_for<'a, 'tcx>(region_vars: &RegionVarBindings<'a, } } -struct ConstraintGraph<'a, 'tcx: 'a> { - tcx: TyCtxt<'a, 'tcx, 'tcx>, +struct ConstraintGraph<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { + tcx: TyCtxt<'a, 'gcx, 'tcx>, graph_name: String, map: &'a FnvHashMap>, node_ids: FnvHashMap, @@ -138,11 +140,11 @@ enum Edge { EnclScope(CodeExtent, CodeExtent), } -impl<'a, 'tcx> ConstraintGraph<'a, 'tcx> { - fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>, +impl<'a, 'gcx, 'tcx> ConstraintGraph<'a, 'gcx, 'tcx> { + fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>, name: String, map: &'a ConstraintMap<'tcx>) - -> ConstraintGraph<'a, 'tcx> { + -> ConstraintGraph<'a, 'gcx, 'tcx> { let mut i = 0; let mut node_ids = FnvHashMap(); { @@ -173,7 +175,7 @@ impl<'a, 'tcx> ConstraintGraph<'a, 'tcx> { } } -impl<'a, 'tcx> dot::Labeller<'a> for ConstraintGraph<'a, 'tcx> { +impl<'a, 'gcx, 'tcx> dot::Labeller<'a> for ConstraintGraph<'a, 'gcx, 'tcx> { type Node = Node; type Edge = Edge; fn graph_id(&self) -> dot::Id { @@ -226,7 +228,7 @@ fn edge_to_nodes(e: &Edge) -> (Node, Node) { } } -impl<'a, 'tcx> dot::GraphWalk<'a> for ConstraintGraph<'a, 'tcx> { +impl<'a, 'gcx, 'tcx> dot::GraphWalk<'a> for ConstraintGraph<'a, 'gcx, 'tcx> { type Node = Node; type Edge = Edge; fn nodes(&self) -> dot::Nodes { @@ -258,10 +260,10 @@ impl<'a, 'tcx> dot::GraphWalk<'a> for ConstraintGraph<'a, 'tcx> { pub type ConstraintMap<'tcx> = FnvHashMap>; -fn dump_region_constraints_to<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, - map: &ConstraintMap<'tcx>, - path: &str) - -> io::Result<()> { +fn dump_region_constraints_to<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>, + map: &ConstraintMap<'tcx>, + path: &str) + -> io::Result<()> { debug!("dump_region_constraints map (len: {}) path: {}", map.len(), path); diff --git a/src/librustc/infer/region_inference/mod.rs b/src/librustc/infer/region_inference/mod.rs index 3e231f8bb3e..b889d0a9daa 100644 --- a/src/librustc/infer/region_inference/mod.rs +++ b/src/librustc/infer/region_inference/mod.rs @@ -190,8 +190,8 @@ impl SameRegions { pub type CombineMap = FnvHashMap; -pub struct RegionVarBindings<'a, 'tcx: 'a> { - tcx: TyCtxt<'a, 'tcx, 'tcx>, +pub struct RegionVarBindings<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { + tcx: TyCtxt<'a, 'gcx, 'tcx>, var_origins: RefCell>, // Constraints of the form `A <= B` introduced by the region @@ -253,8 +253,8 @@ pub struct RegionSnapshot { skolemization_count: u32, } -impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { - pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> RegionVarBindings<'a, 'tcx> { +impl<'a, 'gcx, 'tcx> RegionVarBindings<'a, 'gcx, 'tcx> { + pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> RegionVarBindings<'a, 'gcx, 'tcx> { RegionVarBindings { tcx: tcx, var_origins: RefCell::new(Vec::new()), @@ -600,7 +600,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { origin: SubregionOrigin<'tcx>, mut relate: F) -> Region - where F: FnMut(&RegionVarBindings<'a, 'tcx>, Region, Region) + where F: FnMut(&RegionVarBindings<'a, 'gcx, 'tcx>, Region, Region) { let vars = TwoRegions { a: a, b: b }; match self.combine_map(t).borrow().get(&vars) { @@ -816,7 +816,7 @@ struct RegionAndOrigin<'tcx> { type RegionGraph = graph::Graph<(), Constraint>; -impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { +impl<'a, 'gcx, 'tcx> RegionVarBindings<'a, 'gcx, 'tcx> { fn infer_variable_values(&self, free_regions: &FreeRegionMap, errors: &mut Vec>, @@ -1249,11 +1249,11 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { let WalkState {result, dup_found, ..} = state; return (result, dup_found); - fn process_edges<'a, 'tcx>(this: &RegionVarBindings<'a, 'tcx>, - state: &mut WalkState<'tcx>, - graph: &RegionGraph, - source_vid: RegionVid, - dir: Direction) { + fn process_edges<'a, 'gcx, 'tcx>(this: &RegionVarBindings<'a, 'gcx, 'tcx>, + state: &mut WalkState<'tcx>, + graph: &RegionGraph, + source_vid: RegionVid, + dir: Direction) { debug!("process_edges(source_vid={:?}, dir={:?})", source_vid, dir); let source_node_index = NodeIndex(source_vid.index as usize); @@ -1362,8 +1362,8 @@ impl<'tcx> fmt::Display for GenericKind<'tcx> { } } -impl<'a, 'tcx> GenericKind<'tcx> { - pub fn to_ty(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Ty<'tcx> { +impl<'a, 'gcx, 'tcx> GenericKind<'tcx> { + pub fn to_ty(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> { match *self { GenericKind::Param(ref p) => p.to_ty(tcx), GenericKind::Projection(ref p) => tcx.mk_projection(p.trait_ref.clone(), p.item_name), @@ -1371,7 +1371,7 @@ impl<'a, 'tcx> GenericKind<'tcx> { } } -impl<'a, 'tcx> VerifyBound { +impl<'a, 'gcx, 'tcx> VerifyBound { fn for_each_region(&self, f: &mut FnMut(ty::Region)) { match self { &VerifyBound::AnyRegion(ref rs) | @@ -1424,7 +1424,7 @@ impl<'a, 'tcx> VerifyBound { } } - fn is_met(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, + fn is_met(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, free_regions: &FreeRegionMap, var_values: &Vec, min: ty::Region) diff --git a/src/librustc/middle/astconv_util.rs b/src/librustc/middle/astconv_util.rs index 99521f9ef0f..4129c53c988 100644 --- a/src/librustc/middle/astconv_util.rs +++ b/src/librustc/middle/astconv_util.rs @@ -20,7 +20,7 @@ use ty::{Ty, TyCtxt}; use syntax::codemap::Span; use hir as ast; -impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { pub fn prohibit_type_params(self, segments: &[ast::PathSegment]) { for segment in segments { for typ in segment.parameters.types() { diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 6bb3c380234..4cee8c5d89a 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -209,8 +209,7 @@ enum OverloadedCallType { } impl OverloadedCallType { - fn from_trait_id<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, trait_id: DefId) - -> OverloadedCallType { + fn from_trait_id(tcx: TyCtxt, trait_id: DefId) -> OverloadedCallType { for &(maybe_function_trait, overloaded_call_type) in &[ (tcx.lang_items.fn_once_trait(), FnOnceOverloadedCall), (tcx.lang_items.fn_mut_trait(), FnMutOverloadedCall), @@ -227,8 +226,7 @@ impl OverloadedCallType { bug!("overloaded call didn't map to known function trait") } - fn from_method_id<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, method_id: DefId) - -> OverloadedCallType { + fn from_method_id(tcx: TyCtxt, method_id: DefId) -> OverloadedCallType { let method = tcx.impl_or_trait_item(method_id); OverloadedCallType::from_trait_id(tcx, method.container().id()) } @@ -271,9 +269,9 @@ enum PassArgs { ByRef, } -impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> { pub fn new(delegate: &'a mut (Delegate<'tcx>+'a), - infcx: &'a InferCtxt<'a, 'tcx, 'tcx>) -> Self + infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) -> Self { ExprUseVisitor { mc: mc::MemCategorizationContext::new(infcx), @@ -305,7 +303,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx, 'tcx> { } } - fn tcx(&self) -> TyCtxt<'a, 'tcx, 'tcx> { + fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.mc.infcx.tcx } @@ -1184,10 +1182,10 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx, 'tcx> { } } -fn copy_or_move<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx, 'tcx>, - cmt: &mc::cmt<'tcx>, - move_reason: MoveReason) - -> ConsumeMode +fn copy_or_move<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>, + cmt: &mc::cmt<'tcx>, + move_reason: MoveReason) + -> ConsumeMode { if infcx.type_moves_by_default(cmt.ty, cmt.span) { Move(move_reason) diff --git a/src/librustc/middle/free_region.rs b/src/librustc/middle/free_region.rs index 90d4627c93d..e4ce8976713 100644 --- a/src/librustc/middle/free_region.rs +++ b/src/librustc/middle/free_region.rs @@ -120,11 +120,11 @@ impl FreeRegionMap { /// Determines whether one region is a subregion of another. This is intended to run *after /// inference* and sadly the logic is somewhat duplicated with the code in infer.rs. - pub fn is_subregion_of<'a, 'tcx>(&self, - tcx: TyCtxt<'a, 'tcx, 'tcx>, - sub_region: ty::Region, - super_region: ty::Region) - -> bool { + pub fn is_subregion_of(&self, + tcx: TyCtxt, + sub_region: ty::Region, + super_region: ty::Region) + -> bool { let result = sub_region == super_region || { match (sub_region, super_region) { (ty::ReEmpty, _) | diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 53e6102587b..3999b02425d 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -302,9 +302,7 @@ impl MutabilityCategory { ret } - fn from_local<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, - id: ast::NodeId) - -> MutabilityCategory { + fn from_local(tcx: TyCtxt, id: ast::NodeId) -> MutabilityCategory { let ret = match tcx.map.get(id) { ast_map::NodeLocal(p) => match p.node { PatKind::Ident(bind_mode, _, _) => { @@ -360,13 +358,13 @@ impl MutabilityCategory { } } -impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx, 'tcx> { - pub fn new(infcx: &'a InferCtxt<'a, 'tcx, 'tcx>) - -> MemCategorizationContext<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> { + pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) + -> MemCategorizationContext<'a, 'gcx, 'tcx> { MemCategorizationContext { infcx: infcx } } - fn tcx(&self) -> TyCtxt<'a, 'tcx, 'tcx> { + fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.infcx.tcx } @@ -1074,9 +1072,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx, 'tcx> { slice_pat: &hir::Pat) -> McResult<(cmt<'tcx>, hir::Mutability, ty::Region)> { let slice_ty = self.node_ty(slice_pat.id)?; - let (slice_mutbl, slice_r) = vec_slice_info(self.tcx(), - slice_pat, - slice_ty); + let (slice_mutbl, slice_r) = vec_slice_info(slice_pat, slice_ty); let context = InteriorOffsetKind::Pattern; let cmt_vec = self.deref_vec(slice_pat, vec_cmt, context)?; let cmt_slice = self.cat_index(slice_pat, cmt_vec, context)?; @@ -1085,14 +1081,12 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx, 'tcx> { /// In a pattern like [a, b, ..c], normally `c` has slice type, but if you have [a, b, /// ..ref c], then the type of `ref c` will be `&&[]`, so to extract the slice details we /// have to recurse through rptrs. - fn vec_slice_info<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, - pat: &hir::Pat, - slice_ty: Ty) - -> (hir::Mutability, ty::Region) { + fn vec_slice_info(pat: &hir::Pat, slice_ty: Ty) + -> (hir::Mutability, ty::Region) { match slice_ty.sty { ty::TyRef(r, ref mt) => match mt.ty.sty { ty::TySlice(_) => (mt.mutbl, *r), - _ => vec_slice_info(tcx, pat, mt.ty), + _ => vec_slice_info(pat, mt.ty), }, _ => { @@ -1140,7 +1134,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx, 'tcx> { } pub fn cat_pattern(&self, cmt: cmt<'tcx>, pat: &hir::Pat, mut op: F) -> McResult<()> - where F: FnMut(&MemCategorizationContext<'a, 'tcx, 'tcx>, cmt<'tcx>, &hir::Pat), + where F: FnMut(&MemCategorizationContext<'a, 'gcx, 'tcx>, cmt<'tcx>, &hir::Pat), { self.cat_pattern_(cmt, pat, &mut op) } @@ -1148,7 +1142,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx, 'tcx> { // FIXME(#19596) This is a workaround, but there should be a better way to do this fn cat_pattern_(&self, cmt: cmt<'tcx>, pat: &hir::Pat, op: &mut F) -> McResult<()> - where F : FnMut(&MemCategorizationContext<'a, 'tcx, 'tcx>, cmt<'tcx>, &hir::Pat), + where F : FnMut(&MemCategorizationContext<'a, 'gcx, 'tcx>, cmt<'tcx>, &hir::Pat), { // Here, `cmt` is the categorization for the value being // matched and pat is the pattern it is being matched against. @@ -1466,7 +1460,7 @@ impl<'tcx> cmt_<'tcx> { } - pub fn descriptive_string<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> String { + pub fn descriptive_string(&self, tcx: TyCtxt) -> String { match self.cat { Categorization::StaticItem => { "static item".to_string() diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 69e979f6273..f5610de062f 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -92,7 +92,7 @@ struct CtxtInterners<'tcx> { type_list: RefCell>>, substs: RefCell>>, bare_fn: RefCell>>, - region: RefCell>, + region: RefCell>>, stability: RefCell>, layout: RefCell>, } @@ -740,6 +740,23 @@ impl<'a, 'tcx> Lift<'tcx> for &'a Substs<'a> { } } +impl<'a, 'tcx> Lift<'tcx> for &'a Region { + type Lifted = &'tcx Region; + fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<&'tcx Region> { + if let Some(&InternedRegion { region }) = tcx.interners.region.borrow().get(*self) { + if *self as *const _ == region as *const _ { + return Some(region); + } + } + // Also try in the global tcx if we're not that. + if !tcx.is_global() { + self.lift_to_tcx(tcx.global_tcx()) + } else { + None + } + } +} + impl<'a, 'tcx> Lift<'tcx> for &'a [Ty<'a>] { type Lifted = &'tcx [Ty<'tcx>]; fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<&'tcx [Ty<'tcx>]> { @@ -953,6 +970,18 @@ impl<'tcx: 'lcx, 'lcx> Borrow> for InternedSubsts<'tcx> { } } +/// An entry in the region interner. +#[derive(PartialEq, Eq, Hash)] +struct InternedRegion<'tcx> { + region: &'tcx Region +} + +impl<'tcx> Borrow for InternedRegion<'tcx> { + fn borrow<'a>(&'a self) -> &'a Region { + self.region + } +} + fn bound_list_is_sorted(bounds: &[ty::PolyProjectionPredicate]) -> bool { bounds.is_empty() || bounds[1..].iter().enumerate().all( @@ -1006,12 +1035,14 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } pub fn mk_region(self, region: Region) -> &'tcx Region { - if let Some(region) = self.interners.region.borrow().get(®ion) { - return *region; + if let Some(interned) = self.interners.region.borrow().get(®ion) { + return interned.region; } let region = self.interners.arenas.region.alloc(region); - self.interners.region.borrow_mut().insert(region); + self.interners.region.borrow_mut().insert(InternedRegion { + region: region + }); region } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 27f74de2470..7bede488964 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -1590,7 +1590,7 @@ impl<'a, 'gcx, 'tcx, 'container> AdtDefData<'gcx, 'container> { } } - fn calculate_dtorck(&'gcx self, tcx: TyCtxt<'a, 'gcx, 'tcx>) { + fn calculate_dtorck(&'gcx self, tcx: TyCtxt) { if tcx.is_adt_dtorck(self) { self.flags.set(self.flags.get() | AdtFlags::IS_DTORCK); } @@ -1611,7 +1611,7 @@ impl<'a, 'gcx, 'tcx, 'container> AdtDefData<'gcx, 'container> { /// true, this type being safe for destruction requires it to be /// alive; Otherwise, only the contents are required to be. #[inline] - pub fn is_dtorck(&'gcx self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> bool { + pub fn is_dtorck(&'gcx self, tcx: TyCtxt) -> bool { if !self.flags.get().intersects(AdtFlags::IS_DTORCK_VALID) { self.calculate_dtorck(tcx) } @@ -2932,7 +2932,7 @@ pub enum ExplicitSelfCategory { ByBox, } -impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { pub fn with_freevars(self, fid: NodeId, f: F) -> T where F: FnOnce(&[hir::Freevar]) -> T, { diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index 088ca15acb9..284019ed6a2 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -32,7 +32,10 @@ impl<'tcx, A: Lift<'tcx>, B: Lift<'tcx>> Lift<'tcx> for (A, B) { impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for Option { type Lifted = Option; fn lift_to_tcx<'a, 'gcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Option { - self.as_ref().map(|x| tcx.lift(x)) + match *self { + Some(ref x) => tcx.lift(x).map(Some), + None => Some(None) + } } } @@ -63,6 +66,13 @@ impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for [T] { } } +impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for Vec { + type Lifted = Vec; + fn lift_to_tcx<'a, 'gcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Option { + tcx.lift(&self[..]) + } +} + impl<'tcx> Lift<'tcx> for ty::Region { type Lifted = Self; fn lift_to_tcx(&self, _: TyCtxt) -> Option { @@ -140,6 +150,71 @@ impl<'a, 'tcx> Lift<'tcx> for ty::ClosureSubsts<'a> { } } +impl<'a, 'tcx> Lift<'tcx> for ty::ItemSubsts<'a> { + type Lifted = ty::ItemSubsts<'tcx>; + fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { + tcx.lift(&self.substs).map(|substs| { + ty::ItemSubsts { + substs: substs + } + }) + } +} + +impl<'a, 'tcx> Lift<'tcx> for ty::adjustment::AutoRef<'a> { + type Lifted = ty::adjustment::AutoRef<'tcx>; + fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { + match *self { + ty::adjustment::AutoPtr(r, m) => { + tcx.lift(&r).map(|r| ty::adjustment::AutoPtr(r, m)) + } + ty::adjustment::AutoUnsafe(m) => { + Some(ty::adjustment::AutoUnsafe(m)) + } + } + } +} + +impl<'a, 'tcx> Lift<'tcx> for ty::FnOutput<'a> { + type Lifted = ty::FnOutput<'tcx>; + fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { + match *self { + ty::FnConverging(ty) => { + tcx.lift(&ty).map(ty::FnConverging) + } + ty::FnDiverging => Some(ty::FnDiverging) + } + } +} + +impl<'a, 'tcx> Lift<'tcx> for ty::FnSig<'a> { + type Lifted = ty::FnSig<'tcx>; + fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { + tcx.lift(&self.inputs[..]).and_then(|inputs| { + tcx.lift(&self.output).map(|output| { + ty::FnSig { + inputs: inputs, + output: output, + variadic: self.variadic + } + }) + }) + } +} + +impl<'a, 'tcx> Lift<'tcx> for ty::ClosureTy<'a> { + type Lifted = ty::ClosureTy<'tcx>; + fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { + tcx.lift(&self.sig).map(|sig| { + ty::ClosureTy { + sig: sig, + unsafety: self.unsafety, + abi: self.abi + } + }) + } +} + impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for ty::error::ExpectedFound { type Lifted = ty::error::ExpectedFound; fn lift_to_tcx<'a, 'gcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Option { diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs index 88ebb332354..4b96527cbe1 100644 --- a/src/librustc/ty/util.rs +++ b/src/librustc/ty/util.rs @@ -489,7 +489,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { /// `adt` that do not strictly outlive the adt value itself. /// (This allows programs to make cyclic structures without /// resorting to unasfe means; see RFCs 769 and 1238). - pub fn is_adt_dtorck(self, adt: ty::AdtDef<'tcx>) -> bool { + pub fn is_adt_dtorck(self, adt: ty::AdtDef) -> bool { let dtor_method = match adt.destructor() { Some(dtor) => dtor, None => return false diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 9825829e3bd..b6f1e86780b 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -149,6 +149,27 @@ pub trait AstConv<'gcx, 'tcx> { fn set_tainted_by_errors(&self); } +#[derive(PartialEq, Eq)] +pub enum PathParamMode { + // Any path in a type context. + Explicit, + // The `module::Type` in `module::Type::method` in an expression. + Optional +} + +struct ConvertedBinding<'tcx> { + item_name: ast::Name, + ty: Ty<'tcx>, + span: Span, +} + +struct SelfInfo<'a, 'tcx> { + untransformed_self_ty: Ty<'tcx>, + explicit_self: &'a hir::ExplicitSelf, +} + +type TraitAndProjections<'tcx> = (ty::PolyTraitRef<'tcx>, Vec>); + pub fn ast_region_to_region(tcx: TyCtxt, lifetime: &hir::Lifetime) -> ty::Region { let r = match tcx.named_region_map.get(&lifetime.id) { @@ -254,21 +275,21 @@ fn report_elision_failure( } } -pub fn opt_ast_region_to_region<'tcx>( - this: &AstConv<'tcx, 'tcx>, +impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o { +pub fn opt_ast_region_to_region(&self, rscope: &RegionScope, default_span: Span, opt_lifetime: &Option) -> ty::Region { let r = match *opt_lifetime { Some(ref lifetime) => { - ast_region_to_region(this.tcx(), lifetime) + ast_region_to_region(self.tcx(), lifetime) } None => match rscope.anon_regions(default_span, 1) { Ok(rs) => rs[0], Err(params) => { - let mut err = struct_span_err!(this.tcx().sess, default_span, E0106, + let mut err = struct_span_err!(self.tcx().sess, default_span, E0106, "missing lifetime specifier"); if let Some(params) = params { report_elision_failure(&mut err, params); @@ -288,8 +309,7 @@ pub fn opt_ast_region_to_region<'tcx>( /// Given a path `path` that refers to an item `I` with the declared generics `decl_generics`, /// returns an appropriate set of substitutions for this particular reference to `I`. -pub fn ast_path_substs_for_ty<'tcx>( - this: &AstConv<'tcx, 'tcx>, +pub fn ast_path_substs_for_ty(&self, rscope: &RegionScope, span: Span, param_mode: PathParamMode, @@ -297,7 +317,7 @@ pub fn ast_path_substs_for_ty<'tcx>( item_segment: &hir::PathSegment) -> Substs<'tcx> { - let tcx = this.tcx(); + let tcx = self.tcx(); // ast_path_substs() is only called to convert paths that are // known to refer to traits, types, or structs. In these cases, @@ -312,7 +332,7 @@ pub fn ast_path_substs_for_ty<'tcx>( let (regions, types, assoc_bindings) = match item_segment.parameters { hir::AngleBracketedParameters(ref data) => { - convert_angle_bracketed_parameters(this, rscope, span, decl_generics, data) + self.convert_angle_bracketed_parameters(rscope, span, decl_generics, data) } hir::ParenthesizedParameters(..) => { span_err!(tcx.sess, span, E0214, @@ -324,34 +344,24 @@ pub fn ast_path_substs_for_ty<'tcx>( } }; - assoc_bindings.first().map(|b| this.tcx().prohibit_projection(b.span)); + assoc_bindings.first().map(|b| self.tcx().prohibit_projection(b.span)); - create_substs_for_ast_path(this, - span, - param_mode, - decl_generics, - None, - types, - regions) + self.create_substs_for_ast_path(span, + param_mode, + decl_generics, + None, + types, + regions) } -#[derive(PartialEq, Eq)] -pub enum PathParamMode { - // Any path in a type context. - Explicit, - // The `module::Type` in `module::Type::method` in an expression. - Optional -} - -fn create_region_substs<'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn create_region_substs(&self, rscope: &RegionScope, span: Span, decl_generics: &ty::Generics<'tcx>, regions_provided: Vec) -> Substs<'tcx> { - let tcx = this.tcx(); + let tcx = self.tcx(); // If the type is parameterized by this region, then replace this // region with the current anon region binding (in other words, @@ -387,8 +397,7 @@ fn create_region_substs<'tcx>( /// The `region_substs` should be the result of `create_region_substs` /// -- that is, a substitution with no types but the correct number of /// regions. -fn create_substs_for_ast_path<'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn create_substs_for_ast_path(&self, span: Span, param_mode: PathParamMode, decl_generics: &ty::Generics<'tcx>, @@ -397,7 +406,7 @@ fn create_substs_for_ast_path<'tcx>( region_substs: Substs<'tcx>) -> Substs<'tcx> { - let tcx = this.tcx(); + let tcx = self.tcx(); debug!("create_substs_for_ast_path(decl_generics={:?}, self_ty={:?}, \ types_provided={:?}, region_substs={:?})", @@ -414,16 +423,15 @@ fn create_substs_for_ast_path<'tcx>( .take_while(|x| x.default.is_none()) .count(); - let mut type_substs = get_type_substs_for_defs(this, - span, - types_provided, - param_mode, - ty_param_defs, - region_substs.clone(), - self_ty); + let mut type_substs = self.get_type_substs_for_defs(span, + types_provided, + param_mode, + ty_param_defs, + region_substs.clone(), + self_ty); let supplied_ty_param_count = type_substs.len(); - check_type_argument_count(this.tcx(), span, supplied_ty_param_count, + check_type_argument_count(self.tcx(), span, supplied_ty_param_count, required_ty_param_count, formal_ty_param_count); if supplied_ty_param_count < required_ty_param_count { @@ -489,14 +497,14 @@ fn create_substs_for_ast_path<'tcx>( /// Returns types_provided if it is not empty, otherwise populating the /// type parameters with inference variables as appropriate. -fn get_type_substs_for_defs<'tcx>(this: &AstConv<'tcx, 'tcx>, - span: Span, - types_provided: Vec>, - param_mode: PathParamMode, - ty_param_defs: &[ty::TypeParameterDef<'tcx>], - mut substs: Substs<'tcx>, - self_ty: Option>) - -> Vec> +fn get_type_substs_for_defs(&self, + span: Span, + types_provided: Vec>, + param_mode: PathParamMode, + ty_param_defs: &[ty::TypeParameterDef<'tcx>], + mut substs: Substs<'tcx>, + self_ty: Option>) + -> Vec> { fn default_type_parameter<'tcx>(p: &ty::TypeParameterDef<'tcx>, self_ty: Option>) -> Option> @@ -515,7 +523,7 @@ fn get_type_substs_for_defs<'tcx>(this: &AstConv<'tcx, 'tcx>, if param_mode == PathParamMode::Optional && types_provided.is_empty() { ty_param_defs .iter() - .map(|p| this.ty_infer(default_type_parameter(p, self_ty), Some(&mut substs), + .map(|p| self.ty_infer(default_type_parameter(p, self_ty), Some(&mut substs), Some(TypeSpace), span)) .collect() } else { @@ -523,40 +531,34 @@ fn get_type_substs_for_defs<'tcx>(this: &AstConv<'tcx, 'tcx>, } } -struct ConvertedBinding<'tcx> { - item_name: ast::Name, - ty: Ty<'tcx>, - span: Span, -} - -fn convert_angle_bracketed_parameters<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - span: Span, - decl_generics: &ty::Generics<'tcx>, - data: &hir::AngleBracketedParameterData) - -> (Substs<'tcx>, - Vec>, - Vec>) +fn convert_angle_bracketed_parameters(&self, + rscope: &RegionScope, + span: Span, + decl_generics: &ty::Generics<'tcx>, + data: &hir::AngleBracketedParameterData) + -> (Substs<'tcx>, + Vec>, + Vec>) { let regions: Vec<_> = data.lifetimes.iter() - .map(|l| ast_region_to_region(this.tcx(), l)) + .map(|l| ast_region_to_region(self.tcx(), l)) .collect(); let region_substs = - create_region_substs(this, rscope, span, decl_generics, regions); + self.create_region_substs(rscope, span, decl_generics, regions); let types: Vec<_> = data.types.iter() .enumerate() - .map(|(i,t)| ast_ty_arg_to_ty(this, rscope, decl_generics, - i, ®ion_substs, t)) + .map(|(i,t)| self.ast_ty_arg_to_ty(rscope, decl_generics, + i, ®ion_substs, t)) .collect(); let assoc_bindings: Vec<_> = data.bindings.iter() .map(|b| ConvertedBinding { item_name: b.name, - ty: ast_ty_to_ty(this, rscope, &b.ty), + ty: self.ast_ty_to_ty(rscope, &b.ty), span: b.span }) .collect(); @@ -566,11 +568,11 @@ fn convert_angle_bracketed_parameters<'tcx>(this: &AstConv<'tcx, 'tcx>, /// Returns the appropriate lifetime to use for any output lifetimes /// (if one exists) and a vector of the (pattern, number of lifetimes) /// corresponding to each input type/pattern. -fn find_implied_output_region<'tcx>(this: &AstConv<'tcx, 'tcx>, - input_tys: &[Ty<'tcx>], - input_pats: Vec) -> ElidedLifetime +fn find_implied_output_region(&self, + input_tys: &[Ty<'tcx>], + input_pats: Vec) -> ElidedLifetime { - let tcx = this.tcx(); + let tcx = self.tcx(); let mut lifetimes_for_params = Vec::new(); let mut possible_implied_output_region = None; @@ -602,59 +604,57 @@ fn find_implied_output_region<'tcx>(this: &AstConv<'tcx, 'tcx>, } } -fn convert_ty_with_lifetime_elision<'tcx>(this: &AstConv<'tcx, 'tcx>, - elided_lifetime: ElidedLifetime, - ty: &hir::Ty) - -> Ty<'tcx> +fn convert_ty_with_lifetime_elision(&self, + elided_lifetime: ElidedLifetime, + ty: &hir::Ty) + -> Ty<'tcx> { match elided_lifetime { Ok(implied_output_region) => { let rb = ElidableRscope::new(implied_output_region); - ast_ty_to_ty(this, &rb, ty) + self.ast_ty_to_ty(&rb, ty) } Err(param_lifetimes) => { // All regions must be explicitly specified in the output // if the lifetime elision rules do not apply. This saves // the user from potentially-confusing errors. let rb = UnelidableRscope::new(param_lifetimes); - ast_ty_to_ty(this, &rb, ty) + self.ast_ty_to_ty(&rb, ty) } } } -fn convert_parenthesized_parameters<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - span: Span, - decl_generics: &ty::Generics<'tcx>, - data: &hir::ParenthesizedParameterData) - -> (Substs<'tcx>, - Vec>, - Vec>) +fn convert_parenthesized_parameters(&self, + rscope: &RegionScope, + span: Span, + decl_generics: &ty::Generics<'tcx>, + data: &hir::ParenthesizedParameterData) + -> (Substs<'tcx>, + Vec>, + Vec>) { let region_substs = - create_region_substs(this, rscope, span, decl_generics, Vec::new()); + self.create_region_substs(rscope, span, decl_generics, Vec::new()); let binding_rscope = BindingRscope::new(); let inputs = data.inputs.iter() - .map(|a_t| ast_ty_arg_to_ty(this, &binding_rscope, decl_generics, - 0, ®ion_substs, a_t)) + .map(|a_t| self.ast_ty_arg_to_ty(&binding_rscope, decl_generics, + 0, ®ion_substs, a_t)) .collect::>>(); let input_params = vec![String::new(); inputs.len()]; - let implied_output_region = find_implied_output_region(this, &inputs, input_params); + let implied_output_region = self.find_implied_output_region(&inputs, input_params); - let input_ty = this.tcx().mk_tup(inputs); + let input_ty = self.tcx().mk_tup(inputs); let (output, output_span) = match data.output { Some(ref output_ty) => { - (convert_ty_with_lifetime_elision(this, - implied_output_region, - &output_ty), + (self.convert_ty_with_lifetime_elision(implied_output_region, &output_ty), output_ty.span) } None => { - (this.tcx().mk_nil(), data.span) + (self.tcx().mk_nil(), data.span) } }; @@ -667,8 +667,7 @@ fn convert_parenthesized_parameters<'tcx>(this: &AstConv<'tcx, 'tcx>, (region_substs, vec![input_ty], vec![output_binding]) } -pub fn instantiate_poly_trait_ref<'tcx>( - this: &AstConv<'tcx, 'tcx>, +pub fn instantiate_poly_trait_ref(&self, rscope: &RegionScope, ast_trait_ref: &hir::PolyTraitRef, self_ty: Option>, @@ -676,15 +675,14 @@ pub fn instantiate_poly_trait_ref<'tcx>( -> ty::PolyTraitRef<'tcx> { let trait_ref = &ast_trait_ref.trait_ref; - let trait_def_id = trait_def_id(this, trait_ref); - ast_path_to_poly_trait_ref(this, - rscope, - trait_ref.path.span, - PathParamMode::Explicit, - trait_def_id, - self_ty, - trait_ref.path.segments.last().unwrap(), - poly_projections) + let trait_def_id = self.trait_def_id(trait_ref); + self.ast_path_to_poly_trait_ref(rscope, + trait_ref.path.span, + PathParamMode::Explicit, + trait_def_id, + self_ty, + trait_ref.path.segments.last().unwrap(), + poly_projections) } /// Instantiates the path for the given trait reference, assuming that it's @@ -693,39 +691,36 @@ pub fn instantiate_poly_trait_ref<'tcx>( /// /// If the `projections` argument is `None`, then assoc type bindings like `Foo` /// are disallowed. Otherwise, they are pushed onto the vector given. -pub fn instantiate_mono_trait_ref<'tcx>( - this: &AstConv<'tcx, 'tcx>, +pub fn instantiate_mono_trait_ref(&self, rscope: &RegionScope, trait_ref: &hir::TraitRef, self_ty: Option>) -> ty::TraitRef<'tcx> { - let trait_def_id = trait_def_id(this, trait_ref); - ast_path_to_mono_trait_ref(this, - rscope, - trait_ref.path.span, - PathParamMode::Explicit, - trait_def_id, - self_ty, - trait_ref.path.segments.last().unwrap()) + let trait_def_id = self.trait_def_id(trait_ref); + self.ast_path_to_mono_trait_ref(rscope, + trait_ref.path.span, + PathParamMode::Explicit, + trait_def_id, + self_ty, + trait_ref.path.segments.last().unwrap()) } -fn trait_def_id<'tcx>(this: &AstConv<'tcx, 'tcx>, trait_ref: &hir::TraitRef) -> DefId { +fn trait_def_id(&self, trait_ref: &hir::TraitRef) -> DefId { let path = &trait_ref.path; - match ::lookup_full_def(this.tcx(), path.span, trait_ref.ref_id) { + match ::lookup_full_def(self.tcx(), path.span, trait_ref.ref_id) { Def::Trait(trait_def_id) => trait_def_id, Def::Err => { - this.tcx().sess.fatal("cannot continue compilation due to previous error"); + self.tcx().sess.fatal("cannot continue compilation due to previous error"); } _ => { - span_fatal!(this.tcx().sess, path.span, E0245, "`{}` is not a trait", + span_fatal!(self.tcx().sess, path.span, E0245, "`{}` is not a trait", path); } } } -fn object_path_to_poly_trait_ref<'a,'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn object_path_to_poly_trait_ref(&self, rscope: &RegionScope, span: Span, param_mode: PathParamMode, @@ -734,18 +729,16 @@ fn object_path_to_poly_trait_ref<'a,'tcx>( mut projections: &mut Vec>) -> ty::PolyTraitRef<'tcx> { - ast_path_to_poly_trait_ref(this, - rscope, - span, - param_mode, - trait_def_id, - None, - trait_segment, - projections) + self.ast_path_to_poly_trait_ref(rscope, + span, + param_mode, + trait_def_id, + None, + trait_segment, + projections) } -fn ast_path_to_poly_trait_ref<'a,'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn ast_path_to_poly_trait_ref(&self, rscope: &RegionScope, span: Span, param_mode: PathParamMode, @@ -764,13 +757,12 @@ fn ast_path_to_poly_trait_ref<'a,'tcx>( let shifted_rscope = &ShiftedRscope::new(rscope); let (substs, assoc_bindings) = - create_substs_for_ast_trait_ref(this, - shifted_rscope, - span, - param_mode, - trait_def_id, - self_ty, - trait_segment); + self.create_substs_for_ast_trait_ref(shifted_rscope, + span, + param_mode, + trait_def_id, + self_ty, + trait_segment); let poly_trait_ref = ty::Binder(ty::TraitRef::new(trait_def_id, substs)); { @@ -780,10 +772,9 @@ fn ast_path_to_poly_trait_ref<'a,'tcx>( .filter_map(|binding| { // specify type to assert that error was already reported in Err case: let predicate: Result<_, ErrorReported> = - ast_type_binding_to_poly_projection_predicate(this, - poly_trait_ref.clone(), - self_ty, - binding); + self.ast_type_binding_to_poly_projection_predicate(poly_trait_ref.clone(), + self_ty, + binding); predicate.ok() // ok to ignore Err() because ErrorReported (see above) }); poly_projections.extend(converted_bindings); @@ -794,44 +785,43 @@ fn ast_path_to_poly_trait_ref<'a,'tcx>( poly_trait_ref } -fn ast_path_to_mono_trait_ref<'a,'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - span: Span, - param_mode: PathParamMode, - trait_def_id: DefId, - self_ty: Option>, - trait_segment: &hir::PathSegment) - -> ty::TraitRef<'tcx> +fn ast_path_to_mono_trait_ref(&self, + rscope: &RegionScope, + span: Span, + param_mode: PathParamMode, + trait_def_id: DefId, + self_ty: Option>, + trait_segment: &hir::PathSegment) + -> ty::TraitRef<'tcx> { let (substs, assoc_bindings) = - create_substs_for_ast_trait_ref(this, - rscope, - span, - param_mode, - trait_def_id, - self_ty, - trait_segment); - assoc_bindings.first().map(|b| this.tcx().prohibit_projection(b.span)); + self.create_substs_for_ast_trait_ref(rscope, + span, + param_mode, + trait_def_id, + self_ty, + trait_segment); + assoc_bindings.first().map(|b| self.tcx().prohibit_projection(b.span)); ty::TraitRef::new(trait_def_id, substs) } -fn create_substs_for_ast_trait_ref<'a,'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - span: Span, - param_mode: PathParamMode, - trait_def_id: DefId, - self_ty: Option>, - trait_segment: &hir::PathSegment) - -> (&'tcx Substs<'tcx>, Vec>) +fn create_substs_for_ast_trait_ref(&self, + rscope: &RegionScope, + span: Span, + param_mode: PathParamMode, + trait_def_id: DefId, + self_ty: Option>, + trait_segment: &hir::PathSegment) + -> (&'tcx Substs<'tcx>, Vec>) { debug!("create_substs_for_ast_trait_ref(trait_segment={:?})", trait_segment); - let trait_def = match this.get_trait_def(span, trait_def_id) { + let trait_def = match self.get_trait_def(span, trait_def_id) { Ok(trait_def) => trait_def, Err(ErrorReported) => { // No convenient way to recover from a cycle here. Just bail. Sorry! - this.tcx().sess.abort_if_errors(); + self.tcx().sess.abort_if_errors(); bug!("ErrorReported returned, but no errors reports?") } }; @@ -840,49 +830,47 @@ fn create_substs_for_ast_trait_ref<'a,'tcx>(this: &AstConv<'tcx, 'tcx>, hir::AngleBracketedParameters(ref data) => { // For now, require that parenthetical notation be used // only with `Fn()` etc. - if !this.tcx().sess.features.borrow().unboxed_closures && trait_def.paren_sugar { - emit_feature_err(&this.tcx().sess.parse_sess.span_diagnostic, + if !self.tcx().sess.features.borrow().unboxed_closures && trait_def.paren_sugar { + emit_feature_err(&self.tcx().sess.parse_sess.span_diagnostic, "unboxed_closures", span, GateIssue::Language, "\ the precise format of `Fn`-family traits' type parameters is \ subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead"); } - convert_angle_bracketed_parameters(this, rscope, span, &trait_def.generics, data) + self.convert_angle_bracketed_parameters(rscope, span, &trait_def.generics, data) } hir::ParenthesizedParameters(ref data) => { // For now, require that parenthetical notation be used // only with `Fn()` etc. - if !this.tcx().sess.features.borrow().unboxed_closures && !trait_def.paren_sugar { - emit_feature_err(&this.tcx().sess.parse_sess.span_diagnostic, + if !self.tcx().sess.features.borrow().unboxed_closures && !trait_def.paren_sugar { + emit_feature_err(&self.tcx().sess.parse_sess.span_diagnostic, "unboxed_closures", span, GateIssue::Language, "\ parenthetical notation is only stable when used with `Fn`-family traits"); } - convert_parenthesized_parameters(this, rscope, span, &trait_def.generics, data) + self.convert_parenthesized_parameters(rscope, span, &trait_def.generics, data) } }; - let substs = create_substs_for_ast_path(this, - span, - param_mode, - &trait_def.generics, - self_ty, - types, - regions); + let substs = self.create_substs_for_ast_path(span, + param_mode, + &trait_def.generics, + self_ty, + types, + regions); - (this.tcx().mk_substs(substs), assoc_bindings) + (self.tcx().mk_substs(substs), assoc_bindings) } -fn ast_type_binding_to_poly_projection_predicate<'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn ast_type_binding_to_poly_projection_predicate(&self, mut trait_ref: ty::PolyTraitRef<'tcx>, self_ty: Option>, binding: &ConvertedBinding<'tcx>) -> Result, ErrorReported> { - let tcx = this.tcx(); + let tcx = self.tcx(); // Given something like `U : SomeTrait`, we want to produce a // predicate like `::T = X`. This is somewhat @@ -901,7 +889,7 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>( // We want to produce `>::T == foo`. // Simple case: X is defined in the current trait. - if this.trait_defines_associated_type_named(trait_ref.def_id(), binding.item_name) { + if self.trait_defines_associated_type_named(trait_ref.def_id(), binding.item_name) { return Ok(ty::Binder(ty::ProjectionPredicate { // <-------------------+ projection_ty: ty::ProjectionTy { // | trait_ref: trait_ref.skip_binder().clone(), // Binder moved here --+ @@ -928,11 +916,11 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>( tcx.mk_substs(dummy_substs))); } - this.ensure_super_predicates(binding.span, trait_ref.def_id())?; + self.ensure_super_predicates(binding.span, trait_ref.def_id())?; let mut candidates: Vec = traits::supertraits(tcx, trait_ref.clone()) - .filter(|r| this.trait_defines_associated_type_named(r.def_id(), binding.item_name)) + .filter(|r| self.trait_defines_associated_type_named(r.def_id(), binding.item_name)) .collect(); // If converting for an object type, then remove the dummy-ty from `Self` now. @@ -947,11 +935,10 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>( } } - let candidate = one_bound_for_assoc_type(this, - candidates, - &trait_ref.to_string(), - &binding.item_name.as_str(), - binding.span)?; + let candidate = self.one_bound_for_assoc_type(candidates, + &trait_ref.to_string(), + &binding.item_name.as_str(), + binding.span)?; Ok(ty::Binder(ty::ProjectionPredicate { // <-------------------------+ projection_ty: ty::ProjectionTy { // | @@ -962,8 +949,7 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>( })) } -fn ast_path_to_ty<'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn ast_path_to_ty(&self, rscope: &RegionScope, span: Span, param_mode: PathParamMode, @@ -971,8 +957,8 @@ fn ast_path_to_ty<'tcx>( item_segment: &hir::PathSegment) -> Ty<'tcx> { - let tcx = this.tcx(); - let (generics, decl_ty) = match this.get_item_type_scheme(span, did) { + let tcx = self.tcx(); + let (generics, decl_ty) = match self.get_item_type_scheme(span, did) { Ok(ty::TypeScheme { generics, ty: decl_ty }) => { (generics, decl_ty) } @@ -981,29 +967,26 @@ fn ast_path_to_ty<'tcx>( } }; - let substs = ast_path_substs_for_ty(this, - rscope, - span, - param_mode, - &generics, - item_segment); + let substs = self.ast_path_substs_for_ty(rscope, + span, + param_mode, + &generics, + item_segment); // FIXME(#12938): This is a hack until we have full support for DST. - if Some(did) == this.tcx().lang_items.owned_box() { + if Some(did) == self.tcx().lang_items.owned_box() { assert_eq!(substs.types.len(TypeSpace), 1); - return this.tcx().mk_box(*substs.types.get(TypeSpace, 0)); + return self.tcx().mk_box(*substs.types.get(TypeSpace, 0)); } - decl_ty.subst(this.tcx(), &substs) + decl_ty.subst(self.tcx(), &substs) } -type TraitAndProjections<'tcx> = (ty::PolyTraitRef<'tcx>, Vec>); - -fn ast_ty_to_trait_ref<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - ty: &hir::Ty, - bounds: &[hir::TyParamBound]) - -> Result, ErrorReported> +fn ast_ty_to_trait_ref(&self, + rscope: &RegionScope, + ty: &hir::Ty, + bounds: &[hir::TyParamBound]) + -> Result, ErrorReported> { /*! * In a type like `Foo + Send`, we want to wait to collect the @@ -1018,30 +1001,30 @@ fn ast_ty_to_trait_ref<'tcx>(this: &AstConv<'tcx, 'tcx>, match ty.node { hir::TyPath(None, ref path) => { - let def = match this.tcx().def_map.borrow().get(&ty.id) { + let def = match self.tcx().def_map.borrow().get(&ty.id) { Some(&def::PathResolution { base_def, depth: 0, .. }) => Some(base_def), _ => None }; match def { Some(Def::Trait(trait_def_id)) => { let mut projection_bounds = Vec::new(); - let trait_ref = object_path_to_poly_trait_ref(this, - rscope, - path.span, - PathParamMode::Explicit, - trait_def_id, - path.segments.last().unwrap(), - &mut projection_bounds); + let trait_ref = + self.object_path_to_poly_trait_ref(rscope, + path.span, + PathParamMode::Explicit, + trait_def_id, + path.segments.last().unwrap(), + &mut projection_bounds); Ok((trait_ref, projection_bounds)) } _ => { - span_err!(this.tcx().sess, ty.span, E0172, "expected a reference to a trait"); + span_err!(self.tcx().sess, ty.span, E0172, "expected a reference to a trait"); Err(ErrorReported) } } } _ => { - let mut err = struct_span_err!(this.tcx().sess, ty.span, E0178, + let mut err = struct_span_err!(self.tcx().sess, ty.span, E0178, "expected a path on the left-hand side of `+`, not `{}`", pprust::ty_to_string(ty)); let hi = bounds.iter().map(|x| match *x { @@ -1083,34 +1066,33 @@ fn ast_ty_to_trait_ref<'tcx>(this: &AstConv<'tcx, 'tcx>, } } -fn trait_ref_to_object_type<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - span: Span, - trait_ref: ty::PolyTraitRef<'tcx>, - projection_bounds: Vec>, - bounds: &[hir::TyParamBound]) - -> Ty<'tcx> +fn trait_ref_to_object_type(&self, + rscope: &RegionScope, + span: Span, + trait_ref: ty::PolyTraitRef<'tcx>, + projection_bounds: Vec>, + bounds: &[hir::TyParamBound]) + -> Ty<'tcx> { - let existential_bounds = conv_existential_bounds(this, - rscope, - span, - trait_ref.clone(), - projection_bounds, - bounds); + let existential_bounds = self.conv_existential_bounds(rscope, + span, + trait_ref.clone(), + projection_bounds, + bounds); - let result = make_object_type(this, span, trait_ref, existential_bounds); + let result = self.make_object_type(span, trait_ref, existential_bounds); debug!("trait_ref_to_object_type: result={:?}", result); result } -fn make_object_type<'tcx>(this: &AstConv<'tcx, 'tcx>, - span: Span, - principal: ty::PolyTraitRef<'tcx>, - bounds: ty::ExistentialBounds<'tcx>) - -> Ty<'tcx> { - let tcx = this.tcx(); +fn make_object_type(&self, + span: Span, + principal: ty::PolyTraitRef<'tcx>, + bounds: ty::ExistentialBounds<'tcx>) + -> Ty<'tcx> { + let tcx = self.tcx(); let object = ty::TraitTy { principal: principal, bounds: bounds @@ -1119,7 +1101,7 @@ fn make_object_type<'tcx>(this: &AstConv<'tcx, 'tcx>, object.principal_trait_ref_with_self_ty(tcx, tcx.types.err); // ensure the super predicates and stop if we encountered an error - if this.ensure_super_predicates(span, principal.def_id()).is_err() { + if self.ensure_super_predicates(span, principal.def_id()).is_err() { return tcx.types.err; } @@ -1162,12 +1144,12 @@ fn make_object_type<'tcx>(this: &AstConv<'tcx, 'tcx>, tcx.mk_trait(object.principal, object.bounds) } -fn report_ambiguous_associated_type(tcx: TyCtxt, +fn report_ambiguous_associated_type(&self, span: Span, type_str: &str, trait_str: &str, name: &str) { - span_err!(tcx.sess, span, E0223, + span_err!(self.tcx().sess, span, E0223, "ambiguous associated type; specify the type using the syntax \ `<{} as {}>::{}`", type_str, trait_str, name); @@ -1178,16 +1160,16 @@ fn report_ambiguous_associated_type(tcx: TyCtxt, // (which might be `Self`, but only if it is the `Self` of a trait, not an // impl). This function will fail if there are no suitable bounds or there is // any ambiguity. -fn find_bound_for_assoc_item<'tcx>(this: &AstConv<'tcx, 'tcx>, - ty_param_node_id: ast::NodeId, - ty_param_name: ast::Name, - assoc_name: ast::Name, - span: Span) - -> Result, ErrorReported> +fn find_bound_for_assoc_item(&self, + ty_param_node_id: ast::NodeId, + ty_param_name: ast::Name, + assoc_name: ast::Name, + span: Span) + -> Result, ErrorReported> { - let tcx = this.tcx(); + let tcx = self.tcx(); - let bounds = match this.get_type_parameter_bounds(span, ty_param_node_id) { + let bounds = match self.get_type_parameter_bounds(span, ty_param_node_id) { Ok(v) => v, Err(ErrorReported) => { return Err(ErrorReported); @@ -1195,7 +1177,7 @@ fn find_bound_for_assoc_item<'tcx>(this: &AstConv<'tcx, 'tcx>, }; // Ensure the super predicates and stop if we encountered an error. - if bounds.iter().any(|b| this.ensure_super_predicates(span, b.def_id()).is_err()) { + if bounds.iter().any(|b| self.ensure_super_predicates(span, b.def_id()).is_err()) { return Err(ErrorReported); } @@ -1203,28 +1185,27 @@ fn find_bound_for_assoc_item<'tcx>(this: &AstConv<'tcx, 'tcx>, // correct name. let suitable_bounds: Vec<_> = traits::transitive_bounds(tcx, &bounds) - .filter(|b| this.trait_defines_associated_type_named(b.def_id(), assoc_name)) + .filter(|b| self.trait_defines_associated_type_named(b.def_id(), assoc_name)) .collect(); - one_bound_for_assoc_type(this, - suitable_bounds, - &ty_param_name.as_str(), - &assoc_name.as_str(), - span) + self.one_bound_for_assoc_type(suitable_bounds, + &ty_param_name.as_str(), + &assoc_name.as_str(), + span) } // Checks that bounds contains exactly one element and reports appropriate // errors otherwise. -fn one_bound_for_assoc_type<'tcx>(this: &AstConv<'tcx, 'tcx>, - bounds: Vec>, - ty_param_name: &str, - assoc_name: &str, - span: Span) +fn one_bound_for_assoc_type(&self, + bounds: Vec>, + ty_param_name: &str, + assoc_name: &str, + span: Span) -> Result, ErrorReported> { if bounds.is_empty() { - span_err!(this.tcx().sess, span, E0220, + span_err!(self.tcx().sess, span, E0220, "associated type `{}` not found for `{}`", assoc_name, ty_param_name); @@ -1232,7 +1213,7 @@ fn one_bound_for_assoc_type<'tcx>(this: &AstConv<'tcx, 'tcx>, } if bounds.len() > 1 { - let mut err = struct_span_err!(this.tcx().sess, span, E0221, + let mut err = struct_span_err!(self.tcx().sess, span, E0221, "ambiguous associated type `{}` in bounds of `{}`", assoc_name, ty_param_name); @@ -1255,14 +1236,14 @@ fn one_bound_for_assoc_type<'tcx>(this: &AstConv<'tcx, 'tcx>, // the whole path. // Will fail except for T::A and Self::A; i.e., if ty/ty_path_def are not a type // parameter or Self. -fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, - span: Span, - ty: Ty<'tcx>, - ty_path_def: Def, - item_segment: &hir::PathSegment) - -> (Ty<'tcx>, Def) +fn associated_path_def_to_ty(&self, + span: Span, + ty: Ty<'tcx>, + ty_path_def: Def, + item_segment: &hir::PathSegment) + -> (Ty<'tcx>, Def) { - let tcx = this.tcx(); + let tcx = self.tcx(); let assoc_name = item_segment.identifier.name; debug!("associated_path_def_to_ty: {:?}::{}", ty, assoc_name); @@ -1276,65 +1257,61 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, // `Self` in an impl of a trait - we have a concrete self type and a // trait reference. let trait_ref = tcx.impl_trait_ref(tcx.map.local_def_id(impl_id)).unwrap(); - let trait_ref = if let Some(free_substs) = this.get_free_substs() { + let trait_ref = if let Some(free_substs) = self.get_free_substs() { trait_ref.subst(tcx, free_substs) } else { trait_ref }; - if this.ensure_super_predicates(span, trait_did).is_err() { + if self.ensure_super_predicates(span, trait_did).is_err() { return (tcx.types.err, ty_path_def); } let candidates: Vec = traits::supertraits(tcx, ty::Binder(trait_ref)) - .filter(|r| this.trait_defines_associated_type_named(r.def_id(), + .filter(|r| self.trait_defines_associated_type_named(r.def_id(), assoc_name)) .collect(); - match one_bound_for_assoc_type(this, - candidates, - "Self", - &assoc_name.as_str(), - span) { + match self.one_bound_for_assoc_type(candidates, + "Self", + &assoc_name.as_str(), + span) { Ok(bound) => bound, Err(ErrorReported) => return (tcx.types.err, ty_path_def), } } (&ty::TyParam(_), Def::SelfTy(Some(trait_did), None)) => { let trait_node_id = tcx.map.as_local_node_id(trait_did).unwrap(); - match find_bound_for_assoc_item(this, - trait_node_id, - keywords::SelfType.name(), - assoc_name, - span) { + match self.find_bound_for_assoc_item(trait_node_id, + keywords::SelfType.name(), + assoc_name, + span) { Ok(bound) => bound, Err(ErrorReported) => return (tcx.types.err, ty_path_def), } } (&ty::TyParam(_), Def::TyParam(_, _, param_did, param_name)) => { let param_node_id = tcx.map.as_local_node_id(param_did).unwrap(); - match find_bound_for_assoc_item(this, - param_node_id, - param_name, - assoc_name, - span) { + match self.find_bound_for_assoc_item(param_node_id, + param_name, + assoc_name, + span) { Ok(bound) => bound, Err(ErrorReported) => return (tcx.types.err, ty_path_def), } } _ => { - report_ambiguous_associated_type(tcx, - span, - &ty.to_string(), - "Trait", - &assoc_name.as_str()); + self.report_ambiguous_associated_type(span, + &ty.to_string(), + "Trait", + &assoc_name.as_str()); return (tcx.types.err, ty_path_def); } }; let trait_did = bound.0.def_id; - let ty = this.projected_ty_from_poly_trait_ref(span, bound, assoc_name); + let ty = self.projected_ty_from_poly_trait_ref(span, bound, assoc_name); let item_did = if let Some(trait_id) = tcx.map.as_local_node_id(trait_did) { // `ty::trait_items` used below requires information generated @@ -1357,17 +1334,17 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, (ty, Def::AssociatedTy(trait_did, item_did)) } -fn qpath_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - span: Span, - param_mode: PathParamMode, - opt_self_ty: Option>, - trait_def_id: DefId, - trait_segment: &hir::PathSegment, - item_segment: &hir::PathSegment) - -> Ty<'tcx> +fn qpath_to_ty(&self, + rscope: &RegionScope, + span: Span, + param_mode: PathParamMode, + opt_self_ty: Option>, + trait_def_id: DefId, + trait_segment: &hir::PathSegment, + item_segment: &hir::PathSegment) + -> Ty<'tcx> { - let tcx = this.tcx(); + let tcx = self.tcx(); tcx.prohibit_type_params(slice::ref_slice(item_segment)); @@ -1375,27 +1352,25 @@ fn qpath_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, ty } else { let path_str = tcx.item_path_str(trait_def_id); - report_ambiguous_associated_type(tcx, - span, - "Type", - &path_str, - &item_segment.identifier.name.as_str()); + self.report_ambiguous_associated_type(span, + "Type", + &path_str, + &item_segment.identifier.name.as_str()); return tcx.types.err; }; debug!("qpath_to_ty: self_type={:?}", self_ty); - let trait_ref = ast_path_to_mono_trait_ref(this, - rscope, - span, - param_mode, - trait_def_id, - Some(self_ty), - trait_segment); + let trait_ref = self.ast_path_to_mono_trait_ref(rscope, + span, + param_mode, + trait_def_id, + Some(self_ty), + trait_segment); debug!("qpath_to_ty: trait_ref={:?}", trait_ref); - this.projected_ty(span, trait_ref, item_segment.identifier.name) + self.projected_ty(span, trait_ref, item_segment.identifier.name) } /// Convert a type supplied as value for a type argument from AST into our @@ -1412,37 +1387,37 @@ fn qpath_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, /// * `region_substs`: a partial substitution consisting of /// only the region type parameters being supplied to this type. /// * `ast_ty`: the ast representation of the type being supplied -pub fn ast_ty_arg_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - decl_generics: &ty::Generics<'tcx>, - index: usize, - region_substs: &Substs<'tcx>, - ast_ty: &hir::Ty) - -> Ty<'tcx> +pub fn ast_ty_arg_to_ty(&self, + rscope: &RegionScope, + decl_generics: &ty::Generics<'tcx>, + index: usize, + region_substs: &Substs<'tcx>, + ast_ty: &hir::Ty) + -> Ty<'tcx> { - let tcx = this.tcx(); + let tcx = self.tcx(); if let Some(def) = decl_generics.types.opt_get(TypeSpace, index) { let object_lifetime_default = def.object_lifetime_default.subst(tcx, region_substs); let rscope1 = &ObjectLifetimeDefaultRscope::new(rscope, object_lifetime_default); - ast_ty_to_ty(this, rscope1, ast_ty) + self.ast_ty_to_ty(rscope1, ast_ty) } else { - ast_ty_to_ty(this, rscope, ast_ty) + self.ast_ty_to_ty(rscope, ast_ty) } } // Check the base def in a PathResolution and convert it to a Ty. If there are // associated types in the PathResolution, these will need to be separately // resolved. -fn base_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - span: Span, - param_mode: PathParamMode, - def: &Def, - opt_self_ty: Option>, - base_segments: &[hir::PathSegment]) - -> Ty<'tcx> { - let tcx = this.tcx(); +fn base_def_to_ty(&self, + rscope: &RegionScope, + span: Span, + param_mode: PathParamMode, + def: &Def, + opt_self_ty: Option>, + base_segments: &[hir::PathSegment]) + -> Ty<'tcx> { + let tcx = self.tcx(); match *def { Def::Trait(trait_def_id) => { @@ -1450,30 +1425,28 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, // TyObjectSum, see that fn for details let mut projection_bounds = Vec::new(); - let trait_ref = object_path_to_poly_trait_ref(this, - rscope, - span, - param_mode, - trait_def_id, - base_segments.last().unwrap(), - &mut projection_bounds); + let trait_ref = + self.object_path_to_poly_trait_ref(rscope, + span, + param_mode, + trait_def_id, + base_segments.last().unwrap(), + &mut projection_bounds); tcx.prohibit_type_params(base_segments.split_last().unwrap().1); - trait_ref_to_object_type(this, - rscope, - span, - trait_ref, - projection_bounds, - &[]) + self.trait_ref_to_object_type(rscope, + span, + trait_ref, + projection_bounds, + &[]) } Def::Enum(did) | Def::TyAlias(did) | Def::Struct(did) => { tcx.prohibit_type_params(base_segments.split_last().unwrap().1); - ast_path_to_ty(this, - rscope, - span, - param_mode, - did, - base_segments.last().unwrap()) + self.ast_path_to_ty(rscope, + span, + param_mode, + did, + base_segments.last().unwrap()) } Def::TyParam(space, index, _, name) => { tcx.prohibit_type_params(base_segments); @@ -1483,7 +1456,7 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, // Self in impl (we know the concrete type). tcx.prohibit_type_params(base_segments); let ty = tcx.node_id_to_type(impl_id); - if let Some(free_substs) = this.get_free_substs() { + if let Some(free_substs) = self.get_free_substs() { ty.subst(tcx, free_substs) } else { ty @@ -1496,14 +1469,13 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, } Def::AssociatedTy(trait_did, _) => { tcx.prohibit_type_params(&base_segments[..base_segments.len()-2]); - qpath_to_ty(this, - rscope, - span, - param_mode, - opt_self_ty, - trait_did, - &base_segments[base_segments.len()-2], - base_segments.last().unwrap()) + self.qpath_to_ty(rscope, + span, + param_mode, + opt_self_ty, + trait_did, + &base_segments[base_segments.len()-2], + base_segments.last().unwrap()) } Def::Mod(..) => { // Used as sentinel by callers to indicate the `::A::B::C` form. @@ -1522,36 +1494,35 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, tcx.prim_ty_to_ty(base_segments, prim_ty) } Def::Err => { - this.set_tainted_by_errors(); - return this.tcx().types.err; + self.set_tainted_by_errors(); + return self.tcx().types.err; } _ => { span_err!(tcx.sess, span, E0248, "found value `{}` used as a type", tcx.item_path_str(def.def_id())); - return this.tcx().types.err; + return self.tcx().types.err; } } } // Note that both base_segments and assoc_segments may be empty, although not at // the same time. -pub fn finish_resolving_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - span: Span, - param_mode: PathParamMode, - def: &Def, - opt_self_ty: Option>, - base_segments: &[hir::PathSegment], - assoc_segments: &[hir::PathSegment]) - -> Ty<'tcx> { - let mut ty = base_def_to_ty(this, - rscope, - span, - param_mode, - def, - opt_self_ty, - base_segments); +pub fn finish_resolving_def_to_ty(&self, + rscope: &RegionScope, + span: Span, + param_mode: PathParamMode, + def: &Def, + opt_self_ty: Option>, + base_segments: &[hir::PathSegment], + assoc_segments: &[hir::PathSegment]) + -> Ty<'tcx> { + let mut ty = self.base_def_to_ty(rscope, + span, + param_mode, + def, + opt_self_ty, + base_segments); let mut def = *def; // If any associated type segments remain, attempt to resolve them. for segment in assoc_segments { @@ -1559,11 +1530,10 @@ pub fn finish_resolving_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, break; } // This is pretty bad (it will fail except for T::A and Self::A). - let (a_ty, a_def) = associated_path_def_to_ty(this, - span, - ty, - def, - segment); + let (a_ty, a_def) = self.associated_path_def_to_ty(span, + ty, + def, + segment); ty = a_ty; def = a_def; } @@ -1572,63 +1542,58 @@ pub fn finish_resolving_def_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, /// Parses the programmer's textual representation of a type into our /// internal notion of a type. -pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - ast_ty: &hir::Ty) - -> Ty<'tcx> -{ +pub fn ast_ty_to_ty(&self, rscope: &RegionScope, ast_ty: &hir::Ty) -> Ty<'tcx> { debug!("ast_ty_to_ty(id={:?}, ast_ty={:?})", ast_ty.id, ast_ty); - let tcx = this.tcx(); + let tcx = self.tcx(); match ast_ty.node { hir::TyVec(ref ty) => { - tcx.mk_slice(ast_ty_to_ty(this, rscope, &ty)) + tcx.mk_slice(self.ast_ty_to_ty(rscope, &ty)) } hir::TyObjectSum(ref ty, ref bounds) => { - match ast_ty_to_trait_ref(this, rscope, &ty, bounds) { + match self.ast_ty_to_trait_ref(rscope, &ty, bounds) { Ok((trait_ref, projection_bounds)) => { - trait_ref_to_object_type(this, - rscope, - ast_ty.span, - trait_ref, - projection_bounds, - bounds) + self.trait_ref_to_object_type(rscope, + ast_ty.span, + trait_ref, + projection_bounds, + bounds) } Err(ErrorReported) => { - this.tcx().types.err + self.tcx().types.err } } } hir::TyPtr(ref mt) => { tcx.mk_ptr(ty::TypeAndMut { - ty: ast_ty_to_ty(this, rscope, &mt.ty), + ty: self.ast_ty_to_ty(rscope, &mt.ty), mutbl: mt.mutbl }) } hir::TyRptr(ref region, ref mt) => { - let r = opt_ast_region_to_region(this, rscope, ast_ty.span, region); + let r = self.opt_ast_region_to_region(rscope, ast_ty.span, region); debug!("TyRef r={:?}", r); let rscope1 = &ObjectLifetimeDefaultRscope::new( rscope, ty::ObjectLifetimeDefault::Specific(r)); - let t = ast_ty_to_ty(this, rscope1, &mt.ty); + let t = self.ast_ty_to_ty(rscope1, &mt.ty); tcx.mk_ref(tcx.mk_region(r), ty::TypeAndMut {ty: t, mutbl: mt.mutbl}) } hir::TyTup(ref fields) => { let flds = fields.iter() - .map(|t| ast_ty_to_ty(this, rscope, &t)) + .map(|t| self.ast_ty_to_ty(rscope, &t)) .collect(); tcx.mk_tup(flds) } hir::TyBareFn(ref bf) => { require_c_abi_if_variadic(tcx, &bf.decl, bf.abi, ast_ty.span); - tcx.mk_fn_ptr(ty_of_bare_fn(this, bf.unsafety, bf.abi, &bf.decl)) + tcx.mk_fn_ptr(self.ty_of_bare_fn(bf.unsafety, bf.abi, &bf.decl)) } hir::TyPolyTraitRef(ref bounds) => { - conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds) + self.conv_ty_poly_trait_ref(rscope, ast_ty.span, bounds) } hir::TyPath(ref maybe_qself, ref path) => { let path_res = if let Some(&d) = tcx.def_map.borrow().get(&ast_ty.id) { @@ -1645,16 +1610,15 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, let def = path_res.base_def; let base_ty_end = path.segments.len() - path_res.depth; let opt_self_ty = maybe_qself.as_ref().map(|qself| { - ast_ty_to_ty(this, rscope, &qself.ty) + self.ast_ty_to_ty(rscope, &qself.ty) }); - let ty = finish_resolving_def_to_ty(this, - rscope, - ast_ty.span, - PathParamMode::Explicit, - &def, - opt_self_ty, - &path.segments[..base_ty_end], - &path.segments[base_ty_end..]); + let ty = self.finish_resolving_def_to_ty(rscope, + ast_ty.span, + PathParamMode::Explicit, + &def, + opt_self_ty, + &path.segments[..base_ty_end], + &path.segments[base_ty_end..]); if path_res.depth != 0 && ty.sty != ty::TyError { // Write back the new resolution. @@ -1668,16 +1632,16 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, } hir::TyFixedLengthVec(ref ty, ref e) => { let hint = UncheckedExprHint(tcx.types.usize); - match eval_const_expr_partial(tcx, &e, hint, None) { + match eval_const_expr_partial(tcx.global_tcx(), &e, hint, None) { Ok(ConstVal::Integral(ConstInt::Usize(i))) => { let i = i.as_u64(tcx.sess.target.uint_type); assert_eq!(i as usize as u64, i); - tcx.mk_array(ast_ty_to_ty(this, rscope, &ty), i as usize) + tcx.mk_array(self.ast_ty_to_ty(rscope, &ty), i as usize) }, Ok(val) => { span_err!(tcx.sess, ast_ty.span, E0249, "expected usize value for array length, got {}", val.description()); - this.tcx().types.err + self.tcx().types.err }, // array length errors happen before the global constant check // so we need to report the real error @@ -1690,7 +1654,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, span_note!(&mut err, ast_ty.span, "for array length here") } err.emit(); - this.tcx().types.err + self.tcx().types.err } } } @@ -1704,61 +1668,55 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx, 'tcx>, // values in a ExprClosure, or as // the type of local variables. Both of these cases are // handled specially and will not descend into this routine. - this.ty_infer(None, None, None, ast_ty.span) + self.ty_infer(None, None, None, ast_ty.span) } } } -pub fn ty_of_arg<'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - a: &hir::Arg, - expected_ty: Option>) - -> Ty<'tcx> +pub fn ty_of_arg(&self, + rscope: &RegionScope, + a: &hir::Arg, + expected_ty: Option>) + -> Ty<'tcx> { match a.ty.node { hir::TyInfer if expected_ty.is_some() => expected_ty.unwrap(), - hir::TyInfer => this.ty_infer(None, None, None, a.ty.span), - _ => ast_ty_to_ty(this, rscope, &a.ty), + hir::TyInfer => self.ty_infer(None, None, None, a.ty.span), + _ => self.ast_ty_to_ty(rscope, &a.ty), } } -struct SelfInfo<'a, 'tcx> { - untransformed_self_ty: Ty<'tcx>, - explicit_self: &'a hir::ExplicitSelf, -} - -pub fn ty_of_method<'tcx>(this: &AstConv<'tcx, 'tcx>, - sig: &hir::MethodSig, - untransformed_self_ty: Ty<'tcx>) - -> (&'tcx ty::BareFnTy<'tcx>, ty::ExplicitSelfCategory) { +pub fn ty_of_method(&self, + sig: &hir::MethodSig, + untransformed_self_ty: Ty<'tcx>) + -> (&'tcx ty::BareFnTy<'tcx>, ty::ExplicitSelfCategory) { let self_info = Some(SelfInfo { untransformed_self_ty: untransformed_self_ty, explicit_self: &sig.explicit_self, }); let (bare_fn_ty, optional_explicit_self_category) = - ty_of_method_or_bare_fn(this, - sig.unsafety, - sig.abi, - self_info, - &sig.decl); + self.ty_of_method_or_bare_fn(sig.unsafety, + sig.abi, + self_info, + &sig.decl); (bare_fn_ty, optional_explicit_self_category.unwrap()) } -pub fn ty_of_bare_fn<'tcx>(this: &AstConv<'tcx, 'tcx>, - unsafety: hir::Unsafety, abi: abi::Abi, - decl: &hir::FnDecl) - -> &'tcx ty::BareFnTy<'tcx> { - let (bare_fn_ty, _) = ty_of_method_or_bare_fn(this, unsafety, abi, None, decl); +pub fn ty_of_bare_fn(&self, + unsafety: hir::Unsafety, abi: abi::Abi, + decl: &hir::FnDecl) + -> &'tcx ty::BareFnTy<'tcx> { + let (bare_fn_ty, _) = self.ty_of_method_or_bare_fn(unsafety, abi, None, decl); bare_fn_ty } -fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, - unsafety: hir::Unsafety, - abi: abi::Abi, - opt_self_info: Option>, - decl: &hir::FnDecl) - -> (&'tcx ty::BareFnTy<'tcx>, - Option) +fn ty_of_method_or_bare_fn<'a>(&self, + unsafety: hir::Unsafety, + abi: abi::Abi, + opt_self_info: Option>, + decl: &hir::FnDecl) + -> (&'tcx ty::BareFnTy<'tcx>, + Option) { debug!("ty_of_method_or_bare_fn"); @@ -1773,7 +1731,7 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, // region of the self parameter. let (self_ty, explicit_self_category) = match opt_self_info { None => (None, None), - Some(self_info) => determine_self_type(this, &rb, self_info) + Some(self_info) => self.determine_self_type(&rb, self_info) }; // HACK(eddyb) replace the fake self type in the AST with the actual type. @@ -1783,7 +1741,7 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, &decl.inputs[..] }; let arg_tys: Vec = - arg_params.iter().map(|a| ty_of_arg(this, &rb, a, None)).collect(); + arg_params.iter().map(|a| self.ty_of_arg(&rb, a, None)).collect(); let arg_pats: Vec = arg_params.iter().map(|a| pprust::pat_to_string(&a.pat)).collect(); @@ -1792,19 +1750,18 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, // have that lifetime. let implied_output_region = match explicit_self_category { Some(ty::ExplicitSelfCategory::ByReference(region, _)) => Ok(region), - _ => find_implied_output_region(this, &arg_tys, arg_pats) + _ => self.find_implied_output_region(&arg_tys, arg_pats) }; let output_ty = match decl.output { hir::Return(ref output) => - ty::FnConverging(convert_ty_with_lifetime_elision(this, - implied_output_region, - &output)), - hir::DefaultReturn(..) => ty::FnConverging(this.tcx().mk_nil()), + ty::FnConverging(self.convert_ty_with_lifetime_elision(implied_output_region, + &output)), + hir::DefaultReturn(..) => ty::FnConverging(self.tcx().mk_nil()), hir::NoReturn(..) => ty::FnDiverging }; - (this.tcx().mk_bare_fn(ty::BareFnTy { + (self.tcx().mk_bare_fn(ty::BareFnTy { unsafety: unsafety, abi: abi, sig: ty::Binder(ty::FnSig { @@ -1815,10 +1772,10 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, }), explicit_self_category) } -fn determine_self_type<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, - rscope: &RegionScope, - self_info: SelfInfo<'a, 'tcx>) - -> (Option>, Option) +fn determine_self_type<'a>(&self, + rscope: &RegionScope, + self_info: SelfInfo<'a, 'tcx>) + -> (Option>, Option) { let self_ty = self_info.untransformed_self_ty; return match self_info.explicit_self.node { @@ -1828,12 +1785,11 @@ fn determine_self_type<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, } hir::SelfRegion(ref lifetime, mutability, _) => { let region = - opt_ast_region_to_region(this, - rscope, - self_info.explicit_self.span, - lifetime); - (Some(this.tcx().mk_ref( - this.tcx().mk_region(region), + self.opt_ast_region_to_region(rscope, + self_info.explicit_self.span, + lifetime); + (Some(self.tcx().mk_ref( + self.tcx().mk_region(region), ty::TypeAndMut { ty: self_ty, mutbl: mutability @@ -1841,7 +1797,7 @@ fn determine_self_type<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, Some(ty::ExplicitSelfCategory::ByReference(region, mutability))) } hir::SelfExplicit(ref ast_type, _) => { - let explicit_type = ast_ty_to_ty(this, rscope, &ast_type); + let explicit_type = self.ast_ty_to_ty(rscope, &ast_type); // We wish to (for now) categorize an explicit self // declaration like `self: SomeType` into either `self`, @@ -1906,8 +1862,7 @@ fn determine_self_type<'a, 'tcx>(this: &AstConv<'tcx, 'tcx>, } } -pub fn ty_of_closure<'tcx>( - this: &AstConv<'tcx, 'tcx>, +pub fn ty_of_closure(&self, unsafety: hir::Unsafety, decl: &hir::FnDecl, abi: abi::Abi, @@ -1931,7 +1886,7 @@ pub fn ty_of_closure<'tcx>( None } }); - ty_of_arg(this, &rb, a, expected_arg_ty) + self.ty_of_arg(&rb, a, expected_arg_ty) }).collect(); let expected_ret_ty = expected_sig.map(|e| e.output); @@ -1946,9 +1901,9 @@ pub fn ty_of_closure<'tcx>( _ if is_infer && expected_ret_ty.is_some() => expected_ret_ty.unwrap(), _ if is_infer => - ty::FnConverging(this.ty_infer(None, None, None, decl.output.span())), + ty::FnConverging(self.ty_infer(None, None, None, decl.output.span())), hir::Return(ref output) => - ty::FnConverging(ast_ty_to_ty(this, &rb, &output)), + ty::FnConverging(self.ast_ty_to_ty(&rb, &output)), hir::DefaultReturn(..) => bug!(), hir::NoReturn(..) => ty::FnDiverging }; @@ -1969,8 +1924,7 @@ pub fn ty_of_closure<'tcx>( /// `ExistentialBounds` struct. The `main_trait_refs` argument specifies the `Foo` -- it is absent /// for closures. Eventually this should all be normalized, I think, so that there is no "main /// trait ref" and instead we just have a flat list of bounds as the existential type. -fn conv_existential_bounds<'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn conv_existential_bounds(&self, rscope: &RegionScope, span: Span, principal_trait_ref: ty::PolyTraitRef<'tcx>, @@ -1979,48 +1933,44 @@ fn conv_existential_bounds<'tcx>( -> ty::ExistentialBounds<'tcx> { let partitioned_bounds = - partition_bounds(this.tcx(), span, ast_bounds); + partition_bounds(self.tcx(), span, ast_bounds); - conv_existential_bounds_from_partitioned_bounds( - this, rscope, span, principal_trait_ref, projection_bounds, partitioned_bounds) + self.conv_existential_bounds_from_partitioned_bounds( + rscope, span, principal_trait_ref, projection_bounds, partitioned_bounds) } -fn conv_ty_poly_trait_ref<'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn conv_ty_poly_trait_ref(&self, rscope: &RegionScope, span: Span, ast_bounds: &[hir::TyParamBound]) -> Ty<'tcx> { - let mut partitioned_bounds = partition_bounds(this.tcx(), span, &ast_bounds[..]); + let mut partitioned_bounds = partition_bounds(self.tcx(), span, &ast_bounds[..]); let mut projection_bounds = Vec::new(); let main_trait_bound = if !partitioned_bounds.trait_bounds.is_empty() { let trait_bound = partitioned_bounds.trait_bounds.remove(0); - instantiate_poly_trait_ref(this, - rscope, - trait_bound, - None, - &mut projection_bounds) + self.instantiate_poly_trait_ref(rscope, + trait_bound, + None, + &mut projection_bounds) } else { - span_err!(this.tcx().sess, span, E0224, + span_err!(self.tcx().sess, span, E0224, "at least one non-builtin trait is required for an object type"); - return this.tcx().types.err; + return self.tcx().types.err; }; let bounds = - conv_existential_bounds_from_partitioned_bounds(this, - rscope, - span, - main_trait_bound.clone(), - projection_bounds, - partitioned_bounds); + self.conv_existential_bounds_from_partitioned_bounds(rscope, + span, + main_trait_bound.clone(), + projection_bounds, + partitioned_bounds); - make_object_type(this, span, main_trait_bound, bounds) + self.make_object_type(span, main_trait_bound, bounds) } -pub fn conv_existential_bounds_from_partitioned_bounds<'tcx>( - this: &AstConv<'tcx, 'tcx>, +pub fn conv_existential_bounds_from_partitioned_bounds(&self, rscope: &RegionScope, span: Span, principal_trait_ref: ty::PolyTraitRef<'tcx>, @@ -2035,16 +1985,15 @@ pub fn conv_existential_bounds_from_partitioned_bounds<'tcx>( if !trait_bounds.is_empty() { let b = &trait_bounds[0]; - span_err!(this.tcx().sess, b.trait_ref.path.span, E0225, + span_err!(self.tcx().sess, b.trait_ref.path.span, E0225, "only the builtin traits can be used as closure or object bounds"); } let region_bound = - compute_object_lifetime_bound(this, - span, - ®ion_bounds, - principal_trait_ref, - builtin_bounds); + self.compute_object_lifetime_bound(span, + ®ion_bounds, + principal_trait_ref, + builtin_bounds); let region_bound = match region_bound { Some(r) => r, @@ -2052,7 +2001,7 @@ pub fn conv_existential_bounds_from_partitioned_bounds<'tcx>( match rscope.object_lifetime_default(span) { Some(r) => r, None => { - span_err!(this.tcx().sess, span, E0228, + span_err!(self.tcx().sess, span, E0228, "the lifetime bound for this object type cannot be deduced \ from context; please supply an explicit bound"); ty::ReStatic @@ -2070,15 +2019,14 @@ pub fn conv_existential_bounds_from_partitioned_bounds<'tcx>( /// (if any) we can use to summarize this type. The basic idea is that we will use the bound the /// user provided, if they provided one, and otherwise search the supertypes of trait bounds for /// region bounds. It may be that we can derive no bound at all, in which case we return `None`. -fn compute_object_lifetime_bound<'tcx>( - this: &AstConv<'tcx, 'tcx>, +fn compute_object_lifetime_bound(&self, span: Span, explicit_region_bounds: &[&hir::Lifetime], principal_trait_ref: ty::PolyTraitRef<'tcx>, builtin_bounds: ty::BuiltinBounds) -> Option // if None, use the default { - let tcx = this.tcx(); + let tcx = self.tcx(); debug!("compute_opt_region_bound(explicit_region_bounds={:?}, \ principal_trait_ref={:?}, builtin_bounds={:?})", @@ -2097,7 +2045,7 @@ fn compute_object_lifetime_bound<'tcx>( return Some(ast_region_to_region(tcx, r)); } - if let Err(ErrorReported) = this.ensure_super_predicates(span,principal_trait_ref.def_id()) { + if let Err(ErrorReported) = self.ensure_super_predicates(span,principal_trait_ref.def_id()) { return Some(ty::ReStatic); } @@ -2128,6 +2076,7 @@ fn compute_object_lifetime_bound<'tcx>( } return Some(r); } +} pub struct PartitionedBounds<'a> { pub builtin_bounds: ty::BuiltinBounds, @@ -2137,10 +2086,10 @@ pub struct PartitionedBounds<'a> { /// Divides a list of bounds from the AST into three groups: builtin bounds (Copy, Sized etc), /// general trait bounds, and region bounds. -pub fn partition_bounds<'a, 'b, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, - _span: Span, - ast_bounds: &'b [hir::TyParamBound]) - -> PartitionedBounds<'b> +pub fn partition_bounds<'a, 'b, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>, + _span: Span, + ast_bounds: &'b [hir::TyParamBound]) + -> PartitionedBounds<'b> { let mut builtin_bounds = ty::BuiltinBounds::empty(); let mut region_bounds = Vec::new(); @@ -2227,8 +2176,8 @@ pub struct Bounds<'tcx> { pub projection_bounds: Vec>, } -impl<'a, 'tcx> Bounds<'tcx> { - pub fn predicates(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, param_ty: Ty<'tcx>) +impl<'a, 'gcx, 'tcx> Bounds<'tcx> { + pub fn predicates(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, param_ty: Ty<'tcx>) -> Vec> { let mut vec = Vec::new(); diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 394ecf5fbef..899e4f62cc3 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -16,7 +16,6 @@ use rustc::ty::subst::Substs; use rustc::ty::{self, Ty, TypeFoldable, LvaluePreference}; use check::{FnCtxt, Expectation}; use lint; -use require_same_types; use util::nodemap::FnvHashMap; use session::Session; @@ -56,8 +55,8 @@ fn bad_struct_kind_err(sess: &Session, pat: &hir::Pat, path: &hir::Path, lint: b } } -impl<'a, 'tcx> PatCtxt<'a, 'tcx, 'tcx> { -pub fn check_pat(&self, pat: &'tcx hir::Pat, expected: Ty<'tcx>) { +impl<'a, 'gcx, 'tcx> PatCtxt<'a, 'gcx, 'tcx> { +pub fn check_pat(&self, pat: &'gcx hir::Pat, expected: Ty<'tcx>) { let tcx = self.tcx; debug!("check_pat(pat={:?},expected={:?})", pat, expected); @@ -133,10 +132,8 @@ pub fn check_pat(&self, pat: &'tcx hir::Pat, expected: Ty<'tcx>) { } // Check that the types of the end-points can be unified. - let types_unify = require_same_types( - self.ccx, Some(self), pat.span, rhs_ty, lhs_ty, - "mismatched types in range", - ); + let types_unify = self.require_same_types(pat.span, rhs_ty, lhs_ty, + "mismatched types in range"); // It's ok to return without a message as `require_same_types` prints an error. if !types_unify { @@ -455,11 +452,11 @@ pub fn check_dereferencable(&self, span: Span, expected: Ty<'tcx>, inner: &hir:: } } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn check_match(&self, - expr: &'tcx hir::Expr, - discrim: &'tcx hir::Expr, - arms: &'tcx [hir::Arm], + expr: &'gcx hir::Expr, + discrim: &'gcx hir::Expr, + arms: &'gcx [hir::Arm], expected: Expectation<'tcx>, match_src: hir::MatchSource) { let tcx = self.tcx; @@ -578,9 +575,9 @@ pub fn check_match(&self, } } -impl<'a, 'tcx> PatCtxt<'a, 'tcx, 'tcx> { -pub fn check_pat_struct(&self, pat: &'tcx hir::Pat, - path: &hir::Path, fields: &'tcx [Spanned], +impl<'a, 'gcx, 'tcx> PatCtxt<'a, 'gcx, 'tcx> { +pub fn check_pat_struct(&self, pat: &'gcx hir::Pat, + path: &hir::Path, fields: &'gcx [Spanned], etc: bool, expected: Ty<'tcx>) { let tcx = self.tcx; @@ -617,7 +614,7 @@ pub fn check_pat_struct(&self, pat: &'tcx hir::Pat, fn check_pat_enum(&self, pat: &hir::Pat, path: &hir::Path, - subpats: Option<&'tcx [P]>, + subpats: Option<&'gcx [P]>, expected: Ty<'tcx>, is_tuple_struct_pat: bool) { @@ -764,7 +761,7 @@ fn check_pat_enum(&self, /// `etc` is true if the pattern said '...' and false otherwise. pub fn check_struct_pat_fields(&self, span: Span, - fields: &'tcx [Spanned], + fields: &'gcx [Spanned], variant: ty::VariantDef<'tcx>, substs: &Substs<'tcx>, etc: bool) { diff --git a/src/librustc_typeck/check/assoc.rs b/src/librustc_typeck/check/assoc.rs index fbc5a0b33aa..04b0248ccda 100644 --- a/src/librustc_typeck/check/assoc.rs +++ b/src/librustc_typeck/check/assoc.rs @@ -16,12 +16,13 @@ use syntax::ast; use syntax::codemap::Span; //FIXME(@jroesch): Ideally we should be able to drop the fulfillment_cx argument. -pub fn normalize_associated_types_in<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx, 'tcx>, - fulfillment_cx: &mut FulfillmentContext<'tcx>, - span: Span, - body_id: ast::NodeId, - value: &T) - -> T +pub fn normalize_associated_types_in<'a, 'gcx, 'tcx, T>( + infcx: &InferCtxt<'a, 'gcx, 'tcx>, + fulfillment_cx: &mut FulfillmentContext<'tcx>, + span: Span, + body_id: ast::NodeId, + value: &T) -> T + where T : TypeFoldable<'tcx> { debug!("normalize_associated_types_in(value={:?})", value); diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs index a0565a9870c..9de78168fe7 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -63,11 +63,11 @@ enum CallStep<'tcx> { Overloaded(ty::MethodCallee<'tcx>) } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn check_call(&self, - call_expr: &'tcx hir::Expr, - callee_expr: &'tcx hir::Expr, - arg_exprs: &'tcx [P], + call_expr: &'gcx hir::Expr, + callee_expr: &'gcx hir::Expr, + arg_exprs: &'gcx [P], expected: Expectation<'tcx>) { self.check_expr(callee_expr); @@ -104,8 +104,8 @@ pub fn check_call(&self, } fn try_overloaded_call_step(&self, - call_expr: &'tcx hir::Expr, - callee_expr: &'tcx hir::Expr, + call_expr: &'gcx hir::Expr, + callee_expr: &'gcx hir::Expr, adjusted_ty: Ty<'tcx>, autoderefs: usize) -> Option> @@ -205,7 +205,7 @@ fn try_overloaded_call_traits(&self, fn confirm_builtin_call(&self, call_expr: &hir::Expr, callee_ty: Ty<'tcx>, - arg_exprs: &'tcx [P], + arg_exprs: &'gcx [P], expected: Expectation<'tcx>) { let error_fn_sig; @@ -275,7 +275,7 @@ fn confirm_builtin_call(&self, fn confirm_deferred_closure_call(&self, call_expr: &hir::Expr, - arg_exprs: &'tcx [P], + arg_exprs: &'gcx [P], expected: Expectation<'tcx>, fn_sig: ty::FnSig<'tcx>) { @@ -302,8 +302,8 @@ fn confirm_deferred_closure_call(&self, fn confirm_overloaded_call(&self, call_expr: &hir::Expr, - callee_expr: &'tcx hir::Expr, - arg_exprs: &'tcx [P], + callee_expr: &'gcx hir::Expr, + arg_exprs: &'gcx [P], expected: Expectation<'tcx>, method_callee: ty::MethodCallee<'tcx>) { @@ -328,17 +328,17 @@ fn write_overloaded_call_method_map(&self, } #[derive(Debug)] -struct CallResolution<'tcx> { - call_expr: &'tcx hir::Expr, - callee_expr: &'tcx hir::Expr, +struct CallResolution<'gcx: 'tcx, 'tcx> { + call_expr: &'gcx hir::Expr, + callee_expr: &'gcx hir::Expr, adjusted_ty: Ty<'tcx>, autoderefs: usize, fn_sig: ty::FnSig<'tcx>, closure_def_id: DefId, } -impl<'tcx> DeferredCallResolution<'tcx> for CallResolution<'tcx> { - fn resolve<'a>(&mut self, fcx: &FnCtxt<'a,'tcx, 'tcx>) { +impl<'gcx, 'tcx> DeferredCallResolution<'gcx, 'tcx> for CallResolution<'gcx, 'tcx> { + fn resolve<'a>(&mut self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) { debug!("DeferredCallResolution::resolve() {:?}", self); @@ -348,7 +348,7 @@ impl<'tcx> DeferredCallResolution<'tcx> for CallResolution<'tcx> { // We may now know enough to figure out fn vs fnmut etc. match fcx.try_overloaded_call_traits(self.call_expr, self.callee_expr, - self.adjusted_ty, self.autoderefs) { + self.adjusted_ty, self.autoderefs) { Some(method_callee) => { // One problem is that when we get here, we are going // to have a newly instantiated function signature diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index ad92c3fb072..bdf26eab20f 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -72,7 +72,7 @@ enum UnsizeKind<'tcx> { OfParam(&'tcx ty::ParamTy) } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { /// Returns the kind of unsize information of t, or None /// if t is sized or it is unknown. fn unsize_kind(&self, t: Ty<'tcx>) -> Option> { @@ -109,8 +109,8 @@ enum CastError { NonScalar, } -impl<'a, 'tcx> CastCheck<'tcx> { - pub fn new(fcx: &FnCtxt<'a, 'tcx, 'tcx>, +impl<'a, 'gcx, 'tcx> CastCheck<'tcx> { + pub fn new(fcx: &FnCtxt<'a, 'gcx, 'tcx>, expr: &'tcx hir::Expr, expr_ty: Ty<'tcx>, cast_ty: Ty<'tcx>, @@ -139,7 +139,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { } } - fn report_cast_error(&self, fcx: &FnCtxt<'a, 'tcx, 'tcx>, e: CastError) { + fn report_cast_error(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, e: CastError) { match e { CastError::NeedViaPtr | CastError::NeedViaThinPtr | @@ -202,7 +202,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { } } - fn report_cast_to_unsized_type(&self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) { + fn report_cast_to_unsized_type(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) { if self.cast_ty.references_error() || self.expr_ty.references_error() @@ -256,7 +256,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { err.emit(); } - fn trivial_cast_lint(&self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) { + fn trivial_cast_lint(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) { let t_cast = self.cast_ty; let t_expr = self.expr_ty; if t_cast.is_numeric() && t_expr.is_numeric() { @@ -281,7 +281,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { } - pub fn check(mut self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) { + pub fn check(mut self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) { self.expr_ty = fcx.structurally_resolved_type(self.span, self.expr_ty); self.cast_ty = fcx.structurally_resolved_type(self.span, self.cast_ty); @@ -309,7 +309,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { /// Check a cast, and report an error if one exists. In some cases, this /// can return Ok and create type errors in the fcx rather than returning /// directly. coercion-cast is handled in check instead of here. - fn do_check(&self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) -> Result { + fn do_check(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Result { use rustc::ty::cast::IntTy::*; use rustc::ty::cast::CastTy::*; @@ -376,7 +376,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { } fn check_ptr_ptr_cast(&self, - fcx: &FnCtxt<'a, 'tcx, 'tcx>, + fcx: &FnCtxt<'a, 'gcx, 'tcx>, m_expr: &'tcx ty::TypeAndMut<'tcx>, m_cast: &'tcx ty::TypeAndMut<'tcx>) -> Result @@ -403,7 +403,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { } fn check_fptr_ptr_cast(&self, - fcx: &FnCtxt<'a, 'tcx, 'tcx>, + fcx: &FnCtxt<'a, 'gcx, 'tcx>, m_cast: &'tcx ty::TypeAndMut<'tcx>) -> Result { @@ -417,7 +417,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { } fn check_ptr_addr_cast(&self, - fcx: &FnCtxt<'a, 'tcx, 'tcx>, + fcx: &FnCtxt<'a, 'gcx, 'tcx>, m_expr: &'tcx ty::TypeAndMut<'tcx>) -> Result { @@ -431,7 +431,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { } fn check_ref_cast(&self, - fcx: &FnCtxt<'a, 'tcx, 'tcx>, + fcx: &FnCtxt<'a, 'gcx, 'tcx>, m_expr: &'tcx ty::TypeAndMut<'tcx>, m_cast: &'tcx ty::TypeAndMut<'tcx>) -> Result @@ -457,7 +457,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { } fn check_addr_ptr_cast(&self, - fcx: &FnCtxt<'a, 'tcx, 'tcx>, + fcx: &FnCtxt<'a, 'gcx, 'tcx>, m_cast: &'tcx ty::TypeAndMut<'tcx>) -> Result { @@ -469,13 +469,13 @@ impl<'a, 'tcx> CastCheck<'tcx> { } } - fn try_coercion_cast(&self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) -> bool { + fn try_coercion_cast(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> bool { fcx.try_coerce(self.expr, self.cast_ty).is_ok() } } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { fn type_is_known_to_be_sized(&self, ty: Ty<'tcx>, span: Span) diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index c60020f51ae..43c1f9d367e 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -12,19 +12,19 @@ use super::{check_fn, Expectation, FnCtxt}; -use astconv; +use astconv::AstConv; use rustc::ty::subst; use rustc::ty::{self, ToPolyTraitRef, Ty}; use std::cmp; use syntax::abi::Abi; use rustc::hir; -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn check_expr_closure(&self, expr: &hir::Expr, _capture: hir::CaptureClause, - decl: &'tcx hir::FnDecl, - body: &'tcx hir::Block, + decl: &'gcx hir::FnDecl, + body: &'gcx hir::Block, expected: Expectation<'tcx>) { debug!("check_expr_closure(expr={:?},expected={:?})", expr, @@ -43,8 +43,8 @@ pub fn check_expr_closure(&self, fn check_closure(&self, expr: &hir::Expr, opt_kind: Option, - decl: &'tcx hir::FnDecl, - body: &'tcx hir::Block, + decl: &'gcx hir::FnDecl, + body: &'gcx hir::Block, expected_sig: Option>) { let expr_def_id = self.tcx.map.local_def_id(expr.id); @@ -52,7 +52,7 @@ fn check_closure(&self, opt_kind, expected_sig); - let mut fn_ty = astconv::ty_of_closure(self, + let mut fn_ty = AstConv::ty_of_closure(self, hir::Unsafety::Normal, decl, Abi::RustCall, @@ -68,7 +68,7 @@ fn check_closure(&self, expr.id, upvar_tys); let closure_type = self.tcx.mk_closure(expr_def_id, - self.tcx.mk_substs(self.parameter_environment.free_substs.clone()), + self.parameter_environment.free_substs, upvar_tys); self.write_ty(expr.id, closure_type); @@ -76,14 +76,7 @@ fn check_closure(&self, let fn_sig = self.tcx.liberate_late_bound_regions( self.tcx.region_maps.call_site_extent(expr.id, body.id), &fn_ty.sig); - check_fn(self.ccx, - hir::Unsafety::Normal, - expr.id, - &fn_sig, - decl, - expr.id, - &body, - self); + check_fn(self, hir::Unsafety::Normal, expr.id, &fn_sig, decl, expr.id, &body); // Tuple up the arguments and insert the resulting function type into // the `closures` table. diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index 1e7a9c5b635..55786a03eeb 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -105,8 +105,8 @@ fn coerce_mutbls<'tcx>(from_mutbl: hir::Mutability, } } -impl<'f, 'tcx> Coerce<'f, 'tcx, 'tcx> { - fn new(fcx: &'f FnCtxt<'f, 'tcx, 'tcx>, origin: TypeOrigin) -> Self { +impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> { + fn new(fcx: &'f FnCtxt<'f, 'gcx, 'tcx>, origin: TypeOrigin) -> Self { Coerce { fcx: fcx, origin: origin, @@ -594,11 +594,11 @@ impl<'f, 'tcx> Coerce<'f, 'tcx, 'tcx> { } } -fn apply<'a, 'b, 'tcx, E, I>(coerce: &mut Coerce<'a, 'tcx, 'tcx>, - exprs: &E, - a: Ty<'tcx>, - b: Ty<'tcx>) - -> CoerceResult<'tcx> +fn apply<'a, 'b, 'gcx, 'tcx, E, I>(coerce: &mut Coerce<'a, 'gcx, 'tcx>, + exprs: &E, + a: Ty<'tcx>, + b: Ty<'tcx>) + -> CoerceResult<'tcx> where E: Fn() -> I, I: IntoIterator { @@ -617,7 +617,7 @@ fn apply<'a, 'b, 'tcx, E, I>(coerce: &mut Coerce<'a, 'tcx, 'tcx>, Ok((ty, adjustment)) } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { /// Attempt to coerce an expression to a type, and return the /// adjusted type of the expression, if successful. /// Adjustments are only recorded if the coercion succeeded. diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 4f4b7fa9ef7..065425c86c7 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -16,7 +16,7 @@ use rustc::infer::{InferOk, TypeOrigin}; use syntax::codemap::Span; use rustc::hir; -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // Requires that the two types unify, and prints an error message if // they don't. pub fn demand_suptype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) { @@ -54,4 +54,16 @@ pub fn demand_coerce(&self, expr: &hir::Expr, expected: Ty<'tcx>) { self.report_mismatched_types(origin, expected, expr_ty, e); } } + +pub fn require_same_types(&self, span: Span, t1: Ty<'tcx>, t2: Ty<'tcx>, msg: &str) + -> bool { + if let Err(err) = self.eq_types(false, TypeOrigin::Misc(span), t1, t2) { + let found_ty = self.resolve_type_vars_if_possible(&t1); + let expected_ty = self.resolve_type_vars_if_possible(&t2); + ::emit_type_err(self.tcx, span, found_ty, expected_ty, &err, msg); + false + } else { + true + } +} } diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index c5e7606106f..862dae4bb33 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -16,7 +16,7 @@ use middle::free_region::FreeRegionMap; use rustc::infer::{self, InferCtxt}; use middle::region; use rustc::ty::subst::{self, Subst}; -use rustc::ty::{self, Ty}; +use rustc::ty::{self, Ty, TyCtxt}; use rustc::traits::{self, ProjectionMode}; use util::nodemap::FnvHashSet; @@ -274,10 +274,12 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'a, 'tcx>( /// ensuring that they do not access data nor invoke methods of /// values that have been previously dropped). /// -pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(rcx: &mut RegionCtxt<'a, 'tcx, 'tcx>, - typ: ty::Ty<'tcx>, - span: Span, - scope: region::CodeExtent) { +pub fn check_safety_of_destructor_if_necessary<'a, 'gcx, 'tcx>( + rcx: &mut RegionCtxt<'a, 'gcx, 'tcx>, + typ: ty::Ty<'tcx>, + span: Span, + scope: region::CodeExtent) +{ debug!("check_safety_of_destructor_if_necessary typ: {:?} scope: {:?}", typ, scope); @@ -354,8 +356,8 @@ struct DropckContext<'a, 'b: 'a, 'gcx: 'b+'tcx, 'tcx: 'b> { } // `context` is used for reporting overflow errors -fn iterate_over_potentially_unsafe_regions_in_type<'a, 'b, 'tcx>( - cx: &mut DropckContext<'a, 'b, 'tcx, 'tcx>, +fn iterate_over_potentially_unsafe_regions_in_type<'a, 'b, 'gcx, 'tcx>( + cx: &mut DropckContext<'a, 'b, 'gcx, 'tcx>, context: TypeContext, ty: Ty<'tcx>, depth: usize) -> Result<(), Error<'tcx>> @@ -410,7 +412,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'b, 'tcx>( // unbounded type parameter `T`, we must resume the recursive // analysis on `T` (since it would be ignored by // type_must_outlive). - if has_dtor_of_interest(cx, ty) { + if has_dtor_of_interest(tcx, ty) { debug!("iterate_over_potentially_unsafe_regions_in_type \ {}ty: {} - is a dtorck type!", (0..depth).map(|_| ' ').collect::(), @@ -500,11 +502,11 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'b, 'tcx>( } } -fn has_dtor_of_interest<'a, 'b, 'tcx>(cx: &DropckContext<'a, 'b, 'tcx, 'tcx>, - ty: ty::Ty<'tcx>) -> bool { +fn has_dtor_of_interest<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>, + ty: Ty<'tcx>) -> bool { match ty.sty { ty::TyEnum(def, _) | ty::TyStruct(def, _) => { - def.is_dtorck(cx.rcx.tcx) + def.is_dtorck(tcx) } ty::TyTrait(..) | ty::TyProjection(..) => { debug!("ty: {:?} isn't known, and therefore is a dropck type", ty); diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs index 6243d191dcb..c02139140ae 100644 --- a/src/librustc_typeck/check/intrinsic.rs +++ b/src/librustc_typeck/check/intrinsic.rs @@ -56,7 +56,6 @@ fn equate_intrinsic_type<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, i_n_tps, n_tps); } else { require_same_types(ccx, - None, it.span, i_ty.ty, fty, diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 47098599df2..3360f9dab78 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -52,11 +52,11 @@ struct InstantiatedMethodSig<'tcx> { method_predicates: ty::InstantiatedPredicates<'tcx>, } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn confirm_method(&self, span: Span, - self_expr: &'tcx hir::Expr, - call_expr: &'tcx hir::Expr, + self_expr: &'gcx hir::Expr, + call_expr: &'gcx hir::Expr, unadjusted_self_ty: Ty<'tcx>, pick: probe::Pick<'tcx>, supplied_method_types: Vec>) @@ -72,12 +72,12 @@ pub fn confirm_method(&self, } } -impl<'a,'tcx> ConfirmContext<'a,'tcx, 'tcx> { - fn new(fcx: &'a FnCtxt<'a, 'tcx, 'tcx>, +impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> { + fn new(fcx: &'a FnCtxt<'a, 'gcx, 'tcx>, span: Span, - self_expr: &'tcx hir::Expr, - call_expr: &'tcx hir::Expr) - -> ConfirmContext<'a, 'tcx, 'tcx> + self_expr: &'gcx hir::Expr, + call_expr: &'gcx hir::Expr) + -> ConfirmContext<'a, 'gcx, 'tcx> { ConfirmContext { fcx: fcx, span: span, self_expr: self_expr, call_expr: call_expr } } @@ -286,7 +286,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx, 'tcx> { } fn extract_trait_ref(&mut self, self_ty: Ty<'tcx>, mut closure: F) -> R where - F: FnMut(&mut ConfirmContext<'a, 'tcx, 'tcx>, Ty<'tcx>, &ty::TraitTy<'tcx>) -> R, + F: FnMut(&mut ConfirmContext<'a, 'gcx, 'tcx>, Ty<'tcx>, &ty::TraitTy<'tcx>) -> R, { // If we specified that this is an object method, then the // self-type ought to be something that can be dereferenced to diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index 8d6cc217b8b..f30abbaba0e 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -78,7 +78,7 @@ pub enum CandidateSource { TraitSource(/* trait id */ DefId), } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { /// Determines whether the type `self_ty` supports a method name `method_name` or not. pub fn method_exists(&self, span: Span, @@ -116,8 +116,8 @@ pub fn lookup_method(&self, method_name: ast::Name, self_ty: ty::Ty<'tcx>, supplied_method_types: Vec>, - call_expr: &'tcx hir::Expr, - self_expr: &'tcx hir::Expr) + call_expr: &'gcx hir::Expr, + self_expr: &'gcx hir::Expr) -> Result, MethodError<'tcx>> { debug!("lookup(method_name={}, self_ty={:?}, call_expr={:?}, self_expr={:?})", diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 6ee309516a0..8ce92892e9a 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -136,7 +136,7 @@ pub enum Mode { Path } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn probe_method(&self, span: Span, mode: Mode, @@ -241,14 +241,14 @@ fn create_steps(&self, } } -impl<'a,'tcx> ProbeContext<'a,'tcx, 'tcx> { - fn new(fcx: &'a FnCtxt<'a,'tcx, 'tcx>, +impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> { + fn new(fcx: &'a FnCtxt<'a, 'gcx, 'tcx>, span: Span, mode: Mode, item_name: ast::Name, steps: Vec>, opt_simplified_steps: Option>) - -> ProbeContext<'a,'tcx, 'tcx> + -> ProbeContext<'a, 'gcx, 'tcx> { ProbeContext { fcx: fcx, @@ -554,7 +554,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx, 'tcx> { mut mk_cand: F, ) where F: for<'b> FnMut( - &mut ProbeContext<'b, 'tcx, 'tcx>, + &mut ProbeContext<'b, 'gcx, 'tcx>, ty::PolyTraitRef<'tcx>, ty::ImplOrTraitItem<'tcx>, ), diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 897a588bb62..ed60f9b6e7c 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -39,7 +39,7 @@ use std::cmp::Ordering; use super::{MethodError, NoMatchData, CandidateSource}; use super::probe::Mode; -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { fn is_fn_ty(&self, ty: &Ty<'tcx>, span: Span) -> bool { let tcx = self.tcx; match ty.sty { diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index edaac66763c..9e771d95bbd 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -80,7 +80,7 @@ pub use self::Expectation::*; pub use self::compare_method::{compare_impl_method, compare_const_impl}; use self::TupleArgumentsFlag::*; -use astconv::{self, ast_region_to_region, ast_ty_to_ty, AstConv, PathParamMode}; +use astconv::{AstConv, ast_region_to_region, PathParamMode}; use check::_match::PatCtxt; use dep_graph::DepNode; use fmt_macros::{Parser, Piece, Position}; @@ -168,7 +168,7 @@ pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { // decision. We keep these deferred resolutions grouped by the // def-id of the closure, so that once we decide, we can easily go // back and process them. - deferred_call_resolutions: RefCell>>>, + deferred_call_resolutions: RefCell>>>, deferred_cast_checks: RefCell>>, } @@ -180,11 +180,11 @@ impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> { } } -trait DeferredCallResolution<'tcx> { - fn resolve<'a>(&mut self, fcx: &FnCtxt<'a,'tcx, 'tcx>); +trait DeferredCallResolution<'gcx, 'tcx> { + fn resolve<'a>(&mut self, fcx: &FnCtxt<'a, 'gcx, 'tcx>); } -type DeferredCallResolutionHandler<'tcx> = Box+'tcx>; +type DeferredCallResolutionHandler<'gcx, 'tcx> = Box+'tcx>; /// When type-checking an expression, we propagate downward /// whatever type hint we are able in the form of an `Expectation`. @@ -204,7 +204,7 @@ pub enum Expectation<'tcx> { ExpectRvalueLikeUnsized(Ty<'tcx>), } -impl<'a, 'tcx> Expectation<'tcx> { +impl<'a, 'gcx, 'tcx> Expectation<'tcx> { // Disregard "castable to" expectations because they // can lead us astray. Consider for example `if cond // {22} else {c} as u8` -- if we propagate the @@ -221,7 +221,7 @@ impl<'a, 'tcx> Expectation<'tcx> { // an expected type. Otherwise, we might write parts of the type // when checking the 'then' block which are incompatible with the // 'else' branch. - fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) -> Expectation<'tcx> { + fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> { match *self { ExpectHasType(ety) => { let ety = fcx.shallow_resolve(ety); @@ -257,7 +257,7 @@ impl<'a, 'tcx> Expectation<'tcx> { /// which still is useful, because it informs integer literals and the like. /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169 /// for examples of where this comes up,. - fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> { + fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> { match fcx.tcx.struct_tail(ty).sty { ty::TySlice(_) | ty::TyStr | ty::TyTrait(..) => { ExpectRvalueLikeUnsized(ty) @@ -269,7 +269,7 @@ impl<'a, 'tcx> Expectation<'tcx> { // Resolves `expected` by a single level if it is a variable. If // there is no expected type or resolution is not possible (e.g., // no constraints yet present), just returns `None`. - fn resolve(self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) -> Expectation<'tcx> { + fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> { match self { NoExpectation => { NoExpectation @@ -286,7 +286,7 @@ impl<'a, 'tcx> Expectation<'tcx> { } } - fn to_option(self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) -> Option> { + fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option> { match self.resolve(fcx) { NoExpectation => None, ExpectCastableToType(ty) | @@ -295,7 +295,7 @@ impl<'a, 'tcx> Expectation<'tcx> { } } - fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx, 'tcx>) -> Option> { + fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option> { match self.resolve(fcx) { ExpectHasType(ty) => Some(ty), _ => None @@ -372,7 +372,7 @@ impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> { } } -impl<'a, 'tcx> Inherited<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> { fn enter(ccx: &'a CrateCtxt<'a, 'tcx>, param_env: ty::ParameterEnvironment<'tcx>, f: F) -> R @@ -493,16 +493,15 @@ fn check_bare_fn<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, Inherited::enter(ccx, param_env, |inh| { // Compute the fty from point of view of inside fn. - let fn_scope = ccx.tcx.region_maps.call_site_extent(fn_id, body.id); + let fn_scope = inh.tcx.region_maps.call_site_extent(fn_id, body.id); let fn_sig = - fn_ty.sig.subst(ccx.tcx, &inh.parameter_environment.free_substs); + fn_ty.sig.subst(inh.tcx, &inh.parameter_environment.free_substs); let fn_sig = - ccx.tcx.liberate_late_bound_regions(fn_scope, &fn_sig); + inh.tcx.liberate_late_bound_regions(fn_scope, &fn_sig); let fn_sig = inh.normalize_associated_types_in(body.span, body.id, &fn_sig); - let fcx = check_fn(ccx, fn_ty.unsafety, fn_id, &fn_sig, - decl, fn_id, body, &inh); + let fcx = check_fn(&inh, fn_ty.unsafety, fn_id, &fn_sig, decl, fn_id, body); fcx.select_all_obligations_and_apply_defaults(); fcx.closure_analyze_fn(body); @@ -519,7 +518,7 @@ struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { fcx: &'a FnCtxt<'a, 'gcx, 'tcx> } -impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> { fn assign(&mut self, _span: Span, nid: ast::NodeId, ty_opt: Option>) -> Ty<'tcx> { match ty_opt { None => { @@ -537,9 +536,9 @@ impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx, 'tcx> { } } -impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> { // Add explicitly-declared locals. - fn visit_local(&mut self, local: &'tcx hir::Local) { + fn visit_local(&mut self, local: &'gcx hir::Local) { let o_ty = match local.ty { Some(ref ty) => Some(self.fcx.to_ty(&ty)), None => None @@ -553,7 +552,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx, 'tcx> { } // Add pattern bindings. - fn visit_pat(&mut self, p: &'tcx hir::Pat) { + fn visit_pat(&mut self, p: &'gcx hir::Pat) { if let PatKind::Ident(_, ref path1, _) = p.node { if pat_util::pat_is_binding(&self.fcx.tcx.def_map.borrow(), p) { let var_ty = self.assign(p.span, p.id, None); @@ -571,7 +570,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx, 'tcx> { intravisit::walk_pat(self, p); } - fn visit_block(&mut self, b: &'tcx hir::Block) { + fn visit_block(&mut self, b: &'gcx hir::Block) { // non-obvious: the `blk` variable maps to region lb, so // we have to keep this up-to-date. This // is... unfortunate. It'd be nice to not need this. @@ -580,7 +579,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx, 'tcx> { // Since an expr occurs as part of the type fixed size arrays we // need to record the type for that node - fn visit_ty(&mut self, t: &'tcx hir::Ty) { + fn visit_ty(&mut self, t: &'gcx hir::Ty) { match t.node { hir::TyFixedLengthVec(ref ty, ref count_expr) => { self.visit_ty(&ty); @@ -595,8 +594,8 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx, 'tcx> { } // Don't descend into the bodies of nested closures - fn visit_fn(&mut self, _: intravisit::FnKind<'tcx>, _: &'tcx hir::FnDecl, - _: &'tcx hir::Block, _: Span, _: ast::NodeId) { } + fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl, + _: &'gcx hir::Block, _: Span, _: ast::NodeId) { } } /// Helper used by check_bare_fn and check_expr_fn. Does the grungy work of checking a function @@ -605,17 +604,16 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx, 'tcx> { /// /// * ... /// * inherited: other fields inherited from the enclosing fn (if any) -fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>, - unsafety: hir::Unsafety, - unsafety_id: ast::NodeId, - fn_sig: &ty::FnSig<'tcx>, - decl: &'tcx hir::FnDecl, - fn_id: ast::NodeId, - body: &'tcx hir::Block, - inherited: &'a Inherited<'a, 'tcx, 'tcx>) - -> FnCtxt<'a, 'tcx, 'tcx> +fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>, + unsafety: hir::Unsafety, + unsafety_id: ast::NodeId, + fn_sig: &ty::FnSig<'tcx>, + decl: &'gcx hir::FnDecl, + fn_id: ast::NodeId, + body: &'gcx hir::Block) + -> FnCtxt<'a, 'gcx, 'tcx> { - let tcx = ccx.tcx; + let tcx = inherited.tcx; let arg_tys = &fn_sig.inputs; let ret_ty = fn_sig.output; @@ -1244,8 +1242,8 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, check_representable(ccx.tcx, sp, id, "enum"); } -impl<'a, 'tcx> AstConv<'tcx, 'tcx> for FnCtxt<'a, 'tcx, 'tcx> { - fn tcx<'b>(&'b self) -> TyCtxt<'b, 'tcx, 'tcx> { self.tcx } +impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> { + fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx } fn get_item_type_scheme(&self, _: Span, id: DefId) -> Result, ErrorReported> @@ -1356,7 +1354,7 @@ impl<'a, 'tcx> AstConv<'tcx, 'tcx> for FnCtxt<'a, 'tcx, 'tcx> { } } -impl<'a, 'tcx> RegionScope for FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> RegionScope for FnCtxt<'a, 'gcx, 'tcx> { fn object_lifetime_default(&self, span: Span) -> Option { Some(self.base_object_lifetime_default(span)) } @@ -1413,11 +1411,11 @@ enum TupleArgumentsFlag { TupleArguments, } -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { - pub fn new(inh: &'a Inherited<'a, 'tcx, 'tcx>, +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { + pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>, rty: ty::FnOutput<'tcx>, body_id: ast::NodeId) - -> FnCtxt<'a, 'tcx, 'tcx> { + -> FnCtxt<'a, 'gcx, 'tcx> { FnCtxt { body_id: body_id, writeback_errors: Cell::new(false), @@ -1473,14 +1471,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { fn record_deferred_call_resolution(&self, closure_def_id: DefId, - r: DeferredCallResolutionHandler<'tcx>) { + r: DeferredCallResolutionHandler<'gcx, 'tcx>) { let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut(); deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r); } fn remove_deferred_call_resolutions(&self, closure_def_id: DefId) - -> Vec> + -> Vec> { let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut(); deferred_call_resolutions.remove(&closure_def_id).unwrap_or(Vec::new()) @@ -1619,7 +1617,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { self.tcx.lookup_item_type(did); let type_predicates = self.tcx.lookup_predicates(did); - let substs = astconv::ast_path_substs_for_ty(self, self, + let substs = AstConv::ast_path_substs_for_ty(self, self, path.span, PathParamMode::Optional, &type_scheme.generics, @@ -1723,7 +1721,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { } pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> { - let t = ast_ty_to_ty(self, self, ast_t); + let t = AstConv::ast_ty_to_ty(self, self, ast_t); self.register_wf_obligation(t, ast_t.span, traits::MiscObligation); t } @@ -2325,7 +2323,7 @@ fn make_overloaded_lvalue_return_type(&self, fn lookup_indexing(&self, expr: &hir::Expr, - base_expr: &'tcx hir::Expr, + base_expr: &'gcx hir::Expr, base_ty: Ty<'tcx>, idx_ty: Ty<'tcx>, lvalue_pref: LvaluePreference) @@ -2367,7 +2365,7 @@ fn lookup_indexing(&self, fn try_index_step(&self, method_call: MethodCall, expr: &hir::Expr, - base_expr: &'tcx hir::Expr, + base_expr: &'gcx hir::Expr, adjusted_ty: Ty<'tcx>, autoderefs: usize, unsize: bool, @@ -2442,8 +2440,8 @@ fn try_index_step(&self, fn check_method_argument_types(&self, sp: Span, method_fn_ty: Ty<'tcx>, - callee_expr: &'tcx hir::Expr, - args_no_rcvr: &'tcx [P], + callee_expr: &'gcx hir::Expr, + args_no_rcvr: &'gcx [P], tuple_arguments: TupleArgumentsFlag, expected: Expectation<'tcx>) -> ty::FnOutput<'tcx> { @@ -2482,7 +2480,7 @@ fn check_argument_types(&self, sp: Span, fn_inputs: &[Ty<'tcx>], expected_arg_tys: &[Ty<'tcx>], - args: &'tcx [P], + args: &'gcx [P], variadic: bool, tuple_arguments: TupleArgumentsFlag) { let tcx = self.tcx; @@ -2756,42 +2754,42 @@ fn check_lit(&self, } fn check_expr_eq_type(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, expected: Ty<'tcx>) { self.check_expr_with_hint(expr, expected); self.demand_eqtype(expr.span, expected, self.expr_ty(expr)); } pub fn check_expr_has_type(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, expected: Ty<'tcx>) { self.check_expr_with_hint(expr, expected); self.demand_suptype(expr.span, expected, self.expr_ty(expr)); } fn check_expr_coercable_to_type(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, expected: Ty<'tcx>) { self.check_expr_with_hint(expr, expected); self.demand_coerce(expr, expected); } -fn check_expr_with_hint(&self, expr: &'tcx hir::Expr, +fn check_expr_with_hint(&self, expr: &'gcx hir::Expr, expected: Ty<'tcx>) { self.check_expr_with_expectation(expr, ExpectHasType(expected)) } fn check_expr_with_expectation(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, expected: Expectation<'tcx>) { self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference) } -fn check_expr(&self, expr: &'tcx hir::Expr) { +fn check_expr(&self, expr: &'gcx hir::Expr) { self.check_expr_with_expectation(expr, NoExpectation) } -fn check_expr_with_lvalue_pref(&self, expr: &'tcx hir::Expr, +fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr, lvalue_pref: LvaluePreference) { self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref) } @@ -2867,9 +2865,9 @@ fn expected_types_for_fn_args(&self, // Checks a method call. fn check_method_call(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, method_name: Spanned, - args: &'tcx [P], + args: &'gcx [P], tps: &[P], expected: Expectation<'tcx>, lvalue_pref: LvaluePreference) { @@ -2914,9 +2912,9 @@ fn expected_types_for_fn_args(&self, // A generic function for checking the then and else in an if // or if-else. fn check_then_else(&self, - cond_expr: &'tcx hir::Expr, - then_blk: &'tcx hir::Block, - opt_else_expr: Option<&'tcx hir::Expr>, + cond_expr: &'gcx hir::Expr, + then_blk: &'gcx hir::Block, + opt_else_expr: Option<&'gcx hir::Expr>, id: ast::NodeId, sp: Span, expected: Expectation<'tcx>) { @@ -2989,9 +2987,9 @@ fn expected_types_for_fn_args(&self, // Check field access expressions fn check_field(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, lvalue_pref: LvaluePreference, - base: &'tcx hir::Expr, + base: &'gcx hir::Expr, field: &Spanned) { self.check_expr_with_lvalue_pref(base, lvalue_pref); let expr_t = self.structurally_resolved_type(expr.span, @@ -3080,9 +3078,9 @@ fn expected_types_for_fn_args(&self, // Check tuple index expressions fn check_tup_field(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, lvalue_pref: LvaluePreference, - base: &'tcx hir::Expr, + base: &'gcx hir::Expr, idx: codemap::Spanned) { self.check_expr_with_lvalue_pref(base, lvalue_pref); let expr_t = self.structurally_resolved_type(expr.span, @@ -3180,7 +3178,7 @@ fn expected_types_for_fn_args(&self, adt_ty: Ty<'tcx>, span: Span, variant: ty::VariantDef<'tcx>, - ast_fields: &'tcx [hir::Field], + ast_fields: &'gcx [hir::Field], check_completeness: bool) { let tcx = self.tcx; let substs = match adt_ty.sty { @@ -3237,8 +3235,8 @@ fn expected_types_for_fn_args(&self, fn check_struct_fields_on_error(&self, id: ast::NodeId, - fields: &'tcx [hir::Field], - base_expr: &'tcx Option>) { + fields: &'gcx [hir::Field], + base_expr: &'gcx Option>) { // Make sure to still write the types // otherwise we might ICE self.write_error(id); @@ -3254,8 +3252,8 @@ fn expected_types_for_fn_args(&self, fn check_expr_struct(&self, expr: &hir::Expr, path: &hir::Path, - fields: &'tcx [hir::Field], - base_expr: &'tcx Option>) + fields: &'gcx [hir::Field], + base_expr: &'gcx Option>) { let tcx = self.tcx; @@ -3315,7 +3313,7 @@ fn expected_types_for_fn_args(&self, /// that there are actually multiple representations for `TyError`, so avoid /// that when err needs to be handled differently. fn check_expr_with_expectation_and_lvalue_pref(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, expected: Expectation<'tcx>, lvalue_pref: LvaluePreference) { debug!(">> typechecking: expr={:?} expected={:?}", @@ -3666,7 +3664,7 @@ fn check_expr_with_expectation_and_lvalue_pref(&self, } hir::ExprRepeat(ref element, ref count_expr) => { self.check_expr_has_type(&count_expr, tcx.types.usize); - let count = eval_repeat_count(self.tcx, &count_expr); + let count = eval_repeat_count(self.tcx.global_tcx(), &count_expr); let uty = match expected { ExpectHasType(uty) => { @@ -3827,7 +3825,7 @@ pub fn resolve_ty_and_def_ufcs<'b>(&self, let mut def = path_res.base_def; let ty_segments = path.segments.split_last().unwrap().1; let base_ty_end = path.segments.len() - path_res.depth; - let ty = astconv::finish_resolving_def_to_ty(self, self, span, + let ty = AstConv::finish_resolving_def_to_ty(self, self, span, PathParamMode::Optional, &mut def, opt_self_ty, @@ -3864,8 +3862,8 @@ pub fn resolve_ty_and_def_ufcs<'b>(&self, } pub fn check_decl_initializer(&self, - local: &'tcx hir::Local, - init: &'tcx hir::Expr) + local: &'gcx hir::Local, + init: &'gcx hir::Expr) { let ref_bindings = self.tcx.pat_contains_ref_binding(&local.pat); @@ -3887,7 +3885,7 @@ pub fn check_decl_initializer(&self, }; } -pub fn check_decl_local(&self, local: &'tcx hir::Local) { +pub fn check_decl_local(&self, local: &'gcx hir::Local) { let tcx = self.tcx; let t = self.local_ty(local.span, local.id); @@ -3912,7 +3910,7 @@ pub fn check_decl_local(&self, local: &'tcx hir::Local) { } } -pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) { +pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) { let node_id; let mut saw_bot = false; let mut saw_err = false; @@ -3956,7 +3954,7 @@ pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) { } } -pub fn check_block_no_value(&self, blk: &'tcx hir::Block) { +pub fn check_block_no_value(&self, blk: &'gcx hir::Block) { self.check_block_with_expected(blk, ExpectHasType(self.tcx.mk_nil())); let blkty = self.node_ty(blk.id); if blkty.references_error() { @@ -3968,7 +3966,7 @@ pub fn check_block_no_value(&self, blk: &'tcx hir::Block) { } fn check_block_with_expected(&self, - blk: &'tcx hir::Block, + blk: &'gcx hir::Block, expected: Expectation<'tcx>) { let prev = { let mut fcx_ps = self.ps.borrow_mut(); @@ -4047,7 +4045,7 @@ fn check_block_with_expected(&self, fn check_const_with_ty(&self, _: Span, - e: &'tcx hir::Expr, + e: &'gcx hir::Expr, declty: Ty<'tcx>) { // Gather locals in statics (because of block expressions). // This is technically unnecessary because locals in static items are forbidden, diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs index 9b3823774f7..3986b866033 100644 --- a/src/librustc_typeck/check/op.rs +++ b/src/librustc_typeck/check/op.rs @@ -17,13 +17,13 @@ use syntax::ast; use syntax::parse::token; use rustc::hir; -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { /// Check a `a = b` pub fn check_binop_assign(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, op: hir::BinOp, - lhs_expr: &'tcx hir::Expr, - rhs_expr: &'tcx hir::Expr) + lhs_expr: &'gcx hir::Expr, + rhs_expr: &'gcx hir::Expr) { self.check_expr_with_lvalue_pref(lhs_expr, PreferMutLvalue); @@ -47,10 +47,10 @@ pub fn check_binop_assign(&self, /// Check a potentially overloaded binary operator. pub fn check_binop(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, op: hir::BinOp, - lhs_expr: &'tcx hir::Expr, - rhs_expr: &'tcx hir::Expr) + lhs_expr: &'gcx hir::Expr, + rhs_expr: &'gcx hir::Expr) { let tcx = self.tcx; @@ -106,9 +106,9 @@ pub fn check_binop(&self, } fn enforce_builtin_binop_types(&self, - lhs_expr: &'tcx hir::Expr, + lhs_expr: &'gcx hir::Expr, lhs_ty: Ty<'tcx>, - rhs_expr: &'tcx hir::Expr, + rhs_expr: &'gcx hir::Expr, rhs_ty: Ty<'tcx>, op: hir::BinOp) -> Ty<'tcx> @@ -144,10 +144,10 @@ fn enforce_builtin_binop_types(&self, } fn check_overloaded_binop(&self, - expr: &'tcx hir::Expr, - lhs_expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, + lhs_expr: &'gcx hir::Expr, lhs_ty: Ty<'tcx>, - rhs_expr: &'tcx hir::Expr, + rhs_expr: &'gcx hir::Expr, op: hir::BinOp, is_assign: IsAssign) -> (Ty<'tcx>, Ty<'tcx>) @@ -222,8 +222,8 @@ pub fn check_user_unop(&self, op_str: &str, mname: &str, trait_did: Option, - ex: &'tcx hir::Expr, - operand_expr: &'tcx hir::Expr, + ex: &'gcx hir::Expr, + operand_expr: &'gcx hir::Expr, operand_ty: Ty<'tcx>, op: hir::UnOp) -> Ty<'tcx> @@ -294,7 +294,7 @@ fn name_and_trait_def_id(&self, } fn lookup_op_method(&self, - expr: &'tcx hir::Expr, + expr: &'gcx hir::Expr, lhs_ty: Ty<'tcx>, other_tys: Vec>, opname: ast::Name, diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index b65fcbac8d4..931f77951eb 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -113,7 +113,7 @@ macro_rules! ignore_err { /////////////////////////////////////////////////////////////////////////// // PUBLIC ENTRY POINTS -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn regionck_expr(&self, e: &hir::Expr) { let mut rcx = RegionCtxt::new(self, RepeatingScope(e.id), e.id, Subject(e.id)); if self.err_count_since_creation() == 0 { @@ -198,11 +198,11 @@ impl<'a, 'gcx, 'tcx> Deref for RegionCtxt<'a, 'gcx, 'tcx> { pub struct RepeatingScope(ast::NodeId); pub enum SubjectNode { Subject(ast::NodeId), None } -impl<'a, 'tcx> RegionCtxt<'a, 'tcx, 'tcx> { - pub fn new(fcx: &'a FnCtxt<'a, 'tcx, 'tcx>, +impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> { + pub fn new(fcx: &'a FnCtxt<'a, 'gcx, 'tcx>, initial_repeating_scope: RepeatingScope, initial_body_id: ast::NodeId, - subject: SubjectNode) -> RegionCtxt<'a, 'tcx, 'tcx> { + subject: SubjectNode) -> RegionCtxt<'a, 'gcx, 'tcx> { let RepeatingScope(initial_repeating_scope) = initial_repeating_scope; RegionCtxt { fcx: fcx, @@ -487,7 +487,7 @@ fn constrain_bindings_in_pat(&mut self, pat: &hir::Pat) { } } -impl<'a, 'tcx, 'v> Visitor<'v> for RegionCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx, 'v> Visitor<'v> for RegionCtxt<'a, 'gcx, 'tcx> { // (..) FIXME(#3238) should use visit_pat, not visit_arm/visit_local, // However, right now we run into an issue whereby some free // regions are not properly related if they appear within the @@ -794,7 +794,7 @@ fn visit_expr(&mut self, expr: &hir::Expr) { } } -impl<'a, 'tcx> RegionCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> { fn constrain_cast(&mut self, cast_expr: &hir::Expr, source_expr: &hir::Expr) @@ -1151,7 +1151,7 @@ fn link_fn_args(&self, body_scope: CodeExtent, args: &[hir::Arg]) { /// Link lifetimes of any ref bindings in `root_pat` to the pointers found in the discriminant, if /// needed. fn link_pattern<'t>(&self, - mc: mc::MemCategorizationContext<'a, 'tcx, 'tcx>, + mc: mc::MemCategorizationContext<'a, 'gcx, 'tcx>, discr_cmt: mc::cmt<'tcx>, root_pat: &hir::Pat) { debug!("link_pattern(discr_cmt={:?}, root_pat={:?})", diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index 175171e2f2a..10c16391bf7 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -56,7 +56,7 @@ use rustc::hir::intravisit::{self, Visitor}; /////////////////////////////////////////////////////////////////////////// // PUBLIC ENTRY POINTS -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn closure_analyze_fn(&self, body: &hir::Block) { let mut seed = SeedBorrowKind::new(self); seed.visit_block(body); @@ -90,7 +90,7 @@ struct SeedBorrowKind<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { closures_with_inferred_kinds: HashSet, } -impl<'a, 'tcx, 'v> Visitor<'v> for SeedBorrowKind<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx, 'v> Visitor<'v> for SeedBorrowKind<'a, 'gcx, 'tcx> { fn visit_expr(&mut self, expr: &hir::Expr) { match expr.node { hir::ExprClosure(cc, _, ref body, _) => { @@ -104,8 +104,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for SeedBorrowKind<'a, 'tcx, 'tcx> { } } -impl<'a,'tcx> SeedBorrowKind<'a,'tcx, 'tcx> { - fn new(fcx: &'a FnCtxt<'a,'tcx, 'tcx>) -> SeedBorrowKind<'a,'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> SeedBorrowKind<'a, 'gcx, 'tcx> { + fn new(fcx: &'a FnCtxt<'a, 'gcx, 'tcx>) -> SeedBorrowKind<'a, 'gcx, 'tcx> { SeedBorrowKind { fcx: fcx, closures_with_inferred_kinds: HashSet::new() } } @@ -157,10 +157,10 @@ struct AdjustBorrowKind<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { closures_with_inferred_kinds: &'a HashSet, } -impl<'a,'tcx> AdjustBorrowKind<'a,'tcx, 'tcx> { - fn new(fcx: &'a FnCtxt<'a,'tcx, 'tcx>, +impl<'a, 'gcx, 'tcx> AdjustBorrowKind<'a, 'gcx, 'tcx> { + fn new(fcx: &'a FnCtxt<'a, 'gcx, 'tcx>, closures_with_inferred_kinds: &'a HashSet) - -> AdjustBorrowKind<'a,'tcx, 'tcx> { + -> AdjustBorrowKind<'a, 'gcx, 'tcx> { AdjustBorrowKind { fcx: fcx, closures_with_inferred_kinds: closures_with_inferred_kinds } } @@ -492,7 +492,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx, 'tcx> { } } -impl<'a, 'tcx, 'v> Visitor<'v> for AdjustBorrowKind<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx, 'v> Visitor<'v> for AdjustBorrowKind<'a, 'gcx, 'tcx> { fn visit_fn(&mut self, fn_kind: intravisit::FnKind<'v>, decl: &'v hir::FnDecl, @@ -505,7 +505,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for AdjustBorrowKind<'a, 'tcx, 'tcx> { } } -impl<'a,'tcx> euv::Delegate<'tcx> for AdjustBorrowKind<'a,'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for AdjustBorrowKind<'a, 'gcx, 'tcx> { fn consume(&mut self, _consume_id: ast::NodeId, _consume_span: Span, diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 3069627a421..7739bb6bb8f 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -410,10 +410,8 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { debug!("check_method_receiver: receiver ty = {:?}", rcvr_ty); - let _ = ::require_same_types( - fcx.ccx, Some(fcx), span, - sig.inputs[0], rcvr_ty, - "mismatched method receiver"); + fcx.require_same_types(span, sig.inputs[0], rcvr_ty, + "mismatched method receiver"); } fn check_variances_for_type_defn(&self, diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 5307753613d..1c7496d611e 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -34,7 +34,7 @@ use rustc::hir; /////////////////////////////////////////////////////////////////////////// // Entry point functions -impl<'a, 'tcx> FnCtxt<'a, 'tcx, 'tcx> { +impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { pub fn resolve_type_vars_in_expr(&self, e: &hir::Expr) { assert_eq!(self.writeback_errors.get(), false); let mut wbcx = WritebackCx::new(self); @@ -78,12 +78,12 @@ struct WritebackCx<'cx, 'gcx: 'cx+'tcx, 'tcx: 'cx> { fcx: &'cx FnCtxt<'cx, 'gcx, 'tcx>, } -impl<'cx, 'tcx> WritebackCx<'cx, 'tcx, 'tcx> { - fn new(fcx: &'cx FnCtxt<'cx, 'tcx, 'tcx>) -> WritebackCx<'cx, 'tcx, 'tcx> { +impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> { + fn new(fcx: &'cx FnCtxt<'cx, 'gcx, 'tcx>) -> WritebackCx<'cx, 'gcx, 'tcx> { WritebackCx { fcx: fcx } } - fn tcx(&self) -> TyCtxt<'cx, 'tcx, 'tcx> { + fn tcx(&self) -> TyCtxt<'cx, 'gcx, 'tcx> { self.fcx.tcx } @@ -134,7 +134,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx, 'tcx> { // below. In general, a function is made into a `visitor` if it must // traffic in node-ids or update tables in the type context etc. -impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx, 'tcx> { +impl<'cx, 'gcx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'gcx, 'tcx> { fn visit_stmt(&mut self, s: &hir::Stmt) { if self.fcx.writeback_errors.get() { return; @@ -214,7 +214,7 @@ impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx, 'tcx> { } } -impl<'cx, 'tcx> WritebackCx<'cx, 'tcx, 'tcx> { +impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> { fn visit_upvar_borrow_map(&self) { if self.fcx.writeback_errors.get() { return; @@ -359,8 +359,16 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx, 'tcx> { } } - fn resolve>(&self, t: &T, reason: ResolveReason) -> T { - t.fold_with(&mut Resolver::new(self.fcx, reason)) + fn resolve(&self, x: &T, reason: ResolveReason) -> T::Lifted + where T: TypeFoldable<'tcx> + ty::Lift<'gcx> + { + let x = x.fold_with(&mut Resolver::new(self.fcx, reason)); + if let Some(lifted) = self.tcx().lift_to_global(&x) { + lifted + } else { + span_bug!(reason.span(self.tcx()), + "writeback: `{:?}` missing from the global type context", x); + } } } @@ -378,8 +386,8 @@ enum ResolveReason { ResolvingFieldTypes(ast::NodeId) } -impl ResolveReason { - fn span<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Span { +impl<'a, 'gcx, 'tcx> ResolveReason { + fn span(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Span { match *self { ResolvingExpr(s) => s, ResolvingLocal(s) => s, @@ -415,18 +423,18 @@ struct Resolver<'cx, 'gcx: 'cx+'tcx, 'tcx: 'cx> { reason: ResolveReason, } -impl<'cx, 'tcx> Resolver<'cx, 'tcx, 'tcx> { - fn new(fcx: &'cx FnCtxt<'cx, 'tcx, 'tcx>, +impl<'cx, 'gcx, 'tcx> Resolver<'cx, 'gcx, 'tcx> { + fn new(fcx: &'cx FnCtxt<'cx, 'gcx, 'tcx>, reason: ResolveReason) - -> Resolver<'cx, 'tcx, 'tcx> + -> Resolver<'cx, 'gcx, 'tcx> { Resolver::from_infcx(fcx, &fcx.writeback_errors, reason) } - fn from_infcx(infcx: &'cx InferCtxt<'cx, 'tcx, 'tcx>, + fn from_infcx(infcx: &'cx InferCtxt<'cx, 'gcx, 'tcx>, writeback_errors: &'cx Cell, reason: ResolveReason) - -> Resolver<'cx, 'tcx, 'tcx> + -> Resolver<'cx, 'gcx, 'tcx> { Resolver { infcx: infcx, tcx: infcx.tcx, @@ -480,8 +488,8 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx, 'tcx> { } } -impl<'cx, 'tcx> TypeFolder<'tcx, 'tcx> for Resolver<'cx, 'tcx, 'tcx> { - fn tcx<'a>(&'a self) -> TyCtxt<'a, 'tcx, 'tcx> { +impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Resolver<'cx, 'gcx, 'tcx> { + fn tcx<'a>(&'a self) -> TyCtxt<'a, 'gcx, 'tcx> { self.tcx } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index e49df1fc745..797a1509ebe 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -58,7 +58,7 @@ There are some shortcomings in this design: */ -use astconv::{self, AstConv, ty_of_arg, ast_ty_to_ty, ast_region_to_region}; +use astconv::{AstConv, ast_region_to_region, Bounds, PartitionedBounds, partition_bounds}; use lint; use hir::def::Def; use hir::def_id::DefId; @@ -291,7 +291,7 @@ impl<'a,'tcx> CrateCtxt<'a,'tcx> { impl<'a,'tcx> ItemCtxt<'a,'tcx> { fn to_ty(&self, rs: &RS, ast_ty: &hir::Ty) -> Ty<'tcx> { - ast_ty_to_ty(self, rs, ast_ty) + AstConv::ast_ty_to_ty(self, rs, ast_ty) } } @@ -559,7 +559,7 @@ fn convert_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, ty_generic_predicates_for_fn(ccx, &sig.generics, rcvr_ty_predicates); let (fty, explicit_self_category) = - astconv::ty_of_method(&ccx.icx(&(rcvr_ty_predicates, &sig.generics)), + AstConv::ty_of_method(&ccx.icx(&(rcvr_ty_predicates, &sig.generics)), sig, untransformed_rcvr_ty); let def_id = ccx.tcx.map.local_def_id(id); @@ -712,7 +712,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { }, hir::ItemDefaultImpl(_, ref ast_trait_ref) => { let trait_ref = - astconv::instantiate_mono_trait_ref(&ccx.icx(&()), + AstConv::instantiate_mono_trait_ref(&ccx.icx(&()), &ExplicitRscope, ast_trait_ref, None); @@ -742,7 +742,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { TypeScheme { generics: ty_generics.clone(), ty: selfty }); let trait_ref = opt_trait_ref.as_ref().map(|ast_trait_ref| { - astconv::instantiate_mono_trait_ref(&ccx.icx(&ty_predicates), + AstConv::instantiate_mono_trait_ref(&ccx.icx(&ty_predicates), &ExplicitRscope, ast_trait_ref, Some(selfty)) @@ -1452,7 +1452,7 @@ fn compute_type_scheme_of_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, } hir::ItemFn(ref decl, unsafety, _, abi, ref generics, _) => { let ty_generics = ty_generics_for_fn(ccx, generics, &ty::Generics::empty()); - let tofd = astconv::ty_of_bare_fn(&ccx.icx(generics), unsafety, abi, &decl); + let tofd = AstConv::ty_of_bare_fn(&ccx.icx(generics), unsafety, abi, &decl); let def_id = ccx.tcx.map.local_def_id(it.id); let substs = mk_item_substs(ccx, &ty_generics); let ty = tcx.mk_fn_def(def_id, substs, tofd); @@ -1582,7 +1582,7 @@ fn compute_type_scheme_of_foreign_item<'a, 'tcx>( hir::ForeignItemStatic(ref t, _) => { ty::TypeScheme { generics: ty::Generics::empty(), - ty: ast_ty_to_ty(&ccx.icx(&()), &ExplicitRscope, t) + ty: AstConv::ast_ty_to_ty(&ccx.icx(&()), &ExplicitRscope, t) } } } @@ -1793,9 +1793,9 @@ fn ty_generic_predicates<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, for predicate in &where_clause.predicates { match predicate { &hir::WherePredicate::BoundPredicate(ref bound_pred) => { - let ty = ast_ty_to_ty(&ccx.icx(&(base_predicates, ast_generics)), - &ExplicitRscope, - &bound_pred.bounded_ty); + let ty = AstConv::ast_ty_to_ty(&ccx.icx(&(base_predicates, ast_generics)), + &ExplicitRscope, + &bound_pred.bounded_ty); for bound in bound_pred.bounds.iter() { match bound { @@ -1887,7 +1887,7 @@ fn convert_default_type_parameter<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, index: u32) -> Ty<'tcx> { - let ty = ast_ty_to_ty(&ccx.icx(&()), &ExplicitRscope, &path); + let ty = AstConv::ast_ty_to_ty(&ccx.icx(&()), &ExplicitRscope, &path); for leaf_ty in ty.walk() { if let ty::TyParam(p) = leaf_ty.sty { @@ -1991,7 +1991,7 @@ fn compute_object_lifetime_default<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, hir::TraitTyParamBound(..) => None, hir::RegionTyParamBound(ref lifetime) => - Some(astconv::ast_region_to_region(ccx.tcx, lifetime)), + Some(ast_region_to_region(ccx.tcx, lifetime)), } }) .collect() @@ -2034,7 +2034,7 @@ fn compute_bounds<'tcx>(astconv: &AstConv<'tcx, 'tcx>, ast_bounds: &[hir::TyParamBound], sized_by_default: SizedByDefault, span: Span) - -> astconv::Bounds<'tcx> + -> Bounds<'tcx> { let mut bounds = conv_param_bounds(astconv, @@ -2090,7 +2090,7 @@ fn conv_poly_trait_ref<'tcx>(astconv: &AstConv<'tcx, 'tcx>, projections: &mut Vec>) -> ty::PolyTraitRef<'tcx> { - astconv::instantiate_poly_trait_ref(astconv, + AstConv::instantiate_poly_trait_ref(astconv, &ExplicitRscope, trait_ref, Some(param_ty), @@ -2101,14 +2101,14 @@ fn conv_param_bounds<'a,'tcx>(astconv: &AstConv<'tcx, 'tcx>, span: Span, param_ty: ty::Ty<'tcx>, ast_bounds: &[hir::TyParamBound]) - -> astconv::Bounds<'tcx> + -> Bounds<'tcx> { let tcx = astconv.tcx(); - let astconv::PartitionedBounds { + let PartitionedBounds { builtin_bounds, trait_bounds, region_bounds - } = astconv::partition_bounds(tcx, span, &ast_bounds); + } = partition_bounds(tcx, span, &ast_bounds); let mut projection_bounds = Vec::new(); @@ -2125,7 +2125,7 @@ fn conv_param_bounds<'a,'tcx>(astconv: &AstConv<'tcx, 'tcx>, .map(|r| ast_region_to_region(tcx, r)) .collect(); - astconv::Bounds { + Bounds { region_bounds: region_bounds, builtin_bounds: builtin_bounds, trait_bounds: trait_bounds, @@ -2157,12 +2157,12 @@ fn compute_type_scheme_of_foreign_fn_decl<'a, 'tcx>( let rb = BindingRscope::new(); let input_tys = decl.inputs .iter() - .map(|a| ty_of_arg(&ccx.icx(ast_generics), &rb, a, None)) + .map(|a| AstConv::ty_of_arg(&ccx.icx(ast_generics), &rb, a, None)) .collect::>(); let output = match decl.output { hir::Return(ref ty) => - ty::FnConverging(ast_ty_to_ty(&ccx.icx(ast_generics), &rb, &ty)), + ty::FnConverging(AstConv::ast_ty_to_ty(&ccx.icx(ast_generics), &rb, &ty)), hir::DefaultReturn(..) => ty::FnConverging(ccx.tcx.mk_nil()), hir::NoReturn(..) => diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index cdc3cfb7d31..3c46d962198 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -104,7 +104,7 @@ pub use rustc::util; use dep_graph::DepNode; use hir::map as hir_map; use hir::def::Def; -use rustc::infer::{self, InferCtxt, TypeOrigin}; +use rustc::infer::{InferCtxt, TypeOrigin}; use rustc::ty::subst::Substs; use rustc::ty::{self, Ty, TyCtxt, TypeFoldable}; use rustc::traits::ProjectionMode; @@ -192,36 +192,33 @@ fn require_c_abi_if_variadic(tcx: TyCtxt, } } +pub fn emit_type_err<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>, + span: Span, + found_ty: Ty<'tcx>, + expected_ty: Ty<'tcx>, + terr: &ty::error::TypeError<'tcx>, + msg: &str) { + let mut err = struct_span_err!(tcx.sess, span, E0211, "{}", msg); + err = err.span_label(span, &terr); + err = err.note_expected_found(&"type", &expected_ty, &found_ty); + tcx.note_and_explain_type_err(&mut err, terr, span); + err.emit(); +} + fn require_same_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, - maybe_infcx: Option<&infer::InferCtxt<'a, 'tcx, 'tcx>>, span: Span, t1: Ty<'tcx>, t2: Ty<'tcx>, msg: &str) - -> bool -{ - let err = if let Some(infcx) = maybe_infcx { - infcx.eq_types(false, TypeOrigin::Misc(span), t1, t2).err() - } else { - InferCtxt::enter(ccx.tcx, None, None, ProjectionMode::AnyFinal, |infcx| { - infcx.eq_types(false, TypeOrigin::Misc(span), t1, t2).err() - }) - }; - - if let Some(ref terr) = err { - let mut err = struct_span_err!(ccx.tcx.sess, span, E0211, "{}", msg); - err = err.span_label(span, &terr); - let (mut expected_ty, mut found_ty) = (t2, t1); - if let Some(infcx) = maybe_infcx { - expected_ty = infcx.resolve_type_vars_if_possible(&expected_ty); - found_ty = infcx.resolve_type_vars_if_possible(&found_ty); + -> bool { + InferCtxt::enter(ccx.tcx, None, None, ProjectionMode::AnyFinal, |infcx| { + if let Err(err) = infcx.eq_types(false, TypeOrigin::Misc(span), t1, t2) { + emit_type_err(infcx.tcx, span, t1, t2, &err, msg); + false + } else { + true } - err = err.note_expected_found(&"type", &expected_ty, &found_ty); - ccx.tcx.note_and_explain_type_err(&mut err, terr, span); - err.emit(); - } - - err.is_none() + }) } fn check_main_fn_ty(ccx: &CrateCtxt, @@ -258,7 +255,7 @@ fn check_main_fn_ty(ccx: &CrateCtxt, }) })); - require_same_types(ccx, None, main_span, main_t, se_ty, + require_same_types(ccx, main_span, main_t, se_ty, "main function has wrong type"); } _ => { @@ -307,7 +304,7 @@ fn check_start_fn_ty(ccx: &CrateCtxt, }), })); - require_same_types(ccx, None, start_span, start_t, se_ty, + require_same_types(ccx, start_span, start_t, se_ty, "start function has wrong type"); } _ => {