[Sema] RuntimeMetadata: Synthesize a body for runtime attribute generator

Single expression is not going to cut it in this case because attribute
and attached declaration could have different availability, so we need
to use `if #available` to guard attribute instantiation and return `nil`
in cases where types are not available.

Author: xedin

include/swift/AST/Decl.h

@@ -2805,9 +2805,11 @@ class ValueDecl : public Decl {
   ///        to place it for maximum impact.
   NominalTypeDecl *getRuntimeDiscoverableAttrTypeDecl(CustomAttr *attr) const;
 
-  /// Given a runtime discoverable attribute, return a generator call
-  /// which could be used to instantiate it for this declaration.
-  Expr *getRuntimeDiscoverableAttributeGenerator(CustomAttr *) const;
+  /// Given a runtime discoverable attribute, return a generator
+  /// which could be used to instantiate it for this declaration
+  /// together with its result type.
+  std::pair<BraceStmt *, Type>
+  getRuntimeDiscoverableAttributeGenerator(CustomAttr *) const;
 };
 
 /// This is a common base class for declarations which declare a type.

include/swift/AST/TypeCheckRequests.h

@@ -3830,6 +3830,23 @@ class SynthesizeRuntimeMetadataAttrGenerator
   bool isCached() const { return true; }
 };
 
