AST: Move checkGenericArguments() to AST and rename to checkRequirements()

slavapestov · slavapestov · commit 1e950b17252c · 2024-01-16T14:47:50.000-05:00
diff --git a/include/swift/AST/Requirement.h b/include/swift/AST/Requirement.h
@@ -207,6 +207,29 @@ inline void simple_display(llvm::raw_ostream &out, const Requirement &req) {
   req.print(out, PrintOptions());
 }
 
+enum class CheckRequirementsResult : uint8_t {
+  Success,
+
+  /// One of the requirements was unsatisfied.
+  RequirementFailure,
+
+  /// One of the requirements contained error types, either because of an
+  /// invalid conformance or because it contained a member type that was
+  /// dependent on an earlier conformance requirement that failed.
+  SubstitutionFailure
+};
+
+/// Check if each substituted requirement is satisfied. The requirement must
+/// not contain any type parameters.
+CheckRequirementsResult checkRequirements(ArrayRef<Requirement> requirements);
+
+/// Check if each requirement is satisfied after applying the given
+/// substitutions. The substitutions must replace all type parameters that
+/// appear in the requirement with concrete types or archetypes.
+CheckRequirementsResult checkRequirements(
+    ModuleDecl *module, ArrayRef<Requirement> requirements,
+    TypeSubstitutionFn substitutions, SubstOptions options=llvm::None);
+
 /// A requirement as written in source, together with a source location. See
 /// ProtocolDecl::getStructuralRequirements().
 struct StructuralRequirement {
diff --git a/lib/AST/Requirement.cpp b/lib/AST/Requirement.cpp
@@ -246,6 +246,46 @@ int Requirement::compare(const Requirement &other) const {
   return compareProtos;
 }
 
+CheckRequirementsResult swift::checkRequirements(ArrayRef<Requirement> requirements) {
+  SmallVector<Requirement, 4> worklist(requirements.begin(), requirements.end());
+
+  bool hadSubstFailure = false;
+
+  while (!worklist.empty()) {
+    auto req = worklist.pop_back_val();
+    switch (req.checkRequirement(worklist, /*allowMissing=*/true)) {
+    case CheckRequirementResult::Success:
+    case CheckRequirementResult::ConditionalConformance:
+    case CheckRequirementResult::PackRequirement:
+      break;
+
+    case CheckRequirementResult::RequirementFailure:
+      return CheckRequirementsResult::RequirementFailure;
+
+    case CheckRequirementResult::SubstitutionFailure:
+      hadSubstFailure = true;
+      break;
+    }
+  }
+
+  if (hadSubstFailure)
+    return CheckRequirementsResult::SubstitutionFailure;
+
+  return CheckRequirementsResult::Success;
+}
+
+CheckRequirementsResult swift::checkRequirements(
+    ModuleDecl *module, ArrayRef<Requirement> requirements,
+    TypeSubstitutionFn substitutions, SubstOptions options) {
+  SmallVector<Requirement, 4> substReqs;
+  for (auto req : requirements) {
+    substReqs.push_back(req.subst(substitutions,
+                              LookUpConformanceInModule(module), options));
+  }
+
+  return checkRequirements(substReqs);
+}
+
 InverseRequirement::InverseRequirement(Type subject,
                                        ProtocolDecl *protocol,
                                        SourceLoc loc)
diff --git a/lib/Sema/CSStep.cpp b/lib/Sema/CSStep.cpp
@@ -663,12 +663,12 @@ bool IsDeclRefinementOfRequest::evaluate(Evaluator &evaluator,
   if (!substTypeB)
     return false;
 
-  auto result = TypeChecker::checkGenericArguments(
+  auto result = checkRequirements(
       declA->getDeclContext()->getParentModule(),
       genericSignatureB.getRequirements(),
       QueryTypeSubstitutionMap{ substMap });
 
-  if (result != CheckGenericArgumentsResult::Success)
+  if (result != CheckRequirementsResult::Success)
     return false;
 
   return substTypeA->isEqual(substTypeB);
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -740,14 +740,14 @@ createDesignatedInitOverride(ClassDecl *classDecl,
     // requirements on the base class's own generic parameters that are not
     // satisfied by the derived class. In this case, we don't want to inherit
     // this initializer; there's no way to call it on the derived class.
-    auto checkResult = TypeChecker::checkGenericArguments(
+    auto checkResult = checkRequirements(
         classDecl->getParentModule(),
         superclassCtorSig.getRequirements(),
         [&](Type type) -> Type {
           auto substType = type.subst(subMap);
           return GenericEnvironment::mapTypeIntoContext(genericEnv, substType);
         });
-    if (checkResult != CheckGenericArgumentsResult::Success)
+    if (checkResult != CheckRequirementsResult::Success)
       return nullptr;
   }
 
diff --git a/lib/Sema/IDETypeCheckingRequests.cpp b/lib/Sema/IDETypeCheckingRequests.cpp
@@ -134,10 +134,10 @@ static bool isExtensionAppliedInternal(const DeclContext *DC, Type BaseTy,
   auto *module = DC->getParentModule();
   SubstitutionMap substMap = BaseTy->getContextSubstitutionMap(
       module, ED->getExtendedNominal());
-  return TypeChecker::checkGenericArguments(module,
-                                            genericSig.getRequirements(),
-                                            QuerySubstitutionMap{substMap}) ==
-         CheckGenericArgumentsResult::Success;
+  return checkRequirements(module,
+                           genericSig.getRequirements(),
+                           QuerySubstitutionMap{substMap}) ==
+         CheckRequirementsResult::Success;
 }
 
 static bool isMemberDeclAppliedInternal(const DeclContext *DC, Type BaseTy,
@@ -171,10 +171,10 @@ static bool isMemberDeclAppliedInternal(const DeclContext *DC, Type BaseTy,
 
   // Note: we treat substitution failure as success, to avoid tripping
   // up over generic parameters introduced by the declaration itself.
-  return TypeChecker::checkGenericArguments(module,
-                                            genericSig.getRequirements(),
-                                            QuerySubstitutionMap{substMap}) !=
-         CheckGenericArgumentsResult::RequirementFailure;
+  return checkRequirements(module,
+                           genericSig.getRequirements(),
+                           QuerySubstitutionMap{substMap}) !=
+         CheckRequirementsResult::RequirementFailure;
 }
 
 bool
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -3739,8 +3739,7 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
                                               nominalTypeDecl);
     QuerySubstitutionMap getSubstitution{baseMap};
 
-    // Use invalid 'SourceLoc's to suppress diagnostics.
-    auto result = TypeChecker::checkGenericArguments(
+    auto result = checkRequirements(
           module, genericSignature.getRequirements(),
           [&](SubstitutableType *type) -> Type {
             if (type->isEqual(genericParamType))
@@ -3749,7 +3748,7 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
             return getSubstitution(type);
           });
 
-    if (result != CheckGenericArgumentsResult::Success) {
+    if (result != CheckRequirementsResult::Success) {
       unviable.push_back(
           std::make_tuple(init, UnviableReason::UnsatisfiedRequirements,
                           genericParamType));
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -1064,70 +1064,6 @@ CheckGenericArgumentsResult TypeChecker::checkGenericArgumentsForDiagnostics(
   return CheckGenericArgumentsResult::createSuccess();
 }
 
-CheckGenericArgumentsResult::Kind TypeChecker::checkGenericArguments(
-    ModuleDecl *module, ArrayRef<Requirement> requirements,
-    TypeSubstitutionFn substitutions, SubstOptions options) {
-  SmallVector<Requirement, 4> worklist;
-
-  bool hadSubstFailure = false;
-
-  for (auto req : requirements) {
-    worklist.push_back(req.subst(substitutions,
-                              LookUpConformanceInModule(module), options));
-  }
-
-  while (!worklist.empty()) {
-    auto req = worklist.pop_back_val();
-    switch (req.checkRequirement(worklist, /*allowMissing=*/true)) {
-    case CheckRequirementResult::Success:
-    case CheckRequirementResult::ConditionalConformance:
-    case CheckRequirementResult::PackRequirement:
-      break;
-
-    case CheckRequirementResult::RequirementFailure:
-      return CheckGenericArgumentsResult::RequirementFailure;
-
-    case CheckRequirementResult::SubstitutionFailure:
-      hadSubstFailure = true;
-      break;
-    }
-  }
-
-  if (hadSubstFailure)
-    return CheckGenericArgumentsResult::SubstitutionFailure;
-
-  return CheckGenericArgumentsResult::Success;
-}
-
-CheckGenericArgumentsResult::Kind TypeChecker::checkGenericArguments(
-    ArrayRef<Requirement> requirements) {
-  SmallVector<Requirement, 4> worklist(requirements.begin(), requirements.end());
-
-  bool hadSubstFailure = false;
-
-  while (!worklist.empty()) {
-    auto req = worklist.pop_back_val();
-    switch (req.checkRequirement(worklist, /*allowMissing=*/true)) {
-    case CheckRequirementResult::Success:
-    case CheckRequirementResult::ConditionalConformance:
-    case CheckRequirementResult::PackRequirement:
-      break;
-
-    case CheckRequirementResult::RequirementFailure:
-      return CheckGenericArgumentsResult::RequirementFailure;
-
-    case CheckRequirementResult::SubstitutionFailure:
-      hadSubstFailure = true;
-      break;
-    }
-  }
-
-  if (hadSubstFailure)
-    return CheckGenericArgumentsResult::SubstitutionFailure;
-
-  return CheckGenericArgumentsResult::Success;
-}
-
 Requirement
 RequirementRequest::evaluate(Evaluator &evaluator,
                              WhereClauseOwner owner,
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -5138,21 +5138,21 @@ void ConformanceChecker::ensureRequirementsAreSatisfied() {
 
   const auto result = TypeChecker::checkGenericArgumentsForDiagnostics(
       module, reqSig, QuerySubstitutionMap{substitutions});
-  switch (result) {
-  case CheckGenericArgumentsResult::Success:
+  switch (result.getKind()) {
+  case CheckRequirementsResult::Success:
     // Go on to check exportability.
     break;
 
-  case CheckGenericArgumentsResult::RequirementFailure:
-  case CheckGenericArgumentsResult::SubstitutionFailure:
+  case CheckRequirementsResult::RequirementFailure:
+  case CheckRequirementsResult::SubstitutionFailure:
     // Diagnose the failure generically.
     // FIXME: Would be nice to give some more context here!
     if (!Conformance->isInvalid()) {
       diags.diagnose(Loc, diag::type_does_not_conform,
                      Adoptee,
                      Proto->getDeclaredInterfaceType());
 
-      if (result == CheckGenericArgumentsResult::RequirementFailure) {
+      if (result.getKind() == CheckRequirementsResult::RequirementFailure) {
         TypeChecker::diagnoseRequirementFailure(
             result.getRequirementFailureInfo(), Loc, Loc,
             proto->getDeclaredInterfaceType(),
@@ -5795,27 +5795,21 @@ ProtocolConformanceRef
 TypeChecker::conformsToProtocol(Type T, ProtocolDecl *Proto, ModuleDecl *M,
                                 bool allowMissing) {
   // Look up conformance in the module.
-  auto lookupResult = M->lookupConformance(
-      T, Proto, allowMissing);
-
+  auto lookupResult = M->lookupConformance(T, Proto, allowMissing);
   if (lookupResult.isInvalid()) {
     return ProtocolConformanceRef::forInvalid();
   }
 
-  auto condReqs = lookupResult.getConditionalRequirementsIfAvailable();
-  assert(condReqs &&
-         "unhandled recursion: missing conditional requirements when they're "
-         "required");
+  auto condReqs = lookupResult.getConditionalRequirements();
 
   // If we have a conditional requirements that we need to check, do so now.
-  if (!condReqs->empty()) {
-    auto conditionalCheckResult = checkGenericArguments(*condReqs);
-    switch (conditionalCheckResult) {
-    case CheckGenericArgumentsResult::Success:
+  if (!condReqs.empty()) {
+    switch (checkRequirements(condReqs)) {
+    case CheckRequirementsResult::Success:
       break;
 
-    case CheckGenericArgumentsResult::RequirementFailure:
-    case CheckGenericArgumentsResult::SubstitutionFailure:
+    case CheckRequirementsResult::RequirementFailure:
+    case CheckRequirementsResult::SubstitutionFailure:
       return ProtocolConformanceRef::forInvalid();
     }
   }
diff --git a/lib/Sema/TypeCheckProtocolInference.cpp b/lib/Sema/TypeCheckProtocolInference.cpp
@@ -1353,17 +1353,17 @@ bool AssociatedTypeInference::checkCurrentTypeWitnesses(
   sanitizeProtocolRequirements(proto, requirements,
                                sanitizedRequirements);
 
-  switch (TypeChecker::checkGenericArguments(
+  switch (checkRequirements(
       dc->getParentModule(), sanitizedRequirements,
       QuerySubstitutionMap{substitutions}, options)) {
-  case CheckGenericArgumentsResult::RequirementFailure:
+  case CheckRequirementsResult::RequirementFailure:
     ++NumSolutionStatesFailedCheck;
     LLVM_DEBUG(llvm::dbgs() << std::string(valueWitnesses.size(), '+')
                << "+ Requirement failure\n";);
     return true;
 
-  case CheckGenericArgumentsResult::Success:
-  case CheckGenericArgumentsResult::SubstitutionFailure:
+  case CheckRequirementsResult::Success:
+  case CheckRequirementsResult::SubstitutionFailure:
     break;
   }
 
@@ -1401,14 +1401,14 @@ bool AssociatedTypeInference::checkConstrainedExtension(ExtensionDecl *ext) {
   auto subs = typeInContext->getContextSubstitutions(ext);
 
   SubstOptions options = getSubstOptionsWithCurrentTypeWitnesses();
-  switch (TypeChecker::checkGenericArguments(
+  switch (checkRequirements(
       dc->getParentModule(), ext->getGenericSignature().getRequirements(),
       QueryTypeSubstitutionMap{subs}, options)) {
-  case CheckGenericArgumentsResult::Success:
-  case CheckGenericArgumentsResult::SubstitutionFailure:
+  case CheckRequirementsResult::Success:
+  case CheckRequirementsResult::SubstitutionFailure:
     return false;
 
-  case CheckGenericArgumentsResult::RequirementFailure:
+  case CheckRequirementsResult::RequirementFailure:
     return true;
   }
   llvm_unreachable("unhandled result");
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -651,8 +651,8 @@ bool TypeChecker::checkContextualRequirements(GenericTypeDecl *decl,
 
   const auto result = TypeChecker::checkGenericArgumentsForDiagnostics(
       module, genericSig.getRequirements(), substitutions);
-  switch (result) {
-  case CheckGenericArgumentsResult::RequirementFailure:
+  switch (result.getKind()) {
+  case CheckRequirementsResult::RequirementFailure:
     if (loc.isValid()) {
       TypeChecker::diagnoseRequirementFailure(
           result.getRequirementFailureInfo(), loc, noteLoc,
@@ -661,9 +661,9 @@ bool TypeChecker::checkContextualRequirements(GenericTypeDecl *decl,
     }
 
     return false;
-  case CheckGenericArgumentsResult::SubstitutionFailure:
+  case CheckRequirementsResult::SubstitutionFailure:
     return false;
-  case CheckGenericArgumentsResult::Success:
+  case CheckRequirementsResult::Success:
     return true;
   }
   llvm_unreachable("invalid requirement check type");
@@ -1158,8 +1158,8 @@ Type TypeResolution::applyUnboundGenericArguments(
 
     const auto result = TypeChecker::checkGenericArgumentsForDiagnostics(
         module, genericSig.getRequirements(), substitutions);
-    switch (result) {
-    case CheckGenericArgumentsResult::RequirementFailure:
+    switch (result.getKind()) {
+    case CheckRequirementsResult::RequirementFailure:
       if (loc.isValid()) {
         TypeChecker::diagnoseRequirementFailure(
             result.getRequirementFailureInfo(), loc, noteLoc,
@@ -1168,9 +1168,9 @@ Type TypeResolution::applyUnboundGenericArguments(
       }
 
       LLVM_FALLTHROUGH;
-    case CheckGenericArgumentsResult::SubstitutionFailure:
+    case CheckRequirementsResult::SubstitutionFailure:
       return ErrorType::get(getASTContext());
-    case CheckGenericArgumentsResult::Success:
+    case CheckRequirementsResult::Success:
       break;
     }
   }
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
