[Serialization] Only write the underlying type of an opaque type if inlinable

Clients of a resilient module using opaque types don't need access to
the underlying type unless it's used in an inlinable context. Plus, the
underlying type can reference internal details which can lead to crashes
when they reference implementation-only dependencies. To clean up this
behavior, let's only serialize the underlying type if used by an
inlinable function.

Author: xymus

lib/Serialization/Serialization.cpp

@@ -4280,16 +4280,27 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     using namespace decls_block;
     verifyAttrSerializable(opaqueDecl);
 
-    auto namingDeclID = S.addDeclRef(opaqueDecl->getNamingDecl());
-    auto contextID = S.addDeclContextRef(opaqueDecl->getDeclContext());
+    auto namingDecl = opaqueDecl->getNamingDecl();
+    auto namingDeclID = S.addDeclRef(namingDecl);
+    auto DC = opaqueDecl->getDeclContext();
+    auto contextID = S.addDeclContextRef(DC);
     auto interfaceSigID = S.addGenericSignatureRef(
         opaqueDecl->getOpaqueInterfaceGenericSignature());
     auto interfaceTypeID = S.addTypeRef(opaqueDecl->getDeclaredInterfaceType());
 
     auto genericSigID = S.addGenericSignatureRef(opaqueDecl->getGenericSignature());
 
     SubstitutionMapID underlyingSubsID = 0;
-    if (auto underlying = opaqueDecl->getUniqueUnderlyingTypeSubstitutions()) {
+    bool moduleIsResilient = DC->getParentModule()->getResilienceStrategy() ==
+                               swift::ResilienceStrategy::Resilient;
+    auto *AFD = dyn_cast<AbstractFunctionDecl>(namingDecl);
+    if (moduleIsResilient && AFD &&
+        AFD->getResilienceExpansion() != swift::ResilienceExpansion::Minimal) {
+      // Do not write the underlying type information if the function is
+      // not inlinable in clients. This reflects the behavior in the
+      // swiftinterface where clients are only aware of the underlying type
+      // when the body of the function is public.
+    } else if (auto underlying = opaqueDecl->getUniqueUnderlyingTypeSubstitutions()) {
       underlyingSubsID = S.addSubstitutionMapRef(*underlying);
     } else if (opaqueDecl->hasConditionallyAvailableSubstitutions()) {
       // Universally available type doesn't have any availability conditions

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

@@ -86,6 +86,29 @@ public struct PublicStruct {
     }
 }
 
+/// resultBuilding scenario
+public protocol V {}
+
+@resultBuilder
+public struct VB {
+    public static func buildExpression<Content>(_ content: Content) -> Content where Content : V { fatalError() }
+    public static func buildBlock() -> V { fatalError() }
+    public static func buildBlock<Content>(_ content: Content) -> Content where Content : V { fatalError() }
+}
+
+public struct EV : V {
+    public init () {}
+}
+
+public extension V {
+  @VB
+  func opaqueReferencingPrivate() -> some V {
+    referencedPrivateFunc(v: EV())
+  }
+
+  private func referencedPrivateFunc(v: some V) -> some V { return v }
+}
+
 //--- Client.swift
 
 import Lib
@@ -94,3 +117,6 @@ var x = PublicStruct()
 
 // Trigger a typo correction that reads all members.
 x.notAMember() // expected-error {{value of type 'PublicStruct' has no member 'notAMember'}}
+
+var v = EV()
+let _ = v.opaqueReferencingPrivate()