AST: Introduce ProtocolConformanceRef::forAbstract()

slavapestov · slavapestov · commit 47156e006bf0 · 2024-11-16T16:16:06.000-05:00
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/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
@@ -491,7 +491,7 @@ 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;
@@ -696,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/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/SILGenLValue.cpp b/lib/SILGen/SILGenLValue.cpp
@@ -1088,7 +1088,8 @@ namespace {
 
       SmallVector<ProtocolConformanceRef, 2> conformances;
       for (auto proto : OpenedArchetype->getConformsTo())
-        conformances.push_back(ProtocolConformanceRef(proto));
+        conformances.push_back(ProtocolConformanceRef::forAbstract(
+          OpenedArchetype, proto));
 
       SILValue ref;
       if (base.getType().is<ExistentialMetatypeType>()) {
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -915,11 +915,12 @@ static SILFunction *emitSelfConformanceWitness(SILGenModule &SGM,
   // Open the protocol type.
   auto openedType = OpenedArchetypeType::get(
       protocol->getDeclaredExistentialType()->getCanonicalType());
+  auto openedConf = ProtocolConformanceRef::forAbstract(openedType, protocol);
 
   // Form the substitutions for calling the witness.
   auto witnessSubs = SubstitutionMap::getProtocolSubstitutions(protocol,
                                           openedType,
-                                          ProtocolConformanceRef(protocol));
+                                          openedConf);
 
   // Substitute to get the formal substituted type of the thunk.
   auto reqtSubstTy =
@@ -1073,8 +1074,11 @@ class SILGenDefaultWitnessTable
       addMissingDefault();
       return;
     }
+
+    auto Conf = ProtocolConformanceRef::forAbstract(
+        Proto->getSelfInterfaceType()->getCanonicalType(), Proto);
     SILFunction *witnessFn = SGM.emitProtocolWitness(
-        ProtocolConformanceRef(Proto), SILLinkage::Private, IsNotSerialized,
+        Conf, SILLinkage::Private, IsNotSerialized,
         requirementRef, witnessRef, isFree, witness);
     auto entry = SILWitnessTable::MethodWitness{requirementRef, witnessFn};
     DefaultWitnesses.push_back(entry);
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp
@@ -1181,7 +1181,7 @@ SILInstruction *SILCombiner::createApplyWithConcreteType(
                 // base type of the existential's requirements.
                 return CEI.lookupExistentialConformance(proto);
               }
-              return ProtocolConformanceRef(proto);
+              return ProtocolConformanceRef::forAbstract(substTy, proto);
             }, SubstFlags::SubstituteLocalArchetypes);
         continue;
       }
@@ -1219,7 +1219,7 @@ SILInstruction *SILCombiner::createApplyWithConcreteType(
             // base type of the existential's requirements.
             return CEI.lookupExistentialConformance(proto);
           }
-          return ProtocolConformanceRef(proto);
+          return ProtocolConformanceRef::forAbstract(substTy, proto);
         }, SubstFlags::SubstituteLocalArchetypes);
   }
 
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
`@@ -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`	`}`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,8 @@ operator()(CanType dependentType, Type conformingReplacementType,`
`166`	`166`	`return lookupConformance(archetypeType, conformedProtocol);`
`167`	`167`	`}`
`168`	`168`	`}`
`169`		`- return ProtocolConformanceRef(conformedProtocol);`
	`169`	`+ return ProtocolConformanceRef::forAbstract(`
	`170`	`+ conformingReplacementType, conformedProtocol);`
`170`	`171`	`}`
`171`	`172`
`172`	`173`	`static Type substGenericFunctionType(GenericFunctionType *genericFnType,`
`@@ -1197,7 +1198,7 @@ ProtocolConformanceRef swift::substOpaqueTypesWithUnderlyingTypes(`
`1197`	`1198`	`ProtocolConformanceRef ReplaceOpaqueTypesWithUnderlyingTypes::`
`1198`	`1199`	`operator()(CanType maybeOpaqueType, Type replacementType,`
`1199`	`1200`	`ProtocolDecl *protocol) const {`
`1200`		`- auto abstractRef = ProtocolConformanceRef(protocol);`
	`1201`	`+ auto abstractRef = ProtocolConformanceRef::forAbstract(maybeOpaqueType, protocol);`
`1201`	`1202`
`1202`	`1203`	`auto archetype = dyn_cast<OpaqueTypeArchetypeType>(maybeOpaqueType);`
`1203`	`1204`	`if (!archetype) {`