[SILDeclRef] RuntimeMetadata: Add a special kind for runtime attribute generator

A new `RuntimeAttributeGenerator` is used to reference runtime
attribute generator functions synthesized by SILGen.
`#function` magic literal points to the declaration that declaration
attribute is attached to.

Author: xedin

include/swift/SIL/SILDeclRef.h

@@ -53,6 +53,7 @@ namespace swift {
   enum class SILLinkage : uint8_t;
   class AnyFunctionRef;
   class GenericSignature;
+  class CustomAttr;
 
 /// How a method is dispatched.
 enum class MethodDispatch {
@@ -162,6 +163,10 @@ struct SILDeclRef {
 
     /// The asynchronous main entry-point function.
     AsyncEntryPoint,
+
+    /// This constant references the generator function used to instantiate
+    /// attribute value associated with a particular declaration.
+    RuntimeAttributeGenerator,
   };
 
   /// Represents the variants of a back deployable function.
@@ -198,7 +203,7 @@ struct SILDeclRef {
   unsigned defaultArgIndex : 10;
 
   PointerUnion<AutoDiffDerivativeFunctionIdentifier *,
-               const GenericSignatureImpl *>
+               const GenericSignatureImpl *, CustomAttr *>
       pointer;
 
   /// Returns the type of AST node location being stored by the SILDeclRef.
@@ -277,6 +282,9 @@ struct SILDeclRef {
   /// Produces a SILDeclRef for the entry-point of an async main FileUnit.
   static SILDeclRef getAsyncMainFileEntryPoint(FileUnit *file);
 
+  static SILDeclRef getRuntimeAttributeGenerator(CustomAttr *attr,
+                                                 ValueDecl *decl);
+
   bool isNull() const { return loc.isNull(); }
   explicit operator bool() const { return !isNull(); }
 

lib/IRGen/GenDecl.cpp

@@ -4414,9 +4414,7 @@ void IRGenModule::emitRuntimeDiscoverableAttributes(
 
   // Map attribute type to each declaration it's attached to
   // and a corresponding generator function.
-  llvm::DenseMap<NominalTypeDecl *,
-                 SmallVector<std::pair<ValueDecl *, SILFunction *>, 2>>
-      attributes;
+  llvm::MapVector<NominalTypeDecl *, SmallVector<SILDeclRef, 2>> attributes;
   {
     for (auto *fileUnit : filesToEmit) {
       auto *SF = dyn_cast<SourceFile>(fileUnit);
@@ -4426,15 +4424,16 @@ void IRGenModule::emitRuntimeDiscoverableAttributes(
       for (auto *decl : SF->getDeclsWithRuntimeDiscoverableAttrs()) {
         for (auto *attr : decl->getRuntimeDiscoverableAttrs()) {
           auto *attrType = decl->getRuntimeDiscoverableAttrTypeDecl(attr);
-          auto *generator = getSILModule().lookUpFunction(
-              SILDeclRef(decl->getRuntimeDiscoverableAttributeGenerator(attr)));
-
-          attributes[attrType].push_back({decl, generator});
+          attributes[attrType].push_back(
+              SILDeclRef::getRuntimeAttributeGenerator(attr, decl)
+                  .asRuntimeAccessible());
         }
       }
     }
   }
 
+  auto &SM = getSILModule();
+
   for (auto &attr : attributes) {
     auto *attrType = attr.first;
     const auto &attachedTo = attr.second;
@@ -4457,9 +4456,9 @@ void IRGenModule::emitRuntimeDiscoverableAttributes(
     B.addInt32(attachedTo.size());
 
     // Emit all of the trailing objects
-    for (auto &e : attachedTo) {
-      auto type = e.first->getInterfaceType()->getCanonicalType();
-      auto *generator = e.second;
+    for (auto &ref : attachedTo) {
+      auto type = ref.getDecl()->getInterfaceType()->getCanonicalType();
+      auto *generator = SM.lookUpFunction(ref);
 
       B.addRelativeAddress(
           getTypeRef(type, /*genericSig=*/nullptr, MangledTypeRefRole::Metadata)

lib/IRGen/GenObjC.cpp

@@ -628,6 +628,7 @@ namespace {
       case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
       case SILDeclRef::Kind::EntryPoint:
       case SILDeclRef::Kind::AsyncEntryPoint:
+      case SILDeclRef::Kind::RuntimeAttributeGenerator:
         llvm_unreachable("Method does not have a selector");
 
       case SILDeclRef::Kind::Destroyer:

lib/SIL/IR/SILDeclRef.cpp

@@ -369,6 +369,7 @@ bool SILDeclRef::hasUserWrittenCode() const {
   case Kind::PropertyWrapperInitFromProjectedValue:
   case Kind::EntryPoint:
   case Kind::AsyncEntryPoint:
+  case Kind::RuntimeAttributeGenerator:
     // Implicit decls for these don't splice in user-written code.
     return false;
   }
@@ -510,6 +511,9 @@ static LinkageLimit getLinkageLimit(SILDeclRef constant) {
     // class from which they come, and never get seen externally.
     return Limit::NeverPublic;
 
+  case Kind::RuntimeAttributeGenerator:
+    return Limit::NeverPublic;
+
   case Kind::EntryPoint:
   case Kind::AsyncEntryPoint:
     llvm_unreachable("Already handled");
@@ -671,6 +675,16 @@ SILDeclRef SILDeclRef::getMainFileEntryPoint(FileUnit *file) {
   return result;
 }
 
+SILDeclRef SILDeclRef::getRuntimeAttributeGenerator(CustomAttr *attr,
+                                                    ValueDecl *decl) {
+  SILDeclRef result;
+  result.loc = decl;
+  result.kind = Kind::RuntimeAttributeGenerator;
+  result.isRuntimeAccessible = true;
+  result.pointer = attr;
+  return result;
+}
+
 bool SILDeclRef::hasClosureExpr() const {
   return loc.is<AbstractClosureExpr *>()
     && isa<ClosureExpr>(getAbstractClosureExpr());
@@ -1009,7 +1023,8 @@ bool SILDeclRef::isBackDeploymentThunk() const {
 }
 
 bool SILDeclRef::isRuntimeAccessibleFunction() const {
-  return isRuntimeAccessible && kind == Kind::Func;
+  return isRuntimeAccessible &&
+         (kind == Kind::Func || kind == Kind::RuntimeAttributeGenerator);
 }
 
 /// Use the Clang importer to mangle a Clang declaration.
@@ -1188,6 +1203,10 @@ std::string SILDeclRef::mangle(ManglingKind MKind) const {
   case SILDeclRef::Kind::EntryPoint: {
     return getASTContext().getEntryPointFunctionName();
   }
+
+  case SILDeclRef::Kind::RuntimeAttributeGenerator:
+    return mangler.mangleRuntimeAttributeGeneratorEntity(
+        loc.get<ValueDecl *>(), pointer.get<CustomAttr *>(), SKind);
   }
 
   llvm_unreachable("bad entity kind!");
@@ -1556,7 +1575,7 @@ unsigned SILDeclRef::getParameterListCount() const {
 
   // Always uncurried even if the underlying function is curried.
   if (kind == Kind::DefaultArgGenerator || kind == Kind::EntryPoint ||
-      kind == Kind::AsyncEntryPoint)
+      kind == Kind::AsyncEntryPoint || kind == Kind::RuntimeAttributeGenerator)
     return 1;
 
   auto *vd = getDecl();

lib/SIL/IR/SILFunctionType.cpp

@@ -2396,6 +2396,7 @@ static CanSILFunctionType getNativeSILFunctionType(
     case SILDeclRef::Kind::Destroyer:
     case SILDeclRef::Kind::GlobalAccessor:
     case SILDeclRef::Kind::DefaultArgGenerator:
+    case SILDeclRef::Kind::RuntimeAttributeGenerator:
     case SILDeclRef::Kind::StoredPropertyInitializer:
     case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
     case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
@@ -3238,6 +3239,7 @@ static ObjCSelectorFamily getObjCSelectorFamily(SILDeclRef c) {
   case SILDeclRef::Kind::EnumElement:
   case SILDeclRef::Kind::GlobalAccessor:
   case SILDeclRef::Kind::DefaultArgGenerator:
+  case SILDeclRef::Kind::RuntimeAttributeGenerator:
   case SILDeclRef::Kind::StoredPropertyInitializer:
   case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
   case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
@@ -3508,6 +3510,7 @@ TypeConverter::getDeclRefRepresentation(SILDeclRef c) {
   switch (c.kind) {
     case SILDeclRef::Kind::GlobalAccessor:
     case SILDeclRef::Kind::DefaultArgGenerator:
+    case SILDeclRef::Kind::RuntimeAttributeGenerator:
     case SILDeclRef::Kind::StoredPropertyInitializer:
     case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
     case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
@@ -4370,6 +4373,7 @@ static AbstractFunctionDecl *getBridgedFunction(SILDeclRef declRef) {
   case SILDeclRef::Kind::Deallocator:
   case SILDeclRef::Kind::GlobalAccessor:
   case SILDeclRef::Kind::DefaultArgGenerator:
+  case SILDeclRef::Kind::RuntimeAttributeGenerator:
   case SILDeclRef::Kind::StoredPropertyInitializer:
   case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
   case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:

lib/SIL/IR/SILPrinter.cpp

@@ -376,6 +376,9 @@ void SILDeclRef::print(raw_ostream &OS) const {
   case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
     OS << "!projectedvalueinit";
     break;
+  case SILDeclRef::Kind::RuntimeAttributeGenerator:
+    OS << "!attrgenerator";
+    break;
   }
 
   if (isForeign)

lib/SIL/IR/SILSymbolVisitor.cpp

@@ -367,9 +367,8 @@ class SILSymbolVisitorImpl : public ASTVisitor<SILSymbolVisitorImpl> {
 
   void addRuntimeDiscoverableAttrGenerators(ValueDecl *D) {
     for (auto *attr : D->getRuntimeDiscoverableAttrs()) {
-      auto *generator = D->getRuntimeDiscoverableAttributeGenerator(attr);
-      assert(generator);
-      addFunction(SILDeclRef(generator), /*ignoreLinkage=*/true);
+      addFunction(SILDeclRef::getRuntimeAttributeGenerator(attr, D),
+                  /*ignoreLinkage=*/true);
     }
   }
 

lib/SIL/IR/TypeLowering.cpp

@@ -3229,6 +3229,31 @@ static CanAnyFunctionType getStoredPropertyInitializerInterfaceType(
                                  info);
 }
 
+/// Type of runtime discoverable attribute generator is () -> <#AttrType#>
+static CanAnyFunctionType
+getRuntimeAttributeGeneratorInterfaceType(TypeConverter &TC, SILDeclRef c) {
+  auto *attachedToDecl = c.getDecl();
+  auto *attr = c.pointer.get<CustomAttr *>();
+  auto *attrType = attachedToDecl->getRuntimeDiscoverableAttrTypeDecl(attr);
+  auto *generator =
+      attachedToDecl->getRuntimeDiscoverableAttributeGenerator(attr);
+
+  auto resultTy =
+      generator->getType()->mapTypeOutOfContext()->getCanonicalType();
+
+  CanType canResultTy = resultTy->getReducedType(
+      attrType->getInnermostDeclContext()->getGenericSignatureOfContext());
+
+  // Remove @noescape from function return types. A @noescape
+  // function return type is a contradiction.
+  canResultTy = removeNoEscape(canResultTy);
+
+  // FIXME: Verify ExtInfo state is correct, not working by accident.
+  CanAnyFunctionType::ExtInfo info;
+  return CanAnyFunctionType::get(/*genericSignature=*/nullptr,
+                                 /*params=*/{}, canResultTy, info);
+}
+
 /// Get the type of a property wrapper backing initializer,
 /// (property-type) -> backing-type.
 static CanAnyFunctionType getPropertyWrapperBackingInitializerInterfaceType(
@@ -3489,6 +3514,8 @@ CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
     return getAsyncEntryPoint(Context);
   case SILDeclRef::Kind::EntryPoint:
     return getEntryPointInterfaceType(Context);
+  case SILDeclRef::Kind::RuntimeAttributeGenerator:
+    return getRuntimeAttributeGeneratorInterfaceType(*this, c);
   }
 
   llvm_unreachable("Unhandled SILDeclRefKind in switch.");
@@ -3542,6 +3569,7 @@ TypeConverter::getConstantGenericSignature(SILDeclRef c) {
     return vd->getDeclContext()->getGenericSignatureOfContext();
   case SILDeclRef::Kind::EntryPoint:
   case SILDeclRef::Kind::AsyncEntryPoint:
+  case SILDeclRef::Kind::RuntimeAttributeGenerator:
     llvm_unreachable("Doesn't have generic signature");
   }
 

lib/SIL/Parser/ParseSIL.cpp

@@ -1616,6 +1616,9 @@ bool SILParser::parseSILDeclRef(SILDeclRef &Result,
       } else if (!ParseState && Id.str() == "defaultarg") {
         Kind = SILDeclRef::Kind::IVarInitializer;
         ParseState = 1;
+      } else if (!ParseState && Id.str() == "attrgenerator") {
+        Kind = SILDeclRef::Kind::RuntimeAttributeGenerator;
+        ParseState = 1;
       } else if (!ParseState && Id.str() == "propertyinit") {
         Kind = SILDeclRef::Kind::StoredPropertyInitializer;
         ParseState = 1;

lib/SILGen/SILGen.cpp

@@ -1135,6 +1135,21 @@ void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {
     postEmitFunction(constant, f);
     return;
   }
+
+  case SILDeclRef::Kind::RuntimeAttributeGenerator: {
+    auto *decl = constant.getDecl();
+    auto *attr = constant.pointer.get<CustomAttr *>();
+    auto *DC = decl->getDeclContext()->getParentSourceFile();
+
+    Expr *generator = decl->getRuntimeDiscoverableAttributeGenerator(attr);
+    auto loc = RegularLocation::getAutoGeneratedLocation(generator);
+    preEmitFunction(constant, f, loc);
+    PrettyStackTraceSILFunction X("silgen emitRuntimeAttributeGenerator ", f);
+    SILGenFunction SGF(*this, *f, DC);
+    SGF.emitGeneratorFunction(constant, generator);
+    postEmitFunction(constant, f);
+    break;
+  }
   }
 }
 
@@ -2210,9 +2225,9 @@ class SILGenModuleRAII {
 
     for (auto *D : sf->getDeclsWithRuntimeDiscoverableAttrs()) {
       for (auto *attr : D->getRuntimeDiscoverableAttrs()) {
-        auto *generator = D->getRuntimeDiscoverableAttributeGenerator(attr);
-        assert(generator);
-        emitSILFunctionDefinition(SILDeclRef(generator).asRuntimeAccessible());
+        emitSILFunctionDefinition(
+            SILDeclRef::getRuntimeAttributeGenerator(attr, D)
+                .asRuntimeAccessible());
       }
     }