SIL: Preliminary refactoring of SILWitnessTable::AssociatedConformanceWitness

slavapestov · slavapestov · commit 8bcd09aaa441 · 2025-03-18T19:38:42.000-04:00
The Protocol field isn't really necessary, because the conformance
stores the protocol. But we do need the substituted subject type
of the requirement, just temporarily, until an abstract conformance
stores its own subject type too.
diff --git a/SwiftCompilerSources/Sources/AST/Conformance.swift b/SwiftCompilerSources/Sources/AST/Conformance.swift
@@ -37,6 +37,9 @@ public struct Conformance: CustomStringConvertible, NoReflectionChildren {
     return Type(bridged: bridged.getType())
   }
 
+  public var proto: ProtocolDecl {
+    return bridged.getRequirement().getAs(ProtocolDecl.self)
+  }
   public var isSpecialized: Bool {
     assert(isConcrete)
     return bridged.isSpecializedConformance()
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift
@@ -144,14 +144,17 @@ func specializeWitnessTable(forConformance conformance: Conformance,
     case .associatedType(let requirement, let witness):
       let substType = witness.subst(with: conformance.specializedSubstitutions)
       return .associatedType(requirement: requirement, witness: substType)
-    case .associatedConformance(let requirement, let proto, _):
-      let concreteAssociateConf = conformance.getAssociatedConformance(ofAssociatedType: requirement.rawType, to: proto)
+    case .associatedConformance(let requirement, let substType, let assocConf):
+      // FIXME: let concreteAssociateConf = assocConf.subst(with: conformance.specializedSubstitutions)
+      let concreteAssociateConf = conformance.getAssociatedConformance(ofAssociatedType: requirement.rawType, to: assocConf.proto)
       if concreteAssociateConf.isSpecialized {
         specializeWitnessTable(forConformance: concreteAssociateConf,
                                errorLocation: errorLocation,
                                context, notifyNewWitnessTable)
       }
-      return .associatedConformance(requirement: requirement, protocol: proto, witness: concreteAssociateConf)
+      return .associatedConformance(requirement: requirement,
+                                    substType: substType.subst(with: conformance.specializedSubstitutions),
+                                    witness: concreteAssociateConf)
     }
   }
   let newWT = context.createWitnessTable(entries: newEntries,conformance: conformance,
diff --git a/SwiftCompilerSources/Sources/SIL/WitnessTable.swift b/SwiftCompilerSources/Sources/SIL/WitnessTable.swift
@@ -31,7 +31,7 @@ public struct WitnessTable : CustomStringConvertible, NoReflectionChildren {
     case associatedType(requirement: AssociatedTypeDecl, witness: CanonicalType)
 
     /// A witness table entry describing the witness for an associated type's protocol requirement.
-    case associatedConformance(requirement: CanonicalType, protocol: ProtocolDecl, witness: Conformance)
+    case associatedConformance(requirement: CanonicalType, substType: CanonicalType, witness: Conformance)
 
     /// A witness table entry referencing the protocol conformance for a refined base protocol.
     case baseProtocol(requirement: ProtocolDecl, witness: Conformance)
@@ -48,7 +48,7 @@ public struct WitnessTable : CustomStringConvertible, NoReflectionChildren {
                                witness: CanonicalType(bridged: bridged.getAssociatedTypeWitness()))
       case .associatedConformance:
         self = .associatedConformance(requirement: CanonicalType(bridged: bridged.getAssociatedConformanceRequirement()),
-                                      protocol: bridged.getAssociatedConformanceDecl().getAs(ProtocolDecl.self),
+                                      substType: CanonicalType(bridged: bridged.getAssociatedConformanceSubstType()),
                                       witness: Conformance(bridged: bridged.getAssociatedConformanceWitness()))
       case .baseProtocol:
         self = .baseProtocol(requirement: bridged.getBaseProtocolRequirement().getAs(ProtocolDecl.self),
@@ -71,9 +71,9 @@ public struct WitnessTable : CustomStringConvertible, NoReflectionChildren {
                                                      OptionalBridgedFunction(obj: witness?.bridged.obj))
       case .associatedType(let requirement, let witness):
         return BridgedWitnessTableEntry.createAssociatedType(requirement.bridged, witness.bridged)
-      case .associatedConformance(let requirement, let protocolDecl, let witness):
+      case .associatedConformance(let requirement, let substType, let witness):
         return BridgedWitnessTableEntry.createAssociatedConformance(requirement.bridged,
-                                                                    protocolDecl.bridged,
+                                                                    substType.bridged,
                                                                     witness.bridged)
       case .baseProtocol(let requirement, let witness):
         return BridgedWitnessTableEntry.createBaseProtocol(requirement.bridged, witness.bridged)
diff --git a/include/swift/AST/ASTBridging.h b/include/swift/AST/ASTBridging.h
@@ -3110,6 +3110,7 @@ struct BridgedConformance {
   BRIDGED_INLINE bool isSpecializedConformance() const;
   BRIDGED_INLINE bool isInheritedConformance() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType getType() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedDeclObj getRequirement() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformance getGenericConformance() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformance getInheritedConformance() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedSubstitutionMap getSpecializedSubstitutions() const;
diff --git a/include/swift/AST/ASTBridgingImpl.h b/include/swift/AST/ASTBridgingImpl.h
@@ -601,6 +601,10 @@ BridgedASTType BridgedConformance::getType() const {
   return {unbridged().getConcrete()->getType().getPointer()};
 }
 
+BridgedDeclObj BridgedConformance::getRequirement() const {
+  return {unbridged().getRequirement()};
+}
+
 BridgedConformance BridgedConformance::getGenericConformance() const {
   auto *specPC = swift::cast<swift::SpecializedProtocolConformance>(unbridged().getConcrete());
   return {swift::ProtocolConformanceRef(specPC->getGenericConformance())};
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -1007,7 +1007,7 @@ struct BridgedWitnessTableEntry {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedDeclObj getAssociatedTypeRequirement() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType getAssociatedTypeWitness() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType getAssociatedConformanceRequirement() const;
-  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedDeclObj getAssociatedConformanceDecl() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType getAssociatedConformanceSubstType() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformance getAssociatedConformanceWitness() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedDeclObj getBaseProtocolRequirement() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformance getBaseProtocolWitness() const;
@@ -1022,7 +1022,7 @@ struct BridgedWitnessTableEntry {
                                                        BridgedCanType witness);
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE
   static BridgedWitnessTableEntry createAssociatedConformance(BridgedCanType requirement,
-                                                              BridgedDeclObj protocolDecl,
+                                                              BridgedCanType substType,
                                                               BridgedConformance witness);
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE
   static BridgedWitnessTableEntry createBaseProtocol(BridgedDeclObj requirement,
diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h
@@ -1832,8 +1832,8 @@ BridgedCanType BridgedWitnessTableEntry::getAssociatedConformanceRequirement() c
   return unbridged().getAssociatedConformanceWitness().Requirement;
 }
 
-BridgedDeclObj BridgedWitnessTableEntry::getAssociatedConformanceDecl() const {
-  return {unbridged().getAssociatedConformanceWitness().Protocol};
+BridgedCanType BridgedWitnessTableEntry::getAssociatedConformanceSubstType() const {
+  return {unbridged().getAssociatedConformanceWitness().SubstType};
 }
 
 BridgedConformance BridgedWitnessTableEntry::getAssociatedConformanceWitness() const {
@@ -1867,11 +1867,11 @@ BridgedWitnessTableEntry BridgedWitnessTableEntry::createAssociatedType(BridgedD
 }
 
 BridgedWitnessTableEntry BridgedWitnessTableEntry::createAssociatedConformance(BridgedCanType requirement,
-                                                                               BridgedDeclObj protocolDecl,
+                                                                               BridgedCanType substType,
                                                                                BridgedConformance witness) {
   return bridge(swift::SILWitnessTable::Entry(
     swift::SILWitnessTable::AssociatedConformanceWitness{requirement.unbridged(),
-                                                         protocolDecl.getAs<swift::ProtocolDecl>(),
+                                                         substType.unbridged(),
                                                          witness.unbridged()}));
 }
 
diff --git a/include/swift/SIL/SILWitnessTable.h b/include/swift/SIL/SILWitnessTable.h
@@ -64,13 +64,11 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
   /// A witness table entry describing the witness for an associated type's
   /// protocol requirement.
   struct AssociatedConformanceWitness {
-    /// The associated type required.  A dependent type in the protocol's
-    /// context.
+    /// The subject type of the associated requirement.
     CanType Requirement;
-    /// The protocol requirement on the type.
-    ProtocolDecl *Protocol;
-    /// The ProtocolConformance satisfying the requirement. Null if the
-    /// conformance is dependent.
+    /// FIXME: Temporary.
+    CanType SubstType;
+    /// The ProtocolConformanceRef satisfying the requirement.
     ProtocolConformanceRef Witness;
   };
   
@@ -160,6 +158,7 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
   /// conditional. These aren't public, but any witness thunks need to feed them
   /// into the true witness functions.
   struct ConditionalConformance {
+    /// FIXME: Temporary.
     CanType Requirement;
     ProtocolConformanceRef Conformance;
   };
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -1182,14 +1182,17 @@ namespace {
 
       for (auto &entry : DefaultWitnesses->getEntries()) {
         if (!entry.isValid() ||
-            entry.getKind() != SILWitnessTable::AssociatedConformance ||
-            entry.getAssociatedConformanceWitness().Protocol != requirement ||
-            entry.getAssociatedConformanceWitness().Requirement != association)
+            entry.getKind() != SILWitnessTable::AssociatedConformance)
+          continue;
+
+        auto assocConf = entry.getAssociatedConformanceWitness();
+        if (assocConf.Requirement != association ||
+            assocConf.Witness.getRequirement() != requirement)
           continue;
 
-        auto witness = entry.getAssociatedConformanceWitness().Witness;
         AssociatedConformance conformance(Proto, association, requirement);
-        defineDefaultAssociatedConformanceAccessFunction(conformance, witness);
+        defineDefaultAssociatedConformanceAccessFunction(
+            conformance, assocConf.Witness);
         return IGM.getMangledAssociatedConformance(nullptr, conformance);
       }
 
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
@@ -1780,9 +1780,6 @@ class AccessorConformanceInfo : public ConformanceInfo {
       auto associatedWitness = entry.getAssociatedConformanceWitness();
       assert(associatedWitness.Requirement == requirement.getAssociation()
              && "sil witness table does not match protocol");
-      assert(associatedWitness.Protocol ==
-               requirement.getAssociatedRequirement()
-             && "sil witness table does not match protocol");
       auto piIndex = PI.getAssociatedConformanceIndex(requirement);
       assert((size_t)piIndex.getValue() ==
               Table.size() - WitnessTableFirstRequirementOffset &&
@@ -1792,10 +1789,8 @@ class AccessorConformanceInfo : public ConformanceInfo {
       if (IGM.Context.LangOpts.hasFeature(Feature::Embedded)) {
         // In Embedded Swift associated-conformance entries simply point to the witness table
         // of the associated conformance.
-        ProtocolConformanceRef assocConf =
-          SILWT->getConformance()->getAssociatedConformance(requirement.getAssociation(),
-                                                            requirement.getAssociatedRequirement());
-        llvm::Constant *witnessEntry = IGM.getAddrOfWitnessTable(assocConf.getConcrete());
+        ProtocolConformance *assocConf = associatedWitness.Witness.getConcrete();
+        llvm::Constant *witnessEntry = IGM.getAddrOfWitnessTable(assocConf);
         auto &schema = IGM.getOptions().PointerAuth
                           .ProtocolAssociatedTypeWitnessTableAccessFunctions;
         Table.addSignedPointer(witnessEntry, schema, requirement);
@@ -2030,10 +2025,11 @@ void ResilientWitnessTableBuilder::collectResilientWitnesses(
 
       ProtocolConformanceRef associatedConformance =
         ConformanceInContext.getAssociatedConformance(witness.Requirement,
-                                                      witness.Protocol);
+                                                      witness.Witness.getRequirement());
+
       AssociatedConformance requirement(SILWT->getProtocol(),
                                         witness.Requirement,
-                                        witness.Protocol);
+                                        witness.Witness.getRequirement());
 
       llvm::Constant *witnessEntry =
         getAssociatedConformanceWitness(requirement, associate,
@@ -2353,7 +2349,7 @@ namespace {
 
           AssociatedConformance requirement(SILWT->getProtocol(),
                                             witness.Requirement,
-                                            witness.Protocol);
+                                            witness.Witness.getRequirement());
           auto assocConformanceDescriptor =
             IGM.getAddrOfLLVMVariableOrGOTEquivalent(
               LinkEntity::forAssociatedConformanceDescriptor(requirement));
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -4269,13 +4269,18 @@ void SILWitnessTable::Entry::print(llvm::raw_ostream &out, bool verbose,
   case WitnessKind::AssociatedConformance: {
     // associated_conformance (AssociatedTypeName: Protocol): <conformance>
     auto &assocProtoWitness = getAssociatedConformanceWitness();
+    if (assocProtoWitness.Witness.isInvalid())
+      return;
     out << "associated_conformance (";
     (void) printAssociatedTypePath(out, assocProtoWitness.Requirement);
-    out << ": " << assocProtoWitness.Protocol->getName() << "): ";
-    if (assocProtoWitness.Witness.isConcrete())
-      assocProtoWitness.Witness.getConcrete()->printName(out, options);
-    else
-      out << "dependent";
+    auto conformance = assocProtoWitness.Witness;
+    out << ": " << conformance.getRequirement()->getName() << "): ";
+    if (conformance.isConcrete())
+      conformance.getConcrete()->printName(out, options);
+    else {
+      out << "dependent ";
+      assocProtoWitness.SubstType->print(out, options);
+    }
     break;
   }
   case WitnessKind::BaseProtocol: {
@@ -4316,14 +4321,19 @@ void SILWitnessTable::print(llvm::raw_ostream &OS, bool Verbose) const {
   for (auto conditionalConformance : getConditionalConformances()) {
     // conditional_conformance (TypeName: Protocol):
     // <conformance>
+    if (conditionalConformance.Conformance.isInvalid())
+      continue;
+
     OS << "  conditional_conformance (";
     conditionalConformance.Requirement.print(OS, Options);
     OS << ": " << conditionalConformance.Conformance.getRequirement()->getName()
        << "): ";
     if (conditionalConformance.Conformance.isConcrete())
       conditionalConformance.Conformance.getConcrete()->printName(OS, Options);
-    else
-      OS << "dependent";
+    else {
+      OS << "dependent ";
+      conditionalConformance.Requirement->print(OS, Options);
+    }
 
     OS << '\n';
   }
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -8168,23 +8168,47 @@ static bool parseSILWitnessTableEntry(
         P.parseToken(tok::colon, diag::expected_sil_witness_colon))
       return true;
 
-    // FIXME: Passing an empty Type() here temporarily.
-    auto conformance = ProtocolConformanceRef::forAbstract(Type(), proto);
+    CanType substType;
+    ProtocolConformanceRef conformance;
     if (P.Tok.getText() != "dependent") {
       auto concrete =
         witnessState.parseProtocolConformance();
       // Ignore invalid and abstract witness entries.
       if (concrete.isInvalid() || !concrete.isConcrete())
         return false;
+      substType = concrete.getConcrete()->getType()->getCanonicalType();
       conformance = concrete;
     } else {
       P.consumeToken();
+
+      // Parse AST type.
+      ParserResult<TypeRepr> TyR = P.parseType();
+      if (TyR.isNull())
+        return true;
+
+      SILTypeResolutionContext silContext(/*isSILType=*/false,
+                                          witnessParams,
+                                          /*openedPacks=*/nullptr);
+      auto Ty =
+          swift::performTypeResolution(TyR.get(), P.Context,
+                                       witnessSig, &silContext,
+                                       &P.SF);
+      if (witnessSig) {
+        Ty = witnessSig.getGenericEnvironment()->mapTypeIntoContext(Ty);
+      }
+
+      if (Ty->hasError())
+        return true;
+
+      substType = Ty->getCanonicalType();
+      conformance = ProtocolConformanceRef::forAbstract(
+          Ty->getCanonicalType(), proto);
     }
 
     if (EntryKeyword.str() == "associated_conformance")
       witnessEntries.push_back(
           SILWitnessTable::AssociatedConformanceWitness{assocOrSubject,
-                                                        proto,
+                                                        substType,
                                                         conformance});
     else
       conditionalConformances.push_back(
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -670,12 +670,13 @@ class SILGenConformance : public SILGenWitnessTable<SILGenConformance> {
     auto assocConformance =
       Conformance->getAssociatedConformance(req.getAssociation(),
                                             req.getAssociatedRequirement());
+    auto substType =
+      Conformance->getAssociatedType(req.getAssociation())->getCanonicalType();
 
     SGM.useConformance(assocConformance);
 
     Entries.push_back(SILWitnessTable::AssociatedConformanceWitness{
-        req.getAssociation(), req.getAssociatedRequirement(),
-        assocConformance});
+        req.getAssociation(), substType, assocConformance});
   }
 
   void addConditionalRequirements() {
@@ -1105,7 +1106,7 @@ class SILGenDefaultWitnessTable
       return addMissingDefault();
 
     auto entry = SILWitnessTable::AssociatedConformanceWitness{
-        req.getAssociation(), req.getAssociatedRequirement(), witness};
+        req.getAssociation(), req.getAssociation(), witness};
     DefaultWitnesses.push_back(entry);
   }
 };
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -4446,16 +4446,16 @@ void SILDeserializer::readWitnessTableEntries(
         proto, conformance.getConcrete()
       });
     } else if (kind == SIL_WITNESS_ASSOC_PROTOCOL) {
-      TypeID assocId;
-      DeclID protoId;
+      TypeID origTypeId;
+      DeclID substTypeId;
       ProtocolConformanceID conformanceId;
-      WitnessAssocProtocolLayout::readRecord(scratch, assocId, protoId,
+      WitnessAssocProtocolLayout::readRecord(scratch, origTypeId, substTypeId,
                                              conformanceId);
-      CanType type = MF->getType(assocId)->getCanonicalType();
-      ProtocolDecl *proto = cast<ProtocolDecl>(MF->getDecl(protoId));
+      CanType origType = MF->getType(origTypeId)->getCanonicalType();
+      CanType substType = MF->getType(substTypeId)->getCanonicalType();
       auto conformance = MF->getConformance(conformanceId);
       witnessEntries.push_back(SILWitnessTable::AssociatedConformanceWitness{
-        type, proto, conformance
+        origType, substType, conformance
       });
     } else if (kind == SIL_WITNESS_ASSOC_ENTRY) {
       DeclID assocId;
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 925; // isolated conformances
+const uint16_t SWIFTMODULE_VERSION_MINOR = 926; // abstract conformances
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
diff --git a/lib/Serialization/SILFormat.h b/lib/Serialization/SILFormat.h
@@ -244,8 +244,8 @@ namespace sil_block {
 
   using WitnessAssocProtocolLayout = BCRecordLayout<
     SIL_WITNESS_ASSOC_PROTOCOL,
-    TypeIDField, // ID of associated type
-    DeclIDField, // ID of ProtocolDecl
+    TypeIDField, // ID of requirement subject type
+    TypeIDField, // ID of substituted subject type
     ProtocolConformanceIDField
   >;
 
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
diff --git a/test/SIL/Parser/witness_tables.sil b/test/SIL/Parser/witness_tables.sil
diff --git a/test/SILOptimizer/cast_optimizer_conditional_conformance.sil b/test/SILOptimizer/cast_optimizer_conditional_conformance.sil

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,9 @@ public struct Conformance: CustomStringConvertible, NoReflectionChildren {`
`37`	`37`	`return Type(bridged: bridged.getType())`
`38`	`38`	`}`
`39`	`39`
	`40`	`+ public var proto: ProtocolDecl {`
	`41`	`+ return bridged.getRequirement().getAs(ProtocolDecl.self)`
	`42`	`+ }`
`40`	`43`	`public var isSpecialized: Bool {`
`41`	`44`	`assert(isConcrete)`
`42`	`45`	`return bridged.isSpecializedConformance()`
Original file line number	Diff line number	Diff line change
`@@ -1832,8 +1832,8 @@ BridgedCanType BridgedWitnessTableEntry::getAssociatedConformanceRequirement() c`
`1832`	`1832`	`return unbridged().getAssociatedConformanceWitness().Requirement;`
`1833`	`1833`	`}`
`1834`	`1834`
`1835`		`-BridgedDeclObj BridgedWitnessTableEntry::getAssociatedConformanceDecl() const {`
`1836`		`- return {unbridged().getAssociatedConformanceWitness().Protocol};`
	`1835`	`+BridgedCanType BridgedWitnessTableEntry::getAssociatedConformanceSubstType() const {`
	`1836`	`+ return {unbridged().getAssociatedConformanceWitness().SubstType};`
`1837`	`1837`	`}`
`1838`	`1838`
`1839`	`1839`	`BridgedConformance BridgedWitnessTableEntry::getAssociatedConformanceWitness() const {`
`@@ -1867,11 +1867,11 @@ BridgedWitnessTableEntry BridgedWitnessTableEntry::createAssociatedType(BridgedD`
`1867`	`1867`	`}`
`1868`	`1868`
`1869`	`1869`	`BridgedWitnessTableEntry BridgedWitnessTableEntry::createAssociatedConformance(BridgedCanType requirement,`
`1870`		`- BridgedDeclObj protocolDecl,`
	`1870`	`+ BridgedCanType substType,`
`1871`	`1871`	`BridgedConformance witness) {`
`1872`	`1872`	`return bridge(swift::SILWitnessTable::Entry(`
`1873`	`1873`	`swift::SILWitnessTable::AssociatedConformanceWitness{requirement.unbridged(),`
`1874`		`- protocolDecl.getAs<swift::ProtocolDecl>(),`
	`1874`	`+ substType.unbridged(),`
`1875`	`1875`	`witness.unbridged()}));`
`1876`	`1876`	`}`
`1877`	`1877`