Merge pull request #37440 from slavapestov/clean-up-generic-requirement-checking

Clean up duplicate logic for checking if generic requirements are satisfied

Author: slavapestov

include/swift/AST/ActorIsolation.h

@@ -25,6 +25,7 @@ class raw_ostream;
 
 namespace swift {
 class DeclContext;
+class ModuleDecl;
 class NominalTypeDecl;
 class SubstitutionMap;
 
@@ -33,7 +34,7 @@ class SubstitutionMap;
 bool areTypesEqual(Type type1, Type type2);
 
 /// Determine whether the given type is suitable as a concurrent value type.
-bool isSendableType(const DeclContext *dc, Type type);
+bool isSendableType(ModuleDecl *module, Type type);
 
 /// Describes the actor isolation of a given declaration, which determines
 /// the actors with which it can interact.

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;

include/swift/Sema/ConstraintSystem.h

@@ -5269,17 +5269,9 @@ bool hasAppliedSelf(ConstraintSystem &cs, const OverloadChoice &choice);
 bool hasAppliedSelf(const OverloadChoice &choice,
                     llvm::function_ref<Type(Type)> getFixedType);
 
-/// Check whether type conforms to a given known protocol.
-bool conformsToKnownProtocol(DeclContext *dc, Type type,
-                             KnownProtocolKind protocol);
-
-/// Check whether given type conforms to `RawPepresentable` protocol
+/// Check whether given type conforms to `RawRepresentable` protocol
 /// and return witness type.
 Type isRawRepresentable(ConstraintSystem &cs, Type type);
-/// Check whether given type conforms to a specific known kind
-/// `RawPepresentable` protocol and return witness type.
-Type isRawRepresentable(ConstraintSystem &cs, Type type,
-                        KnownProtocolKind rawRepresentableProtocol);
 
 /// Compute the type that shall stand in for dynamic 'Self' in a member
 /// reference with a base of the given object type.

lib/AST/GenericSignature.cpp

@@ -428,62 +428,28 @@ bool GenericSignatureImpl::areSameTypeParameterInContext(Type type1,
 
 bool GenericSignatureImpl::isRequirementSatisfied(
     Requirement requirement) const {
-  auto GSB = getGenericSignatureBuilder();
+  if (requirement.getFirstType()->hasTypeParameter()) {
+    auto *genericEnv = getGenericEnvironment();
 
-  auto firstType = requirement.getFirstType();
-  auto canFirstType = getCanonicalTypeInContext(firstType);
+    auto substituted = requirement.subst(
+        [&](SubstitutableType *type) -> Type {
+          if (auto *paramType = type->getAs<GenericTypeParamType>())
+            return genericEnv->mapTypeIntoContext(paramType);
 
-  switch (requirement.getKind()) {
-  case RequirementKind::Conformance: {
-    auto *protocol = requirement.getProtocolDecl();
-
-    if (canFirstType->isTypeParameter())
-      return requiresProtocol(canFirstType, protocol);
-    else
-      return (bool)GSB->lookupConformance(canFirstType, protocol);
-  }
+          return type;
+        },
+        LookUpConformanceInSignature(this));
 
-  case RequirementKind::SameType: {
-    auto canSecondType = getCanonicalTypeInContext(requirement.getSecondType());
-    return canFirstType->isEqual(canSecondType);
-  }
-
-  case RequirementKind::Superclass: {
-    auto requiredSuperclass =
-        getCanonicalTypeInContext(requirement.getSecondType());
-
-    // The requirement could be in terms of type parameters like a user-written
-    // requirement, but it could also be in terms of concrete types if it has
-    // been substituted/otherwise 'resolved', so we need to handle both.
-    auto baseType = canFirstType;
-    if (baseType->isTypeParameter()) {
-      auto directSuperclass = getSuperclassBound(baseType);
-      if (!directSuperclass)
-        return false;
-
-      baseType = getCanonicalTypeInContext(directSuperclass);
-    }
+    if (!substituted)
+      return false;
 
-    return requiredSuperclass->isExactSuperclassOf(baseType);
+    requirement = *substituted;
   }
 
-  case RequirementKind::Layout: {
-    auto requiredLayout = requirement.getLayoutConstraint();
-
-    if (canFirstType->isTypeParameter()) {
-      if (auto layout = getLayoutConstraint(canFirstType))
-        return static_cast<bool>(layout.merge(requiredLayout));
-
-      return false;
-    }
+  // FIXME: Need to check conditional requirements here.
+  ArrayRef<Requirement> conditionalRequirements;
 
-    // The requirement is on a concrete type, so it's either globally correct
-    // or globally incorrect, independent of this generic context. The latter
-    // case should be diagnosed elsewhere, so let's assume it's correct.
-    return true;
-  }
-  }
-  llvm_unreachable("unhandled kind");
+  return requirement.isSatisfied(conditionalRequirements);
 }
 
 SmallVector<Requirement, 4> GenericSignatureImpl::requirementsNotSatisfiedBy(
@@ -494,7 +460,7 @@ SmallVector<Requirement, 4> GenericSignatureImpl::requirementsNotSatisfiedBy(
   if (otherSig.getPointer() == this) return result;
 
   // If there is no other signature, no requirements are satisfied.
-  if (!otherSig){
+  if (!otherSig) {
     const auto reqs = getRequirements();
     result.append(reqs.begin(), reqs.end());
     return result;
@@ -722,3 +688,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/IDE/CodeCompletion.cpp

@@ -2539,20 +2539,21 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
     // If the reference is 'async', all types must be 'Sendable'.
     if (implicitlyAsync && T) {
+      auto *M = CurrDeclContext->getParentModule();
       if (isa<VarDecl>(VD)) {
-        if (!isSendableType(CurrDeclContext, T)) {
+        if (!isSendableType(M, T)) {
           NotRecommended = NotRecommendedReason::CrossActorReference;
         }
       } else {
         assert(isa<FuncDecl>(VD) || isa<SubscriptDecl>(VD));
         // Check if the result and the param types are all 'Sendable'.
         auto *AFT = T->castTo<AnyFunctionType>();
-        if (!isSendableType(CurrDeclContext, AFT->getResult())) {
+        if (!isSendableType(M, AFT->getResult())) {
           NotRecommended = NotRecommendedReason::CrossActorReference;
         } else {
           for (auto &param : AFT->getParams()) {
             Type paramType = param.getPlainType();
-            if (!isSendableType(CurrDeclContext, paramType)) {
+            if (!isSendableType(M, paramType)) {
               NotRecommended = NotRecommendedReason::CrossActorReference;
               break;
             }

lib/IDE/IDETypeChecking.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/Requirement.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/Types.h"
 #include "swift/Sema/IDETypeChecking.h"
@@ -169,13 +170,13 @@ struct SynthesizedExtensionAnalyzer::Implementation {
     bool Unmergable;
     unsigned InheritsCount;
     std::set<Requirement> Requirements;
-    void addRequirement(GenericSignature GenericSig,
-                        Type First, Type Second, RequirementKind Kind) {
-      CanType CanFirst = GenericSig->getCanonicalTypeInContext(First);
-      CanType CanSecond;
-      if (Second) CanSecond = GenericSig->getCanonicalTypeInContext(Second);
+    void addRequirement(GenericSignature GenericSig, swift::Requirement Req) {
+      auto First = Req.getFirstType();
+      auto CanFirst = GenericSig->getCanonicalTypeInContext(First);
+      auto Second = Req.getSecondType();
+      auto CanSecond = GenericSig->getCanonicalTypeInContext(Second);
 
-      Requirements.insert({First, Second, Kind, CanFirst, CanSecond});
+      Requirements.insert({First, Second, Req.getKind(), CanFirst, CanSecond});
     }
     bool operator== (const ExtensionMergeInfo& Another) const {
       // Trivially unmergeable.
@@ -289,84 +290,53 @@ struct SynthesizedExtensionAnalyzer::Implementation {
       ProtocolDecl *BaseProto = OwningExt->getInnermostDeclContext()
         ->getSelfProtocolDecl();
       for (auto Req : Reqs) {
-        auto Kind = Req.getKind();
-
-        // FIXME: Could do something here
-        if (Kind == RequirementKind::Layout)
+        // FIXME: Don't skip layout requirements.
+        if (Req.getKind() == RequirementKind::Layout)
           continue;
 
-        Type First = Req.getFirstType();
-        Type Second = Req.getSecondType();
-
         // Skip protocol's Self : <Protocol> requirement.
         if (BaseProto &&
             Req.getKind() == RequirementKind::Conformance &&
-            First->isEqual(BaseProto->getSelfInterfaceType()) &&
-            Second->getAnyNominal() == BaseProto)
+            Req.getFirstType()->isEqual(BaseProto->getSelfInterfaceType()) &&
+            Req.getProtocolDecl() == BaseProto)
           continue;
 
         if (!BaseType->isExistentialType()) {
           // Apply any substitutions we need to map the requirements from a
           // a protocol extension to an extension on the conforming type.
-          First = First.subst(subMap);
-          Second = Second.subst(subMap);
-
-          if (First->hasError() || Second->hasError()) {
+          auto SubstReq = Req.subst(subMap);
+          if (!SubstReq) {
             // Substitution with interface type bases can only fail
             // if a concrete type fails to conform to a protocol.
             // In this case, just give up on the extension altogether.
             return true;
           }
-        }
 
-        assert(!First->hasArchetype() && !Second->hasArchetype());
-        switch (Kind) {
-        case RequirementKind::Conformance: {
-          auto *M = DC->getParentModule();
-          auto *Proto = Second->castTo<ProtocolType>()->getDecl();
-          if (!First->isTypeParameter() &&
-              M->conformsToProtocol(First, Proto).isInvalid())
-            return true;
-          if (M->conformsToProtocol(First, Proto).isInvalid())
-            MergeInfo.addRequirement(GenericSig, First, Second, Kind);
-          break;
+          Req = *SubstReq;
         }
 
-        case RequirementKind::Superclass:
-          // If the subject type of the requirement is still a type parameter,
-          // we need to check if the contextual type could possibly be bound to
-          // the superclass. If not, this extension isn't applicable.
-          if (First->isTypeParameter()) {
-            if (!Target->mapTypeIntoContext(First)->isBindableTo(
-                    Target->mapTypeIntoContext(Second))) {
-              return true;
-            }
-            MergeInfo.addRequirement(GenericSig, First, Second, Kind);
-            break;
-          }
-
-          // If we've substituted in a concrete type for the subject, we can
-          // check for an exact superclass match, and disregard the extension if
-          // it missed.
-          // FIXME: What if it ends being something like `C<U> : C<Int>`?
-          // Arguably we should allow that to be mirrored with a U == Int
-          // constraint.
-          if (!Second->isExactSuperclassOf(First))
-            return true;
-
-          break;
-
-        case RequirementKind::SameType:
-          if (!First->isBindableTo(Second) &&
-              !Second->isBindableTo(First)) {
+        assert(!Req.getFirstType()->hasArchetype());
+        assert(!Req.getSecondType()->hasArchetype());
+
+        auto *M = DC->getParentModule();
+        auto SubstReq = Req.subst(
+          [&](Type type) -> Type {
+            if (type->isTypeParameter())
+              return Target->mapTypeIntoContext(type);
+
+            return type;
+          },
+          LookUpConformanceInModule(M));
+        if (!SubstReq)
+          return true;
+
+        // FIXME: Need to handle conditional requirements here!
+        ArrayRef<Requirement> conditionalRequirements;
+        if (!SubstReq->isSatisfied(conditionalRequirements)) {
+          if (!SubstReq->canBeSatisfied())
             return true;
-          } else if (!First->isEqual(Second)) {
-            MergeInfo.addRequirement(GenericSig, First, Second, Kind);
-          }
-          break;
 
-        case RequirementKind::Layout:
-          llvm_unreachable("Handled above");
+          MergeInfo.addRequirement(GenericSig, Req);
         }
       }
       return false;