diff --git a/include/swift/AST/Requirement.h b/include/swift/AST/Requirement.h
index 642b8a4254b..d0c1eef287a 100644
--- a/include/swift/AST/Requirement.h
+++ b/include/swift/AST/Requirement.h
@@ -74,6 +74,8 @@ public:
     llvm_unreachable("Unhandled RequirementKind in switch.");
   }
 
+  ProtocolDecl *getProtocolDecl() const;
+
   SWIFT_DEBUG_DUMP;
   void dump(raw_ostream &out) const;
   void print(raw_ostream &os, const PrintOptions &opts) const;
diff --git a/include/swift/IRGen/Linking.h b/include/swift/IRGen/Linking.h
index baab9fc66d4..28f719af056 100644
--- a/include/swift/IRGen/Linking.h
+++ b/include/swift/IRGen/Linking.h
@@ -565,8 +565,7 @@ class LinkEntity {
     for (const auto &reqt : proto->getRequirementSignature()) {
       if (reqt.getKind() == RequirementKind::Conformance &&
           reqt.getFirstType()->getCanonicalType() == associatedType &&
-          reqt.getSecondType()->castTo<ProtocolType>()->getDecl() ==
-                                                                requirement) {
+          reqt.getProtocolDecl() == requirement) {
         return index;
       }
       ++index;
@@ -590,7 +589,7 @@ class LinkEntity {
     auto &reqt = proto->getRequirementSignature()[index];
     assert(reqt.getKind() == RequirementKind::Conformance);
     return { reqt.getFirstType()->getCanonicalType(),
-             reqt.getSecondType()->castTo<ProtocolType>()->getDecl() };
+             reqt.getProtocolDecl() };
   }
 
   static std::pair<CanType, ProtocolDecl*>
diff --git a/include/swift/SIL/SILWitnessVisitor.h b/include/swift/SIL/SILWitnessVisitor.h
index 4c8bfeb4af5..6ea733f6cf6 100644
--- a/include/swift/SIL/SILWitnessVisitor.h
+++ b/include/swift/SIL/SILWitnessVisitor.h
@@ -64,9 +64,7 @@ public:
       case RequirementKind::Conformance: {
         auto type = reqt.getFirstType()->getCanonicalType();
         assert(type->isTypeParameter());
-        auto requirement =
-          cast<ProtocolType>(reqt.getSecondType()->getCanonicalType())
-            ->getDecl();
+        auto requirement = reqt.getProtocolDecl();
 
         // ObjC protocols do not have witnesses.
         if (!Lowering::TypeConverter::protocolRequiresWitnessTable(requirement))
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index 92b8c1644ae..c67a149a5ab 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -709,8 +709,7 @@ FuncDecl *ASTContext::getPlusFunctionOnRangeReplaceableCollection() const {
         continue;
       for (auto Req: FD->getGenericRequirements()) {
         if (Req.getKind() == RequirementKind::Conformance &&
-              Req.getSecondType()->getNominalOrBoundGenericNominal() ==
-            getRangeReplaceableCollectionDecl()) {
+              Req.getProtocolDecl() == getRangeReplaceableCollectionDecl()) {
           getImpl().PlusFunctionOnRangeReplaceableCollection = FD;
         }
       }
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
index 4c631288706..1fcf08a9c49 100644
--- a/lib/AST/ASTMangler.cpp
+++ b/lib/AST/ASTMangler.cpp
@@ -1584,8 +1584,7 @@ static bool containsRetroactiveConformance(
   for (auto requirement : rootConformance->getConditionalRequirements()) {
     if (requirement.getKind() != RequirementKind::Conformance)
       continue;
-    ProtocolDecl *proto =
-        requirement.getSecondType()->castTo<ProtocolType>()->getDecl();
+    ProtocolDecl *proto = requirement.getProtocolDecl();
     auto conformance = subMap.lookupConformance(
         requirement.getFirstType()->getCanonicalType(), proto);
     if (conformance.isInvalid()) {
@@ -2598,8 +2597,7 @@ void ASTMangler::appendRequirement(const Requirement &reqt) {
   case RequirementKind::Layout: {
   } break;
   case RequirementKind::Conformance: {
-    Type SecondTy = reqt.getSecondType();
-    appendProtocolName(SecondTy->castTo<ProtocolType>()->getDecl());
+    appendProtocolName(reqt.getProtocolDecl());
   } break;
   case RequirementKind::Superclass:
   case RequirementKind::SameType: {
@@ -3047,7 +3045,7 @@ static unsigned conformanceRequirementIndex(
       continue;
 
     if (req.getFirstType()->isEqual(entry.first) &&
-        req.getSecondType()->castTo<ProtocolType>()->getDecl() == entry.second)
+        req.getProtocolDecl() == entry.second)
       return result;
 
     ++result;
@@ -3175,8 +3173,7 @@ void ASTMangler::appendConcreteProtocolConformance(
       if (type->hasArchetype())
         type = type->mapTypeOutOfContext();
       CanType canType = type->getCanonicalType(CurGenericSignature);
-      auto proto =
-        conditionalReq.getSecondType()->castTo<ProtocolType>()->getDecl();
+      auto proto = conditionalReq.getProtocolDecl();
       
       ProtocolConformanceRef conformance;
       
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
index b316c87abd2..c8fea18cd97 100644
--- a/lib/AST/ASTPrinter.cpp
+++ b/lib/AST/ASTPrinter.cpp
@@ -2533,8 +2533,7 @@ static bool usesFeatureRethrowsProtocol(
           ->getGenericSignatureOfContext()) {
     for (const auto &req : genericSig->getRequirements()) {
       if (req.getKind() == RequirementKind::Conformance &&
-          usesFeatureRethrowsProtocol(
-            req.getSecondType()->getAs<ProtocolType>()->getDecl(), checked))
+          usesFeatureRethrowsProtocol(req.getProtocolDecl(), checked))
         return true;
     }
   }
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
index afaca57cdd9..c7cd012d11c 100644
--- a/lib/AST/ASTVerifier.cpp
+++ b/lib/AST/ASTVerifier.cpp
@@ -2752,8 +2752,7 @@ public:
             abort();
           }
 
-          auto reqProto =
-            req.getSecondType()->castTo<ProtocolType>()->getDecl();
+          auto reqProto = req.getProtocolDecl();
           if (reqProto != conformances[idx].getRequirement()) {
             Out << "error: wrong protocol in signature conformances: have "
               << conformances[idx].getRequirement()->getName().str()
diff --git a/lib/AST/GenericSignature.cpp b/lib/AST/GenericSignature.cpp
index 049b3653d63..0fd81519ba6 100644
--- a/lib/AST/GenericSignature.cpp
+++ b/lib/AST/GenericSignature.cpp
@@ -308,9 +308,8 @@ CanGenericSignature::getCanonical(TypeArrayView<GenericTypeParamType> params,
     assert(reqt.getKind() == RequirementKind::Conformance &&
            "Only conformance requirements can have multiples");
 
-    auto prevProto =
-      prevReqt.getSecondType()->castTo<ProtocolType>()->getDecl();
-    auto proto = reqt.getSecondType()->castTo<ProtocolType>()->getDecl();
+    auto prevProto = prevReqt.getProtocolDecl();
+    auto proto = reqt.getProtocolDecl();
     assert(TypeDecl::compare(prevProto, proto) < 0 &&
            "Out-of-order conformance requirements");
   }
@@ -545,8 +544,7 @@ bool GenericSignatureImpl::isRequirementSatisfied(
 
   switch (requirement.getKind()) {
   case RequirementKind::Conformance: {
-    auto protocolType = requirement.getSecondType()->castTo<ProtocolType>();
-    auto protocol = protocolType->getDecl();
+    auto *protocol = requirement.getProtocolDecl();
 
     if (canFirstType->isTypeParameter())
       return requiresProtocol(canFirstType, protocol);
@@ -746,8 +744,7 @@ static bool hasConformanceInSignature(ArrayRef<Requirement> requirements,
   for (const auto &req: requirements) {
     if (req.getKind() == RequirementKind::Conformance &&
         req.getFirstType()->isEqual(subjectType) &&
-        req.getSecondType()->castTo<ProtocolType>()->getDecl()
-          == proto) {
+        req.getProtocolDecl() == proto) {
       return true;
     }
   }
@@ -1007,7 +1004,6 @@ bool Requirement::isCanonical() const {
   return true;
 }
 
-
 /// Get the canonical form of this requirement.
 Requirement Requirement::getCanonical() const {
   Type firstType = getFirstType();
@@ -1029,3 +1025,8 @@ Requirement Requirement::getCanonical() const {
   }
   llvm_unreachable("Unhandled RequirementKind in switch");
 }
+
+ProtocolDecl *Requirement::getProtocolDecl() const {
+  assert(getKind() == RequirementKind::Conformance);
+  return getSecondType()->castTo<ProtocolType>()->getDecl();
+}
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
index 5f1b7ff2420..e496eb1c846 100644
--- a/lib/AST/NameLookup.cpp
+++ b/lib/AST/NameLookup.cpp
@@ -2700,8 +2700,7 @@ swift::getDirectlyInheritedNominalTypeDecls(
       if (!req.getFirstType()->isEqual(protoSelfTy))
         continue;
 
-      result.emplace_back(req.getSecondType()->castTo<ProtocolType>()->getDecl(),
-                          loc);
+      result.emplace_back(req.getProtocolDecl(), loc);
     }
     return result;
   }
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
index c0355b5b2bb..e94c48ad45e 100644
--- a/lib/AST/ProtocolConformance.cpp
+++ b/lib/AST/ProtocolConformance.cpp
@@ -572,8 +572,7 @@ void NormalProtocolConformance::setSignatureConformances(
              "Should have interface types here");
       assert(idx < conformances.size());
       assert(conformances[idx].isInvalid() ||
-             conformances[idx].getRequirement() ==
-               req.getSecondType()->castTo<ProtocolType>()->getDecl());
+             conformances[idx].getRequirement() == req.getProtocolDecl());
       ++idx;
     }
   }
@@ -772,7 +771,7 @@ NormalProtocolConformance::getAssociatedConformance(Type assocType,
     if (reqt.getKind() == RequirementKind::Conformance) {
       // Is this the conformance we're looking for?
       if (reqt.getFirstType()->isEqual(assocType) &&
-          reqt.getSecondType()->castTo<ProtocolType>()->getDecl() == protocol)
+          reqt.getProtocolDecl() == protocol)
         return getSignatureConformances()[conformanceIndex];
 
       ++conformanceIndex;
@@ -840,7 +839,7 @@ void NormalProtocolConformance::finishSignatureConformances() {
       auto *depMemTy = origTy->castTo<DependentMemberType>();
       substTy = recursivelySubstituteBaseType(module, this, depMemTy);
     }
-    auto reqProto = req.getSecondType()->castTo<ProtocolType>()->getDecl();
+    auto reqProto = req.getProtocolDecl();
 
     // Looking up a conformance for a contextual type and mapping the
     // conformance context produces a more accurate result than looking
diff --git a/lib/AST/SubstitutionMap.cpp b/lib/AST/SubstitutionMap.cpp
index 1d5fb19b204..db4c8ced381 100644
--- a/lib/AST/SubstitutionMap.cpp
+++ b/lib/AST/SubstitutionMap.cpp
@@ -234,8 +234,7 @@ SubstitutionMap SubstitutionMap::get(GenericSignature genericSig,
 
     CanType depTy = req.getFirstType()->getCanonicalType();
     auto replacement = depTy.subst(subs, lookupConformance);
-    auto protoType = req.getSecondType()->castTo<ProtocolType>();
-    auto proto = protoType->getDecl();
+    auto *proto = req.getProtocolDecl();
     auto conformance = lookupConformance(depTy, replacement, proto);
     conformances.push_back(conformance);
   }
@@ -334,38 +333,27 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
 
   auto genericSig = getGenericSignature();
 
-  // Fast path
-  unsigned index = 0;
-  for (auto reqt : genericSig->getRequirements()) {
-    if (reqt.getKind() == RequirementKind::Conformance) {
-      if (reqt.getFirstType()->isEqual(type) &&
-          reqt.getSecondType()->isEqual(proto->getDeclaredInterfaceType()))
-        return getConformances()[index];
+  auto getSignatureConformance =
+      [&](Type type, ProtocolDecl *proto) -> Optional<ProtocolConformanceRef> {
+    unsigned index = 0;
+    for (auto reqt : genericSig->getRequirements()) {
+      if (reqt.getKind() == RequirementKind::Conformance) {
+        if (reqt.getFirstType()->isEqual(type) &&
+            reqt.getProtocolDecl() == proto)
+          return getConformances()[index];
 
-      ++index;
-    }
-  }
-
-  // Retrieve the starting conformance from the conformance map.
-  auto getInitialConformance =
-      [&](Type type, ProtocolDecl *proto) -> ProtocolConformanceRef {
-    unsigned conformanceIndex = 0;
-    for (const auto &req : getGenericSignature()->getRequirements()) {
-      if (req.getKind() != RequirementKind::Conformance)
-        continue;
-
-      // Is this the conformance we're looking for?
-      if (req.getFirstType()->isEqual(type) &&
-          req.getSecondType()->castTo<ProtocolType>()->getDecl() == proto) {
-        return getConformances()[conformanceIndex];
+        ++index;
       }
-
-      ++conformanceIndex;
     }
 
-    return ProtocolConformanceRef::forInvalid();
+    return None;
   };
 
+  // Fast path -- check if the generic signature directly states the
+  // conformance.
+  if (auto directConformance = getSignatureConformance(type, proto))
+    return *directConformance;
+
   // Check whether the superclass conforms.
   if (auto superclass = genericSig->getSuperclassBound(type)) {
     LookUpConformanceInSignature lookup(getGenericSignature().getPointer());
@@ -388,16 +376,16 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
   for (const auto &step : accessPath) {
     // For the first step, grab the initial conformance.
     if (conformance.isInvalid()) {
-      conformance = getInitialConformance(step.first, step.second);
-      if (conformance.isInvalid())
-        return ProtocolConformanceRef::forInvalid();
+      if (auto initialConformance = getSignatureConformance(
+            step.first, step.second)) {
+        conformance = *initialConformance;
+        continue;
+      }
 
-      continue;
+      // We couldn't find the initial conformance, fail.
+      return ProtocolConformanceRef::forInvalid();
     }
 
-    if (conformance.isInvalid())
-      return conformance;
-
     // If we've hit an abstract conformance, everything from here on out is
     // abstract.
     // FIXME: This may not always be true, but it holds for now.
@@ -436,6 +424,8 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
 
     // Get the associated conformance.
     conformance = concrete->getAssociatedConformance(step.first, step.second);
+    if (conformance.isInvalid())
+      return conformance;
   }
 
   return conformance;
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index f581e5df705..1a41e15174a 100644
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -2012,7 +2012,7 @@ public:
       if (req.getKind() != RequirementKind::Conformance) continue;
 
       auto canTy = req.getFirstType()->getCanonicalType();
-      auto *proto = req.getSecondType()->castTo<ProtocolType>()->getDecl();
+      auto *proto = req.getProtocolDecl();
       auto origConf = origSubMap.lookupConformance(canTy, proto);
       auto substConf = substSubMap.lookupConformance(canTy, proto);
 
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
index b81eb2a27f2..0428e11ec4f 100644
--- a/lib/IRGen/GenMeta.cpp
+++ b/lib/IRGen/GenMeta.cpp
@@ -5243,8 +5243,7 @@ GenericRequirementsMetadata irgen::addGenericRequirements(
       break;
 
     case RequirementKind::Conformance: {
-      auto protocol = requirement.getSecondType()->castTo<ProtocolType>()
-        ->getDecl();
+      auto protocol = requirement.getProtocolDecl();
 
       // Marker protocols do not record generic requirements at all.
       if (protocol->isMarkerProtocol()) {
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
index 7925eee8988..2a9a650e3c8 100644
--- a/lib/IRGen/GenProto.cpp
+++ b/lib/IRGen/GenProto.cpp
@@ -266,8 +266,7 @@ irgen::enumerateGenericSignatureRequirements(CanGenericSignature signature,
 
       case RequirementKind::Conformance: {
         auto type = CanType(reqt.getFirstType());
-        auto protocol =
-          cast<ProtocolType>(CanType(reqt.getSecondType()))->getDecl();
+        auto protocol = reqt.getProtocolDecl();
         if (Lowering::TypeConverter::protocolRequiresWitnessTable(protocol)) {
           callback({type, protocol});
         }
@@ -926,7 +925,7 @@ static bool isDependentConformance(
     if (req.getKind() != RequirementKind::Conformance)
       continue;
 
-    auto assocProtocol = req.getSecondType()->castTo<ProtocolType>()->getDecl();
+    auto assocProtocol = req.getProtocolDecl();
     if (assocProtocol->isObjC())
       continue;
 
@@ -2801,8 +2800,7 @@ void NecessaryBindings::addAbstractConditionalRequirements(
   for (auto req : condRequirements) {
     if (req.getKind() != RequirementKind::Conformance)
       continue;
-    auto *proto =
-        req.getSecondType()->castTo<ProtocolType>()->getDecl();
+    auto *proto = req.getProtocolDecl();
     auto ty = req.getFirstType()->getCanonicalType();
     auto archetype = dyn_cast<ArchetypeType>(ty);
     if (!archetype)
diff --git a/lib/SIL/IR/SILWitnessTable.cpp b/lib/SIL/IR/SILWitnessTable.cpp
index b6be229f53e..26e654f5faa 100644
--- a/lib/SIL/IR/SILWitnessTable.cpp
+++ b/lib/SIL/IR/SILWitnessTable.cpp
@@ -187,7 +187,7 @@ bool SILWitnessTable::enumerateWitnessTableConditionalConformances(
     if (req.getKind() != RequirementKind::Conformance)
       continue;
 
-    auto proto = req.getSecondType()->castTo<ProtocolType>()->getDecl();
+    auto proto = req.getProtocolDecl();
 
     if (Lowering::TypeConverter::protocolRequiresWitnessTable(proto)) {
       if (fn(conformanceIndex, req.getFirstType()->getCanonicalType(), proto))
diff --git a/lib/SILOptimizer/Mandatory/Differentiation.cpp b/lib/SILOptimizer/Mandatory/Differentiation.cpp
index f76c233318d..326c1a93367 100644
--- a/lib/SILOptimizer/Mandatory/Differentiation.cpp
+++ b/lib/SILOptimizer/Mandatory/Differentiation.cpp
@@ -266,8 +266,7 @@ static bool diagnoseUnsatisfiedRequirements(ADContext &context,
     }
     // Check conformance requirements.
     case RequirementKind::Conformance: {
-      auto protocolType = req.getSecondType()->castTo<ProtocolType>();
-      auto protocol = protocolType->getDecl();
+      auto *protocol = req.getProtocolDecl();
       assert(protocol && "Expected protocol in generic signature requirement");
       // If the first type does not conform to the second type in the current
       // module, then record the unsatisfied requirement.
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
index 9399fc33525..beb02b7d7f5 100644
--- a/lib/Sema/ConstraintSystem.cpp
+++ b/lib/Sema/ConstraintSystem.cpp
@@ -1381,14 +1381,13 @@ void ConstraintSystem::openGenericRequirements(
     auto kind = req.getKind();
     switch (kind) {
     case RequirementKind::Conformance: {
-      auto proto = req.getSecondType()->castTo<ProtocolType>();
-      auto protoDecl = proto->getDecl();
+      auto protoDecl = req.getProtocolDecl();
       // Determine whether this is the protocol 'Self' constraint we should
       // skip.
       if (skipProtocolSelfConstraint && protoDecl == outerDC &&
           protoDecl->getSelfInterfaceType()->isEqual(req.getFirstType()))
         continue;
-      openedReq = Requirement(kind, openedFirst, proto);
+      openedReq = Requirement(kind, openedFirst, req.getSecondType());
       break;
     }
     case RequirementKind::Superclass:
diff --git a/lib/Sema/DerivedConformanceDifferentiable.cpp b/lib/Sema/DerivedConformanceDifferentiable.cpp
index a1760713a3d..58f6a7fbe35 100644
--- a/lib/Sema/DerivedConformanceDifferentiable.cpp
+++ b/lib/Sema/DerivedConformanceDifferentiable.cpp
@@ -409,7 +409,7 @@ getOrSynthesizeTangentVectorStruct(DerivedConformance &derived, Identifier id) {
   // Note that, for example, this will always find `AdditiveArithmetic` and `Differentiable` because
   // the `Differentiable` protocol itself requires that its `TangentVector` conforms to
   // `AdditiveArithmetic` and `Differentiable`.
-  llvm::SmallPtrSet<ProtocolType *, 4> tvDesiredProtos;
+  llvm::SmallPtrSet<ProtocolDecl *, 4> tvDesiredProtos;
   llvm::SmallPtrSet<ProtocolDecl *, 4> conformanceInheritedProtos;
   getInheritedProtocols(derived.ConformanceDecl, conformanceInheritedProtos);
   auto *diffableProto = C.getProtocol(KnownProtocolKind::Differentiable);
@@ -421,15 +421,13 @@ getOrSynthesizeTangentVectorStruct(DerivedConformance &derived, Identifier id) {
       auto *firstType = req.getFirstType()->getAs<DependentMemberType>();
       if (!firstType || firstType->getAssocType() != tvAssocType)
         continue;
-      auto tvRequiredProto = req.getSecondType()->getAs<ProtocolType>();
-      if (!tvRequiredProto)
-        continue;
-      tvDesiredProtos.insert(tvRequiredProto);
+      tvDesiredProtos.insert(req.getProtocolDecl());
     }
   }
   SmallVector<TypeLoc, 4> tvDesiredProtoTypeLocs;
   for (auto *p : tvDesiredProtos)
-    tvDesiredProtoTypeLocs.push_back(TypeLoc::withoutLoc(p));
+    tvDesiredProtoTypeLocs.push_back(
+      TypeLoc::withoutLoc(p->getDeclaredInterfaceType()));
 
   // Cache original members and their associated types for later use.
   SmallVector<VarDecl *, 8> diffProperties;
diff --git a/lib/Sema/TypeCheckEffects.cpp b/lib/Sema/TypeCheckEffects.cpp
index 3250c4d16b3..e42fb591025 100644
--- a/lib/Sema/TypeCheckEffects.cpp
+++ b/lib/Sema/TypeCheckEffects.cpp
@@ -88,8 +88,7 @@ PolymorphicEffectRequirementsRequest::evaluate(Evaluator &evaluator,
     if (requirement.getKind() != RequirementKind::Conformance)
       continue;
 
-    auto protoTy = requirement.getSecondType()->castTo<ProtocolType>();
-    auto protoDecl = protoTy->getDecl();
+    auto *protoDecl = requirement.getProtocolDecl();
     if (!protoDecl->hasPolymorphicEffect(kind))
       continue;
 
@@ -119,9 +118,7 @@ PolymorphicEffectKindRequest::evaluate(Evaluator &evaluator,
   if (auto genericSig = decl->getGenericSignature()) {
     for (auto req : genericSig->getRequirements()) {
       if (req.getKind() == RequirementKind::Conformance) {
-        if (req.getSecondType()->castTo<ProtocolType>()
-                               ->getDecl()
-                               ->hasPolymorphicEffect(kind)) {
+        if (req.getProtocolDecl()->hasPolymorphicEffect(kind)) {
           return PolymorphicEffectKind::ByConformance;
         }
       }
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
index 20abf643d0b..e7e78e7e15c 100644
--- a/lib/Sema/TypeCheckGeneric.cpp
+++ b/lib/Sema/TypeCheckGeneric.cpp
@@ -259,7 +259,7 @@ void TypeChecker::checkProtocolSelfRequirements(ValueDecl *decl) {
 
       // The conformance of 'Self' to the protocol is okay.
       if (req.getKind() == RequirementKind::Conformance &&
-          req.getSecondType()->getAs<ProtocolType>()->getDecl() == proto &&
+          req.getProtocolDecl() == proto &&
           req.getFirstType()->is<GenericTypeParamType>())
         continue;
 
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
index 635e1fe5766..9cf70981bb3 100644
--- a/lib/Sema/TypeCheckProtocol.cpp
+++ b/lib/Sema/TypeCheckProtocol.cpp
@@ -1942,12 +1942,11 @@ checkIndividualConformance(NormalProtocolConformance *conformance,
     if (!Proto->isMarkerProtocol()) {
       for (const auto &req : *conditionalReqs) {
         if (req.getKind() == RequirementKind::Conformance &&
-            req.getSecondType()->castTo<ProtocolType>()->getDecl()
-              ->isMarkerProtocol()) {
+            req.getProtocolDecl()->isMarkerProtocol()) {
           C.Diags.diagnose(
             ComplainLoc, diag::marker_protocol_conditional_conformance,
             Proto->getName(), req.getFirstType(),
-            req.getSecondType()->castTo<ProtocolType>()->getDecl()->getName());
+            req.getProtocolDecl()->getName());
           conformance->setInvalid();
         }
       }
@@ -4448,7 +4447,7 @@ void ConformanceChecker::ensureRequirementsAreSatisfied() {
   for (auto req : proto->getRequirementSignature()) {
     if (req.getKind() == RequirementKind::Conformance) {
       auto depTy = req.getFirstType();
-      auto *proto = req.getSecondType()->castTo<ProtocolType>()->getDecl();
+      auto *proto = req.getProtocolDecl();
       auto conformance = Conformance->getAssociatedConformance(depTy, proto);
       if (conformance.isConcrete()) {
         auto *concrete = conformance.getConcrete();
@@ -6361,8 +6360,7 @@ void TypeChecker::inferDefaultWitnesses(ProtocolDecl *proto) {
 
     Type defaultAssocTypeInContext =
       proto->mapTypeIntoContext(defaultAssocType);
-    auto requirementProto =
-      req.getSecondType()->castTo<ProtocolType>()->getDecl();
+    auto requirementProto = req.getProtocolDecl();
     auto conformance = conformsToProtocol(defaultAssocTypeInContext,
                                           requirementProto, proto);
     if (conformance.isInvalid()) {
diff --git a/lib/Sema/TypeCheckProtocolInference.cpp b/lib/Sema/TypeCheckProtocolInference.cpp
index 95136d651a2..6f861534c11 100644
--- a/lib/Sema/TypeCheckProtocolInference.cpp
+++ b/lib/Sema/TypeCheckProtocolInference.cpp
@@ -1510,8 +1510,7 @@ static Comparison compareDeclsForInference(DeclContext *DC, ValueDecl *decl1,
       continue;
     switch (reqt.getKind()) {
     case RequirementKind::Conformance: {
-      auto *proto = reqt.getSecondType()->castTo<ProtocolType>()->getDecl();
-      insertProtocol(proto);
+      insertProtocol(reqt.getProtocolDecl());
       break;
     }
     case RequirementKind::Superclass:
@@ -1543,8 +1542,7 @@ static Comparison compareDeclsForInference(DeclContext *DC, ValueDecl *decl1,
       continue;
     switch (reqt.getKind()) {
     case RequirementKind::Conformance: {
-      auto *proto = reqt.getSecondType()->castTo<ProtocolType>()->getDecl();
-      removeProtocol(proto);
+      removeProtocol(reqt.getProtocolDecl());
       break;
     }
     case RequirementKind::Superclass:
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
index 90d85f389a3..a0e17108a9c 100644
--- a/lib/Serialization/Deserialization.cpp
+++ b/lib/Serialization/Deserialization.cpp
@@ -6244,8 +6244,7 @@ void ModuleFile::finishNormalConformance(NormalProtocolConformance *conformance,
     for (const auto &req : proto->getRequirementSignature()) {
       if (req.getKind() != RequirementKind::Conformance)
         continue;
-      ProtocolDecl *proto =
-          req.getSecondType()->castTo<ProtocolType>()->getDecl();
+      ProtocolDecl *proto = req.getProtocolDecl();
       auto iter = conformancesForProtocols.find(proto);
       if (iter != conformancesForProtocols.end()) {
         reqConformances.push_back(iter->getSecond());
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp b/tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp
index f1d3d9ea01f..11e739dd714 100644
--- a/tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp
+++ b/tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp
@@ -318,7 +318,7 @@ static void initDocGenericParams(const Decl *D, DocEntityInfo &Info,
     if (Proto &&
         Req.getKind() == RequirementKind::Conformance &&
         Req.getFirstType()->isEqual(Proto->getSelfInterfaceType()) &&
-        Req.getSecondType()->getAnyNominal() == Proto)
+        Req.getProtocolDecl() == Proto)
       continue;
 
     auto First = Req.getFirstType();