fix xcode-10.2 issues

ottosuess · ottosuess · commit c96a5da4ef8c · 2019-03-26T12:53:22.000+01:00
diff --git a/Sources/SQLite/Helpers.swift b/Sources/SQLite/Helpers.swift
@@ -98,18 +98,6 @@ extension String {
 
 }
 
-func infix<T>(_ lhs: Expressible, _ rhs: Expressible, wrap: Bool = true, function: String = #function) -> Expression<T> {
-    return function.infix(lhs, rhs, wrap: wrap)
-}
-
-func wrap<T>(_ expression: Expressible, function: String = #function) -> Expression<T> {
-    return function.wrap(expression)
-}
-
-func wrap<T>(_ expressions: [Expressible], function: String = #function) -> Expression<T> {
-    return function.wrap(", ".join(expressions))
-}
-
 func transcode(_ literal: Binding?) -> String {
     guard let literal = literal else { return "NULL" }
 
diff --git a/Sources/SQLite/Typed/AggregateFunctions.swift b/Sources/SQLite/Typed/AggregateFunctions.swift
@@ -48,7 +48,7 @@ extension ExpressionType where UnderlyingType : Value {
     /// - Returns: A copy of the expression wrapped with the `count` aggregate
     ///   function.
     public var count: Expression<Int> {
-        return wrap(self)
+        return "count".wrap(self)
     }
 
 }
@@ -79,7 +79,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `count` aggregate
     ///   function.
     public var count: Expression<Int> {
-        return wrap(self)
+        return "count".wrap(self)
     }
 
 }
@@ -96,7 +96,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `max` aggregate
     ///   function.
     public var max: Expression<UnderlyingType?> {
-        return wrap(self)
+        return "max".wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `min` aggregate
@@ -109,7 +109,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var min: Expression<UnderlyingType?> {
-        return wrap(self)
+        return "min".wrap(self)
     }
 
 }
@@ -126,7 +126,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `max` aggregate
     ///   function.
     public var max: Expression<UnderlyingType> {
-        return wrap(self)
+        return "max".wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `min` aggregate
@@ -139,7 +139,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var min: Expression<UnderlyingType> {
-        return wrap(self)
+        return "min".wrap(self)
     }
 
 }
@@ -169,7 +169,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var sum: Expression<UnderlyingType?> {
-        return wrap(self)
+        return "sum".wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `total` aggregate
@@ -182,7 +182,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var total: Expression<Double> {
-        return wrap(self)
+        return "total".wrap(self)
     }
 
 }
@@ -212,7 +212,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var sum: Expression<UnderlyingType> {
-        return wrap(self)
+        return "sum".wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `total` aggregate
@@ -225,15 +225,15 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr
     /// - Returns: A copy of the expression wrapped with the `min` aggregate
     ///   function.
     public var total: Expression<Double> {
-        return wrap(self)
+        return "total".wrap(self)
     }
 
 }
 
 extension ExpressionType where UnderlyingType == Int {
 
     static func count(_ star: Star) -> Expression<UnderlyingType> {
-        return wrap(star(nil, nil))
+        return "count".wrap(star(nil, nil))
     }
 
 }
diff --git a/Sources/SQLite/Typed/CoreFunctions.swift b/Sources/SQLite/Typed/CoreFunctions.swift
@@ -68,9 +68,9 @@ 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 {
-            return wrap([self])
+            return "round".wrap([self])
         }
-        return wrap([self, Int(precision)])
+        return "round".wrap([self, Int(precision)])
     }
 
 }
@@ -88,9 +88,9 @@ 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 {
-            return wrap(self)
+            return "round".wrap(self)
         }
-        return wrap([self, Int(precision)])
+        return "round".wrap([self, Int(precision)])
     }
 
 }
@@ -143,7 +143,7 @@ extension ExpressionType where UnderlyingType == Data {
     ///
     /// - Returns: A copy of the expression wrapped with the `length` function.
     public var length: Expression<Int> {
-        return wrap(self)
+        return "length".wrap(self)
     }
 
 }
@@ -158,7 +158,7 @@ extension ExpressionType where UnderlyingType == Data? {
     ///
     /// - Returns: A copy of the expression wrapped with the `length` function.
     public var length: Expression<Int?> {
-        return wrap(self)
+        return "length".wrap(self)
     }
 
 }
