Merge pull request #63274 from xedin/runtime-metadata-impl-alignment

[AST/Sema] RuntimeMetadata: Align implementation with proposal

Author: xedin

include/swift/AST/Decl.h

@@ -859,6 +859,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     return Attrs;
   }
 
+  /// Retrieve runtime discoverable attributes (if any) associated
+  /// with this declaration.
+  ArrayRef<CustomAttr *> getRuntimeDiscoverableAttrs() const;
+
   /// Returns the semantic attributes attached to this declaration,
   /// including attributes that are generated as the result of member
   /// attribute macro expansion.
@@ -2851,9 +2855,6 @@ class ValueDecl : public Decl {
   GenericParameterReferenceInfo findExistentialSelfReferences(
       Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
 
-  /// Retrieve runtime discoverable attributes (if any) associated
-  /// with this declaration.
-  ArrayRef<CustomAttr *> getRuntimeDiscoverableAttrs() const;
   /// Retrieve a nominal type declaration backing given runtime discoverable
   /// attribute.
   ///

include/swift/AST/DiagnosticsSema.def

@@ -6917,6 +6917,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", ())
 
@@ -6934,6 +6942,26 @@ ERROR(runtime_attribute_type_requirement_not_accessible,none,
       "(which is %select{private|fileprivate|internal|package|public|open}4)",
       (AccessLevel, DescriptiveDeclKind, DeclName, Type, AccessLevel))
 
+ERROR(cannot_use_attr_with_custom_arguments_on_protocol,none,
+      "reflection metadata attributes applied to protocols cannot have"
+      " additional attribute arguments; attribute arguments must be"
+      " explicitly written on the conforming type",
+      ())
+
+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"

include/swift/AST/TypeCheckRequests.h

@@ -3927,15 +3927,15 @@ class ExternalMacroDefinitionRequest
 
 class GetRuntimeDiscoverableAttributes
     : public SimpleRequest<GetRuntimeDiscoverableAttributes,
-                           ArrayRef<CustomAttr *>(ValueDecl *),
+                           ArrayRef<CustomAttr *>(Decl *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  ArrayRef<CustomAttr *> evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+  ArrayRef<CustomAttr *> evaluate(Evaluator &evaluator, Decl *decl) const;
 
 public:
   bool isCached() const { return true; }

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -468,7 +468,7 @@ SWIFT_REQUEST(TypeChecker, SynthesizeRuntimeMetadataAttrGeneratorBody,
               BraceStmt *(CustomAttr *, ValueDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetRuntimeDiscoverableAttributes,
-              ArrayRef<CustomAttr *>(ValueDecl *),
+              ArrayRef<CustomAttr *>(Decl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, LocalDiscriminatorsRequest,
               unsigned(DeclContext *),

lib/AST/ASTPrinter.cpp

@@ -1884,6 +1884,11 @@ bool isNonSendableExtension(const Decl *D) {
 bool ShouldPrintChecker::shouldPrint(const Decl *D,
                                      const PrintOptions &Options) {
   if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
+    // Always print unavilable extensions that carry reflection
+    // metadata attributes.
+    if (!ED->getRuntimeDiscoverableAttrs().empty())
+      return true;
+
     if (Options.printExtensionContentAsMembers(ED))
       return false;
   }
@@ -2975,12 +2980,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/AST/Decl.cpp

@@ -9888,8 +9888,8 @@ ValueDecl::getRuntimeDiscoverableAttrTypeDecl(CustomAttr *attr) const {
   return nominal;
 }
 
-ArrayRef<CustomAttr *> ValueDecl::getRuntimeDiscoverableAttrs() const {
-  auto *mutableSelf = const_cast<ValueDecl *>(this);
+ArrayRef<CustomAttr *> Decl::getRuntimeDiscoverableAttrs() const {
+  auto *mutableSelf = const_cast<Decl *>(this);
   return evaluateOrDefault(getASTContext().evaluator,
                            GetRuntimeDiscoverableAttributes{mutableSelf},
                            nullptr);

lib/Sema/TypeCheckAttr.cpp

@@ -3689,6 +3689,10 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
     case DeclKind::Protocol: {
       // Allow on protocols because they are sources
       // of inference.
+      if (attr->hasArgs()) {
+        diagnoseAndRemoveAttr(
+            attr, diag::cannot_use_attr_with_custom_arguments_on_protocol);
+      }
       return;
     }
 
@@ -3715,6 +3719,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.
@@ -7111,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();
@@ -7415,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();
 
@@ -7425,7 +7472,6 @@ static void forEachCustomAttribute(
     auto *nominal = evaluateOrDefault(
         ctx.evaluator,
         CustomAttrNominalRequest{mutableAttr, decl->getDeclContext()}, nullptr);
-
     if (!nominal)
       continue;
 
@@ -7436,15 +7482,15 @@ static void forEachCustomAttribute(
 
 ArrayRef<CustomAttr *>
 GetRuntimeDiscoverableAttributes::evaluate(Evaluator &evaluator,
-                                           ValueDecl *decl) const {
+                                           Decl *decl) const {
   auto &ctx = decl->getASTContext();
 
   llvm::SmallMapVector<NominalTypeDecl *, CustomAttr *, 4> attrs;
 
   enum class GatheringMode { Direct, Inference };
 
   auto gatherRuntimeAttrsOnDecl =
-      [&](ValueDecl *decl,
+      [&](Decl *decl,
           llvm::SmallMapVector<NominalTypeDecl *, CustomAttr *, 4> &attrs,
           GatheringMode mode) {
         forEachCustomAttribute<RuntimeMetadataAttr>(
@@ -7476,14 +7522,86 @@ 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;
+  //  - declared in the same module as the extended type.
+  if (auto *ED = dyn_cast<ExtensionDecl>(decl)) {
+    if (!AvailableAttr::isUnavailable(ED))
+      return copyAttrs(attrs);
+
+    if (ED->isConstrainedExtension() ||
+        ED->getParentModule() != decl->getDeclContext()->getParentModule())
+      return copyAttrs(attrs);
+  }
+
   // First, gather all of the runtime attributes directly on the decl.
   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())) {
@@ -7501,5 +7619,47 @@ 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);
 }
+
+void TypeChecker::checkReflectionMetadataAttributes(ExtensionDecl *ED) {
+  auto &ctx = ED->getASTContext();
+  auto *extendedType = ED->getExtendedNominal();
+
+  // If extension has any reflection metadata attributes, trigger the
+  // request to set their types.
+  for (auto *attr : ED->getRuntimeDiscoverableAttrs()) {
+    (void)evaluateOrDefault(
+        ctx.evaluator,
+        CustomAttrTypeRequest{attr, ED->getDeclContext(),
+                              CustomAttrTypeKind::RuntimeMetadata},
+        nullptr);
+  }
+
+  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;
+                  })) {
+            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.