Skip to content

Commit 0c16428

Browse files
kavonkavon
committed
have TypeCheckType be specific about the generic type a noncopyable was used with.
This change causes explicit types written in the source language that substitute a noncopyable type for a type variable in a generic type to state that's what's wrong. For example: ``` // NEW: noncopyable type 'MO' cannot be used with generic type 'Dictionary<Key, Value>' yet // OLD: noncopyable type 'MO' cannot be used with generics yet let _: [MO : T] ```
1 parent f3b6b45 commit 0c16428

File tree

4 files changed

+86
-62
lines changed

4 files changed

+86
-62
lines changed

‎lib/Sema/TypeCheckType.cpp

Lines changed: 42 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -999,13 +999,14 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
999999
/// returns true iff an error diagnostic was emitted
10001000
static bool didDiagnoseMoveOnlyGenericArgs(ASTContext &ctx,
10011001
SourceLoc loc,
1002+
Type unboundTy,
10021003
ArrayRef<Type> genericArgs) {
10031004
bool didEmitDiag = false;
10041005
for (auto t: genericArgs) {
10051006
if (!t->isPureMoveOnly())
10061007
continue;
10071008

1008-
ctx.Diags.diagnose(loc, diag::noncopyable_generics, t);
1009+
ctx.Diags.diagnose(loc, diag::noncopyable_generics_specific, t, unboundTy);
10091010
didEmitDiag = true;
10101011
}
10111012

@@ -1033,8 +1034,9 @@ Type TypeResolution::applyUnboundGenericArguments(
10331034
bool skipRequirementsCheck = false;
10341035

10351036
// check for generic args that are move-only
1036-
if (didDiagnoseMoveOnlyGenericArgs(getASTContext(), loc, genericArgs))
1037-
return ErrorType::get(getASTContext());
1037+
auto &ctx = getASTContext();
1038+
if (didDiagnoseMoveOnlyGenericArgs(ctx, loc, resultType, genericArgs))
1039+
return ErrorType::get(ctx);
10381040

10391041
// Get the substitutions for outer generic parameters from the parent
10401042
// type.
@@ -2022,7 +2024,8 @@ namespace {
20222024
return diags.diagnose(std::forward<ArgTypes>(Args)...);
20232025
}
20242026

2025-
bool diagnoseMoveOnly(TypeRepr *repr, Type genericArgTy);
2027+
bool diagnoseMoveOnlyGeneric(TypeRepr *repr,
2028+
Type unboundTy, Type genericArgTy);
20262029
bool diagnoseMoveOnlyMissingOwnership(TypeRepr *repr,
20272030
TypeResolutionOptions options);
20282031

@@ -2276,10 +2279,17 @@ bool TypeResolver::diagnoseInvalidPlaceHolder(OpaqueReturnTypeRepr *repr) {
22762279
/// as an argument for type parameters.
22772280
///
22782281
/// returns true if an error diagnostic was emitted
2279-
bool TypeResolver::diagnoseMoveOnly(TypeRepr *repr, Type genericArgTy) {
2282+
bool TypeResolver::diagnoseMoveOnlyGeneric(TypeRepr *repr,
2283+
Type unboundTy,
2284+
Type genericArgTy) {
22802285
if (genericArgTy->isPureMoveOnly()) {
2281-
diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics,
2282-
genericArgTy);
2286+
if (unboundTy) {
2287+
diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics_specific,
2288+
genericArgTy, unboundTy);
2289+
} else {
2290+
diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics,
2291+
genericArgTy);
2292+
}
22832293
return true;
22842294
}
22852295
return false;
@@ -4364,8 +4374,11 @@ NeverNullType TypeResolver::resolveArrayType(ArrayTypeRepr *repr,
43644374
}
43654375

43664376
// do not allow move-only types in an array
4367-
if (diagnoseMoveOnly(repr, baseTy))
4377+
if (diagnoseMoveOnlyGeneric(repr,
4378+
ctx.getArrayDecl()->getDeclaredInterfaceType(),
4379+
baseTy)) {
43684380
return ErrorType::get(ctx);
4381+
}
43694382

43704383
return ArraySliceType::get(baseTy);
43714384
}
@@ -4405,28 +4418,33 @@ NeverNullType TypeResolver::resolveOptionalType(OptionalTypeRepr *repr,
44054418
TypeResolutionOptions options) {
44064419
TypeResolutionOptions elementOptions = options.withoutContext(true);
44074420
elementOptions.setContext(TypeResolverContext::ImmediateOptionalTypeArgument);
4421+
ASTContext &ctx = getASTContext();
44084422

44094423
auto baseTy = resolveType(repr->getBase(), elementOptions);
44104424
if (baseTy->hasError()) {
4411-
return ErrorType::get(getASTContext());
4425+
return ErrorType::get(ctx);
44124426
}
44134427

44144428
auto optionalTy = TypeChecker::getOptionalType(repr->getQuestionLoc(),
44154429
baseTy);
44164430
if (optionalTy->hasError()) {
4417-
return ErrorType::get(getASTContext());
4431+
return ErrorType::get(ctx);
44184432
}
44194433

44204434
// do not allow move-only types in an optional
4421-
if (diagnoseMoveOnly(repr, baseTy))
4422-
return ErrorType::get(getASTContext());
4435+
if (diagnoseMoveOnlyGeneric(repr,
4436+
ctx.getOptionalDecl()->getDeclaredInterfaceType(),
4437+
baseTy)) {
4438+
return ErrorType::get(ctx);
4439+
}
44234440

44244441
return optionalTy;
44254442
}
44264443

44274444
NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
44284445
ImplicitlyUnwrappedOptionalTypeRepr *repr, TypeResolutionOptions options,
44294446
bool isDirect) {
4447+
ASTContext &ctx = getASTContext();
44304448
TypeResolutionFlags allowIUO = TypeResolutionFlags::SILType;
44314449

44324450
bool doDiag = false;
@@ -4475,7 +4493,7 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
44754493

44764494
if (doDiag && !options.contains(TypeResolutionFlags::SilenceErrors)) {
44774495
// Prior to Swift 5, we allow 'as T!' and turn it into a disjunction.
4478-
if (getASTContext().isSwiftVersionAtLeast(5)) {
4496+
if (ctx.isSwiftVersionAtLeast(5)) {
44794497
// Mark this repr as invalid. This is the only way to indicate that
44804498
// something went wrong without supressing checking other reprs in
44814499
// the same type. For example:
@@ -4509,18 +4527,21 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
45094527

45104528
auto baseTy = resolveType(repr->getBase(), elementOptions);
45114529
if (baseTy->hasError()) {
4512-
return ErrorType::get(getASTContext());
4530+
return ErrorType::get(ctx);
45134531
}
45144532

45154533
auto uncheckedOptionalTy =
45164534
TypeChecker::getOptionalType(repr->getExclamationLoc(), baseTy);
45174535
if (uncheckedOptionalTy->hasError()) {
4518-
return ErrorType::get(getASTContext());
4536+
return ErrorType::get(ctx);
45194537
}
45204538

45214539
// do not allow move-only types in an implicitly-unwrapped optional
4522-
if (diagnoseMoveOnly(repr, baseTy))
4523-
return ErrorType::get(getASTContext());
4540+
if (diagnoseMoveOnlyGeneric(repr,
4541+
ctx.getOptionalDecl()->getDeclaredInterfaceType(),
4542+
baseTy)) {
4543+
return ErrorType::get(ctx);
4544+
}
45244545

45254546
return uncheckedOptionalTy;
45264547
}
@@ -4537,8 +4558,11 @@ NeverNullType TypeResolver::resolveVarargType(VarargTypeRepr *repr,
45374558
}
45384559

45394560
// do not allow move-only types as the element of a vararg
4540-
if (diagnoseMoveOnly(repr, element))
4561+
if (element->isPureMoveOnly()) {
4562+
diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics_variadic,
4563+
element);
45414564
return ErrorType::get(getASTContext());
4565+
}
45424566

45434567
return element;
45444568
}

‎test/Constraints/moveonly_constraints.swift

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -109,7 +109,7 @@ func checkBasicBoxes() {
109109
_ = rb.get()
110110
_ = rb.val
111111

112-
let vb2: ValBox<MO> = .init(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
112+
let vb2: ValBox<MO> = .init(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generic type 'ValBox<T>' yet}}
113113
}
114114

115115
func checkExistential() {
@@ -127,13 +127,13 @@ func checkExistential() {
127127
}
128128

129129
func checkMethodCalls() {
130-
let tg: NotStoredGenerically<MO> = NotStoredGenerically() // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
130+
let tg: NotStoredGenerically<MO> = NotStoredGenerically() // expected-error {{noncopyable type 'MO' cannot be used with generic type 'NotStoredGenerically<T>' yet}}
131131
tg.take(MO())
132132
tg.give()
133133

134-
let _: Maybe<MO> = .none // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
135-
let _ = Maybe<MO>.just(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
136-
let _: Maybe<MO> = .just(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
134+
let _: Maybe<MO> = .none // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Maybe<T>' yet}}
135+
let _ = Maybe<MO>.just(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Maybe<T>' yet}}
136+
let _: Maybe<MO> = .just(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Maybe<T>' yet}}
137137
takeMaybe(.just(MO())) // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
138138

139139
takeMaybe(true ? .none : .just(MO())) // expected-error 3{{noncopyable type 'MO' cannot be used with generics yet}}
@@ -142,7 +142,7 @@ func checkMethodCalls() {
142142
func checkCasting(_ b: any Box, _ mo: borrowing MO, _ a: Any) {
143143
// casting dynamically is allowed, but should always fail since you can't
144144
// construct such a type.
145-
let box = b as! ValBox<MO> // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
145+
let box = b as! ValBox<MO> // expected-error {{noncopyable type 'MO' cannot be used with generic type 'ValBox<T>' yet}}
146146
let dup = box
147147

148148
let _: MO = dup.get()
@@ -226,18 +226,18 @@ func checkCasting(_ b: any Box, _ mo: borrowing MO, _ a: Any) {
226226
}
227227

228228
func checkStdlibTypes(_ mo: borrowing MO) {
229-
let _: [MO] = // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
229+
let _: [MO] = // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
230230
[MO(), MO()]
231-
let _: [MO] = // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
231+
let _: [MO] = // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
232232
[]
233-
let _: [String: MO] = // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
233+
let _: [String: MO] = // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Dictionary<Key, Value>' yet}}
234234
["hello" : MO()] // expected-error{{tuples with noncopyable elements are not supported}}
235235

236236
// i think this one's only caught b/c of the 'Any' change
237237
_ = [MO()] // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
238238

239-
let _: Array<MO> = .init() // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
240-
_ = [MO]() // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
239+
let _: Array<MO> = .init() // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
240+
_ = [MO]() // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
241241

242242
let s: String = "hello \(mo)" // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
243243
}

‎test/Sema/moveonly_illegal_types.swift

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -47,33 +47,33 @@ struct CerebralValley<T> {
4747
// --- now some tests ---
4848
// ----------------------
4949

50-
func basic_vararg(_ va: MO...) {} // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
50+
func basic_vararg(_ va: MO...) {} // expected-error {{noncopyable type 'MO' cannot be used within a variadic type yet}}
5151

5252
func illegalTypes<T>(_ t: T) {
53-
let _: Array<MO> // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
54-
let _: Maybe<MO> // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
55-
let _: Dictionary<MO, String> // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
56-
let _: [MO] // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
57-
let _: [String : MO] // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
58-
let _: [MO : MO] // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
59-
let _: [MO : T] // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
60-
61-
_ = t as! ValBox<MO> // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
62-
63-
let _: Optional<MO> // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
64-
let _: MO? // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
65-
let _: MO?? // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
66-
let _: MO! // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
67-
let _: MO?! // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
53+
let _: Array<MO> // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
54+
let _: Maybe<MO> // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Maybe<T>' yet}}
55+
let _: Dictionary<MO, String> // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Dictionary<Key, Value>' yet}}
56+
let _: [MO] // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
57+
let _: [String : MO] // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Dictionary<Key, Value>' yet}}
58+
let _: [MO : MO] // expected-error 2{{noncopyable type 'MO' cannot be used with generic type 'Dictionary<Key, Value>' yet}}
59+
let _: [MO : T] // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Dictionary<Key, Value>' yet}}
60+
61+
_ = t as! ValBox<MO> // expected-error {{noncopyable type 'MO' cannot be used with generic type 'ValBox<T>' yet}}
62+
63+
let _: Optional<MO> // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Optional<Wrapped>' yet}}
64+
let _: MO? // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Optional<Wrapped>' yet}}
65+
let _: MO?? // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Optional<Wrapped>' yet}}
66+
let _: MO! // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Optional<Wrapped>' yet}}
67+
let _: MO?! // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Optional<Wrapped>' yet}}
6868

6969
let _: Klass & MO // expected-error {{non-protocol, non-class type 'MO' cannot be used within a protocol-constrained type}}
7070
let _: any MO // expected-error {{'any' has no effect on concrete type 'MO'}}
7171
let _: any GenericMO<T> // expected-error {{'any' has no effect on concrete type 'GenericMO<T>'}}
7272

73-
let _: CerebralValley<MO>.TechBro // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
74-
let _: CerebralValley<Int>.GenericBro<MO> // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
73+
let _: CerebralValley<MO>.TechBro // expected-error {{noncopyable type 'MO' cannot be used with generic type 'CerebralValley<T>' yet}}
74+
let _: CerebralValley<Int>.GenericBro<MO> // expected-error {{noncopyable type 'MO' cannot be used with generic type 'CerebralValley<T>.GenericBro<U>' yet}}
7575

76-
let _: GenericMO<MO> // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
76+
let _: GenericMO<MO> // expected-error {{noncopyable type 'MO' cannot be used with generic type 'GenericMO<T>' yet}}
7777
}
7878

7979
func illegalInExpr() {

‎test/Sema/moveonly_restrictions.swift

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -17,15 +17,15 @@ class MoveOnlyStruct {
1717

1818
class C {
1919
var copyable: CopyableKlass? = nil
20-
var moveOnlyC: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
21-
var moveOnlyS: MoveOnlyStruct? = nil // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generics yet}}
20+
var moveOnlyC: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'Optional<Wrapped>' yet}}
21+
var moveOnlyS: MoveOnlyStruct? = nil // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generic type 'Optional<Wrapped>' yet}}
2222
}
2323

2424
@_moveOnly
2525
class CMoveOnly {
2626
var copyable: CopyableKlass? = nil
27-
var moveOnlyC: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
28-
var moveOnlyS: MoveOnlyStruct? = nil // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generics yet}}
27+
var moveOnlyC: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'Optional<Wrapped>' yet}}
28+
var moveOnlyS: MoveOnlyStruct? = nil // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generic type 'Optional<Wrapped>' yet}}
2929
}
3030

3131
struct OptionalGrandField<T> { // expected-error {{generic struct 'OptionalGrandField' cannot contain a noncopyable type without also being noncopyable}}
@@ -34,8 +34,8 @@ struct OptionalGrandField<T> { // expected-error {{generic struct 'OptionalGrand
3434
}
3535

3636
struct S0 {
37-
var moveOnly3: OptionalGrandField<MoveOnlyKlass> // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
38-
var moveOnly4: OptionalGrandField<MoveOnlyStruct> // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generics yet}}
37+
var moveOnly3: OptionalGrandField<MoveOnlyKlass> // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'OptionalGrandField<T>' yet}}
38+
var moveOnly4: OptionalGrandField<MoveOnlyStruct> // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generic type 'OptionalGrandField<T>' yet}}
3939
}
4040

4141
struct SCopyable {
@@ -44,10 +44,10 @@ struct SCopyable {
4444

4545
struct S { // expected-error {{struct 'S' cannot contain a noncopyable type without also being noncopyable}}
4646
var copyable: CopyableKlass
47-
var moveOnly2: MoveOnlyStruct? // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generics yet}}
47+
var moveOnly2: MoveOnlyStruct? // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generic type 'Optional<Wrapped>' yet}}
4848
var moveOnly: MoveOnlyStruct // expected-note {{contained noncopyable property 'S.moveOnly'}}
49-
var moveOnly3: OptionalGrandField<MoveOnlyKlass> // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
50-
var moveOnly3: OptionalGrandField<MoveOnlyStruct> // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generics yet}}
49+
var moveOnly3: OptionalGrandField<MoveOnlyKlass> // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'OptionalGrandField<T>' yet}}
50+
var moveOnly3: OptionalGrandField<MoveOnlyStruct> // expected-error {{noncopyable type 'MoveOnlyStruct' cannot be used with generic type 'OptionalGrandField<T>' yet}}
5151
}
5252

5353
@_moveOnly
@@ -59,7 +59,7 @@ struct SMoveOnly {
5959
enum E { // expected-error {{enum 'E' cannot contain a noncopyable type without also being noncopyable}}
6060
case lhs(CopyableKlass)
6161
case rhs(MoveOnlyKlass) // expected-note {{contained noncopyable enum case 'E.rhs'}}
62-
case rhs2(OptionalGrandField<MoveOnlyKlass>) // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
62+
case rhs2(OptionalGrandField<MoveOnlyKlass>) // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'OptionalGrandField<T>' yet}}
6363
}
6464

6565
@_moveOnly
@@ -81,13 +81,13 @@ extension MoveOnlyStruct {
8181
func foo() {
8282
class C2 {
8383
var copyable: CopyableKlass? = nil
84-
var moveOnly: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
84+
var moveOnly: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'Optional<Wrapped>' yet}}
8585
}
8686

8787
@_moveOnly
8888
class C2MoveOnly {
8989
var copyable: CopyableKlass? = nil
90-
var moveOnly: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
90+
var moveOnly: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'Optional<Wrapped>' yet}}
9191
}
9292

9393
struct S2 { // expected-error {{struct 'S2' cannot contain a noncopyable type without also being noncopyable}}
@@ -114,13 +114,13 @@ func foo() {
114114
{
115115
class C3 {
116116
var copyable: CopyableKlass? = nil
117-
var moveOnly: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
117+
var moveOnly: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'Optional<Wrapped>' yet}}
118118
}
119119

120120
@_moveOnly
121121
class C3MoveOnly {
122122
var copyable: CopyableKlass? = nil
123-
var moveOnly: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generics yet}}
123+
var moveOnly: MoveOnlyKlass? = nil // expected-error {{noncopyable type 'MoveOnlyKlass' cannot be used with generic type 'Optional<Wrapped>' yet}}
124124
}
125125

126126
struct S3 { // expected-error {{struct 'S3' cannot contain a noncopyable type without also being noncopyable}}

0 commit comments

Comments
 (0)