Skip to content

Commit bf228ac

Browse files
aliemjayaliemjay
committed
don't eagerly normalize SelfCtor type
Delay until user annotations are registered. See the added test.
1 parent 030d60f commit bf228ac

File tree

8 files changed

+148
-36
lines changed

8 files changed

+148
-36
lines changed

‎Cargo.lock‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4134,7 +4134,6 @@ dependencies = [
41344134
name = "rustc_hir_typeck"
41354135
version = "0.1.0"
41364136
dependencies = [
4137-
"either",
41384137
"rustc_ast",
41394138
"rustc_data_structures",
41404139
"rustc_errors",

‎compiler/rustc_hir_typeck/Cargo.toml‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,6 @@ edition = "2021"
88
[dependencies]
99
smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
1010
tracing = "0.1"
11-
either = "1.5.0"
1211
rustc_ast = { path = "../rustc_ast" }
1312
rustc_data_structures = { path = "../rustc_data_structures" }
1413
rustc_errors = { path = "../rustc_errors" }

‎compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs‎

Lines changed: 20 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -392,6 +392,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
392392
ty.normalized
393393
}
394394

395+
pub(super) fn user_substs_for_adt(ty: RawTy<'tcx>) -> UserSubsts<'tcx> {
396+
match (ty.raw.kind(), ty.normalized.kind()) {
397+
(ty::Adt(_, substs), _) => UserSubsts { substs, user_self_ty: None },
398+
(_, ty::Adt(adt, substs)) => UserSubsts {
399+
substs,
400+
user_self_ty: Some(UserSelfTy { impl_def_id: adt.did(), self_ty: ty.raw }),
401+
},
402+
_ => bug!("non-adt type {:?}", ty),
403+
}
404+
}
405+
395406
pub fn array_length_to_const(&self, length: &hir::ArrayLen) -> ty::Const<'tcx> {
396407
match length {
397408
&hir::ArrayLen::Infer(_, span) => self.ct_infer(self.tcx.types.usize, None, span),
@@ -1082,20 +1093,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
10821093
.unwrap_or(false);
10831094

10841095
let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
1085-
let ty = tcx.at(span).type_of(impl_def_id);
1086-
let ty = self.normalize(span, ty);
1087-
match *ty.kind() {
1088-
ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
1089-
let variant = adt_def.non_enum_variant();
1090-
let (ctor_kind, ctor_def_id) = variant.ctor.unwrap();
1091-
(Res::Def(DefKind::Ctor(CtorOf::Struct, ctor_kind), ctor_def_id), Some(substs))
1096+
let ty = self.handle_raw_ty(span, tcx.at(span).type_of(impl_def_id));
1097+
match ty.normalized.ty_adt_def() {
1098+
Some(adt_def) if adt_def.has_ctor() => {
1099+
let (ctor_kind, ctor_def_id) = adt_def.non_enum_variant().ctor.unwrap();
1100+
let new_res = Res::Def(DefKind::Ctor(CtorOf::Struct, ctor_kind), ctor_def_id);
1101+
let user_substs = Self::user_substs_for_adt(ty);
1102+
user_self_ty = user_substs.user_self_ty;
1103+
(new_res, Some(user_substs.substs))
10921104
}
10931105
_ => {
10941106
let mut err = tcx.sess.struct_span_err(
10951107
span,
10961108
"the `Self` constructor can only be used with tuple or unit structs",
10971109
);
1098-
if let Some(adt_def) = ty.ty_adt_def() {
1110+
if let Some(adt_def) = ty.normalized.ty_adt_def() {
10991111
match adt_def.adt_kind() {
11001112
AdtKind::Enum => {
11011113
err.help("did you mean to use one of the enum's variants?");

‎compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs‎

Lines changed: 8 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -32,8 +32,6 @@ use rustc_span::symbol::{kw, Ident};
3232
use rustc_span::{self, sym, Span};
3333
use rustc_trait_selection::traits::{self, ObligationCauseCode, SelectionContext};
3434

35-
use either::Either;
36-
3735
use std::iter;
3836
use std::mem;
3937
use std::ops::ControlFlow;
@@ -1233,44 +1231,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
12331231
);
12341232
return None;
12351233
}
1236-
Res::Def(DefKind::Variant, _) => match (ty.raw.kind(), ty.normalized.kind()) {
1237-
(ty::Adt(adt, substs), _) => {
1238-
Some((adt.variant_of_res(def), adt.did(), substs, Either::Left(substs)))
1239-
}
1240-
(_, ty::Adt(adt, substs)) => {
1241-
Some((adt.variant_of_res(def), adt.did(), substs, Either::Right(ty.raw)))
1234+
Res::Def(DefKind::Variant, _) => match ty.normalized.ty_adt_def() {
1235+
Some(adt) => {
1236+
Some((adt.variant_of_res(def), adt.did(), Self::user_substs_for_adt(ty)))
12421237
}
12431238
_ => bug!("unexpected type: {:?}", ty.normalized),
12441239
},
12451240
Res::Def(DefKind::Struct | DefKind::Union | DefKind::TyAlias | DefKind::AssocTy, _)
12461241
| Res::SelfTyParam { .. }
1247-
| Res::SelfTyAlias { .. } => match (ty.raw.kind(), ty.normalized.kind()) {
1248-
(ty::Adt(adt, substs), _) if !adt.is_enum() => {
1249-
Some((adt.non_enum_variant(), adt.did(), substs, Either::Left(substs)))
1250-
}
1251-
(_, ty::Adt(adt, substs)) if !adt.is_enum() => {
1252-
Some((adt.non_enum_variant(), adt.did(), substs, Either::Right(ty.raw)))
1242+
| Res::SelfTyAlias { .. } => match ty.normalized.ty_adt_def() {
1243+
Some(adt) if !adt.is_enum() => {
1244+
Some((adt.non_enum_variant(), adt.did(), Self::user_substs_for_adt(ty)))
12531245
}
12541246
_ => None,
12551247
},
12561248
_ => bug!("unexpected definition: {:?}", def),
12571249
};
12581250

1259-
if let Some((variant, did, substs, user_annotation)) = variant {
1251+
if let Some((variant, did, ty::UserSubsts { substs, user_self_ty })) = variant {
12601252
debug!("check_struct_path: did={:?} substs={:?}", did, substs);
12611253

12621254
// Register type annotation.
1263-
self.probe(|_| {
1264-
// UserSubsts and UserSelfTy are mutually exclusive here.
1265-
let (user_substs, self_ty) = match user_annotation {
1266-
Either::Left(substs) => (*substs, None),
1267-
Either::Right(self_ty) => {
1268-
(self.fresh_substs_for_item(path_span, did), Some(self_ty))
1269-
}
1270-
};
1271-
let self_ty = self_ty.map(|self_ty| ty::UserSelfTy { impl_def_id: did, self_ty });
1272-
self.write_user_type_annotation_from_substs(hir_id, did, user_substs, self_ty);
1273-
});
1255+
self.write_user_type_annotation_from_substs(hir_id, did, substs, user_self_ty);
12741256

12751257
// Check bounds on type arguments used in the path.
12761258
self.add_required_obligations_for_hir(path_span, did, substs, hir_id);

‎src/test/ui/nll/user-annotations/normalization-default.rs‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
// check-fail
2+
3+
trait Trait { type Assoc; }
4+
impl<'a> Trait for &'a () { type Assoc = &'a (); }
5+
6+
struct MyTuple<T, U = <&'static () as Trait>::Assoc>(T, U);
7+
fn test_tuple(x: &(), y: &()) {
8+
MyTuple::<_>((), x);
9+
//~^ ERROR
10+
let _: MyTuple::<_> = MyTuple((), y);
11+
//~^ ERROR
12+
}
13+
14+
struct MyStruct<T, U = <&'static () as Trait>::Assoc> { val: (T, U), }
15+
fn test_struct(x: &(), y: &()) {
16+
MyStruct::<_> { val: ((), x) };
17+
//~^ ERROR
18+
let _: MyStruct::<_> = MyStruct { val: ((), y) };
19+
//~^ ERROR
20+
}
21+
22+
fn main() {}

‎src/test/ui/nll/user-annotations/normalization-default.stderr‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
error: lifetime may not live long enough
2+
--> $DIR/normalization-default.rs:8:22
3+
|
4+
LL | fn test_tuple(x: &(), y: &()) {
5+
| - let's call the lifetime of this reference `'1`
6+
LL | MyTuple::<_>((), x);
7+
| ^ this usage requires that `'1` must outlive `'static`
8+
9+
error: lifetime may not live long enough
10+
--> $DIR/normalization-default.rs:10:12
11+
|
12+
LL | fn test_tuple(x: &(), y: &()) {
13+
| - let's call the lifetime of this reference `'2`
14+
...
15+
LL | let _: MyTuple::<_> = MyTuple((), y);
16+
| ^^^^^^^^^^^^ type annotation requires that `'2` must outlive `'static`
17+
18+
error: lifetime may not live long enough
19+
--> $DIR/normalization-default.rs:16:26
20+
|
21+
LL | fn test_struct(x: &(), y: &()) {
22+
| - let's call the lifetime of this reference `'1`
23+
LL | MyStruct::<_> { val: ((), x) };
24+
| ^^^^^^^ this usage requires that `'1` must outlive `'static`
25+
26+
error: lifetime may not live long enough
27+
--> $DIR/normalization-default.rs:18:12
28+
|
29+
LL | fn test_struct(x: &(), y: &()) {
30+
| - let's call the lifetime of this reference `'2`
31+
...
32+
LL | let _: MyStruct::<_> = MyStruct { val: ((), y) };
33+
| ^^^^^^^^^^^^^ type annotation requires that `'2` must outlive `'static`
34+
35+
error: aborting due to 4 previous errors
36+

‎src/test/ui/nll/user-annotations/normalization-self.rs‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
// check-fail
2+
3+
trait Trait { type Assoc; }
4+
impl<'a> Trait for &'a () { type Assoc = &'a (); }
5+
6+
struct MyTuple<T>(T);
7+
impl MyTuple<<&'static () as Trait>::Assoc> {
8+
fn test(x: &(), y: &()) {
9+
Self(x);
10+
//~^ ERROR
11+
let _: Self = MyTuple(y);
12+
//~^ ERROR
13+
}
14+
}
15+
16+
struct MyStruct<T> { val: T, }
17+
impl MyStruct<<&'static () as Trait>::Assoc> {
18+
fn test(x: &(), y: &()) {
19+
Self { val: x };
20+
//~^ ERROR
21+
let _: Self = MyStruct { val: y };
22+
//~^ ERROR
23+
}
24+
}
25+
26+
fn main() {}

‎src/test/ui/nll/user-annotations/normalization-self.stderr‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
error: lifetime may not live long enough
2+
--> $DIR/normalization-self.rs:9:14
3+
|
4+
LL | fn test(x: &(), y: &()) {
5+
| - let's call the lifetime of this reference `'1`
6+
LL | Self(x);
7+
| ^ this usage requires that `'1` must outlive `'static`
8+
9+
error: lifetime may not live long enough
10+
--> $DIR/normalization-self.rs:11:16
11+
|
12+
LL | fn test(x: &(), y: &()) {
13+
| - let's call the lifetime of this reference `'2`
14+
...
15+
LL | let _: Self = MyTuple(y);
16+
| ^^^^ type annotation requires that `'2` must outlive `'static`
17+
18+
error: lifetime may not live long enough
19+
--> $DIR/normalization-self.rs:19:21
20+
|
21+
LL | fn test(x: &(), y: &()) {
22+
| - let's call the lifetime of this reference `'1`
23+
LL | Self { val: x };
24+
| ^ this usage requires that `'1` must outlive `'static`
25+
26+
error: lifetime may not live long enough
27+
--> $DIR/normalization-self.rs:21:16
28+
|
29+
LL | fn test(x: &(), y: &()) {
30+
| - let's call the lifetime of this reference `'2`
31+
...
32+
LL | let _: Self = MyStruct { val: y };
33+
| ^^^^ type annotation requires that `'2` must outlive `'static`
34+
35+
error: aborting due to 4 previous errors
36+

0 commit comments

Comments
 (0)