Add convenience initializers for simple expr values

Author: kimdv

Sources/SwiftSyntaxBuilder/BooleanLiteralExprConvenienceInitializers.swift

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+extension BooleanLiteralExpr {
+  public init(_ value: Bool) {
+    self.init(booleanLiteral: value ? Tokens.true : Tokens.false)
+  }
+}
+
+extension BooleanLiteralExpr: ExpressibleByBooleanLiteral {
+  public init(booleanLiteral value: Bool) {
+    self.init(value)
+  }
+}

Sources/SwiftSyntaxBuilder/FloatLiteralExprConvenienceInitializers.swift

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+extension FloatLiteralExpr {
+  public init(_ value: Float) {
+    self.init(floatingDigits: SyntaxFactory.makeFloatingLiteral(String(value)))
+  }
+}
+
+extension FloatLiteralExpr: ExpressibleByFloatLiteral {
+  public init(floatLiteral value: Float) {
+    self.init(value)
+  }
+}

Sources/SwiftSyntaxBuilder/IntegerLiteralExprConvenienceInitializers.swift

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+extension IntegerLiteralExpr {
+  public init(_ value: Int) {
+    self.init(digits: SyntaxFactory.makeIntegerLiteral(String(value)))
+  }
+}
+
+extension IntegerLiteralExpr: ExpressibleByIntegerLiteral {
+  public init(integerLiteral value: Int) {
+    self.init(value)
+  }
+}

Sources/SwiftSyntaxBuilder/StringLiteralExprConvenienceInitializers.swift

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+extension StringLiteralExpr {
+  public init(_ value: String) {
+    let content = SyntaxFactory.makeToken(TokenKind.stringSegment(value), presence: .present)
+    let segment = StringSegment(content: content)
+    let segments = StringLiteralSegments([segment])
+
+    self.init(openQuote: Tokens.stringQuote,
+              segments: segments,
+              closeQuote: Tokens.stringQuote)
+  }
+}
+
+extension StringLiteralExpr: ExpressibleByStringLiteral {
+  public init(stringLiteral value: String) {
+    self.init(value)
+  }
+}

Tests/SwiftSyntaxBuilderTest/BooleanLiteralTests.swift

@@ -0,0 +1,29 @@
+import XCTest
+import SwiftSyntax
+
+import SwiftSyntaxBuilder
+
+final class BooleanLiteralTests: XCTestCase {
+  func testBooleanLiteral() {
+    let leadingTrivia = Trivia.garbageText("␣")
+
+    let testCases: [UInt: (BooleanLiteralExpr, String)] = [
+      #line: (BooleanLiteralExpr(booleanLiteral: Tokens.true), "␣true "),
+      #line: (BooleanLiteralExpr(booleanLiteral: Tokens.false), "␣false "),
+      #line: (BooleanLiteralExpr(true), "␣true "),
+      #line: (BooleanLiteralExpr(false), "␣false "),
+      #line: (false, "␣false "),
+      #line: (true, "␣true "),
+    ]
+
+    for (line, testCase) in testCases {
+      let (builder, expected) = testCase
+      let syntax = builder.buildSyntax(format: Format(), leadingTrivia: leadingTrivia)
+
+      var text = ""
+      syntax.write(to: &text)
+
+      XCTAssertEqual(text, expected, line: line)
+    }
+  }
+}

Tests/SwiftSyntaxBuilderTest/FloatLiteralTests.swift

@@ -0,0 +1,27 @@
+import XCTest
+import SwiftSyntax
+
+import SwiftSyntaxBuilder
+
+final class FloatLiteralTests: XCTestCase {
+  func testFloatLiteral() {
+    let leadingTrivia = Trivia.garbageText("␣")
+
+    let testCases: [UInt: (FloatLiteralExpr, String)] = [
+        #line: (FloatLiteralExpr(floatingDigits: SyntaxFactory.makeFloatingLiteral(String(123.321))), "␣123.321"),
+        #line: (FloatLiteralExpr(floatingDigits: SyntaxFactory.makeFloatingLiteral(String(-123.321))), "␣-123.321"),
+        #line: (123.321, "␣123.321"),
+        #line: (-123.321, "␣-123.321"),
+    ]
+
+    for (line, testCase) in testCases {
+      let (builder, expected) = testCase
+      let syntax = builder.buildSyntax(format: Format(), leadingTrivia: leadingTrivia)
+
+      var text = ""
+      syntax.write(to: &text)
+
+      XCTAssertEqual(text, expected, line: line)
+    }
+  }
+}

Tests/SwiftSyntaxBuilderTest/IntegerLiteralTests.swift

@@ -10,6 +10,8 @@ final class IntegerLiteralTests: XCTestCase {
     let testCases: [UInt: (IntegerLiteralExpr, String)] = [
       #line: (IntegerLiteralExpr(digits: SyntaxFactory.makeIntegerLiteral(String(123))), "␣123"),
       #line: (IntegerLiteralExpr(digits: SyntaxFactory.makeIntegerLiteral(String(-123))), "␣-123"),
+      #line: (123, "␣123"),
+      #line: (-123, "␣-123"),
     ]
 
     for (line, testCase) in testCases {

Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift

@@ -26,4 +26,22 @@ final class StringLiteralTests: XCTestCase {
       XCTAssertEqual(text, expected, line: line)
     }
   }
+
+    func testStringConvenienceInitializers() {
+        let leadingTrivia = Trivia.garbageText("␣")
+        let testCases: [UInt: (StringLiteralExpr, String)] = [
+          #line: ("", #"␣"""#),
+          #line: ("asdf", #"␣"asdf""#),
+        ]
+
+        for (line, testCase) in testCases {
+          let (builder, expected) = testCase
+          let syntax = builder.buildSyntax(format: Format(), leadingTrivia: leadingTrivia)
+
+          var text = ""
+          syntax.write(to: &text)
+
+          XCTAssertEqual(text, expected, line: line)
+        }
+    }
 }