AST: Move guts of checkGenericArguments() to a new Requirement::isSatisfied() method

Author: slavapestov

include/swift/AST/Requirement.h

@@ -76,6 +76,21 @@ class Requirement
 
   ProtocolDecl *getProtocolDecl() const;
 
+  /// 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
+  /// requirement is completely satisfied.
+  bool isSatisfied(ArrayRef<Requirement> &conditionalRequirements) const;
+
+  /// Determines if this substituted requirement can ever be satisfied,
+  /// possibly with additional substitutions.
+  ///
+  /// For example, if 'T' is unconstrained, then a superclass requirement
+  /// 'T : C' can be satisfied; however, if 'T' already has an unrelated
+  /// superclass requirement, 'T : C' cannot be satisfied.
+  bool canBeSatisfied() const;
+
   SWIFT_DEBUG_DUMP;
   void dump(raw_ostream &out) const;
   void print(raw_ostream &os, const PrintOptions &opts) const;

lib/AST/GenericSignature.cpp

@@ -722,3 +722,67 @@ ProtocolDecl *Requirement::getProtocolDecl() const {
   assert(getKind() == RequirementKind::Conformance);
   return getSecondType()->castTo<ProtocolType>()->getDecl();
 }
+
+bool
+Requirement::isSatisfied(ArrayRef<Requirement> &conditionalRequirements) const {
+  switch (getKind()) {
+  case RequirementKind::Conformance: {
+    auto *proto = getProtocolDecl();
+    auto *module = proto->getParentModule();
+    auto conformance = module->lookupConformance(getFirstType(), proto);
+    if (!conformance)
+      return false;
+
+    conditionalRequirements = conformance.getConditionalRequirements();
+    return true;
+  }
+
+  case RequirementKind::Layout: {
+    if (auto *archetypeType = getFirstType()->getAs<ArchetypeType>()) {
+      auto layout = archetypeType->getLayoutConstraint();
+      return (layout && layout.merge(getLayoutConstraint()));
+    }
+
+    if (getLayoutConstraint()->isClass())
+      return getFirstType()->satisfiesClassConstraint();
+
+    // TODO: Statically check other layout constraints, once they can
+    // be spelled in Swift.
+    return true;
+  }
+
+  case RequirementKind::Superclass:
+    return getSecondType()->isExactSuperclassOf(getFirstType());
+
+  case RequirementKind::SameType:
+    return getFirstType()->isEqual(getSecondType());
+  }
+
+  llvm_unreachable("Bad requirement kind");
+}
+
+bool Requirement::canBeSatisfied() const {
+  switch (getKind()) {
+  case RequirementKind::Conformance:
+    return getFirstType()->is<ArchetypeType>();
+
+  case RequirementKind::Layout: {
+    if (auto *archetypeType = getFirstType()->getAs<ArchetypeType>()) {
+      auto layout = archetypeType->getLayoutConstraint();
+      return (!layout || layout.merge(getLayoutConstraint()));
+    }
+
+    return false;
+  }
+
+  case RequirementKind::Superclass:
+    return (getFirstType()->isBindableTo(getSecondType()) ||
+            getSecondType()->isBindableTo(getFirstType()));
+
+  case RequirementKind::SameType:
+    return (getFirstType()->isBindableTo(getSecondType()) ||
+            getSecondType()->isBindableTo(getFirstType()));
+  }
+
+  llvm_unreachable("Bad requirement kind");
+}

lib/Sema/TypeCheckGeneric.cpp

@@ -791,47 +791,17 @@ RequirementCheckResult TypeChecker::checkGenericArguments(
         req = *substed;
       }
 
-      auto checkRequirement = [&]() {
-        switch (req.getKind()) {
-        case RequirementKind::Conformance: {
-          // Protocol conformance requirements.
-          auto proto = req.getProtocolDecl();
-          auto conformance = module->lookupConformance(
-              req.getFirstType(), proto);
-
-          if (!conformance)
-            return false;
-
-          auto conditionalReqs = conformance.getConditionalRequirements();
-          if (!conditionalReqs.empty()) {
-            auto history = current.Parents;
-            history.push_back({req.getFirstType(), proto});
-            pendingReqs.push_back({conditionalReqs, std::move(history)});
-          }
-
-          return true;
-        }
-
-        case RequirementKind::Layout: {
-          // TODO: Statically check other layout constraints, once they can
-          // be spelled in Swift.
-          if (req.getLayoutConstraint()->isClass() &&
-              !req.getFirstType()->satisfiesClassConstraint())
-            return false;
-
-          return true;
-        }
-
-        case RequirementKind::Superclass:
-          return req.getSecondType()->isExactSuperclassOf(req.getFirstType());
-
-        case RequirementKind::SameType:
-          return req.getFirstType()->isEqual(req.getSecondType());
+      ArrayRef<Requirement> conditionalRequirements;
+      if (req.isSatisfied(conditionalRequirements)) {
+        if (!conditionalRequirements.empty()) {
+          assert(req.getKind() == RequirementKind::Conformance);
+
+          auto history = current.Parents;
+          history.push_back({req.getFirstType(), req.getProtocolDecl()});
+          pendingReqs.push_back({conditionalRequirements, std::move(history)});
         }
-      };
-
-      if (checkRequirement())
         continue;
+      }
 
       if (loc.isValid()) {
         Diag<Type, Type, Type> diagnostic;