From 9faae6a5ca1c5579a8185138b1e534285324db87 Mon Sep 17 00:00:00 2001 From: Jared Roesch Date: Tue, 30 Jun 2015 02:18:03 -0700 Subject: [PATCH] Remove Typer and ClosureTyper This commit finalizes the work of the past commits by fully moving the fulfillment context into the InferCtxt, cleaning up related context interfaces, removing the Typer and ClosureTyper traits and cleaning up related intefaces --- src/librustc/middle/astencode.rs | 1 - src/librustc/middle/check_const.rs | 2 +- src/librustc/middle/check_match.rs | 2 +- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/expr_use_visitor.rs | 13 +- src/librustc/middle/implicator.rs | 6 +- src/librustc/middle/infer/mod.rs | 250 +++++++++--------- src/librustc/middle/liveness.rs | 2 - src/librustc/middle/mem_categorization.rs | 33 +-- src/librustc/middle/traits/coherence.rs | 2 +- src/librustc/middle/traits/fulfill.rs | 18 +- src/librustc/middle/traits/mod.rs | 10 +- src/librustc/middle/traits/select.rs | 24 +- src/librustc/middle/ty.rs | 36 +-- src/librustc_borrowck/borrowck/mod.rs | 1 - src/librustc_lint/builtin.rs | 1 - src/librustc_trans/trans/adt.rs | 2 +- src/librustc_trans/trans/attributes.rs | 2 +- src/librustc_trans/trans/base.rs | 2 +- src/librustc_trans/trans/closure.rs | 3 +- src/librustc_trans/trans/common.rs | 11 +- src/librustc_trans/trans/debuginfo/gdb.rs | 1 - .../trans/debuginfo/metadata.rs | 2 +- src/librustc_trans/trans/debuginfo/mod.rs | 2 +- .../trans/debuginfo/namespace.rs | 1 - .../trans/debuginfo/type_names.rs | 3 +- src/librustc_trans/trans/declare.rs | 2 +- src/librustc_trans/trans/expr.rs | 1 - src/librustc_trans/trans/meth.rs | 1 - src/librustc_trans/trans/monomorphize.rs | 4 +- src/librustc_typeck/check/assoc.rs | 6 +- src/librustc_typeck/check/callee.rs | 2 +- src/librustc_typeck/check/coercion.rs | 2 +- src/librustc_typeck/check/compare_method.rs | 10 +- src/librustc_typeck/check/method/confirm.rs | 1 - src/librustc_typeck/check/method/mod.rs | 2 +- src/librustc_typeck/check/method/probe.rs | 6 +- src/librustc_typeck/check/method/suggest.rs | 2 +- src/librustc_typeck/check/mod.rs | 15 +- src/librustc_typeck/check/regionck.rs | 7 +- src/librustc_typeck/check/wf.rs | 2 +- src/librustc_typeck/coherence/mod.rs | 3 +- 42 files changed, 194 insertions(+), 304 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index d2c79e1d820..ad87643e550 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -26,7 +26,6 @@ use metadata::tydecode::{RegionParameter, ClosureSource}; use metadata::tyencode; use middle::cast; use middle::check_const::ConstQualif; -use middle::mem_categorization::Typer; use middle::privacy::{AllPublic, LastMod}; use middle::subst; use middle::subst::VecPerParamSpace; diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 2798cfa43dd..19b688e5ccf 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -289,7 +289,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> { let cause = traits::ObligationCause::new(e.span, e.id, traits::SharedStatic); let mut fulfill_cx = infcx.fulfillment_cx.borrow_mut(); fulfill_cx.register_builtin_bound(&infcx, ty, ty::BoundSync, cause); - match fulfill_cx.select_all_or_error(&infcx, &infcx) { + match fulfill_cx.select_all_or_error(&infcx) { Ok(()) => { }, Err(ref errors) => { traits::report_fulfillment_errors(&infcx, errors); diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 900a231835e..8e315901db2 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -21,7 +21,7 @@ use middle::expr_use_visitor::{JustWrite, LoanCause, MutateMode}; use middle::expr_use_visitor::WriteAndRead; use middle::expr_use_visitor as euv; use middle::infer; -use middle::mem_categorization::{cmt, Typer}; +use middle::mem_categorization::{cmt}; use middle::pat_util::*; use middle::ty::*; use middle::ty; diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index b98864304d2..7d54b8c284f 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -1033,7 +1033,7 @@ fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>, tcx.populate_implementations_for_trait_if_necessary(trait_ref.def_id()); let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, None, false); - let mut selcx = traits::SelectionContext::new(&infcx, &infcx); + let mut selcx = traits::SelectionContext::new(&infcx); let obligation = traits::Obligation::new(traits::ObligationCause::dummy(), trait_ref.to_poly_trait_predicate()); let selection = match selcx.select(&obligation) { diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index c8555d28e40..3edf0490214 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -23,8 +23,7 @@ use self::OverloadedCallType::*; use middle::{def, region, pat_util}; use middle::infer; use middle::mem_categorization as mc; -use middle::mem_categorization::Typer; -use middle::ty::{self, ClosureTyper}; +use middle::ty::{self}; use middle::ty::{MethodCall, MethodObject, MethodTraitObject}; use middle::ty::{MethodOrigin, MethodParam, MethodTypeParam}; use middle::ty::{MethodStatic, MethodStaticClosure}; @@ -356,7 +355,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { } fn tcx(&self) -> &'t ty::ctxt<'tcx> { - self.typer.tcx() + self.typer.tcx } fn delegate_consume(&mut self, @@ -691,7 +690,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { match local.init { None => { let delegate = &mut self.delegate; - pat_util::pat_bindings(&self.typer.tcx().def_map, &*local.pat, + pat_util::pat_bindings(&self.typer.tcx.def_map, &*local.pat, |_, id, span, _| { delegate.decl_without_init(id, span); }) @@ -1053,7 +1052,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { let delegate = &mut self.delegate; return_if_err!(mc.cat_pattern(cmt_discr.clone(), pat, |mc, cmt_pat, pat| { if pat_util::pat_is_binding(def_map, pat) { - let tcx = typer.tcx(); + let tcx = typer.tcx; debug!("binding cmt_pat={:?} pat={:?} match_mode={:?}", cmt_pat, @@ -1140,7 +1139,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { // the leaves of the pattern tree structure. return_if_err!(mc.cat_pattern(cmt_discr, pat, |mc, cmt_pat, pat| { let def_map = def_map.borrow(); - let tcx = typer.tcx(); + let tcx = typer.tcx; match pat.node { ast::PatEnum(_, _) | ast::PatQPath(..) | @@ -1279,7 +1278,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { } } -fn copy_or_move<'tcx>(typer: &mc::Typer<'tcx>, +fn copy_or_move<'a, 'tcx>(typer: &infer::InferCtxt<'a, 'tcx>, cmt: &mc::cmt<'tcx>, move_reason: MoveReason) -> ConsumeMode diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs index d5fa885b16a..3e097578857 100644 --- a/src/librustc/middle/implicator.rs +++ b/src/librustc/middle/implicator.rs @@ -34,7 +34,6 @@ pub enum Implication<'tcx> { struct Implicator<'a, 'tcx: 'a> { infcx: &'a InferCtxt<'a,'tcx>, - closure_typer: &'a (ty::ClosureTyper<'tcx>+'a), body_id: ast::NodeId, stack: Vec<(ty::Region, Option>)>, span: Span, @@ -46,7 +45,6 @@ struct Implicator<'a, 'tcx: 'a> { /// appear in a context with lifetime `outer_region` pub fn implications<'a,'tcx>( infcx: &'a InferCtxt<'a,'tcx>, - closure_typer: &ty::ClosureTyper<'tcx>, body_id: ast::NodeId, ty: Ty<'tcx>, outer_region: ty::Region, @@ -60,8 +58,7 @@ pub fn implications<'a,'tcx>( let mut stack = Vec::new(); stack.push((outer_region, None)); - let mut wf = Implicator { closure_typer: closure_typer, - infcx: infcx, + let mut wf = Implicator { infcx: infcx, body_id: body_id, span: span, stack: stack, @@ -404,7 +401,6 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { { let value = traits::fully_normalize(self.infcx, - self.closure_typer, traits::ObligationCause::misc(self.span, self.body_id), value); match value { diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 6ca1c22a2c2..a64fe8b9128 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -19,7 +19,6 @@ pub use self::TypeOrigin::*; pub use self::ValuePairs::*; pub use self::fixup_err::*; pub use middle::ty::IntVarValue; -use middle::ty::ClosureTyper; pub use self::freshen::TypeFreshener; pub use self::region_inference::GenericKind; @@ -475,129 +474,6 @@ pub struct CombinedSnapshot { region_vars_snapshot: RegionSnapshot, } -impl<'a, 'tcx> mc::Typer<'tcx> for InferCtxt<'a, 'tcx> { - fn node_ty(&self, id: ast::NodeId) -> McResult> { - let ty = self.node_type(id); - self.resolve_type_vars_or_error(&ty) - } - - fn expr_ty_adjusted(&self, expr: &ast::Expr) -> McResult> { - let ty = self.adjust_expr_ty(expr, self.tables.borrow().adjustments.get(&expr.id)); - self.resolve_type_vars_or_error(&ty) - } - - fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool { - let ty = self.resolve_type_vars_if_possible(&ty); - !traits::type_known_to_meet_builtin_bound(self, self, ty, ty::BoundCopy, span) - } - - fn node_method_ty(&self, method_call: ty::MethodCall) - -> Option> { - self.tables - .borrow() - .method_map - .get(&method_call) - .map(|method| method.ty) - .map(|ty| self.resolve_type_vars_if_possible(&ty)) - } - - fn node_method_origin(&self, method_call: ty::MethodCall) - -> Option> - { - self.tables - .borrow() - .method_map - .get(&method_call) - .map(|method| method.origin.clone()) - } - - fn adjustments(&self) -> Ref>> { - fn project_adjustments<'a, 'tcx>(tables: &'a ty::Tables<'tcx>) - -> &'a NodeMap> { - &tables.adjustments - } - - Ref::map(self.tables.borrow(), project_adjustments) - } - - fn is_method_call(&self, id: ast::NodeId) -> bool { - self.tables.borrow().method_map.contains_key(&ty::MethodCall::expr(id)) - } - - fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option { - self.tcx.region_maps.temporary_scope(rvalue_id) - } - - fn upvar_capture(&self, upvar_id: ty::UpvarId) -> Option { - self.tables.borrow().upvar_capture_map.get(&upvar_id).cloned() - } -} - -impl<'a, 'tcx> ty::ClosureTyper<'tcx> for InferCtxt<'a, 'tcx> { - fn param_env<'b>(&'b self) -> &'b ty::ParameterEnvironment<'b,'tcx> { - &self.parameter_environment - } - - fn closure_kind(&self, - def_id: ast::DefId) - -> Option - { - self.tables.borrow().closure_kinds.get(&def_id).cloned() - } - - fn closure_type(&self, - def_id: ast::DefId, - substs: &subst::Substs<'tcx>) - -> ty::ClosureTy<'tcx> - { - - let closure_ty = self.tables - .borrow() - .closure_tys - .get(&def_id) - .unwrap() - .subst(self.tcx, substs); - - if self.normalize { - // NOTE: this flag is currently *always* set to false, we are slowly folding - // normalization into this trait and will come back to remove this in the near - // future. - - // code from NormalizingClosureTyper: - // the substitutions in `substs` are already monomorphized, - // but we still must normalize associated types - // normalize_associated_type(self.param_env.tcx, &closure_ty) - normalize_associated_type(&self.tcx, &closure_ty) - // panic!("see issue 26597: fufillment context refactor must occur") - } else { - closure_ty - } - } - - fn closure_upvars(&self, - def_id: ast::DefId, - substs: &Substs<'tcx>) - -> Option>> - { - let result = ty::ctxt::closure_upvars(self, def_id, substs); - - if self.normalize { - // NOTE: this flag is currently *always* set to false, we are slowly folding - // normalization into this trait and will come back to remove this in the near - // future. - - // code from NormalizingClosureTyper: - // the substitutions in `substs` are already monomorphized, - // but we still must normalize associated types - // monomorphize::normalize_associated_type(self.param_env.tcx, &result) - // panic!("see issue 26597: fufillment context refactor must occur") - normalize_associated_type(&self.tcx, &result) - } else { - result - } - } -} - pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T where T : TypeFoldable<'tcx> + HasTypeFlags { @@ -610,7 +486,7 @@ pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T } let infcx = new_infer_ctxt(tcx, &tcx.tables, None, true); - let mut selcx = traits::SelectionContext::new(&infcx, &infcx); + let mut selcx = traits::SelectionContext::new(&infcx); let cause = traits::ObligationCause::dummy(); let traits::Normalized { value: result, obligations } = traits::normalize(&mut selcx, cause, &value); @@ -663,12 +539,11 @@ pub fn drain_fulfillment_cx<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>, { debug!("drain_fulfillment_cx(result={:?})", result); - // this is stupid but temporary - let typer: &ClosureTyper<'tcx> = infcx; + // In principle, we only need to do this so long as `result` // contains unbound type parameters. It could be a slight // optimization to stop iterating early. - match fulfill_cx.select_all_or_error(infcx, typer) { + match fulfill_cx.select_all_or_error(infcx) { Ok(()) => { } Err(errors) => { return Err(errors); @@ -1429,6 +1304,125 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { self.equate(true, trace).relate(a, b) }).map(|_| ()) } + + pub fn node_ty(&self, id: ast::NodeId) -> McResult> { + let ty = self.node_type(id); + self.resolve_type_vars_or_error(&ty) + } + + pub fn expr_ty_adjusted(&self, expr: &ast::Expr) -> McResult> { + let ty = self.adjust_expr_ty(expr, self.tables.borrow().adjustments.get(&expr.id)); + self.resolve_type_vars_or_error(&ty) + } + + pub fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool { + let ty = self.resolve_type_vars_if_possible(&ty); + !traits::type_known_to_meet_builtin_bound(self, ty, ty::BoundCopy, span) + } + + pub fn node_method_ty(&self, method_call: ty::MethodCall) + -> Option> { + self.tables + .borrow() + .method_map + .get(&method_call) + .map(|method| method.ty) + .map(|ty| self.resolve_type_vars_if_possible(&ty)) + } + + pub fn node_method_origin(&self, method_call: ty::MethodCall) + -> Option> + { + self.tables + .borrow() + .method_map + .get(&method_call) + .map(|method| method.origin.clone()) + } + + pub fn adjustments(&self) -> Ref>> { + fn project_adjustments<'a, 'tcx>(tables: &'a ty::Tables<'tcx>) + -> &'a NodeMap> { + &tables.adjustments + } + + Ref::map(self.tables.borrow(), project_adjustments) + } + + pub fn is_method_call(&self, id: ast::NodeId) -> bool { + self.tables.borrow().method_map.contains_key(&ty::MethodCall::expr(id)) + } + + pub fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option { + self.tcx.region_maps.temporary_scope(rvalue_id) + } + + pub fn upvar_capture(&self, upvar_id: ty::UpvarId) -> Option { + self.tables.borrow().upvar_capture_map.get(&upvar_id).cloned() + } + + pub fn param_env<'b>(&'b self) -> &'b ty::ParameterEnvironment<'b,'tcx> { + &self.parameter_environment + } + + pub fn closure_kind(&self, + def_id: ast::DefId) + -> Option + { + self.tables.borrow().closure_kinds.get(&def_id).cloned() + } + + pub fn closure_type(&self, + def_id: ast::DefId, + substs: &subst::Substs<'tcx>) + -> ty::ClosureTy<'tcx> + { + + let closure_ty = self.tables + .borrow() + .closure_tys + .get(&def_id) + .unwrap() + .subst(self.tcx, substs); + + if self.normalize { + // NOTE: this flag is currently *always* set to false, we are slowly folding + // normalization into this trait and will come back to remove this in the near + // future. + + // code from NormalizingClosureTyper: + // the substitutions in `substs` are already monomorphized, + // but we still must normalize associated types + // normalize_associated_type(self.param_env.tcx, &closure_ty) + normalize_associated_type(&self.tcx, &closure_ty) + // panic!("see issue 26597: fufillment context refactor must occur") + } else { + closure_ty + } + } + + pub fn closure_upvars(&self, + def_id: ast::DefId, + substs: &Substs<'tcx>) + -> Option>> + { + let result = ty::ctxt::closure_upvars(self, def_id, substs); + + if self.normalize { + // NOTE: this flag is currently *always* set to false, we are slowly folding + // normalization into this trait and will come back to remove this in the near + // future. + + // code from NormalizingClosureTyper: + // the substitutions in `substs` are already monomorphized, + // but we still must normalize associated types + // monomorphize::normalize_associated_type(self.param_env.tcx, &result) + // panic!("see issue 26597: fufillment context refactor must occur") + normalize_associated_type(&self.tcx, &result) + } else { + result + } + } } impl<'tcx> TypeTrace<'tcx> { diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 7d237a511c4..68001ae1564 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -110,11 +110,9 @@ use self::LiveNodeKind::*; use self::VarKind::*; use middle::def::*; -use middle::mem_categorization::Typer; use middle::pat_util; use middle::region; use middle::ty; -use middle::ty::ClosureTyper; use lint; use util::nodemap::NodeMap; diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 867174ffbc5..32fbd773900 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -77,14 +77,12 @@ use middle::infer; use middle::check_const; use middle::def; use middle::region; -use middle::ty::{self, Ty, ClosureTyper}; -use util::nodemap::NodeMap; +use middle::ty::{self, Ty}; use syntax::ast::{MutImmutable, MutMutable}; use syntax::ast; use syntax::codemap::Span; -use std::cell::Ref; use std::fmt; use std::rc::Rc; @@ -264,35 +262,6 @@ pub struct MemCategorizationContext<'t, 'a: 't, 'tcx : 'a> { pub type McResult = Result; -/// The `Typer` trait provides the interface for the mem-categorization -/// module to the results of the type check. It can be used to query -/// the type assigned to an expression node, to inquire after adjustments, -/// and so on. -/// -/// This interface is needed because mem-categorization is used from -/// two places: `regionck` and `borrowck`. `regionck` executes before -/// type inference is complete, and hence derives types and so on from -/// intermediate tables. This also implies that type errors can occur, -/// and hence `node_ty()` and friends return a `Result` type -- any -/// error will propagate back up through the mem-categorization -/// routines. -/// -/// In the borrow checker, in contrast, type checking is complete and we -/// know that no errors have occurred, so we simply consult the tcx and we -/// can be sure that only `Ok` results will occur. -pub trait Typer<'tcx> : ty::ClosureTyper<'tcx> { - fn node_ty(&self, id: ast::NodeId) -> McResult>; - fn expr_ty_adjusted(&self, expr: &ast::Expr) -> McResult>; - fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool; - fn node_method_ty(&self, method_call: ty::MethodCall) -> Option>; - fn node_method_origin(&self, method_call: ty::MethodCall) - -> Option>; - fn adjustments(&self) -> Ref>>; - fn is_method_call(&self, id: ast::NodeId) -> bool; - fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option; - fn upvar_capture(&self, upvar_id: ty::UpvarId) -> Option; -} - impl MutabilityCategory { pub fn from_mutbl(m: ast::Mutability) -> MutabilityCategory { let ret = match m { diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 25b336f0c7a..977d0577e48 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -38,7 +38,7 @@ pub fn overlapping_impls(infcx: &InferCtxt, impl1_def_id, impl2_def_id); - let selcx = &mut SelectionContext::intercrate(infcx, infcx); + let selcx = &mut SelectionContext::intercrate(infcx); infcx.probe(|_| { overlap(selcx, impl1_def_id, impl2_def_id) || overlap(selcx, impl2_def_id, impl1_def_id) }) diff --git a/src/librustc/middle/traits/fulfill.rs b/src/librustc/middle/traits/fulfill.rs index a769ef8233e..08cb3e57015 100644 --- a/src/librustc/middle/traits/fulfill.rs +++ b/src/librustc/middle/traits/fulfill.rs @@ -132,7 +132,6 @@ impl<'tcx> FulfillmentContext<'tcx> { /// `projection_ty` again. pub fn normalize_projection_type<'a>(&mut self, infcx: &InferCtxt<'a,'tcx>, - typer: &ty::ClosureTyper<'tcx>, projection_ty: ty::ProjectionTy<'tcx>, cause: ObligationCause<'tcx>) -> Ty<'tcx> @@ -144,7 +143,7 @@ impl<'tcx> FulfillmentContext<'tcx> { // FIXME(#20304) -- cache - let mut selcx = SelectionContext::new(infcx, typer); + let mut selcx = SelectionContext::new(infcx); let normalized = project::normalize_projection_type(&mut selcx, projection_ty, cause, 0); for obligation in normalized.obligations { @@ -208,11 +207,10 @@ impl<'tcx> FulfillmentContext<'tcx> { } pub fn select_all_or_error<'a>(&mut self, - infcx: &InferCtxt<'a,'tcx>, - typer: &ty::ClosureTyper<'tcx>) + infcx: &InferCtxt<'a,'tcx>) -> Result<(),Vec>> { - try!(self.select_where_possible(infcx, typer)); + try!(self.select_where_possible(infcx)); // Anything left is ambiguous. let errors: Vec = @@ -233,20 +231,18 @@ impl<'tcx> FulfillmentContext<'tcx> { /// gaining type information. It'd be equally valid to use `select_where_possible` but it /// results in `O(n^2)` performance (#18208). pub fn select_new_obligations<'a>(&mut self, - infcx: &InferCtxt<'a,'tcx>, - typer: &ty::ClosureTyper<'tcx>) + infcx: &InferCtxt<'a,'tcx>) -> Result<(),Vec>> { - let mut selcx = SelectionContext::new(infcx, typer); + let mut selcx = SelectionContext::new(infcx); self.select(&mut selcx, true) } pub fn select_where_possible<'a>(&mut self, - infcx: &InferCtxt<'a,'tcx>, - typer: &ty::ClosureTyper<'tcx>) + infcx: &InferCtxt<'a,'tcx>) -> Result<(),Vec>> { - let mut selcx = SelectionContext::new(infcx, typer); + let mut selcx = SelectionContext::new(infcx); self.select(&mut selcx, false) } diff --git a/src/librustc/middle/traits/mod.rs b/src/librustc/middle/traits/mod.rs index 8c065e182cd..a39fe453664 100644 --- a/src/librustc/middle/traits/mod.rs +++ b/src/librustc/middle/traits/mod.rs @@ -312,7 +312,6 @@ pub fn predicates_for_generics<'tcx>(cause: ObligationCause<'tcx>, /// conservative towards *no impl*, which is the opposite of the /// `evaluate` methods). pub fn type_known_to_meet_builtin_bound<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, - typer: &ty::ClosureTyper<'tcx>, ty: Ty<'tcx>, bound: ty::BuiltinBound, span: Span) @@ -334,7 +333,7 @@ pub fn type_known_to_meet_builtin_bound<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, // Note: we only assume something is `Copy` if we can // *definitively* show that it implements `Copy`. Otherwise, // assume it is move; linear is always ok. - match fulfill_cx.select_all_or_error(infcx, typer) { + match fulfill_cx.select_all_or_error(infcx) { Ok(()) => { debug!("type_known_to_meet_builtin_bound: ty={:?} bound={:?} success", ty, @@ -398,7 +397,7 @@ pub fn normalize_param_env_or_error<'a,'tcx>(unnormalized_env: ty::ParameterEnvi let elaborated_env = unnormalized_env.with_caller_bounds(predicates); let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, Some(elaborated_env), false); - let predicates = match fully_normalize(&infcx, &infcx, cause, + let predicates = match fully_normalize(&infcx, cause, &infcx.parameter_environment.caller_bounds) { Ok(predicates) => predicates, Err(errors) => { @@ -429,7 +428,6 @@ pub fn normalize_param_env_or_error<'a,'tcx>(unnormalized_env: ty::ParameterEnvi } pub fn fully_normalize<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>, - closure_typer: &ty::ClosureTyper<'tcx>, cause: ObligationCause<'tcx>, value: &T) -> Result>> @@ -437,7 +435,7 @@ pub fn fully_normalize<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>, { debug!("normalize_param_env(value={:?})", value); - let mut selcx = &mut SelectionContext::new(infcx, closure_typer); + let mut selcx = &mut SelectionContext::new(infcx); // FIXME (@jroesch): I'm not sure if this is a bug or not, needs // further investigation. It appears that by reusing the fulfillment_cx // here we incur more obligations and later trip an asssertion on @@ -458,7 +456,7 @@ pub fn fully_normalize<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>, for obligation in obligations { fulfill_cx.register_predicate_obligation(selcx.infcx(), obligation); } - try!(fulfill_cx.select_all_or_error(infcx, closure_typer)); + try!(fulfill_cx.select_all_or_error(infcx)); let resolved_value = infcx.resolve_type_vars_if_possible(&normalized_value); debug!("normalize_param_env: resolved_value={:?}", resolved_value); Ok(resolved_value) diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index ae15c8aa8e0..3bc4fd0c0a1 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -55,8 +55,6 @@ use util::nodemap::FnvHashMap; pub struct SelectionContext<'cx, 'tcx:'cx> { infcx: &'cx InferCtxt<'cx, 'tcx>, - closure_typer: &'cx (ty::ClosureTyper<'tcx>+'cx), - /// Freshener used specifically for skolemizing entries on the /// obligation stack. This ensures that all entries on the stack /// at one time will have the same set of skolemized entries, @@ -244,23 +242,19 @@ enum EvaluationResult<'tcx> { } impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { - pub fn new(infcx: &'cx InferCtxt<'cx, 'tcx>, - closure_typer: &'cx ty::ClosureTyper<'tcx>) + pub fn new(infcx: &'cx InferCtxt<'cx, 'tcx>) -> SelectionContext<'cx, 'tcx> { SelectionContext { infcx: infcx, - closure_typer: closure_typer, freshener: infcx.freshener(), intercrate: false, } } - pub fn intercrate(infcx: &'cx InferCtxt<'cx, 'tcx>, - closure_typer: &'cx ty::ClosureTyper<'tcx>) + pub fn intercrate(infcx: &'cx InferCtxt<'cx, 'tcx>) -> SelectionContext<'cx, 'tcx> { SelectionContext { infcx: infcx, - closure_typer: closure_typer, freshener: infcx.freshener(), intercrate: true, } @@ -275,11 +269,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } pub fn param_env(&self) -> &'cx ty::ParameterEnvironment<'cx, 'tcx> { - self.closure_typer.param_env() + self.infcx.param_env() } - pub fn closure_typer(&self) -> &'cx (ty::ClosureTyper<'tcx>+'cx) { - self.closure_typer + pub fn closure_typer(&self) -> &'cx InferCtxt<'cx, 'tcx> { + self.infcx } /////////////////////////////////////////////////////////////////////////// @@ -1163,7 +1157,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { kind, obligation); - match self.closure_typer.closure_kind(closure_def_id) { + match self.infcx.closure_kind(closure_def_id) { Some(closure_kind) => { debug!("assemble_unboxed_candidates: closure_kind = {:?}", closure_kind); if closure_kind.extends(kind) { @@ -1727,7 +1721,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { return ok_if(Vec::new()); } - match self.closure_typer.closure_upvars(def_id, substs) { + match self.infcx.closure_upvars(def_id, substs) { Some(upvars) => ok_if(upvars.iter().map(|c| c.ty).collect()), None => { debug!("assemble_builtin_bound_candidates: no upvar types available yet"); @@ -1865,7 +1859,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::TyClosure(def_id, substs) => { assert_eq!(def_id.krate, ast::LOCAL_CRATE); - match self.closure_typer.closure_upvars(def_id, substs) { + match self.infcx.closure_upvars(def_id, substs) { Some(upvars) => { Some(upvars.iter().map(|c| c.ty).collect()) } @@ -2844,7 +2838,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { substs: &Substs<'tcx>) -> ty::PolyTraitRef<'tcx> { - let closure_type = self.closure_typer.closure_type(closure_def_id, substs); + let closure_type = self.infcx.closure_type(closure_def_id, substs); let ty::Binder((trait_ref, _)) = util::closure_trait_ref_and_return_type(self.tcx(), obligation.predicate.def_id(), diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 23aa840703b..e20df807c87 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -52,7 +52,6 @@ use middle::dependency_format; use middle::fast_reject; use middle::free_region::FreeRegionMap; use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem, FnOnceTraitLangItem}; -use middle::mem_categorization::Typer; use middle::region; use middle::resolve_lifetime; use middle::infer; @@ -3179,35 +3178,6 @@ impl ClosureKind { } } -pub trait ClosureTyper<'tcx> { - fn tcx(&self) -> &ctxt<'tcx> { - self.param_env().tcx - } - - fn param_env<'a>(&'a self) -> &'a ty::ParameterEnvironment<'a, 'tcx>; - - /// Is this a `Fn`, `FnMut` or `FnOnce` closure? During typeck, - /// returns `None` if the kind of this closure has not yet been - /// inferred. - fn closure_kind(&self, - def_id: ast::DefId) - -> Option; - - /// Returns the argument/return types of this closure. - fn closure_type(&self, - def_id: ast::DefId, - substs: &subst::Substs<'tcx>) - -> ty::ClosureTy<'tcx>; - - /// Returns the set of all upvars and their transformed - /// types. During typeck, maybe return `None` if the upvar types - /// have not yet been inferred. - fn closure_upvars(&self, - def_id: ast::DefId, - substs: &Substs<'tcx>) - -> Option>>; -} - impl<'tcx> CommonTypes<'tcx> { fn new(arena: &'tcx TypedArena>, interner: &mut FnvHashMap, Ty<'tcx>>) @@ -4406,7 +4376,7 @@ impl<'tcx> TyS<'tcx> { let tcx = param_env.tcx; let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, Some(param_env.clone()), false); - let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, &infcx, + let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, self, bound, span); debug!("Ty::impls_bound({:?}, {:?}) = {:?}", @@ -6116,7 +6086,7 @@ impl<'tcx> ctxt<'tcx> { } // Returns a list of `ClosureUpvar`s for each upvar. - pub fn closure_upvars(typer: &Typer<'tcx>, + pub fn closure_upvars<'a>(typer: &infer::InferCtxt<'a, 'tcx>, closure_id: ast::DefId, substs: &Substs<'tcx>) -> Option>> @@ -6127,7 +6097,7 @@ impl<'tcx> ctxt<'tcx> { // This may change if abstract return types of some sort are // implemented. assert!(closure_id.krate == ast::LOCAL_CRATE); - let tcx = typer.tcx(); + let tcx = typer.tcx; match tcx.freevars.borrow().get(&closure_id.node) { None => Some(vec![]), Some(ref freevars) => { diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 3cf2a62b3b6..3a4318527fb 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -30,7 +30,6 @@ use rustc::middle::dataflow::KillFrom; use rustc::middle::expr_use_visitor as euv; use rustc::middle::free_region::FreeRegionMap; use rustc::middle::mem_categorization as mc; -use rustc::middle::mem_categorization::Typer; use rustc::middle::region; use rustc::middle::ty::{self, Ty}; diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 5661109ab45..2e812a0a780 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -30,7 +30,6 @@ use metadata::{csearch, decoder}; use middle::def::*; -use middle::mem_categorization::Typer; use middle::subst::Substs; use middle::ty::{self, Ty}; use middle::{def, pat_util, stability}; diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index b96dcf940a8..eca9891c57c 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -51,7 +51,7 @@ use llvm::{ValueRef, True, IntEQ, IntNE}; use back::abi::FAT_PTR_ADDR; use middle::subst; use middle::infer; -use middle::ty::{self, Ty, ClosureTyper}; +use middle::ty::{self, Ty}; use middle::ty::Disr; use syntax::ast; use syntax::attr; diff --git a/src/librustc_trans/trans/attributes.rs b/src/librustc_trans/trans/attributes.rs index fd704ed2d37..25cde149df1 100644 --- a/src/librustc_trans/trans/attributes.rs +++ b/src/librustc_trans/trans/attributes.rs @@ -11,7 +11,7 @@ use libc::{c_uint, c_ulonglong}; use llvm::{self, ValueRef, AttrHelper}; -use middle::ty::{self, ClosureTyper}; +use middle::ty; use middle::infer; use session::config::NoDebugInfo; use syntax::abi; diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 088df7288be..156d591b909 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -41,7 +41,7 @@ use middle::infer; use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem}; use middle::weak_lang_items; use middle::subst::Substs; -use middle::ty::{self, Ty, ClosureTyper, HasTypeFlags}; +use middle::ty::{self, Ty, HasTypeFlags}; use rustc::ast_map; use session::config::{self, NoDebugInfo}; use session::Session; diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index c9bab6861ca..5fd0f92400f 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -11,7 +11,6 @@ use arena::TypedArena; use back::link::{self, mangle_internal_name_by_path_and_seq}; use llvm::{ValueRef, get_params}; -use middle::mem_categorization::Typer; use middle::infer; use trans::adt; use trans::attributes; @@ -26,7 +25,7 @@ use trans::declare; use trans::expr; use trans::monomorphize::{self, MonoId}; use trans::type_of::*; -use middle::ty::{self, ClosureTyper}; +use middle::ty; use middle::subst::Substs; use session::config::FullDebugInfo; diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 598029b842b..6dffb3fe2a7 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -22,8 +22,6 @@ use middle::cfg; use middle::def; use middle::infer; use middle::lang_items::LangItem; -use middle::mem_categorization::Typer; -use middle::ty::ClosureTyper; use middle::region; use middle::subst::{self, Substs}; use trans::base; @@ -872,7 +870,7 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // Do the initial selection for the obligation. This yields the // shallow result we are looking for -- that is, what specific impl. let infcx = infer::normalizing_infer_ctxt(tcx, &tcx.tables); - let mut selcx = traits::SelectionContext::new(&infcx, &infcx); + let mut selcx = traits::SelectionContext::new(&infcx); let obligation = traits::Obligation::new(traits::ObligationCause::misc(span, ast::DUMMY_NODE_ID), @@ -931,7 +929,7 @@ pub fn normalize_and_test_predicates<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let tcx = ccx.tcx(); let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, None, true); - let mut selcx = traits::SelectionContext::new(&infcx, &infcx); + let mut selcx = traits::SelectionContext::new(&infcx); let mut fulfill_cx = infcx.fulfillment_cx.borrow_mut(); let cause = traits::ObligationCause::dummy(); let traits::Normalized { value: predicates, obligations } = @@ -979,12 +977,11 @@ pub fn drain_fulfillment_cx<'a,'tcx,T>(infcx: &infer::InferCtxt<'a,'tcx>, { debug!("drain_fulfillment_cx(result={:?})", result); - // this is stupid but temporary - let typer: &ClosureTyper<'tcx> = infcx; + // In principle, we only need to do this so long as `result` // contains unbound type parameters. It could be a slight // optimization to stop iterating early. - match fulfill_cx.select_all_or_error(infcx, typer) { + match fulfill_cx.select_all_or_error(infcx) { Ok(()) => { } Err(errors) => { return Err(errors); diff --git a/src/librustc_trans/trans/debuginfo/gdb.rs b/src/librustc_trans/trans/debuginfo/gdb.rs index a6f1199d0ff..f7b0f37c9ff 100644 --- a/src/librustc_trans/trans/debuginfo/gdb.rs +++ b/src/librustc_trans/trans/debuginfo/gdb.rs @@ -16,7 +16,6 @@ use llvm::ValueRef; use trans::common::{C_bytes, CrateContext}; use trans::declare; use trans::type_::Type; -use middle::ty::ClosureTyper; use session::config::NoDebugInfo; use std::ffi::CString; diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 12892c87b46..45349969a0b 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -32,7 +32,7 @@ use trans::{type_of, adt, machine, monomorphize}; use trans::common::{self, CrateContext, FunctionContext, Block}; use trans::_match::{BindingInfo, TrByCopy, TrByMove, TrByRef}; use trans::type_::Type; -use middle::ty::{self, Ty, ClosureTyper}; +use middle::ty::{self, Ty}; use session::config::{self, FullDebugInfo}; use util::nodemap::FnvHashMap; use util::common::path2cstr; diff --git a/src/librustc_trans/trans/debuginfo/mod.rs b/src/librustc_trans/trans/debuginfo/mod.rs index 7487e8d331b..ebe5e832e6f 100644 --- a/src/librustc_trans/trans/debuginfo/mod.rs +++ b/src/librustc_trans/trans/debuginfo/mod.rs @@ -30,7 +30,7 @@ use rustc::ast_map; use trans::common::{NodeIdAndSpan, CrateContext, FunctionContext, Block}; use trans; use trans::monomorphize; -use middle::ty::{Ty, ClosureTyper}; +use middle::ty::Ty; use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo}; use util::nodemap::{DefIdMap, NodeMap, FnvHashMap, FnvHashSet}; diff --git a/src/librustc_trans/trans/debuginfo/namespace.rs b/src/librustc_trans/trans/debuginfo/namespace.rs index 2e5943a248a..8b33acdee8e 100644 --- a/src/librustc_trans/trans/debuginfo/namespace.rs +++ b/src/librustc_trans/trans/debuginfo/namespace.rs @@ -16,7 +16,6 @@ use llvm; use llvm::debuginfo::DIScope; use rustc::ast_map; use trans::common::CrateContext; -use middle::ty::ClosureTyper; use std::ffi::CString; use std::ptr; diff --git a/src/librustc_trans/trans/debuginfo/type_names.rs b/src/librustc_trans/trans/debuginfo/type_names.rs index 6ea43d7392c..f4116883199 100644 --- a/src/librustc_trans/trans/debuginfo/type_names.rs +++ b/src/librustc_trans/trans/debuginfo/type_names.rs @@ -14,7 +14,7 @@ use super::namespace::crate_root_namespace; use trans::common::CrateContext; use middle::subst::{self, Substs}; -use middle::ty::{self, Ty, ClosureTyper}; +use middle::ty::{self, Ty}; use syntax::ast; use syntax::parse::token; @@ -225,4 +225,3 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, output.push('>'); } } - diff --git a/src/librustc_trans/trans/declare.rs b/src/librustc_trans/trans/declare.rs index 0eaaaaa5b34..b29da9d560f 100644 --- a/src/librustc_trans/trans/declare.rs +++ b/src/librustc_trans/trans/declare.rs @@ -20,7 +20,7 @@ //! * Use define_* family of methods when you might be defining the ValueRef. //! * When in doubt, define. use llvm::{self, ValueRef}; -use middle::ty::{self, ClosureTyper}; +use middle::ty; use middle::infer; use syntax::abi; use trans::attributes; diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 045cc69bf95..39bb9b25be7 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -56,7 +56,6 @@ use llvm::{self, ValueRef, TypeKind}; use middle::check_const; use middle::def; use middle::lang_items::CoerceUnsizedTraitLangItem; -use middle::mem_categorization::Typer; use middle::subst::{Substs, VecPerParamSpace}; use middle::traits; use trans::{_match, adt, asm, base, callee, closure, consts, controlflow}; diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index e46c3b5fab1..1b01fb6c7f8 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -17,7 +17,6 @@ use middle::subst::{Subst, Substs}; use middle::subst::VecPerParamSpace; use middle::subst; use middle::traits; -use middle::ty::ClosureTyper; use rustc::ast_map; use trans::base::*; use trans::build::*; diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index b297a731d29..3ef72e2c4af 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -322,10 +322,8 @@ pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T } // FIXME(#20304) -- cache - // NOTE: @jroesch - // Here is of an example where we do not use a param_env but use a typer instead. let infcx = infer::normalizing_infer_ctxt(tcx, &tcx.tables); - let mut selcx = traits::SelectionContext::new(&infcx, &infcx); + let mut selcx = traits::SelectionContext::new(&infcx); let cause = traits::ObligationCause::dummy(); let traits::Normalized { value: result, obligations } = traits::normalize(&mut selcx, cause, &value); diff --git a/src/librustc_typeck/check/assoc.rs b/src/librustc_typeck/check/assoc.rs index 4eafbaaf794..75263c35d59 100644 --- a/src/librustc_typeck/check/assoc.rs +++ b/src/librustc_typeck/check/assoc.rs @@ -11,13 +11,13 @@ use middle::infer::InferCtxt; use middle::traits::{self, FulfillmentContext, Normalized, MiscObligation, SelectionContext, ObligationCause}; -use middle::ty::{self, HasTypeFlags}; +use middle::ty::HasTypeFlags; use middle::ty_fold::TypeFoldable; use syntax::ast; use syntax::codemap::Span; +//FIME(@jroesch): Refactor this pub fn normalize_associated_types_in<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>, - typer: &(ty::ClosureTyper<'tcx>+'a), fulfillment_cx: &mut FulfillmentContext<'tcx>, span: Span, body_id: ast::NodeId, @@ -26,7 +26,7 @@ pub fn normalize_associated_types_in<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>, where T : TypeFoldable<'tcx> + HasTypeFlags { debug!("normalize_associated_types_in(value={:?})", value); - let mut selcx = SelectionContext::new(infcx, typer); + let mut selcx = SelectionContext::new(infcx); let cause = ObligationCause::new(span, body_id, MiscObligation); let Normalized { value: result, obligations } = traits::normalize(&mut selcx, cause, value); debug!("normalize_associated_types_in: result={:?} predicates={:?}", diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs index d29c0494572..f32a4fe43d6 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -27,7 +27,7 @@ use super::write_call; use CrateCtxt; use middle::infer; -use middle::ty::{self, Ty, ClosureTyper}; +use middle::ty::{self, Ty}; use syntax::ast; use syntax::codemap::Span; use syntax::parse::token; diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index b38b6884a98..a0abef74907 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -273,7 +273,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { }; let source = source.adjust_for_autoref(self.tcx(), reborrow); - let mut selcx = traits::SelectionContext::new(self.fcx.infcx(), self.fcx.infcx()); + let mut selcx = traits::SelectionContext::new(self.fcx.infcx()); // Use a FIFO queue for this custom fulfillment procedure. let mut queue = VecDeque::new(); diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index c05b95f4aeb..7926394ebb5 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -246,7 +246,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, debug!("compare_impl_method: trait_bounds={:?}", infcx.parameter_environment.caller_bounds); - let mut selcx = traits::SelectionContext::new(&infcx, &infcx); + let mut selcx = traits::SelectionContext::new(&infcx); for predicate in impl_pred.fns { let traits::Normalized { value: predicate, .. } = @@ -293,7 +293,6 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, impl_sig.subst(tcx, impl_to_skol_substs); let impl_sig = assoc::normalize_associated_types_in(&infcx, - &infcx, &mut fulfillment_cx, impl_m_span, impl_m_body_id, @@ -312,7 +311,6 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, trait_sig.subst(tcx, &trait_to_skol_substs); let trait_sig = assoc::normalize_associated_types_in(&infcx, - &infcx, &mut fulfillment_cx, impl_m_span, impl_m_body_id, @@ -347,7 +345,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, // Check that all obligations are satisfied by the implementation's // version. - match fulfillment_cx.select_all_or_error(&infcx, &infcx) { + match fulfillment_cx.select_all_or_error(&infcx) { Err(ref errors) => { traits::report_fulfillment_errors(&infcx, errors) } Ok(_) => {} } @@ -456,21 +454,21 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>, // There is no "body" here, so just pass dummy id. let impl_ty = assoc::normalize_associated_types_in(&infcx, - &infcx, &mut fulfillment_cx, impl_c_span, 0, &impl_ty); + debug!("compare_const_impl: impl_ty={:?}", impl_ty); let trait_ty = assoc::normalize_associated_types_in(&infcx, - &infcx, &mut fulfillment_cx, impl_c_span, 0, &trait_ty); + debug!("compare_const_impl: trait_ty={:?}", trait_ty); diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 9c2d1c4a34d..7a887fac9d4 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -12,7 +12,6 @@ use super::probe; use check::{self, FnCtxt, NoPreference, PreferMutLvalue, callee, demand}; use check::UnresolvedTypeAction; -use middle::mem_categorization::Typer; use middle::subst::{self}; use middle::traits; use middle::ty::{self, Ty}; diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index f312db9c4dc..7ed5c69ad61 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -195,7 +195,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, poly_trait_ref.to_predicate()); // Now we want to know if this can be matched - let mut selcx = traits::SelectionContext::new(fcx.infcx(), fcx.infcx()); + let mut selcx = traits::SelectionContext::new(fcx.infcx()); if !selcx.evaluate_obligation(&obligation) { debug!("--> Cannot match obligation"); return None; // Cannot be matched, no such method resolution is possible. diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 94a2050829d..8eb4716cb2a 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -421,7 +421,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // We can't use normalize_associated_types_in as it will pollute the // fcx's fulfillment context after this probe is over. let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id); - let mut selcx = &mut traits::SelectionContext::new(self.fcx.infcx(), self.fcx.infcx()); + let mut selcx = &mut traits::SelectionContext::new(self.fcx.infcx()); let traits::Normalized { value: xform_self_ty, obligations } = traits::normalize(selcx, cause, &xform_self_ty); debug!("assemble_inherent_impl_probe: xform_self_ty = {:?}", @@ -681,7 +681,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // as it will pollute the fcx's fulfillment context after this probe // is over. let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id); - let mut selcx = &mut traits::SelectionContext::new(self.fcx.infcx(), self.fcx.infcx()); + let mut selcx = &mut traits::SelectionContext::new(self.fcx.infcx()); let traits::Normalized { value: xform_self_ty, obligations } = traits::normalize(selcx, cause, &xform_self_ty); @@ -1076,7 +1076,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { match probe.kind { InherentImplCandidate(impl_def_id, ref substs, ref ref_obligations) | ExtensionImplCandidate(impl_def_id, _, ref substs, _, ref ref_obligations) => { - let selcx = &mut traits::SelectionContext::new(self.infcx(), self.fcx.infcx()); + let selcx = &mut traits::SelectionContext::new(self.infcx()); let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id); // Check whether the impl imposes obligations we have to worry about. diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index b81b672e684..d6a8b3583f8 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -102,7 +102,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, let obligation = Obligation::misc(span, fcx.body_id, poly_trait_ref.to_predicate()); - let mut selcx = SelectionContext::new(infcx, fcx.infcx()); + let mut selcx = SelectionContext::new(infcx); if selcx.evaluate_obligation(&obligation) { span_stored_function(); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 4d750f88093..477b6e98256 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -305,7 +305,6 @@ impl<'a, 'tcx> Inherited<'a, 'tcx> { } fn normalize_associated_types_in(&self, - typer: &ty::ClosureTyper<'tcx>, span: Span, body_id: ast::NodeId, value: &T) @@ -314,7 +313,6 @@ impl<'a, 'tcx> Inherited<'a, 'tcx> { { let mut fulfillment_cx = self.infcx.fulfillment_cx.borrow_mut(); assoc::normalize_associated_types_in(&self.infcx, - typer, &mut fulfillment_cx, span, body_id, @@ -431,8 +429,7 @@ fn check_bare_fn<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, ccx.tcx.liberate_late_bound_regions(region::DestructionScopeData::new(body.id), &fn_sig); let fn_sig = - inh.normalize_associated_types_in(&inh.infcx, - body.span, + inh.normalize_associated_types_in(body.span, body.id, &fn_sig); @@ -1377,7 +1374,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fn normalize_associated_types_in(&self, span: Span, value: &T) -> T where T : TypeFoldable<'tcx> + HasTypeFlags { - self.inh.normalize_associated_types_in(self.infcx(), span, self.body_id, value) + self.inh.normalize_associated_types_in(span, self.body_id, value) } fn normalize_associated_type(&self, @@ -1394,7 +1391,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .fulfillment_cx .borrow_mut() .normalize_projection_type(self.infcx(), - self.infcx(), ty::ProjectionTy { trait_ref: trait_ref, item_name: item_name, @@ -1504,7 +1500,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { -> bool { traits::type_known_to_meet_builtin_bound(self.infcx(), - self.infcx(), ty, ty::BoundSized, span) @@ -1750,7 +1745,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { self.select_all_obligations_and_apply_defaults(); let mut fulfillment_cx = self.inh.infcx.fulfillment_cx.borrow_mut(); - match fulfillment_cx.select_all_or_error(self.infcx(), self.infcx()) { + match fulfillment_cx.select_all_or_error(self.infcx()) { Ok(()) => { } Err(errors) => { report_fulfillment_errors(self.infcx(), &errors); } } @@ -1761,7 +1756,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { match self.inh.infcx.fulfillment_cx .borrow_mut() - .select_where_possible(self.infcx(), self.infcx()) + .select_where_possible(self.infcx()) { Ok(()) => { } Err(errors) => { report_fulfillment_errors(self.infcx(), &errors); } @@ -1776,7 +1771,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { match self.inh.infcx.fulfillment_cx .borrow_mut() - .select_new_obligations(self.infcx(), self.infcx()) + .select_new_obligations(self.infcx()) { Ok(()) => { } Err(errors) => { report_fulfillment_errors(self.infcx(), &errors); } diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index a98bcc247ed..bb3c9f9fb54 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -86,13 +86,12 @@ use astconv::AstConv; use check::dropck; use check::FnCtxt; use middle::free_region::FreeRegionMap; -use middle::infer::InferCtxt; use middle::implicator; use middle::mem_categorization as mc; use middle::region::CodeExtent; use middle::subst::Substs; use middle::traits; -use middle::ty::{self, ClosureTyper, ReScope, Ty, MethodCall, HasTypeFlags}; +use middle::ty::{self, ReScope, Ty, MethodCall, HasTypeFlags}; use middle::infer::{self, GenericKind}; use middle::pat_util; @@ -360,7 +359,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { debug!("relate_free_regions(t={:?})", ty); let body_scope = CodeExtent::from_node_id(body_id); let body_scope = ty::ReScope(body_scope); - let implications = implicator::implications(self.fcx.infcx(), self.fcx.infcx(), body_id, + let implications = implicator::implications(self.fcx.infcx(), body_id, ty, body_scope, span); // Record any relations between free regions that we observe into the free-region-map. @@ -1409,7 +1408,7 @@ pub fn type_must_outlive<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, ty, region); - let implications = implicator::implications(rcx.fcx.infcx(), rcx.fcx.infcx(), rcx.body_id, + let implications = implicator::implications(rcx.fcx.infcx(), rcx.body_id, ty, region, origin.span()); for implication in implications { debug!("implication: {:?}", implication); diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index df01b99fd9b..7cf7d73a566 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -268,7 +268,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { let predicates = fcx.tcx().lookup_super_predicates(poly_trait_ref.def_id()); let predicates = predicates.instantiate_supertrait(fcx.tcx(), &poly_trait_ref); let predicates = { - let selcx = &mut traits::SelectionContext::new(fcx.infcx(), fcx.infcx()); + let selcx = &mut traits::SelectionContext::new(fcx.infcx()); traits::normalize(selcx, cause.clone(), &predicates) }; for predicate in predicates.value.predicates { diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 0650f7deb06..fca23a1b029 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -540,8 +540,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { fulfill_cx.register_predicate_obligation(&infcx, predicate); // Check that all transitive obligations are satisfied. - if let Err(errors) = fulfill_cx.select_all_or_error(&infcx, - &infcx) { + if let Err(errors) = fulfill_cx.select_all_or_error(&infcx) { traits::report_fulfillment_errors(&infcx, &errors); }