[AST] RuntimeMetadata: Allow use of reflection metadata attrs on unavailable extensions

This is just a way to opt-out a type from use of the attribute,
there is no code generation for such cases because the attribute
could never be reached.

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -6914,6 +6914,14 @@ ERROR(invalid_decl_for_runtime_discoverable_attr,none,
       "@%0 can only be applied to non-generic types, methods, "
       "instance properties, and global functions", (StringRef))
 
+ERROR(invalid_decl_for_runtime_discoverable_attr_in_extension,none,
+      "@%0 can only be applied to unavailable extensions in the same module"
+      " as %1", (StringRef, DeclName))
+
+ERROR(invalid_attr_redeclaration_in_extension,none,
+      "@%0 is already applied to type %1; did you want to remove it?",
+      (StringRef, DeclName))
+
 ERROR(duplicate_runtime_discoverable_attr,none,
       "duplicate runtime discoverable attribute", ())
 

lib/Sema/TypeCheckAttr.cpp

@@ -3715,6 +3715,40 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
       return;
     }
 
+    case DeclKind::Extension: {
+      auto *ext = cast<ExtensionDecl>(D);
+
+      // Only allowed on unavailable extensions in the same module as type
+      // as a way to opt-out from use of the attribute.
+      if (AvailableAttr::isUnavailable(ext)) {
+        auto *extendedType = ext->getExtendedNominal();
+
+        // If there is no type, fallback to default diagnostic.
+        if (!extendedType)
+          break;
+
+        if (extendedType->getParentModule() == ext->getParentModule()) {
+          for (auto directAttr : extendedType->getRuntimeDiscoverableAttrs()) {
+            auto directAttrDecl =
+                extendedType->getRuntimeDiscoverableAttrTypeDecl(directAttr);
+            if (directAttrDecl == nominal) {
+              diagnose(attr->getLocation(),
+                       diag::invalid_attr_redeclaration_in_extension,
+                       nominal->getNameStr(), extendedType->getName())
+                  .fixItRemove(directAttr->getRangeWithAt());
+            }
+          }
+
+          return;
+        }
+      }
+
+      diagnoseAndRemoveAttr(
+          attr, diag::invalid_decl_for_runtime_discoverable_attr_in_extension,
+          nominal->getNameStr(), ext->getExtendedNominal()->getName());
+      return;
+    }
+
     default:
       // All other kinds of declarations i.e. subscripts, constructors etc.
       // are unsupported.

test/type/Inputs/RuntimeAttrs.swift

@@ -0,0 +1 @@
+public struct CrossModuleTest {}

test/type/runtime_discoverable_attrs.swift

@@ -1,7 +1,11 @@
-// RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-experimental-feature RuntimeDiscoverableAttrs
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module %S/Inputs/RuntimeAttrs.swift -o %t
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-experimental-feature RuntimeDiscoverableAttrs -I %t
 
 // REQUIRES: asserts
 
+import RuntimeAttrs
+
 @runtimeMetadata
 struct Flag<T> {
   init(attachedTo: T.Type, _ description: String = "") {}
@@ -264,3 +268,18 @@ extension EnumFlag where B == Void {
   @EnumFlag func testInst() {}
   @EnumFlag static func testStatic() -> Int { 42 }
 }
+
+@Flag extension EnumTypeTest { // expected-error {{@Flag can only be applied to unavailable extensions in the same module as 'EnumTypeTest'}}
+}
+
+@available(*, unavailable)
+@Flag extension EnumTypeTest { // Ok
+}
+
+@available(*, unavailable)
+@EnumFlag extension EnumTypeTest { // expected-error {{@EnumFlag is already applied to type 'EnumTypeTest'; did you want to remove it?}} {{266:1-11=}}
+}
+
+@available(*, unavailable)
+@Flag extension CrossModuleTest { // expected-error {{@Flag can only be applied to unavailable extensions in the same module as 'CrossModuleTest'}}
+}