Merge all convenience initializers into one file

Author: ahoppen

Sources/SwiftSyntaxBuilder/CMakeLists.txt

@@ -7,27 +7,13 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 add_library(SwiftSyntaxBuilder STATIC
+  ConvenienceInitializers.swift
   HasTrailingComma.swift
   Indenter.swift
   ResultBuilderExtensions.swift
   Syntax+StringInterpolation.swift
+  SyntaxNodeWithBody.swift
 
-  ConvenienceInitializers/BinaryOperatorExprConvenienceInitializers.swift
-  ConvenienceInitializers/BooleanLiteralExprConvenienceInitializers.swift
-  ConvenienceInitializers/CatchClauseConvenienceInitializer.swift
-  ConvenienceInitializers/CustomAttributeConvenienceInitializers.swift
-  ConvenienceInitializers/DictionaryExprConvenienceInitializers.swift
-  ConvenienceInitializers/FloatLiteralExprConvenienceInitializers.swift
-  ConvenienceInitializers/FunctionCallExprConvenienceInitializers.swift
-  ConvenienceInitializers/IfStmtConvenienceInitializers.swift
-  ConvenienceInitializers/IntegerLiteralExprConvenienceInitializers.swift
-  ConvenienceInitializers/MemberAccessExprConvenienceInitializers.swift
-  ConvenienceInitializers/SwitchCaseConvenienceInitializers.swift
-  ConvenienceInitializers/SyntaxNodeWithBody.swift
-  ConvenienceInitializers/StringLiteralExprConvenienceInitializers.swift
-  ConvenienceInitializers/TernaryExprConvenienceInitializers.swift
-  ConvenienceInitializers/TupleExprElementConvenienceInitializers.swift
-  ConvenienceInitializers/VariableDeclConvenienceInitializers.swift
 
   generated/BuildableCollectionNodes.swift
   generated/BuildableNodes.swift

Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift

@@ -0,0 +1,295 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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 Foundation
+import SwiftSyntax
+
+extension BinaryOperatorExpr {
+  public init(text: String) {
+    self.init(operatorToken: .spacedBinaryOperator(text))
+  }
+}
+
+extension BooleanLiteralExpr: ExpressibleByBooleanLiteral {
+  public init(_ value: Bool) {
+    self.init(booleanLiteral: value ? .true : .false)
+  }
+
+  public init(booleanLiteral value: Bool) {
+    self.init(value)
+  }
+}
+
+extension CatchClause {
+  /// A convenience initializer that calculates spacing around the `catch` keyword.
+  public init(
+    leadingTrivia: Trivia = [],
+    _ catchItems: CatchItemList,
+    @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      catchKeyword: .catch.withTrailingTrivia(catchItems.isEmpty ? [] : .space),
+      catchItems: catchItems,
+      body: CodeBlockSyntax(statements: bodyBuilder())
+    )
+  }
+}
+
+extension CustomAttribute {
+  /// A convenience initializer that allows passing in arguments using a result builder
+  /// and automatically adds parentheses as needed, similar to the convenience
+  /// initializer for ``FunctionCallExpr``.
+  public init(
+    _ attributeName: TypeSyntax,
+    @TupleExprElementListBuilder argumentList: () -> TupleExprElementList? = { nil }
+  ) {
+    let argumentList = argumentList()
+    self.init(
+      attributeName: attributeName,
+      leftParen: argumentList != nil ? .leftParen : nil,
+      argumentList: argumentList,
+      rightParen: argumentList != nil ? .rightParen : nil
+    )
+  }
+}
+
+extension DictionaryExpr {
+  /// A convenience initializer that allows passing in members using a result builder
+  /// instead of having to wrap them in a `DictionaryElementList`.
+  public init(
+    leftSquare: Token = .`leftSquareBracket`,
+    rightSquare: Token = .`rightSquareBracket`,
+    @DictionaryElementListBuilder contentBuilder: () -> DictionaryElementListSyntax = { DictionaryElementList([]) }
+  ) {
+    let elementList = contentBuilder()
+    self.init(
+      leftSquare: leftSquare,
+      content: elementList.isEmpty ? Syntax(Token.colon.withTrailingTrivia([])) : Syntax(elementList),
+      rightSquare: rightSquare
+    )
+  }
+}
+
+extension FloatLiteralExprSyntax: ExpressibleByFloatLiteral {
+  public init(_ value: Float) {
+    self.init(floatingDigits: String(value))
+  }
+
+  public init(floatLiteral value: Float) {
+    self.init(value)
+  }
+}
+
+extension FunctionCallExpr {
+  /// A convenience initializer that allows passing in arguments using a result builder
+  /// 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: ExprSyntaxProtocol,
+    trailingClosure: ClosureExprSyntax? = nil,
+    additionalTrailingClosures: MultipleTrailingClosureElementList? = nil,
+    @TupleExprElementListBuilder argumentList: () -> TupleExprElementList = { [] }
+  ) {
+    let argumentList = argumentList()
+    let shouldOmitParens = argumentList.isEmpty && trailingClosure != nil
+    self.init(
+      calledExpression: calledExpression,
+      leftParen: shouldOmitParens ? nil : .leftParen,
+      argumentList: argumentList,
+      rightParen: shouldOmitParens ? nil : .rightParen,
+      trailingClosure: trailingClosure,
+      additionalTrailingClosures: additionalTrailingClosures
+    )
+  }
+}
+
+extension IfStmt {
+  /// A convenience initializer that uses builder closures to express an
+  /// if body, potentially with a second trailing builder closure for an else
+  /// body.
+  public init(
+    leadingTrivia: Trivia = [],
+    conditions: ConditionElementList,
+    @CodeBlockItemListBuilder body: () -> CodeBlockItemList,
+    @CodeBlockItemListBuilder elseBody: () -> CodeBlockItemList? = { nil }
+  ) {
+    let generatedElseBody = elseBody()
+    self.init(
+      leadingTrivia: leadingTrivia,
+      conditions: conditions,
+      body: CodeBlockSyntax(statements: body()),
+      elseKeyword: generatedElseBody == nil ? nil : Token.else.withLeadingTrivia(.space).withTrailingTrivia([]),
+      elseBody: generatedElseBody.map { CodeBlock(statements: $0) }
+    )
+  }
+}
+
+
+extension IntegerLiteralExpr: ExpressibleByIntegerLiteral {
+  public init(_ value: Int) {
+    self.init(digits: String(value))
+  }
+
+  public init(integerLiteral value: Int) {
+    self.init(value)
+  }
+}
+
+extension MemberAccessExpr {
+  /// Creates a `MemberAccessExpr` using the provided parameters.
+  public init(
+    base: ExprSyntax? = nil,
+    dot: Token = .period,
+    name: String,
+    declNameArguments: DeclNameArgumentsSyntax? = nil
+  ) {
+    self.init(base: base, dot: dot, name: TokenSyntax.identifier(name), declNameArguments: declNameArguments)
+  }
+}
+
+extension StringLiteralExpr {
+  /// A regular expression matching sequences of `#`s with an adjacent quote or
+  /// interpolation. Used to determine the number of `#`s for a raw string literal.
+  private static let rawStringPotentialEscapesPattern = try! NSRegularExpression(
+    pattern: [
+      #""(#*)"#, // Match potential opening delimiters
+      #"(#*)""#, // Match potential closing delimiters
+      #"\\(#*)"#, // Match potential interpolations
+    ].joined(separator: "|")
+  )
+
+  /// Creates a string literal, optionally specifying quotes and delimiters.
+  /// If `openDelimiter` and `closeDelimiter` are `nil`, automatically determines
+  /// the number of `#`s needed to express the string as-is without any escapes.
+  public init(
+    openDelimiter: Token? = nil,
+    openQuote: Token = .stringQuote,
+    content: String,
+    closeQuote: Token = .stringQuote,
+    closeDelimiter: Token? = nil
+  ) {
+    let contentToken = Token.stringSegment(content)
+    let segment = StringSegment(content: contentToken)
+    let segments = StringLiteralSegments([segment])
+
+    var openDelimiter = openDelimiter
+    var closeDelimiter = closeDelimiter
+    if openDelimiter == nil, closeDelimiter == nil {
+      // Match potential escapes in the string
+      let matches = Self.rawStringPotentialEscapesPattern.matches(in: content, range: NSRange(content.startIndex..., in: content))
+
+      // Find longest sequence of `#`s by taking the maximum length over all captures
+      let poundCount = matches
+        .compactMap { match in (1..<match.numberOfRanges).map { match.range(at: $0).length + 1 }.max() }
+        .max() ?? 0
+
+      // Use a delimiter that is exactly one longer
+      openDelimiter = Token.rawStringDelimiter(String(repeating: "#", count: poundCount))
+      closeDelimiter = openDelimiter
+    }
+
+    self.init(
+      openDelimiter: openDelimiter,
+      openQuote: openQuote,
+      segments: segments,
+      closeQuote: closeQuote,
+      closeDelimiter: closeDelimiter
+    )
+  }
+}
+
+extension SwitchCase {
+  public init(_ label: String, @CodeBlockItemListBuilder statementsBuilder: () -> CodeBlockItemListSyntax) {
+    self.init("\(label)")
+    self.statements = statementsBuilder()
+  }
+}
+
+extension TernaryExpr {
+  public init(
+    if condition: ExprSyntaxProtocol,
+    then firstChoice: ExprSyntaxProtocol,
+    else secondChoice: ExprSyntaxProtocol
+  ) {
+    self.init(
+      conditionExpression: condition,
+      questionMark: .infixQuestionMark.withLeadingTrivia(.space).withTrailingTrivia(.space),
+      firstChoice: firstChoice,
+      colonMark: .colon.withLeadingTrivia(.space),
+      secondChoice: secondChoice
+    )
+  }
+}
+
+extension TupleExprElement {
+  /// A convenience initializer that allows passing in label as an optional string.
+  /// The presence of the colon will be inferred based on the presence of the label.
+  public init(label: String? = nil, expression: ExprSyntax) {
+    self.init(
+      label: label.map { Token.identifier($0) }, colon: label == nil ? nil : Token.colon, expression: expression, trailingComma: nil)
+  }
+}
+
+extension VariableDecl {
+  /// Creates an optionally initialized property.
+  public init(
+    leadingTrivia: Trivia = [],
+    attributes: AttributeList? = nil,
+    modifiers: ModifierList? = nil,
+    _ letOrVarKeyword: Token,
+    name: IdentifierPattern,
+    type: TypeAnnotation? = nil,
+    initializer: InitializerClause? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      attributes: attributes?.withTrailingTrivia(.space),
+      modifiers: modifiers,
+      letOrVarKeyword: letOrVarKeyword
+    ) {
+      PatternBinding(
+        pattern: name,
+        typeAnnotation: type,
+        initializer: initializer
+      )
+    }
+  }
+
+  /// Creates a computed property with the given accessor.
+  public init(
+    leadingTrivia: Trivia = [],
+    attributes: AttributeList? = nil,
+    modifiers: ModifierList? = nil,
+    name: IdentifierPattern,
+    type: TypeAnnotation,
+    @CodeBlockItemListBuilder accessor: () -> CodeBlockItemList
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      attributes: attributes?.withTrailingTrivia(.space),
+      modifiers: modifiers,
+      letOrVarKeyword: .var
+    ) {
+      PatternBinding(
+        pattern: name,
+        typeAnnotation: type,
+        accessor: CodeBlock(statements: accessor())
+      )
+    }
+  }
+}
+
+//==========================================================================//
+// IMPORTANT: If you are tempted to add an extension here, please insert    //
+// it in alphabetical order above                                           //
+//==========================================================================//