SIL: Fix opaque type erasure after clearing [serialized] flags

After serialization, we no longer need to enforce the resilience
boundary between inlinable and non-inlinable functions, so we
make a pass over the SIL to clear [serialized] flags and
substitute any opaque return types.

The logic for AST types was wrong; we can't just lower the type
and get the AST type out. Instead, do the same thing that
TypeSubstCloner does.

Fixes rdar://problem/115355709.

Author: slavapestov

lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp

@@ -57,11 +57,11 @@ class MapOpaqueArchetypes : public SILCloner<MapOpaqueArchetypes> {
              .getTypeExpansionContext()
              .shouldLookThroughOpaqueTypeArchetypes())
       return ty;
-    // Remap types containing opaque result types in the current context.
-    return getBuilder()
-        .getTypeLowering(SILType::getPrimitiveObjectType(ty))
-        .getLoweredType()
-        .getASTType();
+
+    return substOpaqueTypesWithUnderlyingTypes(
+        ty,
+        TypeExpansionContext(getBuilder().getFunction()),
+        /*allowLoweredTypes=*/false);
   }
 
   ProtocolConformanceRef remapConformance(Type ty,

test/SIL/Serialization/opaque_return_type_serialize.swift

@@ -0,0 +1,18 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module %s
+
+// We substitute away opaque archetypes after serialization;
+// make sure this correctly handles unlowered types like
+// AST functions and packs.
+
+public func horse<T>(_: T) {}
+
+@_transparent public func packCallee<each T>(_ t: repeat each T) {
+  repeat horse(each t)
+}
+
+@inlinable public func packCaller() {
+  packCallee(opaque())
+}
+
+public func opaque() -> some Any { return 3 }