Merge pull request #80482 from slavapestov/abstract-conformance-cleanup

AST: Simplify ProtocolConformanceRef operations a little bit

Author: slavapestov

include/swift/AST/GenericEnvironment.h

@@ -325,19 +325,6 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// abstraction level of their associated type requirements.
   SILType mapTypeIntoContext(SILModule &M, SILType type) const;
 
-  /// Map an interface type's protocol conformance into the corresponding
-  /// conformance for the contextual type.
-  static std::pair<Type, ProtocolConformanceRef>
-  mapConformanceRefIntoContext(GenericEnvironment *genericEnv,
-                               Type conformingType,
-                               ProtocolConformanceRef conformance);
-
-  /// Map an interface type's protocol conformance into the corresponding
-  /// conformance for the contextual type.
-  std::pair<Type, ProtocolConformanceRef>
-  mapConformanceRefIntoContext(Type conformingType,
-                               ProtocolConformanceRef conformance) const;
-
   /// Returns a substitution map that sends every generic parameter to its
   /// corresponding archetype in this generic environment.
   SubstitutionMap getForwardingSubstitutionMap() const;

include/swift/AST/ProtocolAssociations.h

@@ -23,51 +23,6 @@
 
 namespace swift {
 
-/// A type associated with a protocol.
-///
-/// This struct exists largely so that we can maybe eventually
-/// generalize it to an arbitrary path.
-class AssociatedType {
-  AssociatedTypeDecl *Association;
-  using AssociationInfo = llvm::DenseMapInfo<AssociatedTypeDecl*>;
-
-  struct SpecialValue {};
-  explicit AssociatedType(SpecialValue _, AssociatedTypeDecl *specialValue)
-      : Association(specialValue) {}
-
-public:
-  explicit AssociatedType(AssociatedTypeDecl *association)
-      : Association(association) {
-    assert(association);
-  }
-
-  ProtocolDecl *getSourceProtocol() const {
-    return Association->getProtocol();
-  }
-
-  AssociatedTypeDecl *getAssociation() const {
-    return Association;
-  }
-
-  friend bool operator==(AssociatedType lhs, AssociatedType rhs) {
-    return lhs.Association == rhs.Association;
-  }
-  friend bool operator!=(AssociatedType lhs, AssociatedType rhs) {
-    return !(lhs == rhs);
-  }
-
-  unsigned getHashValue() const {
-    return llvm::hash_value(Association);
-  }
-
-  static AssociatedType getEmptyKey() {
-    return AssociatedType(SpecialValue(), AssociationInfo::getEmptyKey());
-  }
-  static AssociatedType getTombstoneKey() {
-    return AssociatedType(SpecialValue(), AssociationInfo::getTombstoneKey());
-  }
-};
-
 /// A base conformance of a protocol.
 class BaseConformance {
   ProtocolDecl *Source;
@@ -147,24 +102,6 @@ class AssociatedConformance {
 } // end namespace swift
 
 namespace llvm {
-  template <> struct DenseMapInfo<swift::AssociatedType> {
-    static inline swift::AssociatedType getEmptyKey() {
-      return swift::AssociatedType::getEmptyKey();
-    }
-
-    static inline swift::AssociatedType getTombstoneKey() {
-      return swift::AssociatedType::getTombstoneKey();
-    }
-
-    static unsigned getHashValue(swift::AssociatedType val) {
-      return val.getHashValue();
-    }
-
-    static bool isEqual(swift::AssociatedType lhs, swift::AssociatedType rhs) {
-      return lhs == rhs;
-    }
-  };
-
   template <> struct DenseMapInfo<swift::AssociatedConformance> {
     static inline swift::AssociatedConformance getEmptyKey() {
       return swift::AssociatedConformance::getEmptyKey();

include/swift/AST/ProtocolConformance.h

@@ -363,10 +363,6 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
   /// Retrieve the protocol conformance for the inherited protocol.
   ProtocolConformance *getInheritedConformance(ProtocolDecl *protocol) const;
 
-  /// Given a dependent type expressed in terms of the self parameter,
-  /// map it into the context of this conformance.
-  Type getAssociatedType(Type assocType) const;
-
   /// Given that the requirement signature of the protocol directly states
   /// that the given dependent type must conform to the given protocol,
   /// return its associated conformance.

include/swift/AST/ProtocolConformanceRef.h

@@ -185,38 +185,36 @@ 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;
 
   /// 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
   /// protocol), follow it from the conforming type.
-  Type getAssociatedType(Type origType, Type dependentType) const;
+  Type getAssociatedType(Type dependentType) const;
 
   /// Given a dependent type (expressed in terms of this conformance's
   /// protocol) and conformance, follow it from the conforming type.
   ProtocolConformanceRef
-  getAssociatedConformance(Type origType, Type dependentType,
-                           ProtocolDecl *requirement) const;
+  getAssociatedConformance(Type dependentType, ProtocolDecl *requirement) const;
 
   SWIFT_DEBUG_DUMP;
   void dump(llvm::raw_ostream &out, unsigned indent = 0,
@@ -235,15 +233,15 @@ class ProtocolConformanceRef {
     return llvm::hash_value(conformance.Union.getOpaqueValue());
   }
 
-  Type getTypeWitnessByName(Type type, Identifier name) const;
+  Type getTypeWitnessByName(Identifier name) const;
 
   /// Find a particular named function witness for a type that conforms to
   /// the given protocol.
   ///
   /// \param type The conforming type.
   ///
   /// \param name The name of the requirement.
-  ConcreteDeclRef getWitnessByName(Type type, DeclName name) const;
+  ConcreteDeclRef getWitnessByName(DeclName name) const;
 
   /// Determine whether this conformance is canonical.
   bool isCanonical() const;

include/swift/AST/SubstitutionMap.h

@@ -187,6 +187,10 @@ class SubstitutionMap {
   SubstitutionMap mapIntoTypeExpansionContext(
       TypeExpansionContext context) const;
 
+  /// Create a substitution map for a protocol conformance.
+  static SubstitutionMap
+  getProtocolSubstitutions(ProtocolConformanceRef conformance);
+
   /// Create a substitution map for a protocol conformance.
   static SubstitutionMap
   getProtocolSubstitutions(ProtocolDecl *protocol,

include/swift/AST/Types.h

@@ -5028,7 +5028,7 @@ Type substOpaqueTypesWithUnderlyingTypes(Type type,
 CanType substOpaqueTypesWithUnderlyingTypes(CanType type,
                                             TypeExpansionContext context);
 ProtocolConformanceRef
-substOpaqueTypesWithUnderlyingTypes(ProtocolConformanceRef ref, Type origType,
+substOpaqueTypesWithUnderlyingTypes(ProtocolConformanceRef ref,
                                     TypeExpansionContext context);
 namespace Lowering {
   class TypeConverter;

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);
     }
@@ -576,7 +576,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
           !context.shouldLookThroughOpaqueTypeArchetypes())
         return C;
 
-      return substOpaqueTypesWithUnderlyingTypes(C, Ty, context);
+      return substOpaqueTypesWithUnderlyingTypes(C, context);
     }
 
     return C;

include/swift/SIL/SILWitnessVisitor.h

@@ -100,7 +100,7 @@ template <class T> class SILWitnessVisitor : public ASTVisitor<T> {
       // If this is a new associated type (which does not override an
       // existing associated type), add it.
       if (associatedType->getOverriddenDecls().empty())
-        asDerived().addAssociatedType(AssociatedType(associatedType));
+        asDerived().addAssociatedType(associatedType);
     }
 
     if (asDerived().shouldVisitRequirementSignatureOnly())

lib/AST/ASTContext.cpp

@@ -1678,7 +1678,7 @@ ASTContext::getBuiltinInitDecl(NominalTypeDecl *decl,
   }
 
   auto *ctx = const_cast<ASTContext *>(this);
-  witness = builtinConformance.getWitnessByName(type, initName(*ctx));
+  witness = builtinConformance.getWitnessByName(initName(*ctx));
   if (!witness) {
     assert(false && "Missing required witness");
     witness = ConcreteDeclRef();
@@ -6486,7 +6486,7 @@ Type ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
       *bridgedValueType = type;
 
     // Find the Objective-C class type we bridge to.
-    Type witnessTy = conformance.getTypeWitnessByName(type, Id_ObjectiveCType);
+    Type witnessTy = conformance.getTypeWitnessByName(Id_ObjectiveCType);
     // If Objective-C import is broken, witness type would be a dependent member
     // with `<<error type>>` base.
     return (witnessTy && !witnessTy->hasError()) ? witnessTy : Type();

lib/AST/ActorIsolation.cpp

@@ -61,7 +61,7 @@ ActorIsolation::forActorInstanceParameter(Expr *actor,
     if (auto globalActor = ctx.getProtocol(KnownProtocolKind::GlobalActor)) {
       auto conformance = checkConformance(baseType, globalActor);
       if (conformance &&
-          conformance.getWitnessByName(baseType, ctx.Id_shared) == declRef) {
+          conformance.getWitnessByName(ctx.Id_shared) == declRef) {
         return ActorIsolation::forGlobalActor(baseType);
       }
     }