AST: TypeChecker::conformsToProtocol() => ModuleDecl::checkConformance()

Author: slavapestov

include/swift/AST/Module.h

@@ -823,10 +823,7 @@ class ModuleDecl
                          DeclName name,
                          SmallVectorImpl<ValueDecl*> &results) const;
 
-  /// Look for the conformance of the given type to the given protocol.
-  ///
-  /// This routine determines whether the given \c type conforms to the given
-  /// \c protocol.
+  /// Global conformance lookup, does not check conditional requirements.
   ///
   /// \param type The type for which we are computing conformance.
   ///
@@ -836,23 +833,33 @@ class ModuleDecl
   /// might include "missing" conformances, which are synthesized for some
   /// protocols as an error recovery mechanism.
   ///
-  /// \returns The result of the conformance search, which will be
-  /// None if the type does not conform to the protocol or contain a
-  /// ProtocolConformanceRef if it does conform.
+  /// \returns An invalid conformance if the search failed, otherwise an
+  /// abstract, concrete or pack conformance, depending on the lookup type.
   ProtocolConformanceRef lookupConformance(Type type, ProtocolDecl *protocol,
                                            bool allowMissing = false);
 
+  /// Global conformance lookup, checks conditional requirements.
+  ///
+  /// \param type The type for which we are computing conformance. Must not
+  /// contain type parameters.
+  ///
+  /// \param protocol The protocol to which we are computing conformance.
+  ///
+  /// \param allowMissing When \c true, the resulting conformance reference
+  /// might include "missing" conformances, which are synthesized for some
+  /// protocols as an error recovery mechanism.
+  ///
+  /// \returns An invalid conformance if the search failed, otherwise an
+  /// abstract, concrete or pack conformance, depending on the lookup type.
+  ProtocolConformanceRef checkConformance(Type type, ProtocolDecl *protocol,
+                                          // Note: different default than above
+                                          bool allowMissing = true);
+
   /// Look for the conformance of the given existential type to the given
   /// protocol.
   ProtocolConformanceRef lookupExistentialConformance(Type type,
                                                       ProtocolDecl *protocol);
 
-  /// Exposes TypeChecker functionality for querying protocol conformance.
-  /// Returns a valid ProtocolConformanceRef only if all conditional
-  /// requirements are successfully resolved.
-  ProtocolConformanceRef conformsToProtocol(Type sourceTy,
-                                            ProtocolDecl *targetProtocol);
-
   /// Collect the conformances of \c fromType to each of the protocols of an
   /// existential type's layout.
   ///

lib/AST/Module.cpp

@@ -2249,6 +2249,31 @@ LookupConformanceInModuleRequest::evaluate(
   return ProtocolConformanceRef(conformance);
 }
 
