Just replace the inner abstraction pattern when combining a subtype conversion

into a reabstraction.

Author: rjmccall

lib/SILGen/Conversion.h

@@ -319,6 +319,21 @@ class Conversion {
     return getReabstractionOutputLoweredType();
   }
 
+  /// Given that this conversion is not one of the specialized bridging
+  /// conversion (i.e. it is either a reabstraction or a subtype conversion),
+  /// rebuild it with the given source type.
+  Conversion withSourceType(AbstractionPattern origSourceType,
+                            CanType sourceType,
+                            SILType loweredSourceTy) const;
+  Conversion withSourceType(SILGenFunction &SGF, CanType sourceType) const;
+
+  /// Given that this conversion is not one of the specialized bridging
+  /// conversion (i.e. it is either a reabstraction or a subtype conversion),
+  /// rebuild it with the given result type.
+  Conversion withResultType(AbstractionPattern origResultType,
+                            CanType sourceType,
+                            SILType loweredSourceTy) const;
+
   ManagedValue emit(SILGenFunction &SGF, SILLocation loc,
                     ManagedValue source, SGFContext ctxt) const;
 

lib/SILGen/SILGenConvert.cpp

@@ -1546,39 +1546,43 @@ static bool isMatchedAnyToAnyObjectConversion(CanType from, CanType to) {
   return false;
 }
 
-static Conversion withNewInputType(const Conversion &conv,
-                                   AbstractionPattern origType,
-                                   CanType substType,
-                                   SILType loweredType) {
-  switch (conv.getKind()) {
-  case Conversion::Reabstract:
-    return Conversion::getReabstract(origType, substType, loweredType,
-                                     conv.getReabstractionOutputOrigType(),
-                                     conv.getReabstractionOutputSubstType(),
-                                     conv.getReabstractionOutputLoweredType());
-  case Conversion::Subtype:
-    return Conversion::getSubtype(substType, conv.getBridgingResultType(),
-                                  conv.getBridgingLoweredResultType());
+Conversion
+Conversion::withSourceType(SILGenFunction &SGF, CanType substType) const {
+  return withSourceType(AbstractionPattern(substType), substType,
+                        SGF.getLoweredType(substType));
+}
+
+Conversion
+Conversion::withSourceType(AbstractionPattern origType,
+                           CanType substType, SILType loweredType) const {
+  switch (getKind()) {
+  case Reabstract:
+    return getReabstract(origType, substType, loweredType,
+                         getReabstractionOutputOrigType(),
+                         getReabstractionOutputSubstType(),
+                         getReabstractionOutputLoweredType());
+  case Subtype:
+    return getSubtype(substType, getResultType(), getLoweredResultType());
   default:
-    llvm_unreachable("shouldn't be trying to combine these kinds");
+    llvm_unreachable("operation not supported on specialized bridging "
+                     "conversions");
   }
 }
 
-static Conversion withNewOutputType(const Conversion &conv,
-                                    AbstractionPattern origType,
-                                    CanType substType,
-                                    SILType loweredType) {
-  switch (conv.getKind()) {
-  case Conversion::Reabstract:
-    return Conversion::getReabstract(conv.getReabstractionInputOrigType(),
-                                     conv.getReabstractionInputSubstType(),
-                                     conv.getReabstractionInputLoweredType(),
-                                     origType, substType, loweredType);
-  case Conversion::Subtype:
-    return Conversion::getSubtype(conv.getBridgingSourceType(),
-                                  substType, loweredType);
+Conversion
+Conversion::withResultType(AbstractionPattern origType,
+                           CanType substType, SILType loweredType) const {
+  switch (getKind()) {
+  case Reabstract:
+    return getReabstract(getReabstractionInputOrigType(),
+                         getReabstractionInputSubstType(),
+                         getReabstractionInputLoweredType(),
+                         origType, substType, loweredType);
+  case Subtype:
+    return getSubtype(getSourceType(), substType, loweredType);
   default:
-    llvm_unreachable("shouldn't be trying to combine these kinds");
+    llvm_unreachable("operation not supported on specialized bridging "
+                     "conversions");
   }
 }
 
@@ -1743,12 +1747,10 @@ salvageUncombinableConversion(SILGenFunction &SGF,
 
       // Construct the new conversions with the new intermediate type.
       return CombinedConversions(
-               withNewOutputType(inner, newIntermediateOrigType,
-                                 newIntermediateSubstType,
-                                 newIntermediateLoweredType),
-               withNewInputType(outer, newIntermediateOrigType,
-                                newIntermediateSubstType,
-                                newIntermediateLoweredType));
+               inner.withResultType(newIntermediateOrigType,
+                                    newIntermediateSubstType,
+                                    newIntermediateLoweredType),
+               outer.withSourceType(SGF, newIntermediateSubstType));
     }
   }
 

lib/SILGen/SILGenExpr.cpp

@@ -2853,9 +2853,6 @@ wrappedValueAutoclosurePlaceholder(const AbstractClosureExpr *e) {
 static std::optional<FunctionTypeInfo>
 tryGetSpecializedClosureTypeFromContext(CanAnyFunctionType closureType,
                                         const Conversion &conv) {
-  // NOTE: if you support new kinds of conversion here, make sure you can
-  // rewrite them in narrowClosureConvention below
-
   if (conv.getKind() == Conversion::Reabstract) {
     // We don't care about the input type here; we'll be emitting that
     // based on the closure.
@@ -2881,33 +2878,6 @@ tryGetSpecializedClosureTypeFromContext(CanAnyFunctionType closureType,
   return std::nullopt;
 }
 
-/// Given that tryGetSpecializedClosureTypeFromContext was able to return
-/// specialized closure type information from the given contextual conversion,
-/// construct a new conversion that starts from the given type, which is a
-/// supertype of the previous closure type but a subtype of the final type.
-/// The conversion should end with the same type.
-static Conversion narrowClosureConversion(SILGenFunction &SGF,
-                                          CanAnyFunctionType newClosureType,
-                                          const Conversion &conv) {
-  if (conv.getKind() == Conversion::Reabstract) {
-    auto inputOrigType = conv.getReabstractionInputOrigType();
-    auto inputLoweredTy = SGF.getLoweredType(inputOrigType, newClosureType);
-    return Conversion::getReabstract(inputOrigType, newClosureType,
-                                     inputLoweredTy,
-                                     conv.getReabstractionOutputOrigType(),
-                                     conv.getReabstractionOutputSubstType(),
-                                     conv.getReabstractionOutputLoweredType());
-  }
-
-  if (conv.getKind() == Conversion::Subtype) {
-    return Conversion::getSubtype(newClosureType,
-                                  conv.getBridgingResultType(),
-                                  conv.getBridgingLoweredResultType());
-  }
-
-  llvm_unreachable("mismatch with tryGetSpecializedClosureTypeFromContext");
-}
-
 /// Whether the given abstraction pattern as an opaque thrown error.
 static bool hasOpaqueThrownError(const AbstractionPattern &pattern) {
   if (auto thrownPattern = pattern.getFunctionThrownErrorType())
@@ -3020,7 +2990,7 @@ RValueEmitter::tryEmitConvertedClosure(AbstractClosureExpr *e,
     auto erasedResult = emitClosureReference(e, erasureInfo);
 
     // Narrow the original conversion to start from the erased closure type.
-    auto convAfterErasure = narrowClosureConversion(SGF, erasedClosureType, conv);
+    auto convAfterErasure = conv.withSourceType(SGF, erasedClosureType);
 
     // Apply the narrowed conversion.
     return convAfterErasure.emit(SGF, e, erasedResult, SGFContext());