Sema: Allow one-element tuples when -enable-experimental-variadic-generics is on

Author: slavapestov

lib/Parse/ParseExpr.cpp

@@ -3181,9 +3181,16 @@ ParserResult<Expr> Parser::parseTupleOrParenExpr(tok leftTok, tok rightTok) {
                     rightLoc, SyntaxKind::TupleExprElementList);
 
   // A tuple with a single, unlabeled element is just parentheses.
-  if (elts.size() == 1 && elts[0].Label.empty()) {
-    return makeParserResult(
-        status, new (Context) ParenExpr(leftLoc, elts[0].E, rightLoc));
+  if (Context.LangOpts.hasFeature(Feature::VariadicGenerics)) {
+    if (elts.size() == 1 && elts[0].LabelLoc.isInvalid()) {
+      return makeParserResult(
+          status, new (Context) ParenExpr(leftLoc, elts[0].E, rightLoc));
+    }
+  } else {
+    if (elts.size() == 1 && elts[0].Label.empty()) {
+      return makeParserResult(
+          status, new (Context) ParenExpr(leftLoc, elts[0].E, rightLoc));
+    }
   }
 
   SmallVector<Expr *, 8> exprs;

lib/Sema/MiscDiagnostics.cpp

@@ -293,13 +293,15 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
         }
       }
 
-      // Diagnose single-element tuple expressions.
-      if (auto *tupleExpr = dyn_cast<TupleExpr>(E)) {
-        if (tupleExpr->getNumElements() == 1) {
-          Ctx.Diags.diagnose(tupleExpr->getElementNameLoc(0),
-                             diag::tuple_single_element)
-            .fixItRemoveChars(tupleExpr->getElementNameLoc(0),
-                              tupleExpr->getElement(0)->getStartLoc());
+      if (!Ctx.LangOpts.hasFeature(Feature::VariadicGenerics)) {
+        // Diagnose single-element tuple expressions.
+        if (auto *tupleExpr = dyn_cast<TupleExpr>(E)) {
+          if (tupleExpr->getNumElements() == 1) {
+            Ctx.Diags.diagnose(tupleExpr->getElementNameLoc(0),
+                               diag::tuple_single_element)
+              .fixItRemoveChars(tupleExpr->getElementNameLoc(0),
+                                tupleExpr->getElement(0)->getStartLoc());
+          }
         }
       }
 

lib/Sema/PreCheckExpr.cpp

@@ -1702,11 +1702,8 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
 
       // If the tuple element has a label, propagate it.
       elt.Type = eltTE->getTypeRepr();
-      Identifier name = TE->getElementName(EltNo);
-      if (!name.empty()) {
-        elt.Name = name;
-        elt.NameLoc = TE->getElementNameLoc(EltNo);
-      }
+      elt.Name = TE->getElementName(EltNo);
+      elt.NameLoc = TE->getElementNameLoc(EltNo);
 
       Elts.push_back(elt);
       ++EltNo;

lib/Sema/TypeCheckType.cpp

@@ -4129,29 +4129,33 @@ TypeResolver::maybeResolvePackExpansionType(PackExpansionTypeRepr *repr,
 
 NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr,
                                                      TypeResolutionOptions options) {
+  auto &ctx = getASTContext();
+
   auto pair = maybeResolvePackExpansionType(repr, options);
 
   if (pair.first->hasError())
-    return ErrorType::get(getASTContext());
+    return ErrorType::get(ctx);
 
   // We might not allow variadic expansions here at all.
   if (!options.isPackExpansionSupported()) {
     diagnose(repr->getLoc(), diag::expansion_not_allowed, pair.first);
-    return ErrorType::get(getASTContext());
+    return ErrorType::get(ctx);
   }
 
   // The pattern type must contain at least one variadic generic parameter.
   if (!pair.second) {
     diagnose(repr->getLoc(), diag::expansion_not_variadic, pair.first)
       .highlight(repr->getSourceRange());
-    return ErrorType::get(getASTContext());
+    return ErrorType::get(ctx);
   }
 
   return PackExpansionType::get(pair.first, pair.second);
 }
 
 NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
                                              TypeResolutionOptions options) {
+  auto &ctx = getASTContext();
+
   SmallVector<TupleTypeElt, 8> elements;
   elements.reserve(repr->getNumElements());
 
@@ -4188,30 +4192,33 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
   }
 
   if (hadError)
-    return ErrorType::get(getASTContext());
-
-  // Single-element labeled tuples are not permitted outside of declarations
-  // or SIL, either.
-  if (elements.size() == 1 && elements[0].hasName()
-      && !(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());
-  }
+    return ErrorType::get(ctx);
 
   // Tuples with duplicate element labels are not permitted
   if (foundDupLabel) {
     diagnose(repr->getLoc(), diag::tuple_duplicate_label);
   }
 
-  // FIXME: One-element pack expansions should retain the tuple type
-  // wrapper
-  if (elements.size() == 1 && !elements[0].hasName())
-    return ParenType::get(getASTContext(), elements[0].getType());
+  if (ctx.LangOpts.hasFeature(Feature::VariadicGenerics)) {
+    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)) {
+      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())
+      return ParenType::get(ctx, elements[0].getType());
+  }
 
