AST: Fix ReplaceOpaqueTypesWithUnderlyingTypes to consider the curren…

lib/AST/TypeSubstitution.cpp

@@ -1009,6 +1009,7 @@ static Type substOpaqueTypesWithUnderlyingTypesRec(
 /// opaque substitutions are or are not allowed.
 static bool canSubstituteTypeInto(Type ty, const DeclContext *dc,
                                   OpaqueSubstitutionKind kind,
+                                  ResilienceExpansion contextExpansion,
                                   bool isContextWholeModule) {
   TypeDecl *typeDecl = ty->getAnyNominal();
   if (!typeDecl) {
@@ -1049,7 +1050,8 @@ static bool canSubstituteTypeInto(Type ty, const DeclContext *dc,
 
   case OpaqueSubstitutionKind::SubstituteNonResilientModule:
     // Can't access types that are not public from a different module.
-    if (dc->getParentModule() == typeDecl->getDeclContext()->getParentModule())
+    if (dc->getParentModule() == typeDecl->getDeclContext()->getParentModule() &&
+        contextExpansion != ResilienceExpansion::Minimal)
       return typeDecl->getEffectiveAccess() > AccessLevel::FilePrivate;
 
     return typeDecl->getEffectiveAccess() > AccessLevel::Internal;
@@ -1093,10 +1095,13 @@ operator()(SubstitutableType *maybeOpaqueType) const {
   // context.
   auto inContext = this->getContext();
   auto isContextWholeModule = this->isWholeModule();
+  auto contextExpansion = this->contextExpansion;
   if (inContext &&
       partialSubstTy.findIf(
-          [inContext, substitutionKind, isContextWholeModule](Type t) -> bool {
+          [inContext, substitutionKind, isContextWholeModule,
+           contextExpansion](Type t) -> bool {
             if (!canSubstituteTypeInto(t, inContext, substitutionKind,
+                                       contextExpansion,
                                        isContextWholeModule))
               return true;
             return false;
@@ -1204,9 +1209,12 @@ operator()(CanType maybeOpaqueType, Type replacementType,
   // context.
   auto inContext = this->getContext();
   auto isContextWholeModule = this->isWholeModule();
+  auto contextExpansion = this->contextExpansion;
   if (partialSubstTy.findIf(
-          [inContext, substitutionKind, isContextWholeModule](Type t) -> bool {
+          [inContext, substitutionKind, isContextWholeModule,
+          contextExpansion](Type t) -> bool {
             if (!canSubstituteTypeInto(t, inContext, substitutionKind,
+                                       contextExpansion,
                                        isContextWholeModule))
               return true;
             return false;

test/IRGen/Inputs/opaque_result_type_internal_inlinable.swift

@@ -0,0 +1,36 @@
+public protocol P {}
+
+public struct G<T, V> : P {
+
+  var t: T
+  var v: V
+
+  public init(_ t: T, _ v: V) {
+    self.t = t
+    self.v = v
+  }
+}
+
+struct I {
+  public init() {
+  }
+}
+
+public struct E : P {
+  public init() {}
+
+  @inlinable
+  public static var a : some P {
+    return G(E(), C().b())
+  }
+}
+
+public struct C {
+  public init() {}
+
+  @usableFromInline
+  internal func b() -> some P {
+    return G(self, I())
+  }
+}
+

test/IRGen/oapque_result_type_internal.swift

@@ -0,0 +1,13 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -O -disable-availability-checking -emit-module -emit-module-path=%t/R.swiftmodule -module-name=R %S/Inputs/opaque_result_type_internal_inlinable.swift
+// RUN: %target-swift-frontend -O -I %t -disable-availability-checking -c -primary-file %s
+
+import R
+
+// This used to crash because when we were importing E.a the serialized sil
+// contained underlying types that this module does not have access to (internal type `I`).
+
+public func testIt() {
+    var e = E.a
+    print(e)
+}