[NFC] GenericSignatureImpl: Spell conformsToProtocol & getConformsTo in terms of requirements

AnthonyLatsis · AnthonyLatsis · commit 44a92a926cfd · 2020-05-14T22:51:44.000+03:00
diff --git a/include/swift/AST/GenericSignature.h b/include/swift/AST/GenericSignature.h
@@ -152,7 +152,7 @@ class GenericSignature {
                       TypeArrayView<GenericTypeParamType> genericParams,
                       ArrayRef<Requirement> requirements);
 public:
-  using ConformsToArray = SmallVector<ProtocolDecl *, 2>;
+  using RequiredProtocols = SmallVector<ProtocolDecl *, 2>;
 
 private:
   // Direct comparison is disabled for generic signatures.  Canonicalize them
@@ -318,12 +318,13 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Determine the superclass bound on the given dependent type.
   Type getSuperclassBound(Type type) const;
 
-  /// Determine the set of protocols to which the given dependent type
-  /// must conform.
-  GenericSignature::ConformsToArray getConformsTo(Type type) const;
+  /// Determine the set of protocols to which the given type parameter is
+  /// required to conform.
+  GenericSignature::RequiredProtocols getRequiredProtocols(Type type) const;
 
-  /// Determine whether the given dependent type conforms to this protocol.
-  bool conformsToProtocol(Type type, ProtocolDecl *proto) const;
+  /// Determine whether the given type parameter is required to conform to
+  /// the given protocol.
+  bool requiresProtocol(Type type, ProtocolDecl *proto) const;
 
   /// Determine whether the given dependent type is equal to a concrete type.
   bool isConcreteType(Type type) const;
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -3723,11 +3723,8 @@ OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl,
       superclass = superclass.subst(Substitutions);
     }
   #endif
