Skip to content

Commit ada0d33

Browse files
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 e631205 commit ada0d33

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
@@ -1000,13 +1000,14 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
10001000
/// returns true iff an error diagnostic was emitted
10011001
static bool didDiagnoseMoveOnlyGenericArgs(ASTContext &ctx,
10021002
SourceLoc loc,
1003+
Type unboundTy,
10031004
ArrayRef<Type> genericArgs) {
10041005
bool didEmitDiag = false;
10051006
for (auto t: genericArgs) {
10061007
if (!t->isPureMoveOnly())
10071008
continue;
10081009

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

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

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

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

2026-
bool diagnoseMoveOnly(TypeRepr *repr, Type genericArgTy);
2028+
bool diagnoseMoveOnlyGeneric(TypeRepr *repr,
2029+
Type unboundTy, Type genericArgTy);
20272030
bool diagnoseMoveOnlyMissingOwnership(TypeRepr *repr,
20282031
TypeResolutionOptions options);
20292032

@@ -2277,10 +2280,17 @@ bool TypeResolver::diagnoseInvalidPlaceHolder(OpaqueReturnTypeRepr *repr) {
22772280
/// as an argument for type parameters.
22782281
///
22792282
/// returns true if an error diagnostic was emitted
2280-
bool TypeResolver::diagnoseMoveOnly(TypeRepr *repr, Type genericArgTy) {
2283+
bool TypeResolver::diagnoseMoveOnlyGeneric(TypeRepr *repr,
2284+
Type unboundTy,
2285+
Type genericArgTy) {
22812286
if (genericArgTy->isPureMoveOnly()) {
2282-
diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics,
2283-
genericArgTy);
2287+
if (unboundTy) {
2288+
diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics_specific,
2289+
genericArgTy, unboundTy);
2290+
} else {
2291+
diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics,
2292+
genericArgTy);
2293+
}
22842294
return true;
22852295
}
22862296
return false;
@@ -4365,8 +4375,11 @@ NeverNullType TypeResolver::resolveArrayType(ArrayTypeRepr *repr,
43654375
}
43664376

43674377
// do not allow move-only types in an array
4368-
if (diagnoseMoveOnly(repr, baseTy))
4378+
if (diagnoseMoveOnlyGeneric(repr,
4379+
ctx.getArrayDecl()->getDeclaredInterfaceType(),
4380+
baseTy)) {
43694381
return ErrorType::get(ctx);
4382+
}
43704383

43714384
return ArraySliceType::get(baseTy);
43724385
}
@@ -4406,28 +4419,33 @@ NeverNullType TypeResolver::resolveOptionalType(OptionalTypeRepr *repr,
44064419
TypeResolutionOptions options) {
44074420
TypeResolutionOptions elementOptions = options.withoutContext(true);
44084421
elementOptions.setContext(TypeResolverContext::ImmediateOptionalTypeArgument);
4422+
ASTContext &ctx = getASTContext();
44094423

44104424
auto baseTy = resolveType(repr->getBase(), elementOptions);
44114425
if (baseTy->hasError()) {
4412-
return ErrorType::get(getASTContext());
4426+
return ErrorType::get(ctx);
44134427
}
44144428

44154429
auto optionalTy = TypeChecker::getOptionalType(repr->getQuestionLoc(),
44164430
baseTy);
44174431
if (optionalTy->hasError()) {
4418-
return ErrorType::get(getASTContext());
4432+
return ErrorType::get(ctx);
44194433
}
44204434

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

44254442
return optionalTy;
44264443
}
44274444

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

44334451
bool doDiag = false;
@@ -4476,7 +4494,7 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
44764494

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

45114529
auto baseTy = resolveType(repr->getBase(), elementOptions);
45124530
if (baseTy->hasError()) {
4513-
return ErrorType::get(getASTContext());
4531+
return ErrorType::get(ctx);
45144532
}
45154533

45164534
auto uncheckedOptionalTy =
45174535
TypeChecker::getOptionalType(repr->getExclamationLoc(), baseTy);
45184536
if (uncheckedOptionalTy->hasError()) {
4519-
return ErrorType::get(getASTContext());
4537+
return ErrorType::get(ctx);
45204538
}
45214539

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

45264547
return uncheckedOptionalTy;
45274548
}
@@ -4538,8 +4559,11 @@ NeverNullType TypeResolver::resolveVarargType(VarargTypeRepr *repr,
45384559
}
45394560

45404561
// do not allow move-only types as the element of a vararg
4541-
if (diagnoseMoveOnly(repr, element))
4562+
if (element->isPureMoveOnly()) {
4563+
diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics_variadic,
4564+
element);
45424565
return ErrorType::get(getASTContext());
4566+
}
45434567

45444568
return element;
45454569
}

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)