[Sema] TypeWrappers: Introduce a Wrapped type parameter requirement

xedin · xedin · commit 5f2cd38d93ae · 2022-10-21T20:04:01.000+01:00
This parameter should be the first in the list of generic parameters.
`for: Wrapped.Type` parameter is added to a required initializer.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -6591,18 +6591,27 @@ ERROR(type_wrapper_attribute_not_allowed_here,none,
       "type wrapper attribute %0 can only be applied to a class, struct",
       (Identifier))
 
-ERROR(type_wrapper_requires_a_single_generic_param,none,
-      "type wrapper has to declare a single generic parameter "
-      "for underlying storage type", ())
+ERROR(type_wrapper_requires_two_generic_params,none,
+      "type wrapper has to declare two generic parameters: "
+      "wrapped and storage types", ())
 
 ERROR(cannot_use_multiple_type_wrappers,none,
       "type %0 cannot use more than one type wrapper", ())
 
 ERROR(type_wrapper_requires_memberwise_init,none,
       "type wrapper type %0 does not contain a required initializer"
-      " - init(storage:)",
+      " - init(for:storage:)",
       (DeclName))
 
+ERROR(cannot_overload_type_wrapper_initializer,none,
+      "cannot overload type wrapper initializer 'init(for:storage:)'", ())
+
+ERROR(cannot_declare_type_wrapper_init_with_invalid_first_param,none,
+      "first parameter of type wrapper initializer should be wrapped type - %0", (Type))
+
+ERROR(cannot_declare_type_wrapper_init_with_invalid_second_param,none,
+      "second parameter of type wrapper initializer should be storage type - %0", (Type))
+
 ERROR(type_wrapper_requires_subscript,none,
       "type wrapper type %0 does not contain a required subscript"
       " - subscript(storedKeyPath:)",
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -3750,25 +3750,25 @@ void AttributeChecker::visitTypeWrapperAttr(TypeWrapperAttr *attr) {
 
   // Check whether type marked as @typeWrapper is valid:
   //
-  // - Has a single generic parameter <Storage>
-  // - Has `init(storage: <Storage>)`
+  // - Has two generic parameters - `Wrapped` and `Storage`
+  // - Has `init(for: <Wrapped>.Type, storage: <Storage>)`
   // - Has at least one `subscript(storedKeyPath: KeyPath<...>)` overload
 
   // Has a single generic parameter.
+  auto *genericParams = nominal->getGenericParams();
   {
-    auto *genericParams = nominal->getGenericParams();
-    if (!genericParams || genericParams->size() != 1) {
+    if (!genericParams || genericParams->size() != 2) {
       diagnose(nominal->getLoc(),
-               diag::type_wrapper_requires_a_single_generic_param);
+               diag::type_wrapper_requires_two_generic_params);
       attr->setInvalid();
       return;
     }
   }
 
-  // `init(storage:)`
+  // `init(for:storage:)`
   {
     DeclName initName(ctx, DeclBaseName::createConstructor(),
-                      ArrayRef<Identifier>(ctx.Id_storage));
+                      {ctx.Id_for, ctx.Id_storage});
 
     SmallVector<ValueDecl *, 2> inits;
     if (findMembersOrDiagnose(initName, inits,
@@ -3787,8 +3787,11 @@ void AttributeChecker::visitTypeWrapperAttr(TypeWrapperAttr *attr) {
         nonViableInits[init].push_back(UnviabilityReason::Inaccessible);
     }
 
-    // If there are no viable initializers, let's complain.
-    if (inits.size() - nonViableInits.size() == 0) {
+    unsigned numViable = inits.size() - nonViableInits.size();
+
+    switch (numViable) {
+    case 0: {
+      // If there are no viable initializers, let's complain.
       for (const auto &entry : nonViableInits) {
         auto *init = entry.first;
 
@@ -3814,6 +3817,61 @@ void AttributeChecker::visitTypeWrapperAttr(TypeWrapperAttr *attr) {
       attr->setInvalid();
       return;
     }
+
+    case 1: {
+      // If there is only one choice let's check whether it's correct.
+      for (auto *decl : inits) {
+        auto *ctor = cast<ConstructorDecl>(decl);
+
+        if (nonViableInits.count(ctor))
+          continue;
+
+        auto wrappedType = ctor->getParameters()->get(0)->getInterfaceType();
+        auto storageType = ctor->getParameters()->get(1)->getInterfaceType();
+
+        auto typeWrapperGenericParams = genericParams->getParams();
+
+        // Let's check wrapped type - it should be a metatype of the first
+        // generic parameter - <Wrapped>.
+        {
+          auto wrappedTypeParamTy =
+              typeWrapperGenericParams[0]->getInterfaceType();
+          if (!wrappedType->isEqual(wrappedTypeParamTy)) {
+            diagnose(
+                ctor,
+                diag::cannot_declare_type_wrapper_init_with_invalid_first_param,
+                wrappedTypeParamTy);
+            ctor->setInvalid();
+          }
+        }
+
+        // Second parameter should be <Storage> generic parameter type.
+        {
+          auto storageTypeParamTy = typeWrapperGenericParams[1]
+                                        ->getInterfaceType()
+                                        ->getMetatypeInstanceType();
+          if (!storageType->isEqual(storageTypeParamTy)) {
+            diagnose(
+                ctor,
+                diag::
+                    cannot_declare_type_wrapper_init_with_invalid_second_param,
+                storageTypeParamTy);
+            ctor->setInvalid();
+          }
+        }
+
+        if (ctor->isInvalid()) {
+          attr->setInvalid();
+          return;
+        }
+      }
+      break;
+    }
+
+    default:
+      diagnose(inits.front(), diag::cannot_overload_type_wrapper_initializer);
+      return;
+    }
   }
 
   // subscript(storedKeypath: KeyPath<...>)
diff --git a/test/type/type_wrapper.swift b/test/type/type_wrapper.swift
@@ -3,43 +3,43 @@
 // REQUIRES: asserts
 
 @typeWrapper
-struct ConcreteTypeWrapper { // expected-error {{type wrapper has to declare a single generic parameter for underlying storage type}}
+struct ConcreteTypeWrapper { // expected-error {{type wrapper has to declare two generic parameters: wrapped and storage types}}
   init(storage: Int) {}
 }
 
 @typeWrapper
-struct EmptyTypeWrapper<S> { // expected-error {{type wrapper type 'EmptyTypeWrapper' does not contain a required initializer - init(storage:)}}
+struct EmptyTypeWrapper<W, S> { // expected-error {{type wrapper type 'EmptyTypeWrapper' does not contain a required initializer - init(for:storage:)}}
 }
 
 @typeWrapper
-struct NoMemberwiseInit<S> {
-  // expected-error@-1 {{type wrapper type 'NoMemberwiseInit' does not contain a required initializer - init(storage:)}}
+struct NoMemberwiseInit<W, S> {
+  // expected-error@-1 {{type wrapper type 'NoMemberwiseInit' does not contain a required initializer - init(for:storage:)}}
 
   subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
     get { fatalError() }
   }
 }
 
 @typeWrapper
-struct FailableInit<S> {
-  init?(storage: S) { // expected-error {{type wrapper initializer 'init(storage:)' cannot be failable}}
+struct FailableInit<W, S> {
+  init?(for: W.Type, storage: S) { // expected-error {{type wrapper initializer 'init(for:storage:)' cannot be failable}}
   }
 
   subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
     get { fatalError() }
   }
 }
 
-// Okay because there is a valid `init(storage:)` overload.
+// Okay because there is a valid `init(for:storage:)` overload.
 @typeWrapper
-struct FailableAndValidInit<S> {
+struct FailableAndValidInit<W, S> {
   // expected-error@-1 {{type wrapper type 'FailableAndValidInit' does not contain a required writable subscript}}
-  // expected-note@-2 {{do you want to add a stub?}} {{33-33=\nsubscript<Value>(storageKeyPath path: WritableKeyPath<<#Base#>, Value>) -> Value { get { <#code#> \} set { <#code#> \} \}}}
+  // expected-note@-2 {{do you want to add a stub?}} {{36-36=\nsubscript<Value>(storageKeyPath path: WritableKeyPath<<#Base#>, Value>) -> Value { get { <#code#> \} set { <#code#> \} \}}}
 
-  init(storage: S) {
+  init(for: W.Type, storage: S) {
   }
 
-  init?(storage: S) where S == Int {
+  init?(for: W.Type, storage: S) where S == Int {
   }
 
   subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
@@ -48,14 +48,14 @@ struct FailableAndValidInit<S> {
 }
 
 @typeWrapper
-public struct InaccessibleInit<S> {
-  fileprivate init(storage: S) {
-    // expected-error@-1 {{fileprivate initializer 'init(storage:)' cannot have more restrictive access than its enclosing type wrapper type 'InaccessibleInit' (which is public)}}
+public struct InaccessibleInit<W, S> {
+  fileprivate init(for: W.Type, storage: S) {
+    // expected-error@-1 {{fileprivate initializer 'init(for:storage:)' cannot have more restrictive access than its enclosing type wrapper type 'InaccessibleInit' (which is public)}}
   }
 
-  private init?(storage: S) where S: AnyObject {
-    // expected-error@-1 {{private initializer 'init(storage:)' cannot have more restrictive access than its enclosing type wrapper type 'InaccessibleInit' (which is public)}}
-    // expected-error@-2 {{type wrapper initializer 'init(storage:)' cannot be failable}}
+  private init?(for: W.Type, storage: S) where S: AnyObject {
+    // expected-error@-1 {{private initializer 'init(for:storage:)' cannot have more restrictive access than its enclosing type wrapper type 'InaccessibleInit' (which is public)}}
+    // expected-error@-2 {{type wrapper initializer 'init(for:storage:)' cannot be failable}}
   }
 
   subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
@@ -64,14 +64,14 @@ public struct InaccessibleInit<S> {
 }
 
 @typeWrapper
-struct NoSubscripts<S> {
+struct NoSubscripts<W, S> {
   // expected-error@-1 {{type wrapper type 'NoSubscripts' does not contain a required subscript - subscript(storedKeyPath:)}}
-  init(storage: S) {}
+  init(for: W.Type, storage: S) {}
 }
 
 @typeWrapper
-struct InaccessibleOrInvalidSubscripts<S> {
-  init(storage: S) {}
+struct InaccessibleOrInvalidSubscripts<W, S> {
+  init(for: W.Type, storage: S) {}
 
   fileprivate subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
     // expected-error@-1 {{fileprivate subscript 'subscript(storageKeyPath:)' cannot have more restrictive access than its enclosing type wrapper type 'InaccessibleOrInvalidSubscripts' (which is internal)}}
@@ -94,8 +94,54 @@ struct InaccessibleOrInvalidSubscripts<S> {
 }
 
 @typeWrapper
-struct NoopWrapper<S> {
-  init(storage: S) {}
+struct OverloadedCtorWrapper<W, S> {
+  init(for: W.Type, storage: S) {} // expected-error {{cannot overload type wrapper initializer 'init(for:storage:)'}}
+  init(for: W.Type, storage: Int) {}
+
+  subscript<V>(storageKeyPath path: KeyPath<S, V>) -> [V] { get { fatalError() } }
+  subscript<V>(storageKeyPath path: WritableKeyPath<S, V>) -> [V] {
+    get { fatalError() }
+    set { }
+  }
+}
+
+do {
+  @typeWrapper
+  struct InvalidInit1<W, S> {
+    init(for: Int, storage: S) {} // expected-error {{first parameter of type wrapper initializer should be wrapped type - 'W.Type'}}
+  }
+
+  @typeWrapper
+  struct InvalidInit2<W, S> {
+    init(for: W, storage: S) {} // expected-error {{first parameter of type wrapper initializer should be wrapped type - 'W.Type'}}
+  }
+
+  @typeWrapper
+  struct InvalidInit3<W, S> {
+    init(for: Int.Type, storage: S) {} // expected-error {{first parameter of type wrapper initializer should be wrapped type - 'W.Type'}}
+  }
+
+  @typeWrapper
+  struct InvalidInit4<W, S> {
+    init(for: W.Type, storage: Int) {} // expected-error {{second parameter of type wrapper initializer should be storage type - 'S'}}
+  }
+
+  @typeWrapper
+  struct InvalidInit5<W, S> {
+    init(for: W.Type, storage: UnknownType) {} // expected-error {{second parameter of type wrapper initializer should be storage type - 'S'}}
+    // expected-error@-1 {{cannot find type 'UnknownType' in scope}}
+  }
+
+  @typeWrapper
+  struct InvalidInit6<W, S> {
+    init(for: UnknownType.Type, storage: S) {} // expected-error {{first parameter of type wrapper initializer should be wrapped type - 'W.Type'}}
+    // expected-error@-1 {{cannot find type 'UnknownType' in scope}}
+  }
+}
+
+@typeWrapper
+struct NoopWrapper<W, S> {
+  init(for: W.Type, storage: S) {}
 
   subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
     get { fatalError() }
@@ -137,8 +183,8 @@ func testWrappedTypeAccessChecking() {
 
 struct Parent {
   @typeWrapper
-  struct Wrapper<S> {
-    init(storage: S) {}
+  struct Wrapper<W, S> {
+    init(for: W.Type, storage: S) {}
 
     subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
       get { fatalError() }
@@ -456,11 +502,11 @@ func testIgnoredAttr() {
 
 func testMissingReadOnlyAndWritableSubscriptsAreDiagnosed() {
   @typeWrapper
-  struct MissingReadOnly<S> {
+  struct MissingReadOnly<W, S> {
     // expected-error@-1 {{type wrapper type 'MissingReadOnly' does not contain a required ready-only subscript}}
-    // expected-note@-2 {{do you want to add a stub?}} {{30-30=\nsubscript<Value>(storageKeyPath path: KeyPath<<#Base#>, Value>) -> Value { get { <#code#> \} \}}}
+    // expected-note@-2 {{do you want to add a stub?}} {{33-33=\nsubscript<Value>(storageKeyPath path: KeyPath<<#Base#>, Value>) -> Value { get { <#code#> \} \}}}
 
-    init(storage: S) {}
+    init(for: W.Type, storage: S) {}
 
     subscript<V>(storageKeyPath path: WritableKeyPath<S, V>) -> V {
       get { fatalError() }
@@ -469,11 +515,11 @@ func testMissingReadOnlyAndWritableSubscriptsAreDiagnosed() {
   }
 
   @typeWrapper
-  struct MissingWritable<S> {
+  struct MissingWritable<W, S> {
     // expected-error@-1 {{type wrapper type 'MissingWritable' does not contain a required writable subscript}}
-    // expected-note@-2 {{do you want to add a stub?}} {{30-30=\nsubscript<Value>(storageKeyPath path: WritableKeyPath<<#Base#>, Value>) -> Value { get { <#code#> \} set { <#code#> \} \}}}
+    // expected-note@-2 {{do you want to add a stub?}} {{33-33=\nsubscript<Value>(storageKeyPath path: WritableKeyPath<<#Base#>, Value>) -> Value { get { <#code#> \} set { <#code#> \} \}}}
 
-    init(storage: S) {}
+    init(for: W.Type, storage: S) {}
 
     subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
       get { fatalError() }
