added typed throws

leogdion · leogdion · commit 0517bfbffaf9 · 2025-06-21T16:20:21.000-04:00
diff --git a/Examples/Remaining/errors_async/code copy.swift b/Examples/Remaining/errors_async/code copy.swift
@@ -14,34 +14,8 @@ do {
     print("Unexpected error: \(error).")
 }
 
-func nonThrowingFunction() throws(Never) {
-  // ...
-}
-
 func summarize(_ ratings: [Int]) throws(StatisticsError) {
     guard !ratings.isEmpty else { throw .noRatings }
-
-
-    var counts = [1: 0, 2: 0, 3: 0]
-    for rating in ratings {
-        guard rating > 0 && rating <= 3 else { throw .invalidRating(rating) }
-        counts[rating]! += 1
-    }
-
-
-    print("*", counts[1]!, "-- **", counts[2]!, "-- ***", counts[3]!)
-}
-
-let ratings = []
-do throws(StatisticsError) {
-    try summarize(ratings)
-} catch {
-    switch error {
-    case .noRatings:
-        print("No ratings available")
-    case .invalidRating(let rating):
-        print("Invalid rating: \(rating)")
-    }
 }
 
 // MARK: - Task Groups
@@ -76,4 +50,9 @@ Task {
 
 Task { @MainActor [unowned self] in
     _ = try await fetchUserData(id: 1)
+}
+
+
+func nonThrowingFunction() throws(Never) {
+    
 }
diff --git a/Examples/Remaining/errors_async/code.swift b/Examples/Remaining/errors_async/code.swift
@@ -12,4 +12,12 @@ do {
     print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
 } catch {
     print("Unexpected error: \(error).")
-}
+}
+
+func summarize(_ ratings: [Int]) throws(StatisticsError) {
+    guard !ratings.isEmpty else { throw .noRatings }
+}
+
+async let data = fetchUserData(id: 1)
+async let posts = fetchUserPosts(id: 1)
+let (fetchedData, fetchedPosts) = try await (data, posts)
diff --git a/Examples/Remaining/errors_async/dsl.swift b/Examples/Remaining/errors_async/dsl.swift
@@ -1,28 +1,50 @@
-Variable(.var, "vendingMachine", equals: Init("VendingMachine"))
+Variable(.var, name: "vendingMachine", equals: Init("VendingMachine"))
 Assignment("vendingMachine.coinsDeposited", Literal.integer(8))
