From e339e84fffb3156aaa78fbf686436de02ba4cf48 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 10 Oct 2018 15:34:23 -0400 Subject: [PATCH] move `force_instantiate_unchecked` to be local to `nll_relate` code --- src/librustc/infer/mod.rs | 59 --------------------------- src/librustc/infer/nll_relate/mod.rs | 61 ++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 59 deletions(-) diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs index 9d56cf5aabe..fbd38ebd78c 100644 --- a/src/librustc/infer/mod.rs +++ b/src/librustc/infer/mod.rs @@ -1231,65 +1231,6 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { self.inlined_shallow_resolve(typ) } - /// A hacky sort of method used by the NLL type-relating code: - /// - /// - `var` must be some unbound type variable. - /// - `value` must be a suitable type to use as its value. - /// - /// `var` will then be equated with `value`. Note that this - /// sidesteps a number of important checks, such as the "occurs - /// check" that prevents cyclic types, so it is important not to - /// use this method during regular type-check. - fn force_instantiate_unchecked(&self, var: Ty<'tcx>, value: Ty<'tcx>) { - match (&var.sty, &value.sty) { - (&ty::Infer(ty::TyVar(vid)), _) => { - let mut type_variables = self.type_variables.borrow_mut(); - - // In NLL, we don't have type inference variables - // floating around, so we can do this rather imprecise - // variant of the occurs-check. - assert!(!value.has_infer_types()); - - type_variables.instantiate(vid, value); - } - - (&ty::Infer(ty::IntVar(vid)), &ty::Int(value)) => { - let mut int_unification_table = self.int_unification_table.borrow_mut(); - int_unification_table - .unify_var_value(vid, Some(ty::IntVarValue::IntType(value))) - .unwrap_or_else(|_| { - bug!("failed to unify int var `{:?}` with `{:?}`", vid, value); - }); - } - - (&ty::Infer(ty::IntVar(vid)), &ty::Uint(value)) => { - let mut int_unification_table = self.int_unification_table.borrow_mut(); - int_unification_table - .unify_var_value(vid, Some(ty::IntVarValue::UintType(value))) - .unwrap_or_else(|_| { - bug!("failed to unify int var `{:?}` with `{:?}`", vid, value); - }); - } - - (&ty::Infer(ty::FloatVar(vid)), &ty::Float(value)) => { - let mut float_unification_table = self.float_unification_table.borrow_mut(); - float_unification_table - .unify_var_value(vid, Some(ty::FloatVarValue(value))) - .unwrap_or_else(|_| { - bug!("failed to unify float var `{:?}` with `{:?}`", vid, value) - }); - } - - _ => { - bug!( - "force_instantiate_unchecked invoked with bad combination: var={:?} value={:?}", - var, - value, - ); - } - } - } - pub fn resolve_type_vars_if_possible(&self, value: &T) -> T where T: TypeFoldable<'tcx>, diff --git a/src/librustc/infer/nll_relate/mod.rs b/src/librustc/infer/nll_relate/mod.rs index bd126b17971..e003c1989e0 100644 --- a/src/librustc/infer/nll_relate/mod.rs +++ b/src/librustc/infer/nll_relate/mod.rs @@ -673,3 +673,64 @@ where Ok(ty::Binder::bind(result)) } } + +impl InferCtxt<'_, '_, 'tcx> { + /// A hacky sort of method used by the NLL type-relating code: + /// + /// - `var` must be some unbound type variable. + /// - `value` must be a suitable type to use as its value. + /// + /// `var` will then be equated with `value`. Note that this + /// sidesteps a number of important checks, such as the "occurs + /// check" that prevents cyclic types, so it is important not to + /// use this method during regular type-check. + fn force_instantiate_unchecked(&self, var: Ty<'tcx>, value: Ty<'tcx>) { + match (&var.sty, &value.sty) { + (&ty::Infer(ty::TyVar(vid)), _) => { + let mut type_variables = self.type_variables.borrow_mut(); + + // In NLL, we don't have type inference variables + // floating around, so we can do this rather imprecise + // variant of the occurs-check. + assert!(!value.has_infer_types()); + + type_variables.instantiate(vid, value); + } + + (&ty::Infer(ty::IntVar(vid)), &ty::Int(value)) => { + let mut int_unification_table = self.int_unification_table.borrow_mut(); + int_unification_table + .unify_var_value(vid, Some(ty::IntVarValue::IntType(value))) + .unwrap_or_else(|_| { + bug!("failed to unify int var `{:?}` with `{:?}`", vid, value); + }); + } + + (&ty::Infer(ty::IntVar(vid)), &ty::Uint(value)) => { + let mut int_unification_table = self.int_unification_table.borrow_mut(); + int_unification_table + .unify_var_value(vid, Some(ty::IntVarValue::UintType(value))) + .unwrap_or_else(|_| { + bug!("failed to unify int var `{:?}` with `{:?}`", vid, value); + }); + } + + (&ty::Infer(ty::FloatVar(vid)), &ty::Float(value)) => { + let mut float_unification_table = self.float_unification_table.borrow_mut(); + float_unification_table + .unify_var_value(vid, Some(ty::FloatVarValue(value))) + .unwrap_or_else(|_| { + bug!("failed to unify float var `{:?}` with `{:?}`", vid, value) + }); + } + + _ => { + bug!( + "force_instantiate_unchecked invoked with bad combination: var={:?} value={:?}", + var, + value, + ); + } + } + } +}