Use shorthand optional binding

jberkel · jberkel · commit ab3c598db29a · 2023-05-21T23:59:35.000+02:00
diff --git a/.swiftlint.yml b/.swiftlint.yml
@@ -1,3 +1,5 @@
+opt_in_rules:
+  - shorthand_optional_binding
 disabled_rules: # rule identifiers to exclude from running
   - todo
   - operator_whitespace
diff --git a/Sources/SQLite/Core/Connection+Attach.swift b/Sources/SQLite/Core/Connection+Attach.swift
@@ -13,7 +13,7 @@ extension Connection {
     #if SQLITE_SWIFT_SQLCIPHER
     /// See https://www.zetetic.net/sqlcipher/sqlcipher-api/#attach
     public func attach(_ location: Location, as schemaName: String, key: String? = nil) throws {
-        if let key = key {
+        if let key {
             try run("ATTACH DATABASE ? AS ? KEY ?", location.description, schemaName, key)
         } else {
             try run("ATTACH DATABASE ? AS ?", location.description, schemaName)
diff --git a/Sources/SQLite/Core/Connection.swift b/Sources/SQLite/Core/Connection.swift
@@ -414,7 +414,7 @@ public final class Connection {
     ///   times it’s been called for this lock. If it returns `true`, it will
     ///   try again. If it returns `false`, no further attempts will be made.
     public func busyHandler(_ callback: ((_ tries: Int) -> Bool)?) {
-        guard let callback = callback else {
+        guard let callback else {
             sqlite3_busy_handler(handle, nil, nil)
             busyHandler = nil
             return
@@ -449,7 +449,7 @@ public final class Connection {
     @available(watchOS, deprecated: 3.0)
     @available(tvOS, deprecated: 10.0)
     fileprivate func trace_v1(_ callback: ((String) -> Void)?) {
-        guard let callback = callback else {
+        guard let callback else {
             sqlite3_trace(handle, nil /* xCallback */, nil /* pCtx */)
             trace = nil
             return
@@ -458,7 +458,7 @@ public final class Connection {
             callback(String(cString: pointer.assumingMemoryBound(to: UInt8.self)))
         }
         sqlite3_trace(handle, { (context: UnsafeMutableRawPointer?, SQL: UnsafePointer<Int8>?) in
-                    if let context = context, let SQL = SQL {
+                    if let context, let SQL {
                         unsafeBitCast(context, to: Trace.self)(SQL)
                     }
             },
@@ -469,7 +469,7 @@ public final class Connection {
 
     @available(iOS 10.0, OSX 10.12, tvOS 10.0, watchOS 3.0, *)
     fileprivate func trace_v2(_ callback: ((String) -> Void)?) {
-        guard let callback = callback else {
+        guard let callback else {
             // If the X callback is NULL or if the M mask is zero, then tracing is disabled.
             sqlite3_trace_v2(handle, 0 /* mask */, nil /* xCallback */, nil /* pCtx */)
             trace = nil
@@ -485,7 +485,7 @@ public final class Connection {
                  // callback was invoked. The C argument is a copy of the context pointer.
                  // The P and X arguments are pointers whose meanings depend on T.
                  (_: UInt32, context: UnsafeMutableRawPointer?, pointer: UnsafeMutableRawPointer?, _: UnsafeMutableRawPointer?) in
-                 if let pointer = pointer,
+                 if let pointer,
                     let expandedSQL = sqlite3_expanded_sql(OpaquePointer(pointer)) {
                      unsafeBitCast(context, to: Trace.self)(expandedSQL)
                      sqlite3_free(expandedSQL)
@@ -507,7 +507,7 @@ public final class Connection {
     ///   `.Insert`, `.Update`, or `.Delete`), database name, table name, and
     ///   rowid.
     public func updateHook(_ callback: ((_ operation: Operation, _ db: String, _ table: String, _ rowid: Int64) -> Void)?) {
-        guard let callback = callback else {
+        guard let callback else {
             sqlite3_update_hook(handle, nil, nil)
             updateHook = nil
             return
@@ -535,7 +535,7 @@ public final class Connection {
     ///   committed. If this callback throws, the transaction will be rolled
     ///   back.
     public func commitHook(_ callback: (() throws -> Void)?) {
-        guard let callback = callback else {
+        guard let callback else {
             sqlite3_commit_hook(handle, nil, nil)
             commitHook = nil
             return
@@ -562,7 +562,7 @@ public final class Connection {
     /// - Parameter callback: A callback invoked when a transaction is rolled
     ///   back.
     public func rollbackHook(_ callback: (() -> Void)?) {
-        guard let callback = callback else {
+        guard let callback else {
             sqlite3_rollback_hook(handle, nil, nil)
             rollbackHook = nil
             return
@@ -650,7 +650,7 @@ public final class Connection {
         try check(sqlite3_create_collation_v2(handle, collation, SQLITE_UTF8,
             unsafeBitCast(box, to: UnsafeMutableRawPointer.self), { (callback: UnsafeMutableRawPointer?, _,
                                                                      lhs: UnsafeRawPointer?, _, rhs: UnsafeRawPointer?) in /* xCompare */
-            if let lhs = lhs, let rhs = rhs {
+            if let lhs, let rhs {
                 return unsafeBitCast(callback, to: Collation.self)(lhs, rhs)
             } else {
                 fatalError("sqlite3_create_collation_v2 callback called with NULL pointer")
diff --git a/Sources/SQLite/Core/Result.swift b/Sources/SQLite/Core/Result.swift
@@ -51,13 +51,13 @@ extension Result: CustomStringConvertible {
     public var description: String {
         switch self {
         case let .error(message, errorCode, statement):
-            if let statement = statement {
+            if let statement {
                 return "\(message) (\(statement)) (code: \(errorCode))"
             } else {
                 return "\(message) (code: \(errorCode))"
             }
         case let .extendedError(message, extendedCode, statement):
-            if let statement = statement {
+            if let statement {
                 return "\(message) (\(statement)) (extended code: \(extendedCode))"
             } else {
                 return "\(message) (extended code: \(extendedCode))"
diff --git a/Sources/SQLite/Extensions/FTS4.swift b/Sources/SQLite/Extensions/FTS4.swift
@@ -98,7 +98,7 @@ public struct Tokenizer {
                                  separators: Set<Character> = []) -> Tokenizer {
         var arguments = [String]()
 
-        if let removeDiacritics = removeDiacritics {
+        if let removeDiacritics {
             arguments.append("remove_diacritics=\(removeDiacritics ? 1 : 0)".quote())
         }
 
@@ -208,13 +208,13 @@ open class FTSConfig {
     func options() -> Options {
         var options = Options()
         options.append(formatColumnDefinitions())
-        if let tokenizer = tokenizer {
+        if let tokenizer {
             options.append("tokenize", value: Expression<Void>(literal: tokenizer.description))
         }
         options.appendCommaSeparated("prefix", values: prefixes.sorted().map { String($0) })
         if isContentless {
             options.append("content", value: "")
-        } else if let externalContentSchema = externalContentSchema {
+        } else if let externalContentSchema {
             options.append("content", value: externalContentSchema.tableName())
         }
         return options
@@ -306,19 +306,19 @@ open class FTS4Config: FTSConfig {
         for (column, _) in (columnDefinitions.filter { $0.options.contains(.unindexed) }) {
             options.append("notindexed", value: column)
         }
-        if let languageId = languageId {
+        if let languageId {
             options.append("languageid", value: languageId)
         }
-        if let compressFunction = compressFunction {
+        if let compressFunction {
             options.append("compress", value: compressFunction)
         }
-        if let uncompressFunction = uncompressFunction {
+        if let uncompressFunction {
             options.append("uncompress", value: uncompressFunction)
         }
-        if let matchInfo = matchInfo {
+        if let matchInfo {
             options.append("matchinfo", value: matchInfo.rawValue)
         }
-        if let order = order {
+        if let order {
             options.append("order", value: order.rawValue)
         }
         return options
diff --git a/Sources/SQLite/Extensions/FTS5.swift b/Sources/SQLite/Extensions/FTS5.swift
@@ -69,13 +69,13 @@ open class FTS5Config: FTSConfig {
 
     override func options() -> Options {
         var options = super.options()
-        if let contentRowId = contentRowId {
+        if let contentRowId {
             options.append("content_rowid", value: contentRowId)
         }
-        if let columnSize = columnSize {
+        if let columnSize {
             options.append("columnsize", value: Expression<Int>(value: columnSize))
         }
-        if let detail = detail {
+        if let detail {
             options.append("detail", value: detail.rawValue)
         }
         return options
diff --git a/Sources/SQLite/Helpers.swift b/Sources/SQLite/Helpers.swift
@@ -109,7 +109,7 @@ extension String {
 }
 
 func transcode(_ literal: Binding?) -> String {
-    guard let literal = literal else { return "NULL" }
+    guard let literal else { return "NULL" }
 
     switch literal {
     case let blob as Blob:
diff --git a/Sources/SQLite/Schema/SchemaDefinitions.swift b/Sources/SQLite/Schema/SchemaDefinitions.swift
@@ -170,7 +170,7 @@ public enum LiteralValue: Equatable, CustomStringConvertible {
     // swiftlint:enable identifier_name
 
     init(_ string: String?) {
-        guard let string = string else {
+        guard let string else {
             self = .NULL
             return
         }
diff --git a/Sources/SQLite/Schema/SchemaReader.swift b/Sources/SQLite/Schema/SchemaReader.swift
@@ -39,10 +39,10 @@ public class SchemaReader {
                                   type: ObjectDefinition.ObjectType? = nil,
                                   temp: Bool = false) throws -> [ObjectDefinition] {
         var query: QueryType = SchemaTable.get(for: connection, temp: temp)
-        if let name = name {
+        if let name {
             query = query.where(SchemaTable.nameColumn == name)
         }
-        if let type = type {
+        if let type {
             query = query.where(SchemaTable.typeColumn == type.rawValue)
         }
         return try connection.prepare(query).map { row -> ObjectDefinition in
diff --git a/Sources/SQLite/Typed/Coding.swift b/Sources/SQLite/Typed/Coding.swift
@@ -215,39 +215,39 @@ private class SQLiteEncoder: Encoder {
         }
 
         func encodeIfPresent(_ value: Int?, forKey key: SQLiteEncoder.SQLiteKeyedEncodingContainer<Key>.Key) throws {
-            if let value = value {
+            if let value {
                 try encode(value, forKey: key)
             } else if forcingNilValueSetters {
                 encoder.setters.append(Expression<Int?>(key.stringValue) <- nil)
             }
         }
 
         func encodeIfPresent(_ value: Bool?, forKey key: Key) throws {
-            if let value = value {
+            if let value {
                 try encode(value, forKey: key)
             } else if forcingNilValueSetters {
                 encoder.setters.append(Expression<Bool?>(key.stringValue) <- nil)
             }
         }
 
         func encodeIfPresent(_ value: Float?, forKey key: Key) throws {
-            if let value = value {
+            if let value {
                 try encode(value, forKey: key)
             } else if forcingNilValueSetters {
                 encoder.setters.append(Expression<Double?>(key.stringValue) <- nil)
             }
         }
 
         func encodeIfPresent(_ value: Double?, forKey key: Key) throws {
-            if let value = value {
+            if let value {
                 try encode(value, forKey: key)
             } else if forcingNilValueSetters {
                 encoder.setters.append(Expression<Double?>(key.stringValue) <- nil)
             }
         }
 
         func encodeIfPresent(_ value: String?, forKey key: MyKey) throws {
-            if let value = value {
+            if let value {
                 try encode(value, forKey: key)
             } else if forcingNilValueSetters {
                 encoder.setters.append(Expression<String?>(key.stringValue) <- nil)
@@ -270,7 +270,7 @@ private class SQLiteEncoder: Encoder {
         }
 
         func encodeIfPresent<T>(_ value: T?, forKey key: Key) throws where T: Swift.Encodable {
-            guard let value = value else {
+            guard let value else {
                 guard forcingNilValueSetters else {
                     return
                 }
diff --git a/Sources/SQLite/Typed/CoreFunctions.swift b/Sources/SQLite/Typed/CoreFunctions.swift
@@ -100,7 +100,7 @@ extension ExpressionType where UnderlyingType == Double {
     ///
     /// - Returns: A copy of the expression wrapped with the `round` function.
     public func round(_ precision: Int? = nil) -> Expression<UnderlyingType> {
-        guard let precision = precision else {
+        guard let precision else {
             return Function.round.wrap([self])
         }
         return Function.round.wrap([self, Int(precision)])
@@ -120,7 +120,7 @@ extension ExpressionType where UnderlyingType == Double? {
     ///
     /// - Returns: A copy of the expression wrapped with the `round` function.
     public func round(_ precision: Int? = nil) -> Expression<UnderlyingType> {
-        guard let precision = precision else {
+        guard let precision else {
             return Function.round.wrap(self)
         }
         return Function.round.wrap([self, Int(precision)])
@@ -250,7 +250,7 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression appended with a `LIKE` query against
     ///   the given pattern.
     public func like(_ pattern: String, escape character: Character? = nil) -> Expression<Bool> {
-        guard let character = character else {
+        guard let character else {
             return "LIKE".infix(self, pattern)
         }
         return Expression("(\(template) LIKE ? ESCAPE ?)", bindings + [pattern, String(character)])
@@ -274,7 +274,7 @@ extension ExpressionType where UnderlyingType == String {
     /// - Returns: A copy of the expression appended with a `LIKE` query against
     ///   the given pattern.
     public func like(_ pattern: Expression<String>, escape character: Character? = nil) -> Expression<Bool> {
-        guard let character = character else {
+        guard let character else {
             return Function.like.infix(self, pattern)
         }
         let like: Expression<Bool> =  Function.like.infix(self, pattern, wrap: false)
@@ -349,7 +349,7 @@ extension ExpressionType where UnderlyingType == String {
     ///
     /// - Returns: A copy of the expression wrapped with the `ltrim` function.
     public func ltrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
-        guard let characters = characters else {
+        guard let characters else {
             return Function.ltrim.wrap(self)
         }
         return Function.ltrim.wrap([self, String(characters)])
@@ -367,7 +367,7 @@ extension ExpressionType where UnderlyingType == String {
     ///
     /// - Returns: A copy of the expression wrapped with the `rtrim` function.
     public func rtrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
-        guard let characters = characters else {
+        guard let characters else {
             return Function.rtrim.wrap(self)
         }
         return Function.rtrim.wrap([self, String(characters)])
@@ -385,7 +385,7 @@ extension ExpressionType where UnderlyingType == String {
     ///
     /// - Returns: A copy of the expression wrapped with the `trim` function.
     public func trim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
-        guard let characters = characters else {
+        guard let characters else {
             return Function.trim.wrap([self])
         }
         return Function.trim.wrap([self, String(characters)])
@@ -409,7 +409,7 @@ extension ExpressionType where UnderlyingType == String {
     }
 
     public func substring(_ location: Int, length: Int? = nil) -> Expression<UnderlyingType> {
-        guard let length = length else {
+        guard let length else {
             return Function.substr.wrap([self, location])
         }
         return Function.substr.wrap([self, location, length])
@@ -475,7 +475,7 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression appended with a `LIKE` query against
     ///   the given pattern.
     public func like(_ pattern: String, escape character: Character? = nil) -> Expression<Bool?> {
-        guard let character = character else {
+        guard let character else {
             return Function.like.infix(self, pattern)
         }
         return Expression("(\(template) LIKE ? ESCAPE ?)", bindings + [pattern, String(character)])
@@ -499,7 +499,7 @@ extension ExpressionType where UnderlyingType == String? {
     /// - Returns: A copy of the expression appended with a `LIKE` query against
     ///   the given pattern.
     public func like(_ pattern: Expression<String>, escape character: Character? = nil) -> Expression<Bool?> {
-        guard let character = character else {
+        guard let character else {
             return Function.like.infix(self, pattern)
         }
         let like: Expression<Bool> = Function.like.infix(self, pattern, wrap: false)
@@ -574,7 +574,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `ltrim` function.
     public func ltrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
-        guard let characters = characters else {
+        guard let characters else {
             return Function.ltrim.wrap(self)
         }
         return Function.ltrim.wrap([self, String(characters)])
@@ -592,7 +592,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `rtrim` function.
     public func rtrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
-        guard let characters = characters else {
+        guard let characters else {
             return Function.rtrim.wrap(self)
         }
         return Function.rtrim.wrap([self, String(characters)])
@@ -610,7 +610,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `trim` function.
     public func trim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {
-        guard let characters = characters else {
+        guard let characters else {
             return Function.trim.wrap(self)
         }
         return Function.trim.wrap([self, String(characters)])
@@ -649,7 +649,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `substr` function.
     public func substring(_ location: Int, length: Int? = nil) -> Expression<UnderlyingType> {
-        guard let length = length else {
+        guard let length else {
             return Function.substr.wrap([self, location])
         }
         return Function.substr.wrap([self, location, length])
@@ -726,7 +726,7 @@ extension String {
     /// - Returns: A copy of the expression appended with a `LIKE` query against
     ///   the given pattern.
     public func like(_ pattern: Expression<String>, escape character: Character? = nil) -> Expression<Bool> {
-        guard let character = character else {
+        guard let character else {
             return Function.like.infix(self, pattern)
         }
         let like: Expression<Bool> = Function.like.infix(self, pattern, wrap: false)
diff --git a/Sources/SQLite/Typed/Operators.swift b/Sources/SQLite/Typed/Operators.swift

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+opt_in_rules:`
	`2`	`+ - shorthand_optional_binding`
`1`	`3`	`disabled_rules: # rule identifiers to exclude from running`
`2`	`4`	`- todo`
`3`	`5`	`- operator_whitespace`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ public struct Tokenizer {`
`98`	`98`	`separators: Set<Character> = []) -> Tokenizer {`
`99`	`99`	`var arguments = [String]()`
`100`	`100`
`101`		`- if let removeDiacritics = removeDiacritics {`
	`101`	`+ if let removeDiacritics {`
`102`	`102`	`arguments.append("remove_diacritics=\(removeDiacritics ? 1 : 0)".quote())`
`103`	`103`	`}`
`104`	`104`
`@@ -208,13 +208,13 @@ open class FTSConfig {`
`208`	`208`	`func options() -> Options {`
`209`	`209`	`var options = Options()`
`210`	`210`	`options.append(formatColumnDefinitions())`
`211`		`- if let tokenizer = tokenizer {`
	`211`	`+ if let tokenizer {`
`212`	`212`	`options.append("tokenize", value: Expression<Void>(literal: tokenizer.description))`
`213`	`213`	`}`
`214`	`214`	`options.appendCommaSeparated("prefix", values: prefixes.sorted().map { String($0) })`
`215`	`215`	`if isContentless {`
`216`	`216`	`options.append("content", value: "")`
`217`		`- } else if let externalContentSchema = externalContentSchema {`
	`217`	`+ } else if let externalContentSchema {`
`218`	`218`	`options.append("content", value: externalContentSchema.tableName())`
`219`	`219`	`}`
`220`	`220`	`return options`
`@@ -306,19 +306,19 @@ open class FTS4Config: FTSConfig {`
`306`	`306`	`for (column, _) in (columnDefinitions.filter { $0.options.contains(.unindexed) }) {`
`307`	`307`	`options.append("notindexed", value: column)`
`308`	`308`	`}`
`309`		`- if let languageId = languageId {`
	`309`	`+ if let languageId {`
`310`	`310`	`options.append("languageid", value: languageId)`
`311`	`311`	`}`
`312`		`- if let compressFunction = compressFunction {`
	`312`	`+ if let compressFunction {`
`313`	`313`	`options.append("compress", value: compressFunction)`
`314`	`314`	`}`
`315`		`- if let uncompressFunction = uncompressFunction {`
	`315`	`+ if let uncompressFunction {`
`316`	`316`	`options.append("uncompress", value: uncompressFunction)`
`317`	`317`	`}`
`318`		`- if let matchInfo = matchInfo {`
	`318`	`+ if let matchInfo {`
`319`	`319`	`options.append("matchinfo", value: matchInfo.rawValue)`
`320`	`320`	`}`
`321`		`- if let order = order {`
	`321`	`+ if let order {`
`322`	`322`	`options.append("order", value: order.rawValue)`
`323`	`323`	`}`
`324`	`324`	`return options`
Original file line number	Diff line number	Diff line change
`@@ -69,13 +69,13 @@ open class FTS5Config: FTSConfig {`
`69`	`69`
`70`	`70`	`override func options() -> Options {`
`71`	`71`	`var options = super.options()`
`72`		`- if let contentRowId = contentRowId {`
	`72`	`+ if let contentRowId {`
`73`	`73`	`options.append("content_rowid", value: contentRowId)`
`74`	`74`	`}`
`75`		`- if let columnSize = columnSize {`
	`75`	`+ if let columnSize {`
`76`	`76`	`options.append("columnsize", value: Expression<Int>(value: columnSize))`
`77`	`77`	`}`
`78`		`- if let detail = detail {`
	`78`	`+ if let detail {`
`79`	`79`	`options.append("detail", value: detail.rawValue)`
`80`	`80`	`}`
`81`	`81`	`return options`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ extension String {`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`func transcode(_ literal: Binding?) -> String {`
`112`		`- guard let literal = literal else { return "NULL" }`
	`112`	`+ guard let literal else { return "NULL" }`
`113`	`113`
`114`	`114`	`switch literal {`
`115`	`115`	`case let blob as Blob:`
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ public enum LiteralValue: Equatable, CustomStringConvertible {`
`170`	`170`	`// swiftlint:enable identifier_name`
`171`	`171`
`172`	`172`	`init(_ string: String?) {`
`173`		`- guard let string = string else {`
	`173`	`+ guard let string else {`
`174`	`174`	`self = .NULL`
`175`	`175`	`return`
`176`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,10 +39,10 @@ public class SchemaReader {`
`39`	`39`	`type: ObjectDefinition.ObjectType? = nil,`
`40`	`40`	`temp: Bool = false) throws -> [ObjectDefinition] {`
`41`	`41`	`var query: QueryType = SchemaTable.get(for: connection, temp: temp)`
`42`		`- if let name = name {`
	`42`	`+ if let name {`
`43`	`43`	`query = query.where(SchemaTable.nameColumn == name)`
`44`	`44`	`}`
`45`		`- if let type = type {`
	`45`	`+ if let type {`
`46`	`46`	`query = query.where(SchemaTable.typeColumn == type.rawValue)`
`47`	`47`	`}`
`48`	`48`	`return try connection.prepare(query).map { row -> ObjectDefinition in`
Original file line number	Diff line number	Diff line change
`@@ -215,39 +215,39 @@ private class SQLiteEncoder: Encoder {`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`func encodeIfPresent(_ value: Int?, forKey key: SQLiteEncoder.SQLiteKeyedEncodingContainer<Key>.Key) throws {`
`218`		`- if let value = value {`
	`218`	`+ if let value {`
`219`	`219`	`try encode(value, forKey: key)`
`220`	`220`	`} else if forcingNilValueSetters {`
`221`	`221`	`encoder.setters.append(Expression<Int?>(key.stringValue) <- nil)`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`func encodeIfPresent(_ value: Bool?, forKey key: Key) throws {`
`226`		`- if let value = value {`
	`226`	`+ if let value {`
`227`	`227`	`try encode(value, forKey: key)`
`228`	`228`	`} else if forcingNilValueSetters {`
`229`	`229`	`encoder.setters.append(Expression<Bool?>(key.stringValue) <- nil)`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`func encodeIfPresent(_ value: Float?, forKey key: Key) throws {`
`234`		`- if let value = value {`
	`234`	`+ if let value {`
`235`	`235`	`try encode(value, forKey: key)`
`236`	`236`	`} else if forcingNilValueSetters {`
`237`	`237`	`encoder.setters.append(Expression<Double?>(key.stringValue) <- nil)`
`238`	`238`	`}`
`239`	`239`	`}`
`240`	`240`
`241`	`241`	`func encodeIfPresent(_ value: Double?, forKey key: Key) throws {`
`242`		`- if let value = value {`
	`242`	`+ if let value {`
`243`	`243`	`try encode(value, forKey: key)`
`244`	`244`	`} else if forcingNilValueSetters {`
`245`	`245`	`encoder.setters.append(Expression<Double?>(key.stringValue) <- nil)`
`246`	`246`	`}`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`func encodeIfPresent(_ value: String?, forKey key: MyKey) throws {`
`250`		`- if let value = value {`
	`250`	`+ if let value {`
`251`	`251`	`try encode(value, forKey: key)`
`252`	`252`	`} else if forcingNilValueSetters {`
`253`	`253`	`encoder.setters.append(Expression<String?>(key.stringValue) <- nil)`
`@@ -270,7 +270,7 @@ private class SQLiteEncoder: Encoder {`
`270`	`270`	`}`
`271`	`271`
`272`	`272`	`func encodeIfPresent<T>(_ value: T?, forKey key: Key) throws where T: Swift.Encodable {`
`273`		`- guard let value = value else {`
	`273`	`+ guard let value else {`
`274`	`274`	`guard forcingNilValueSetters else {`
`275`	`275`	`return`
`276`	`276`	`}`