Sema: Requirement inference from generic typealias in tuple extension

Author: slavapestov

lib/AST/Decl.cpp

@@ -7865,7 +7865,13 @@ TupleType *BuiltinTupleDecl::getTupleSelfType(const ExtensionDecl *owner) const
   auto &ctx = getASTContext();
 
   // Get the generic parameter type 'each T'.
-  auto *genericParams = owner->getGenericParams();
+  GenericParamList *genericParams;
+  if (owner != nullptr) {
+    genericParams = owner->getGenericParams();
+  } else {
+    genericParams = getGenericParams();
+  }
+
   assert(genericParams != nullptr);
   assert(genericParams->getParams().size() == 1);
   assert(genericParams->getOuterParameters() == nullptr);
@@ -7887,7 +7893,7 @@ Type DeclContext::getSelfInterfaceType() const {
 
   if (auto *nominalDecl = getSelfNominalTypeDecl()) {
     if (auto *builtinTupleDecl = dyn_cast<BuiltinTupleDecl>(nominalDecl))
-      return builtinTupleDecl->getTupleSelfType(cast<ExtensionDecl>(this));
+      return builtinTupleDecl->getTupleSelfType(dyn_cast<ExtensionDecl>(this));
 
     if (isa<ProtocolDecl>(nominalDecl)) {
       auto *genericParams = nominalDecl->getGenericParams();

lib/Sema/TypeCheckDecl.cpp

@@ -2938,6 +2938,12 @@ bool TypeChecker::isPassThroughTypealias(TypeAliasDecl *typealias,
   // If neither is generic at this level, we have a pass-through typealias.
   if (!typealias->isGeneric()) return true;
 
+  if (isa<BuiltinTupleDecl>(nominal) &&
+      typealias->getUnderlyingType()->isEqual(
+        nominal->getSelfInterfaceType())) {
+    return true;
+  }
+
   auto boundGenericType = typealias->getUnderlyingType()
       ->getAs<BoundGenericType>();
   if (!boundGenericType) return false;
@@ -2995,8 +3001,9 @@ ExtendedTypeRequest::evaluate(Evaluator &eval, ExtensionDecl *ext) const {
                    : extendedNominal->getDeclaredType();
       }
 
-      if (underlyingType->is<TupleType>())
-        extendedType = underlyingType;
+      if (underlyingType->is<TupleType>()) {
+        return extendedType;
+      }
     }
   }
 

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -3496,6 +3496,27 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     checkAccessControl(EED);
   }
 
+  /// The extended type must be '(repeat each Element)' or a generic
+  /// typealias with that underlying type.
+  static bool isValidExtendedTypeForTupleExtension(ExtensionDecl *ED) {
+    auto extType = ED->getExtendedType();
+    auto selfType = ED->getSelfInterfaceType();
+
+    // The extended type must be '(repeat each Element)'.
+    if (extType->is<UnboundGenericType>()) {
+      auto *extDecl = extType->getAnyGeneric();
+      if (!extDecl->getDeclaredInterfaceType()->isEqual(selfType))
+        return false;
+    } else if (extType->is<TupleType>()) {
+      if (!extType->isEqual(selfType))
+        return false;
+    } else {
+      assert(false && "Huh?");
+    }
+
+    return true;
+  }
+
   static void checkTupleExtension(ExtensionDecl *ED) {
     auto *nominal = ED->getExtendedNominal();
     if (!nominal || !isa<BuiltinTupleDecl>(nominal))
@@ -3507,14 +3528,9 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       ED->diagnose(diag::experimental_tuple_extension);
     }
 
-    auto extType = ED->getExtendedType();
-
-    // The extended type must be '(repeat each Element)'.
-    if (extType->is<TupleType>()) {
-      auto selfType = ED->getSelfInterfaceType();
-      if (!extType->isEqual(selfType)) {
-        ED->diagnose(diag::tuple_extension_wrong_type, selfType);
-      }
+    if (!isValidExtendedTypeForTupleExtension(ED)) {
+      ED->diagnose(diag::tuple_extension_wrong_type,
+                   ED->getSelfInterfaceType());
     }
 
     // Make sure we declare conformance to exactly one protocol.
@@ -3526,6 +3542,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     auto *protocol = protocols[0];
 
+    // Validate the generic signature.
     auto genericSig = ED->getGenericSignature();
 
     // We have a single parameter pack by construction, if we

lib/Sema/TypeCheckGeneric.cpp

@@ -571,7 +571,6 @@ static void collectAdditionalExtensionRequirements(
   if (type->is<ErrorType>())
     return;
 
-  // Tuple extensions cannot introduce requirements via this mechanism.
   if (type->is<TupleType>())
     return;
 
@@ -605,6 +604,8 @@ static void collectAdditionalExtensionRequirements(
   if (!nominal) {
     type = typealias->getUnderlyingType();
     nominal = type->getNominalOrBoundGenericNominal();
+    if (!nominal && type->is<TupleType>())
+      nominal = type->getASTContext().getBuiltinTupleDecl();
   }
 
   // If we have a bound generic type, add same-type requirements for each of
@@ -773,17 +774,23 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
       }
     }
   } else if (auto *ext = dyn_cast<ExtensionDecl>(GC)) {
-    parentSig = ext->getExtendedNominal()->getGenericSignatureOfContext();
-    genericParams = nullptr;
-
     collectAdditionalExtensionRequirements(ext->getExtendedType(), sameTypeReqs);
 
+    auto *extendedNominal = ext->getExtendedNominal();
+
+    if (isa<BuiltinTupleDecl>(extendedNominal)) {
+      genericParams = ext->getGenericParams();
+    } else {
+      parentSig = extendedNominal->getGenericSignatureOfContext();
+      genericParams = nullptr;
+    }
+
     // Re-use the signature of the type being extended by default.
     // For tuple extensions, always build a new signature to get
     // the right sugared types, since we don't want to expose the
     // name of the generic parameter of BuiltinTupleDecl itself.
     if (sameTypeReqs.empty() && !ext->getTrailingWhereClause() &&
-        !isa<BuiltinTupleDecl>(ext->getExtendedNominal())) {
+        !isa<BuiltinTupleDecl>(extendedNominal)) {
       return parentSig;
     }
 

test/Generics/tuple-conformances.swift

@@ -11,6 +11,11 @@ extension () {
   // expected-error@-1 {{type 'Nested' cannot be nested in tuple extension}}
 }
 
+typealias BadTuple<each Horse> = (repeat each Horse, Int)
+extension BadTuple {}
+// expected-error@-1 {{tuple extension must be written as extension of '(repeat each Horse)'}}
+// expected-error@-2 {{tuple extension must declare conformance to exactly one protocol}}
+
 typealias Tuple<each Element> = (repeat each Element)
 
 protocol Q {}
@@ -28,8 +33,8 @@ protocol Base1 {}
 protocol Derived1: Base1 {}
 
 extension Tuple: Derived1 where repeat each Element: Derived1 {}
-// expected-error@-1 {{conditional conformance of type '(repeat each Element)' to protocol 'Derived1' does not imply conformance to inherited protocol 'Base1'}} // FIXME: crappy error
-// expected-note@-2 {{did you mean to explicitly state the conformance like 'extension (repeat each Element): Base1 where ...'?}}
+// expected-error@-1 {{conditional conformance of type '(repeat each Element)' to protocol 'Derived1' does not imply conformance to inherited protocol 'Base1'}}
+// expected-note@-2 {{did you mean to explicitly state the conformance like 'extension Tuple: Base1 where ...'?}}
 // expected-error@-3 {{tuple extension must declare conformance to exactly one protocol}}
 
 protocol Base2 {}
@@ -38,6 +43,22 @@ protocol Derived2: Base2 {}
 extension Tuple: Derived2 {}
 // expected-error@-1 {{tuple extension must declare conformance to exactly one protocol}} // FIXME: crappy error
 
+////
+
+protocol P2 {}
+
+typealias FancyTuple1<each Cat: P2> = (repeat each Cat)
+extension FancyTuple1: P2 {}
+
+protocol P3 {}
+
+typealias FancyTuple2<each Cat: C> = (repeat each Cat)
+extension FancyTuple2: P3 {}
+// expected-error@-1 {{tuple extension cannot require that 'each Cat' subclasses 'C'}}
+// expected-error@-2 {{tuple extension must require that 'each Cat' conforms to 'P3'}}
+
+////
+
 protocol P {
   associatedtype A
   associatedtype B