From b354ae95a29a7f78059a1a9fc867dd2e8639671a Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Mon, 13 Jun 2016 20:13:37 +0300 Subject: [PATCH] rustc: move the SelfSpace before TypeSpace in Substs. --- src/librustc/traits/error_reporting.rs | 2 +- src/librustc/traits/select.rs | 5 +- src/librustc/ty/subst.rs | 75 +++++++++---------- src/librustc_trans/base.rs | 4 +- src/librustc_typeck/check/mod.rs | 2 +- .../trait-method-default-impl.rs | 10 +-- .../compile-fail/variance-associated-types.rs | 4 +- .../compile-fail/variance-object-types.rs | 2 +- .../compile-fail/variance-region-bounds.rs | 2 +- .../compile-fail/variance-regions-direct.rs | 14 ++-- .../compile-fail/variance-regions-indirect.rs | 10 +-- .../compile-fail/variance-trait-bounds.rs | 10 +-- .../variance-trait-object-bound.rs | 2 +- .../compile-fail/variance-types-bounds.rs | 10 +-- src/test/compile-fail/variance-types.rs | 12 +-- 15 files changed, 82 insertions(+), 82 deletions(-) diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index cf004767b2a..4c8489ff071 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -182,7 +182,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { let rps = self.region_vars_for_defs(obligation.cause.span, rps); let mut substs = subst::Substs::new( subst::VecPerParamSpace::empty(), - subst::VecPerParamSpace::new(rps, Vec::new(), Vec::new())); + subst::VecPerParamSpace::new(Vec::new(), rps, Vec::new())); self.type_vars_for_defs(obligation.cause.span, TypeSpace, &mut substs, diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs index 6b9de746f66..9c7dd7ccd70 100644 --- a/src/librustc/traits/select.rs +++ b/src/librustc/traits/select.rs @@ -1602,7 +1602,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { return; } }; - let target = obligation.predicate.0.input_types()[0]; + let target = obligation.predicate.skip_binder().input_types()[1]; debug!("assemble_candidates_for_unsizing(source={:?}, target={:?})", source, target); @@ -2476,7 +2476,8 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { // regions here. See the comment there for more details. let source = self.infcx.shallow_resolve( tcx.no_late_bound_regions(&obligation.self_ty()).unwrap()); - let target = self.infcx.shallow_resolve(obligation.predicate.0.input_types()[0]); + let target = obligation.predicate.skip_binder().input_types()[1]; + let target = self.infcx.shallow_resolve(target); debug!("confirm_builtin_unsize_candidate(source={:?}, target={:?})", source, target); diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs index 25b108cee27..0fe8d096640 100644 --- a/src/librustc/ty/subst.rs +++ b/src/librustc/ty/subst.rs @@ -48,8 +48,8 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> { r: Vec) -> Substs<'tcx> { - Substs::new(VecPerParamSpace::new(t, Vec::new(), Vec::new()), - VecPerParamSpace::new(r, Vec::new(), Vec::new())) + Substs::new(VecPerParamSpace::new(vec![], t, vec![]), + VecPerParamSpace::new(vec![], r, vec![])) } pub fn new_trait(t: Vec>, @@ -57,8 +57,8 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> { s: Ty<'tcx>) -> Substs<'tcx> { - Substs::new(VecPerParamSpace::new(t, vec!(s), Vec::new()), - VecPerParamSpace::new(r, Vec::new(), Vec::new())) + Substs::new(VecPerParamSpace::new(vec![s], t, vec![]), + VecPerParamSpace::new(vec![], r, vec![])) } pub fn empty() -> Substs<'tcx> { @@ -169,28 +169,28 @@ impl<'tcx> Decodable for &'tcx Substs<'tcx> { #[derive(PartialOrd, Ord, PartialEq, Eq, Copy, Clone, Hash, RustcEncodable, RustcDecodable, Debug)] pub enum ParamSpace { - TypeSpace, // Type parameters attached to a type definition, trait, or impl SelfSpace, // Self parameter on a trait + TypeSpace, // Type parameters attached to a type definition, trait, or impl FnSpace, // Type parameters attached to a method or fn } impl ParamSpace { pub fn all() -> [ParamSpace; 3] { - [TypeSpace, SelfSpace, FnSpace] + [SelfSpace, TypeSpace, FnSpace] } pub fn to_uint(self) -> usize { match self { - TypeSpace => 0, - SelfSpace => 1, + SelfSpace => 0, + TypeSpace => 1, FnSpace => 2, } } pub fn from_uint(u: usize) -> ParamSpace { match u { - 0 => TypeSpace, - 1 => SelfSpace, + 0 => SelfSpace, + 1 => TypeSpace, 2 => FnSpace, _ => bug!("Invalid ParamSpace: {}", u) } @@ -209,19 +209,19 @@ pub struct VecPerParamSpace { // Here is how the representation corresponds to the abstraction // i.e. the "abstraction function" AF: // - // AF(self) = (self.content[..self.type_limit], - // self.content[self.type_limit..self.self_limit], - // self.content[self.self_limit..]) - type_limit: usize, + // AF(self) = (self.content[..self.self_limit], + // self.content[self.self_limit..self.type_limit], + // self.content[self.type_limit..]) self_limit: usize, + type_limit: usize, content: Vec, } impl fmt::Debug for VecPerParamSpace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "[{:?};{:?};{:?}]", - self.get_slice(TypeSpace), self.get_slice(SelfSpace), + self.get_slice(TypeSpace), self.get_slice(FnSpace)) } } @@ -229,44 +229,44 @@ impl fmt::Debug for VecPerParamSpace { impl VecPerParamSpace { fn limits(&self, space: ParamSpace) -> (usize, usize) { match space { - TypeSpace => (0, self.type_limit), - SelfSpace => (self.type_limit, self.self_limit), - FnSpace => (self.self_limit, self.content.len()), + SelfSpace => (0, self.self_limit), + TypeSpace => (self.self_limit, self.type_limit), + FnSpace => (self.type_limit, self.content.len()), } } pub fn empty() -> VecPerParamSpace { VecPerParamSpace { - type_limit: 0, self_limit: 0, + type_limit: 0, content: Vec::new() } } - /// `t` is the type space. /// `s` is the self space. + /// `t` is the type space. /// `f` is the fn space. - pub fn new(t: Vec, s: Vec, f: Vec) -> VecPerParamSpace { - let type_limit = t.len(); - let self_limit = type_limit + s.len(); + pub fn new(s: Vec, t: Vec, f: Vec) -> VecPerParamSpace { + let self_limit = s.len(); + let type_limit = self_limit + t.len(); - let mut content = t; - content.extend(s); + let mut content = s; + content.extend(t); content.extend(f); VecPerParamSpace { - type_limit: type_limit, self_limit: self_limit, + type_limit: type_limit, content: content, } } - fn new_internal(content: Vec, type_limit: usize, self_limit: usize) + fn new_internal(content: Vec, self_limit: usize, type_limit: usize) -> VecPerParamSpace { VecPerParamSpace { - type_limit: type_limit, self_limit: self_limit, + type_limit: type_limit, content: content, } } @@ -278,8 +278,8 @@ impl VecPerParamSpace { pub fn push(&mut self, space: ParamSpace, value: T) { let (_, limit) = self.limits(space); match space { - TypeSpace => { self.type_limit += 1; self.self_limit += 1; } - SelfSpace => { self.self_limit += 1; } + SelfSpace => { self.type_limit += 1; self.self_limit += 1; } + TypeSpace => { self.type_limit += 1; } FnSpace => { } } self.content.insert(limit, value); @@ -302,8 +302,8 @@ impl VecPerParamSpace { None } else { match space { - TypeSpace => { self.type_limit -= 1; self.self_limit -= 1; } - SelfSpace => { self.self_limit -= 1; } + SelfSpace => { self.type_limit -= 1; self.self_limit -= 1; } + TypeSpace => { self.type_limit -= 1; } FnSpace => {} } if self.content.is_empty() { @@ -388,8 +388,7 @@ impl VecPerParamSpace { pub fn all_vecs

(&self, mut pred: P) -> bool where P: FnMut(&[T]) -> bool, { - let spaces = [TypeSpace, SelfSpace, FnSpace]; - spaces.iter().all(|&space| { pred(self.get_slice(space)) }) + ParamSpace::all().iter().all(|&space| { pred(self.get_slice(space)) }) } pub fn all

(&self, pred: P) -> bool where P: FnMut(&T) -> bool { @@ -407,8 +406,8 @@ impl VecPerParamSpace { pub fn map(&self, pred: P) -> VecPerParamSpace where P: FnMut(&T) -> U { let result = self.iter().map(pred).collect(); VecPerParamSpace::new_internal(result, - self.type_limit, - self.self_limit) + self.self_limit, + self.type_limit) } pub fn map_enumerated(&self, pred: P) -> VecPerParamSpace where @@ -416,8 +415,8 @@ impl VecPerParamSpace { { let result = self.iter_enumerated().map(pred).collect(); VecPerParamSpace::new_internal(result, - self.type_limit, - self.self_limit) + self.self_limit, + self.type_limit) } pub fn with_slice(mut self, space: ParamSpace, slice: &[T]) diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs index c78cda75e82..3ea7f0d5eab 100644 --- a/src/librustc_trans/base.rs +++ b/src/librustc_trans/base.rs @@ -675,8 +675,8 @@ pub fn custom_coerce_unsize_info<'scx, 'tcx>(scx: &SharedCrateContext<'scx, 'tcx source_ty: Ty<'tcx>, target_ty: Ty<'tcx>) -> CustomCoerceUnsized { - let trait_substs = Substs::new(subst::VecPerParamSpace::new(vec![target_ty], - vec![source_ty], + let trait_substs = Substs::new(subst::VecPerParamSpace::new(vec![source_ty], + vec![target_ty], Vec::new()), subst::VecPerParamSpace::empty()); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index d985d3ccbea..76b9052af68 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2797,7 +2797,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { let rps = self.region_vars_for_defs(span, rps); let mut substs = subst::Substs::new( VecPerParamSpace::empty(), - VecPerParamSpace::new(rps, Vec::new(), Vec::new())); + VecPerParamSpace::new(Vec::new(), rps, Vec::new())); self.type_vars_for_defs(span, ParamSpace::TypeSpace, &mut substs, tps); let substd_ty = self.instantiate_type_scheme(span, &substs, &raw_ty); diff --git a/src/test/codegen-units/item-collection/trait-method-default-impl.rs b/src/test/codegen-units/item-collection/trait-method-default-impl.rs index 2b3b83cb7ec..47892781902 100644 --- a/src/test/codegen-units/item-collection/trait-method-default-impl.rs +++ b/src/test/codegen-units/item-collection/trait-method-default-impl.rs @@ -37,7 +37,7 @@ impl SomeGenericTrait for i32 { // For the non-generic foo(), we should generate a codegen-item even if it // is not called anywhere - //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::foo[0] + //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::foo[0] } // Non-generic impl of generic trait @@ -54,16 +54,16 @@ fn main() { //~ TRANS_ITEM fn trait_method_default_impl::SomeTrait[0]::bar[0] let _ = 2i8.bar("&str"); - //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0] + //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0] 0i32.bar(0u64, 'c'); - //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0] + //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0] 0i32.bar(0u64, "&str"); - //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0] + //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0] 0u32.bar(0i8, &['c']); - //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0] + //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0] 0u32.bar(0i16, ()); } diff --git a/src/test/compile-fail/variance-associated-types.rs b/src/test/compile-fail/variance-associated-types.rs index 0ed0861d34a..a3456b0628b 100644 --- a/src/test/compile-fail/variance-associated-types.rs +++ b/src/test/compile-fail/variance-associated-types.rs @@ -20,12 +20,12 @@ trait Trait<'a> { } #[rustc_variance] -struct Foo<'a, T : Trait<'a>> { //~ ERROR ItemVariances(types=[[+];[];[]], regions=[[-];[];[]]) +struct Foo<'a, T : Trait<'a>> { //~ ERROR ItemVariances(types=[[];[+];[]], regions=[[];[-];[]]) field: (T, &'a ()) } #[rustc_variance] -struct Bar<'a, T : Trait<'a>> { //~ ERROR ItemVariances(types=[[o];[];[]], regions=[[o];[];[]]) +struct Bar<'a, T : Trait<'a>> { //~ ERROR ItemVariances(types=[[];[o];[]], regions=[[];[o];[]]) field: >::Type } diff --git a/src/test/compile-fail/variance-object-types.rs b/src/test/compile-fail/variance-object-types.rs index 2b7b05970d9..ffd829c38d3 100644 --- a/src/test/compile-fail/variance-object-types.rs +++ b/src/test/compile-fail/variance-object-types.rs @@ -18,7 +18,7 @@ use std::cell::Cell; // For better or worse, associated types are invariant, and hence we // get an invariant result for `'a`. #[rustc_variance] -struct Foo<'a> { //~ ERROR regions=[[o];[];[]] +struct Foo<'a> { //~ ERROR regions=[[];[o];[]] x: Box &'a i32 + 'static> } diff --git a/src/test/compile-fail/variance-region-bounds.rs b/src/test/compile-fail/variance-region-bounds.rs index dfa5dc14441..6dd791f2558 100644 --- a/src/test/compile-fail/variance-region-bounds.rs +++ b/src/test/compile-fail/variance-region-bounds.rs @@ -13,7 +13,7 @@ #![feature(rustc_attrs)] #[rustc_variance] -trait Foo: 'static { //~ ERROR types=[[];[o];[]] +trait Foo: 'static { //~ ERROR types=[[o];[];[]] } #[rustc_variance] diff --git a/src/test/compile-fail/variance-regions-direct.rs b/src/test/compile-fail/variance-regions-direct.rs index bb452eecbfc..0c712d3fa03 100644 --- a/src/test/compile-fail/variance-regions-direct.rs +++ b/src/test/compile-fail/variance-regions-direct.rs @@ -16,7 +16,7 @@ // Regions that just appear in normal spots are contravariant: #[rustc_variance] -struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[]] +struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[];[-, -, -];[]] x: &'a isize, y: &'b [isize], c: &'c str @@ -25,7 +25,7 @@ struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[]] // Those same annotations in function arguments become covariant: #[rustc_variance] -struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[]] +struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[];[+, +, +];[]] x: extern "Rust" fn(&'a isize), y: extern "Rust" fn(&'b [isize]), c: extern "Rust" fn(&'c str), @@ -34,7 +34,7 @@ struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[]] // Mutability induces invariance: #[rustc_variance] -struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]] +struct Test4<'a, 'b:'a> { //~ ERROR regions=[[];[-, o];[]] x: &'a mut &'b isize, } @@ -42,7 +42,7 @@ struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]] // contravariant context: #[rustc_variance] -struct Test5<'a, 'b:'a> { //~ ERROR regions=[[+, o];[];[]] +struct Test5<'a, 'b:'a> { //~ ERROR regions=[[];[+, o];[]] x: extern "Rust" fn(&'a mut &'b isize), } @@ -52,14 +52,14 @@ struct Test5<'a, 'b:'a> { //~ ERROR regions=[[+, o];[];[]] // argument list occurs in an invariant context. #[rustc_variance] -struct Test6<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]] +struct Test6<'a, 'b:'a> { //~ ERROR regions=[[];[-, o];[]] x: &'a mut extern "Rust" fn(&'b isize), } // No uses at all is bivariant: #[rustc_variance] -struct Test7<'a> { //~ ERROR regions=[[*];[];[]] +struct Test7<'a> { //~ ERROR regions=[[];[*];[]] //~^ ERROR parameter `'a` is never used x: isize } @@ -67,7 +67,7 @@ struct Test7<'a> { //~ ERROR regions=[[*];[];[]] // Try enums too. #[rustc_variance] -enum Test8<'a, 'b, 'c:'b> { //~ ERROR regions=[[+, -, o];[];[]] +enum Test8<'a, 'b, 'c:'b> { //~ ERROR regions=[[];[+, -, o];[]] Test8A(extern "Rust" fn(&'a isize)), Test8B(&'b [isize]), Test8C(&'b mut &'c str), diff --git a/src/test/compile-fail/variance-regions-indirect.rs b/src/test/compile-fail/variance-regions-indirect.rs index 9beb90d0b24..9bdb05e188d 100644 --- a/src/test/compile-fail/variance-regions-indirect.rs +++ b/src/test/compile-fail/variance-regions-indirect.rs @@ -15,7 +15,7 @@ #![feature(rustc_attrs)] #[rustc_variance] -enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR regions=[[+, -, o, *];[];[]] +enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR regions=[[];[+, -, o, *];[]] //~^ ERROR parameter `'d` is never used Test8A(extern "Rust" fn(&'a isize)), Test8B(&'b [isize]), @@ -23,25 +23,25 @@ enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR regions=[[+, -, o, *];[];[]] } #[rustc_variance] -struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR regions=[[*, o, -, +];[];[]] +struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR regions=[[];[*, o, -, +];[]] //~^ ERROR parameter `'w` is never used f: Base<'z, 'y, 'x, 'w> } #[rustc_variance] // Combine - and + to yield o -struct Derived2<'a, 'b:'a, 'c> { //~ ERROR regions=[[o, o, *];[];[]] +struct Derived2<'a, 'b:'a, 'c> { //~ ERROR regions=[[];[o, o, *];[]] //~^ ERROR parameter `'c` is never used f: Base<'a, 'a, 'b, 'c> } #[rustc_variance] // Combine + and o to yield o (just pay attention to 'a here) -struct Derived3<'a:'b, 'b, 'c> { //~ ERROR regions=[[o, -, *];[];[]] +struct Derived3<'a:'b, 'b, 'c> { //~ ERROR regions=[[];[o, -, *];[]] //~^ ERROR parameter `'c` is never used f: Base<'a, 'b, 'a, 'c> } #[rustc_variance] // Combine + and * to yield + (just pay attention to 'a here) -struct Derived4<'a, 'b, 'c:'b> { //~ ERROR regions=[[+, -, o];[];[]] +struct Derived4<'a, 'b, 'c:'b> { //~ ERROR regions=[[];[+, -, o];[]] f: Base<'a, 'b, 'c, 'a> } diff --git a/src/test/compile-fail/variance-trait-bounds.rs b/src/test/compile-fail/variance-trait-bounds.rs index b6f197987ba..528be50c0b8 100644 --- a/src/test/compile-fail/variance-trait-bounds.rs +++ b/src/test/compile-fail/variance-trait-bounds.rs @@ -25,18 +25,18 @@ trait Setter { //~ ERROR types=[[o];[o];[]] } #[rustc_variance] -struct TestStruct> { //~ ERROR types=[[+, +];[];[]] +struct TestStruct> { //~ ERROR types=[[];[+, +];[]] t: T, u: U } #[rustc_variance] -enum TestEnum> {//~ ERROR types=[[*, +];[];[]] +enum TestEnum> {//~ ERROR types=[[];[*, +];[]] //~^ ERROR parameter `U` is never used Foo(T) } #[rustc_variance] -trait TestTrait> { //~ ERROR types=[[o, o];[o];[]] +trait TestTrait> { //~ ERROR types=[[o];[o, o];[]] fn getter(&self, u: U) -> T; } @@ -50,13 +50,13 @@ trait TestTrait3 { //~ ERROR types=[[o];[o];[]] } #[rustc_variance] -struct TestContraStruct> { //~ ERROR types=[[*, +];[];[]] +struct TestContraStruct> { //~ ERROR types=[[];[*, +];[]] //~^ ERROR parameter `U` is never used t: T } #[rustc_variance] -struct TestBox+Setter> { //~ ERROR types=[[*, +];[];[]] +struct TestBox+Setter> { //~ ERROR types=[[];[*, +];[]] //~^ ERROR parameter `U` is never used t: T } diff --git a/src/test/compile-fail/variance-trait-object-bound.rs b/src/test/compile-fail/variance-trait-object-bound.rs index f0ca1edd563..b5854020498 100644 --- a/src/test/compile-fail/variance-trait-object-bound.rs +++ b/src/test/compile-fail/variance-trait-object-bound.rs @@ -21,7 +21,7 @@ use std::mem; trait T { fn foo(&self); } #[rustc_variance] -struct TOption<'a> { //~ ERROR regions=[[-];[];[]] +struct TOption<'a> { //~ ERROR regions=[[];[-];[]] v: Option>, } diff --git a/src/test/compile-fail/variance-types-bounds.rs b/src/test/compile-fail/variance-types-bounds.rs index a02f20656e7..d110c402d3b 100644 --- a/src/test/compile-fail/variance-types-bounds.rs +++ b/src/test/compile-fail/variance-types-bounds.rs @@ -14,24 +14,24 @@ #![feature(rustc_attrs)] #[rustc_variance] -struct TestImm { //~ ERROR types=[[+, +];[];[]] +struct TestImm { //~ ERROR types=[[];[+, +];[]] x: A, y: B, } #[rustc_variance] -struct TestMut { //~ ERROR types=[[+, o];[];[]] +struct TestMut { //~ ERROR types=[[];[+, o];[]] x: A, y: &'static mut B, } #[rustc_variance] -struct TestIndirect { //~ ERROR types=[[+, o];[];[]] +struct TestIndirect { //~ ERROR types=[[];[+, o];[]] m: TestMut } #[rustc_variance] -struct TestIndirect2 { //~ ERROR types=[[o, o];[];[]] +struct TestIndirect2 { //~ ERROR types=[[];[o, o];[]] n: TestMut, m: TestMut } @@ -68,7 +68,7 @@ trait SetterInTypeBound { //~ ERROR types=[[o];[o];[]] } #[rustc_variance] -struct TestObject { //~ ERROR types=[[o, o];[];[]] +struct TestObject { //~ ERROR types=[[];[o, o];[]] n: Box+Send>, m: Box+Send>, } diff --git a/src/test/compile-fail/variance-types.rs b/src/test/compile-fail/variance-types.rs index 2fd8bf20c79..8c1a544334c 100644 --- a/src/test/compile-fail/variance-types.rs +++ b/src/test/compile-fail/variance-types.rs @@ -17,32 +17,32 @@ use std::cell::Cell; // not considered bivariant. #[rustc_variance] -struct InvariantMut<'a,A:'a,B:'a> { //~ ERROR types=[[o, o];[];[]], regions=[[-];[];[]] +struct InvariantMut<'a,A:'a,B:'a> { //~ ERROR types=[[];[o, o];[]], regions=[[];[-];[]] t: &'a mut (A,B) } #[rustc_variance] -struct InvariantCell { //~ ERROR types=[[o];[];[]] +struct InvariantCell { //~ ERROR types=[[];[o];[]] t: Cell } #[rustc_variance] -struct InvariantIndirect { //~ ERROR types=[[o];[];[]] +struct InvariantIndirect { //~ ERROR types=[[];[o];[]] t: InvariantCell } #[rustc_variance] -struct Covariant { //~ ERROR types=[[+];[];[]] +struct Covariant { //~ ERROR types=[[];[+];[]] t: A, u: fn() -> A } #[rustc_variance] -struct Contravariant { //~ ERROR types=[[-];[];[]] +struct Contravariant { //~ ERROR types=[[];[-];[]] t: fn(A) } #[rustc_variance] -enum Enum { //~ ERROR types=[[+, -, o];[];[]] +enum Enum { //~ ERROR types=[[];[+, -, o];[]] Foo(Covariant), Bar(Contravariant), Zed(Covariant,Contravariant)