[Sema] Eliminate single-element tuples after parameter pack substitution.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -5289,6 +5289,9 @@ ERROR(dot_protocol_on_non_existential,none,
       "cannot use 'Protocol' with non-protocol type %0", (Type))
 ERROR(tuple_single_element,none,
       "cannot create a single-element tuple with an element label", ())
+ERROR(tuple_pack_element_label,none,
+      "cannot use label with pack expansion tuple element",
+      ())
 ERROR(vararg_not_allowed,none,
       "variadic parameter cannot appear outside of a function parameter list",
       ())

include/swift/AST/Types.h

@@ -2395,7 +2395,7 @@ class TupleType final : public TypeBase, public llvm::FoldingSetNode,
 
   bool containsPackExpansionType() const;
 
-  TupleType *flattenPackTypes();
+  Type flattenPackTypes();
 
 private:
   TupleType(ArrayRef<TupleTypeElt> elements, const ASTContext *CanCtx,

lib/AST/ParameterPack.cpp

@@ -158,7 +158,7 @@ bool TupleType::containsPackExpansionType() const {
 }
 
 /// (W, {X, Y}..., Z) => (W, X, Y, Z)
-TupleType *TupleType::flattenPackTypes() {
+Type TupleType::flattenPackTypes() {
   bool anyChanged = false;
   SmallVector<TupleTypeElt, 4> elts;
 
@@ -193,6 +193,15 @@ TupleType *TupleType::flattenPackTypes() {
   if (!anyChanged)
     return this;
 
+  // If pack substitution yields a single-element tuple, the tuple
+  // structure is flattened to produce the element type.
+  if (elts.size() == 1) {
+    auto type = elts.front().getType();
+    if (!type->is<PackExpansionType>() && !type->is<TypeVariableType>()) {
+      return type;
+    }
+  }
+
   return TupleType::get(elts, getASTContext());
 }
 

lib/Sema/CSSimplify.cpp

@@ -6743,22 +6743,21 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
       // If the tuple has consecutive pack expansions, packs must be
       // resolved before matching.
       auto delayMatching = [](TupleType *tuple) {
-        bool afterUnresolvedPack = false;
+        bool afterPack = false;
         for (auto element : tuple->getElements()) {
-          if (afterUnresolvedPack && !element.hasName()) {
-            return true;
-          }
-
-          if (element.getType()->is<PackExpansionType>()) {
+          if (afterPack && !element.hasName()) {
             SmallPtrSet<TypeVariableType *, 2> typeVars;
             element.getType()->getTypeVariables(typeVars);
 
-            afterUnresolvedPack = llvm::any_of(typeVars, [](auto *tv) {
+            bool hasUnresolvedPack = llvm::any_of(typeVars, [](auto *tv) {
               return tv->getImpl().canBindToPack();
             });
-          } else {
-            afterUnresolvedPack = false;
+
+            if (hasUnresolvedPack)
+              return true;
           }
+
+          afterPack = element.getType()->is<PackExpansionType>();
         }
 
         return false;

lib/Sema/ConstraintSystem.cpp

@@ -1118,6 +1118,16 @@ Type ConstraintSystem::getFixedTypeRecursive(Type type,
     return getFixedTypeRecursive(newType, flags, wantRValue);
   }
 
+  // Tuple types can lose their tuple structure under substitution
+  // when a parameter pack is substituted with one element.
+  if (auto tuple = type->getAs<TupleType>()) {
+    auto simplified = simplifyType(type);
+    if (simplified.getPointer() == type.getPointer())
+      return type;
+
+    return getFixedTypeRecursive(simplified, flags, wantRValue);
+  }
+
   if (auto typeVar = type->getAs<TypeVariableType>()) {
     if (auto fixed = getFixedType(typeVar))
       return getFixedTypeRecursive(fixed, flags, wantRValue);
@@ -3702,6 +3712,20 @@ Type ConstraintSystem::simplifyTypeImpl(Type type,
     if (auto tvt = dyn_cast<TypeVariableType>(type.getPointer()))
       return getFixedTypeFn(tvt);
 
+    if (auto tuple = dyn_cast<TupleType>(type.getPointer())) {
+      if (tuple->getNumElements() == 1) {
+        auto element = tuple->getElement(0);
+        auto elementType = simplifyTypeImpl(element.getType(), getFixedTypeFn);
+
+        // Flatten single-element tuples containing type variables that cannot
+        // bind to packs.
+        auto typeVar = elementType->getAs<TypeVariableType>();
+        if (!element.hasName() && typeVar && !typeVar->getImpl().canBindToPack()) {
+          return typeVar;
+        }
+      }
+    }
+
     // If this is a dependent member type for which we end up simplifying
     // the base to a non-type-variable, perform lookup.
     if (auto depMemTy = dyn_cast<DependentMemberType>(type.getPointer())) {

lib/Sema/TypeCheckType.cpp

@@ -4634,6 +4634,11 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
     if (eltName.empty())
       continue;
 
+    if (ty->is<PackExpansionType>()) {
+      diagnose(repr->getElementNameLoc(i), diag::tuple_pack_element_label);
+      hadError = true;
+    }
+
     if (seenEltNames.count(eltName) == 1) {
       foundDupLabel = true;
     }
@@ -4649,23 +4654,24 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
     diagnose(repr->getLoc(), diag::tuple_duplicate_label);
   }
 
-  if (options.contains(TypeResolutionFlags::SILType) ||
-      ctx.LangOpts.hasFeature(Feature::VariadicGenerics)) {
+  if (options.contains(TypeResolutionFlags::SILType)) {
     if (repr->isParenType())
       return ParenType::get(ctx, elements[0].getType());
   } else {
     // Single-element labeled tuples are not permitted outside of declarations
     // or SIL, either.
-    if (elements.size() == 1 && elements[0].hasName()
-        && !(options & TypeResolutionFlags::SILType)) {
+    if (elements.size() == 1 && elements[0].hasName() &&
+        !elements[0].getType()->is<PackExpansionType>() &&
+        !(options & TypeResolutionFlags::SILType)) {
       diagnose(repr->getElementNameLoc(0), diag::tuple_single_element)
         .fixItRemoveChars(repr->getElementNameLoc(0),
                           repr->getElementType(0)->getStartLoc());
 
       elements[0] = TupleTypeElt(elements[0].getType());
     }
 
-    if (elements.size() == 1 && !elements[0].hasName())
+    if (elements.size() == 1 && !elements[0].hasName() &&
+        !elements[0].getType()->is<PackExpansionType>())
       return ParenType::get(ctx, elements[0].getType());
   }
 

test/Constraints/one_element_tuple.swift

@@ -3,10 +3,29 @@
 // REQUIRES: asserts
 
 let t1: (_: Int) = (_: 3)
+
+// FIXME: diag::tuple_single_element should be diagnosed in the constraint system
+// instead of MiscDiagnostics, which will allow the compiler to emit that
+// error instead of bogus type mismatches for tuple expressions.
 let t2: (x: Int) = (x: 3)
+// expected-error@-1{{cannot create a single-element tuple with an element label}}
+// expected-error@-2 {{cannot convert value of type '(x: Int)' to specified type 'Int'}}
 
 let i1: Int = t1.0
+// expected-error@-1 {{value of type 'Int' has no member '0'}}
+
 let i2: Int = t2.x
+// expected-error@-1 {{value of type 'Int' has no member 'x'}}
 
 let m1: (_: Int).Type = (_: Int).self
 let m2: (x: Int).Type = (x: Int).self
+// expected-error@-1 2 {{cannot create a single-element tuple with an element label}}
+
+struct S<each T> {
+  var t: (repeat each T)
+}
+
+func packSubstitution() -> Int {
+  let s = S<Int>(t: 1)
+  return s.t
+}