Fix issues decoding the Pkl 0.30 Class/TypeAlias representation

Sources/PklSwift/API/Class.swift

@@ -22,24 +22,24 @@ public struct Class: Hashable {
     /// Will be an empty string for values encoded by Pkl versions older than 0.30.
     public let moduleUri: String
 
-    /// The qualified name of this class.
+    /// The name of this class.
     /// Will be an empty string for values encoded by Pkl versions older than 0.30.
-    public let qualifiedName: String
+    public let name: String
 }
 
 extension Class: PklSerializableType, Sendable {
     public static let messageTag: PklValueType = .class
 
     public static func decode(_ fields: [MessagePackValue], codingPath: [any CodingKey]) throws -> Class {
-        if fields.count > 1 { // pkl 0.30+ includes the qualified name and module uri
+        if fields.count > 1 { // pkl 0.30+ includes the name and module uri
             try checkFieldCount(fields, codingPath: codingPath, min: 3)
             return try Class(
-                moduleUri: fields[1].decode(String.self),
-                qualifiedName: fields[2].decode(String.self)
+                moduleUri: fields[2].decode(String.self),
+                name: fields[1].decode(String.self)
             )
         }
 
         try checkFieldCount(fields, codingPath: codingPath, min: 1)
-        return Class(moduleUri: "", qualifiedName: "")
+        return Class(moduleUri: "", name: "")
     }
 }

Sources/PklSwift/API/TypeAlias.swift

@@ -22,24 +22,24 @@ public struct TypeAlias: Hashable {
     /// Will be an empty string for values encoded by Pkl versions older than 0.30.
     public let moduleUri: String
 
-    /// The qualified name of this typealias.
+    /// The name of this typealias.
     /// Will be an empty string for values encoded by Pkl versions older than 0.30.
-    public let qualifiedName: String
+    public let name: String
 }
 
 extension TypeAlias: PklSerializableType, Sendable {
     public static let messageTag: PklValueType = .typealias
 
     public static func decode(_ fields: [MessagePackValue], codingPath: [any CodingKey]) throws -> TypeAlias {
-        if fields.count > 1 { // pkl 0.30+ includes the qualified name and module uri
+        if fields.count > 1 { // pkl 0.30+ includes the name and module uri
             try checkFieldCount(fields, codingPath: codingPath, min: 3)
             return try TypeAlias(
-                moduleUri: fields[1].decode(String.self),
-                qualifiedName: fields[2].decode(String.self)
+                moduleUri: fields[2].decode(String.self),
+                name: fields[1].decode(String.self)
             )
         }
 
         try checkFieldCount(fields, codingPath: codingPath, min: 1)
-        return TypeAlias(moduleUri: "", qualifiedName: "")
+        return TypeAlias(moduleUri: "", name: "")
     }
 }

Tests/PklSwiftTests/Fixtures/ApiTypes.pkl

@@ -4,6 +4,10 @@ res1: Duration = 10.h
 res2: DataSize = 1.2345.gib
 
 stringClass: Class = String
-moduleClass: Class = base.getClass()
-typeAlias: TypeAlias = UInt8
+baseModuleClass: Class = base.getClass()
+uint8TypeAlias: TypeAlias = UInt8
+fooClass: Class = Foo
+barTypeAlias: TypeAlias = Bar
 
+class Foo {}
+typealias Bar = Foo

Tests/PklSwiftTests/Fixtures/Generated/ApiTypes.pkl.swift

@@ -13,25 +13,41 @@ extension ApiTypes {
 
         public var stringClass: Class
 
-        public var moduleClass: Class
+        public var baseModuleClass: Class
 
-        public var typeAlias: TypeAlias
+        public var uint8TypeAlias: TypeAlias
+
+        public var fooClass: Class
+
+        public var barTypeAlias: TypeAlias
 
         public init(
             res1: Duration,
             res2: DataSize,
             stringClass: Class,
-            moduleClass: Class,
-            typeAlias: TypeAlias
+            baseModuleClass: Class,
+            uint8TypeAlias: TypeAlias,
+            fooClass: Class,
+            barTypeAlias: TypeAlias
         ) {
             self.res1 = res1
             self.res2 = res2
             self.stringClass = stringClass
-            self.moduleClass = moduleClass
-            self.typeAlias = typeAlias
+            self.baseModuleClass = baseModuleClass
+            self.uint8TypeAlias = uint8TypeAlias
+            self.fooClass = fooClass
+            self.barTypeAlias = barTypeAlias
         }
     }
 
+    public struct Foo: PklRegisteredType, Decodable, Hashable, Sendable {
+        public static let registeredIdentifier: String = "ApiTypes#Foo"
+
+        public init() {}
+    }
+
+    public typealias Bar = Foo
+
     /// Load the Pkl module at the given source and evaluate it into `ApiTypes.Module`.
     ///
     /// - Parameter source: The source of the Pkl module.

Tests/PklSwiftTests/FixturesTest.swift

@@ -86,23 +86,31 @@ class FixturesTest: XCTestCase {
     }
 
     func testEvaluateApiTypes() async throws {
+        let inputPath = "\(#filePath)/../Fixtures/ApiTypes.pkl"
         let result = try await ApiTypes.loadFrom(
             evaluator: self.evaluator,
-            source: .path("\(#filePath)/../Fixtures/ApiTypes.pkl")
+            source: .path(inputPath)
         )
 
         let stringClass: Class
-        let moduleClass: Class
-        let typeAlias: TypeAlias
+        let baseModuleClass: Class
+        let uint8TypeAlias: TypeAlias
+        let fooClass: Class
+        let barTypeAlias: TypeAlias
         let version = try await SemanticVersion(EvaluatorManager().getVersion())!
         if version < pklVersion0_30 {
-            stringClass = Class(moduleUri: "", qualifiedName: "")
-            moduleClass = Class(moduleUri: "", qualifiedName: "")
-            typeAlias = TypeAlias(moduleUri: "", qualifiedName: "")
+            stringClass = Class(moduleUri: "", name: "")
+            baseModuleClass = Class(moduleUri: "", name: "")
+            uint8TypeAlias = TypeAlias(moduleUri: "", name: "")
+            fooClass = Class(moduleUri: "", name: "")
+            barTypeAlias = TypeAlias(moduleUri: "", name: "")
         } else {
-            stringClass = Class(moduleUri: "pkl:base", qualifiedName: "pkl.base#String")
-            moduleClass = Class(moduleUri: "pkl:base", qualifiedName: "pkl.base")
-            typeAlias = TypeAlias(moduleUri: "pkl:base", qualifiedName: "pkl.base#UInt8")
+            let inputModuleURI = URL(filePath: inputPath).absoluteString
+            stringClass = Class(moduleUri: "pkl:base", name: "String")
+            baseModuleClass = Class(moduleUri: "pkl:base", name: "ModuleClass")
+            uint8TypeAlias = TypeAlias(moduleUri: "pkl:base", name: "UInt8")
+            fooClass = Class(moduleUri: inputModuleURI, name: "ApiTypes#Foo")
+            barTypeAlias = TypeAlias(moduleUri: inputModuleURI, name: "ApiTypes#Bar")
         }
 
         XCTAssertEqual(
@@ -111,8 +119,10 @@ class FixturesTest: XCTestCase {
                 res1: .hours(10),
                 res2: .gibibytes(1.2345),
                 stringClass: stringClass,
-                moduleClass: moduleClass,
-                typeAlias: typeAlias
+                baseModuleClass: baseModuleClass,
+                uint8TypeAlias: uint8TypeAlias,
+                fooClass: fooClass,
+                barTypeAlias: barTypeAlias
             )
         )
     }