feat: Generate schemas with native-Swift code generator

Package.swift

@@ -311,7 +311,9 @@ let package = Package(
             name: "SmithyCodegenCore",
             dependencies: [
                 "Smithy",
-            ]
+                "SmithySerialization",
+            ],
+            resources: [ .process("Resources") ]
         ),
         .testTarget(
             name: "ClientRuntimeTests",
@@ -400,5 +402,9 @@ let package = Package(
             name: "SmithyStreamsTests",
             dependencies: ["SmithyStreams", "Smithy"]
         ),
+        .testTarget(
+            name: "SmithyCodegenCoreTests",
+            dependencies: ["SmithyCodegenCore"]
+        ),
     ].compactMap { $0 }
 )

Plugins/SmithyCodeGenerator/SmithyCodeGeneratorPlugin.swift

@@ -49,19 +49,27 @@ struct SmithyCodeGeneratorPlugin: BuildToolPlugin {
         let modelPathURL = currentWorkingDirectoryFileURL.appendingPathComponent(smithyModelInfo.path)
         let modelPath = Path(modelPathURL.path)
 
-        // Construct the schemas.swift path.
+        // Construct the Schemas.swift path.
         let schemasSwiftPath = outputDirectoryPath.appending("\(name)Schemas.swift")
 
+        // Construct the Serialize.swift path.
+        let serializeSwiftPath = outputDirectoryPath.appending("\(name)Serialize.swift")
+
+        // Construct the Deserialize.swift path.
+        let deserializeSwiftPath = outputDirectoryPath.appending("\(name)Deserialize.swift")
+
         // Construct the build command that invokes SmithyCodegenCLI.
         return .buildCommand(
             displayName: "Generating Swift source files from model file \(smithyModelInfo.path)",
             executable: generatorToolPath,
             arguments: [
                 "--schemas-path", schemasSwiftPath,
+                "--serialize-path", serializeSwiftPath,
+                "--deserialize-path", deserializeSwiftPath,
                 modelPath
             ],
             inputFiles: [inputPath, modelPath],
-            outputFiles: [schemasSwiftPath]
+            outputFiles: [schemasSwiftPath, serializeSwiftPath, deserializeSwiftPath]
         )
     }
 }

Sources/Smithy/Schema/Schema.swift

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-/// A class which describes selected Smithy model information for a Smithy model shape.
+/// A class which describes selected, modeled information for a Smithy shape.
 ///
 /// Typically, the Schema contains only modeled info & properties that are relevant to
 /// serialization, transport bindings, and other functions performed by the SDK.
@@ -29,7 +29,13 @@ public final class Schema: Sendable {
     public let members: [Schema]
 
     /// The target schema for this schema.  Will only be used when this is a member schema.
-    public let target: Schema?
+    public var target: Schema? {
+        _target()
+    }
+
+    /// Target schema is passed as an autoclosure so that schemas with self-referencing targets will not cause
+    /// an infinite loop when accessed.
+    private let _target: @Sendable () -> Schema?
 
     /// The index of this schema, if it represents a Smithy member.
     ///
@@ -49,24 +55,14 @@ public final class Schema: Sendable {
         type: ShapeType,
         traits: [ShapeID: Node] = [:],
         members: [Schema] = [],
-        target: Schema? = nil,
+        target: @Sendable @escaping @autoclosure () -> Schema? = nil,
         index: Int = -1
     ) {
         self.id = id
         self.type = type
         self.traits = traits
         self.members = members
-        self.target = target
+        self._target = target
         self.index = index
     }
 }
-
-public extension Schema {
-
-    /// The member name for this schema, if any.
-    ///
-    /// Member name is computed from the schema's ID.
-    var memberName: String? {
-        id.member
-    }
-}

Sources/SmithyCodegenCLI/SmithyCodegenCLI.swift

