Fix URLEncodedForm errors (#716)

adam-fowler · web-flow · commit 65ace7855fa8 · 2025-05-31T20:00:14.000+01:00
diff --git a/Sources/Hummingbird/Codable/URLEncodedForm/URLEncodedFormDecoder.swift b/Sources/Hummingbird/Codable/URLEncodedForm/URLEncodedFormDecoder.swift
@@ -118,7 +118,7 @@ private class _URLEncodedFormDecoder: Decoder {
         case .empty:
             KeyedDecodingContainer(KDC(container: .init(values: [:]), decoder: self))
         default:
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))
+            throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))
         }
     }
 
@@ -129,7 +129,7 @@ private class _URLEncodedFormDecoder: Decoder {
         case .empty:
             UKDC(container: .init(values: []), decoder: self)
         default:
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected an array"))
+            throw DecodingError.typeMismatch([Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected an array"))
         }
     }
 
@@ -278,7 +278,7 @@ private class _URLEncodedFormDecoder: Decoder {
                 throw DecodingError.keyNotFound(key, .init(codingPath: self.codingPath, debugDescription: ""))
             }
             guard case .map(let map) = node else {
-                throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))
+                throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))
             }
             let container = KDC<NestedKey>(container: map, decoder: self.decoder)
             return KeyedDecodingContainer(container)
@@ -292,7 +292,7 @@ private class _URLEncodedFormDecoder: Decoder {
                 throw DecodingError.keyNotFound(key, .init(codingPath: self.codingPath, debugDescription: ""))
             }
             guard case .array(let array) = node else {
-                throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))
+                throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))
             }
             return UKDC(container: array, decoder: self.decoder)
         }
@@ -407,7 +407,7 @@ private class _URLEncodedFormDecoder: Decoder {
             let node = container.values[self.currentIndex]
             self.currentIndex += 1
             guard case .map(let map) = node else {
-                throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))
+                throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))
             }
             let container = KDC<NestedKey>(container: map, decoder: self.decoder)
             return KeyedDecodingContainer(container)
@@ -420,7 +420,7 @@ private class _URLEncodedFormDecoder: Decoder {
             let node = self.container.values[self.currentIndex]
             self.currentIndex += 1
             guard case .array(let array) = node else {
-                throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected an array"))
+                throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected an array"))
             }
             return UKDC(container: array, decoder: self.decoder)
         }
@@ -511,13 +511,13 @@ extension _URLEncodedFormDecoder {
 
     func unbox(_ node: URLEncodedFormNode, as type: Bool.Type) throws -> Bool {
         guard case .leaf(let value) = node else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))
+            throw DecodingError.typeMismatch(Bool.self, .init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))
         }
         if let value2 = value {
             if let unboxValue = Bool(value2.value) {
                 return unboxValue
             } else {
-                throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Bool"))
+                throw DecodingError.typeMismatch(Bool.self, .init(codingPath: self.codingPath, debugDescription: "Expected Boolean value"))
             }
         } else {
             return false
@@ -526,107 +526,110 @@ extension _URLEncodedFormDecoder {
 
     func unbox(_ node: URLEncodedFormNode, as type: String.Type) throws -> String {
         guard case .leaf(let value) = node else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))
+            throw DecodingError.typeMismatch(
+                String.self,
+                .init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary")
+            )
         }
         guard let value2 = value else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected value not empty string"))
+            throw DecodingError.typeMismatch(String.self, .init(codingPath: self.codingPath, debugDescription: "Expected value not empty string"))
         }
         return value2.value
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: URL.Type) throws -> URL {
         guard case .leaf(let value) = node else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))
+            throw DecodingError.typeMismatch(URL.self, .init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))
         }
         guard let value2 = value else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected value not empty string"))
+            throw DecodingError.typeMismatch(URL.self, .init(codingPath: self.codingPath, debugDescription: "Expected value not empty string"))
         }
         guard let url = URL(string: value2.value) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Invalid URL String"))
