Merge pull request swiftlang#9204 from jckarter/opened-type-subst

SILCloner: Map opened types using Type::subst instead of transform.

Author: jckarter

include/swift/AST/Type.h

@@ -72,6 +72,15 @@ struct QueryTypeSubstitutionMap {
   Type operator()(SubstitutableType *type) const;
 };
 
+/// A function object suitable for use as a \c TypeSubstitutionFn that
+/// queries an underlying \c TypeSubstitutionMap, or returns the original type
+/// if no match was found.
+struct QueryTypeSubstitutionMapOrIdentity {
+  const TypeSubstitutionMap &substitutions;
+  
+  Type operator()(SubstitutableType *type) const;
+};
+
 /// A function object suitable for use as a \c TypeSubstitutionFn that
 /// queries an underlying \c SubstitutionMap.
 struct QuerySubstitutionMap {

include/swift/SIL/SILCloner.h

@@ -118,10 +118,21 @@ class SILCloner : protected SILVisitor<ImplClass> {
   }
 
   SILType getTypeInClonedContext(SILType Ty) {
+    auto objectTy = Ty.getSwiftRValueType();
+    // Do not substitute opened existential types, if we do not have any.
+    if (!objectTy->hasOpenedExistential())
+      return Ty;
+    // Do not substitute opened existential types, if it is not required.
+    // This is often the case when cloning basic blocks inside the same
+    // function.
+    if (OpenedExistentialSubs.empty())
+      return Ty;
+
     // Substitute opened existential types, if we have any.
-    return SILType::getPrimitiveObjectType(
-      getASTTypeInClonedContext(Ty.getSwiftRValueType()))
-      .copyCategory(Ty);
+    return Ty.subst(
+      Builder.getModule(),
+      QueryTypeSubstitutionMapOrIdentity{OpenedExistentialSubs},
+      MakeAbstractConformanceForGenericType());
   }
   SILType getOpType(SILType Ty) {
     Ty = getTypeInClonedContext(Ty);
@@ -138,24 +149,10 @@ class SILCloner : protected SILVisitor<ImplClass> {
     if (OpenedExistentialSubs.empty())
       return ty->getCanonicalType();
 
-    return ty.transform(
-      [&](Type t) -> Type {
-        if (t->isOpenedExistential()) {
-          auto found = OpenedExistentialSubs.find(
-            t->castTo<ArchetypeType>());
-          // If an opened existential is supposed to be
-          // remapped, it is guaranteed by construction
-          // to be in the OpenedExistentialSubs, because
-          // a cloner always processes definitions of
-          // opened existentials before their uses and
-          // adds found opened existentials definitions
-          // to the map.
-          if (found != OpenedExistentialSubs.end())
-            return found->second;
-          return t;
-        }
-        return t;
-      })->getCanonicalType();
+    return ty.subst(
+      QueryTypeSubstitutionMapOrIdentity{OpenedExistentialSubs},
+      MakeAbstractConformanceForGenericType()
+    )->getCanonicalType();
   }
 
   CanType getOpASTType(CanType ty) {

lib/AST/Type.cpp

@@ -50,6 +50,16 @@ Type QueryTypeSubstitutionMap::operator()(SubstitutableType *type) const {
   return Type();
 }
 
+Type
+QueryTypeSubstitutionMapOrIdentity::operator()(SubstitutableType *type) const {
+  auto key = type->getCanonicalType()->castTo<SubstitutableType>();
+  auto known = substitutions.find(key);
+  if (known != substitutions.end() && known->second)
+    return known->second;
+  
+  return type;
+}
+
 Type QuerySubstitutionMap::operator()(SubstitutableType *type) const {
   auto key = cast<SubstitutableType>(type->getCanonicalType());
   return subMap.lookupSubstitution(key);