AST: Generalize Requirement::isSatisfied() to Requirement::checkRequirement()

Author: slavapestov

include/swift/AST/Requirement.h

@@ -27,6 +27,24 @@
 
 namespace swift {
 
+/// Return type of Requirement::checkRequirement().
+enum class CheckRequirementResult : uint8_t {
+  /// The requirement was fully satisfied.
+  Success,
+
+  /// The subject type conforms conditionally; the sub-requirements are
+  /// conditional requirements which must be checked.
+  ConditionalConformance,
+
+  /// The requirement cannot ever be satisfied.
+  RequirementFailure,
+
+  /// Some other requirement is expected to fail, or there was an invalid
+  /// conformance and an error should be diagnosed elsewhere, so this
+  /// requirement does not need to be diagnosed.
+  SubstitutionFailure
+};
+
 /// A single requirement placed on the type parameters (or associated
 /// types thereof) of a
 class Requirement {
@@ -155,11 +173,12 @@ class Requirement {
 
   /// Determines if this substituted requirement is satisfied.
   ///
-  /// \param conditionalRequirements An out parameter initialized to an
-  /// array of requirements that the caller must check to ensure this
+  /// \param subReqs An out parameter initialized to a list of simpler
+  /// requirements which the caller must check to ensure this
   /// requirement is completely satisfied.
-  bool isSatisfied(ArrayRef<Requirement> &conditionalRequirements,
-                   bool allowMissing = false) const;
+  CheckRequirementResult checkRequirement(
+      SmallVectorImpl<Requirement> &subReqs,
+      bool allowMissing = false) const;
 
   /// Determines if this substituted requirement can ever be satisfied,
   /// possibly with additional substitutions.

lib/AST/GenericSignature.cpp

@@ -405,10 +405,19 @@ bool GenericSignatureImpl::isRequirementSatisfied(
         LookUpConformanceInSignature(this));
   }
 
-  // FIXME: Need to check conditional requirements here.
-  ArrayRef<Requirement> conditionalRequirements;
+  SmallVector<Requirement, 2> subReqs;
+  switch (requirement.checkRequirement(subReqs, allowMissing)) {
+  case CheckRequirementResult::Success:
+    return true;
+
+  case CheckRequirementResult::ConditionalConformance:
+    // FIXME: Need to check conditional requirements here.
+    return true;
 
-  return requirement.isSatisfied(conditionalRequirements, allowMissing);
+  case CheckRequirementResult::RequirementFailure:
+  case CheckRequirementResult::SubstitutionFailure:
+    return false;
+  }
 }
 
 SmallVector<Requirement, 4>

lib/AST/Requirement.cpp

@@ -76,45 +76,67 @@ ProtocolDecl *Requirement::getProtocolDecl() const {
   return getSecondType()->castTo<ProtocolType>()->getDecl();
 }
 
-bool
-Requirement::isSatisfied(ArrayRef<Requirement> &conditionalRequirements,
-                         bool allowMissing) const {
+CheckRequirementResult Requirement::checkRequirement(
+    SmallVectorImpl<Requirement> &subReqs,
+    bool allowMissing) const {
+  if (hasError())
+    return CheckRequirementResult::SubstitutionFailure;
+
   switch (getKind()) {
   case RequirementKind::Conformance: {
     auto *proto = getProtocolDecl();
     auto *module = proto->getParentModule();
     auto conformance = module->lookupConformance(
         getFirstType(), proto, allowMissing);
     if (!conformance)
-      return false;
+      return CheckRequirementResult::RequirementFailure;
 
-    conditionalRequirements = conformance.getConditionalRequirements();
-    return true;
+    auto condReqs = conformance.getConditionalRequirements();
+    if (condReqs.empty())
+      return CheckRequirementResult::Success;
+    subReqs.append(condReqs.begin(), condReqs.end());
+    return CheckRequirementResult::ConditionalConformance;
   }
 
   case RequirementKind::Layout: {
     if (auto *archetypeType = getFirstType()->getAs<ArchetypeType>()) {
       auto layout = archetypeType->getLayoutConstraint();
-      return (layout && layout.merge(getLayoutConstraint()));
+      if (layout && layout.merge(getLayoutConstraint()))
+        return CheckRequirementResult::Success;
+
+      return CheckRequirementResult::RequirementFailure;
     }
 
-    if (getLayoutConstraint()->isClass())
-      return getFirstType()->satisfiesClassConstraint();
+    if (getLayoutConstraint()->isClass()) {
+      if (getFirstType()->satisfiesClassConstraint())
+        return CheckRequirementResult::Success;
+
+      return CheckRequirementResult::RequirementFailure;
+    }
 
     // TODO: Statically check other layout constraints, once they can
     // be spelled in Swift.
-    return true;
+    return CheckRequirementResult::Success;
   }
 
   case RequirementKind::Superclass:
-    return getSecondType()->isExactSuperclassOf(getFirstType());
+    if (getSecondType()->isExactSuperclassOf(getFirstType()))
+      return CheckRequirementResult::Success;
+
+    return CheckRequirementResult::RequirementFailure;
 
   case RequirementKind::SameType:
-    return getFirstType()->isEqual(getSecondType());
+    if (getFirstType()->isEqual(getSecondType()))
+      return CheckRequirementResult::Success;
+
+    return CheckRequirementResult::RequirementFailure;
 
   case RequirementKind::SameShape:
-    return (getFirstType()->getReducedShape() ==
-            getSecondType()->getReducedShape());
+    if (getFirstType()->getReducedShape() ==
+        getSecondType()->getReducedShape())
+      return CheckRequirementResult::Success;
+
+    return CheckRequirementResult::RequirementFailure;
   }
 
   llvm_unreachable("Bad requirement kind");

lib/IDE/IDETypeChecking.cpp

@@ -344,16 +344,25 @@ struct SynthesizedExtensionAnalyzer::Implementation {
             return type;
           },
           LookUpConformanceInModule(M));
-        if (SubstReq.hasError())
+
+        SmallVector<Requirement, 2> subReqs;
+        switch (SubstReq.checkRequirement(subReqs)) {
+        case CheckRequirementResult::Success:
+          break;
+
+        case CheckRequirementResult::ConditionalConformance:
+          // FIXME: Need to handle conditional requirements here!
+          break;
+
+        case CheckRequirementResult::SubstitutionFailure:
           return true;
 
-        // FIXME: Need to handle conditional requirements here!
-        ArrayRef<Requirement> conditionalRequirements;
-        if (!SubstReq.isSatisfied(conditionalRequirements)) {
+        case CheckRequirementResult::RequirementFailure:
           if (!SubstReq.canBeSatisfied())
             return true;
 
           MergeInfo.addRequirement(Req);
+          break;
         }
       }
       return false;

lib/Sema/TypeCheckGeneric.cpp

@@ -886,66 +886,64 @@ CheckGenericArgumentsResult TypeChecker::checkGenericArgumentsForDiagnostics(
       SmallVector<ParentConditionalConformance, 2>;
 
   struct WorklistItem {
-    /// The set of requirements to check. These are either the primary set
-    /// of requirements, or the conditional requirements of the last conformance
-    /// in \c ReqsPath (if any).
-    ArrayRef<Requirement> Requirements;
+    /// The requirement to check. This is either a top-level requirement or
+    /// a conditional requirements of the last conformancein \c ReqsPath
+    /// (if any).
+    Requirement Req;
 
     /// The chain of conditional conformances that leads to the above
     /// requirement set.
-    ParentConditionalConformances ReqsPath;
+    ParentConditionalConformances Path;
 
-    WorklistItem(ArrayRef<Requirement> Requirements,
-                 ParentConditionalConformances ReqsPath)
-        : Requirements(Requirements), ReqsPath(ReqsPath) {}
+    WorklistItem(Requirement Req, ParentConditionalConformances Path)
+        : Req(Req), Path(Path) {}
   };
 
   bool hadSubstFailure = false;
   SmallVector<WorklistItem, 4> worklist;
 
-  worklist.emplace_back(requirements, ParentConditionalConformances{});
+  for (auto req : llvm::reverse(requirements))
+    worklist.emplace_back(req, ParentConditionalConformances{});
+
   while (!worklist.empty()) {
     const auto item = worklist.pop_back_val();
 
-    const bool isPrimaryReq = item.ReqsPath.empty();
-    for (const auto &req : item.Requirements) {
-      Requirement substReq = req;
-      if (isPrimaryReq) {
-        // Primary requirements do not have substitutions applied.
-        auto resolved =
-            req.subst(substitutions, LookUpConformanceInModule(module));
-        if (!resolved.hasError()) {
-          substReq = resolved;
-        } else {
-          // Another requirement might fail later; just continue.
-          hadSubstFailure = true;
-          continue;
-        }
-      }
-
-      ArrayRef<Requirement> conditionalRequirements;
-      if (!substReq.isSatisfied(conditionalRequirements,
-                                /*allowMissing=*/true)) {
-        return CheckGenericArgumentsResult::createRequirementFailure(
-            req, substReq, std::move(item.ReqsPath));
-      }
+    auto req = item.Req;
+    auto substReq = item.Req;
+    if (item.Path.empty()) {
+      // Primary requirements do not have substitutions applied.
+      substReq =
+          req.subst(substitutions, LookUpConformanceInModule(module));
+    }
 
-      if (conditionalRequirements.empty()) {
-        continue;
-      }
+    SmallVector<Requirement, 2> subReqs;
+    switch (substReq.checkRequirement(subReqs, /*allowMissing=*/true)) {
+    case CheckRequirementResult::Success:
+      break;
 
-      assert(req.getKind() == RequirementKind::Conformance);
+    case CheckRequirementResult::ConditionalConformance: {
+      assert(substReq.getKind() == RequirementKind::Conformance);
 
-      auto reqsPath = item.ReqsPath;
+      auto reqsPath = item.Path;
       reqsPath.push_back({substReq.getFirstType(), substReq.getProtocolDecl()});
 
-      worklist.emplace_back(conditionalRequirements, std::move(reqsPath));
+      for (auto subReq : subReqs)
+        worklist.emplace_back(subReq, reqsPath);
+      break;
+    }
+
+    case CheckRequirementResult::RequirementFailure:
+      return CheckGenericArgumentsResult::createRequirementFailure(
+          req, substReq, std::move(item.Path));
+
+    case CheckRequirementResult::SubstitutionFailure:
+      hadSubstFailure = true;
+      break;
     }
   }
 
-  if (hadSubstFailure) {
+  if (hadSubstFailure)
     return CheckGenericArgumentsResult::createSubstitutionFailure();
-  }
 
   return CheckGenericArgumentsResult::createSuccess();
 }
@@ -954,31 +952,34 @@ CheckGenericArgumentsResult::Kind TypeChecker::checkGenericArguments(
     ModuleDecl *module, ArrayRef<Requirement> requirements,
     TypeSubstitutionFn substitutions, SubstOptions options) {
   SmallVector<Requirement, 4> worklist;
-  bool valid = true;
+
+  bool hadSubstFailure = false;
 
   for (auto req : requirements) {
-    auto resolved = req.subst(substitutions,
-                              LookUpConformanceInModule(module), options);
-    if (!resolved.hasError()) {
-      worklist.push_back(resolved);
-    } else {
-      valid = false;
-    }
+    worklist.push_back(req.subst(substitutions,
+                              LookUpConformanceInModule(module), options));
   }
 
   while (!worklist.empty()) {
     auto req = worklist.pop_back_val();
-    ArrayRef<Requirement> conditionalRequirements;
-    if (!req.isSatisfied(conditionalRequirements, /*allowMissing=*/true))
+    switch (req.checkRequirement(worklist, /*allowMissing=*/true)) {
+    case CheckRequirementResult::Success:
+    case CheckRequirementResult::ConditionalConformance:
+      break;
+
+    case CheckRequirementResult::RequirementFailure:
       return CheckGenericArgumentsResult::RequirementFailure;
 
-    worklist.append(conditionalRequirements.begin(),
-                    conditionalRequirements.end());
+    case CheckRequirementResult::SubstitutionFailure:
+      hadSubstFailure = true;
+      break;
+    }
   }
 
-  if (valid)
-    return CheckGenericArgumentsResult::Success;
-  return CheckGenericArgumentsResult::SubstitutionFailure;
+  if (hadSubstFailure)
+    return CheckGenericArgumentsResult::SubstitutionFailure;
+
+  return CheckGenericArgumentsResult::Success;
 }
 
 Requirement