diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index a64fe8b91282..43be1beba91d 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -1386,16 +1386,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { .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 } @@ -1409,15 +1400,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { 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 diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 32fbd7739005..f506de525ff9 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -257,7 +257,6 @@ impl ast_node for ast::Pat { #[derive(Copy, Clone)] pub struct MemCategorizationContext<'t, 'a: 't, 'tcx : 'a> { pub typer: &'t infer::InferCtxt<'a, 'tcx>, - // pub monomorphize: bool, } pub type McResult = Result; diff --git a/src/librustc/middle/traits/mod.rs b/src/librustc/middle/traits/mod.rs index a39fe4536643..47002497acca 100644 --- a/src/librustc/middle/traits/mod.rs +++ b/src/librustc/middle/traits/mod.rs @@ -436,17 +436,20 @@ pub fn fully_normalize<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>, debug!("normalize_param_env(value={:?})", value); 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 - // regionck.rs line 337. The two possibilities I see is that - // normalization is not actually fully happening and we - // have a bug else where or that we are adding a duplicate - // bound into the list causing its size to change. I think - // we should probably land this refactor and then come + // 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 regionck.rs line 337. + // + // The two possibilities I see is: + // - normalization is not actually fully happening and we + // have a bug else where + // - we are adding a duplicate bound into the list causing + // its size to change. + // + // I think we should probably land this refactor and then come // back to this is a follow-up patch. let mut fulfill_cx = FulfillmentContext::new(false); - // let mut fulfill_cx = infcx.fulfillment_cx.borrow_mut(); let Normalized { value: normalized_value, obligations } = project::normalize(selcx, cause, value); @@ -456,6 +459,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)); let resolved_value = infcx.resolve_type_vars_if_possible(&normalized_value); debug!("normalize_param_env: resolved_value={:?}", resolved_value); diff --git a/src/librustc_typeck/check/assoc.rs b/src/librustc_typeck/check/assoc.rs index 75263c35d595..c80c48a96922 100644 --- a/src/librustc_typeck/check/assoc.rs +++ b/src/librustc_typeck/check/assoc.rs @@ -16,7 +16,7 @@ use middle::ty_fold::TypeFoldable; use syntax::ast; use syntax::codemap::Span; -//FIME(@jroesch): Refactor this +//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>, fulfillment_cx: &mut FulfillmentContext<'tcx>, span: Span, diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 477b6e982568..b7ebf1abd2d2 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -158,9 +158,6 @@ pub struct Inherited<'a, 'tcx: 'a> { // one is never copied into the tcx: it is only used by regionck. fn_sig_map: RefCell>>>, - // Tracks trait obligations incurred during this function body. - // fulfillment_cx: RefCell>, - // When we process a call like `c()` where `c` is a closure type, // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or // `FnOnce` closure. In that case, we defer full resolution of the diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index fca23a1b029a..a1c5ad51dcdf 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -631,7 +631,6 @@ fn subst_receiver_types_in_method_ty<'tcx>(tcx: &ty::ctxt<'tcx>, pub fn check_coherence(crate_context: &CrateCtxt) { CoherenceChecker { crate_context: crate_context, - // XXXJAREDXXX: not sure if the bool is right here? inference_context: new_infer_ctxt(crate_context.tcx, &crate_context.tcx.tables, None, true), inherent_impls: RefCell::new(FnvHashMap()), }.check(crate_context.tcx.map.krate());