Renamed coder to adapter

Author: wickwirew

Sources/Compiler/Gen/Language.swift

@@ -14,7 +14,7 @@ public protocol Language {
 
     var boolName: String { get }
 
-    var builtinCoders: Set<String> { get }
+    var builtinAdapters: Set<String> { get }
 
     func queryTypeName(input: String, output: String) -> String
 
@@ -27,7 +27,7 @@ public protocol Language {
         migrations: [String],
         tables: [GeneratedModel],
         queries: [(String?, [GeneratedQuery])],
-        coders: [String]
+        adapters: [String]
     ) throws -> String
 
     /// Function to generate a interpolation segment in a string
@@ -49,20 +49,20 @@ extension Language {
     ) throws -> String {
         let values = try assemble(queries: queries, schema: schema)
 
-        // Get a list of all coders used. Right now we only have to look at the
+        // Get a list of all adapters used. Right now we only have to look at the
         // tables since any output would inhereit the encoding of the source table.
-        let coders: Set<String> = values.tables.reduce(into: []) { coders, table in
+        let adapters: Set<String> = values.tables.reduce(into: []) { adapters, table in
             for field in table.fields.values {
-                guard let coder = field.type.coder else { continue }
-                coders.insert(coder)
+                guard let adapter = field.type.adapter else { continue }
+                adapters.insert(adapter)
             }
         }
 
         return try file(
             migrations: migrations,
             tables: values.tables,
             queries: values.queries,
-            coders: coders.subtracting(builtinCoders).sorted()
+            adapters: adapters.subtracting(builtinAdapters).sorted()
         )
     }
 
@@ -145,8 +145,8 @@ extension Language {
             result.append(.arrayStart(name: "input", elementName: "element"))
             result.append(contentsOf: bindings(for: values, index: &index, owner: "element"))
             result.append(.arrayEnd)
-        case .encoded(_, _, let coder):
-            result.append(.value(index: index, name: "input", owner: owner, coder: coder))
+        case .encoded(_, _, let adapter):
+            result.append(.value(index: index, name: "input", owner: owner, adapter: adapter))
             index += 1
         }
 
@@ -174,7 +174,7 @@ extension Language {
         switch type {
         case let .nominal(name):
             return .builtin(builtinType(named: name))
-        case let .alias(root, alias, coder):
+        case let .alias(root, alias, adapter):
             let alias = switch alias {
             case .explicit(let e): e.description
             case .hint(let hint):
@@ -186,7 +186,7 @@ extension Language {
             return .encoded(
                 generationType(for: root),
                 alias: alias,
-                coder: "\(coder?.description ?? alias)DatabaseValueCoder"
+                adapter: "\(adapter?.description ?? alias)DatabaseValueAdapter"
             )
         case let .optional(type):
             return .optional(generationType(for: type))
@@ -342,7 +342,7 @@ public struct GeneratedQuery {
     let bindings: [Binding]
 
     public enum Binding {
-        case value(index: Int, name: String, owner: String? = nil, coder: String? = nil)
+        case value(index: Int, name: String, owner: String? = nil, adapter: String? = nil)
         case arrayStart(name: String, elementName: String)
         case arrayEnd
     }
@@ -354,7 +354,7 @@ public enum GenerationType: Equatable {
     case model(GeneratedModel)
     indirect case optional(Self)
     indirect case array(Self)
-    indirect case encoded(Self, alias: String, coder: String)
+    indirect case encoded(Self, alias: String, adapter: String)
 
     var model: GeneratedModel? {
         switch self {
@@ -366,12 +366,12 @@ public enum GenerationType: Equatable {
         }
     }
 
-    var coder: String? {
+    var adapter: String? {
         switch self {
         case .void, .builtin, .model: nil
-        case .optional(let optional): optional.coder
-        case .array(let array): array.coder
-        case .encoded(_, _, let coder): coder
+        case .optional(let optional): optional.adapter
+        case .array(let array): array.adapter
+        case .encoded(_, _, let adapter): adapter
         }
     }
 }

Sources/Compiler/Gen/SwiftLanguage.swift

@@ -15,23 +15,23 @@ public struct SwiftLanguage: Language {
 
     public var boolName: String { "Bool" }
 
-    public var builtinCoders: Set<String> {
+    public var builtinAdapters: Set<String> {
         [
-            "BoolDatabaseValueCoder",
-            "Int8DatabaseValueCoder",
-            "Int16DatabaseValueCoder",
-            "Int32DatabaseValueCoder",
-            "Int64DatabaseValueCoder",
-            "UInt8DatabaseValueCoder",
-            "UInt16DatabaseValueCoder",
-            "UInt32DatabaseValueCoder",
-            "UInt64DatabaseValueCoder",
-            "UIntDatabaseValueCoder",
-            "FloatDatabaseValueCoder",
-            "Float16DatabaseValueCoder",
-            "UUIDDatabaseValueCoder",
-            "DecimalDatabaseValueCoder",
-            "DateDatabaseValueCoder",
+            "BoolDatabaseValueAdapter",
+            "Int8DatabaseValueAdapter",
+            "Int16DatabaseValueAdapter",
+            "Int32DatabaseValueAdapter",
+            "Int64DatabaseValueAdapter",
+            "UInt8DatabaseValueAdapter",
+            "UInt16DatabaseValueAdapter",
+            "UInt32DatabaseValueAdapter",
+            "UInt64DatabaseValueAdapter",
+            "UIntDatabaseValueAdapter",
+            "FloatDatabaseValueAdapter",
+            "Float16DatabaseValueAdapter",
+            "UUIDDatabaseValueAdapter",
+            "DecimalDatabaseValueAdapter",
+            "DateDatabaseValueAdapter",
         ]
     }
 
@@ -72,9 +72,9 @@ public struct SwiftLanguage: Language {
         migrations: [String],
         tables: [GeneratedModel],
         queries: [(String?, [GeneratedQuery])],
-        coders: [String]
+        adapters: [String]
     ) throws -> String {
-        // Note: For now just going to ignore the `coders`
+        // Note: For now just going to ignore the `adapters`
         // Kotlin will need that info which is why it exists.
         // Swift having less finegrained namespaces makes it
         // so it can just do module level lookups for the type.
@@ -496,10 +496,10 @@ public struct SwiftLanguage: Language {
                 writer.write("row.embedded(at: start + ", index.description, ")")
             case .optional(.model):
                 writer.write("row.optionallyEmbedded(at: start + ", index.description, ")")
-            case let .encoded(_, _, coder):
-                writer.write("row.value(at: start + ", index.description, ", using: ", coder, ".self)")
-            case let .optional(.encoded(_, _, coder)):
-                writer.write("row.optionalValue(at: start + ", index.description, ", using: ", coder, ".self)")
+            case let .encoded(_, _, adapter):
+                writer.write("row.value(at: start + ", index.description, ", using: ", adapter, ".self)")
+            case let .optional(.encoded(_, _, adapter)):
+                writer.write("row.optionalValue(at: start + ", index.description, ", using: ", adapter, ".self)")
             default:
                 fatalError("Invalid field type \(field.typeName) \(field.type)")
             }
@@ -639,7 +639,7 @@ public struct SwiftLanguage: Language {
 
     private func bind(binding: GeneratedQuery.Binding) {
         switch binding {
-        case let .value(index, name, owner, coder):
+        case let .value(index, name, owner, adapter):
             writer.write(line: "try statement.bind(value: ")
 
             if let owner {
@@ -648,8 +648,8 @@ public struct SwiftLanguage: Language {
 
             writer.write(name, ", to: ", index.description)
 
-            if let coder {
-                writer.write(", using: ", coder, ".self")
+            if let adapter {
+                writer.write(", using: ", adapter, ".self")
             }
 
             writer.write(")")

Sources/Compiler/Sema/InferenceState.swift

@@ -123,7 +123,7 @@ struct InferenceState {
         for type: Type,
         at location: SourceLocation
     ) {
-        unify(type, with: .alias(type, .hint(hint), coder: nil), at: location)
+        unify(type, with: .alias(type, .hint(hint), adapter: nil), at: location)
     }
 
     /// Gets the final type from the solution for the type if its a ty var.
@@ -141,8 +141,8 @@ struct InferenceState {
             return tv.defaultType
         case let .optional(ty):
             return .optional(solution(for: ty, defaultIfTyVar: true))
-        case let .alias(ty, alias, coder):
-            return .alias(solution(for: ty, defaultIfTyVar: true), alias, coder: coder)
+        case let .alias(ty, alias, adapter):
+            return .alias(solution(for: ty, defaultIfTyVar: true), alias, adapter: adapter)
         case let .row(row):
             if let type = row.first, row.count == 1, !row.isUnknown {
                 return solution(for: type, defaultIfTyVar: true)

Sources/Compiler/Sema/StmtTypeChecker.swift

@@ -1304,7 +1304,7 @@ extension StmtTypeChecker {
         let nominal: Type = .nominal(column.type.name.value)
 
         let type: Type = if let alias = column.type.alias {
-            .alias(nominal, .explicit(alias.name.identifier.value), coder: alias.using?.value)
+            .alias(nominal, .explicit(alias.name.identifier.value), adapter: alias.using?.value)
         } else {
             nominal
         }

Sources/Compiler/Sema/Type.swift

@@ -24,7 +24,7 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
     /// A type that has been aliased. These are not in SQL by default
     /// but are from the layer on top that we are adding so a user
     /// can replace a `INTEGER` with a `Bool`
-    indirect case alias(Type, Alias, coder: Substring?)
+    indirect case alias(Type, Alias, adapter: Substring?)
     /// There was an error somewhere in the analysis. We can just return
     /// an `error` type and continue the analysis. So if the user makes up
     /// 3 columns, they can get all 3 errors at once.
@@ -43,7 +43,7 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
     static let real: Type = .nominal("REAL")
     static let blob: Type = .nominal("BLOB")
     static let any: Type = .nominal("ANY")
-    static let boolean: Type = .alias(.integer, .hint(.bool), coder: nil)
+    static let boolean: Type = .alias(.integer, .hint(.bool), adapter: nil)
 
     static let validTypeNames: Set<Substring> = [
         "TEXT", "INT", "INTEGER", "REAL", "BLOB", "ANY",
@@ -166,7 +166,7 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
         case let .optional(ty):
             return .optional(ty.apply(s))
         case let .alias(t, a, c):
-            return .alias(t.apply(s), a, coder: c)
+            return .alias(t.apply(s), a, adapter: c)
         case .nominal, .error:
             // Literals can't be substituted for.
             return self

Sources/Otter/Cursor.swift

@@ -37,24 +37,24 @@ public struct Row: ~Copyable {
     }
 
     /// Decodes the column at the index as the `Storage.Value` type
-    @inlinable public func value<Storage: DatabasePrimitive, Coder: DatabaseValueCoder>(
+    @inlinable public func value<Storage: DatabasePrimitive, Coder: DatabaseValueAdapter>(
         at column: Int32,
-        using coder: Coder.Type,
+        using adapter: Coder.Type,
         storage: Storage
     ) throws(OtterError) -> Coder.Value {
         let storage = try Storage(from: sqliteStatement, at: column)
-        return try storage.decode(from: coder)
+        return try storage.decode(from: adapter)
     }
 
     /// Decodes the column at the index as the `Storage.Value` type
     /// if it has a value.
-    @inlinable public func optionalValue<Storage: DatabasePrimitive, Coder: DatabaseValueCoder>(
+    @inlinable public func optionalValue<Storage: DatabasePrimitive, Coder: DatabaseValueAdapter>(
         at column: Int32,
-        using coder: Coder.Type,
+        using adapter: Coder.Type,
         storage: Storage
     ) throws(OtterError) -> Coder.Value? {
         guard let storage = try Storage?(from: sqliteStatement, at: column) else { return  nil}
-        return try storage.decode(from: coder)
+        return try storage.decode(from: adapter)
     }
 
     /// Decodes the struct embeeded at the start index as the `Value` type.