-Do{
-    Call("buyFavoriteSnack"){
-        ParameterExp("person", Literal.string("Alice"))
-        ParameterExp("vendingMachine", Literal.ref("vendingMachine"))
+Do {
+    Call("buyFavoriteSnack") {
+        ParameterExp(name: "person", value: Literal.string("Alice"))
+        ParameterExp(name: "vendingMachine", value: Literal.ref("vendingMachine"))
     }.throwing()
-    Call("print", Literal.string("Success! Yum."))
+    Call("print") {
+        ParameterExp(unlabeled: Literal.string("Success! Yum."))
     }
-} catch: {
+    } catch: {
     Catch(EnumCase("VendingMachineError.invalidSelection")) {
-        Call("print", Literal.string("Invalid Selection."))
+        Call("print") {
+        ParameterExp(unlabeled: Literal.string("Invalid Selection."))
+        }
     }
     Catch(EnumCase("VendingMachineError.outOfStock")) {
-        Call("print",  Literal.string("Out of Stock."))
+        Call("print") {
+        ParameterExp(unlabeled: Literal.string("Out of Stock."))
+        }
     }
-    Catch(EnumCase("VendingMachineError.insufficientFunds").associatedValue("coinsNeeded", type: "Int")) {
-        Call("print", Literal.string("Insufficient funds. Please insert an additional \\(coinsNeeded) coins."))
+    Catch(
+        EnumCase("VendingMachineError.insufficientFunds").associatedValue(
+        "coinsNeeded", type: "Int")
+    ) {
+        Call("print") {
+        ParameterExp(
+            unlabeled: Literal.string(
+            "Insufficient funds. Please insert an additional \\(coinsNeeded) coins."))
+        }
     }
     Catch {
-        Call("print", Literal.string("Unexpected error: \\(error)."))
+        Call("print") {
+        ParameterExp(unlabeled: Literal.string("Unexpected error: \\(error)."))
+        }
     }
 }
 
-
+Function("summarize") {
+    Parameter(name: "ratings", type: "[Int]")
+} _: {
+    Guard{
+        (VariableExp("ratings").property("isEmpty") as! PropertyAccessExp).not()
+    } else: {
+        Throw(EnumCase("noRatings"))
+    }
+}.throws("StatisticsError")
 
 
 
diff --git a/Examples/Remaining/errors_async/syntax.json b/Examples/Remaining/errors_async/syntax.json
diff --git a/Sources/SyntaxKit/EnumCase.swift b/Sources/SyntaxKit/EnumCase.swift
@@ -90,6 +90,47 @@ public struct EnumCase: CodeBlock {
     self.equals(.float(value))
   }
 
+  /// Returns a SwiftSyntax expression for this enum case (for use in throw/return/etc).
+  public var asExpressionSyntax: ExprSyntax {
+    // Support qualified (Type.case) and unqualified (.case) forms
+    let parts = name.split(separator: ".", maxSplits: 1)
+    let base: ExprSyntax? =
+      parts.count == 2
+      ? ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier(String(parts[0])))) : nil
+    let caseName = parts.count == 2 ? String(parts[1]) : name
+
+    let memberAccess = MemberAccessExprSyntax(
+      base: base,
+      dot: .periodToken(),
+      name: .identifier(caseName)
+    )
+
+    if let associated = associatedValue {
+      // .caseName(associated)
+      let tuple = TupleExprSyntax(
+        leftParen: .leftParenToken(),
+        elements: TupleExprElementListSyntax([
+          TupleExprElementSyntax(
+            label: nil,
+            colon: nil,
+            expression: ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier(associated.name))),
+            trailingComma: nil
+          )
+        ]),
+        rightParen: .rightParenToken()
+      )
+      return ExprSyntax(
+        FunctionCallExprSyntax(
+          calledExpression: ExprSyntax(memberAccess),
+          leftParen: tuple.leftParen,
+          arguments: tuple.elements,
+          rightParen: tuple.rightParen
+        ))
+    } else {
+      return ExprSyntax(memberAccess)
+    }
+  }
+
   public var syntax: SyntaxProtocol {
     let caseKeyword = TokenSyntax.keyword(.case, trailingTrivia: .space)
     let identifier = TokenSyntax.identifier(name, trailingTrivia: .space)
diff --git a/Sources/SyntaxKit/Function+Effects.swift b/Sources/SyntaxKit/Function+Effects.swift
@@ -34,17 +34,25 @@ extension Function {
   internal enum Effect {
     case none
     /// synchronous effect specifier: throws or rethrows
-    case `throws`(isRethrows: Bool)
+    case `throws`(isRethrows: Bool, errorType: String?)
     case async
     /// combined async and throws/rethrows
-    case asyncThrows(isRethrows: Bool)
+    case asyncThrows(isRethrows: Bool, errorType: String?)
   }
 
   /// Marks the function as `throws` or `rethrows`.
   /// - Parameter rethrows: Pass `true` to emit `rethrows` instead of `throws`.
   public func `throws`(isRethrows: Bool = false) -> Self {
     var copy = self
-    copy.effect = .throws(isRethrows: isRethrows)
+    copy.effect = .throws(isRethrows: isRethrows, errorType: nil)
+    return copy
+  }
+
+  /// Marks the function as `throws` with a specific error type.
+  /// - Parameter errorType: The error type to specify in the throws clause.
+  public func `throws`(_ errorType: String) -> Self {
+    var copy = self
+    copy.effect = .throws(isRethrows: false, errorType: errorType)
     return copy
   }
 
@@ -59,7 +67,15 @@ extension Function {
   /// - Parameter rethrows: Pass `true` to emit `async rethrows`.
   public func asyncThrows(isRethrows: Bool = false) -> Self {
     var copy = self
-    copy.effect = .asyncThrows(isRethrows: isRethrows)
+    copy.effect = .asyncThrows(isRethrows: isRethrows, errorType: nil)
+    return copy
+  }
+
+  /// Marks the function as `async throws` with a specific error type.
+  /// - Parameter errorType: The error type to specify in the throws clause.
+  public func asyncThrows(_ errorType: String) -> Self {
+    var copy = self
+    copy.effect = .asyncThrows(isRethrows: false, errorType: errorType)
     return copy
   }
 }
diff --git a/Sources/SyntaxKit/Function+Syntax.swift b/Sources/SyntaxKit/Function+Syntax.swift
@@ -113,23 +113,54 @@ extension Function {
       switch effect {
       case .none:
         return nil
-      case .throws(let isRethrows):
-        return FunctionEffectSpecifiersSyntax(
-          asyncSpecifier: nil,
-          throwsSpecifier: .keyword(
-            isRethrows ? .rethrows : .throws, leadingTrivia: .space, trailingTrivia: .space)
-        )
+      case .throws(let isRethrows, let errorType):
+        let throwsSpecifier: TokenSyntax
+        if let errorType = errorType {
+          throwsSpecifier = .keyword(
+            isRethrows ? .rethrows : .throws, leadingTrivia: .space)
+          return FunctionEffectSpecifiersSyntax(
+            asyncSpecifier: nil,
+            throwsClause: ThrowsClauseSyntax(
+              throwsSpecifier: throwsSpecifier,
+              leftParen: .leftParenToken(),
+              type: IdentifierTypeSyntax(name: .identifier(errorType)),
+              rightParen: .rightParenToken()
+            )
+          )
+        } else {
+          throwsSpecifier = .keyword(
+            isRethrows ? .rethrows : .throws, leadingTrivia: .space)
+          return FunctionEffectSpecifiersSyntax(
+            asyncSpecifier: nil,
+            throwsSpecifier: throwsSpecifier
+          )
+        }
       case .async:
         return FunctionEffectSpecifiersSyntax(
           asyncSpecifier: .keyword(.async, leadingTrivia: .space, trailingTrivia: .space),
           throwsSpecifier: nil
         )
-      case .asyncThrows(let isRethrows):
-        return FunctionEffectSpecifiersSyntax(
-          asyncSpecifier: .keyword(.async, leadingTrivia: .space, trailingTrivia: .space),
-          throwsSpecifier: .keyword(
-            isRethrows ? .rethrows : .throws, leadingTrivia: .space, trailingTrivia: .space)
-        )
+      case .asyncThrows(let isRethrows, let errorType):
+        let throwsSpecifier: TokenSyntax
+        if let errorType = errorType {
+          throwsSpecifier = .keyword(.throws, leadingTrivia: .space)
+          return FunctionEffectSpecifiersSyntax(
+            asyncSpecifier: .keyword(.async, leadingTrivia: .space, trailingTrivia: .space),
+            throwsClause: ThrowsClauseSyntax(
+              throwsSpecifier: throwsSpecifier,
+              leftParen: .leftParenToken(),
+              type: IdentifierTypeSyntax(name: .identifier(errorType)),
+              rightParen: .rightParenToken()
+            )
+          )
+        } else {
+          throwsSpecifier = .keyword(
+            isRethrows ? .rethrows : .throws, leadingTrivia: .space)
+          return FunctionEffectSpecifiersSyntax(
+            asyncSpecifier: .keyword(.async, leadingTrivia: .space, trailingTrivia: .space),
+            throwsSpecifier: throwsSpecifier
+          )
+        }
       }
     }()
 
diff --git a/Sources/SyntaxKit/Function.swift b/Sources/SyntaxKit/Function.swift
@@ -71,4 +71,20 @@ public struct Function: CodeBlock {
     self.returnType = returnType
     self.body = content()
   }
+
+  /// Creates a `func` declaration with parameters and body using the DSL syntax.
+  /// - Parameters:
+  ///   - name: The name of the function.
+  ///   - params: A ``ParameterBuilder`` that provides the parameters of the function.
+  ///   - body: A ``CodeBlockBuilder`` that provides the body of the function.
+  public init(
+    _ name: String,
+    @ParameterBuilderResult _ params: () -> [Parameter],
+    @CodeBlockBuilderResult _ body: () -> [CodeBlock]
+  ) {
+    self.name = name
+    self.parameters = params()
+    self.returnType = nil
+    self.body = body()
+  }
 }
diff --git a/Sources/SyntaxKit/Throw.swift b/Sources/SyntaxKit/Throw.swift
@@ -37,9 +37,14 @@ public struct Throw: CodeBlock {
   }
 
   public var syntax: SyntaxProtocol {
-    let expression =
-      expr.syntax.as(ExprSyntax.self)
-      ?? ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier("")))
+    let expression: ExprSyntax
+    if let enumCase = expr as? EnumCase {
+      expression = enumCase.asExpressionSyntax
+    } else {
+      expression =
+        expr.syntax.as(ExprSyntax.self)
+        ?? ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier("")))
+    }
     return StmtSyntax(
       ThrowStmtSyntax(
         throwKeyword: .keyword(.throw, trailingTrivia: .space),
diff --git a/Sources/SyntaxKit/VariableExp.swift b/Sources/SyntaxKit/VariableExp.swift
@@ -42,7 +42,7 @@ public struct VariableExp: CodeBlock, PatternConvertible {
   /// Accesses a property on the variable.
   /// - Parameter propertyName: The name of the property to access.
   /// - Returns: A ``PropertyAccessExp`` that represents the property access.
-  public func property(_ propertyName: String) -> CodeBlock {
+  public func property(_ propertyName: String) -> PropertyAccessExp {
     PropertyAccessExp(baseName: name, propertyName: propertyName)
   }
 
@@ -87,6 +87,12 @@ public struct PropertyAccessExp: CodeBlock {
     self.propertyName = propertyName
   }
 
+  /// Negates the property access expression.
+  /// - Returns: A negated property access expression.
+  public func not() -> CodeBlock {
+    NegatedPropertyAccessExp(baseName: baseName, propertyName: propertyName)
+  }
+
   public var syntax: SyntaxProtocol {
     let base = ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier(baseName)))
     let property = TokenSyntax.identifier(propertyName)
@@ -99,6 +105,38 @@ public struct PropertyAccessExp: CodeBlock {
   }
 }
 
+/// An expression that negates a property access.
+public struct NegatedPropertyAccessExp: CodeBlock {
+  internal let baseName: String
+  internal let propertyName: String
+
+  /// Creates a negated property access expression.
+  /// - Parameters:
+  ///  - baseName: The name of the base variable.
+  ///  - propertyName: The name of the property to access.
+  public init(baseName: String, propertyName: String) {
+    self.baseName = baseName
+    self.propertyName = propertyName
+  }
+
+  public var syntax: SyntaxProtocol {
+    let base = ExprSyntax(DeclReferenceExprSyntax(baseName: .identifier(baseName)))
+    let property = TokenSyntax.identifier(propertyName)
+    let memberAccess = ExprSyntax(
+      MemberAccessExprSyntax(
+        base: base,
+        dot: .periodToken(),
+        name: property
+      ))
+    return ExprSyntax(
+      PrefixOperatorExprSyntax(
+        operator: .prefixOperator("!", leadingTrivia: [], trailingTrivia: []),
+        expression: memberAccess
+      )
+    )
+  }
+}
+
 /// An expression that calls a function.
 public struct FunctionCallExp: CodeBlock {
   internal let baseName: String
diff --git a/Tests/SyntaxKitTests/Unit/ErrorHandlingTests.swift b/Tests/SyntaxKitTests/Unit/ErrorHandlingTests.swift
