Macro fixes for release/archive builds and Swift 6.2 (#71)

* Add member macro attribute.

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* clean up

* clean up

* clean up

* wip

---------

Co-authored-by: Stephen Celis <[email protected]>

Author: mbrandonw

.gitignore

@@ -7,4 +7,4 @@ DerivedData/
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
 Package.resolved
-db.sqlite
+*.sqlite

Sources/StructuredQueries/Macros.swift

@@ -9,22 +9,19 @@ import StructuredQueriesCore
   conformances: Table,
   PartialSelectStatement,
   PrimaryKeyedTable,
-  names: named(TableColumns),
-  named(From),
-  named(Draft),
+  names: named(From),
   named(columns),
   named(init(_:)),
   named(init(decoder:)),
   named(QueryValue),
   named(schemaName),
   named(tableName)
 )
-@attached(
-  memberAttribute
-)
+@attached(member, names: named(Draft), named(TableColumns))
+@attached(memberAttribute)
 public macro Table(
-  _ name: String? = nil,
-  schema schemaName: String? = nil
+  _ name: String = "",
+  schema schemaName: String = ""
 ) =
   #externalMacro(
     module: "StructuredQueriesMacros",
@@ -38,9 +35,9 @@ public macro Table(
 ///   - representableType: A type that represents the property type in a query expression. For types
 ///     that don't have a single representation in SQL, like `Date` and `UUID`.
 ///   - primaryKey: The column is its table's auto-incrementing primary key.
-@attached(accessor, names: named(willSet))
+@attached(peer)
 public macro Column(
-  _ name: String? = nil,
+  _ name: String = "",
   as representableType: (any QueryRepresentable.Type)? = nil,
   primaryKey: Bool = false
 ) =
@@ -52,7 +49,7 @@ public macro Column(
 /// Tells Structured Queries not to consider the annotated property a column of the table
 ///
 /// Like SwiftData's `@Transient` macro, but for SQL.
-@attached(accessor, names: named(willSet))
+@attached(peer)
 public macro Ephemeral() =
   #externalMacro(
     module: "StructuredQueriesMacros",
@@ -95,6 +92,7 @@ public macro Ephemeral() =
   names: named(Columns),
   named(init(decoder:))
 )
+@attached(member, names: named(Columns))
 public macro Selection() =
   #externalMacro(
     module: "StructuredQueriesMacros",
@@ -134,22 +132,3 @@ public macro sql<QueryValue>(
   as queryValueType: QueryValue.Type = QueryValue.self
 ) -> SQLQueryExpression<QueryValue> =
   #externalMacro(module: "StructuredQueriesMacros", type: "SQLMacro")
-
-// NB: Due to a bug in Swift, this macro is expanded internally by the '@Table' macro.
-// @attached(
-//   memberAttribute
-// )
-// @attached(
-//   extension,
-//   conformances: Table,
-//   names: named(TableColumns),
-//   named(columns),
-//   named(init(_:)),
-//   named(init(decoder:)),
-//   named(tableName)
-// )
-// public macro _Draft<T: Table>(_: T.Type) =
-//   #externalMacro(
-//     module: "StructuredQueriesMacros",
-//     type: "TableMacro"
-//   )

Sources/StructuredQueriesCore/Optional.swift

@@ -1,12 +1,14 @@
 public protocol _OptionalProtocol<Wrapped> {
   associatedtype Wrapped
   var _wrapped: Wrapped? { get }
-  static var none: Self { get }
-  static func some(_ wrapped: Wrapped) -> Self
+  static var _none: Self { get }
+  static func _some(_ wrapped: Wrapped) -> Self
 }
 
 extension Optional: _OptionalProtocol {
   public var _wrapped: Wrapped? { self }
+  public static var _none: Self { .none }
+  public static func _some(_ wrapped: Wrapped) -> Self { .some(wrapped) }
 }
 
 public protocol _OptionalPromotable<_Optionalized> {

Sources/StructuredQueriesCore/Statements/Insert.swift

@@ -458,7 +458,7 @@ extension Table {
       conflictTargetColumnNames: conflictTargetColumnNames,
       conflictTargetFilter: targetFilter(Self.columns),
       values: values,
-      updates: updates.map(Updates.init),
+      updates: updates.map { Updates($0) },
       updateFilter: updateFilter(Self.columns),
       returning: []
     )

Sources/StructuredQueriesMacros/ColumnMacro.swift

@@ -1,15 +1,12 @@
 import SwiftSyntax
 import SwiftSyntaxMacros
 
-public enum ColumnMacro: AccessorMacro {
-  public static func expansion<
-    Context: MacroExpansionContext,
-    Declaration: DeclSyntaxProtocol
-  >(
+public enum ColumnMacro: PeerMacro {
+  public static func expansion<D: DeclSyntaxProtocol, C: MacroExpansionContext>(
     of node: AttributeSyntax,
-    providingAccessorsOf declaration: Declaration,
-    in context: Context
-  ) throws -> [AccessorDeclSyntax] {
-    return []
+    providingPeersOf declaration: D,
+    in context: C
+  ) throws -> [DeclSyntax] {
+    []
   }
 }

Sources/StructuredQueriesMacros/EphemeralMacro.swift

@@ -1,15 +1,12 @@
 import SwiftSyntax
 import SwiftSyntaxMacros
 
-public enum EphemeralMacro: AccessorMacro {
-  public static func expansion<
-    Context: MacroExpansionContext,
-    Declaration: DeclSyntaxProtocol
-  >(
+public enum EphemeralMacro: PeerMacro {
+  public static func expansion<D: DeclSyntaxProtocol, C: MacroExpansionContext>(
     of node: AttributeSyntax,
-    providingAccessorsOf declaration: Declaration,
-    in context: Context
-  ) throws -> [AccessorDeclSyntax] {
-    return []
+    providingPeersOf declaration: D,
+    in context: C
+  ) throws -> [DeclSyntax] {
+    []
   }
 }

Sources/StructuredQueriesMacros/SelectionMacro.swift

@@ -157,7 +157,6 @@ extension SelectionMacro: ExtensionMacro {
 
     var conformances: [TypeSyntax] = []
     let protocolNames: [TokenSyntax] = ["QueryRepresentable"]
-    let schemaConformances: [ExprSyntax] = ["\(moduleName).QueryExpression"]
     if let inheritanceClause = declaration.inheritanceClause {
       for type in protocolNames {
         if !inheritanceClause.inheritedTypes.contains(where: {
@@ -175,16 +174,7 @@ extension SelectionMacro: ExtensionMacro {
       return []
     }
 
-    let initArguments =
-      allColumns
-      .map { "\($0): some \(moduleName).QueryExpression\($1.map { "<\($0)>" } ?? "")" }
-      .joined(separator: ",\n")
-    let initAssignment: [String] =
-      allColumns
-      .map { #"\(\#($0.name).queryFragment) AS \#($0.name.text.quoted())"# }
-
     let initDecoder: DeclSyntax = """
-
       public init(decoder: inout some \(moduleName).QueryDecoder) throws {
       \(raw: (decodings + decodingUnwrappings + decodingAssignments).joined(separator: "\n"))
       }
@@ -194,17 +184,7 @@ extension SelectionMacro: ExtensionMacro {
         """
         \(declaration.attributes.availability)extension \(type)\
         \(conformances.isEmpty ? "" : ": \(conformances, separator: ", ")") {
-        public struct Columns: \(schemaConformances, separator: ", ") {
-        public typealias QueryValue = \(type.trimmed)
-        public let queryFragment: \(moduleName).QueryFragment
-        public init(
-        \(raw: initArguments)
-        ) {
-        self.queryFragment = \"\"\"
-        \(raw: initAssignment.joined(separator: ", "))
-        \"\"\"
-        }
-        }\(initDecoder)
+        \(initDecoder)
         }
         """
       )
@@ -213,6 +193,158 @@ extension SelectionMacro: ExtensionMacro {
   }
 }
 
+extension SelectionMacro: MemberMacro {
+  public static func expansion<D: DeclGroupSyntax, C: MacroExpansionContext>(
+    of node: AttributeSyntax,
+    providingMembersOf declaration: D,
+    conformingTo protocols: [TypeSyntax],
+    in context: C
+  ) throws -> [DeclSyntax] {
+    guard
+      let declaration = declaration.as(StructDeclSyntax.self)
+    else {
+      return []
+    }
+    let type = IdentifierTypeSyntax(name: declaration.name.trimmed)
+    var allColumns: [(name: TokenSyntax, type: TypeSyntax?)] = []
+    var decodings: [String] = []
+    var decodingUnwrappings: [String] = []
+    var decodingAssignments: [String] = []
+    var expansionFailed = false
+
+    let selfRewriter = SelfRewriter(selfEquivalent: type.name)
+    for member in declaration.memberBlock.members {
+      guard
+        let property = member.decl.as(VariableDeclSyntax.self),
+        !property.isStatic,
+        !property.isComputed,
+        property.bindings.count == 1,
+        let binding = property.bindings.first,
+        let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier.trimmed
+      else { continue }
+
+      var columnQueryValueType =
+        (binding.typeAnnotation?.type.trimmed
+        ?? binding.initializer?.value.literalType)
+        .map { selfRewriter.rewrite($0).cast(TypeSyntax.self) }
+
+      for attribute in property.attributes {
+        guard
+          let attribute = attribute.as(AttributeSyntax.self),
+          let attributeName = attribute.attributeName.as(IdentifierTypeSyntax.self)?.name.text,
+          attributeName == "Column",
+          case .argumentList(let arguments) = attribute.arguments
+        else { continue }
+
+        for argumentIndex in arguments.indices {
+          let argument = arguments[argumentIndex]
+
+          switch argument.label {
+          case nil:
+            var newArguments = arguments
+            newArguments.remove(at: argumentIndex)
+            expansionFailed = true
+
+          case .some(let label) where label.text == "as":
+            guard
+              let memberAccess = argument.expression.as(MemberAccessExprSyntax.self),
+              memberAccess.declName.baseName.tokenKind == .keyword(.self),
+              let base = memberAccess.base
+            else {
+              expansionFailed = true
+              continue
+            }
+
+            columnQueryValueType = "\(raw: base.trimmedDescription)"
+
+          case .some(let label) where label.text == "primaryKey":
+            var newArguments = arguments
+            newArguments.remove(at: argumentIndex)
+            expansionFailed = true
+
+          case let argument?:
+            fatalError("Unexpected argument: \(argument)")
+          }
+        }
+      }
+
+      var assignedType: String? {
+        binding
+          .initializer?
+          .value
+          .as(FunctionCallExprSyntax.self)?
+          .calledExpression
+          .as(DeclReferenceExprSyntax.self)?
+          .baseName
+          .text
+      }
+
+      allColumns.append((identifier, columnQueryValueType))
+      let decodedType = columnQueryValueType?.asNonOptionalType()
+      decodings.append(
+        """
+        let \(identifier) = try decoder.decode(\(decodedType.map { "\($0).self" } ?? ""))
+        """
+      )
+      if columnQueryValueType.map({ !$0.isOptionalType }) ?? true {
+        decodingUnwrappings.append(
+          """
+          guard let \(identifier) else { throw QueryDecodingError.missingRequiredColumn }
+          """
+        )
+      }
+      decodingAssignments.append(
+        """
+        self.\(identifier) = \(identifier)
+        """
+      )
+    }
+
+    var conformances: [TypeSyntax] = []
+    let protocolNames: [TokenSyntax] = ["QueryRepresentable"]
+    let schemaConformances: [ExprSyntax] = ["\(moduleName).QueryExpression"]
+    if let inheritanceClause = declaration.inheritanceClause {
+      for type in protocolNames {
+        if !inheritanceClause.inheritedTypes.contains(where: {
+          [type.text, "\(moduleName).\(type)"].contains($0.type.trimmedDescription)
+        }) {
+          conformances.append("\(moduleName).\(type)")
+        }
+      }
+    } else {
+      conformances = protocolNames.map { "\(moduleName).\($0)" }
+    }
+
+    guard !expansionFailed else {
+      return []
+    }
+
+    let initArguments =
+      allColumns
+      .map { "\($0): some \(moduleName).QueryExpression\($1.map { "<\($0)>" } ?? "")" }
+      .joined(separator: ",\n")
+    let initAssignment: [String] =
+      allColumns
+      .map { #"\(\#($0.name).queryFragment) AS \#($0.name.text.quoted())"# }
+
+    return [
+      """
+      public struct Columns: \(schemaConformances, separator: ", ") {
+      public typealias QueryValue = \(type.trimmed)
+      public let queryFragment: \(moduleName).QueryFragment
+      public init(
+      \(raw: initArguments)
+      ) {
+      self.queryFragment = \"\"\"
+      \(raw: initAssignment.joined(separator: ", "))
+      \"\"\"
+      }
+      }
+      """
+    ]
+  }
+}
+
 extension SelectionMacro: MemberAttributeMacro {
   public static func expansion<D: DeclGroupSyntax, T: DeclSyntaxProtocol, C: MacroExpansionContext>(
     of node: AttributeSyntax,