Merge pull request swiftlang#77664 from slavapestov/abstract-conformance-prep

slavapestov · web-flow · commit 12a942bf2870 · 2024-11-16T22:10:31.000-05:00
AST: Introduce ProtocolConformanceRef::forAbstract()
diff --git a/include/swift/AST/ProtocolConformanceRef.h b/include/swift/AST/ProtocolConformanceRef.h
@@ -59,13 +59,15 @@ class ProtocolConformanceRef {
 
   explicit ProtocolConformanceRef(UnionType value) : Union(value) {}
 
-public:
   /// Create an abstract protocol conformance reference.
   explicit ProtocolConformanceRef(ProtocolDecl *proto) : Union(proto) {
     assert(proto != nullptr &&
            "cannot construct ProtocolConformanceRef with null");
   }
 
+public:
+  ProtocolConformanceRef() : Union() {}
+
   /// Create a concrete protocol conformance reference.
   explicit ProtocolConformanceRef(ProtocolConformance *conf) : Union(conf) {
     assert(conf != nullptr &&
@@ -78,9 +80,6 @@ class ProtocolConformanceRef {
            "cannot construct ProtocolConformanceRef with null");
   }
 
-  ProtocolConformanceRef(std::nullptr_t = nullptr)
-      : Union((ProtocolDecl *)nullptr) {}
-
   static ProtocolConformanceRef forInvalid() {
     return ProtocolConformanceRef();
   }
@@ -94,10 +93,9 @@ class ProtocolConformanceRef {
 
   explicit operator bool() const { return !isInvalid(); }
 
-  /// Create either a concrete or an abstract protocol conformance reference,
-  /// depending on whether ProtocolConformance is null.
-  explicit ProtocolConformanceRef(ProtocolDecl *protocol,
-                                  ProtocolConformance *conf);
+  /// Create an abstract conformance for a type parameter or archetype.
+  static ProtocolConformanceRef forAbstract(Type subjectType,
+                                            ProtocolDecl *protocol);
 
   bool isConcrete() const {
     return !isInvalid() && Union.is<ProtocolConformance*>();
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -93,7 +93,7 @@ struct SubstitutionMapWithLocalArchetypes {
     if (SubsMap)
       return SubsMap->lookupConformance(origType, proto);
 
-    return ProtocolConformanceRef(proto);
+    return ProtocolConformanceRef::forAbstract(substType, proto);
   }
 
   void dump(llvm::raw_ostream &out) const {
diff --git a/include/swift/Sema/ConstraintSystem.h b/include/swift/Sema/ConstraintSystem.h
@@ -1625,7 +1625,7 @@ class Solution {
 
   /// The set of conformances synthesized during solving (i.e. for
   /// ad-hoc distributed `SerializationRequirement` conformances).
-  llvm::DenseMap<ConstraintLocator *, ProtocolConformanceRef>
+  llvm::DenseMap<ConstraintLocator *, ProtocolDecl *>
       SynthesizedConformances;
 
   /// Record a new argument matching choice for given locator that maps a
@@ -2426,7 +2426,7 @@ class ConstraintSystem {
 
   /// The set of conformances synthesized during solving (i.e. for
   /// ad-hoc distributed `SerializationRequirement` conformances).
-  llvm::DenseMap<ConstraintLocator *, ProtocolConformanceRef>
+  llvm::DenseMap<ConstraintLocator *, ProtocolDecl *>
       SynthesizedConformances;
 
 private:
@@ -4948,7 +4948,7 @@ class ConstraintSystem {
                                             TypeMatchOptions flags);
 
   void recordSynthesizedConformance(ConstraintLocator *locator,
-                                    ProtocolConformanceRef conformance);
+                                    ProtocolDecl *conformance);
 
   /// Attempt to simplify the given conformance constraint.
   ///
diff --git a/lib/APIDigester/ModuleAnalyzerNodes.cpp b/lib/APIDigester/ModuleAnalyzerNodes.cpp
@@ -1976,7 +1976,8 @@ SwiftDeclCollector::addConformancesToTypeDecl(SDKNodeDeclType *Root,
   if (auto *PD = dyn_cast<ProtocolDecl>(NTD)) {
     for (auto *inherited : PD->getAllInheritedProtocols()) {
       if (!Ctx.shouldIgnore(inherited)) {
-        ProtocolConformanceRef Conf(inherited);
+        auto Conf = ProtocolConformanceRef::forAbstract(
+          PD->getSelfInterfaceType(), inherited);
         auto ConfNode = SDKNodeInitInfo(Ctx, Conf)
             .createSDKNode(SDKNodeKind::Conformance);
         Root->addConformance(ConfNode);
diff --git a/lib/AST/ConformanceLookup.cpp b/lib/AST/ConformanceLookup.cpp
@@ -509,7 +509,7 @@ LookupConformanceInModuleRequest::evaluate(
 
     for (auto ap : archetype->getConformsTo()) {
       if (ap == protocol || ap->inheritsFrom(protocol))
-        return ProtocolConformanceRef(protocol);
+        return ProtocolConformanceRef::forAbstract(archetype, protocol);
     }
 
     return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
@@ -527,17 +527,17 @@ LookupConformanceInModuleRequest::evaluate(
 
   // Type parameters have trivial conformances.
   if (type->isTypeParameter())
-    return ProtocolConformanceRef(protocol);
+    return ProtocolConformanceRef::forAbstract(type, protocol);
 
   // Type variables have trivial conformances.
   if (type->isTypeVariableOrMember())
-    return ProtocolConformanceRef(protocol);
+    return ProtocolConformanceRef::forAbstract(type, protocol);
 
   // UnresolvedType is a placeholder for an unknown type used when generating
   // diagnostics.  We consider it to conform to all protocols, since the
   // intended type might have. Same goes for PlaceholderType.
   if (type->is<UnresolvedType>() || type->is<PlaceholderType>())
-    return ProtocolConformanceRef(protocol);
+    return ProtocolConformanceRef::forAbstract(type, protocol);
 
   // Pack types can conform to protocols.
   if (auto packType = type->getAs<PackType>()) {
diff --git a/lib/AST/DistributedDecl.cpp b/lib/AST/DistributedDecl.cpp
@@ -130,8 +130,7 @@ swift::getDistributedActorAsActorConformanceRef(ASTContext &C) {
   auto distributedActorAsActorConformance =
       getDistributedActorAsActorConformance(C);
 
-  auto actorProto = C.getProtocol(KnownProtocolKind::Actor);
-  return ProtocolConformanceRef(actorProto, distributedActorAsActorConformance);
+  return ProtocolConformanceRef(distributedActorAsActorConformance);
 }
 NormalProtocolConformance *
 swift::getDistributedActorAsActorConformance(ASTContext &C) {
diff --git a/lib/AST/ExistentialGeneralization.cpp b/lib/AST/ExistentialGeneralization.cpp
@@ -195,35 +195,37 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
       newArgs.push_back(generalizeComponentType(CanType(origArg)));
     }
 
+    auto origSig = origSubs.getGenericSignature();
+
     // Generalize all of the conformances.
     // TODO: for abstract requirements, we might not generalize all
     // arguments, and we may need to leave corresponding conformances
     // concrete.
     SmallVector<ProtocolConformanceRef, 4> newConformances;
-    auto origConformances = origSubs.getConformances();
-    for (auto origConformance: origConformances) {
+    for (const auto &req : origSig.getRequirements()) {
+      if (req.getKind() != RequirementKind::Conformance)
+        continue;
       newConformances.push_back(
-        ProtocolConformanceRef(origConformance.getRequirement()));
+          ProtocolConformanceRef::forAbstract(req.getFirstType(),
+                                              req.getProtocolDecl()));
     }
 
-    auto origSig = origSubs.getGenericSignature();
     auto newSubs = SubstitutionMap::get(origSig, newArgs, newConformances);
 
     // Add any conformance requirements to the generic signature and
     // remember the conformances we generalized.
-    if (!origConformances.empty()) {
-      size_t i = 0;
-      for (auto &origReq: origSig.getRequirements()) {
-        if (origReq.getKind() != RequirementKind::Conformance) continue;
-        auto origConformance = origConformances[i++];
-
-        auto newReq = origReq.subst(newSubs);
-        addedRequirements.push_back(newReq);
-
-        substConformances.insert({{newReq.getFirstType()->getCanonicalType(),
-                                   newReq.getProtocolDecl()},
-                                  origConformance});
-      }
+    auto origConformances = origSubs.getConformances();
+    size_t i = 0;
+    for (auto &origReq: origSig.getRequirements()) {
+      if (origReq.getKind() != RequirementKind::Conformance) continue;
+      auto origConformance = origConformances[i++];
+
+      auto newReq = origReq.subst(newSubs);
+      addedRequirements.push_back(newReq);
+
+      substConformances.insert({{newReq.getFirstType()->getCanonicalType(),
+                                 newReq.getProtocolDecl()},
+                                origConformance});
     }
 
     // Build the new type.
diff --git a/lib/AST/LocalArchetypeRequirementCollector.cpp b/lib/AST/LocalArchetypeRequirementCollector.cpp
@@ -265,7 +265,7 @@ swift::buildSubstitutionMapWithCapturedEnvironments(
     [&](CanType origType, Type substType,
         ProtocolDecl *proto) -> ProtocolConformanceRef {
       if (origType->getRootGenericParam()->getDepth() >= baseDepth)
-        return ProtocolConformanceRef(proto);
+        return ProtocolConformanceRef::forAbstract(substType, proto);
       return baseSubMap.lookupConformance(origType, proto);
     });
 }
diff --git a/lib/AST/ProtocolConformanceRef.cpp b/lib/AST/ProtocolConformanceRef.cpp
@@ -33,16 +33,10 @@
 
 using namespace swift;
 
-ProtocolConformanceRef::ProtocolConformanceRef(ProtocolDecl *protocol,
-                                               ProtocolConformance *conf) {
-  assert(protocol != nullptr &&
-         "cannot construct ProtocolConformanceRef with null protocol");
-  if (conf) {
-    assert(protocol == conf->getProtocol() && "protocol conformance mismatch");
-    Union = conf;
-  } else {
-    Union = protocol;
-  }
+ProtocolConformanceRef ProtocolConformanceRef::forAbstract(
+    Type subjectType, ProtocolDecl *proto) {
+  // Temporary implementation:
+  return ProtocolConformanceRef(proto);
 }
 
 bool ProtocolConformanceRef::isInvalid() const {
diff --git a/lib/AST/SubstitutionMap.cpp b/lib/AST/SubstitutionMap.cpp
@@ -271,12 +271,8 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
 
   // If the protocol is invertible, fall back to a global lookup instead of
   // evaluating a conformance path, to avoid an infinite substitution issue.
-  if (proto->getInvertibleProtocolKind()) {
-    auto substType = type.subst(*this);
-    if (!substType->isTypeParameter())
-      return swift::lookupConformance(substType, proto);
-    return ProtocolConformanceRef(proto);
-  }
+  if (proto->getInvertibleProtocolKind())
+    return swift::lookupConformance(type.subst(*this), proto);
 
   auto path = genericSig->getConformancePath(type, proto);
 
@@ -300,18 +296,7 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
     if (conformance.isAbstract()) {
       // FIXME: Rip this out once we can get a concrete conformance from
       // an archetype.
-      auto substType = type.subst(*this);
-      if (substType->hasError())
-        return ProtocolConformanceRef(proto);
-
-      if ((!substType->is<ArchetypeType>() ||
-           substType->castTo<ArchetypeType>()->getSuperclass()) &&
-          !substType->isTypeParameter() &&
-          !substType->isExistentialType()) {
-        return swift::lookupConformance(substType, proto);
-      }
-
-      return ProtocolConformanceRef(proto);
+      return swift::lookupConformance(type.subst(*this), proto);
     }
 
     // For the second step, we're looking into the requirement signature for
@@ -506,14 +491,11 @@ LookUpConformanceInOverrideSubs::operator()(CanType type,
                                             Type substType,
                                             ProtocolDecl *proto) const {
   if (type->getRootGenericParam()->getDepth() >= info.BaseDepth)
-    return ProtocolConformanceRef(proto);
+    return ProtocolConformanceRef::forAbstract(substType, proto);
 
   if (auto conformance = info.BaseSubMap.lookupConformance(type, proto))
     return conformance;
 
-  if (substType->isTypeParameter())
-    return ProtocolConformanceRef(proto);
-
   return lookupConformance(substType, proto);
 }
 
@@ -714,7 +696,8 @@ ProtocolConformanceRef OuterSubstitutions::operator()(
                                         Type conformingReplacementType,
                                         ProtocolDecl *conformedProtocol) const {
   if (isUnsubstitutedTypeParameter(dependentType))
-    return ProtocolConformanceRef(conformedProtocol);
+    return ProtocolConformanceRef::forAbstract(
+      conformingReplacementType, conformedProtocol);
 
   return LookUpConformanceInSubstitutionMap(subs)(
       dependentType, conformingReplacementType, conformedProtocol);
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -2306,15 +2306,11 @@ class IsBindableVisitor : public TypeVisitor<IsBindableVisitor, CanType, CanType
           QueryTypeSubstitutionMap{newParamsMap},
           LookUpConformanceInModule());
         
-        if (newSubstTy->isTypeParameter()) {
-          newConformances.push_back(ProtocolConformanceRef(proto));
-        } else {
-          auto newConformance
-            = lookupConformance(newSubstTy, proto, /*allowMissing=*/true);
-          if (!newConformance)
-            return CanType();
-          newConformances.push_back(newConformance);
-        }
+        auto newConformance
+          = lookupConformance(newSubstTy, proto, /*allowMissing=*/true);
+        if (!newConformance)
+          return CanType();
+        newConformances.push_back(newConformance);
       }
     }
 
diff --git a/lib/AST/TypeSubstitution.cpp b/lib/AST/TypeSubstitution.cpp
@@ -166,7 +166,8 @@ operator()(CanType dependentType, Type conformingReplacementType,
       return lookupConformance(archetypeType, conformedProtocol);
     }
   }
-  return ProtocolConformanceRef(conformedProtocol);
+  return ProtocolConformanceRef::forAbstract(
+    conformingReplacementType, conformedProtocol);
 }
 
 static Type substGenericFunctionType(GenericFunctionType *genericFnType,
@@ -1197,7 +1198,7 @@ ProtocolConformanceRef swift::substOpaqueTypesWithUnderlyingTypes(
 ProtocolConformanceRef ReplaceOpaqueTypesWithUnderlyingTypes::
 operator()(CanType maybeOpaqueType, Type replacementType,
            ProtocolDecl *protocol) const {
-  auto abstractRef = ProtocolConformanceRef(protocol);
+  auto abstractRef = ProtocolConformanceRef::forAbstract(maybeOpaqueType, protocol);
   
   auto archetype = dyn_cast<OpaqueTypeArchetypeType>(maybeOpaqueType);
   if (!archetype) {
diff --git a/lib/IRGen/GenArchetype.cpp b/lib/IRGen/GenArchetype.cpp
@@ -306,8 +306,10 @@ llvm::Value *irgen::emitArchetypeWitnessTableRef(IRGenFunction &IGF,
     assert(rootWTable && "root witness table not bound in local context!");
   }
 
+  auto conformance = ProtocolConformanceRef::forAbstract(
+      rootArchetype, rootProtocol);
   wtable = path.followFromWitnessTable(IGF, rootArchetype,
-                                       ProtocolConformanceRef(rootProtocol),
+                                       conformance,
                                        MetadataResponse::forComplete(rootWTable),
                                        /*request*/ MetadataState::Complete,
                                        nullptr).getMetadata();
diff --git a/lib/IRGen/GenPack.cpp b/lib/IRGen/GenPack.cpp
@@ -354,10 +354,12 @@ static void bindElementSignatureRequirementsAtIndex(
                       patternPackArchetype)
                   ->getCanonicalType();
           llvm::Value *_metadata = nullptr;
-          auto packConformance = ProtocolConformanceRef(proto);
+          auto packConformance = ProtocolConformanceRef::forAbstract(
+              patternPackArchetype, proto);
           auto *wtablePack = emitWitnessTableRef(IGF, patternPackArchetype,
                                                  &_metadata, packConformance);
-          auto elementConformance = ProtocolConformanceRef(proto);
+          auto elementConformance = ProtocolConformanceRef::forAbstract(
+              elementArchetype, proto);
           auto *wtable = bindWitnessTableAtIndex(
               IGF, elementArchetype, elementConformance, wtablePack, index);
           assert(wtable);
diff --git a/lib/IRGen/LocalTypeDataKind.h b/lib/IRGen/LocalTypeDataKind.h
@@ -186,7 +186,10 @@ class LocalTypeDataKind {
   ProtocolConformanceRef getProtocolConformance() const {
     assert(!isSingletonKind());
     if ((Value & KindMask) == Kind_Decl) {
-      return ProtocolConformanceRef(getAbstractProtocolConformance());
+      // FIXME: Passing an empty Type() here temporarily while staging in
+      // new representation for abstract conformances
+      return ProtocolConformanceRef::forAbstract(
+          Type(), getAbstractProtocolConformance());
     } else if ((Value & KindMask) == Kind_PackConformance) {
       return ProtocolConformanceRef(getPackProtocolConformance());
     } else {
diff --git a/lib/SIL/IR/SILFunctionType.cpp b/lib/SIL/IR/SILFunctionType.cpp
@@ -3940,7 +3940,8 @@ static CanSILFunctionType getUncachedSILFunctionTypeForConstant(
 
     if (silRep == SILFunctionTypeRepresentation::WitnessMethod) {
       auto proto = constant.getDecl()->getDeclContext()->getSelfProtocolDecl();
-      witnessMethodConformance = ProtocolConformanceRef(proto);
+      witnessMethodConformance = ProtocolConformanceRef::forAbstract(
+          proto->getSelfInterfaceType()->getCanonicalType(), proto);
     }
 
     // Does this constant have a preferred abstraction pattern set?
diff --git a/lib/SIL/IR/SILTypeSubstitution.cpp b/lib/SIL/IR/SILTypeSubstitution.cpp
@@ -75,7 +75,8 @@ class SILTypeSubstituter :
              Type conformingReplacementType,
              ProtocolDecl *conformedProtocol) -> ProtocolConformanceRef {
         return substOpaqueTypesWithUnderlyingTypes(
-               ProtocolConformanceRef(conformedProtocol),
+               ProtocolConformanceRef::forAbstract(conformingReplacementType,
+                                                   conformedProtocol),
                conformingReplacementType->getCanonicalType(),
                typeExpansionContext);
       },
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -1875,7 +1875,8 @@ SubstitutionMap getApplySubstitutionsFromParsed(
                       proto->getDeclaredInterfaceType());
         failed = true;
 
-        return ProtocolConformanceRef(proto);
+        // FIXME: Passing an empty Type() here temporarily.
+        return ProtocolConformanceRef::forAbstract(Type(), proto);
       });
 
   return failed ? SubstitutionMap() : subMap;
@@ -8162,7 +8163,8 @@ static bool parseSILWitnessTableEntry(
         P.parseToken(tok::colon, diag::expected_sil_witness_colon))
       return true;
 
-    ProtocolConformanceRef conformance(proto);
+    // FIXME: Passing an empty Type() here temporarily.
+    auto conformance = ProtocolConformanceRef::forAbstract(Type(), proto);
     if (P.Tok.getText() != "dependent") {
       auto concrete =
         witnessState.parseProtocolConformance();
diff --git a/lib/SILGen/SILGenConcurrency.cpp b/lib/SILGen/SILGenConcurrency.cpp
diff --git a/lib/SILGen/SILGenLValue.cpp b/lib/SILGen/SILGenLValue.cpp
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ struct SubstitutionMapWithLocalArchetypes {`
`93`	`93`	`if (SubsMap)`
`94`	`94`	`return SubsMap->lookupConformance(origType, proto);`
`95`	`95`
`96`		`- return ProtocolConformanceRef(proto);`
	`96`	`+ return ProtocolConformanceRef::forAbstract(substType, proto);`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`void dump(llvm::raw_ostream &out) const {`
Original file line number	Diff line number	Diff line change
`@@ -130,8 +130,7 @@ swift::getDistributedActorAsActorConformanceRef(ASTContext &C) {`
`130`	`130`	`auto distributedActorAsActorConformance =`
`131`	`131`	`getDistributedActorAsActorConformance(C);`
`132`	`132`
`133`		`- auto actorProto = C.getProtocol(KnownProtocolKind::Actor);`
`134`		`- return ProtocolConformanceRef(actorProto, distributedActorAsActorConformance);`
	`133`	`+ return ProtocolConformanceRef(distributedActorAsActorConformance);`
`135`	`134`	`}`
`136`	`135`	`NormalProtocolConformance *`
`137`	`136`	`swift::getDistributedActorAsActorConformance(ASTContext &C) {`
Original file line number	Diff line number	Diff line change
`@@ -265,7 +265,7 @@ swift::buildSubstitutionMapWithCapturedEnvironments(`
`265`	`265`	`[&](CanType origType, Type substType,`
`266`	`266`	`ProtocolDecl *proto) -> ProtocolConformanceRef {`
`267`	`267`	`if (origType->getRootGenericParam()->getDepth() >= baseDepth)`
`268`		`- return ProtocolConformanceRef(proto);`
	`268`	`+ return ProtocolConformanceRef::forAbstract(substType, proto);`
`269`	`269`	`return baseSubMap.lookupConformance(origType, proto);`
`270`	`270`	`});`
`271`	`271`	`}`