Allow all types of returns

Author: wickwirew

README.md

@@ -79,7 +79,7 @@ Otter can even run within a Swift macro by adding the `@Database` macro to a `st
 @Database
 struct DB {
     @Query("SELECT * FROM foo")
-    var selectFooQuery: SelectFooDatabaseQuery
+    var selectFooQuery: any SelectFooQuery
 
     static var migrations: [String] {
         return [
@@ -111,7 +111,6 @@ that won't scale well beyond a fairly simple schema and a handfull of queries.
 #### Current Limitations
 * Since macros operate purely on the syntax, all queries must be within the `@Database` itself so it has access to the schema.
 * All generated types will be nested under the `@Database` struct.
-* All `@Query` definitions must define their type as the generated `typealias` by the `@Database` macro.
 * Any diagnostics will be on the entire string rather than the part that actually failed.
 
 # Installation

Sources/OtterMacros/Syntax+Extensions.swift

@@ -72,36 +72,38 @@ extension VariableDeclSyntax {
         return nil
     }
 
-    var getter: CodeBlockItemListSyntax? {
+    func asMigrationsArray(in context: some MacroExpansionContext) -> [(String, ExprSyntax)] {
         for binding in bindings {
-            guard let accessorBlock = binding.accessorBlock,
-                  // TODO: Handle explicit `get {}`, seems different than the `.getter`
-                  case let .getter(getter) = accessorBlock.accessors else { return nil }
-            return getter
+            if let accessorBlock = binding.accessorBlock,
+                  case let .getter(getter) = accessorBlock.accessors {
+                // Has a getter block `{ return [] }`
+                guard let stmt = getter.last?.item, getter.count == 1 else {
+                    context.addDiagnostics(from: SyntaxError("Migrations must have one statement returning [String]"), node: self)
+                    return []
+                }
+                
+                if let ret = stmt.as(ReturnStmtSyntax.self), let expr = ret.expression {
+                    return getMigrationsArray(expr: expr, in: context)
+                } else if let expr = stmt.as(ExprSyntax.self) {
+                    return getMigrationsArray(expr: expr, in: context)
+                } else {
+                    context.addDiagnostics(from: SyntaxError("Must be return statement"), node: self)
+                    return []
+                }
+            } else if let initializer = binding.initializer {
+                // Set with a value `ident = value`
+                return getMigrationsArray(expr: initializer.value, in: context)
+            }
         }
 
-        return nil
+        context.addDiagnostics(from: SyntaxError("Must have a getter that returns [String]"), node: self)
+        return []
     }
 
-    func asMigrationsArray(in context: some MacroExpansionContext) -> [(String, ExprSyntax)] {
+    func getMigrationsArray(expr: ExprSyntax, in context: some MacroExpansionContext) -> [(String, ExprSyntax)] {
         var strings: [(String, ExprSyntax)] = []
 
-        guard let getter else {
-            context.addDiagnostics(from: SyntaxError("Must have a getter that returns [String]"), node: self)
-            return strings
-        }
-        
-        guard let stmt = getter.last?.item, getter.count == 1 else {
-            context.addDiagnostics(from: SyntaxError("Migrations must have one statement returning [String]"), node: self)
-            return strings
-        }
-        
-        guard let ret = stmt.as(ReturnStmtSyntax.self) else {
-            context.addDiagnostics(from: SyntaxError("Must be return statement"), node: self)
-            return strings
-        }
-        
-        guard let array = ret.expression?.as(ArrayExprSyntax.self) else {
+        guard let array = expr.as(ArrayExprSyntax.self) else {
             context.addDiagnostics(from: SyntaxError("Migrations must return an array literal"), node: self)
             return strings
         }

Tests/OtterTests/SQLAnyTests.swift

@@ -48,8 +48,6 @@ struct SQLAnyTests {
         @Query("SELECT * FROM foo")
         var selectFoos: any SelectFoosQuery
 
-        static var migrations: [String] {
-            return ["CREATE TABLE foo (bar ANY);"]
-        }
+        static let migrations: [String] = ["CREATE TABLE foo (bar ANY);"]
     }
 }