+            throw DecodingError.typeMismatch(URL.self, .init(codingPath: self.codingPath, debugDescription: "Invalid URL String"))
         }
         return url
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: Double.Type) throws -> Double {
         guard let unboxValue = try Double(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Double"))
+            throw DecodingError.typeMismatch(Double.self, .init(codingPath: self.codingPath, debugDescription: "Expected Double"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: Float.Type) throws -> Float {
         guard let unboxValue = try Float(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Float"))
+            throw DecodingError.typeMismatch(Float.self, .init(codingPath: self.codingPath, debugDescription: "Expected Float"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: Int.Type) throws -> Int {
         guard let unboxValue = try Int(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int"))
+            throw DecodingError.typeMismatch(Int.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: Int8.Type) throws -> Int8 {
         guard let unboxValue = try Int8(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int8"))
+            throw DecodingError.typeMismatch(Int8.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int8"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: Int16.Type) throws -> Int16 {
         guard let unboxValue = try Int16(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int16"))
+            throw DecodingError.typeMismatch(Int16.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int16"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: Int32.Type) throws -> Int32 {
         guard let unboxValue = try Int32(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int32"))
+            throw DecodingError.typeMismatch(Int32.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int32"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: Int64.Type) throws -> Int64 {
         guard let unboxValue = try Int64(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int64"))
+            throw DecodingError.typeMismatch(Int64.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int64"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: UInt.Type) throws -> UInt {
         guard let unboxValue = try UInt(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt"))
+            throw DecodingError.typeMismatch(UInt.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: UInt8.Type) throws -> UInt8 {
         guard let unboxValue = try UInt8(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt8"))
+            throw DecodingError.typeMismatch(UInt8.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt8"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: UInt16.Type) throws -> UInt16 {
         guard let unboxValue = try UInt16(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt16"))
+            throw DecodingError.typeMismatch(UInt16.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt16"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: UInt32.Type) throws -> UInt32 {
         guard let unboxValue = try UInt32(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt32"))
+            throw DecodingError.typeMismatch(UInt32.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt32"))
         }
         return unboxValue
     }
 
     func unbox(_ node: URLEncodedFormNode, as type: UInt64.Type) throws -> UInt64 {
         guard let unboxValue = try UInt64(unbox(node, as: String.self)) else {
-            throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt64"))
+            throw DecodingError.typeMismatch(UInt64.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt64"))
         }
         return unboxValue
     }
@@ -647,11 +650,15 @@ extension _URLEncodedFormDecoder {
             let dateString = try unbox(node, as: String.self)
             #if compiler(>=6.0)
             guard let date = try? Date(dateString, strategy: .iso8601) else {
-                throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Invalid date format"))
+                throw DecodingError.dataCorrupted(
+                    .init(codingPath: self.codingPath, debugDescription: "Expected date string to be ISO8601-formatted.")
+                )
             }
             #else
             guard let date = URLEncodedForm.iso8601Formatter.date(from: dateString) else {
-                throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Invalid date format"))
+                throw DecodingError.dataCorrupted(
+                    .init(codingPath: self.codingPath, debugDescription: "Expected date string to be ISO8601-formatted.")
+                )
             }
             #endif
             return date
diff --git a/Sources/Hummingbird/Server/Request.swift b/Sources/Hummingbird/Server/Request.swift
@@ -41,8 +41,8 @@ extension Request {
     public func decode<Type: Decodable>(as type: Type.Type, context: some RequestContext) async throws -> Type {
         do {
             return try await context.requestDecoder.decode(type, from: self, context: context)
-        } catch DecodingError.dataCorrupted(_) {
-            let message = "The given data was not valid input."
+        } catch DecodingError.dataCorrupted(let context) {
+            let message = "The given data was not valid input: \(context.debugDescription)"
             throw HTTPError(.badRequest, message: message)
         } catch DecodingError.keyNotFound(let key, _) {
             let path = key.pathKeyValue

Original file line number	Diff line number	Diff line change
`@@ -118,7 +118,7 @@ private class _URLEncodedFormDecoder: Decoder {`
`118`	`118`	`case .empty:`
`119`	`119`	`KeyedDecodingContainer(KDC(container: .init(values: [:]), decoder: self))`
`120`	`120`	`default:`
`121`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))`
	`121`	`+ throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`@@ -129,7 +129,7 @@ private class _URLEncodedFormDecoder: Decoder {`
`129`	`129`	`case .empty:`
`130`	`130`	`UKDC(container: .init(values: []), decoder: self)`
`131`	`131`	`default:`
`132`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected an array"))`
	`132`	`+ throw DecodingError.typeMismatch([Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected an array"))`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`@@ -278,7 +278,7 @@ private class _URLEncodedFormDecoder: Decoder {`
`278`	`278`	`throw DecodingError.keyNotFound(key, .init(codingPath: self.codingPath, debugDescription: ""))`
`279`	`279`	`}`
`280`	`280`	`guard case .map(let map) = node else {`
`281`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))`
	`281`	`+ throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))`
`282`	`282`	`}`
`283`	`283`	`let container = KDC<NestedKey>(container: map, decoder: self.decoder)`
`284`	`284`	`return KeyedDecodingContainer(container)`
`@@ -292,7 +292,7 @@ private class _URLEncodedFormDecoder: Decoder {`
`292`	`292`	`throw DecodingError.keyNotFound(key, .init(codingPath: self.codingPath, debugDescription: ""))`
`293`	`293`	`}`
`294`	`294`	`guard case .array(let array) = node else {`
`295`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))`
	`295`	`+ throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))`
`296`	`296`	`}`
`297`	`297`	`return UKDC(container: array, decoder: self.decoder)`
`298`	`298`	`}`
`@@ -407,7 +407,7 @@ private class _URLEncodedFormDecoder: Decoder {`
`407`	`407`	`let node = container.values[self.currentIndex]`
`408`	`408`	`self.currentIndex += 1`
`409`	`409`	`guard case .map(let map) = node else {`
`410`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))`
	`410`	`+ throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected a dictionary"))`
`411`	`411`	`}`
`412`	`412`	`let container = KDC<NestedKey>(container: map, decoder: self.decoder)`
`413`	`413`	`return KeyedDecodingContainer(container)`
`@@ -420,7 +420,7 @@ private class _URLEncodedFormDecoder: Decoder {`
`420`	`420`	`let node = self.container.values[self.currentIndex]`
`421`	`421`	`self.currentIndex += 1`
`422`	`422`	`guard case .array(let array) = node else {`
`423`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected an array"))`
	`423`	`+ throw DecodingError.typeMismatch([String: Any].self, .init(codingPath: self.codingPath, debugDescription: "Expected an array"))`
`424`	`424`	`}`
`425`	`425`	`return UKDC(container: array, decoder: self.decoder)`
`426`	`426`	`}`
`@@ -511,13 +511,13 @@ extension _URLEncodedFormDecoder {`
`511`	`511`
`512`	`512`	`func unbox(_ node: URLEncodedFormNode, as type: Bool.Type) throws -> Bool {`
`513`	`513`	`guard case .leaf(let value) = node else {`
`514`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))`
	`514`	`+ throw DecodingError.typeMismatch(Bool.self, .init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))`
`515`	`515`	`}`
`516`	`516`	`if let value2 = value {`
`517`	`517`	`if let unboxValue = Bool(value2.value) {`
`518`	`518`	`return unboxValue`
`519`	`519`	`} else {`
`520`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Bool"))`
	`520`	`+ throw DecodingError.typeMismatch(Bool.self, .init(codingPath: self.codingPath, debugDescription: "Expected Boolean value"))`
`521`	`521`	`}`
`522`	`522`	`} else {`
`523`	`523`	`return false`
`@@ -526,107 +526,110 @@ extension _URLEncodedFormDecoder {`
`526`	`526`
`527`	`527`	`func unbox(_ node: URLEncodedFormNode, as type: String.Type) throws -> String {`
`528`	`528`	`guard case .leaf(let value) = node else {`
`529`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))`
	`529`	`+ throw DecodingError.typeMismatch(`
	`530`	`+ String.self,`
	`531`	`+ .init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary")`
	`532`	`+ )`
`530`	`533`	`}`
`531`	`534`	`guard let value2 = value else {`
`532`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected value not empty string"))`
	`535`	`+ throw DecodingError.typeMismatch(String.self, .init(codingPath: self.codingPath, debugDescription: "Expected value not empty string"))`
`533`	`536`	`}`
`534`	`537`	`return value2.value`
`535`	`538`	`}`
`536`	`539`
`537`	`540`	`func unbox(_ node: URLEncodedFormNode, as type: URL.Type) throws -> URL {`
`538`	`541`	`guard case .leaf(let value) = node else {`
`539`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))`
	`542`	`+ throw DecodingError.typeMismatch(URL.self, .init(codingPath: self.codingPath, debugDescription: "Expect value not array or dictionary"))`
`540`	`543`	`}`
`541`	`544`	`guard let value2 = value else {`
`542`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected value not empty string"))`
	`545`	`+ throw DecodingError.typeMismatch(URL.self, .init(codingPath: self.codingPath, debugDescription: "Expected value not empty string"))`
`543`	`546`	`}`
`544`	`547`	`guard let url = URL(string: value2.value) else {`
`545`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Invalid URL String"))`
	`548`	`+ throw DecodingError.typeMismatch(URL.self, .init(codingPath: self.codingPath, debugDescription: "Invalid URL String"))`
`546`	`549`	`}`
`547`	`550`	`return url`
`548`	`551`	`}`
`549`	`552`
`550`	`553`	`func unbox(_ node: URLEncodedFormNode, as type: Double.Type) throws -> Double {`
`551`	`554`	`guard let unboxValue = try Double(unbox(node, as: String.self)) else {`
`552`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Double"))`
	`555`	`+ throw DecodingError.typeMismatch(Double.self, .init(codingPath: self.codingPath, debugDescription: "Expected Double"))`
`553`	`556`	`}`
`554`	`557`	`return unboxValue`
`555`	`558`	`}`
`556`	`559`
`557`	`560`	`func unbox(_ node: URLEncodedFormNode, as type: Float.Type) throws -> Float {`
`558`	`561`	`guard let unboxValue = try Float(unbox(node, as: String.self)) else {`
`559`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Float"))`
	`562`	`+ throw DecodingError.typeMismatch(Float.self, .init(codingPath: self.codingPath, debugDescription: "Expected Float"))`
`560`	`563`	`}`
`561`	`564`	`return unboxValue`
`562`	`565`	`}`
`563`	`566`
`564`	`567`	`func unbox(_ node: URLEncodedFormNode, as type: Int.Type) throws -> Int {`
`565`	`568`	`guard let unboxValue = try Int(unbox(node, as: String.self)) else {`
`566`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int"))`
	`569`	`+ throw DecodingError.typeMismatch(Int.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int"))`
`567`	`570`	`}`
`568`	`571`	`return unboxValue`
`569`	`572`	`}`
`570`	`573`
`571`	`574`	`func unbox(_ node: URLEncodedFormNode, as type: Int8.Type) throws -> Int8 {`
`572`	`575`	`guard let unboxValue = try Int8(unbox(node, as: String.self)) else {`
`573`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int8"))`
	`576`	`+ throw DecodingError.typeMismatch(Int8.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int8"))`
`574`	`577`	`}`
`575`	`578`	`return unboxValue`
`576`	`579`	`}`
`577`	`580`
`578`	`581`	`func unbox(_ node: URLEncodedFormNode, as type: Int16.Type) throws -> Int16 {`
`579`	`582`	`guard let unboxValue = try Int16(unbox(node, as: String.self)) else {`
`580`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int16"))`
	`583`	`+ throw DecodingError.typeMismatch(Int16.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int16"))`
`581`	`584`	`}`
`582`	`585`	`return unboxValue`
`583`	`586`	`}`
`584`	`587`
`585`	`588`	`func unbox(_ node: URLEncodedFormNode, as type: Int32.Type) throws -> Int32 {`
`586`	`589`	`guard let unboxValue = try Int32(unbox(node, as: String.self)) else {`
`587`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int32"))`
	`590`	`+ throw DecodingError.typeMismatch(Int32.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int32"))`
`588`	`591`	`}`
`589`	`592`	`return unboxValue`
`590`	`593`	`}`
`591`	`594`
`592`	`595`	`func unbox(_ node: URLEncodedFormNode, as type: Int64.Type) throws -> Int64 {`
`593`	`596`	`guard let unboxValue = try Int64(unbox(node, as: String.self)) else {`
`594`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected Int64"))`
	`597`	`+ throw DecodingError.typeMismatch(Int64.self, .init(codingPath: self.codingPath, debugDescription: "Expected Int64"))`
`595`	`598`	`}`
`596`	`599`	`return unboxValue`
`597`	`600`	`}`
`598`	`601`
`599`	`602`	`func unbox(_ node: URLEncodedFormNode, as type: UInt.Type) throws -> UInt {`
`600`	`603`	`guard let unboxValue = try UInt(unbox(node, as: String.self)) else {`
`601`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt"))`
	`604`	`+ throw DecodingError.typeMismatch(UInt.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt"))`
`602`	`605`	`}`
`603`	`606`	`return unboxValue`
`604`	`607`	`}`
`605`	`608`
`606`	`609`	`func unbox(_ node: URLEncodedFormNode, as type: UInt8.Type) throws -> UInt8 {`
`607`	`610`	`guard let unboxValue = try UInt8(unbox(node, as: String.self)) else {`
`608`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt8"))`
	`611`	`+ throw DecodingError.typeMismatch(UInt8.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt8"))`
`609`	`612`	`}`
`610`	`613`	`return unboxValue`
`611`	`614`	`}`
`612`	`615`
`613`	`616`	`func unbox(_ node: URLEncodedFormNode, as type: UInt16.Type) throws -> UInt16 {`
`614`	`617`	`guard let unboxValue = try UInt16(unbox(node, as: String.self)) else {`
`615`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt16"))`
	`618`	`+ throw DecodingError.typeMismatch(UInt16.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt16"))`
`616`	`619`	`}`
`617`	`620`	`return unboxValue`
`618`	`621`	`}`
`619`	`622`
`620`	`623`	`func unbox(_ node: URLEncodedFormNode, as type: UInt32.Type) throws -> UInt32 {`
`621`	`624`	`guard let unboxValue = try UInt32(unbox(node, as: String.self)) else {`
`622`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt32"))`
	`625`	`+ throw DecodingError.typeMismatch(UInt32.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt32"))`
`623`	`626`	`}`
`624`	`627`	`return unboxValue`
`625`	`628`	`}`
`626`	`629`
`627`	`630`	`func unbox(_ node: URLEncodedFormNode, as type: UInt64.Type) throws -> UInt64 {`
`628`	`631`	`guard let unboxValue = try UInt64(unbox(node, as: String.self)) else {`
`629`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Expected UInt64"))`
	`632`	`+ throw DecodingError.typeMismatch(UInt64.self, .init(codingPath: self.codingPath, debugDescription: "Expected UInt64"))`
`630`	`633`	`}`
`631`	`634`	`return unboxValue`
`632`	`635`	`}`
`@@ -647,11 +650,15 @@ extension _URLEncodedFormDecoder {`
`647`	`650`	`let dateString = try unbox(node, as: String.self)`
`648`	`651`	`#if compiler(>=6.0)`
`649`	`652`	`guard let date = try? Date(dateString, strategy: .iso8601) else {`
`650`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Invalid date format"))`
	`653`	`+ throw DecodingError.dataCorrupted(`
	`654`	`+ .init(codingPath: self.codingPath, debugDescription: "Expected date string to be ISO8601-formatted.")`
	`655`	`+ )`
`651`	`656`	`}`
`652`	`657`	`#else`
`653`	`658`	`guard let date = URLEncodedForm.iso8601Formatter.date(from: dateString) else {`
`654`		`- throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Invalid date format"))`
	`659`	`+ throw DecodingError.dataCorrupted(`
	`660`	`+ .init(codingPath: self.codingPath, debugDescription: "Expected date string to be ISO8601-formatted.")`
	`661`	`+ )`
`655`	`662`	`}`
`656`	`663`	`#endif`
`657`	`664`	`return date`