@@ -173,7 +173,7 @@ extension ExpressionType where UnderlyingType == String {
     ///
     /// - Returns: A copy of the expression wrapped with the `length` function.
     public var length: Expression<Int> {
-        return wrap(self)
+        return "length".wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `lower` function.
@@ -317,9 +317,9 @@ 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 {
-            return wrap(self)
+            return "ltrim".wrap(self)
         }
-        return wrap([self, String(characters)])
+        return "ltrim".wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `rtrim` function.
@@ -335,9 +335,9 @@ 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 {
-            return wrap(self)
+            return "rtrim".wrap(self)
         }
-        return wrap([self, String(characters)])
+        return "rtrim".wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `trim` function.
@@ -353,9 +353,9 @@ 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 {
-            return wrap([self])
+            return "trim".wrap([self])
         }
-        return wrap([self, String(characters)])
+        return "trim".wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `replace` function.
@@ -398,7 +398,7 @@ extension ExpressionType where UnderlyingType == String? {
     ///
     /// - Returns: A copy of the expression wrapped with the `length` function.
     public var length: Expression<Int?> {
-        return wrap(self)
+        return "length".wrap(self)
     }
 
     /// Builds a copy of the expression wrapped with the `lower` function.
@@ -542,9 +542,9 @@ 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 {
-            return wrap(self)
+            return "ltrim".wrap(self)
         }
-        return wrap([self, String(characters)])
+        return "ltrim".wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `rtrim` function.
@@ -560,9 +560,9 @@ 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 {
-            return wrap(self)
+            return "rtrim".wrap(self)
         }
-        return wrap([self, String(characters)])
+        return "rtrim".wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `trim` function.
@@ -578,9 +578,9 @@ 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 {
-            return wrap(self)
+            return "trim".wrap(self)
         }
-        return wrap([self, String(characters)])
+        return "trim".wrap([self, String(characters)])
     }
 
     /// Builds a copy of the expression wrapped with the `replace` function.
diff --git a/Sources/SQLite/Typed/Operators.swift b/Sources/SQLite/Typed/Operators.swift

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ extension ExpressionType where UnderlyingType : Value {`
`48`	`48`	/// - Returns: A copy of the expression wrapped with the `count` aggregate
`49`	`49`	`/// function.`
`50`	`50`	`public var count: Expression<Int> {`
`51`		`- return wrap(self)`
	`51`	`+ return "count".wrap(self)`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`}`
`@@ -79,7 +79,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr`
`79`	`79`	/// - Returns: A copy of the expression wrapped with the `count` aggregate
`80`	`80`	`/// function.`
`81`	`81`	`public var count: Expression<Int> {`
`82`		`- return wrap(self)`
	`82`	`+ return "count".wrap(self)`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`}`
`@@ -96,7 +96,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :`
`96`	`96`	/// - Returns: A copy of the expression wrapped with the `max` aggregate
`97`	`97`	`/// function.`
`98`	`98`	`public var max: Expression<UnderlyingType?> {`
`99`		`- return wrap(self)`
	`99`	`+ return "max".wrap(self)`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	/// Builds a copy of the expression wrapped with the `min` aggregate
`@@ -109,7 +109,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :`
`109`	`109`	/// - Returns: A copy of the expression wrapped with the `min` aggregate
`110`	`110`	`/// function.`
`111`	`111`	`public var min: Expression<UnderlyingType?> {`
`112`		`- return wrap(self)`
	`112`	`+ return "min".wrap(self)`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`}`
`@@ -126,7 +126,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr`
`126`	`126`	/// - Returns: A copy of the expression wrapped with the `max` aggregate
`127`	`127`	`/// function.`
`128`	`128`	`public var max: Expression<UnderlyingType> {`
`129`		`- return wrap(self)`
	`129`	`+ return "max".wrap(self)`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	/// Builds a copy of the expression wrapped with the `min` aggregate
`@@ -139,7 +139,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr`
`139`	`139`	/// - Returns: A copy of the expression wrapped with the `min` aggregate
`140`	`140`	`/// function.`
`141`	`141`	`public var min: Expression<UnderlyingType> {`
`142`		`- return wrap(self)`
	`142`	`+ return "min".wrap(self)`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`}`
`@@ -169,7 +169,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :`
`169`	`169`	/// - Returns: A copy of the expression wrapped with the `min` aggregate
`170`	`170`	`/// function.`
`171`	`171`	`public var sum: Expression<UnderlyingType?> {`
`172`		`- return wrap(self)`
	`172`	`+ return "sum".wrap(self)`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	/// Builds a copy of the expression wrapped with the `total` aggregate
`@@ -182,7 +182,7 @@ extension ExpressionType where UnderlyingType : Value, UnderlyingType.Datatype :`
`182`	`182`	/// - Returns: A copy of the expression wrapped with the `min` aggregate
`183`	`183`	`/// function.`
`184`	`184`	`public var total: Expression<Double> {`
`185`		`- return wrap(self)`
	`185`	`+ return "total".wrap(self)`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`}`
`@@ -212,7 +212,7 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr`
`212`	`212`	/// - Returns: A copy of the expression wrapped with the `min` aggregate
`213`	`213`	`/// function.`
`214`	`214`	`public var sum: Expression<UnderlyingType> {`
`215`		`- return wrap(self)`
	`215`	`+ return "sum".wrap(self)`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	/// Builds a copy of the expression wrapped with the `total` aggregate
`@@ -225,15 +225,15 @@ extension ExpressionType where UnderlyingType : _OptionalType, UnderlyingType.Wr`
`225`	`225`	/// - Returns: A copy of the expression wrapped with the `min` aggregate
`226`	`226`	`/// function.`
`227`	`227`	`public var total: Expression<Double> {`
`228`		`- return wrap(self)`
	`228`	`+ return "total".wrap(self)`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`extension ExpressionType where UnderlyingType == Int {`
`234`	`234`
`235`	`235`	`static func count(_ star: Star) -> Expression<UnderlyingType> {`
`236`		`- return wrap(star(nil, nil))`
	`236`	`+ return "count".wrap(star(nil, nil))`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,9 +68,9 @@ extension ExpressionType where UnderlyingType == Double {`
`68`	`68`	/// - Returns: A copy of the expression wrapped with the `round` function.
`69`	`69`	`public func round(_ precision: Int? = nil) -> Expression<UnderlyingType> {`
`70`	`70`	`guard let precision = precision else {`
`71`		`- return wrap([self])`
	`71`	`+ return "round".wrap([self])`
`72`	`72`	`}`
`73`		`- return wrap([self, Int(precision)])`
	`73`	`+ return "round".wrap([self, Int(precision)])`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`}`
`@@ -88,9 +88,9 @@ extension ExpressionType where UnderlyingType == Double? {`
`88`	`88`	/// - Returns: A copy of the expression wrapped with the `round` function.
`89`	`89`	`public func round(_ precision: Int? = nil) -> Expression<UnderlyingType> {`
`90`	`90`	`guard let precision = precision else {`
`91`		`- return wrap(self)`
	`91`	`+ return "round".wrap(self)`
`92`	`92`	`}`
`93`		`- return wrap([self, Int(precision)])`
	`93`	`+ return "round".wrap([self, Int(precision)])`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`}`
`@@ -143,7 +143,7 @@ extension ExpressionType where UnderlyingType == Data {`
`143`	`143`	`///`
`144`	`144`	/// - Returns: A copy of the expression wrapped with the `length` function.
`145`	`145`	`public var length: Expression<Int> {`
`146`		`- return wrap(self)`
	`146`	`+ return "length".wrap(self)`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`}`
`@@ -158,7 +158,7 @@ extension ExpressionType where UnderlyingType == Data? {`
`158`	`158`	`///`
`159`	`159`	/// - Returns: A copy of the expression wrapped with the `length` function.
`160`	`160`	`public var length: Expression<Int?> {`
`161`		`- return wrap(self)`
	`161`	`+ return "length".wrap(self)`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`}`
`@@ -173,7 +173,7 @@ extension ExpressionType where UnderlyingType == String {`
`173`	`173`	`///`
`174`	`174`	/// - Returns: A copy of the expression wrapped with the `length` function.
`175`	`175`	`public var length: Expression<Int> {`
`176`		`- return wrap(self)`
	`176`	`+ return "length".wrap(self)`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	/// Builds a copy of the expression wrapped with the `lower` function.
`@@ -317,9 +317,9 @@ extension ExpressionType where UnderlyingType == String {`
`317`	`317`	/// - Returns: A copy of the expression wrapped with the `ltrim` function.
`318`	`318`	`public func ltrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {`
`319`	`319`	`guard let characters = characters else {`
`320`		`- return wrap(self)`
	`320`	`+ return "ltrim".wrap(self)`
`321`	`321`	`}`
`322`		`- return wrap([self, String(characters)])`
	`322`	`+ return "ltrim".wrap([self, String(characters)])`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	/// Builds a copy of the expression wrapped with the `rtrim` function.
`@@ -335,9 +335,9 @@ extension ExpressionType where UnderlyingType == String {`
`335`	`335`	/// - Returns: A copy of the expression wrapped with the `rtrim` function.
`336`	`336`	`public func rtrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {`
`337`	`337`	`guard let characters = characters else {`
`338`		`- return wrap(self)`
	`338`	`+ return "rtrim".wrap(self)`
`339`	`339`	`}`
`340`		`- return wrap([self, String(characters)])`
	`340`	`+ return "rtrim".wrap([self, String(characters)])`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	/// Builds a copy of the expression wrapped with the `trim` function.
`@@ -353,9 +353,9 @@ extension ExpressionType where UnderlyingType == String {`
`353`	`353`	/// - Returns: A copy of the expression wrapped with the `trim` function.
`354`	`354`	`public func trim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {`
`355`	`355`	`guard let characters = characters else {`
`356`		`- return wrap([self])`
	`356`	`+ return "trim".wrap([self])`
`357`	`357`	`}`
`358`		`- return wrap([self, String(characters)])`
	`358`	`+ return "trim".wrap([self, String(characters)])`
`359`	`359`	`}`
`360`	`360`
`361`	`361`	/// Builds a copy of the expression wrapped with the `replace` function.
`@@ -398,7 +398,7 @@ extension ExpressionType where UnderlyingType == String? {`
`398`	`398`	`///`
`399`	`399`	/// - Returns: A copy of the expression wrapped with the `length` function.
`400`	`400`	`public var length: Expression<Int?> {`
`401`		`- return wrap(self)`
	`401`	`+ return "length".wrap(self)`
`402`	`402`	`}`
`403`	`403`
`404`	`404`	/// Builds a copy of the expression wrapped with the `lower` function.
`@@ -542,9 +542,9 @@ extension ExpressionType where UnderlyingType == String? {`
`542`	`542`	/// - Returns: A copy of the expression wrapped with the `ltrim` function.
`543`	`543`	`public func ltrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {`
`544`	`544`	`guard let characters = characters else {`
`545`		`- return wrap(self)`
	`545`	`+ return "ltrim".wrap(self)`
`546`	`546`	`}`
`547`		`- return wrap([self, String(characters)])`
	`547`	`+ return "ltrim".wrap([self, String(characters)])`
`548`	`548`	`}`
`549`	`549`
`550`	`550`	/// Builds a copy of the expression wrapped with the `rtrim` function.
`@@ -560,9 +560,9 @@ extension ExpressionType where UnderlyingType == String? {`
`560`	`560`	/// - Returns: A copy of the expression wrapped with the `rtrim` function.
`561`	`561`	`public func rtrim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {`
`562`	`562`	`guard let characters = characters else {`
`563`		`- return wrap(self)`
	`563`	`+ return "rtrim".wrap(self)`
`564`	`564`	`}`
`565`		`- return wrap([self, String(characters)])`
	`565`	`+ return "rtrim".wrap([self, String(characters)])`
`566`	`566`	`}`
`567`	`567`
`568`	`568`	/// Builds a copy of the expression wrapped with the `trim` function.
`@@ -578,9 +578,9 @@ extension ExpressionType where UnderlyingType == String? {`
`578`	`578`	/// - Returns: A copy of the expression wrapped with the `trim` function.
`579`	`579`	`public func trim(_ characters: Set<Character>? = nil) -> Expression<UnderlyingType> {`
`580`	`580`	`guard let characters = characters else {`
`581`		`- return wrap(self)`
	`581`	`+ return "trim".wrap(self)`
`582`	`582`	`}`
`583`		`- return wrap([self, String(characters)])`
	`583`	`+ return "trim".wrap([self, String(characters)])`
`584`	`584`	`}`
`585`	`585`
`586`	`586`	/// Builds a copy of the expression wrapped with the `replace` function.