more internal types

Author: leogdion

Sources/SyntaxKit/Collections/ArrayLiteral.swift

@@ -31,21 +31,21 @@ import Foundation
 
 /// An array literal value that can be used as a literal.
 internal struct ArrayLiteral: LiteralValue, CodeBlockable {
-  let elements: [Literal]
+  internal let elements: [Literal]
 
   /// Creates an array with the given elements.
   /// - Parameter elements: The array elements.
-  init(_ elements: [Literal]) {
+  internal init(_ elements: [Literal]) {
     self.elements = elements
   }
 
   /// The code block representation of this array literal.
-  var codeBlock: CodeBlock {
+  internal var codeBlock: CodeBlock {
     Literal.array(elements)
   }
 
   /// The Swift type name for this array.
-  var typeName: String {
+  internal var typeName: String {
     if elements.isEmpty {
       return "[Any]"
     }
@@ -54,7 +54,7 @@ internal struct ArrayLiteral: LiteralValue, CodeBlockable {
   }
 
   /// Renders this array as a Swift literal string.
-  var literalString: String {
+  internal var literalString: String {
     let elementStrings = elements.map { element in
       switch element {
       case .integer(let value): return String(value)

…t/Collections/TupleLiteralProtocol.swift …t/Collections/CodeBlockableLiteral.swiftSources/SyntaxKit/Collections/TupleLiteralProtocol.swift renamed to Sources/SyntaxKit/Collections/CodeBlockableLiteral.swift Sources/SyntaxKit/Collections/TupleLiteralProtocol.swift renamed to Sources/SyntaxKit/Collections/CodeBlockableLiteral.swift

@@ -1,5 +1,5 @@
 //
-//  TupleLiteralProtocol.swift
+//  CodeBlockableLiteral.swift
 //  SyntaxKit
 //
 //  Created by Leo Dion.
@@ -30,4 +30,4 @@
 import Foundation
 
 /// A protocol for tuple literal values that can be used as literals.
-public typealias TupleLiteralProtocol = LiteralValue & CodeBlockable
+public typealias CodeBlockableLiteral = LiteralValue & CodeBlockable

Sources/SyntaxKit/Collections/DictionaryLiteral.swift

@@ -31,21 +31,21 @@ import Foundation
 
 /// A dictionary literal value that can be used as a literal.
 internal struct DictionaryLiteral: LiteralValue, CodeBlockable {
-  let elements: [(Literal, Literal)]
+  internal let elements: [(Literal, Literal)]
 
   /// Creates a dictionary with the given key-value pairs.
   /// - Parameter elements: The dictionary key-value pairs.
-  init(_ elements: [(Literal, Literal)]) {
+  internal init(_ elements: [(Literal, Literal)]) {
     self.elements = elements
   }
 
   /// The code block representation of this dictionary literal.
-  var codeBlock: CodeBlock {
+  internal var codeBlock: CodeBlock {
     Literal.dictionary(elements)
   }
 
   /// The Swift type name for this dictionary.
-  var typeName: String {
+  internal var typeName: String {
     if elements.isEmpty {
       return "[Any: Any]"
     }
@@ -55,7 +55,7 @@ internal struct DictionaryLiteral: LiteralValue, CodeBlockable {
   }
 
   /// Renders this dictionary as a Swift literal string.
-  var literalString: String {
+  internal var literalString: String {
     let elementStrings = elements.map { key, value in
       let keyString: String
       let valueString: String

…/Collections/TuplePatternCodeBlock.swift …tions/PatternConvertableCollection.swiftSources/SyntaxKit/Collections/TuplePatternCodeBlock.swift renamed to Sources/SyntaxKit/Collections/PatternConvertableCollection.swift Sources/SyntaxKit/Collections/TuplePatternCodeBlock.swift renamed to Sources/SyntaxKit/Collections/PatternConvertableCollection.swift

@@ -1,5 +1,5 @@
 //
-//  TuplePatternCodeBlock.swift
+//  PatternConvertableCollection.swift
 //  SyntaxKit
 //
 //  Created by Leo Dion.
@@ -30,14 +30,14 @@
 import SwiftSyntax
 
 /// A tuple pattern that can be used as a CodeBlock for for-in loops.
-internal struct TuplePatternCodeBlock: PatternCodeBlock {
+internal struct PatternConvertableCollection: PatternCodeBlock {
   private let elements: [PatternConvertible?]
 
   internal init(elements: [PatternConvertible?]) {
     self.elements = elements
   }
 
-  var patternSyntax: PatternSyntax {
+  internal var patternSyntax: PatternSyntax {
     let patternElements = TuplePatternElementListSyntax(
       elements.enumerated().map { index, element in
         let patternElement: TuplePatternElementSyntax
@@ -70,7 +70,7 @@ internal struct TuplePatternCodeBlock: PatternCodeBlock {
     )
   }
 
-  var syntax: SyntaxProtocol {
+  internal var syntax: SyntaxProtocol {
     // For CodeBlock conformance, we return the pattern syntax as an expression
     // This is a bit of a hack, but it allows us to use TuplePatternCodeBlock in For loops
     patternSyntax

Sources/SyntaxKit/Collections/Tuple.swift

@@ -50,7 +50,7 @@ public struct Tuple: CodeBlock {
   /// Creates a tuple pattern that can be used as a CodeBlock.
   /// - Parameter elements: Array of pattern elements, where `nil` represents a wildcard pattern.
   public static func patternCodeBlock(_ elements: [PatternConvertible?]) -> PatternCodeBlock {
-    TuplePatternCodeBlock(elements: elements)
+    PatternConvertableCollection(elements: elements)
   }
 
   /// Marks this tuple as async.

Sources/SyntaxKit/Collections/TupleAssignment.swift

@@ -42,37 +42,37 @@ internal struct TupleAssignment: CodeBlock {
   /// - Parameters:
   ///   - elements: The names of the variables to destructure into.
   ///   - value: The expression to destructure.
-  init(_ elements: [String], equals value: CodeBlock) {
+  internal init(_ elements: [String], equals value: CodeBlock) {
     self.elements = elements
     self.value = value
   }
 
   /// Marks this destructuring as async.
   /// - Returns: A copy of the destructuring marked as async.
-  func async() -> Self {
+  internal func async() -> Self {
     var copy = self
     copy.isAsync = true
     return copy
   }
 
   /// Marks this destructuring as throwing.
   /// - Returns: A copy of the destructuring marked as throwing.
-  func throwing() -> Self {
+  internal func throwing() -> Self {
     var copy = self
     copy.isThrowing = true
     return copy
   }
 
   /// Marks this destructuring as concurrent async (async let set).
   /// - Returns: A copy of the destructuring marked as async set.
-  func asyncSet() -> Self {
+  internal func asyncSet() -> Self {
     var copy = self
     copy.isAsyncSet = true
     return copy
   }
 
   /// The syntax representation of this tuple assignment.
-  var syntax: SyntaxProtocol {
+  internal var syntax: SyntaxProtocol {
     if isAsyncSet {
       return generateAsyncSetSyntax()
     }

Sources/SyntaxKit/Collections/TupleLiteralArray.swift

@@ -31,22 +31,22 @@ import Foundation
 import SwiftSyntax
 
 /// A tuple literal value that can be used as a literal.
-internal struct TupleLiteralArray: TupleLiteralProtocol {
-  let elements: [Literal?]
+internal struct TupleLiteralArray: CodeBlockableLiteral {
+  internal let elements: [Literal?]
 
   /// Creates a tuple with the given elements.
   /// - Parameter elements: The tuple elements, where `nil` represents a wildcard.
-  init(_ elements: [Literal?]) {
+  internal init(_ elements: [Literal?]) {
     self.elements = elements
   }
 
   /// The code block representation of this tuple literal.
-  var codeBlock: CodeBlock {
+  internal var codeBlock: CodeBlock {
     Literal.tuple(elements)
   }
 
   /// The Swift type name for this tuple.
-  var typeName: String {
+  internal var typeName: String {
     let elementTypes = elements.map { element in
       if let element = element {
         switch element {
@@ -68,7 +68,7 @@ internal struct TupleLiteralArray: TupleLiteralProtocol {
   }
 
   /// Renders this tuple as a Swift literal string.
-  var literalString: String {
+  internal var literalString: String {
     let elementStrings = elements.map { element in
       if let element = element {
         switch element {

Sources/SyntaxKit/Collections/TuplePattern.swift

@@ -37,7 +37,7 @@ internal struct TuplePattern: PatternConvertible {
     self.elements = elements
   }
 
-  var patternSyntax: PatternSyntax {
+  internal var patternSyntax: PatternSyntax {
     let patternElements = TuplePatternElementListSyntax(
       elements.enumerated().map { index, element in
         let patternElement: TuplePatternElementSyntax

Sources/SyntaxKit/Collections/TuplePatternCodeBlockProtocol.swift

@@ -43,7 +43,7 @@ extension Literal {
   }
 
   /// Converts a Literal.tuple to a TupleLiteral for use in Variable declarations.
-  public var asTupleLiteral: TupleLiteralProtocol? {
+  public var asTupleLiteral: CodeBlockableLiteral? {
     switch self {
     case .tuple(let elements):
       return TupleLiteralArray(elements)