From ff8cd2e42836bc1ccf6fabcec9847e018126128a Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 8 Nov 2017 03:52:27 -0500 Subject: [PATCH] strip old lub-glb tests from `librustc_driver` Good riddance. --- src/librustc_driver/test.rs | 212 ------------------------------------ 1 file changed, 212 deletions(-) diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index 9e02065145d2..78ce959e5c94 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -353,28 +353,10 @@ impl<'a, 'gcx, 'tcx> Env<'a, 'gcx, 'tcx> { self.infcx.tcx.mk_imm_ref(r, self.tcx().types.isize) } - pub fn t_rptr_static(&self) -> Ty<'tcx> { - self.infcx.tcx.mk_imm_ref(self.infcx.tcx.types.re_static, - self.tcx().types.isize) - } - - pub fn t_rptr_empty(&self) -> Ty<'tcx> { - self.infcx.tcx.mk_imm_ref(self.infcx.tcx.types.re_empty, - self.tcx().types.isize) - } - pub fn sub(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) -> InferResult<'tcx, ()> { self.infcx.at(&ObligationCause::dummy(), self.param_env).sub(t1, t2) } - pub fn lub(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) -> InferResult<'tcx, Ty<'tcx>> { - self.infcx.at(&ObligationCause::dummy(), self.param_env).lub(t1, t2) - } - - pub fn glb(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) -> InferResult<'tcx, Ty<'tcx>> { - self.infcx.at(&ObligationCause::dummy(), self.param_env).glb(t1, t2) - } - /// Checks that `t1 <: t2` is true (this may register additional /// region checks). pub fn check_sub(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) { @@ -399,37 +381,6 @@ impl<'a, 'gcx, 'tcx> Env<'a, 'gcx, 'tcx> { } } } - - /// Checks that `LUB(t1,t2) == t_lub` - pub fn check_lub(&self, t1: Ty<'tcx>, t2: Ty<'tcx>, t_lub: Ty<'tcx>) { - match self.lub(t1, t2) { - Ok(InferOk { obligations, value: t }) => { - // None of these tests should require nested obligations: - assert!(obligations.is_empty()); - - self.assert_eq(t, t_lub); - } - Err(ref e) => panic!("unexpected error in LUB: {}", e), - } - } - - /// Checks that `GLB(t1,t2) == t_glb` - pub fn check_glb(&self, t1: Ty<'tcx>, t2: Ty<'tcx>, t_glb: Ty<'tcx>) { - debug!("check_glb(t1={}, t2={}, t_glb={})", t1, t2, t_glb); - match self.glb(t1, t2) { - Err(e) => panic!("unexpected error computing LUB: {:?}", e), - Ok(InferOk { obligations, value: t }) => { - // None of these tests should require nested obligations: - assert!(obligations.is_empty()); - - self.assert_eq(t, t_glb); - - // sanity check for good measure: - self.assert_subtype(t, t1); - self.assert_subtype(t, t2); - } - } - } } #[test] @@ -508,169 +459,6 @@ fn sub_free_bound_false_infer() { }) } -#[test] -fn lub_free_bound_infer() { - //! Test result of: - //! - //! LUB(fn(_#1), for<'b> fn(&'b isize)) - //! - //! This should yield `fn(&'_ isize)`. We check - //! that it yields `fn(&'x isize)` for some free `'x`, - //! anyhow. - - test_env(EMPTY_SOURCE_STR, errors(&[]), |mut env| { - env.create_simple_region_hierarchy(); - let t_infer1 = env.infcx.next_ty_var(TypeVariableOrigin::MiscVariable(DUMMY_SP)); - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_rptr_free1 = env.t_rptr_free(1); - env.check_lub(env.t_fn(&[t_infer1], env.tcx().types.isize), - env.t_fn(&[t_rptr_bound1], env.tcx().types.isize), - env.t_fn(&[t_rptr_free1], env.tcx().types.isize)); - }); -} - -#[test] -fn lub_bound_bound() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |env| { - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_rptr_bound2 = env.t_rptr_late_bound(2); - env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize), - env.t_fn(&[t_rptr_bound2], env.tcx().types.isize), - env.t_fn(&[t_rptr_bound1], env.tcx().types.isize)); - }) -} - -#[test] -fn lub_bound_free() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |mut env| { - env.create_simple_region_hierarchy(); - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_rptr_free1 = env.t_rptr_free(1); - env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize), - env.t_fn(&[t_rptr_free1], env.tcx().types.isize), - env.t_fn(&[t_rptr_free1], env.tcx().types.isize)); - }) -} - -#[test] -fn lub_bound_static() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |env| { - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_rptr_static = env.t_rptr_static(); - env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize), - env.t_fn(&[t_rptr_static], env.tcx().types.isize), - env.t_fn(&[t_rptr_static], env.tcx().types.isize)); - }) -} - -#[test] -fn lub_bound_bound_inverse_order() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |env| { - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_rptr_bound2 = env.t_rptr_late_bound(2); - env.check_lub(env.t_fn(&[t_rptr_bound1, t_rptr_bound2], t_rptr_bound1), - env.t_fn(&[t_rptr_bound2, t_rptr_bound1], t_rptr_bound1), - env.t_fn(&[t_rptr_bound1, t_rptr_bound1], t_rptr_bound1)); - }) -} - -#[test] -fn lub_free_free() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |mut env| { - env.create_simple_region_hierarchy(); - let t_rptr_free1 = env.t_rptr_free(1); - let t_rptr_free2 = env.t_rptr_free(2); - let t_rptr_static = env.t_rptr_static(); - env.check_lub(env.t_fn(&[t_rptr_free1], env.tcx().types.isize), - env.t_fn(&[t_rptr_free2], env.tcx().types.isize), - env.t_fn(&[t_rptr_static], env.tcx().types.isize)); - }) -} - -#[test] -fn lub_returning_scope() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |mut env| { - env.create_simple_region_hierarchy(); - let t_rptr_scope10 = env.t_rptr_scope(10); - let t_rptr_scope11 = env.t_rptr_scope(11); - let t_rptr_empty = env.t_rptr_empty(); - env.check_lub(env.t_fn(&[t_rptr_scope10], env.tcx().types.isize), - env.t_fn(&[t_rptr_scope11], env.tcx().types.isize), - env.t_fn(&[t_rptr_empty], env.tcx().types.isize)); - }); -} - -#[test] -fn glb_free_free_with_common_scope() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |mut env| { - env.create_simple_region_hierarchy(); - let t_rptr_free1 = env.t_rptr_free(1); - let t_rptr_free2 = env.t_rptr_free(2); - let t_rptr_scope = env.t_rptr_scope(1); - env.check_glb(env.t_fn(&[t_rptr_free1], env.tcx().types.isize), - env.t_fn(&[t_rptr_free2], env.tcx().types.isize), - env.t_fn(&[t_rptr_scope], env.tcx().types.isize)); - }) -} - -#[test] -fn glb_bound_bound() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |env| { - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_rptr_bound2 = env.t_rptr_late_bound(2); - env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize), - env.t_fn(&[t_rptr_bound2], env.tcx().types.isize), - env.t_fn(&[t_rptr_bound1], env.tcx().types.isize)); - }) -} - -#[test] -fn glb_bound_free() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |mut env| { - env.create_simple_region_hierarchy(); - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_rptr_free1 = env.t_rptr_free(1); - env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize), - env.t_fn(&[t_rptr_free1], env.tcx().types.isize), - env.t_fn(&[t_rptr_bound1], env.tcx().types.isize)); - }) -} - -#[test] -fn glb_bound_free_infer() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |env| { - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_infer1 = env.infcx.next_ty_var(TypeVariableOrigin::MiscVariable(DUMMY_SP)); - - // compute GLB(fn(_) -> isize, for<'b> fn(&'b isize) -> isize), - // which should yield for<'b> fn(&'b isize) -> isize - env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize), - env.t_fn(&[t_infer1], env.tcx().types.isize), - env.t_fn(&[t_rptr_bound1], env.tcx().types.isize)); - - // as a side-effect, computing GLB should unify `_` with - // `&'_ isize` - let t_resolve1 = env.infcx.shallow_resolve(t_infer1); - match t_resolve1.sty { - ty::TyRef(..) => {} - _ => { - panic!("t_resolve1={:?}", t_resolve1); - } - } - }) -} - -#[test] -fn glb_bound_static() { - test_env(EMPTY_SOURCE_STR, errors(&[]), |env| { - let t_rptr_bound1 = env.t_rptr_late_bound(1); - let t_rptr_static = env.t_rptr_static(); - env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize), - env.t_fn(&[t_rptr_static], env.tcx().types.isize), - env.t_fn(&[t_rptr_bound1], env.tcx().types.isize)); - }) -} - /// Test substituting a bound region into a function, which introduces another level of binding. /// This requires adjusting the Debruijn index. #[test]