+ProtocolConformanceRef
+ModuleDecl::checkConformance(Type type, ProtocolDecl *proto,
+                             bool allowMissing) {
+  auto lookupResult = lookupConformance(type, proto, allowMissing);
+  if (lookupResult.isInvalid()) {
+    return ProtocolConformanceRef::forInvalid();
+  }
+
+  auto condReqs = lookupResult.getConditionalRequirements();
+
+  // If we have a conditional requirements that we need to check, do so now.
+  if (!condReqs.empty()) {
+    switch (checkRequirements(condReqs)) {
+    case CheckRequirementsResult::Success:
+      break;
+
+    case CheckRequirementsResult::RequirementFailure:
+    case CheckRequirementsResult::SubstitutionFailure:
+      return ProtocolConformanceRef::forInvalid();
+    }
+  }
+
+  return lookupResult;
+}
+
 Fingerprint SourceFile::getInterfaceHash() const {
   assert(hasInterfaceHash() && "Interface hash not enabled");
   auto &eval = getASTContext().evaluator;

lib/IDE/ConformingMethodList.cpp

@@ -179,7 +179,7 @@ void ConformingMethodListCallbacks::getMatchingMethods(
 
       // The return type conforms to any of the requested protocols.
       for (auto Proto : ExpectedTypes) {
-        if (CurModule->conformsToProtocol(resultTy, Proto))
+        if (CurModule->checkConformance(resultTy, Proto))
           return true;
       }
 

lib/IDE/IDETypeChecking.cpp

@@ -689,7 +689,7 @@ class ExpressionTypeCollector: public SourceEntityWalker {
 
     // Collecting protocols conformed by this expressions that are in the list.
     for (auto Proto: InterestedProtocols) {
-      if (Module.conformsToProtocol(E->getType(), Proto.first)) {
+      if (Module.checkConformance(E->getType(), Proto.first)) {
         Conformances.push_back(Proto.second);
       }
     }

lib/Refactoring/Async/AsyncHandlerDesc.cpp

@@ -19,7 +19,7 @@ using namespace swift::refactoring::asyncrefactorings;
 static bool isErrorType(Type Ty, ModuleDecl *MD) {
   if (!Ty)
     return false;
-  return !MD->conformsToProtocol(Ty, Ty->getASTContext().getErrorDecl())
+  return !MD->checkConformance(Ty, Ty->getASTContext().getErrorDecl())
               .isInvalid();
 }
 

lib/SIL/IR/SILType.cpp

@@ -1252,7 +1252,7 @@ SILType SILType::removingMoveOnlyWrapperToBoxedType(const SILFunction *fn) {
 
 ProtocolConformanceRef
 SILType::conformsToProtocol(SILFunction *fn, ProtocolDecl *protocol) const {
-  return fn->getParentModule()->conformsToProtocol(getASTType(), protocol);
+  return fn->getParentModule()->checkConformance(getASTType(), protocol);
 }
 
 bool SILType::isSendable(SILFunction *fn) const {

lib/SIL/IR/TypeLowering.cpp

@@ -3027,7 +3027,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
   if (!bitwiseCopyableProtocol)
     return;
 
-  auto conformance = M.conformsToProtocol(substType, bitwiseCopyableProtocol);
+  auto conformance = M.checkConformance(substType, bitwiseCopyableProtocol);
 
   if (lowering.isTrivial() && !conformance) {
     // A trivial type can only lack a conformance if one of its leaves is a
@@ -3063,7 +3063,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
 
           // A BitwiseCopyable conformer appearing within its layout doesn't
           // explain why substType doesn't itself conform.
-          if (M.conformsToProtocol(ty, bitwiseCopyableProtocol))
+          if (M.checkConformance(ty, bitwiseCopyableProtocol))
             return true;
 
           // ModuleTypes are trivial but don't warrant being given a conformance
@@ -3143,7 +3143,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
 
           // Unfortunately, the type parameter's conformance may not be visible
           // here.
-          assert(M.conformsToProtocol(ty, bitwiseCopyableProtocol) &&
+          assert(M.checkConformance(ty, bitwiseCopyableProtocol) &&
                  "leaf of non-trivial BitwiseCopyable type that doesn't "
                  "conform to BitwiseCopyable!?");
 

lib/SIL/Utils/DynamicCasts.cpp

@@ -103,17 +103,17 @@ classifyDynamicCastToProtocol(ModuleDecl *M, CanType source, CanType target,
   if (!TargetProtocol)
     return DynamicCastFeasibility::MaySucceed;
 
-  // If the target is a parameterized protocol type, conformsToProtocol
+  // If the target is a parameterized protocol type, checkConformance
   // is insufficient to prove the feasibility of the cast as it does not
   // check the additional requirements.
   // FIXME: This is a weak predicate that doesn't take into account
   // class compositions - since any C & P<T> doesn't work yet anyways.
   if (isa<ParameterizedProtocolType>(unwrapExistential(target)))
     return DynamicCastFeasibility::MaySucceed;
 
-  // If conformsToProtocol returns a valid conformance, then all requirements
-  // were proven by the type checker.
-  if (M->conformsToProtocol(source, TargetProtocol))
+  // If checkConformance() returns a valid conformance, then all conditional
+  // requirements were satisfied.
+  if (M->checkConformance(source, TargetProtocol))
     return DynamicCastFeasibility::WillSucceed;
 
   auto *SourceNominalTy = source.getAnyNominal();
@@ -141,14 +141,14 @@ classifyDynamicCastToProtocol(ModuleDecl *M, CanType source, CanType target,
   }
 
   // The WillFail conditions below assume any possible conformance on the
-  // nominal source type has been ruled out. The prior conformsToProtocol query
+  // nominal source type has been ruled out. The prior checkConformance query
   // identified any definite conformance. Now check if there is already a known
   // conditional conformance on the nominal type with requirements that were
   // not proven.
   //
   // TODO: The TypeChecker can easily prove that some requirements cannot be
   // met. Returning WillFail in those cases would be more optimal. To do that,
-  // the conformsToProtocol interface needs to be reformulated as a query, and
+  // the checkConformance interface needs to be reformulated as a query, and
   // the implementation, including checkGenericArguments, needs to be taught to
   // recognize that types with archetypes may potentially succeed.
   if (auto conformance = M->lookupConformance(source, TargetProtocol)) {

lib/SILGen/SILGenApply.cpp

@@ -5866,7 +5866,7 @@ SILValue SILGenFunction::emitApplyWithRethrow(SILLocation loc, SILValue fn,
         assert(outerErrorType == SILType::getExceptionType(getASTContext()));
 
         ProtocolConformanceRef conformances[1] = {
-          getModule().getSwiftModule()->conformsToProtocol(
+          getModule().getSwiftModule()->checkConformance(
             innerError->getType().getASTType(),
             getASTContext().getErrorDecl())
         };

lib/SILGen/SILGenExpr.cpp

@@ -5949,7 +5949,7 @@ static void diagnoseImplicitRawConversion(Type sourceTy, Type pointerTy,
   auto *SM = SGF.getModule().getSwiftModule();
   if (auto *fixedWidthIntegerDecl = SM->getASTContext().getProtocol(
           KnownProtocolKind::FixedWidthInteger)) {
-    if (SM->conformsToProtocol(eltTy, fixedWidthIntegerDecl))
+    if (SM->checkConformance(eltTy, fixedWidthIntegerDecl))
       return;
   }
 

lib/SILGen/SILGenStmt.cpp

@@ -1606,7 +1606,7 @@ void SILGenFunction::emitThrow(SILLocation loc, ManagedValue exnMV,
     assert(destErrorType == SILType::getExceptionType(getASTContext()));
 
     ProtocolConformanceRef conformances[1] = {
-      getModule().getSwiftModule()->conformsToProtocol(
+      getModule().getSwiftModule()->checkConformance(
         exn->getType().getASTType(), getASTContext().getErrorDecl())
     };
 

lib/SILOptimizer/Utils/CastOptimizer.cpp

@@ -1461,14 +1461,14 @@ static bool optimizeStaticallyKnownProtocolConformance(
     // SourceType is a non-existential type with a non-conditional
     // conformance to a protocol represented by the TargetType.
     //
-    // TypeChecker::conformsToProtocol checks any conditional conformances. If
+    // ModuleDecl::checkConformance() checks any conditional conformances. If
     // they depend on information not known until runtime, the conformance
     // will not be returned. For instance, if `X: P` where `T == Int` in `func
     // foo<T>(_: T) { ... X<T>() as? P ... }`, the cast will succeed for
     // `foo(0)` but not for `foo("string")`. There are many cases where
     // everything is completely static (`X<Int>() as? P`), in which case a
     // valid conformance will be returned.
-    auto Conformance = SM->conformsToProtocol(SourceType, Proto);
+    auto Conformance = SM->checkConformance(SourceType, Proto);
     if (Conformance.isInvalid())
       return false;
 

lib/SILOptimizer/Utils/Existential.cpp

@@ -389,7 +389,7 @@ ConcreteExistentialInfo::ConcreteExistentialInfo(SILValue existential,
 
   // We have the open_existential; we still need the conformance.
   auto ConformanceRef =
-      M->getSwiftModule()->conformsToProtocol(ConcreteTypeCandidate, Protocol);
+      M->getSwiftModule()->checkConformance(ConcreteTypeCandidate, Protocol);
   if (ConformanceRef.isInvalid())
     return;
 

lib/Sema/CSApply.cpp

@@ -113,8 +113,8 @@ Solution::computeSubstitutions(GenericSignature sig,
     }
 
     // FIXME: Retrieve the conformance from the solution itself.
-    return TypeChecker::conformsToProtocol(replacement, protoType,
-                                   getConstraintSystem().DC->getParentModule());
+    return getConstraintSystem().DC->getParentModule()->checkConformance(
+        replacement, protoType);
   };
 
   return SubstitutionMap::get(sig,
@@ -565,7 +565,7 @@ namespace {
           // the protocol requirement with Self == the concrete type, and SILGen
           // (or later) can devirtualize as appropriate.
           auto conformance =
-            TypeChecker::conformsToProtocol(baseTy, proto, dc->getParentModule());
+            dc->getParentModule()->checkConformance(baseTy, proto);
           if (conformance.isConcrete()) {
             if (auto witness = conformance.getConcrete()->getWitnessDecl(decl)) {
               bool isMemberOperator = witness->getDeclContext()->isTypeContext();
@@ -2459,9 +2459,7 @@ namespace {
 
       // Try to find the conformance of the value type to _BridgedToObjectiveC.
       auto bridgedToObjectiveCConformance
-        = TypeChecker::conformsToProtocol(valueType,
-                                          bridgedProto,
-                                          dc->getParentModule());
+        = dc->getParentModule()->checkConformance(valueType, bridgedProto);
 
       FuncDecl *fn = nullptr;
 
@@ -2722,7 +2720,7 @@ namespace {
       ProtocolDecl *protocol = TypeChecker::getProtocol(
           ctx, expr->getLoc(), KnownProtocolKind::ExpressibleByStringLiteral);
 
-      if (!TypeChecker::conformsToProtocol(type, protocol, dc->getParentModule())) {
+      if (!dc->getParentModule()->checkConformance(type, protocol)) {
         // If the type does not conform to ExpressibleByStringLiteral, it should
         // be ExpressibleByExtendedGraphemeClusterLiteral.
         protocol = TypeChecker::getProtocol(
@@ -2731,7 +2729,7 @@ namespace {
         isStringLiteral = false;
         isGraphemeClusterLiteral = true;
       }
-      if (!TypeChecker::conformsToProtocol(type, protocol, dc->getParentModule())) {
+      if (!dc->getParentModule()->checkConformance(type, protocol)) {
         // ... or it should be ExpressibleByUnicodeScalarLiteral.
         protocol = TypeChecker::getProtocol(
             cs.getASTContext(), expr->getLoc(),
@@ -2846,7 +2844,7 @@ namespace {
         assert(proto && "Missing string interpolation protocol?");
 
         auto conformance =
-          TypeChecker::conformsToProtocol(type, proto, dc->getParentModule());
+          dc->getParentModule()->checkConformance(type, proto);
         assert(conformance && "string interpolation type conforms to protocol");
 
         DeclName constrName(ctx, DeclBaseName::createConstructor(), argLabels);
@@ -2987,8 +2985,7 @@ namespace {
       auto proto = TypeChecker::getLiteralProtocol(ctx, expr);
       assert(proto && "Missing object literal protocol?");
       auto conformance =
-        TypeChecker::conformsToProtocol(conformingType, proto,
-                                        dc->getParentModule());
+        dc->getParentModule()->checkConformance(conformingType, proto);
       assert(conformance && "object literal type conforms to protocol");
 
       auto constrName = TypeChecker::getObjectLiteralConstructorName(ctx, expr);
@@ -3686,8 +3683,7 @@ namespace {
       assert(arrayProto && "type-checked array literal w/o protocol?!");
 
       auto conformance =
-        TypeChecker::conformsToProtocol(arrayTy, arrayProto,
-                                        dc->getParentModule());
+        dc->getParentModule()->checkConformance(arrayTy, arrayProto);
       assert(conformance && "Type does not conform to protocol?");
 
       DeclName name(ctx, DeclBaseName::createConstructor(),
@@ -3733,8 +3729,7 @@ namespace {
           KnownProtocolKind::ExpressibleByDictionaryLiteral);
 
       auto conformance =
-        TypeChecker::conformsToProtocol(dictionaryTy, dictionaryProto,
-                                        dc->getParentModule());
+        dc->getParentModule()->checkConformance(dictionaryTy, dictionaryProto);
       if (conformance.isInvalid())
         return nullptr;
 
@@ -5345,8 +5340,7 @@ namespace {
         // verified by the solver, we just need to get it again
         // with all of the generic parameters resolved.
         auto hashableConformance =
-          TypeChecker::conformsToProtocol(indexType, hashable,
-                                          dc->getParentModule());
+          dc->getParentModule()->checkConformance(indexType, hashable);
         assert(hashableConformance);
 
         conformances.push_back(hashableConformance);
@@ -6905,8 +6899,8 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       // Find the conformance of the source type to Hashable.
       auto hashable = ctx.getProtocol(KnownProtocolKind::Hashable);
       auto conformance =
-        TypeChecker::conformsToProtocol(
-                        cs.getType(expr), hashable, dc->getParentModule());
+        dc->getParentModule()->checkConformance(
+                        cs.getType(expr), hashable);
       assert(conformance && "must conform to Hashable");
 
       return cs.cacheType(
@@ -7692,8 +7686,8 @@ Expr *ExprRewriter::convertLiteralInPlace(
   // Check whether this literal type conforms to the builtin protocol. If so,
   // initialize via the builtin protocol.
   if (builtinProtocol) {
-    auto builtinConformance = TypeChecker::conformsToProtocol(
-        type, builtinProtocol, dc->getParentModule());
+    auto builtinConformance = dc->getParentModule()->checkConformance(
+        type, builtinProtocol);
     if (builtinConformance) {
       // Find the witness that we'll use to initialize the type via a builtin
       // literal.
@@ -7716,8 +7710,7 @@ Expr *ExprRewriter::convertLiteralInPlace(
 
   // This literal type must conform to the (non-builtin) protocol.
   assert(protocol && "requirements should have stopped recursion");
-  auto conformance = TypeChecker::conformsToProtocol(type, protocol,
-                                                     dc->getParentModule());
+  auto conformance = dc->getParentModule()->checkConformance(type, protocol);
   assert(conformance && "must conform to literal protocol");
 
   // Dig out the literal type and perform a builtin literal conversion to it.
@@ -7841,8 +7834,7 @@ std::pair<Expr *, ArgumentList *> ExprRewriter::buildDynamicCallable(
     auto dictLitProto =
         ctx.getProtocol(KnownProtocolKind::ExpressibleByDictionaryLiteral);
     auto conformance =
-        TypeChecker::conformsToProtocol(argumentType, dictLitProto,
-                                        dc->getParentModule());
+        dc->getParentModule()->checkConformance(argumentType, dictLitProto);
     auto keyType = conformance.getTypeWitnessByName(argumentType, ctx.Id_Key);
     auto valueType =
         conformance.getTypeWitnessByName(argumentType, ctx.Id_Value);
@@ -9192,8 +9184,8 @@ static llvm::Optional<SequenceIterationInfo> applySolutionToForEachStmt(
         parsedSequence, LocatorPathElt::ContextualType(CTP_ForEachSequence));
     type = Type(solution.OpenedExistentialTypes[contextualLoc]);
   }
-  auto sequenceConformance = TypeChecker::conformsToProtocol(
-      type, sequenceProto, dc->getParentModule());
+  auto sequenceConformance = dc->getParentModule()->checkConformance(
+      type, sequenceProto);
   assert(!sequenceConformance.isInvalid() &&
          "Couldn't find sequence conformance");
   stmt->setSequenceConformance(sequenceConformance);