+class SynthesizeRuntimeMetadataAttrGeneratorBody
+    : public SimpleRequest<SynthesizeRuntimeMetadataAttrGeneratorBody,
+                           BraceStmt *(CustomAttr *, ValueDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  BraceStmt *evaluate(Evaluator &evaluator, CustomAttr *attr,
+                      ValueDecl *attachedTo) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Compute the local discriminators for the given declaration context.
 ///
 /// This is a state-changing operation for closures within the context, which

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -452,6 +452,9 @@ SWIFT_REQUEST(TypeChecker, MacroDefinitionRequest,
 SWIFT_REQUEST(TypeChecker, SynthesizeRuntimeMetadataAttrGenerator,
               Expr *(CustomAttr *, ValueDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, SynthesizeRuntimeMetadataAttrGeneratorBody,
+              BraceStmt *(CustomAttr *, ValueDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetRuntimeDiscoverableAttributes,
               ArrayRef<CustomAttr *>(ValueDecl *),
               Cached, NoLocationInfo)

lib/SIL/IR/TypeLowering.cpp

@@ -3235,11 +3235,10 @@ getRuntimeAttributeGeneratorInterfaceType(TypeConverter &TC, SILDeclRef c) {
   auto *attachedToDecl = c.getDecl();
   auto *attr = c.pointer.get<CustomAttr *>();
   auto *attrType = attachedToDecl->getRuntimeDiscoverableAttrTypeDecl(attr);
-  auto *generator =
+  auto generator =
       attachedToDecl->getRuntimeDiscoverableAttributeGenerator(attr);
 
-  auto resultTy =
-      generator->getType()->mapTypeOutOfContext()->getCanonicalType();
+  auto resultTy = generator.second->getCanonicalType();
 
   CanType canResultTy = resultTy->getReducedType(
       attrType->getInnermostDeclContext()->getGenericSignatureOfContext());

lib/SILGen/SILGen.cpp

@@ -1141,12 +1141,12 @@ void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {
     auto *attr = constant.pointer.get<CustomAttr *>();
     auto *DC = decl->getDeclContext()->getParentSourceFile();
 
-    Expr *generator = decl->getRuntimeDiscoverableAttributeGenerator(attr);
-    auto loc = RegularLocation::getAutoGeneratedLocation(generator);
+    auto generator = decl->getRuntimeDiscoverableAttributeGenerator(attr);
+    auto loc = RegularLocation::getAutoGeneratedLocation();
     preEmitFunction(constant, f, loc);
     PrettyStackTraceSILFunction X("silgen emitRuntimeAttributeGenerator ", f);
     SILGenFunction SGF(*this, *f, DC);
-    SGF.emitGeneratorFunction(constant, generator);
+    SGF.emitGeneratorFunction(constant, generator.second, generator.first);
     postEmitFunction(constant, f);
     break;
   }

lib/SILGen/SILGenFunction.cpp

@@ -1165,7 +1165,7 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function,
                                            BraceStmt *body) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(function);
 
-  RegularLocation loc(body);
+  RegularLocation loc(function.getDecl());
   loc.markAutoGenerated();
 
   auto *dc = function.getDecl()->getInnermostDeclContext();

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1881,7 +1881,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         if (!runtimeDiscoverableAttrs.empty()) {
           // Register the declaration only if all of its attributes are valid.
           if (llvm::all_of(runtimeDiscoverableAttrs, [&](CustomAttr *attr) {
-                return VD->getRuntimeDiscoverableAttributeGenerator(attr);
+                return VD->getRuntimeDiscoverableAttributeGenerator(attr).first;
               }))
             SF->addDeclWithRuntimeDiscoverableAttrs(VD);
         }

lib/Sema/TypeCheckRuntimeMetadataAttr.cpp

@@ -35,12 +35,21 @@ ArrayRef<CustomAttr *> ValueDecl::getRuntimeDiscoverableAttrs() const {
                            nullptr);
 }
 
-Expr *
+std::pair<BraceStmt *, Type>
 ValueDecl::getRuntimeDiscoverableAttributeGenerator(CustomAttr *attr) const {
   auto *mutableSelf = const_cast<ValueDecl *>(this);
-  return evaluateOrDefault(
+  auto *body = evaluateOrDefault(
+      getASTContext().evaluator,
+      SynthesizeRuntimeMetadataAttrGeneratorBody{attr, mutableSelf}, nullptr);
+  if (!body)
+    return std::make_pair(nullptr, Type());
+
+  auto *init = evaluateOrDefault(
       getASTContext().evaluator,
       SynthesizeRuntimeMetadataAttrGenerator{attr, mutableSelf}, nullptr);
+  assert(init);
+
+  return std::make_pair(body, init->getType()->mapTypeOutOfContext());
 }
 
 Expr *SynthesizeRuntimeMetadataAttrGenerator::evaluate(
@@ -180,3 +189,88 @@ Expr *SynthesizeRuntimeMetadataAttrGenerator::evaluate(
 
   return result;
 }
+
+BraceStmt *SynthesizeRuntimeMetadataAttrGeneratorBody::evaluate(
+    Evaluator &evaluator, CustomAttr *attr, ValueDecl *attachedTo) const {
+  auto &ctx = attachedTo->getASTContext();
+
+  Expr *init = evaluateOrDefault(
+      ctx.evaluator, SynthesizeRuntimeMetadataAttrGenerator{attr, attachedTo},
+      nullptr);
+  if (!init)
+    return nullptr;
+
+  auto resultTy = init->getType();
+
+  SmallVector<ASTNode, 4> body;
+
+  auto declAvailability = attachedTo->getAvailabilityForLinkage();
+  auto attrAvailability = attachedTo->getRuntimeDiscoverableAttrTypeDecl(attr)
+                              ->getAvailabilityForLinkage();
+  declAvailability.intersectWith(attrAvailability);
+
+  if (!declAvailability.isAlwaysAvailable()) {
+
+    // if #available(...) {
+    //  return <#initializer call#>
+    // }
+    // return nil
+
+    auto availableOn = declAvailability.getOSVersion().getLowerEndpoint();
+    auto *platformSpec = new (ctx) PlatformVersionConstraintAvailabilitySpec(
+        targetPlatform(ctx.LangOpts), /*PlatformLoc=*/SourceLoc(), availableOn,
+        availableOn, /*VersionSrcRange=*/SourceRange());
+
+    auto *wildcardSpec =
+        new (ctx) OtherPlatformAvailabilitySpec(/*StarLoc=*/SourceLoc());
+
+    StmtConditionElement platformCond(PoundAvailableInfo::create(
+        ctx, /*PoundLoc=*/SourceLoc(),
+        /*LParenLoc=*/SourceLoc(), {platformSpec, wildcardSpec},
+        /*RParenLoc=*/SourceLoc(),
+        /*isUnavailability=*/false));
+
+    NullablePtr<Stmt> thenStmt;
+    {
+      SmallVector<ASTNode, 4> thenBody;
+
+      thenBody.push_back(new (ctx) ReturnStmt(/*loc=*/SourceLoc(), init,
+                                              /*isImplicit=*/true));
+
+      thenStmt = BraceStmt::create(ctx, /*lbloc=*/SourceLoc(), thenBody,
+                                   /*rbloc=*/SourceLoc(), /*implicit=*/true);
+    }
+
+    NullablePtr<Stmt> elseStmt;
+    {
+      // return nil as Optional<<#attribute type#>>
+      auto *nil =
+          new (ctx) NilLiteralExpr(/*Loc=*/SourceLoc(), /*implicit=*/true);
+      nil->setType(resultTy);
+
+      auto *returnNil = new (ctx) ReturnStmt(/*loc=*/SourceLoc(), nil,
+                                             /*isImplicit=*/true);
+
+      elseStmt = BraceStmt::create(ctx, /*lbloc=*/SourceLoc(), {returnNil},
+                                   /*rbloc=*/SourceLoc(), /*implicit=*/true);
+    }
+
+    auto *ifStmt = new (ctx)
+        IfStmt(LabeledStmtInfo(), /*ifLoc=*/SourceLoc(),
+               ctx.AllocateCopy(ArrayRef<StmtConditionElement>(platformCond)),
+               thenStmt.get(),
+               /*ElseLoc=*/SourceLoc(), elseStmt.get(), /*Implicit=*/true);
+
+    body.push_back(ifStmt);
+  } else {
+    // just `return <#initializer value#>`
+    body.push_back(new (ctx) ReturnStmt(/*loc=*/SourceLoc(), init,
+                                        /*isImplicit=*/true));
+  }
+
+  ASTNode braceStmt =
+      BraceStmt::create(ctx, /*lbloc=*/attr->getLocation(), body,
+                        /*rbloc=*/attr->getLocation(), /*implicit=*/true);
+
+  return cast<BraceStmt>(braceStmt.get<Stmt *>());
+}