Merge pull request #16903 from xedin/fix-constrainted-expr-typealias

[CSSolver] Make sure generic requirements are checked for typealiases

Author: xedin

include/swift/AST/Types.h

@@ -1616,15 +1616,14 @@ class NameAliasType final
     return Bits.NameAliasType.HasSubstitutionMap ? 1 : 0;
   }
 
+public:
   /// Retrieve the generic signature used for substitutions.
   GenericSignature *getGenericSignature() const {
     return getSubstitutionMap().getGenericSignature();
   }
 
-public:
   static NameAliasType *get(TypeAliasDecl *typealias, Type parent,
-                                 SubstitutionMap substitutions,
-                                 Type underlying);
+                            SubstitutionMap substitutions, Type underlying);
 
   /// \brief Returns the declaration that declares this type.
   TypeAliasDecl *getDecl() const {

lib/Sema/ConstraintSystem.cpp

@@ -486,6 +486,32 @@ Type ConstraintSystem::openUnboundGenericType(
        ConstraintLocatorBuilder locator) {
   assert(!type->hasTypeParameter());
 
+  // If this is a generic typealias defined inside of constrainted extension,
+  // let's add all of the generic requirements to the constraint system to
+  // make sure that it's something we can use.
+  if (auto *NAT = dyn_cast<NameAliasType>(type.getPointer())) {
+    auto *decl = NAT->getDecl();
+    auto *extension = dyn_cast<ExtensionDecl>(decl->getDeclContext());
+    auto parentTy = NAT->getParent();
+
+    if (parentTy && extension && extension->isConstrainedExtension()) {
+      auto subMap = NAT->getSubstitutionMap();
+      auto contextSubMap = parentTy->getContextSubstitutionMap(
+          extension->getParentModule(),
+          extension->getAsNominalTypeOrNominalTypeExtensionContext());
+
+      if (auto *signature = NAT->getGenericSignature()) {
+        openGenericRequirements(
+            extension, signature, /*skipProtocolSelfConstraint*/ true, locator,
+            [&](Type type) {
+              return type.subst(QuerySubstitutionMap{contextSubMap},
+                                LookUpConformanceInSubstitutionMap(subMap),
+                                SubstFlags::UseErrorType);
+            });
+      }
+    }
+  }
+
   if (!type->hasUnboundGenericType())
     return type;
 
@@ -1133,41 +1159,48 @@ void ConstraintSystem::openGeneric(
   bindArchetypesFromContext(*this, outerDC, locatorPtr, replacements);
 
   // Add the requirements as constraints.
-  auto requirements = sig->getRequirements();
+  openGenericRequirements(
+      outerDC, sig, skipProtocolSelfConstraint, locator,
+      [&](Type type) { return openType(type, replacements); });
+}
+
+void ConstraintSystem::openGenericRequirements(
+    DeclContext *outerDC, GenericSignature *signature,
+    bool skipProtocolSelfConstraint, ConstraintLocatorBuilder locator,
+    llvm::function_ref<Type(Type)> substFn) {
+  auto requirements = signature->getRequirements();
   for (unsigned pos = 0, n = requirements.size(); pos != n; ++pos) {
     const auto &req = requirements[pos];
 
-    Optional<Requirement> openedReq;
-    auto openedFirst = openType(req.getFirstType(), replacements);
+    auto firstType = substFn(req.getFirstType());
 
     auto kind = req.getKind();
+    auto requirementLoc =
+        locator.withPathElement(ConstraintLocator::OpenedGeneric)
+            .withPathElement(LocatorPathElt::getTypeRequirementComponent(pos));
+
     switch (kind) {
     case RequirementKind::Conformance: {
       auto proto = req.getSecondType()->castTo<ProtocolType>();
       auto protoDecl = proto->getDecl();
       // Determine whether this is the protocol 'Self' constraint we should
       // skip.
-      if (skipProtocolSelfConstraint &&
-          protoDecl == outerDC &&
+      if (skipProtocolSelfConstraint && protoDecl == outerDC &&
           protoDecl->getSelfInterfaceType()->isEqual(req.getFirstType()))
         continue;
-      openedReq = Requirement(kind, openedFirst, proto);
+      addConstraint(Requirement(kind, firstType, proto), requirementLoc);
       break;
     }
     case RequirementKind::Superclass:
     case RequirementKind::SameType:
-      openedReq = Requirement(kind, openedFirst,
-                              openType(req.getSecondType(), replacements));
+      addConstraint(Requirement(kind, firstType, substFn(req.getSecondType())),
+                    requirementLoc);
       break;
     case RequirementKind::Layout:
-      openedReq = Requirement(kind, openedFirst, req.getLayoutConstraint());
+      addConstraint(Requirement(kind, firstType, req.getLayoutConstraint()),
+                    requirementLoc);
       break;
     }
-
-    addConstraint(
-        *openedReq,
-        locator.withPathElement(ConstraintLocator::OpenedGeneric)
-            .withPathElement(LocatorPathElt::getTypeRequirementComponent(pos)));
   }
 }
 
@@ -1246,7 +1279,6 @@ ConstraintSystem::getTypeOfMemberReference(
 
     auto memberTy = TC.substMemberTypeWithBase(DC->getParentModule(),
                                                typeDecl, baseObjTy);
-
     // Open the type if it was a reference to a generic type.
     memberTy = openUnboundGenericType(memberTy, locator);
 

lib/Sema/ConstraintSystem.h

@@ -2175,6 +2175,15 @@ class ConstraintSystem {
                    ConstraintLocatorBuilder locator,
                    OpenedTypeMap &replacements);
 
+  /// Given generic signature open its generic requirements,
+  /// using substitution function, and record them in the
+  /// constraint system for further processing.
+  void openGenericRequirements(DeclContext *outerDC,
+                               GenericSignature *signature,
+                               bool skipProtocolSelfConstraint,
+                               ConstraintLocatorBuilder locator,
+                               llvm::function_ref<Type(Type)> subst);
+
   /// Record the set of opened types for the given locator.
   void recordOpenedTypes(
          ConstraintLocatorBuilder locator,

test/Constraints/rdar39931339.swift

@@ -0,0 +1,46 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol P {}
+
+struct S<T> {}
+
+class C : P {}
+
+extension S where T : P {
+  typealias A = Int
+  typealias B<U> = S<U>
+}
+
+extension S where T == Float {
+  typealias C = Int
+}
+
+class A<T, U> {}
+
+extension A where T == [U], U: P {
+  typealias S1 = Int
+}
+
+extension A where T == [U], U == Int {
+  typealias S2 = Int
+}
+
+class B<U> : A<[U], U> {}
+
+_ = B<C>.S1()          // Ok
+_ = B<Int>.S2()        // Ok
+_ = B<Float>.S1()      // expected-error {{type 'Float' does not conform to protocol 'P'}}
+_ = B<String>.S2()     // expected-error {{'B<String>.S2.Type' (aka 'Int.Type') requires the types '[String]' and '[Int]' be equivalent}}
+
+_ = S<C>.A()           // Ok
+_ = S<Int>.A()         // expected-error {{type 'Int' does not conform to protocol 'P'}}
+_ = S<String>.B<Int>() // expected-error {{type 'String' does not conform to protocol 'P'}}
+_ = S<Int>.C()         // expected-error {{'S<Int>.C.Type' (aka 'Int.Type') requires the types 'Int' and 'Float' be equivalent}}
+
+func foo<T>(_ s: S<T>.Type) {
+  _ = s.A() // expected-error {{type 'T' does not conform to protocol 'P'}}
+}
+
+func bar<T: P>(_ s: S<T>.Type) {
+  _ = s.A() // Ok
+}