(112983484) Predicate coding shouldn't crash on types with type parameter packs

Author: jmschonfeld

Sources/FoundationEssentials/Predicate/Archiving/ExpressionArchiving.swift

@@ -20,12 +20,14 @@ enum PredicateCodableError : Error, CustomStringConvertible {
     case disallowedType(typeName: String, path: String)
     case disallowedIdentifier(String, path: String)
     case reconstructionFailure(PartialType, [Type])
+    case variadicType(typeName: String, path: String)
 
     var description: String {
         switch self {
         case .disallowedType(let typeName, let path): return "The '\(typeName)' type is not in the provided allowlist (required by \(path))"
         case .disallowedIdentifier(let id, let path): return "The '\(id)' identifier is not in the provided allowlist (required by \(path))"
         case .reconstructionFailure(let partial, let args): return "Reconstruction of '\(partial.name)' with the arguments \(args.map(\.swiftType)) failed"
+        case .variadicType(let typeName, let path): return "The '\(typeName)' type is not allowed because it contains type pack parameters (required by \(path))"
         }
     }
 }
@@ -63,6 +65,11 @@ private struct ExpressionStructure : Codable {
     }
 
     init(_ type: Type, with configuration: PredicateCodableConfiguration, path: [String] = []) throws {
+#if canImport(ReflectionInternal, _version: "18")
+        if type.partial?.hasParameterPacks ?? false {
+            throw PredicateCodableError.variadicType(typeName: _typeName(type.swiftType), path: "/\(path.joined(separator: "/"))")
+        }
+#endif
         guard let result = configuration._identifier(for: type) else {
             throw PredicateCodableError.disallowedType(typeName: _typeName(type.swiftType), path: "/\(path.joined(separator: "/"))")
         }
@@ -91,6 +98,12 @@ private struct ExpressionStructure : Codable {
             partial = partialType
         }
 
+#if canImport(ReflectionInternal, _version: "18")
+        if partial.hasParameterPacks {
+            throw PredicateCodableError.variadicType(typeName: partial.name, path: "/\(path.joined(separator: "/"))")
+        }
+#endif
+        
         let argTypes = try args.map {
             try $0.reconstruct(with: configuration, path: path + [identifier])
         }

Tests/FoundationEssentialsTests/PredicateCodableTests.swift

@@ -542,6 +542,95 @@ final class PredicateCodableTests: XCTestCase {
         XCTAssertThrowsError(try _encodeDecode(predicate, for: EmptyConfig.self))
         XCTAssertThrowsError(try _encodeDecode(predicate))
     }
+    
+    func testCapturedVariadicTypes() throws {
+#if !canImport(ReflectionInternal, _version: "18")
+        throw XCTSkip("Insufficient ReflectionInternal version for this test")
+#else
+        struct A<each T> : Equatable, Codable {
+            init(_: repeat (each T).Type) {}
+            
+            func encode(to encoder: Encoder) throws {
+                var container = encoder.singleValueContainer()
+                try container.encodeNil()
+            }
+            
+            init(from decoder: Decoder) throws {
+                var container = try decoder.singleValueContainer()
+                guard container.decodeNil() else {
+                    throw DecodingError.dataCorrupted(.init(codingPath: container.codingPath, debugDescription: "Did not find encoded nil"))
+                }
+            }
+        }
+
+        let a = A(String.self, Int.self)
+
+        let predicate = Predicate<Int> { _ in
+            // a == a
+            PredicateExpressions.build_Equal(
+                lhs: PredicateExpressions.build_Arg(a),
+                rhs: PredicateExpressions.build_Arg(a)
+            )
+        }
+
+        let encoder = JSONEncoder()
+        var config = PredicateCodableConfiguration.standardConfiguration
+        config.allowPartialType(A< >.self, identifier: "PredicateCodableTests.A")
+        XCTAssertThrowsError(try encoder.encode(predicate, configuration: config)) {
+            XCTAssertTrue(String(describing: $0).contains("type is not allowed because it contains type pack parameters"))
+        }
+        
+        let json = """
+        [
+          {
+            "expression" : [
+              null,
+              null
+            ],
+            "structure" : {
+              "identifier" : "PredicateExpressions.Equal",
+              "args" : [
+                {
+                  "identifier" : "PredicateExpressions.Value",
+                  "args" : [
+                    {
+                      "identifier": "PredicateCodableTests.A",
+                      "args": [
+                        "Swift.String",
+                        "Swift.Int"
+                      ]
+                    }
+                  ]
+                },
+                {
+                  "args" : [
+                    {
+                      "identifier": "PredicateCodableTests.A",
+                      "args": [
+                        "Swift.String",
+                        "Swift.Int"
+                      ]
+                    }
+                  ],
+                  "identifier" : "PredicateExpressions.Value"
+                }
+              ]
+            },
+            "variable" : [
+              {
+                "key" : 0
+              }
+            ]
+          }
+        ]
+        """
+        
+        let decoder = JSONDecoder()
+        XCTAssertThrowsError(try decoder.decode(Predicate<Int>.self, from: json.data(using: .utf8)!, configuration: config)) {
+            XCTAssertTrue(String(describing: $0).contains("type is not allowed because it contains type pack parameters"))
+        }
+#endif
+    }
 }
 
 #endif // FOUNDATION_FRAMEWORK