From e2d7e904ca621b72a7445e666baba4b282d2bb7d Mon Sep 17 00:00:00 2001 From: Jared Roesch Date: Sun, 28 Jun 2015 23:03:47 -0700 Subject: [PATCH] Remove Typer + ClosureTyper impls for ParameterEnv --- src/librustc/middle/check_const.rs | 9 +- src/librustc/middle/check_match.rs | 10 +- src/librustc/middle/check_rvalues.rs | 7 +- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/infer/mod.rs | 2 +- src/librustc/middle/traits/coherence.rs | 3 +- src/librustc/middle/traits/mod.rs | 2 +- src/librustc/middle/ty.rs | 91 +++---------------- src/librustc_borrowck/borrowck/check_loans.rs | 6 +- .../borrowck/gather_loans/mod.rs | 9 +- src/librustc_borrowck/borrowck/mod.rs | 2 +- src/librustc_lint/builtin.rs | 4 +- src/librustc_trans/trans/_match.rs | 3 +- src/librustc_trans/trans/common.rs | 4 +- src/librustc_trans/trans/datum.rs | 5 +- src/librustc_typeck/check/compare_method.rs | 12 +-- src/librustc_typeck/check/mod.rs | 4 +- src/librustc_typeck/coherence/mod.rs | 2 +- 18 files changed, 60 insertions(+), 117 deletions(-) diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 95a598ad115a..139750af6284 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -111,13 +111,16 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> { fn with_euv<'b, F, R>(&'b mut self, item_id: Option, f: F) -> R where F: for<'t> FnOnce(&mut euv::ExprUseVisitor<'b, 't, 'tcx, - ty::ParameterEnvironment<'a, 'tcx>>) -> R, + infer::InferCtxt<'a, 'tcx>>) -> R, { let param_env = match item_id { Some(item_id) => ty::ParameterEnvironment::for_item(self.tcx, item_id), None => self.tcx.empty_parameter_environment() }; - f(&mut euv::ExprUseVisitor::new(self, ¶m_env)) + + let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, Some(param_env), false); + + f(&mut euv::ExprUseVisitor::new(self, &infcx)) } fn global_expr(&mut self, mode: Mode, expr: &ast::Expr) -> ConstQualif { @@ -287,7 +290,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.parameter_environment) { + match fulfill_cx.select_all_or_error(&infcx, &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 f61884e21366..900a231835e5 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -20,6 +20,7 @@ use middle::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, Init}; 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::pat_util::*; use middle::ty::*; @@ -1111,7 +1112,9 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, match p.node { ast::PatIdent(ast::BindByValue(_), _, ref sub) => { let pat_ty = tcx.node_id_to_type(p.id); - if cx.param_env.type_moves_by_default(pat_ty, pat.span) { + //FIXME: (@jroesch) this code should be floated up as well + let infcx = infer::new_infer_ctxt(cx.tcx, &cx.tcx.tables, Some(cx.param_env.clone()), false); + if infcx.type_moves_by_default(pat_ty, pat.span) { check_move(p, sub.as_ref().map(|p| &**p)); } } @@ -1139,8 +1142,9 @@ fn check_for_mutation_in_guard<'a, 'tcx>(cx: &'a MatchCheckCtxt<'a, 'tcx>, let mut checker = MutationChecker { cx: cx, }; - let mut visitor = ExprUseVisitor::new(&mut checker, - &checker.cx.param_env); + + let infcx = infer::new_infer_ctxt(cx.tcx, &cx.tcx.tables, Some(checker.cx.param_env.clone()), false); + let mut visitor = ExprUseVisitor::new(&mut checker, &infcx); visitor.walk_expr(guard); } diff --git a/src/librustc/middle/check_rvalues.rs b/src/librustc/middle/check_rvalues.rs index 1489e946fe2c..23accf88dc9d 100644 --- a/src/librustc/middle/check_rvalues.rs +++ b/src/librustc/middle/check_rvalues.rs @@ -12,6 +12,7 @@ // is the public starting point. use middle::expr_use_visitor as euv; +use middle::infer; use middle::mem_categorization as mc; use middle::ty::ParameterEnvironment; use middle::ty; @@ -38,9 +39,11 @@ impl<'a, 'tcx, 'v> visit::Visitor<'v> for RvalueContext<'a, 'tcx> { s: Span, fn_id: ast::NodeId) { { + // FIXME (@jroesch) change this to be an inference context let param_env = ParameterEnvironment::for_item(self.tcx, fn_id); - let mut delegate = RvalueContextDelegate { tcx: self.tcx, param_env: ¶m_env }; - let mut euv = euv::ExprUseVisitor::new(&mut delegate, ¶m_env); + let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, Some(param_env), false); + let mut delegate = RvalueContextDelegate { tcx: self.tcx, param_env: &infcx.parameter_environment }; + let mut euv = euv::ExprUseVisitor::new(&mut delegate, &infcx); euv.walk_fn(fd, b); } visit::walk_fn(self, fk, fd, b, s) diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 7d4553c8b146..b98864304d25 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.parameter_environment); + let mut selcx = traits::SelectionContext::new(&infcx, &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/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 91fee77f0a7a..31bfc01886c0 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -525,7 +525,7 @@ impl<'a, 'tcx> mc::Typer<'tcx> for InferCtxt<'a, 'tcx> { } fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option { - self.parameter_environment.temporary_scope(rvalue_id) + self.tcx.region_maps.temporary_scope(rvalue_id) } fn upvar_capture(&self, upvar_id: ty::UpvarId) -> Option { diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 371b5c309a85..25b336f0c7a6 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -38,8 +38,7 @@ pub fn overlapping_impls(infcx: &InferCtxt, impl1_def_id, impl2_def_id); - let param_env = &infcx.tcx.empty_parameter_environment(); - let selcx = &mut SelectionContext::intercrate(infcx, param_env); + let selcx = &mut SelectionContext::intercrate(infcx, 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/mod.rs b/src/librustc/middle/traits/mod.rs index c398a24f4f67..8c065e182cd4 100644 --- a/src/librustc/middle/traits/mod.rs +++ b/src/librustc/middle/traits/mod.rs @@ -398,7 +398,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.parameter_environment, cause, + let predicates = match fully_normalize(&infcx, &infcx, cause, &infcx.parameter_environment.caller_bounds) { Ok(predicates) => predicates, Err(errors) => { diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 8e5b6f4d4507..23aa840703bb 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 as mc; use middle::mem_categorization::Typer; use middle::region; use middle::resolve_lifetime; @@ -2919,11 +2918,14 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { -> Result<(),CopyImplementationError> { let tcx = self.tcx; + // FIXME: (@jroesch) float this code up + let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, Some(self.clone()), false); + let did = match self_type.sty { ty::TyStruct(struct_did, substs) => { let fields = tcx.struct_fields(struct_did, substs); for field in &fields { - if self.type_moves_by_default(field.mt.ty, span) { + if infcx.type_moves_by_default(field.mt.ty, span) { return Err(FieldDoesNotImplementCopy(field.name)) } } @@ -2935,7 +2937,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { for variant_arg_type in &variant.args { let substd_arg_type = variant_arg_type.subst(tcx, substs); - if self.type_moves_by_default(substd_arg_type, span) { + if infcx.type_moves_by_default(substd_arg_type, span) { return Err(VariantDoesNotImplementCopy(variant.name)) } } @@ -4272,7 +4274,8 @@ impl<'tcx> TyS<'tcx> { TyClosure(did, substs) => { // FIXME(#14449): `borrowed_contents` below assumes `&mut` closure. let param_env = cx.empty_parameter_environment(); - let upvars = param_env.closure_upvars(did, substs).unwrap(); + let infcx = infer::new_infer_ctxt(cx, &cx.tables, Some(param_env), false); + let upvars = infcx.closure_upvars(did, substs).unwrap(); TypeContents::union(&upvars, |f| tc_ty(cx, &f.ty, cache)) } @@ -4400,10 +4403,10 @@ impl<'tcx> TyS<'tcx> { span: Span) -> bool { - let tcx = param_env.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, param_env, + let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, &infcx, self, bound, span); debug!("Ty::impls_bound({:?}, {:?}) = {:?}", @@ -4412,7 +4415,8 @@ impl<'tcx> TyS<'tcx> { is_impld } - fn moves_by_default<'a>(&'tcx self, param_env: &ParameterEnvironment<'a,'tcx>, + // temp hack, probably should be private + pub fn moves_by_default<'a>(&'tcx self, param_env: &ParameterEnvironment<'a,'tcx>, span: Span) -> bool { if self.flags.get().intersects(TypeFlags::MOVENESS_CACHED) { return self.flags.get().intersects(TypeFlags::MOVES_BY_DEFAULT); @@ -6711,79 +6715,6 @@ impl<'tcx> ctxt<'tcx> { } } -impl<'a,'tcx> Typer<'tcx> for ParameterEnvironment<'a,'tcx> { - fn node_ty(&self, id: ast::NodeId) -> mc::McResult> { - Ok(self.tcx.node_id_to_type(id)) - } - - fn expr_ty_adjusted(&self, expr: &ast::Expr) -> mc::McResult> { - Ok(self.tcx.expr_ty_adjusted(expr)) - } - - fn node_method_ty(&self, method_call: ty::MethodCall) -> Option> { - self.tcx.tables.borrow().method_map.get(&method_call).map(|method| method.ty) - } - - fn node_method_origin(&self, method_call: ty::MethodCall) - -> Option> - { - self.tcx.tables.borrow().method_map.get(&method_call).map(|method| method.origin.clone()) - } - - fn adjustments(&self) -> Ref>> { - fn projection<'a, 'tcx>(tables: &'a Tables<'tcx>) -> &'a NodeMap> { - &tables.adjustments - } - - Ref::map(self.tcx.tables.borrow(), projection) - } - - fn is_method_call(&self, id: ast::NodeId) -> bool { - self.tcx.is_method_call(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.tcx.upvar_capture(upvar_id) - } - - fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool { - ty.moves_by_default(self, span) - } -} - -impl<'a,'tcx> ClosureTyper<'tcx> for ty::ParameterEnvironment<'a,'tcx> { - fn param_env<'b>(&'b self) -> &'b ty::ParameterEnvironment<'b,'tcx> { - self - } - - fn closure_kind(&self, - def_id: ast::DefId) - -> Option - { - Some(self.tcx.closure_kind(def_id)) - } - - fn closure_type(&self, - def_id: ast::DefId, - substs: &subst::Substs<'tcx>) - -> ty::ClosureTy<'tcx> - { - self.tcx.closure_type(def_id, substs) - } - - fn closure_upvars(&self, - def_id: ast::DefId, - substs: &Substs<'tcx>) - -> Option>> { - ctxt::closure_upvars(self, def_id, substs) - } -} - - /// The category of explicit self. #[derive(Clone, Copy, Eq, PartialEq, Debug)] pub enum ExplicitSelfCategory { diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index 9d4fb4c994d4..7c2318eef9cd 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -21,6 +21,7 @@ use self::UseError::*; use borrowck::*; use borrowck::InteriorKind::{InteriorElement, InteriorField}; use rustc::middle::expr_use_visitor as euv; +use rustc::middle::infer; use rustc::middle::mem_categorization as mc; use rustc::middle::region; use rustc::middle::ty; @@ -198,17 +199,18 @@ pub fn check_loans<'a, 'b, 'c, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, debug!("check_loans(body id={})", body.id); let param_env = ty::ParameterEnvironment::for_item(bccx.tcx, fn_id); + let infcx = infer::new_infer_ctxt(bccx.tcx, &bccx.tcx.tables, Some(param_env), false); let mut clcx = CheckLoanCtxt { bccx: bccx, dfcx_loans: dfcx_loans, move_data: move_data, all_loans: all_loans, - param_env: ¶m_env, + param_env: &infcx.parameter_environment }; { - let mut euv = euv::ExprUseVisitor::new(&mut clcx, ¶m_env); + let mut euv = euv::ExprUseVisitor::new(&mut clcx, &infcx); euv.walk_fn(decl, body); } } diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index 44a4a0d25040..432d6289efec 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -19,6 +19,7 @@ use borrowck::*; use borrowck::move_data::MoveData; use rustc::middle::expr_use_visitor as euv; +use rustc::middle::infer; use rustc::middle::mem_categorization as mc; use rustc::middle::region; use rustc::middle::ty; @@ -49,9 +50,9 @@ pub fn gather_loans_in_fn<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, }; let param_env = ty::ParameterEnvironment::for_item(bccx.tcx, fn_id); - + let infcx = infer::new_infer_ctxt(bccx.tcx, &bccx.tcx.tables, Some(param_env), false); { - let mut euv = euv::ExprUseVisitor::new(&mut glcx, ¶m_env); + let mut euv = euv::ExprUseVisitor::new(&mut glcx, &infcx); euv.walk_fn(decl, body); } @@ -490,8 +491,8 @@ struct StaticInitializerCtxt<'a, 'tcx: 'a> { impl<'a, 'tcx, 'v> Visitor<'v> for StaticInitializerCtxt<'a, 'tcx> { fn visit_expr(&mut self, ex: &Expr) { if let ast::ExprAddrOf(mutbl, ref base) = ex.node { - let param_env = self.bccx.tcx.empty_parameter_environment(); - let mc = mc::MemCategorizationContext::new(¶m_env); + let infcx = infer::new_infer_ctxt(self.bccx.tcx, &self.bccx.tcx.tables, None, false); + let mc = mc::MemCategorizationContext::new(&infcx); let base_cmt = mc.cat_expr(&**base).unwrap(); let borrow_kind = ty::BorrowKind::from_mutbl(mutbl); // Check that we don't allow borrows of unsafe static items. diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 4f726044a1ba..3cf2a62b3b67 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -747,7 +747,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { -> (&'static str, &'static str) { match ty.sty { _ => { - if param_env.type_moves_by_default(ty, span) { + if ty.moves_by_default(param_env, span) { ("non-copyable", "perhaps you meant to use `clone()`?") } else { diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 190e2965e76c..5661109ab455 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -1704,7 +1704,9 @@ impl LintPass for MissingCopyImplementations { _ => return, }; let parameter_environment = cx.tcx.empty_parameter_environment(); - if !parameter_environment.type_moves_by_default(ty, item.span) { + // FIXME (@jroesch) should probably inver this so that the parameter env still impls this + // method + if !ty.moves_by_default(¶meter_environment, item.span) { return; } if parameter_environment.can_type_implement_copy(ty, item.span).is_ok() { diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 47c2a5e579d9..9b293f7b1a78 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -197,7 +197,6 @@ use middle::def::{self, DefMap}; use middle::expr_use_visitor as euv; use middle::lang_items::StrEqFnLangItem; use middle::mem_categorization as mc; -use middle::mem_categorization::Typer; use middle::pat_util::*; use trans::adt; use trans::base::*; @@ -1416,7 +1415,7 @@ fn create_bindings_map<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat: &ast::Pat, let trmode; match bm { ast::BindByValue(_) - if !param_env.type_moves_by_default(variable_ty, span) || reassigned => + if !variable_ty.moves_by_default(¶m_env, span) || reassigned => { llmatch = alloca_no_lifetime(bcx, llvariable_ty.ptr_to(), diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 1fc68790db07..d4f318a4258c 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -154,7 +154,7 @@ fn type_needs_drop_given_env<'a,'tcx>(cx: &ty::ctxt<'tcx>, // normalized version of the type, and therefore will definitely // know whether the type implements Copy (and thus needs no // cleanup/drop/zeroing) ... - let implements_copy = !param_env.type_moves_by_default(ty, DUMMY_SP); + let implements_copy = !ty.moves_by_default(param_env, DUMMY_SP); if implements_copy { return false; } @@ -630,7 +630,7 @@ impl<'blk, 'tcx> mc::Typer<'tcx> for BlockS<'blk, 'tcx> { } fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool { - self.fcx.param_env.type_moves_by_default(ty, span) + ty.moves_by_default(&self.fcx.param_env, span) } } diff --git a/src/librustc_trans/trans/datum.rs b/src/librustc_trans/trans/datum.rs index 2c539b67cb62..c0ebffb58afc 100644 --- a/src/librustc_trans/trans/datum.rs +++ b/src/librustc_trans/trans/datum.rs @@ -101,7 +101,6 @@ use trans::cleanup::CleanupMethods; use trans::expr; use trans::tvec; use trans::type_of; -use middle::mem_categorization::Typer; use middle::ty::Ty; use std::fmt; @@ -606,8 +605,8 @@ impl<'tcx, K: KindOps + fmt::Debug> Datum<'tcx, K> { * affine values (since they must never be duplicated). */ - assert!(!bcx.tcx().empty_parameter_environment() - .type_moves_by_default(self.ty, DUMMY_SP)); + assert!(!self.ty + .moves_by_default(&bcx.tcx().empty_parameter_environment(), DUMMY_SP)); self.shallow_copy_raw(bcx, dst) } diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index 85478945e1cf..c05b95f4aeb2 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.parameter_environment); + let mut selcx = traits::SelectionContext::new(&infcx, &infcx); for predicate in impl_pred.fns { let traits::Normalized { value: predicate, .. } = @@ -293,7 +293,7 @@ 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, - &impl_param_env, + &infcx, &mut fulfillment_cx, impl_m_span, impl_m_body_id, @@ -312,7 +312,7 @@ 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, - &impl_param_env, + &infcx, &mut fulfillment_cx, impl_m_span, impl_m_body_id, @@ -347,7 +347,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.parameter_environment) { + match fulfillment_cx.select_all_or_error(&infcx, &infcx) { Err(ref errors) => { traits::report_fulfillment_errors(&infcx, errors) } Ok(_) => {} } @@ -456,7 +456,7 @@ 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, - &impl_param_env, + &infcx, &mut fulfillment_cx, impl_c_span, 0, @@ -466,7 +466,7 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>, let trait_ty = assoc::normalize_associated_types_in(&infcx, - &impl_param_env, + &infcx, &mut fulfillment_cx, impl_c_span, 0, diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 806bcb2306bd..4d750f88093f 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -431,7 +431,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.parameter_environment, + inh.normalize_associated_types_in(&inh.infcx, body.span, body.id, &fn_sig); @@ -1504,7 +1504,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { -> bool { traits::type_known_to_meet_builtin_bound(self.infcx(), - self.param_env(), + self.infcx(), ty, ty::BoundSized, span) diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 1219f2928c1c..0650f7deb06f 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -541,7 +541,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { // Check that all transitive obligations are satisfied. if let Err(errors) = fulfill_cx.select_all_or_error(&infcx, - &infcx.parameter_environment) { + &infcx) { traits::report_fulfillment_errors(&infcx, &errors); }