AST: Remove origType parameter from ProtocolConformanceRef::subst()

Author: slavapestov

include/swift/AST/ProtocolConformanceRef.h

@@ -185,20 +185,19 @@ class ProtocolConformanceRef {
   ProtocolDecl *getProtocol() const;
 
   /// Apply a substitution to the conforming type.
-  ProtocolConformanceRef subst(Type origType, SubstitutionMap subMap,
+  ProtocolConformanceRef subst(SubstitutionMap subMap,
                                SubstOptions options = std::nullopt) const;
 
   /// Apply a substitution to the conforming type.
-  ProtocolConformanceRef subst(Type origType, TypeSubstitutionFn subs,
+  ProtocolConformanceRef subst(TypeSubstitutionFn subs,
                                LookupConformanceFn conformances,
                                SubstOptions options = std::nullopt) const;
 
   /// Apply a substitution to the conforming type.
   ///
   /// This function should generally not be used outside of the substitution
   /// subsystem.
-  ProtocolConformanceRef subst(Type origType,
-                               InFlightSubstitution &IFS) const;
+  ProtocolConformanceRef subst(InFlightSubstitution &IFS) const;
 
   /// Map contextual types to interface types in the conformance.
   ProtocolConformanceRef mapConformanceOutOfContext() const;

include/swift/SIL/SILCloner.h

@@ -564,7 +564,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
       if (Functor.hasLocalArchetypes())
         options |= SubstFlags::SubstituteLocalArchetypes;
 
-      C = C.subst(Ty, Functor, Functor, options);
+      C = C.subst(Functor, Functor, options);
       if (asImpl().shouldSubstOpaqueArchetypes())
         Ty = Ty.subst(Functor, Functor, options);
     }

lib/AST/GenericEnvironment.cpp

@@ -766,7 +766,7 @@ std::pair<Type, ProtocolConformanceRef>
 GenericEnvironment::mapConformanceRefIntoContext(
                                      Type conformingInterfaceType,
                                      ProtocolConformanceRef conformance) const {
-  auto contextConformance = conformance.subst(conformingInterfaceType,
+  auto contextConformance = conformance.subst(
     QueryInterfaceTypeSubstitutions(this),
     LookUpConformanceInModule());
 

lib/AST/PackConformance.cpp

@@ -199,15 +199,12 @@ PackConformance::subst(InFlightSubstitution &IFS) const {
         // Just substitute the conformance.  We don't directly represent
         // pack expansion conformances here; it's sort of implicit in the
         // corresponding pack element type.
-        substConformances.push_back(
-            origConformances[i].subst(origExpansion->getPatternType(), IFS));
+        substConformances.push_back(origConformances[i].subst(IFS));
       });
     } else {
       // Substitute a scalar element of the original pack.
       substElementTypes.push_back(origElementType.subst(IFS));
-
-      substConformances.push_back(
-          origConformances[i].subst(origElementType, IFS));
+      substConformances.push_back(origConformances[i].subst(IFS));
     }
   }
 

lib/AST/ProtocolConformance.cpp

@@ -896,14 +896,7 @@ SpecializedProtocolConformance::getAssociatedConformance(Type assocType,
   ProtocolConformanceRef conformance =
     GenericConformance->getAssociatedConformance(assocType, protocol);
 
-  auto subMap = getSubstitutionMap();
-
-  Type origType =
-    (conformance.isConcrete()
-       ? conformance.getConcrete()->getType()
-       : GenericConformance->getAssociatedType(assocType));
-
-  return conformance.subst(origType, subMap);
+  return conformance.subst(getSubstitutionMap());
 }
 
 ConcreteDeclRef

lib/AST/ProtocolConformanceRef.cpp

@@ -67,24 +67,22 @@ ProtocolDecl *ProtocolConformanceRef::getProtocol() const {
 }
 
 ProtocolConformanceRef
-ProtocolConformanceRef::subst(Type origType,
-                              SubstitutionMap subMap,
+ProtocolConformanceRef::subst(SubstitutionMap subMap,
                               SubstOptions options) const {
   InFlightSubstitutionViaSubMap IFS(subMap, options);
-  return subst(origType, IFS);
+  return subst(IFS);
 }
 
 ProtocolConformanceRef
-ProtocolConformanceRef::subst(Type origType,
-                              TypeSubstitutionFn subs,
+ProtocolConformanceRef::subst(TypeSubstitutionFn subs,
                               LookupConformanceFn conformances,
                               SubstOptions options) const {
   InFlightSubstitution IFS(subs, conformances, options);
-  return subst(origType, IFS);
+  return subst(IFS);
 }
 
 ProtocolConformanceRef
-ProtocolConformanceRef::subst(Type origType, InFlightSubstitution &IFS) const {
+ProtocolConformanceRef::subst(InFlightSubstitution &IFS) const {
   if (isInvalid())
     return *this;
 
@@ -93,36 +91,28 @@ ProtocolConformanceRef::subst(Type origType, InFlightSubstitution &IFS) const {
   if (isPack())
     return getPack()->subst(IFS);
 
-  ASSERT(isAbstract());
-  auto *proto = getProtocol();
+  auto *abstract = getAbstract();
+  auto origType = abstract->getType();
+  auto *proto = abstract->getProtocol();
 
   // If the type is an opaque archetype, the conformance will remain abstract,
   // unless we're specifically substituting opaque types.
-  if (origType->getAs<OpaqueTypeArchetypeType>()) {
-    if (!IFS.shouldSubstituteOpaqueArchetypes()) {
-      return forAbstract(origType.subst(IFS), proto);
-    }
+  if (origType->is<OpaqueTypeArchetypeType>() &&
+      !IFS.shouldSubstituteOpaqueArchetypes()) {
+    return forAbstract(origType.subst(IFS), proto);
   }
 
-  // FIXME: Handle local archetypes as above!
-
-  // Otherwise, compute the substituted type.
-  auto substType = origType.subst(IFS);
-
-  // If the type is an existential, it must be self-conforming.
-  // FIXME: This feels like it's in the wrong place.
-  if (substType->isExistentialType()) {
-    auto optConformance =
-        lookupConformance(substType, proto, /*allowMissing=*/true);
-    if (optConformance)
-      return optConformance;
-
-    return ProtocolConformanceRef::forInvalid();
+  // If the type is a local archetype, the conformance will remain abstract,
+  // unless we're specifically substituting local types.
+  if (origType->is<LocalArchetypeType>() &&
+      !IFS.shouldSubstituteLocalArchetypes()) {
+    return forAbstract(origType.subst(IFS), proto);
   }
 
   // Local conformance lookup into the substitution map.
   // FIXME: Pack element level?
-  return IFS.lookupConformance(origType->getCanonicalType(), substType, proto,
+  return IFS.lookupConformance(origType->getCanonicalType(),
+                               origType.subst(IFS), proto,
                                /*level=*/0);
 }
 

lib/AST/SubstitutionMap.cpp

@@ -369,23 +369,10 @@ SubstitutionMap SubstitutionMap::subst(InFlightSubstitution &IFS) const {
 
   auto genericSig = getGenericSignature();
   for (const auto &req : genericSig.getRequirements()) {
-    if (req.getKind() != RequirementKind::Conformance) continue;
-
-    auto conformance = oldConformances[0];
-
-    // Fast path for concrete case -- we don't need to compute substType
-    // at all.
-    if (conformance.isConcrete() &&
-        !IFS.shouldSubstituteOpaqueArchetypes()) {
-      newConformances.push_back(
-        ProtocolConformanceRef(conformance.getConcrete()->subst(IFS)));
-    } else {
-      auto origType = req.getFirstType();
-      auto substType = origType.subst(*this);
+    if (req.getKind() != RequirementKind::Conformance)
+      continue;
 
-      newConformances.push_back(conformance.subst(substType, IFS));
-    }
-    
+    newConformances.push_back(oldConformances[0].subst(IFS));
     oldConformances = oldConformances.slice(1);
   }
 

lib/AST/TypeSubstitution.cpp

@@ -1094,7 +1094,7 @@ static ProtocolConformanceRef substOpaqueTypesWithUnderlyingTypesRec(
     llvm::DenseSet<ReplaceOpaqueTypesWithUnderlyingTypes::SeenDecl> &decls) {
   ReplaceOpaqueTypesWithUnderlyingTypes replacer(inContext, contextExpansion,
                                                  isWholeModuleContext, decls);
-  return ref.subst(origType, replacer, replacer,
+  return ref.subst(replacer, replacer,
                    SubstFlags::SubstituteOpaqueArchetypes |
                    SubstFlags::PreservePackExpansionLevel);
 }
@@ -1104,7 +1104,7 @@ ProtocolConformanceRef swift::substOpaqueTypesWithUnderlyingTypes(
   ReplaceOpaqueTypesWithUnderlyingTypes replacer(
       context.getContext(), context.getResilienceExpansion(),
       context.isWholeModuleContext());
-  return ref.subst(origType, replacer, replacer,
+  return ref.subst(replacer, replacer,
                    SubstFlags::SubstituteOpaqueArchetypes);
 }
 
@@ -1159,8 +1159,7 @@ operator()(CanType maybeOpaqueType, Type replacementType,
   auto partialSubstRef =
       subs->lookupConformance(archetype->getInterfaceType()->getCanonicalType(),
                               protocol);
-  auto substRef =
-      partialSubstRef.subst(partialSubstTy, outerSubs);
+  auto substRef = partialSubstRef.subst(outerSubs);
 
   // If the type still contains opaque types, recur.
   if (substTy->hasOpaqueArchetype()) {

lib/IRGen/GenReflection.cpp

@@ -602,7 +602,7 @@ IRGenModule::emitWitnessTableRefString(CanType type,
             type = genericEnv->mapTypeIntoContext(type)->getCanonicalType();
           }
           if (origType->hasTypeParameter()) {
-            conformance = conformance.subst(origType,
+            conformance = conformance.subst(
                 genericEnv->getForwardingSubstitutionMap());
           }
           auto ret = emitWitnessTableRef(IGF, type, conformance);

lib/SIL/IR/SILTypeSubstitution.cpp

@@ -282,7 +282,7 @@ class SILTypeSubstituter :
       selfType = next;
     }
 
-    auto substConformance = conformance.subst(selfType, IFS);
+    auto substConformance = conformance.subst(IFS);
 
     // Substitute the underlying conformance of opaque type archetypes if we
     // should look through opaque archetypes.

lib/SILGen/SILGenExpr.cpp

@@ -4320,9 +4320,8 @@ getOrCreateKeyPathEqualsAndHash(SILGenModule &SGM,
       auto hashable = index.Hashable;
       if (genericEnv) {
         formalTy = genericEnv->mapTypeIntoContext(formalTy)->getCanonicalType();
-        hashable = hashable.subst(index.FormalType,
-          [&](Type t) -> Type { return genericEnv->mapTypeIntoContext(t); },
-          LookUpConformanceInModule());
+        hashable = hashable.subst(
+          genericEnv->getForwardingSubstitutionMap());
       }
 
       // Set up a substitution of Self => IndexType.

lib/Sema/AssociatedTypeInference.cpp

@@ -2906,8 +2906,7 @@ bool AssociatedTypeInference::checkCurrentTypeWitnesses(
   if (auto *genericEnv = conformance->getGenericEnvironment()) {
     typeInContext = genericEnv->mapTypeIntoContext(typeInContext);
     conformanceInContext =
-      conformanceInContext.subst(conformance->getType(),
-                                 genericEnv->getForwardingSubstitutionMap());
+      conformanceInContext.subst(genericEnv->getForwardingSubstitutionMap());
   }
 
   auto substitutions =

lib/Sema/TypeCheckProtocol.cpp

@@ -5237,8 +5237,7 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
   if (auto *genericEnv = conformance->getGenericEnvironment()) {
     typeInContext = genericEnv->mapTypeIntoContext(typeInContext);
     conformanceInContext =
-      conformanceInContext.subst(conformance->getType(),
-                                 genericEnv->getForwardingSubstitutionMap());
+      conformanceInContext.subst(genericEnv->getForwardingSubstitutionMap());
   }
   auto substitutions = SubstitutionMap::getProtocolSubstitutions(
       proto, typeInContext, conformanceInContext);