@@ -12,14 +12,17 @@ import struct SmithyCodegenCore.CodeGenerator
 @main
 struct SmithyCodegenCLI: AsyncParsableCommand {
 
-    @Argument(help: "The full or relative path to the JSON model file.")
+    @Argument(help: "The full or relative path to read the JSON AST model input file.")
     var modelPath: String
 
-    @Option(help: "The full or relative path to write the schemas output file.")
+    @Option(help: "The full or relative path to write the Schemas output file.")
     var schemasPath: String?
 
-    @Option(help: "The full or relative path to write the struct consumers output file.")
-    var structConsumersPath: String?
+    @Option(help: "The full or relative path to write the Serialize output file.")
+    var serializePath: String?
+
+    @Option(help: "The full or relative path to write the Deserialize output file.")
+    var deserializePath: String?
 
     func run() async throws {
         let currentWorkingDirectoryFileURL = currentWorkingDirectoryFileURL()
@@ -35,10 +38,24 @@ struct SmithyCodegenCLI: AsyncParsableCommand {
         // If --schemas-path was supplied, create the schema file URL
         let schemasFileURL = resolve(paramName: "--schemas-path", path: schemasPath)
 
+        // If --serialize-path was supplied, create the Serialize file URL
+        let serializeFileURL = resolve(
+            paramName: "--serialize-path",
+            path: serializePath
+        )
+
+        // If --deserialize-path was supplied, create the Deserialize file URL
+        let deserializeFileURL = resolve(
+            paramName: "--deserialize-path",
+            path: deserializePath
+        )
+
         // Use resolved file URLs to run code generator
         try CodeGenerator(
             modelFileURL: modelFileURL,
-            schemasFileURL: schemasFileURL
+            schemasFileURL: schemasFileURL,
+            serializeFileURL: serializeFileURL,
+            deserializeFileURL: deserializeFileURL
         ).run()
     }
 

Sources/SmithyCodegenCore/CodeGenerator.swift

@@ -6,20 +6,25 @@
 //
 
 import struct Foundation.Data
-import class Foundation.FileManager
 import class Foundation.JSONDecoder
 import struct Foundation.URL
 
 public struct CodeGenerator {
     let modelFileURL: URL
     let schemasFileURL: URL?
+    let serializeFileURL: URL?
+    let deserializeFileURL: URL?
 
     public init(
         modelFileURL: URL,
-        schemasFileURL: URL?
+        schemasFileURL: URL?,
+        serializeFileURL: URL?,
+        deserializeFileURL: URL?
     ) {
         self.modelFileURL = modelFileURL
         self.schemasFileURL = schemasFileURL
+        self.serializeFileURL = serializeFileURL
+        self.deserializeFileURL = deserializeFileURL
     }
 
     public func run() throws {
@@ -31,17 +36,24 @@ public struct CodeGenerator {
         let model = try Model(astModel: astModel)
 
         // Create a generation context from the model
-        _ = try GenerationContext(model: model)
+        let ctx = try GenerationContext(model: model)
 
-        // Generation context will be used here in the future
-        // to generate needed files.
-
-        // This code simply writes an empty schemas file, since it is expected to exist after the
-        // code generator plugin runs.
-        //
-        // Actual code generation will be implemented here later.
+        // If a schemas file URL was provided, generate it
         if let schemasFileURL {
-            FileManager.default.createFile(atPath: schemasFileURL.path, contents: Data())
+            let schemasContents = try SmithySchemaCodegen().generate(ctx: ctx)
+            try Data(schemasContents.utf8).write(to: schemasFileURL)
+        }
+
+        // If a Serialize file URL was provided, generate it
+        if let serializeFileURL {
+            let serializeContents = try SerializeCodegen().generate(ctx: ctx)
+            try Data(serializeContents.utf8).write(to: serializeFileURL)
+        }
+
+        // If a Deserialize file URL was provided, generate it
+        if let deserializeFileURL {
+            let deserializeContents = try DeserializeCodegen().generate(ctx: ctx)
+            try Data(deserializeContents.utf8).write(to: deserializeFileURL)
         }
     }
 }

Sources/SmithyCodegenCore/Deserialize/DeserializeCodegen.swift

@@ -0,0 +1,156 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package struct DeserializeCodegen {
+
+    package init() {}
+
+    package func generate(ctx: GenerationContext) throws -> String {
+        let writer = SwiftWriter()
+        writer.write("import Foundation")
+        writer.write("import enum Smithy.Prelude")
+        writer.write("import class Smithy.Schema")
+        writer.write("import protocol SmithySerialization.ShapeDeserializer")
+        writer.write("import protocol SmithySerialization.DeserializableStruct")
+        writer.write("import typealias SmithySerialization.StructMemberConsumer")
+        writer.write("")
+
+        let structsAndUnions = ctx.model.allShapesSorted.filter { $0.type == .structure || $0.type == .union }
+        for shape in structsAndUnions {
+            let swiftType = try ctx.symbolProvider.swiftType(shape: shape)
+            try writer.openBlock("extension \(swiftType): SmithySerialization.DeserializableStruct {", "}") { writer in
+                writer.write("")
+                let consumerType = "SmithySerialization.StructMemberConsumer<\(swiftType)>"
+                try writer.openBlock(
+                    "public static var consumer: \(consumerType) {", "}") { writer in
+                    try writer.openBlock("{ memberSchema, structure, deserializer in", "}") { writer in
+                        try writer.openBlock("switch memberSchema.index {", "}") { writer in
+                            writer.dedent()
+                            for (index, member) in members(of: shape).enumerated() {
+                                writer.write("case \(index):")
+                                writer.indent()
+                                try writeDeserializeCall(
+                                    ctx: ctx, writer: writer, shape: shape, member: member, index: index
+                                )
+                                writer.dedent()
+                            }
+                            writer.write("default: break")
+                            writer.indent()
+                        }
+                    }
+                }
+                writer.write("")
+                let deserializerType = "any SmithySerialization.ShapeDeserializer"
+                writer.openBlock(
+                    "public mutating func deserialize(_ deserializer: \(deserializerType)) throws {", "}"
+                ) { writer in
+                    writer.write("var value = self")
+                    writer.write("try deserializer.readStruct(Self.schema, &value, Self.consumer)")
+                    writer.write("self = value")
+                }
+            }
+            writer.write("")
+        }
+        writer.unwrite("\n")
+        return writer.finalize()
+    }
+
+    private func writeDeserializeCall(
+        ctx: GenerationContext, writer: SwiftWriter, shape: Shape, member: MemberShape, index: Int
+    ) throws {
+        switch member.target.type {
+        case .structure:
+            try writeStructureDeserializeCall(
+                ctx: ctx, writer: writer, shape: shape, member: member, index: index, initializer: "()"
+            )
+        case .union:
+            try writeStructureDeserializeCall(
+                ctx: ctx, writer: writer, shape: shape, member: member, index: index, initializer: ".sdkUnknown(\"\")"
+            )
+        case .list, .set:
+            let listShape = member.target as! ListShape // swiftlint:disable:this force_cast
+            let elementSwiftType = try ctx.symbolProvider.swiftType(shape: listShape.member.target)
+            writer.write("var value = [\(elementSwiftType)]()")
+            let schemaVarName = try shape.schemaVarName
+            try writer.openBlock(
+                "try deserializer.readList(\(schemaVarName).members[\(index)], &value) { deserializer in",
+                "}"
+            ) { writer in
+                try writeDeserializeCall(ctx: ctx, writer: writer, shape: listShape, member: listShape.member, index: 0)
+            }
+            try writeAssignment(ctx: ctx, writer: writer, shape: shape, member: member)
+        case .map:
+            let mapShape = member.target as! MapShape // swiftlint:disable:this force_cast
+            let keySwiftType = try ctx.symbolProvider.swiftType(shape: mapShape.key.target)
+            let valueSwiftType = try ctx.symbolProvider.swiftType(shape: mapShape.value.target)
+            writer.write("var value = [\(keySwiftType): \(valueSwiftType)]()")
+            let schemaVarName = try shape.schemaVarName
+            try writer.openBlock(
+                "try deserializer.readMap(\(schemaVarName).members[\(index)], &value) { key, deserializer in",
+                "}"
+            ) { writer in
+                try writeDeserializeCall(ctx: ctx, writer: writer, shape: mapShape, member: mapShape.value, index: 1)
+            }
+            try writeAssignment(ctx: ctx, writer: writer, shape: shape, member: member)
+        default:
+            let propertyName = try ctx.symbolProvider.propertyName(shapeID: member.id)
+            let methodName = try member.target.deserializeMethodName
+            let schemaVarName = try shape.schemaVarName
+            let properties = shape.hasTrait(.init("smithy.api", "error")) ? "properties." : ""
+            let lhs = switch shape.type {
+            case .list, .set, .map:
+                ""
+            default:
+                "structure.\(properties)\(propertyName) = "
+            }
+            writer.write("\(lhs)try deserializer.\(methodName)(\(schemaVarName).members[\(index)])")
+        }
+    }
+
+    private func writeStructureDeserializeCall(
+        ctx: GenerationContext, writer: SwiftWriter, shape: Shape, member: MemberShape, index: Int, initializer: String
+    ) throws {
+        let target = member.target
+        let propertySwiftType = try ctx.symbolProvider.swiftType(shape: target)
+        let schemaVarName = try shape.schemaVarName
+        let consumer = "\(propertySwiftType).consumer"
+        writer.write("var value = \(propertySwiftType)\(initializer)")
+        writer.write("try deserializer.readStruct(\(schemaVarName).members[\(index)], &value, \(consumer))")
+        try writeAssignment(ctx: ctx, writer: writer, shape: shape, member: member)
+    }
+
+    private func writeAssignment(
+        ctx: GenerationContext, writer: SwiftWriter, shape: Shape, member: MemberShape
+    ) throws {
+        // Only the "composite types" need to have an assignment written.
+        guard [.structure, .union, .list, .set, .map].contains(member.target.type) else { return }
+
+        // The assignment being written is based on the shape enclosing the member.
+        switch shape.type {
+        case .structure:
+            // For a structure member, write the value to the appropriate structure property,
+            // making the appropriate adjustment for an error.
+            let properties = shape.hasTrait(.init("smithy.api", "error")) ? "properties." : ""
+            let propertyName = try ctx.symbolProvider.propertyName(shapeID: member.id)
+            writer.write("structure.\(properties)\(propertyName) = value")
+        case .union:
+            // For a union member, write the value to the appropriate union case
+            let enumCaseName = try ctx.symbolProvider.enumCaseName(shapeID: member.id)
+            writer.write("structure = .\(enumCaseName)(value)")
+        case .list, .set, .map:
+            // For a collection member, return it to the caller since this is being written
+            // into a consumer block that returns the collection element.
+            writer.write("return value")
+        default: break
+        }
+    }
+
+    private func members(of shape: Shape) -> [MemberShape] {
+        guard let hasMembers = shape as? HasMembers else { return [] }
+        return hasMembers.members
+    }
+}