[Serialization] Fix deserializing opaque types for computed properties and subscripts

A client shouldn't know about the underlying type of an opaque type
unless it can see the body of the naming decl. Attempting to read it can
lead to accessing a hidden dependency and a compiler crash.

This was protected by a check specific to function decls that left out
var decls and subscripts. Fix this hole with a new service checking for
inlinable attributes directly.

rdar://117607906

Author: xymus

include/swift/AST/Decl.h

@@ -3294,6 +3294,14 @@ class OpaqueTypeDecl final :
     };
   }
 
+  /// Should we consider the underlying type as visible to clients outside of
+  /// the module?
+  ///
+  /// This is used during deserialization to determine if this information
+  /// can be read reliably. We should be careful to what data is accessed by
+  /// this service as \c this may not be fully consistent.
+  bool exportUnderylingTypeToClients() const;
+
   /// The substitutions that map the generic parameters of the opaque type to
   /// the unique underlying types, when that information is known.
   llvm::Optional<SubstitutionMap> getUniqueUnderlyingTypeSubstitutions() const {

lib/AST/Decl.cpp

@@ -9464,6 +9464,25 @@ GenericTypeParamDecl *OpaqueTypeDecl::getExplicitGenericParam(
   return genericParamType->getDecl();
 }
 
+bool OpaqueTypeDecl::exportUnderylingTypeToClients() const {
+  auto mod = getDeclContext()->getParentModule();
+  if (mod->getResilienceStrategy() != ResilienceStrategy::Resilient)
+    return true;
+
+  ValueDecl *namingDecl = getNamingDecl();
+  if (auto *AFD = dyn_cast<AbstractFunctionDecl>(namingDecl)) {
+    return AFD->getResilienceExpansion() == ResilienceExpansion::Minimal;
+
+  } else if (auto *ASD = dyn_cast<AbstractStorageDecl>(namingDecl)) {
+    return !ASD->isResilient();
+
+  } else {
+    llvm_unreachable("The naming decl is expected to be either an AFD or ASD");
+  }
+
+  return false;
+}
+
 llvm::Optional<unsigned>
 OpaqueTypeDecl::getAnonymousOpaqueParamOrdinal(TypeRepr *repr) const {
   assert(NamingDeclAndHasOpaqueReturnTypeRepr.getInt() &&

lib/Serialization/Deserialization.cpp

@@ -4244,14 +4244,17 @@ class DeclDeserializer {
     else
       opaqueDecl->setGenericSignature(GenericSignature());
 
-    auto *AFD = dyn_cast<AbstractFunctionDecl>(namingDecl);
-    if (MF.getResilienceStrategy() == ResilienceStrategy::Resilient &&
-        !MF.FileContext->getParentModule()->isMainModule() &&
-        AFD && AFD->getResilienceExpansion() != ResilienceExpansion::Minimal) {
+    if (!MF.FileContext->getParentModule()->isMainModule() &&
+        !opaqueDecl->exportUnderylingTypeToClients()) {
       // Do not try to read the underlying type information if the function
       // is not inlinable in clients. This reflects the swiftinterface behavior
       // in where clients are only aware of the underlying type when the body
       // of the function is public.
+      LLVM_DEBUG(
+        llvm::dbgs() << "Ignoring underlying information for opaque type of '";
+        llvm::dbgs() << namingDecl->getName();
+        llvm::dbgs() << "'\n";
+        );
 
     } else if (underlyingTypeSubsID) {
       auto subMapOrError = MF.getSubstitutionMapChecked(underlyingTypeSubsID);

test/Serialization/Safety/skip-reading-internal-details.swift

@@ -68,6 +68,14 @@
 // SAFE: Skipping unsafe deserialization: 'fileprivateFunc()'
 // SAFE: Skipping unsafe deserialization: 'refToIOI()'
 
+/// Always skip opaque return type underlying information when non-inlinable.
+// NEEDED: Ignoring underlying information for opaque type of 'opaqueReferencingPrivate()'
+// NEEDED: Ignoring underlying information for opaque type of 'opaqueReferencingPrivateVar'
+// NEEDED: Ignoring underlying information for opaque type of 'subscript(_:)'
+// NEEDED: Ignoring underlying information for opaque type of 'inlinableOpaqueVar'
+// NEEDED: Ignoring underlying information for opaque type of 'inlinableOpaqueVarPattern'
+// NEEDED-NOT: Ignoring underlying information for opaque type of
+
 //--- HiddenLib.swift
 
 public struct HiddenStruct {
@@ -113,6 +121,34 @@ public extension V {
   }
 
   private func referencedPrivateFunc(v: some V) -> some V { return v }
+
+  var opaqueReferencingPrivateVar: some V {
+    referencedPrivateFunc(v: EV())
+  }
+
+  subscript(v: some V) -> some V {
+    referencedPrivateFunc(v: v)
+  }
+
+  @inlinable
+  func inlinableOpaqueFunc() -> some V { EV() }
+
+  @backDeployed(before: SwiftStdlib 5.1)
+  func backdeployedOpaqueFunc() -> some V { EV() }
+
+  @_alwaysEmitIntoClient
+  func aeicOpaqueFunc() -> some V { EV() }
+
+  @_transparent
+  func transparentOpaqueFunc() -> some V { EV() }
+
+  @inlinable
+  var inlinableOpaqueVar: some V { EV() }
+
+  var inlinableOpaqueVarPattern: some V {
+      @inlinable
+      get { EV() }
+  }
 }
 
 //--- Client.swift
@@ -127,4 +163,14 @@ x.notAMember() // expected-error {{value of type 'PublicStruct' has no member 'n
 if #available(SwiftStdlib 5.1, *) {
   let v = EV()
   let _ = v.opaqueReferencingPrivate()
+  let _ = v.opaqueReferencingPrivateVar
+  let _ = v[v]
+
+  let _ = v.inlinableOpaqueFunc()
+  let _ = v.backdeployedOpaqueFunc()
+  let _ = v.aeicOpaqueFunc()
+  let _ = v.transparentOpaqueFunc()
+
+  let _ = v.inlinableOpaqueVar
+  let _ = v.inlinableOpaqueVarPattern
 }