[NFC] Hide VarargExpansionExpr's Constructor

Author: CodaFi

include/swift/AST/Expr.h

@@ -3429,10 +3429,13 @@ class InOutExpr : public Expr {
 class VarargExpansionExpr : public Expr {
   Expr *SubExpr;
 
-public:
   VarargExpansionExpr(Expr *subExpr, bool implicit, Type type = Type())
     : Expr(ExprKind::VarargExpansion, implicit, type), SubExpr(subExpr) {}
 
+public:
+  static VarargExpansionExpr *createParamExpansion(ASTContext &ctx, Expr *E);
+  static VarargExpansionExpr *createArrayExpansion(ASTContext &ctx, ArrayExpr *AE);
+
   SWIFT_FORWARD_SOURCE_LOCS_TO(SubExpr)
 
   Expr *getSubExpr() const { return SubExpr; }
@@ -5823,6 +5826,7 @@ class PackExpr final : public Expr,
 
   static bool classof(const Expr *E) { return E->getKind() == ExprKind::Pack; }
 };
+
 inline bool Expr::isInfixOperator() const {
   return isa<BinaryExpr>(this) || isa<IfExpr>(this) ||
          isa<AssignExpr>(this) || isa<ExplicitCastExpr>(this);

lib/AST/Expr.cpp

@@ -1132,11 +1132,6 @@ VarargExpansionExpr *VarargExpansionExpr::createArrayExpansion(ASTContext &ctx,
   return new (ctx) VarargExpansionExpr(AE, /*implicit*/ true, AE->getType());
 }
 
-VarargExpansionExpr *VarargExpansionExpr::createTupleExpansion(ASTContext &ctx, TupleExpr *TE) {
-  assert(TE->getType() && "Expansion must have fully-resolved type!");
-  return new (ctx) VarargExpansionExpr(TE, /*implicit*/ true, TE->getType());
-}
-
 SequenceExpr *SequenceExpr::create(ASTContext &ctx, ArrayRef<Expr*> elements) {
   assert(elements.size() & 1 && "even number of elements in sequence");
   size_t bytes = totalSizeToAlloc<Expr *>(elements.size());

lib/Sema/CSApply.cpp

@@ -1144,9 +1144,8 @@ namespace {
             paramRef = new (context) InOutExpr(SourceLoc(), paramRef,
                                                outerParamType, /*implicit=*/true);
           } else if (innerParam->isVariadic()) {
-            paramRef = new (context) VarargExpansionExpr(paramRef,
-                                                         /*implicit=*/ true,
-                                                         outerParamType);
+            assert(outerParamType->isEqual(paramRef->getType()));
+            paramRef = VarargExpansionExpr::createParamExpansion(context, paramRef);
           }
           cs.cacheType(paramRef);
 
@@ -1317,9 +1316,8 @@ namespace {
                                     /*implicit=*/true);
           cs.cacheType(paramRef);
         } else if (param->isVariadic()) {
-          paramRef =
-            new (context) VarargExpansionExpr(paramRef, /*implicit*/ true);
-          paramRef->setType(calleeParamType);
+          assert(calleeParamType->isEqual(paramRef->getType()));
+          paramRef = VarargExpansionExpr::createParamExpansion(context, paramRef);
           cs.cacheType(paramRef);
         }
 
@@ -5717,9 +5715,8 @@ ArgumentList *ExprRewriter::coerceCallArguments(
       cs.cacheType(arrayExpr);
 
       // Wrap the ArrayExpr in a VarargExpansionExpr.
-      auto *varargExpansionExpr = new (ctx)
-          VarargExpansionExpr(arrayExpr,
-                              /*implicit=*/true, arrayExpr->getType());
+      auto *varargExpansionExpr =
+          VarargExpansionExpr::createArrayExpansion(ctx, arrayExpr);
       cs.cacheType(varargExpansionExpr);
 
       newArgs.push_back(Argument(labelLoc, paramLabel, varargExpansionExpr));

lib/Sema/CodeSynthesis.cpp

@@ -109,8 +109,8 @@ ArgumentList *swift::buildForwardingArgumentList(ArrayRef<ParamDecl *> params,
     if (param->isInOut()) {
       ref = new (ctx) InOutExpr(SourceLoc(), ref, type, /*isImplicit=*/true);
     } else if (param->isVariadic()) {
-      ref = new (ctx) VarargExpansionExpr(ref, /*implicit*/ true);
-      ref->setType(type);
+      assert(ref->getType()->isEqual(type));
+      ref = VarargExpansionExpr::createParamExpansion(ctx, ref);
     }
     args.emplace_back(SourceLoc(), param->getArgumentName(), ref);
   }