[Sema] RuntimeMetadata: Diagnose missing explicit reflection metadata attributes

Diagnose situations where a sub-class or a protocol do not have all
of the reflection metadata attributes required by a superclass.

Resolves: rdar://103990788

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -6949,6 +6949,17 @@ NOTE(missing_reflection_metadata_attribute_on_type,none,
      "protocol %0 requires reflection metadata attribute @%1",
      (DeclName, StringRef))
 
+ERROR(missing_reflection_metadata_attribute_on_subclass,none,
+      "superclass %0 requires reflection metadata attribute @%1",
+      (DeclName, StringRef))
+NOTE(add_missing_reflection_metadata_attr,none,
+     "add missing reflection metadata attribute @%0", (StringRef))
+NOTE(opt_out_from_missing_reflection_metadata_attr,none,
+     "opt-out of reflection metadata attribute @%0 using"
+     " unavailable extension",
+     (StringRef))
+
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
 

lib/AST/ASTPrinter.cpp

@@ -2965,12 +2965,6 @@ static bool usesFeatureTypeWrappers(Decl *decl) {
 }
 
 static bool usesFeatureRuntimeDiscoverableAttrs(Decl *decl) {
-  if (decl->getAttrs().hasAttribute<RuntimeMetadataAttr>())
-    return true;
-
-  if (auto *VD = dyn_cast<ValueDecl>(decl))
-    return !VD->getRuntimeDiscoverableAttrs().empty();
-
   return false;
 }
 

lib/Sema/TypeCheckAttr.cpp

