[DNM][requires-evolution] Explicit varargs expansion expression

include/swift/AST/DiagnosticsParse.def

@@ -1228,6 +1228,9 @@ ERROR(expected_type_after_is,none,
       "expected type after 'is'", ())
 ERROR(expected_type_after_as,none,
       "expected type after 'as'", ())
+ERROR(invalid_ellipsis_after_as_type,none,
+      "coercion to variadic arguments using '%0' is not allowed; did you mean"
+      " to use 'as'?", (StringRef))
 
 // Extra tokens in string interpolation like in " >> \( $0 } ) << "
 ERROR(string_interpolation_extra,none,

include/swift/AST/DiagnosticsSema.def

@@ -356,6 +356,23 @@ ERROR(cannot_convert_default_arg_value_nil,none,
 ERROR(cannot_convert_argument_value,none,
       "cannot convert value of type %0 to expected argument type %1",
       (Type,Type))
+
+ERROR(cannot_convert_array_to_variadic,none,
+      "cannot pass an array of type %0 as variadic arguments of type %1",
+      (Type,Type))
+ERROR(vararg_expansion_must_appear_alone,none,
+      "array elements coerced to variadic arguments cannot be used alongside "
+      "additional variadic arguments",
+      ())
+ERROR(array_to_vararg_coercion_outside_arg_position,none,
+      "coercion to variadic arguments is only allowed in an argument position",
+      ())
+
+NOTE(suggest_pass_elements_directly,none,
+     "remove brackets to pass array elements directly", ())
+NOTE(suggest_pass_elements_using_vararg_expansion,none,
+     "use 'as' to pass array elements as variadic arguments", ())
+
 ERROR(cannot_convert_argument_value_generic,none,
       "cannot convert value of type %0 (%1) to expected argument type %2 (%3)",
       (Type, StringRef, Type, StringRef))

include/swift/AST/Expr.h

@@ -61,6 +61,7 @@ namespace swift {
   class EnumElementDecl;
   class CallExpr;
   class KeyPathExpr;
+  class CoerceExpr;
 
 enum class ExprKind : uint8_t {
 #define EXPR(Id, Parent) Id,
@@ -3342,14 +3343,19 @@ class InOutExpr : public Expr {
   }
 };
 
-/// The not-yet-actually-surfaced '...' varargs expansion operator,
-/// which splices an array into a sequence of variadic arguments.
+/// The  varargs expansion operator, which expands an array into a sequence of
+/// variadic arguments. Is written in source as part of a coercion operation,
+/// e.g. 'as T...'
 class VarargExpansionExpr : public Expr {
   Expr *SubExpr;
 
 public:
   VarargExpansionExpr(Expr *subExpr, bool implicit, Type type = Type())
-    : Expr(ExprKind::VarargExpansion, implicit, type), SubExpr(subExpr) {}
+      : Expr(ExprKind::VarargExpansion, implicit, type), SubExpr(subExpr) {
+    assert(implicit ||
+           isa<CoerceExpr>(subExpr) &&
+               "SubExpr of explicit VarargExpansionExpr must be a CoerceExpr");
+  }
 
   SWIFT_FORWARD_SOURCE_LOCS_TO(SubExpr)
 
@@ -4414,15 +4420,17 @@ class CoerceExpr : public ExplicitCastExpr {
   /// we use it to store `start` of the initializer
   /// call source range to save some storage.
   SourceLoc InitRangeEnd;
+  bool IncludesVarargExpansion;
 
 public:
-  CoerceExpr(Expr *sub, SourceLoc asLoc, TypeLoc type)
-    : ExplicitCastExpr(ExprKind::Coerce, sub, asLoc, type, type.getType())
-  { }
+  CoerceExpr(Expr *sub, SourceLoc asLoc, TypeLoc type,
+             bool includesVarargExpansion = false)
+      : ExplicitCastExpr(ExprKind::Coerce, sub, asLoc, type, type.getType()),
+        IncludesVarargExpansion(includesVarargExpansion) {}
 
-  CoerceExpr(SourceLoc asLoc, TypeLoc type)
-    : CoerceExpr(nullptr, asLoc, type)
-  { }
+  CoerceExpr(SourceLoc asLoc, TypeLoc type,
+             bool includesVarargExpansion = false)
+      : CoerceExpr(nullptr, asLoc, type, includesVarargExpansion) {}
 
 private:
   CoerceExpr(SourceRange initRange, Expr *literal, TypeLoc type)
@@ -4441,6 +4449,8 @@ class CoerceExpr : public ExplicitCastExpr {
 
   bool isLiteralInit() const { return InitRangeEnd.isValid(); }
 
+  bool includesVarargExpansion() const { return IncludesVarargExpansion; }
+
   SourceRange getSourceRange() const {
     return isLiteralInit()
             ? SourceRange(getAsLoc(), InitRangeEnd)

lib/Parse/ParseExpr.cpp

@@ -88,7 +88,7 @@ ParserResult<Expr> Parser::parseExprIs() {
 
 /// parseExprAs
 ///   expr-as:
-///     'as' type
+///     'as' type '...'?
 ///     'as?' type
 ///     'as!' type
 ParserResult<Expr> Parser::parseExprAs() {
@@ -111,16 +111,38 @@ ParserResult<Expr> Parser::parseExprAs() {
   if (type.isNull())
     return nullptr;
 
+  bool includesVarargExpansion = false;
+  SourceLoc ellipsisLoc;
+  auto typeRepr = type.get();
+  if (Tok.is(tok::oper_postfix) && Tok.isEllipsis()) {
+    ellipsisLoc = consumeToken();
+    includesVarargExpansion = true;
+    typeRepr =
+        new (Context) ArrayTypeRepr(typeRepr, typeRepr->getSourceRange());
+  }
+  ParserStatus status;
   Expr *parsed;
   if (questionLoc.isValid()) {
-    parsed = new (Context) ConditionalCheckedCastExpr(asLoc, questionLoc,
-                                                      type.get());
+    if (includesVarargExpansion) {
+      diagnose(asLoc, diag::invalid_ellipsis_after_as_type, "as?")
+          .fixItRemove(questionLoc);
+      status.setIsParseError();
+    }
+    parsed =
+        new (Context) ConditionalCheckedCastExpr(asLoc, questionLoc, typeRepr);
   } else if (exclaimLoc.isValid()) {
-    parsed = new (Context) ForcedCheckedCastExpr(asLoc, exclaimLoc, type.get());
+    if (includesVarargExpansion) {
+      diagnose(asLoc, diag::invalid_ellipsis_after_as_type, "as!")
+          .fixItRemove(exclaimLoc);
+      status.setIsParseError();
+    }
+    parsed = new (Context) ForcedCheckedCastExpr(asLoc, exclaimLoc, typeRepr);
   } else {
-    parsed = new (Context) CoerceExpr(asLoc, type.get());
+    parsed = new (Context) CoerceExpr(asLoc, typeRepr, includesVarargExpansion);
   }
-  return makeParserResult(parsed);
+  return status.isError() ? makeParserErrorResult(
+                                new (Context) ErrorExpr({asLoc, ellipsisLoc}))
+                          : makeParserResult(parsed);
 }
 
 /// parseExprArrow

lib/Sema/CSApply.cpp

@@ -5318,10 +5318,11 @@ Expr *ExprRewriter::coerceCallArguments(
   auto params = funcType->getParams();
 
   // Local function to produce a locator to refer to the given parameter.
-  auto getArgLocator = [&](unsigned argIdx, unsigned paramIdx)
-                         -> ConstraintLocatorBuilder {
+  auto getArgLocator =
+      [&](unsigned argIdx, unsigned paramIdx,
+          ParameterTypeFlags flags) -> ConstraintLocatorBuilder {
     return locator.withPathElement(
-             LocatorPathElt::getApplyArgToParam(argIdx, paramIdx));
+        LocatorPathElt::getApplyArgToParam(argIdx, paramIdx, flags));
   };
 
   bool matchCanFail =
@@ -5421,20 +5422,39 @@ Expr *ExprRewriter::coerceCallArguments(
       else
         newLabelLocs.push_back(SourceLoc());
 
+      bool isVarargExpansion = false;
       // Convert the arguments.
       for (auto argIdx : varargIndices) {
         auto arg = getArg(argIdx);
         auto argType = cs.getType(arg);
 
+        if (isa<VarargExpansionExpr>(arg) && varargIndices.size() > 1) {
+          tc.diagnose(arg->getLoc(), diag::vararg_expansion_must_appear_alone);
+          return nullptr;
+        } else if (isa<VarargExpansionExpr>(arg)) {
+          isVarargExpansion = true;
+        }
+
+        auto paramType =
+            isVarargExpansion ? param.getParameterType() : param.getPlainType();
+
         // If the argument type exactly matches, this just works.
-        if (argType->isEqual(param.getPlainType())) {
+        if (argType->isEqual(paramType)) {
           variadicArgs.push_back(arg);
           continue;
         }
 
         // Convert the argument.
-        auto convertedArg = coerceToType(arg, param.getPlainType(),
-                                         getArgLocator(argIdx, paramIdx));
+        Expr *convertedArg;
+        auto argLocator = getArgLocator(argIdx, paramIdx,
+                                        param.getParameterFlags());
+        if (isVarargExpansion) {
+          convertedArg = buildCollectionUpcastExpr(arg, paramType, false,
+                                                   argLocator);
+        } else {
+          convertedArg = coerceToType(arg, paramType, argLocator);
+        }
+
         if (!convertedArg)
           return nullptr;
 
@@ -5448,21 +5468,22 @@ Expr *ExprRewriter::coerceCallArguments(
         end = variadicArgs.back()->getEndLoc();
       }
 
-      // Collect them into an ArrayExpr.
-      auto *arrayExpr = ArrayExpr::create(tc.Context,
-                                          start,
-                                          variadicArgs,
-                                          {}, end,
-                                          param.getParameterType());
-      arrayExpr->setImplicit();
-      cs.cacheType(arrayExpr);
+      Expr *varargExpansionExpr;
+      if (variadicArgs.empty() || !isVarargExpansion) {
+        // Collect them into an ArrayExpr.
+        auto *arrayExpr = ArrayExpr::create(tc.Context, start, variadicArgs, {},
+                                            end, param.getParameterType());
+        arrayExpr->setImplicit();
+        cs.cacheType(arrayExpr);
 
-      // Wrap the ArrayExpr in a VarargExpansionExpr.
-      auto *varargExpansionExpr =
-        new (tc.Context) VarargExpansionExpr(arrayExpr,
-                                             /*implicit=*/true,
-                                             arrayExpr->getType());
-      cs.cacheType(varargExpansionExpr);
+        // Wrap the ArrayExpr in a VarargExpansionExpr.
+        varargExpansionExpr = new (tc.Context)
+            VarargExpansionExpr(arrayExpr,
+                                /*implicit=*/true, arrayExpr->getType());
+        cs.cacheType(varargExpansionExpr);
+      } else {
+        varargExpansionExpr = variadicArgs.front();
+      }
 
       newArgs.push_back(varargExpansionExpr);
       newParams.push_back(param);
@@ -5554,8 +5575,9 @@ Expr *ExprRewriter::coerceCallArguments(
       convertedArg = cs.TC.buildAutoClosureExpr(dc, arg, closureType);
       cs.cacheExprTypes(convertedArg);
     } else {
-      convertedArg =
-          coerceToType(arg, paramType, getArgLocator(argIdx, paramIdx));
+      convertedArg = coerceToType(
+          arg, paramType,
+          getArgLocator(argIdx, paramIdx, param.getParameterFlags()));
     }
 
     if (!convertedArg)

lib/Sema/CSDiag.cpp

@@ -2760,7 +2760,10 @@ typeCheckArgumentChildIndependently(Expr *argExpr, Type argType,
 
     resultElts.push_back(elExpr);
     auto resFlags =
-        ParameterTypeFlags().withInOut(elExpr->isSemanticallyInOutExpr());
+        ParameterTypeFlags()
+            .withInOut(elExpr->isSemanticallyInOutExpr())
+            .withVariadic(elExpr->getSemanticsProvidingExpr()->getKind() ==
+                          ExprKind::VarargExpansion);
     resultEltTys.push_back({CS.getType(elExpr)->getInOutObjectType(),
                             TE->getElementName(i), resFlags});
   }

lib/Sema/CSDiagnostics.cpp

@@ -813,10 +813,19 @@ bool MissingForcedDowncastFailure::diagnoseAsError() {
   case CheckedCastKind::DictionaryDowncast:
   case CheckedCastKind::SetDowncast:
   case CheckedCastKind::ValueCast:
-    emitDiagnostic(coerceExpr->getLoc(), diag::missing_forced_downcast,
-                   fromType, toType)
-        .highlight(coerceExpr->getSourceRange())
-        .fixItReplace(coerceExpr->getLoc(), "as!");
+    auto diag = emitDiagnostic(coerceExpr->getLoc(),
+                               diag::missing_forced_downcast, fromType, toType);
+    diag.highlight(coerceExpr->getSourceRange());
+    if (coerceExpr->includesVarargExpansion()) {
+      diag.fixItInsert(coerceExpr->getStartLoc(), "(");
+      llvm::SmallString<32> insertAfter;
+      insertAfter += " as! ";
+      insertAfter += toType->getWithoutParens()->getString();
+      insertAfter += ")";
+      diag.fixItInsertAfter(subExpr->getEndLoc(), insertAfter);
+    } else {
+      diag.fixItReplace(coerceExpr->getLoc(), "as!");
+    }
     return true;
   }
   llvm_unreachable("unhandled cast kind");
@@ -3493,3 +3502,48 @@ bool MutatingMemberRefOnImmutableBase::diagnoseAsError() {
                             diagIDmember);
   return failure.diagnoseAsError();
 }
+
+bool ExpandArrayIntoVarargsFailure::diagnoseAsError() {
+  if (auto anchor = getAnchor()) {
+    emitDiagnostic(anchor->getLoc(), diag::cannot_convert_array_to_variadic,
+                   getFromType(), getToType());
+
+    // Offer to pass the array elements using 'as T...'
+    auto *DC = getDC();
+    auto &TC = getTypeChecker();
+    auto asPG = getTypeChecker().lookupPrecedenceGroup(
+        DC, DC->getASTContext().Id_CastingPrecedence, SourceLoc());
+    // Parens are never needed on the outside because 'as T...' is only allowed
+    // as an argument
+    bool needsParensInside =
+        !asPG || exprNeedsParensInsideFollowingOperator(TC, DC, anchor, asPG);
+
+    llvm::SmallString<2> insertBefore;
+    llvm::SmallString<32> insertAfter;
+    if (needsParensInside) {
+      insertBefore += "(";
+      insertAfter += ")";
+    }
+    insertAfter += " as ";
+    insertAfter += getToType()->getWithoutParens()->getString();
+    insertAfter += "...";
+    emitDiagnostic(anchor->getLoc(),
+                   diag::suggest_pass_elements_using_vararg_expansion)
+        .fixItInsert(anchor->getStartLoc(), insertBefore)
+        .fixItInsertAfter(anchor->getEndLoc(), insertAfter);
+
+    // If this is an array literal, offer to remove the brackets and pass the
+    // elements directly as variadic arguments.
+    if (auto *arrayExpr = dyn_cast<ArrayExpr>(anchor)) {
+      auto diag = emitDiagnostic(arrayExpr->getLoc(),
+                                 diag::suggest_pass_elements_directly);
+      diag.fixItRemove(arrayExpr->getLBracketLoc())
+          .fixItRemove(arrayExpr->getRBracketLoc());
+      // Handle the case where the array literal has a trailing comma.
+      if (arrayExpr->getNumCommas() == arrayExpr->getNumElements())
+        diag.fixItRemove(arrayExpr->getCommaLocs().back());
+    }
+    return true;
+  }
+  return false;
+}

lib/Sema/CSDiagnostics.h

@@ -1457,6 +1457,15 @@ class SkipUnhandledConstructInFunctionBuilderFailure final
   bool diagnoseAsNote() override;
 };
 
+class ExpandArrayIntoVarargsFailure final : public ContextualFailure {
+public:
+  ExpandArrayIntoVarargsFailure(Expr *root, ConstraintSystem &cs, Type lhs,
+                                Type rhs, ConstraintLocator *locator)
+      : ContextualFailure(root, cs, lhs, rhs, locator) {}
+
+  bool diagnoseAsError() override;
+};
+
 /// Provides information about the application of a function argument to a
 /// parameter.
 class FunctionArgApplyInfo {

lib/Sema/CSFix.cpp

@@ -657,3 +657,16 @@ AllowMutatingMemberOnRValueBase::create(ConstraintSystem &cs, Type baseType,
   return new (cs.getAllocator())
       AllowMutatingMemberOnRValueBase(cs, baseType, member, name, locator);
 }
+
+ExpandArrayIntoVarargs *
+ExpandArrayIntoVarargs::create(ConstraintSystem &cs, Type srcType, Type dstType,
+                               ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      ExpandArrayIntoVarargs(cs, srcType, dstType, locator);
+}
+
+bool ExpandArrayIntoVarargs::diagnose(Expr *root, bool asNote) const {
+  ExpandArrayIntoVarargsFailure failure(
+      root, getConstraintSystem(), getFromType(), getToType(), getLocator());
+  return failure.diagnose(asNote);
+}