[SIL] Keep alive @_alwaysEmitIntoClient decls with opaque result types

If such declarations have availability conditions they have to be
kept alive until IRGen to emit opaque type descriptor that is going
be used at runtime to determine the underlying type.

This is important for "optimized" mode only because in non-optimized
mode "shared" symbol survives SILGen.

Author: xedin

include/swift/SIL/SILFunction.h

@@ -1121,6 +1121,32 @@ class SILFunction
     return false;
   }
 
+  /// Returns true if this function belongs to a declaration that
+  /// has `@_alwaysEmitIntoClient` attribute.
+  bool markedAsAlwaysEmitIntoClient() const {
+    if (!hasLocation())
+      return false;
+
+    auto *V = getLocation().getAsASTNode<ValueDecl>();
+    return V && V->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>();
+  }
+
+  /// Returns true if this function belongs to a declaration that returns
+  /// an opaque result type with one or more availability conditions that are
+  /// allowed to produce a different underlying type at runtime.
+  bool hasOpaqueResultTypeWithAvailabilityConditions() const {
+    if (!hasLocation())
+      return false;
+
+    if (auto *V = getLocation().getAsASTNode<ValueDecl>()) {
+      auto *opaqueResult = V->getOpaqueResultTypeDecl();
+      return opaqueResult &&
+             opaqueResult->hasConditionallyAvailableSubstitutions();
+    }
+
+    return false;
+  }
+
   //===--------------------------------------------------------------------===//
   // Block List Access
   //===--------------------------------------------------------------------===//

lib/IRGen/IRGenSIL.cpp

@@ -2232,18 +2232,15 @@ void IRGenSILFunction::emitSILFunction() {
     IGM.IRGen.addDynamicReplacement(CurSILFn);
 
   if (CurSILFn->getLinkage() == SILLinkage::Shared) {
-    if (auto *V = CurSILFn->getLocation().getAsASTNode<ValueDecl>()) {
-      bool alwaysEmitIntoClient =
-          V->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>();
+    if (CurSILFn->markedAsAlwaysEmitIntoClient() &&
+        CurSILFn->hasOpaqueResultTypeWithAvailabilityConditions()) {
+      auto *V = CurSILFn->getLocation().castToASTNode<ValueDecl>();
       auto *opaqueResult = V->getOpaqueResultTypeDecl();
       // `@_alwaysEmitIntoClient` declaration with opaque result
       // has to emit opaque type descriptor into client module
       // when it has availability conditions because the underlying
       // type in such cases is unknown until runtime.
-      if (alwaysEmitIntoClient && opaqueResult &&
-          opaqueResult->hasConditionallyAvailableSubstitutions()) {
-        IGM.maybeEmitOpaqueTypeDecl(opaqueResult);
-      }
+      IGM.maybeEmitOpaqueTypeDecl(opaqueResult);
     }
   }
 

lib/SIL/IR/SILFunction.cpp

@@ -708,6 +708,13 @@ SILFunction::isPossiblyUsedExternally() const {
   if (isDistributed() && isThunk())
     return true;
 
+  // Declaration marked as `@_alwaysEmitIntoClient` that
+  // returns opaque result type with availability conditions
+  // has to be kept alive to emit opaque type metadata descriptor.
+  if (markedAsAlwaysEmitIntoClient() &&
+      hasOpaqueResultTypeWithAvailabilityConditions())
+    return true;
+
   return swift::isPossiblyUsedExternally(linkage, getModule().isWholeModule());
 }