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

Author: slavapestov

include/swift/AST/ProtocolConformanceRef.h

@@ -205,7 +205,7 @@ class ProtocolConformanceRef {
 
   /// Look up the type witness for an associated type declaration in this
   /// conformance.
-  Type getTypeWitness(Type origType, AssociatedTypeDecl *assocType,
+  Type getTypeWitness(AssociatedTypeDecl *assocType,
                       SubstOptions options = std::nullopt) const;
 
   /// Given a dependent type (expressed in terms of this conformance's

lib/AST/PackConformance.cpp

@@ -112,17 +112,15 @@ PackType *PackConformance::getTypeWitness(
     // conformance.
     if (auto *packExpansion = packElement->getAs<PackExpansionType>()) {
       auto assocTypePattern =
-        conformances[i].getTypeWitness(packExpansion->getPatternType(),
-                                       assocType, options);
+        conformances[i].getTypeWitness(assocType, options);
 
       packElements.push_back(PackExpansionType::get(
           assocTypePattern, packExpansion->getCountType()));
 
     // If the pack element is a scalar type, replace the scalar type with
     // the associated type witness from the pattern conformance.
     } else {
-      auto assocTypeScalar =
-        conformances[i].getTypeWitness(packElement, assocType, options);
+      auto assocTypeScalar = conformances[i].getTypeWitness(assocType, options);
       packElements.push_back(assocTypeScalar);
     }
   }

lib/AST/ProtocolConformanceRef.cpp

@@ -160,7 +160,7 @@ ProtocolConformanceRef::getTypeWitnessByName(Type type, Identifier name) const {
   if (!assocType)
     return ErrorType::get(proto->getASTContext());
 
-  return getTypeWitness(type, assocType);
+  return getTypeWitness(assocType);
 }
 
 ConcreteDeclRef
@@ -190,43 +190,32 @@ ProtocolConformanceRef::getConditionalRequirements() const {
     return {};
 }
 
-Type ProtocolConformanceRef::getTypeWitness(Type conformingType,
-                                            AssociatedTypeDecl *assocType,
+Type ProtocolConformanceRef::getTypeWitness(AssociatedTypeDecl *assocType,
                                             SubstOptions options) const {
+  if (isInvalid())
+    return ErrorType::get(assocType->getASTContext());
+
   if (isPack()) {
     auto *pack = getPack();
-    ASSERT(conformingType->isEqual(pack->getType()));
-    return pack->getTypeWitness(assocType);
+    return pack->getTypeWitness(assocType, options);
   }
 
-  auto failed = [&]() {
-    return DependentMemberType::get(ErrorType::get(conformingType),
-                                    assocType);
-  };
-
-  if (isInvalid())
-    return failed();
-
-  auto proto = getProtocol();
-  ASSERT(assocType->getProtocol() == proto);
-
   if (isConcrete()) {
-    auto witnessType = getConcrete()->getTypeWitness(assocType, options);
-    if (!witnessType || witnessType->is<ErrorType>())
-      return failed();
+    auto *concrete = getConcrete();
+    ASSERT(concrete->getProtocol() == assocType->getProtocol());
+
+    auto witnessType = concrete->getTypeWitness(assocType, options);
+    if (!witnessType)
+      return ErrorType::get(assocType->getASTContext());
     return witnessType;
   }
 
-  ASSERT(isAbstract());
+  auto *abstract = getAbstract();
+  auto conformingType = abstract->getType();
+  ASSERT(abstract->getProtocol() == assocType->getProtocol());
 
-  if (auto *archetypeType = conformingType->getAs<ArchetypeType>()) {
+  if (auto *archetypeType = conformingType->getAs<ArchetypeType>())
     return archetypeType->getNestedType(assocType);
-  }
-
-  CONDITIONAL_ASSERT(conformingType->isTypeParameter() ||
-                     conformingType->isTypeVariableOrMember() ||
-                     conformingType->is<UnresolvedType>() ||
-                     conformingType->is<PlaceholderType>());
 
   return DependentMemberType::get(conformingType, assocType);
 }

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -302,7 +302,7 @@ ConcreteContraction::substTypeParameterRec(Type type, Position position) const {
         return std::nullopt;
       }
 
-      return conformance.getTypeWitness(*substBaseType, assocType);
+      return conformance.getTypeWitness(assocType);
     }
 
     // An unresolved DependentMemberType stores an identifier. Handle this

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -346,7 +346,7 @@ static Type substPrefixType(Type type, unsigned suffixLength, Type prefixType,
   auto *assocDecl = memberType->getAssocType();
   auto *proto = assocDecl->getProtocol();
   auto conformance = lookupConformance(substBaseType, proto);
-  return conformance.getTypeWitness(substBaseType, assocDecl);
+  return conformance.getTypeWitness(assocDecl);
 }
 
 Type RequirementMachine::getReducedTypeParameter(

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -665,7 +665,7 @@ struct InferRequirementsWalker : public TypeWalker {
         auto addSameTypeConstraint = [&](Type firstType,
                                          AssociatedTypeDecl *assocType) {
           auto conformance = lookupConformance(firstType, differentiableProtocol);
-          auto secondType = conformance.getTypeWitness(firstType, assocType);
+          auto secondType = conformance.getTypeWitness(assocType);
           reqs.push_back({Requirement(RequirementKind::SameType,
                                       firstType, secondType),
                           SourceLoc()});

lib/AST/Type.cpp

@@ -4569,7 +4569,7 @@ TypeBase::getAutoDiffTangentSpace(LookupConformanceFn lookupConformance) {
   // Try to get the `TangentVector` associated type of `base`.
   // Return the associated type if it is valid.
   auto conformance = swift::lookupConformance(this, differentiableProtocol);
-  auto assocTy = conformance.getTypeWitness(this, assocDecl);
+  auto assocTy = conformance.getTypeWitness(assocDecl);
   if (!assocTy->hasError())
     return cache(TangentSpace::getTangentVector(assocTy));
 

lib/AST/TypeSubstitution.cpp

@@ -443,7 +443,7 @@ Type TypeSubstituter::transformDependentMemberType(DependentMemberType *dependen
     IFS.lookupConformance(origBase->getCanonicalType(), substBase,
                           proto, level);
 
-  auto result = conformance.getTypeWitness(substBase, assocType, IFS.getOptions());
+  auto result = conformance.getTypeWitness(assocType, IFS.getOptions());
   if (result->is<ErrorType>())
     return DependentMemberType::get(ErrorType::get(substBase), assocType);
   return result;

lib/Sema/ConstraintSystem.cpp

@@ -1709,7 +1709,7 @@ struct TypeSimplifier {
           return memberTy;
         }
 
-        auto result = conformance.getTypeWitness(lookupBaseType, assocType);
+        auto result = conformance.getTypeWitness(assocType);
         if (result && !result->hasError())
           return result;
       }

lib/Sema/TypeCheckEffects.cpp

@@ -1352,8 +1352,7 @@ class ApplyClassifier {
     }
   }
 
-  Classification classifyConformance(Type type,
-                                     ProtocolConformanceRef conformanceRef,
+  Classification classifyConformance(ProtocolConformanceRef conformanceRef,
                                      EffectKind kind) {
     if (conformanceRef.isInvalid())
       return Classification::forInvalidCode();
@@ -1374,8 +1373,7 @@ class ApplyClassifier {
           conditional = ConditionalEffectKind::Always;
 
         // Use the Failure type witness, when present.
-        Type thrownError = conformanceRef.getTypeWitness(
-            type, failureAssocType);
+        Type thrownError = conformanceRef.getTypeWitness(failureAssocType);
         return Classification::forThrows(
             thrownError, conditional,
             /*FIXME*/PotentialEffectReason::forConformance());
@@ -1671,13 +1669,11 @@ class ApplyClassifier {
           if (req.getKind() != RequirementKind::Conformance)
             continue;
 
-          Type type = req.getFirstType().subst(substitutions);
-
           auto conformanceRef = substitutions.lookupConformance(
               req.getFirstType()->getCanonicalType(), req.getProtocolDecl());
           assert(conformanceRef);
 
-          result.merge(classifyConformance(type, conformanceRef, kind));
+          result.merge(classifyConformance(conformanceRef, kind));
         }
 
         // 'ByConformance' is a superset of 'ByClosure', so check for