remove Variable fatalError

Author: leogdion

Sources/SyntaxKit/Collections/Array+LiteralValue.swift

@@ -29,10 +29,15 @@
 
 import Foundation
 
-extension Array: LiteralValue where Element == String {
+extension Array: LiteralValue, CodeBlockable where Element == String {
   /// The Swift type name for an array of strings.
   public var typeName: String { "[String]" }
 
+  /// The code block representation of this array of strings.
+  public var codeBlock: CodeBlock {
+    Literal.array(self.map { .string($0) })
+  }
+
   /// Renders this array as a Swift literal string with proper escaping.
   public var literalString: String {
     let elements = self.map { element in

Sources/SyntaxKit/Collections/ArrayLiteral.swift

@@ -30,7 +30,7 @@
 import Foundation
 
 /// An array literal value that can be used as a literal.
-public struct ArrayLiteral: LiteralValue {
+public struct ArrayLiteral: LiteralValue, CodeBlockable {
   public let elements: [Literal]
 
   /// Creates an array with the given elements.
@@ -39,6 +39,11 @@ public struct ArrayLiteral: LiteralValue {
     self.elements = elements
   }
 
+  /// The code block representation of this array literal.
+  public var codeBlock: CodeBlock {
+    Literal.array(elements)
+  }
+
   /// The Swift type name for this array.
   public var typeName: String {
     if elements.isEmpty {

Sources/SyntaxKit/Collections/Dictionary+LiteralValue.swift

@@ -29,10 +29,15 @@
 
 import Foundation
 
-extension Dictionary: LiteralValue where Key == Int, Value == String {
+extension Dictionary: LiteralValue, CodeBlockable where Key == Int, Value == String {
   /// The Swift type name for a dictionary mapping integers to strings.
   public var typeName: String { "[Int: String]" }
 
+  /// The code block representation of this dictionary.
+  public var codeBlock: CodeBlock {
+    Literal.dictionary(self.map { (.integer($0.key), .string($0.value)) })
+  }
+
   /// Renders this dictionary as a Swift literal string with proper escaping.
   public var literalString: String {
     let elements = self.map { key, value in

Sources/SyntaxKit/Collections/DictionaryExpr.swift

@@ -30,7 +30,7 @@
 import SwiftSyntax
 
 /// A dictionary expression that can contain both Literal types and CodeBlock types.
-public struct DictionaryExpr: CodeBlock, LiteralValue {
+public struct DictionaryExpr: CodeBlock, LiteralValue, CodeBlockable {
   private let elements: [(DictionaryValue, DictionaryValue)]
 
   /// Creates a dictionary expression with the given key-value pairs.
@@ -39,6 +39,11 @@ public struct DictionaryExpr: CodeBlock, LiteralValue {
     self.elements = elements
   }
 
+  /// The code block representation of this dictionary expression.
+  public var codeBlock: CodeBlock {
+    self
+  }
+
   /// The Swift type name for this dictionary.
   public var typeName: String {
     if elements.isEmpty {

Sources/SyntaxKit/Collections/DictionaryLiteral.swift

@@ -30,7 +30,7 @@
 import Foundation
 
 /// A dictionary literal value that can be used as a literal.
-public struct DictionaryLiteral: LiteralValue {
+public struct DictionaryLiteral: LiteralValue, CodeBlockable {
   public let elements: [(Literal, Literal)]
 
   /// Creates a dictionary with the given key-value pairs.
@@ -39,6 +39,11 @@ public struct DictionaryLiteral: LiteralValue {
     self.elements = elements
   }
 
+  /// The code block representation of this dictionary literal.
+  public var codeBlock: CodeBlock {
+    Literal.dictionary(elements)
+  }
+
   /// The Swift type name for this dictionary.
   public var typeName: String {
     if elements.isEmpty {

Sources/SyntaxKit/Collections/TupleLiteral.swift

@@ -30,7 +30,7 @@
 import Foundation
 
 /// A tuple literal value that can be used as a literal.
-public struct TupleLiteral: LiteralValue {
+public struct TupleLiteral: LiteralValue, CodeBlockable {
   public let elements: [Literal?]
 
   /// Creates a tuple with the given elements.
@@ -39,6 +39,11 @@ public struct TupleLiteral: LiteralValue {
     self.elements = elements
   }
 
+  /// The code block representation of this tuple literal.
+  public var codeBlock: CodeBlock {
+    Literal.tuple(elements)
+  }
+
   /// The Swift type name for this tuple.
   public var typeName: String {
     let elementTypes = elements.map { element in

Sources/SyntaxKit/Declarations/Init.swift

@@ -30,7 +30,7 @@
 import SwiftSyntax
 
 /// An initializer expression.
-public struct Init: CodeBlock, ExprCodeBlock, LiteralValue {
+public struct Init: CodeBlock, ExprCodeBlock, LiteralValue, CodeBlockable {
   private let type: String
   private let parameters: [ParameterExp]
 
@@ -52,6 +52,11 @@ public struct Init: CodeBlock, ExprCodeBlock, LiteralValue {
     self.parameters = try params()
   }
 
+  /// The code block representation of this initializer expression.
+  public var codeBlock: CodeBlock {
+    self
+  }
+
   public var exprSyntax: ExprSyntax {
     var args = parameters
     var trailingClosure: ClosureExprSyntax?

Sources/SyntaxKit/Expressions/Literal.swift

@@ -30,7 +30,7 @@
 import SwiftSyntax
 
 /// A literal value.
-public enum Literal: CodeBlock {
+public enum Literal: CodeBlock, CodeBlockable {
   /// A string literal.
   case string(String)
   /// A floating-point literal.
@@ -50,6 +50,11 @@ public enum Literal: CodeBlock {
   /// A dictionary literal.
   case dictionary([(Literal, Literal)])
 
+  /// The code block representation of this literal.
+  public var codeBlock: CodeBlock {
+    self
+  }
+
   /// The Swift type name for this literal.
   public var typeName: String {
     switch self {

Sources/SyntaxKit/Utilities/CodeBlockable.swift

@@ -0,0 +1,34 @@
+//
+//  CodeBlockable.swift
+//  SyntaxKit
+//
+//  Created by Leo Dion.
+//  Copyright © 2025 BrightDigit.
+//
+//  Permission is hereby granted, free of charge, to any person
+//  obtaining a copy of this software and associated documentation
+//  files (the “Software”), to deal in the Software without
+//  restriction, including without limitation the rights to use,
+//  copy, modify, merge, publish, distribute, sublicense, and/or
+//  sell copies of the Software, and to permit persons to whom the
+//  Software is furnished to do so, subject to the following
+//  conditions:
+//
+//  The above copyright notice and this permission notice shall be
+//  included in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+//  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+//  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+//  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+//  OTHER DEALINGS IN THE SOFTWARE.
+//
+
+/// Can export a `CodeBlock`.
+public protocol CodeBlockable {
+  /// Returns a `CodeBlock`.
+  var codeBlock: CodeBlock { get }
+}

Sources/SyntaxKit/Variables/Variable+LiteralInitializers.swift

@@ -32,53 +32,23 @@ import Foundation
 // MARK: - Variable Literal Initializers
 
 extension Variable {
-  // swiftlint:disable cyclomatic_complexity
   /// Creates a `let` or `var` declaration with a literal value.
   /// - Parameters:
   ///   - kind: The kind of variable, either ``VariableKind/let`` or ``VariableKind/var``.
   ///   - name: The name of the variable.
   ///   - equals: A literal value that conforms to ``LiteralValue``.
-  public init<T: LiteralValue>(
+  public init<T: CodeBlockable & LiteralValue>(
     _ kind: VariableKind, name: String, equals value: T
   ) {
-    let defaultValue: CodeBlock
-    if let literal = value as? Literal {
-      defaultValue = literal
-    } else if let tuple = value as? TupleLiteral {
-      defaultValue = Literal.tuple(tuple.elements)
-    } else if let array = value as? ArrayLiteral {
-      defaultValue = Literal.array(array.elements)
-    } else if let dict = value as? DictionaryLiteral {
-      defaultValue = Literal.dictionary(dict.elements)
-    } else if let array = value as? [String] {
-      defaultValue = Literal.array(array.map { .string($0) })
-    } else if let dict = value as? [Int: String] {
-      defaultValue = Literal.dictionary(dict.map { (.integer($0.key), .string($0.value)) })
-    } else if let dictExpr = value as? DictionaryExpr {
-      defaultValue = dictExpr
-    } else if let initExpr = value as? Init {
-      defaultValue = initExpr
-    } else if let codeBlock = value as? CodeBlock {
-      defaultValue = codeBlock
-    } else {
-      // For any other LiteralValue type that doesn't conform to CodeBlock,
-      // create a fallback or throw an error
-      fatalError(
-        "Variable: Unsupported LiteralValue type that doesn't conform to CodeBlock: \(T.self)"
-      )
-    }
-
     self.init(
       kind: kind,
       name: name,
       type: value.typeName,
-      defaultValue: defaultValue,
+      defaultValue: value.codeBlock,
       explicitType: false
     )
   }
 
-  // swiftlint:enable cyclomatic_complexity
-
   /// Creates a `let` or `var` declaration with a string literal value.
   /// - Parameters:
   ///   - kind: The kind of variable, either ``VariableKind/let`` or ``VariableKind/var``.