[Sema] RuntimeMetadata: Verify that runtime attribute has a valid initializer

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -6810,6 +6810,21 @@ ERROR(invalid_decl_for_runtime_discoverable_attr,none,
 ERROR(duplicate_runtime_discoverable_attr,none,
       "duplicate runtime discoverable attribute", ())
 
+ERROR(runtime_attribute_requires_init,none,
+      "runtime attribute type %0 does not contain a required initializer"
+      " - init(attachedTo:)",
+      (DeclName))
+
+ERROR(runtime_attribute_type_failable_init,none,
+      "runtime attribute type initializer %0 cannot be failable", (DeclName))
+
+ERROR(runtime_attribute_type_requirement_not_accessible,none,
+      "%select{private|fileprivate|internal|public|open}0 %1 %2 cannot have "
+      "more restrictive access than its enclosing runtime attribute type %3 "
+      "(which is %select{private|fileprivate|internal|public|open}4)",
+      (AccessLevel, DescriptiveDeclKind, DeclName, Type, AccessLevel))
+
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
 

lib/Sema/TypeCheckAttr.cpp

@@ -3806,6 +3806,11 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
   attr->setInvalid();
 }
 
+static bool isMemberLessAccessibleThanType(NominalTypeDecl *typeDecl,
+                                           ValueDecl *member) {
+  return member->getFormalAccess() <
+         std::min(typeDecl->getFormalAccess(), AccessLevel::Public);
+}
 
 void AttributeChecker::visitPropertyWrapperAttr(PropertyWrapperAttr *attr) {
   auto nominal = dyn_cast<NominalTypeDecl>(D);
@@ -3829,11 +3834,6 @@ void AttributeChecker::visitTypeWrapperAttr(TypeWrapperAttr *attr) {
 
   auto &ctx = D->getASTContext();
 
-  auto isLessAccessibleThanType = [&](ValueDecl *decl) {
-    return decl->getFormalAccess() <
-           std::min(nominal->getFormalAccess(), AccessLevel::Public);
-  };
-
   enum class UnviabilityReason {
     Failable,
     InvalidWrappedSelfType,
@@ -3891,7 +3891,7 @@ void AttributeChecker::visitTypeWrapperAttr(TypeWrapperAttr *attr) {
       if (init->isFailable())
         nonViableInits[init].push_back(UnviabilityReason::Failable);
 
-      if (isLessAccessibleThanType(init))
+      if (isMemberLessAccessibleThanType(nominal, init))
         nonViableInits[init].push_back(UnviabilityReason::Inaccessible);
     }
 
@@ -4112,7 +4112,7 @@ void AttributeChecker::visitTypeWrapperAttr(TypeWrapperAttr *attr) {
               UnviabilityReason::InvalidStorageType);
         }
 
-        if (isLessAccessibleThanType(subscript))
+        if (isMemberLessAccessibleThanType(nominal, subscript))
           nonViableSubscripts[subscript].push_back(
               UnviabilityReason::Inaccessible);
       }
@@ -4198,7 +4198,7 @@ void AttributeChecker::visitTypeWrapperAttr(TypeWrapperAttr *attr) {
         if (!hasKeyPathType(storageKeyPathParam))
           diagnoseSubscript(subscript, UnviabilityReason::InvalidStorageType);
 
-        if (isLessAccessibleThanType(subscript))
+        if (isMemberLessAccessibleThanType(nominal, subscript))
           diagnoseSubscript(subscript, UnviabilityReason::Inaccessible);
       }
     }
@@ -7028,6 +7028,73 @@ void AttributeChecker::visitRuntimeMetadataAttr(RuntimeMetadataAttr *attr) {
     attr->setInvalid();
     return;
   }
+
+  auto nominal = dyn_cast<NominalTypeDecl>(D);
+  if (!nominal)
+    return;
+
+  enum class UnviabilityReason { Failable, Inaccessible };
+
+  llvm::SmallVector<ConstructorDecl *, 2> matchingInits;
+  llvm::SmallDenseMap<ConstructorDecl *, SmallVector<UnviabilityReason, 2>, 2>
+      nonViableInits;
+
+  // Check whether type marked as runtime attribute capable has an initializer
+  // with first parameter labeled as `attachedTo:`.
+  for (auto *member : nominal->getMembers()) {
+    auto *init = dyn_cast<ConstructorDecl>(member);
+    if (!init)
+      continue;
+
+    auto *params = init->getParameters();
+    if (!params || params->size() == 0)
+      continue;
+
+    if (params->get(0)->getArgumentName() != Ctx.Id_attachedTo)
+      continue;
+
+    matchingInits.push_back(init);
+
+    if (init->isFailable())
+      nonViableInits[init].push_back(UnviabilityReason::Failable);
+
+    if (isMemberLessAccessibleThanType(nominal, init))
+      nonViableInits[init].push_back(UnviabilityReason::Inaccessible);
+  }
+
+  // If there are no matching initializers, let's complain.
+  if (matchingInits.empty()) {
+    diagnose(nominal->getLoc(), diag::runtime_attribute_requires_init,
+             nominal->getName());
+    attr->setInvalid();
+    return;
+  }
+
+  // If there are matching initializers but none of them are viable.
+  if (matchingInits.size() - nonViableInits.size() == 0) {
+    for (const auto &entry : nonViableInits) {
+      auto *init = entry.first;
+
+      for (auto reason : entry.second) {
+        switch (reason) {
+        case UnviabilityReason::Failable:
+          diagnose(init, diag::runtime_attribute_type_failable_init,
+                   init->getName());
+          break;
+
+        case UnviabilityReason::Inaccessible:
+          diagnose(init,
+                   diag::runtime_attribute_type_requirement_not_accessible,
+                   init->getFormalAccess(), init->getDescriptiveKind(),
+                   init->getName(), nominal->getDeclaredType(),
+                   nominal->getFormalAccess());
+          break;
+        }
+      }
+    }
+
+    attr->setInvalid();
+  }
 }
 
 namespace {

test/type/runtime_discoverable_attrs.swift

@@ -14,6 +14,23 @@ struct OnlyPropsTest<B, V> {
   init(attachedTo: KeyPath<B, V>) {}
 }
 
+@runtimeMetadata
+struct NoInitAttr { // expected-error {{runtime attribute type 'NoInitAttr' does not contain a required initializer - init(attachedTo:)}}
+}
+
+@runtimeMetadata
+struct FailiableInit {
+  init?(attachedTo: Any) {} // expected-error {{runtime attribute type initializer 'init(attachedTo:)' cannot be failable}}
+}
+
+@runtimeMetadata
+public struct AccessMismatchInAttr {
+  private init(attachedTo: Any) {}
+  // expected-error@-1 {{private initializer 'init(attachedTo:)' cannot have more restrictive access than its enclosing runtime attribute type 'AccessMismatchInAttr' (which is public)}}
+  internal init<T>(attachedTo: T.Type, other: Int) {}
+  // expected-error@-1 {{internal initializer 'init(attachedTo:other:)' cannot have more restrictive access than its enclosing runtime attribute type 'AccessMismatchInAttr' (which is public)}}
+}
+
 @Flag("global") func gloabalFn() {}
 
 @runtimeMetadata