[Sema] RuntimeMetadata: Make reflection metadata attribute a conformance requirement

If conforming type doesn't declare required set of reflection metadata
attributes (based on the protocol declaration) fail conformance via
extension.

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -6945,6 +6945,10 @@ ERROR(cannot_use_attr_with_custom_arguments_on_protocol,none,
       " explicitly written on the conforming type",
       ())
 
+NOTE(missing_reflection_metadata_attribute_on_type,none,
+     "protocol %0 requires reflection metadata attribute @%1",
+     (DeclName, StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
 

lib/Sema/TypeCheckAttr.cpp

@@ -7541,3 +7541,29 @@ GetRuntimeDiscoverableAttributes::evaluate(Evaluator &evaluator,
 
   return copyAttrs(attrs);
 }
+
+void TypeChecker::checkReflectionMetadataAttributes(ExtensionDecl *ED) {
+  auto *extendedType = ED->getExtendedNominal();
+
+  for (auto *protocol : ED->getLocalProtocols()) {
+    forEachCustomAttribute<RuntimeMetadataAttr>(
+        protocol, [&](CustomAttr *attr, NominalTypeDecl *attrType) {
+          if (llvm::none_of(
+                  extendedType->getRuntimeDiscoverableAttrs(),
+                  [&](CustomAttr *typeAttr) {
+                    return extendedType->getRuntimeDiscoverableAttrTypeDecl(
+                               typeAttr) == attrType;
+                  })) {
+            auto &ctx = protocol->getASTContext();
+            ctx.Diags.diagnose(ED->getLoc(), diag::type_does_not_conform,
+                               ED->getExtendedType(),
+                               protocol->getDeclaredInterfaceType());
+
+            ctx.Diags.diagnose(
+                ED->getLoc(),
+                diag::missing_reflection_metadata_attribute_on_type,
+                protocol->getName(), attrType->getNameStr());
+          }
+        });
+  }
+}

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -3360,6 +3360,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       ED->diagnose(diag::moveonly_cannot_conform_to_protocol,
                    nominal->getDescriptiveKind(), nominal->getBaseName());
     }
+
+    TypeChecker::checkReflectionMetadataAttributes(ED);
   }
 
   void visitTopLevelCodeDecl(TopLevelCodeDecl *TLCD) {

lib/Sema/TypeChecker.h

@@ -1296,6 +1296,11 @@ bool diagnoseInvalidFunctionType(FunctionType *fnTy, SourceLoc loc,
 /// type repr. \param inferredType The type inferred by the type checker.
 void notePlaceholderReplacementTypes(Type writtenType, Type inferredType);
 
+/// Check whether the given extension introduces a conformance
+/// to a protocol annotated with reflection metadata attribute(s).
+/// If that's the case, conforming type supposed to match attribute
+/// requirements.
+void checkReflectionMetadataAttributes(ExtensionDecl *extension);
 } // namespace TypeChecker
 
 /// Returns the protocol requirement kind of the given declaration.

test/type/runtime_discoverable_attrs.swift

@@ -133,6 +133,9 @@ struct TestNoAmbiguity {
 @Flag
 protocol Flagged {}
 
+@Flag
+protocol OtherFlagged {}
+
 @Flag("flag from protocol") // expected-error {{reflection metadata attributes applied to protocols cannot have additional attribute arguments}}
 protocol InvalidFlagged {}
 
@@ -249,6 +252,9 @@ enum EnumFlag<B, V> {
   case function(() -> V)
 }
 
+@EnumFlag
+protocol EnumFlagged {}
+
 extension EnumFlag {
   init(attachedTo: KeyPath<B, V>) { self = .property(attachedTo) }
   init(attachedTo: @escaping (B) -> V) { self = .method(attachedTo) }
@@ -280,9 +286,35 @@ extension EnumFlag where B == Void {
 }
 
 @available(*, unavailable)
-@EnumFlag extension EnumTypeTest { // expected-error {{@EnumFlag is already applied to type 'EnumTypeTest'; did you want to remove it?}} {{269:1-11=}}
+@EnumFlag extension EnumTypeTest { // expected-error {{@EnumFlag is already applied to type 'EnumTypeTest'; did you want to remove it?}} {{275:1-11=}}
 }
 
 @available(*, unavailable)
 @Flag extension CrossModuleTest { // expected-error {{@Flag can only be applied to unavailable extensions in the same module as 'CrossModuleTest'}}
 }
+
+struct InvalidConformanceTest1 {}
+struct InvalidConformanceTest2 {}
+
+extension InvalidConformanceTest1 : Flagged {} // expected-error {{type 'InvalidConformanceTest1' does not conform to protocol 'Flagged'}}
+// expected-note@-1 {{protocol 'Flagged' requires reflection metadata attribute @Flag}}
+
+extension InvalidConformanceTest2 : Flagged & EnumFlagged {}
+// expected-error@-1 {{type 'InvalidConformanceTest2' does not conform to protocol 'Flagged'}}
+// expected-error@-2 {{type 'InvalidConformanceTest2' does not conform to protocol 'EnumFlagged'}}
+// expected-note@-3 {{protocol 'Flagged' requires reflection metadata attribute @Flag}}
+// expected-note@-4 {{protocol 'EnumFlagged' requires reflection metadata attribute @EnumFlag}}
+
+@Flag
+struct ValidConformance1 {}
+extension ValidConformance1 : Flagged {} // Ok
+
+struct ValidConformance2 : Flagged {}
+extension ValidConformance2 : OtherFlagged {} // Ok (@Flag is inferred from Flagged protocol conformance)
+
+@EnumFlag @Flag
+class MultiAttrTest {
+  init() {}
+}
+
+extension MultiAttrTest : Flagged & EnumFlagged {} // Ok