Add calledExpression label to FunctionCallExpr convenience initializer

Otherwise initializing a `FunctionCallExpr` from a string is ambiguous whether it should be parsed or call the string

Author: ahoppen

Sources/SwiftSyntaxBuilder/ConvenienceInitializers/FunctionCallExprConvenienceInitializers.swift

@@ -18,7 +18,7 @@ extension FunctionCallExpr {
   /// instead of having to wrap them in a `TupleExprElementList`.
   /// The presence of the parenthesis will be inferred based on the presence of arguments and the trailing closure.
   public init(
-    _ calledExpression: ExpressibleAsExprBuildable,
+    calledExpression: ExpressibleAsExprBuildable,
     trailingClosure: ExpressibleAsClosureExpr? = nil,
     additionalTrailingClosures: MultipleTrailingClosureElementList? = nil,
     @TupleExprElementListBuilder argumentList: () -> ExpressibleAsTupleExprElementList = { [] }

Tests/SwiftSyntaxBuilderTest/CollectionNodeFlatteningTests.swift

@@ -9,18 +9,18 @@ final class CollectionNodeFlatteningTests: XCTestCase {
 
     @CodeBlockItemListBuilder
     func buildInnerCodeBlockItemList() -> ExpressibleAsCodeBlockItemList {
-      FunctionCallExpr("innerBuilder")
+      FunctionCallExpr(calledExpression: "innerBuilder")
     }
 
     @CodeBlockItemListBuilder
     func buildOuterCodeBlockItemList() -> ExpressibleAsCodeBlockItemList {
-      FunctionCallExpr("outerBuilder")
+      FunctionCallExpr(calledExpression: "outerBuilder")
 
       buildInnerCodeBlockItemList()
     }
 
     let codeBlock = CodeBlock(leadingTrivia: leadingTrivia) {
-      FunctionCallExpr("outsideBuilder")
+      FunctionCallExpr(calledExpression: "outsideBuilder")
       buildOuterCodeBlockItemList()
     }
 
@@ -41,13 +41,13 @@ final class CollectionNodeFlatteningTests: XCTestCase {
     let leadingTrivia = Trivia.unexpectedText("␣")
 
     func buildInnerCodeBlockItemList() -> ExpressibleAsCodeBlockItemList {
-      CodeBlockItemList([FunctionCallExpr("innerBuilder")])
+      CodeBlockItemList([FunctionCallExpr(calledExpression: "innerBuilder")])
     }
 
     func buildOuterCodeBlockItemList() -> ExpressibleAsCodeBlockItemList {
       CodeBlockItemList(
         combining: [
-          CodeBlockItemList([FunctionCallExpr("outerBuilder")]),
+          CodeBlockItemList([FunctionCallExpr(calledExpression: "outerBuilder")]),
           buildInnerCodeBlockItemList()
         ]
       )
@@ -57,7 +57,7 @@ final class CollectionNodeFlatteningTests: XCTestCase {
       leadingTrivia: leadingTrivia,
       statements: CodeBlockItemList(
         combining: [
-          CodeBlockItemList([FunctionCallExpr("outsideBuilder")]),
+          CodeBlockItemList([FunctionCallExpr(calledExpression: "outsideBuilder")]),
           buildOuterCodeBlockItemList()
         ]
       )

Tests/SwiftSyntaxBuilderTest/DoStmtTests.swift

@@ -5,14 +5,14 @@ final class DoStmtTests: XCTestCase {
   func testDoStmt() {
     let buildable = DoStmt(
       body: CodeBlock(statementsBuilder: {
-        CodeBlockItem(item: TryExpr(expression: FunctionCallExpr(MemberAccessExpr(base: "a", name: "b"))))
+        CodeBlockItem(item: TryExpr(expression: FunctionCallExpr(calledExpression: MemberAccessExpr(base: "a", name: "b"))))
       }),
       catchClauses: [
         CatchClause(CatchItemList {
           CatchItem(pattern: "Error1")
           CatchItem(pattern: "Error2")
         }) {
-          FunctionCallExpr("print") {
+          FunctionCallExpr(calledExpression: "print") {
             TupleExprElement(expression: StringLiteralExpr("Known error"))
           }
         },
@@ -23,7 +23,7 @@ final class DoStmtTests: XCTestCase {
           ThrowStmt(expression: MemberAccessExpr(base: "Error4", name: "error3"))
         },
         CatchClause {
-          FunctionCallExpr("print") {
+          FunctionCallExpr(calledExpression: "print") {
             TupleExprElement(expression: "error")
           }
         }

Tests/SwiftSyntaxBuilderTest/ExpressibleBuildablesTests.swift

@@ -45,7 +45,7 @@ final class ExpressibleBuildablesTests: XCTestCase {
 
   func testExprExpressibleAsCodeBlockItem() {
     let myCodeBlock = CodeBlock(leftBrace: .leftBrace.withLeadingTrivia([])) {
-      FunctionCallExpr("print") { TupleExprElement(expression: StringLiteralExpr("Hello world")) }
+      FunctionCallExpr(calledExpression: "print") { TupleExprElement(expression: StringLiteralExpr("Hello world")) }
       IntegerLiteralExpr(42)
       "someIdentifier"
     }

Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift

@@ -7,7 +7,7 @@ final class ExtensionDeclTests: XCTestCase {
     let keywords = ["associatedtype", "class"].map { keyword -> VariableDecl in
       // We need to use `CodeBlock` here to ensure there is braces around.
       let body = CodeBlock {
-        FunctionCallExpr("TokenSyntax.\(keyword)Keyword")
+        FunctionCallExpr(calledExpression: "TokenSyntax.\(keyword)Keyword")
       }
 
       return VariableDecl(

Tests/SwiftSyntaxBuilderTest/FunctionTests.swift

@@ -26,7 +26,7 @@ final class FunctionTests: XCTestCase {
         body: ifCodeBlock)
 
       ReturnStmt(expression: SequenceExpr {
-        FunctionCallExpr("fibonacci") {
+        FunctionCallExpr(calledExpression: "fibonacci") {
           SequenceExpr {
             IntegerLiteralExpr(digits: "n")
             BinaryOperatorExpr("-")
@@ -36,7 +36,7 @@ final class FunctionTests: XCTestCase {
 
         BinaryOperatorExpr("+")
 
-        FunctionCallExpr(MemberAccessExpr(base: "self", name: "fibonacci")) {
+        FunctionCallExpr(calledExpression: MemberAccessExpr(base: "self", name: "fibonacci")) {
           SequenceExpr {
             IntegerLiteralExpr(digits: "n")
             BinaryOperatorExpr("-")
@@ -58,7 +58,7 @@ final class FunctionTests: XCTestCase {
   }
 
   func testArguments() {
-    let buildable = FunctionCallExpr("test") {
+    let buildable = FunctionCallExpr(calledExpression: "test") {
       for param in (1...5) {
         TupleExprElement(label: param.isMultiple(of: 2) ? "p\(param)" : nil, expression: "value\(param)")
       }
@@ -68,13 +68,13 @@ final class FunctionTests: XCTestCase {
   }
 
   func testParensEmittedForNoArgumentsAndNoTrailingClosure() {
-    let buildable = FunctionCallExpr("test")
+    let buildable = FunctionCallExpr(calledExpression: "test")
     let syntax = buildable.buildSyntax()
     XCTAssertEqual(syntax.description, "test()")
   }
 
   func testParensEmittedForArgumentAndTrailingClosure() {
-    let buildable = FunctionCallExpr("test", trailingClosure: ClosureExpr()) {
+    let buildable = FunctionCallExpr(calledExpression: "test", trailingClosure: ClosureExpr()) {
       TupleExprElement(expression: "42")
     }
     let syntax = buildable.buildSyntax()
@@ -83,11 +83,11 @@ final class FunctionTests: XCTestCase {
 
   func testParensOmittedForNoArgumentsAndTrailingClosure() {
     let closure = ClosureExpr(statementsBuilder: {
-      FunctionCallExpr("f") {
+      FunctionCallExpr(calledExpression: "f") {
         TupleExprElement(expression: "a")
       }
     })
-    let buildable = FunctionCallExpr("test", trailingClosure: closure)
+    let buildable = FunctionCallExpr(calledExpression: "test", trailingClosure: closure)
     let syntax = buildable.buildSyntax()
     XCTAssertEqual(
       syntax.description,

Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift

@@ -19,11 +19,11 @@ final class IfStmtTests: XCTestCase {
     // Use the convenience initializer from IfStmtConvenienceInitializers
     // with an else branch expressed by a second trailing closure.
     let buildable = IfStmt(conditions: ExprList([BooleanLiteralExpr(true)])) {
-      FunctionCallExpr("print") {
+      FunctionCallExpr(calledExpression: "print") {
         TupleExprElement(expression: StringLiteralExpr("Hello from the if-branch!"))
       }
     } elseBody: {
-      FunctionCallExpr("print") {
+      FunctionCallExpr(calledExpression: "print") {
         TupleExprElement(expression: StringLiteralExpr("Hello from the else-branch!"))
       }
     }