-  return TupleType::get(elements, getASTContext());
+  return TupleType::get(elements, ctx);
 }
 
 NeverNullType

test/Constraints/one_element_tuple.swift

@@ -0,0 +1,10 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-variadic-generics
+
+let t1: (_: Int) = (_: 3)
+let t2: (x: Int) = (x: 3)
+
+let i1: Int = t1.0
+let i2: Int = t2.x
+
+let m1: (_: Int).Type = (_: Int).self
+let m2: (x: Int).Type = (x: Int).self

test/Constraints/type_sequence.swift

@@ -28,7 +28,7 @@ func badParameter<T>(_ : @_typeSequence T) {} // expected-error {{attribute does
 func directAliases() {
   typealias Tuple<@_typeSequence Ts> = (Ts...)
 
-  typealias Many<T, U, V, @_typeSequence Ws> = Tuple<T, U, V, Ws>
+  typealias Many<T, U, V, @_typeSequence Ws> = Tuple<T, U, V, Ws... >
 
   let _: Many<Int, String, Double, Void, Void, Void, Void> = 42 // expected-error {{cannot convert value of type 'Int' to specified type}}
 }
@@ -70,17 +70,17 @@ func invalidPacks() {
 }
 
 func call() {
-  func multipleParameters<@_typeSequence T>(xs: T..., ys: T...) -> (T...) { return xs }
+  func multipleParameters<@_typeSequence T>(xs: T..., ys: T...) -> (T...) { return (_: xs) }
   // expected-note@-1 {{in call to function 'multipleParameters(xs:ys:)'}}
   _ = multipleParameters()
   // expected-error@-1 2 {{generic parameter 'T' could not be inferred}}
-  let x: (String) = multipleParameters(xs: "", ys: "")
+  let x: (_: String) = multipleParameters(xs: "", ys: "")
   let (one, two) = multipleParameters(xs: "", 5.0, ys: "", 5.0)
   multipleParameters(xs: "", 5.0, ys: 5.0, "") // expected-error {{type of expression is ambiguous without more context}}
 
-  func multipleSequences<@_typeSequence T, @_typeSequence U>(xs: T..., ys: U...) -> (T...) { return ys }
+  func multipleSequences<@_typeSequence T, @_typeSequence U>(xs: T..., ys: U...) -> (T...) { return (_: ys) }
   // expected-note@-1 {{in call to function 'multipleSequences(xs:ys:)'}}
-  // expected-error@-2 {{cannot convert return expression of type 'U' to return type 'T'}}
+  // expected-error@-2 {{cannot convert return expression of type '(U...)' to return type '(T...)'}}
 
   _ = multipleSequences()
   // expected-error@-1 {{generic parameter 'T' could not be inferred}}