-  SmallVector<ProtocolDecl*, 4> protos;
-  for (auto proto : signature->getConformsTo(opaqueInterfaceTy)) {
-    protos.push_back(proto);
-  }
-  
+  const auto protos = signature->getRequiredProtocols(opaqueInterfaceTy);
+
   auto mem = ctx.Allocate(
     OpaqueTypeArchetypeType::totalSizeToAlloc<ProtocolDecl *, Type, LayoutConstraint>(
       protos.size(), superclass ? 1 : 0, layout ? 1 : 0),
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -2539,8 +2539,9 @@ void ASTMangler::appendGenericSignatureParts(
 DependentMemberType *
 ASTMangler::dropProtocolFromAssociatedType(DependentMemberType *dmt) {
   auto baseTy = dmt->getBase();
-  bool unambiguous = (!dmt->getAssocType() ||
-                      CurGenericSignature->getConformsTo(baseTy).size() <= 1);
+  bool unambiguous =
+      (!dmt->getAssocType() ||
+       CurGenericSignature->getRequiredProtocols(baseTy).size() <= 1);
 
   if (auto *baseDMT = baseTy->getAs<DependentMemberType>())
     baseTy = dropProtocolFromAssociatedType(baseDMT);
@@ -2573,8 +2574,8 @@ void ASTMangler::appendAssociatedTypeName(DependentMemberType *dmt) {
     // If the base type is known to have a single protocol conformance
     // in the current generic context, then we don't need to disambiguate the
     // associated type name by protocol.
-    if (!OptimizeProtocolNames || !CurGenericSignature
-        || CurGenericSignature->getConformsTo(dmt->getBase()).size() > 1) {
+    if (!OptimizeProtocolNames || !CurGenericSignature ||
+        CurGenericSignature->getRequiredProtocols(dmt->getBase()).size() > 1) {
       appendAnyGenericType(assocTy->getProtocol());
     }
     return;
diff --git a/lib/AST/GenericSignature.cpp b/lib/AST/GenericSignature.cpp
@@ -424,10 +424,10 @@ Type GenericSignatureImpl::getSuperclassBound(Type type) const {
   return equivClass->superclass;
 }
 
-/// Determine the set of protocols to which the given dependent type
-/// must conform.
-SmallVector<ProtocolDecl *, 2>
-GenericSignatureImpl::getConformsTo(Type type) const {
+/// Determine the set of protocols to which the given type parameter is
+/// required to conform.
+GenericSignature::RequiredProtocols
+GenericSignatureImpl::getRequiredProtocols(Type type) const {
   if (!type->isTypeParameter()) return { };
 
   auto &builder = *getGenericSignatureBuilder();
@@ -437,12 +437,12 @@ GenericSignatureImpl::getConformsTo(Type type) const {
                                   ArchetypeResolutionKind::CompleteWellFormed);
   if (!equivClass) return { };
 
-  // If this type was mapped to a concrete type, then there are no
-  // requirements.
+  // If this type parameter was mapped to a concrete type, then there
+  // are no requirements.
   if (equivClass->concreteType) return { };
 
   // Retrieve the protocols to which this type conforms.
-  SmallVector<ProtocolDecl *, 2> result;
+  GenericSignature::RequiredProtocols result;
   for (const auto &conforms : equivClass->conformsTo)
     result.push_back(conforms.first);
 
@@ -452,8 +452,8 @@ GenericSignatureImpl::getConformsTo(Type type) const {
   return result;
 }
 
-bool GenericSignatureImpl::conformsToProtocol(Type type,
-                                              ProtocolDecl *proto) const {
+bool GenericSignatureImpl::requiresProtocol(Type type,
+                                            ProtocolDecl *proto) const {
   assert(type->isTypeParameter() && "Expected a type parameter");
 
   auto &builder = *getGenericSignatureBuilder();
@@ -463,7 +463,11 @@ bool GenericSignatureImpl::conformsToProtocol(Type type,
                                   ArchetypeResolutionKind::CompleteWellFormed);
   if (!equivClass) return false;
 
-  // FIXME: Deal with concrete conformances here?
+  // FIXME: Optionally deal with concrete conformances here
+  // or have a separate method do that additionally?
+  //
+  // If this type parameter was mapped to a concrete type, then there
+  // are no requirements.
   if (equivClass->concreteType) return false;
 
   // Check whether the representative conforms to this protocol.
@@ -541,7 +545,7 @@ bool GenericSignatureImpl::isRequirementSatisfied(
     auto protocol = protocolType->getDecl();
 
     if (canFirstType->isTypeParameter())
-      return conformsToProtocol(canFirstType, protocol);
+      return requiresProtocol(canFirstType, protocol);
     else
       return (bool)GSB->lookupConformance(/*dependentType=*/CanType(),
                                           canFirstType, protocol);
diff --git a/lib/AST/SubstitutionMap.cpp b/lib/AST/SubstitutionMap.cpp
@@ -368,7 +368,7 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
 
   // If the type doesn't conform to this protocol, the result isn't formed
   // from these requirements.
-  if (!genericSig->conformsToProtocol(type, proto))
+  if (!genericSig->requiresProtocol(type, proto))
     return ProtocolConformanceRef::forInvalid();
 
   auto accessPath =
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
@@ -2416,7 +2416,7 @@ bool ClangImporter::Implementation::matchesHashableBound(Type type) {
     if (auto *generic = genericTy->getDecl()) {
       auto genericSig =
         generic->getDeclContext()->getGenericSignatureOfContext();
-      if (genericSig && genericSig->getConformsTo(type).empty()) {
+      if (genericSig && genericSig->getRequiredProtocols(type).empty()) {
         type = genericSig->getSuperclassBound(type);
         if (!type)
           return false;
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -2344,7 +2344,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       }
 
       if (t->isTypeParameter()) {
-        auto protos = genericSig->getConformsTo(t);
+        const auto protos = genericSig->getRequiredProtocols(t);
         if (!protos.empty())
           return buildProtocolComposition(protos);
       }
@@ -4729,7 +4729,7 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
     bool hasExplicitAnyObject = false;
     if (auto superTy = genericSig->getSuperclassBound(ResultT))
       opaqueTypes.push_back(superTy);
-    for (auto proto : genericSig->getConformsTo(ResultT))
+    for (const auto proto : genericSig->getRequiredProtocols(ResultT))
       opaqueTypes.push_back(proto->getDeclaredInterfaceType());
     if (auto layout = genericSig->getLayoutConstraint(ResultT))
       hasExplicitAnyObject = layout->isClass();
diff --git a/lib/IRGen/Fulfillment.h b/lib/IRGen/Fulfillment.h
@@ -68,7 +68,7 @@ class FulfillmentMap {
     virtual bool hasLimitedInterestingConformances(CanType type) const = 0;
 
     /// Return the limited interesting conformances for an interesting type.
-    virtual GenericSignature::ConformsToArray
+    virtual GenericSignature::RequiredProtocols
       getInterestingConformances(CanType type) const = 0;
 
     /// Return the limited interesting conformances for an interesting type.
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
@@ -101,8 +101,8 @@ class PolymorphicConvention {
 
   FulfillmentMap Fulfillments;
 
-  GenericSignature::ConformsToArray getConformsTo(Type t) {
-    return Generics->getConformsTo(t);
+  GenericSignature::RequiredProtocols getRequiredProtocols(Type t) {
+    return Generics->getRequiredProtocols(t);
   }
 
   CanType getSuperclassBound(Type t) {
@@ -166,9 +166,9 @@ class PolymorphicConvention {
     bool hasLimitedInterestingConformances(CanType type) const override {
       return true;
     }
-    GenericSignature::ConformsToArray
+    GenericSignature::RequiredProtocols
     getInterestingConformances(CanType type) const override {
-      return Self.getConformsTo(type);
+      return Self.getRequiredProtocols(type);
     }
     CanType getSuperclassBound(CanType type) const override {
       return Self.getSuperclassBound(type);
@@ -1203,7 +1203,7 @@ class AccessorConformanceInfo : public ConformanceInfo {
           bool hasLimitedInterestingConformances(CanType type) const override {
             return false;
           }
-          GenericSignature::ConformsToArray
+          GenericSignature::RequiredProtocols
           getInterestingConformances(CanType type) const override {
             llvm_unreachable("no limits");
           }
diff --git a/lib/IRGen/LocalTypeData.cpp b/lib/IRGen/LocalTypeData.cpp
@@ -497,7 +497,7 @@ void LocalTypeDataCache::addAbstractForTypeMetadata(IRGenFunction &IGF,
     bool hasLimitedInterestingConformances(CanType type) const override {
       return false;
     }
-    GenericSignature::ConformsToArray
+    GenericSignature::RequiredProtocols
     getInterestingConformances(CanType type) const override {
       llvm_unreachable("no limits");
     }
diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp
@@ -741,7 +741,7 @@ bool irgen::isNominalGenericContextTypeMetadataAccessTrivial(
 
   auto allWitnessTablesAreReferenceable = llvm::all_of(environment->getGenericParams(), [&](auto parameter) {
     auto signature = environment->getGenericSignature();
-    auto protocols = signature->getConformsTo(parameter);
+    const auto protocols = signature->getRequiredProtocols(parameter);
     auto argument = ((Type *)parameter)->subst(substitutions);
     auto canonicalType = argument->getCanonicalType();
     auto witnessTablesAreReferenceable = [&]() {
diff --git a/lib/PrintAsObjC/ModuleContentsWriter.cpp b/lib/PrintAsObjC/ModuleContentsWriter.cpp
@@ -71,8 +71,7 @@ class ReferencedTypeFinder : public TypeDeclFinder {
     if (sig->getSuperclassBound(paramTy))
       return true;
 
-    auto conformsTo = sig->getConformsTo(paramTy);
-    return !conformsTo.empty();
+    return !sig->getRequiredProtocols(paramTy).empty();
   }
 
   Action visitBoundGenericType(BoundGenericType *boundGeneric) override {
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -2923,9 +2923,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     require(selfRequirement &&
             selfRequirement->getKind() == RequirementKind::Conformance,
             "first non-same-typerequirement should be conformance requirement");
-    auto conformsTo = genericSig->getConformsTo(selfGenericParam);
-    require(std::find(conformsTo.begin(), conformsTo.end(), protocol)
-              != conformsTo.end(),
+    const auto protos = genericSig->getRequiredProtocols(selfGenericParam);
+    require(std::find(protos.begin(), protos.end(), protocol) != protos.end(),
             "requirement Self parameter must conform to called protocol");
 
     auto lookupType = AMI->getLookupType();
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -2750,7 +2750,7 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
     ParamDecl *param = *init->getParameters()->begin();
     if (param->getArgumentName() != ctx.Id_erasing ||
         !param->getInterfaceType()->isEqual(genericParamType) ||
-        !genericSignature->conformsToProtocol(genericParamType, protocol))
+        !genericSignature->requiresProtocol(genericParamType, protocol))
       return false;
 
     // Allow other constraints as long as the init can be called with any
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -3707,7 +3707,7 @@ CheckTypeWitnessResult swift::checkTypeWitness(DeclContext *dc,
   auto *module = dc->getParentModule();
 
   // Check protocol conformances.
-  for (auto reqProto : genericSig->getConformsTo(depTy)) {
+  for (const auto reqProto : genericSig->getRequiredProtocols(depTy)) {
     if (module->lookupConformance(contextType, reqProto)
             .isInvalid())
       return CheckTypeWitnessResult(reqProto->getDeclaredType());
diff --git a/tools/swift-ast-script/ASTScriptEvaluator.cpp b/tools/swift-ast-script/ASTScriptEvaluator.cpp
@@ -60,7 +60,7 @@ class ASTScriptWalker : public ASTWalker {
       auto paramResultType = paramFnType->getResult();
       if (!paramResultType->isTypeParameter()) continue;
       auto sig = fn->getGenericSignature();
-      if (!sig->conformsToProtocol(paramResultType, ViewProtocol)) continue;
+      if (!sig->requiresProtocol(paramResultType, ViewProtocol)) continue;
 
       // The parameter must not be a @ViewBuilder parameter.
       if (param->getFunctionBuilderType()) continue;

Original file line number	Diff line number	Diff line change
`@@ -101,8 +101,8 @@ class PolymorphicConvention {`
`101`	`101`
`102`	`102`	`FulfillmentMap Fulfillments;`
`103`	`103`
`104`		`- GenericSignature::ConformsToArray getConformsTo(Type t) {`
`105`		`- return Generics->getConformsTo(t);`
	`104`	`+ GenericSignature::RequiredProtocols getRequiredProtocols(Type t) {`
	`105`	`+ return Generics->getRequiredProtocols(t);`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`CanType getSuperclassBound(Type t) {`
`@@ -166,9 +166,9 @@ class PolymorphicConvention {`
`166`	`166`	`bool hasLimitedInterestingConformances(CanType type) const override {`
`167`	`167`	`return true;`
`168`	`168`	`}`
`169`		`- GenericSignature::ConformsToArray`
	`169`	`+ GenericSignature::RequiredProtocols`
`170`	`170`	`getInterestingConformances(CanType type) const override {`
`171`		`- return Self.getConformsTo(type);`
	`171`	`+ return Self.getRequiredProtocols(type);`
`172`	`172`	`}`
`173`	`173`	`CanType getSuperclassBound(CanType type) const override {`
`174`	`174`	`return Self.getSuperclassBound(type);`
`@@ -1203,7 +1203,7 @@ class AccessorConformanceInfo : public ConformanceInfo {`
`1203`	`1203`	`bool hasLimitedInterestingConformances(CanType type) const override {`
`1204`	`1204`	`return false;`
`1205`	`1205`	`}`
`1206`		`- GenericSignature::ConformsToArray`
	`1206`	`+ GenericSignature::RequiredProtocols`
`1207`	`1207`	`getInterestingConformances(CanType type) const override {`
`1208`	`1208`	`llvm_unreachable("no limits");`
`1209`	`1209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -497,7 +497,7 @@ void LocalTypeDataCache::addAbstractForTypeMetadata(IRGenFunction &IGF,`
`497`	`497`	`bool hasLimitedInterestingConformances(CanType type) const override {`
`498`	`498`	`return false;`
`499`	`499`	`}`
`500`		`- GenericSignature::ConformsToArray`
	`500`	`+ GenericSignature::RequiredProtocols`
`501`	`501`	`getInterestingConformances(CanType type) const override {`
`502`	`502`	`llvm_unreachable("no limits");`
`503`	`503`	`}`