@@ -7149,7 +7149,16 @@ void AttributeChecker::visitCompilerInitializedAttr(
 }
 
 void AttributeChecker::visitRuntimeMetadataAttr(RuntimeMetadataAttr *attr) {
-  if (!Ctx.LangOpts.hasFeature(Feature::RuntimeDiscoverableAttrs)) {
+  auto isEnabled = [&]() {
+    if (Ctx.LangOpts.hasFeature(Feature::RuntimeDiscoverableAttrs))
+      return true;
+
+    // Accept attributes that come from swiftinterface files.
+    auto *parentSF = D->getDeclContext()->getParentSourceFile();
+    return parentSF && parentSF->Kind == SourceFileKind::Interface;
+  };
+
+  if (!isEnabled()) {
     diagnose(attr->getLocation(),
              diag::runtime_discoverable_attrs_are_experimental);
     attr->setInvalid();
@@ -7453,7 +7462,7 @@ ValueDecl *RenamedDeclRequest::evaluate(Evaluator &evaluator,
 
 template <typename ATTR>
 static void forEachCustomAttribute(
-    ValueDecl *decl,
+    Decl *decl,
     llvm::function_ref<void(CustomAttr *attr, NominalTypeDecl *)> fn) {
   auto &ctx = decl->getASTContext();
 
@@ -7513,6 +7522,57 @@ GetRuntimeDiscoverableAttributes::evaluate(Evaluator &evaluator,
     return copy;
   };
 
+  // Verify that a subclass or a protocol has all of the reflection
+  // metadata attributes expected by the superclass.
+  auto verifySuperclassAttrRequirements = [&](NominalTypeDecl *typeDecl,
+                                              ClassDecl *superclass) {
+    auto attrRequirements = superclass->getRuntimeDiscoverableAttrs();
+    if (attrRequirements.empty())
+      return;
+
+    // All of the reflection metadata attributes declared in
+    // unavailable extensions of this type in the same module.
+    llvm::SmallPtrSet<NominalTypeDecl *, 4> unavailableAttrs;
+    for (auto *extension : typeDecl->getExtensions()) {
+      if (extension->isConstrainedExtension() ||
+          extension->getParentModule() != typeDecl->getParentModule())
+        continue;
+
+      forEachCustomAttribute<RuntimeMetadataAttr>(
+          extension, [&](CustomAttr *attr, NominalTypeDecl *attrDecl) {
+            unavailableAttrs.insert(attrDecl);
+          });
+    }
+
+    for (auto *attr : attrRequirements) {
+      auto *attrDecl = superclass->getRuntimeDiscoverableAttrTypeDecl(attr);
+      if (attrs.count(attrDecl) || unavailableAttrs.count(attrDecl))
+        continue;
+
+      std::string attrName = attrDecl->getNameStr().str();
+      std::string subclassName = typeDecl->getNameStr().str();
+
+      ctx.Diags.diagnose(
+          typeDecl, diag::missing_reflection_metadata_attribute_on_subclass,
+          superclass->getName(), attrName);
+
+      ctx.Diags
+          .diagnose(typeDecl, diag::add_missing_reflection_metadata_attr,
+                    attrName)
+          .fixItInsert(
+              typeDecl->getAttributeInsertionLoc(/*forModifier=*/false),
+              "@" + attrName + " ");
+
+      ctx.Diags
+          .diagnose(typeDecl,
+                    diag::opt_out_from_missing_reflection_metadata_attr,
+                    attrName)
+          .fixItInsertAfter(typeDecl->getEndLoc(),
+                            "\n\n@available(*, unavailable)\n@" + attrName +
+                                " extension " + subclassName + " {}\n");
+    }
+  };
+
   // Gather reflection metadata attributes only if this extension is:
   //  - unavailable;
   //  - unconstrained;
@@ -7530,10 +7590,18 @@ GetRuntimeDiscoverableAttributes::evaluate(Evaluator &evaluator,
   gatherRuntimeAttrsOnDecl(decl, attrs, GatheringMode::Direct);
 
   auto *NTD = dyn_cast<NominalTypeDecl>(decl);
-  // Attribute inference is only possible from protocol conformances.
-  if (!NTD || isa<ProtocolDecl>(NTD) || NTD->getDeclContext()->isLocalContext())
+  if (!NTD || NTD->getDeclContext()->isLocalContext())
     return copyAttrs(attrs);
 
+  // If this is a protocol, let's check whether superclass
+  // has any reflection metadata attribute requirements.
+  if (auto *protocol = dyn_cast<ProtocolDecl>(NTD)) {
+    if (auto *superclass = protocol->getSuperclassDecl())
+      verifySuperclassAttrRequirements(NTD, superclass);
+
+    return copyAttrs(attrs);
+  }
+
   // Gather any attributes inferred from (explicit) protocol conformances
   // associated with the declaration of the type.
   for (unsigned i : indices(NTD->getInherited())) {
@@ -7551,6 +7619,12 @@ GetRuntimeDiscoverableAttributes::evaluate(Evaluator &evaluator,
     gatherRuntimeAttrsOnDecl(protocol, attrs, GatheringMode::Inference);
   }
 
+  // Check superclass attribute requirements after inference.
+  if (auto *classDecl = dyn_cast<ClassDecl>(NTD)) {
+    if (auto *superclass = classDecl->getSuperclassDecl())
+      verifySuperclassAttrRequirements(NTD, superclass);
+  }
+
   return copyAttrs(attrs);
 }
 

test/ModuleInterface/custom_reflection_metadata_attr.swift

@@ -0,0 +1,27 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-emit-module-interface(%t/ReflectionMetadata.swiftinterface) %s -module-name CRM -enable-experimental-feature RuntimeDiscoverableAttrs
+// RUN: %target-swift-typecheck-module-from-interface(%t/ReflectionMetadata.swiftinterface) -module-name CRM
+// RUN: %FileCheck %s < %t/ReflectionMetadata.swiftinterface
+
+// REQUIRES: asserts
+
+@runtimeMetadata
+public struct Flag {
+  public init<T>(attachedTo: T) {}
+}
+
+@Flag
+public class BaseClass {}
+
+// CHECK: public class TestClass : CRM.BaseClass
+
+public class TestClass : BaseClass {}
+
+// CHECK: @available(*, unavailable)
+// CHECK-NEXT: @Flag extension CRM.TestClass {
+// CHECK-NEXT: }
+
+@available(*, unavailable)
+@Flag
+public extension TestClass {
+}

test/SILGen/Inputs/runtime_metadata_defs.swift

@@ -8,3 +8,14 @@ public struct Ignore {
 
 @Ignore
 public protocol Ignorable {}
+
+public class Base : Ignorable {
+  public init() {}
+}
+
+public class Child : Base {
+}
+
+@available(*, unavailable)
+@Ignore
+extension Child {}

test/SILGen/runtime_attributes.swift

@@ -105,3 +105,6 @@ struct TestSelfUse {
   // CHECK-NEXT: {{.*}} = apply [[FLAG_INIT_REF]]<String, (TestSelfUse) -> ()>({{.*}}, [[PROP_VAL_COPY]], [[FUNC_NAME_STR]], {{.*}})
   @Flag(value: Self.question) func test() {}
 }
+
+// This make sure that Child is valid even though it opted-out of attribute.
+_ = Child()

test/type/runtime_discoverable_attrs.swift

@@ -318,3 +318,34 @@ class MultiAttrTest {
 }
 
 extension MultiAttrTest : Flagged & EnumFlagged {} // Ok
+
+@Flag
+class BaseClass {}
+
+@Flag
+class ValidChild : BaseClass {} // Ok
+
+class InvalidChild : BaseClass {}
+// expected-error@-1 {{superclass 'BaseClass' requires reflection metadata attribute @Flag}}
+// expected-note@-2 {{add missing reflection metadata attribute @Flag}} {{1-1=@Flag }}
+// expected-note@-3 {{opt-out of reflection metadata attribute @Flag using unavailable extension}} {{34-34=\n\n@available(*, unavailable)\n@Flag extension InvalidChild {\}\n}}
+
+class OptedOutChild : BaseClass {} // Ok (used unavailable extension to opt-out of the attribute)
+
+@available(*, unavailable)
+@Flag
+extension OptedOutChild {}
+
+protocol InvalidProtoWithSuperclass : BaseClass {}
+// expected-error@-1 {{superclass 'BaseClass' requires reflection metadata attribute @Flag}}
+// expected-note@-2 {{add missing reflection metadata attribute @Flag}} {{1-1=@Flag }}
+// expected-note@-3 {{opt-out of reflection metadata attribute @Flag using unavailable extension}} {{51-51=\n\n@available(*, unavailable)\n@Flag extension InvalidProtoWithSuperclass {\}\n}}
+
+@Flag
+protocol ValidProtoWithSuperclass : BaseClass {} // Ok
+
+protocol OptedOutProtoWithSuperclass : BaseClass {} // Ok
+
+@available(*, unavailable)
+@Flag
+extension OptedOutProtoWithSuperclass {}