[AST] Add CallExpr::createImplicitEmpty

Add a convenience constructor for an implicit
nullary call. This will become more useful when
the argument parameter starts taking an
ArgumentList.

Author: hamishknight

include/swift/AST/Expr.h

@@ -4721,6 +4721,14 @@ class CallExpr final : public ApplyExpr,
                   /*trailingClosures=*/{}, /*implicit=*/true, getType);
   }
 
+  /// Create a new implicit call expression with no arguments and no
+  /// source-location information.
+  ///
+  /// \param fn The nullary function being called.
+  static CallExpr *createImplicitEmpty(ASTContext &ctx, Expr *fn) {
+    return createImplicit(ctx, fn, {}, {});
+  }
+
   /// Create a new call expression.
   ///
   /// \param fn The function being called

lib/ClangImporter/ImportDecl.cpp

@@ -1278,7 +1278,7 @@ synthesizeStructDefaultConstructorBody(AbstractFunctionDecl *afd,
   FunctionType::ExtInfo info;
   zeroInitializerRef->setType(FunctionType::get({}, selfType, info));
 
-  auto call = CallExpr::createImplicit(ctx, zeroInitializerRef, {}, {});
+  auto call = CallExpr::createImplicitEmpty(ctx, zeroInitializerRef);
   call->setType(selfType);
   call->setThrows(false);
 

lib/Parse/ParseStmt.cpp

@@ -968,7 +968,7 @@ ParserResult<Stmt> Parser::parseStmtDefer() {
   auto DRE = new (Context) DeclRefExpr(tempDecl, DeclNameLoc(loc),
                                        /*Implicit*/true,
                                        AccessSemantics::DirectToStorage);
-  auto call = CallExpr::createImplicit(Context, DRE, { }, { });
+  auto call = CallExpr::createImplicitEmpty(Context, DRE);
 
   auto DS = new (Context) DeferStmt(DeferLoc, tempDecl, call);
   return makeParserResult(Status, DS);

lib/Sema/CSApply.cpp

@@ -6057,7 +6057,7 @@ Expr *ExprRewriter::coerceCallArguments(
             cs.buildAutoClosureExpr(arg, closureType, dc,
                                     isDefaultWrappedValue),
             /*isAutoClosure=*/true);
-        arg = CallExpr::createImplicit(ctx, placeholder, {}, {});
+        arg = CallExpr::createImplicitEmpty(ctx, placeholder);
         arg->setType(closureType->getResult());
         cs.cacheType(arg);
       }
@@ -8338,8 +8338,7 @@ static Expr *wrapAsyncLetInitializer(
 
   // Call the autoclosure so that the AST types line up. SILGen will ignore the
   // actual calls and translate them into a different mechanism.
-  auto autoclosureCall = CallExpr::createImplicit(
-      ctx, autoclosureExpr, { }, { });
+  auto autoclosureCall = CallExpr::createImplicitEmpty(ctx, autoclosureExpr);
   autoclosureCall->setType(initializerType);
   autoclosureCall->setThrows(throws);
 

lib/Sema/DebuggerTestingTransform.cpp

@@ -239,7 +239,7 @@ class DebuggerTestingTransform : public ASTWalker {
     Closure->setBody(ClosureBody, /*isSingleExpression=*/false);
 
     // Call the closure.
-    auto *ClosureCall = CallExpr::createImplicit(Ctx, Closure, {}, {});
+    auto *ClosureCall = CallExpr::createImplicitEmpty(Ctx, Closure);
     ClosureCall->setThrows(false);
 
     // TODO: typeCheckExpression() seems to assign types to everything here,

lib/Sema/DerivedConformanceCodable.cpp

@@ -1431,8 +1431,7 @@ deriveBodyDecodable_init(AbstractFunctionDecl *initDecl, void *) {
 
         // container.superDecoder()
         auto *superDecoderCall =
-          CallExpr::createImplicit(C, superDecoderRef, ArrayRef<Expr *>(),
-                                   ArrayRef<Identifier>());
+            CallExpr::createImplicitEmpty(C, superDecoderRef);
 
         // super
         auto *superRef = new (C) SuperRefExpr(initDecl->getImplicitSelfDecl(),
@@ -1477,9 +1476,7 @@ deriveBodyDecodable_init(AbstractFunctionDecl *initDecl, void *) {
         auto *superInitRef = UnresolvedDotExpr::createImplicit(C, superRef,
                                                                initName);
         // super.init() call
-        Expr *callExpr = CallExpr::createImplicit(C, superInitRef,
-                                                  ArrayRef<Expr *>(),
-                                                  ArrayRef<Identifier>());
+        Expr *callExpr = CallExpr::createImplicitEmpty(C, superInitRef);
 
         // If super.init throws, try super.init()
         if (superInitDecl->hasThrows())

lib/Sema/TypeCheckAttr.cpp

@@ -1866,7 +1866,7 @@ synthesizeMainBody(AbstractFunctionDecl *fn, void *arg) {
       /*Implicit*/ true);
   memberRefExpr->setImplicit(true);
 
-  auto *callExpr = CallExpr::createImplicit(context, memberRefExpr, {}, {});
+  auto *callExpr = CallExpr::createImplicitEmpty(context, memberRefExpr);
   callExpr->setImplicit(true);
   callExpr->setType(context.TheEmptyTupleType);
 

lib/Sema/TypeCheckStmt.cpp

@@ -1595,7 +1595,7 @@ static Expr* constructCallToSuperInit(ConstructorDecl *ctor,
                                               SourceLoc(), /*Implicit=*/true);
   Expr *r = UnresolvedDotExpr::createImplicit(
       Context, superRef, DeclBaseName::createConstructor());
-  r = CallExpr::createImplicit(Context, r, { }, { });
+  r = CallExpr::createImplicitEmpty(Context, r);
 
   if (ctor->hasThrows())
     r = new (Context) TryExpr(SourceLoc(), r, Type(), /*implicit=*/true);

lib/Sema/TypeCheckStorage.cpp

@@ -1574,7 +1574,7 @@ synthesizeObservedSetterBody(AccessorDecl *Set, TargetImpl target,
     if (arg) {
       Call = CallExpr::createImplicit(Ctx, Callee, {ValueDRE}, {Identifier()});
     } else {
-      Call = CallExpr::createImplicit(Ctx, Callee, {}, {});
+      Call = CallExpr::createImplicitEmpty(Ctx, Callee);
     }
 
     if (auto funcType = type->getAs<FunctionType>())
@@ -1751,7 +1751,7 @@ synthesizeModifyCoroutineBodyWithSimpleDidSet(AccessorDecl *accessor,
       Callee = DSCE;
     }
 
-    auto *Call = CallExpr::createImplicit(ctx, Callee, {}, {});
+    auto *Call = CallExpr::createImplicitEmpty(ctx, Callee);
     if (auto funcType = type->getAs<FunctionType>())
       type = funcType->getResult();
     Call->setType(type);