fix: disambiguate sdk types (#301)

Author: kneekey23

Packages/ClientRuntime/Sources/Serialization/Decoder/JSONDecoder+Extensions.swift

@@ -5,6 +5,7 @@
 
 import Foundation
 
+public typealias JSONDecoder = Foundation.JSONDecoder
 extension JSONDecoder: ResponseDecoder {
     public func decode<T>(responseBody: Data) throws -> T where T: Decodable {
         return try decode(T.self, from: responseBody)

Packages/ClientRuntime/Sources/Serialization/Encoder/JSONEncoder+Extensions.swift

@@ -5,4 +5,5 @@
 
 import Foundation
 
+public typealias JSONEncoder = Foundation.JSONEncoder
 extension JSONEncoder: RequestEncoder {}

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/ClientRuntimeTypes.kt

@@ -17,22 +17,70 @@ object ClientRuntimeTypes {
     object Http {
         val HttpClientEngine = runtimeSymbol("HttpClientEngine")
         val HttpClientConfiguration = runtimeSymbol("HttpClientConfiguration")
+        val Headers = runtimeSymbol("Headers")
+        val HttpStatusCode = runtimeSymbol("HttpStatusCode")
+        val SdkHttpClient = runtimeSymbol("SdkHttpClient")
+        val SdkHttpRequestBuilder = runtimeSymbol("SdkHttpRequestBuilder")
+        val SdkHttpRequest = runtimeSymbol("SdkHttpRequest")
+        val HttpBody = runtimeSymbol("HttpBody")
+        val HttpResponse = runtimeSymbol("HttpResponse")
+        val HttpResponseBinding = runtimeSymbol("HttpResponseBinding")
+        val HttpServiceError = runtimeSymbol("HttpServiceError")
+        val UnknownHttpServiceError = runtimeSymbol("UnknownHttpServiceError")
+        val HttpContextBuilder = runtimeSymbol("HttpContextBuilder")
     }
 
     object Serde {
         val RequestEncoder = runtimeSymbol("RequestEncoder")
         val ResponseDecoder = runtimeSymbol("ResponseDecoder")
+        val Key = runtimeSymbol("Key")
+        val TimestampWrapper = runtimeSymbol("TimestampWrapper")
+        val DynamicNodeDecoding = runtimeSymbol("DynamicNodeDecoding")
+        val DynamicNodeEncoding = runtimeSymbol("DynamicNodeEncoding")
+        val NodeDecoding = runtimeSymbol("NodeDecoding")
+        val NodeEncoding = runtimeSymbol("NodeEncoding")
+        val TimestampWrapperDecoder = runtimeSymbol("TimestampWrapperDecoder")
+        val MapEntry = runtimeSymbol("MapEntry")
+        val CollectionMember = runtimeSymbol("CollectionMember")
+        val MapKeyValue = runtimeSymbol("MapKeyValue")
+        val FormURLEncoder = runtimeSymbol("FormURLEncoder")
+        val JSONDecoder = runtimeSymbol("JSONDecoder")
+        val JSONEncoder = runtimeSymbol("JSONEncoder")
+        val XMLEncoder = runtimeSymbol("XMLEncoder")
+        val XMLDecoder = runtimeSymbol("XMLDecoder")
+    }
+
+    object Middleware {
+        val OperationOutput = runtimeSymbol("OperationOutput")
+        val Middleware = runtimeSymbol("Middleware")
     }
 
     object Core {
+        val ByteStream = runtimeSymbol("ByteStream")
+        val Date = runtimeSymbol("Date")
+        val Data = runtimeSymbol("Data")
+        val Document = runtimeSymbol("Document")
+        val URLQueryItem = runtimeSymbol("URLQueryItem")
+        val ClientError = runtimeSymbol("ClientError")
+        val SdkError = runtimeSymbol("SdkError")
+        val ServiceError = runtimeSymbol("ServiceError")
+        val SdkResult = runtimeSymbol("SdkResult")
         val Logger = runtimeSymbol("LogAgent")
+        val SDKLogHandlerFactory = runtimeSymbol("SDKLogHandlerFactory")
+        val SDKLogLevel = runtimeSymbol("SDKLogLevel")
         val ClientLogMode = runtimeSymbol("ClientLogMode")
         val IdempotencyTokenGenerator = runtimeSymbol("IdempotencyTokenGenerator")
         val Retrier = runtimeSymbol("Retrier")
+        val ErrorType = runtimeSymbol("ErrorType")
+        val SDKRuntimeConfiguration = runtimeSymbol("SDKRuntimeConfiguration")
+        val DefaultSDKRuntimeConfiguration = runtimeSymbol("DefaultSDKRuntimeConfiguration")
+        val DateFormatter = runtimeSymbol("DateFormatter")
+        val Reflection: Symbol = runtimeSymbol("Reflection")
     }
 }
 
 private fun runtimeSymbol(name: String): Symbol = buildSymbol {
     this.name = name
+    this.namespace = SwiftDependency.CLIENT_RUNTIME.target
     dependency(SwiftDependency.CLIENT_RUNTIME)
 }

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/CodegenVisitor.kt

@@ -21,6 +21,11 @@ import software.amazon.smithy.model.traits.EnumTrait
 import software.amazon.smithy.swift.codegen.integration.CustomDebugStringConvertibleGenerator
 import software.amazon.smithy.swift.codegen.integration.ProtocolGenerator
 import software.amazon.smithy.swift.codegen.integration.SwiftIntegration
+import software.amazon.smithy.swift.codegen.model.AddOperationShapes
+import software.amazon.smithy.swift.codegen.model.HashableShapeTransformer
+import software.amazon.smithy.swift.codegen.model.NestedShapeTransformer
+import software.amazon.smithy.swift.codegen.model.RecursiveShapeBoxer
+import software.amazon.smithy.swift.codegen.model.hasTrait
 import java.util.ServiceLoader
 import java.util.logging.Logger
 
@@ -48,11 +53,7 @@ class CodegenVisitor(context: PluginContext) : ShapeVisitor.Default<Void>() {
         for (integration in integrations) {
             resolvedModel = integration.preprocessModel(resolvedModel, settings)
         }
-        // Add operation input/output shapes if not provided for future evolution of sdk
-        resolvedModel = AddOperationShapes.execute(resolvedModel, settings.getService(resolvedModel), settings.moduleName)
-        resolvedModel = RecursiveShapeBoxer.transform(resolvedModel)
-        resolvedModel = HashableShapeTransformer.transform(resolvedModel)
-        model = resolvedModel
+        model = preprocessModel(resolvedModel)
 
         service = settings.getService(model)
 
@@ -66,6 +67,15 @@ class CodegenVisitor(context: PluginContext) : ShapeVisitor.Default<Void>() {
         protocolGenerator = resolveProtocolGenerator(integrations, model, service, settings)
     }
 
+    fun preprocessModel(model: Model): Model {
+        var resolvedModel = model
+        resolvedModel = AddOperationShapes.execute(resolvedModel, settings.getService(resolvedModel), settings.moduleName)
+        resolvedModel = RecursiveShapeBoxer.transform(resolvedModel)
+        resolvedModel = HashableShapeTransformer.transform(resolvedModel)
+        resolvedModel = NestedShapeTransformer.transform(resolvedModel, settings.getService(resolvedModel))
+        return resolvedModel
+    }
+
     private fun resolveProtocolGenerator(
         integrations: List<SwiftIntegration>,
         model: Model,
@@ -127,29 +137,30 @@ class CodegenVisitor(context: PluginContext) : ShapeVisitor.Default<Void>() {
     }
 
     override fun structureShape(shape: StructureShape): Void? {
-        writers.useShapeWriter(shape) { writer: SwiftWriter -> StructureGenerator(model, symbolProvider, writer, shape).render() }
+        writers.useShapeWriter(shape) { writer: SwiftWriter -> StructureGenerator(model, symbolProvider, writer, shape, settings).render() }
         writers.useShapeExtensionWriter(shape, "CustomDebugStringConvertible") { writer: SwiftWriter ->
             CustomDebugStringConvertibleGenerator(symbolProvider, writer, shape).render()
         }
         return null
     }
 
     override fun stringShape(shape: StringShape): Void? {
-        if (shape.hasTrait(EnumTrait::class.java)) {
-            writers.useShapeWriter(shape) { writer: SwiftWriter -> EnumGenerator(symbolProvider.toSymbol(shape), writer, shape).render() }
+        if (shape.hasTrait<EnumTrait>()) {
+            writers.useShapeWriter(shape) { writer: SwiftWriter -> EnumGenerator(model, symbolProvider, writer, shape, settings).render() }
         }
         return null
     }
 
     override fun unionShape(shape: UnionShape): Void? {
-        writers.useShapeWriter(shape) { writer: SwiftWriter -> UnionGenerator(model, symbolProvider, writer, shape).render() }
+        writers.useShapeWriter(shape) { writer: SwiftWriter -> UnionGenerator(model, symbolProvider, writer, shape, settings).render() }
         return null
     }
 
     override fun serviceShape(shape: ServiceShape): Void? {
         writers.useShapeWriter(shape) {
             writer: SwiftWriter ->
             ServiceGenerator(settings, model, symbolProvider, writer, writers, protocolGenerator).render()
+            ServiceNamespaceGenerator(settings, model, symbolProvider, writer).render()
         }
         return null
     }

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/EnumGenerator.kt

@@ -5,11 +5,17 @@
 
 package software.amazon.smithy.swift.codegen
 
-import software.amazon.smithy.codegen.core.Symbol
+import software.amazon.smithy.codegen.core.SymbolProvider
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.model.shapes.ServiceShape
 import software.amazon.smithy.model.shapes.StringShape
 import software.amazon.smithy.model.traits.EnumDefinition
 import software.amazon.smithy.model.traits.EnumTrait
 import software.amazon.smithy.swift.codegen.SwiftSettings.Companion.reservedKeywords
+import software.amazon.smithy.swift.codegen.customtraits.NestedTrait
+import software.amazon.smithy.swift.codegen.model.expectShape
+import software.amazon.smithy.swift.codegen.model.hasTrait
+import software.amazon.smithy.swift.codegen.model.nestedNamespaceType
 import software.amazon.smithy.utils.CaseUtils
 
 /**
@@ -100,9 +106,11 @@ import software.amazon.smithy.utils.CaseUtils
  * ```
  */
 class EnumGenerator(
-    private val symbol: Symbol,
+    private val model: Model,
+    private val symbolProvider: SymbolProvider,
     private val writer: SwiftWriter,
-    private val shape: StringShape
+    private val shape: StringShape,
+    private val settings: SwiftSettings
 ) {
 
     init {
@@ -113,20 +121,33 @@ class EnumGenerator(
         shape.getTrait(EnumTrait::class.java).get()
     }
 
-    var allCasesBuilder: MutableList<String> = mutableListOf<String>()
-    var rawValuesBuilder: MutableList<String> = mutableListOf<String>()
+    private var allCasesBuilder: MutableList<String> = mutableListOf()
+    private var rawValuesBuilder: MutableList<String> = mutableListOf()
 
     fun render() {
+        val symbol = symbolProvider.toSymbol(shape)
         writer.putContext("enum.name", symbol.name)
+        val isNestedType = shape.hasTrait<NestedTrait>()
+        if (isNestedType) {
+            val service = model.expectShape<ServiceShape>(settings.service)
+            writer.openBlock("extension ${service.nestedNamespaceType(symbolProvider)} {", "}") {
+                renderEnum()
+            }
+        } else {
+            renderEnum()
+        }
+        writer.removeContext("enum.name")
+    }
+
+    private fun renderEnum() {
         writer.writeShapeDocs(shape)
         writer.writeAvailableAttribute(null, shape)
-        writer.openBlock("public enum \$enum.name:L {", "}\n") {
+        writer.openBlock("public enum \$enum.name:L: \$N, \$N, \$N, \$N, \$N {", "}", SwiftTypes.Protocols.Equatable, SwiftTypes.Protocols.RawRepresentable, SwiftTypes.Protocols.CaseIterable, SwiftTypes.Protocols.Codable, SwiftTypes.Protocols.Hashable) {
             createEnumWriterContexts()
             // add the sdkUnknown case which will always be last
-            writer.write("case sdkUnknown(String)")
-        }
+            writer.write("case sdkUnknown(\$N)", SwiftTypes.String)
 
-        writer.openBlock("extension \$enum.name:L : Equatable, RawRepresentable, Codable, CaseIterable, Hashable { ", "}") {
+            writer.write("")
 
             // Generate allCases static array
             generateAllCasesBlock()
@@ -140,7 +161,6 @@ class EnumGenerator(
             // Generate deserializer
             generateInitFromDecoderBlock()
         }
-        writer.removeContext("enum.name")
     }
 
     fun addEnumCaseToEnum(definition: EnumDefinition) {
@@ -178,23 +198,23 @@ class EnumGenerator(
     }
 
     fun generateInitFromRawValueBlock() {
-        writer.openBlock("public init?(rawValue: String) {", "}") {
+        writer.openBlock("public init?(rawValue: \$N) {", "}", SwiftTypes.String) {
             writer.write("let value = Self.allCases.first(where: { \$\$0.rawValue == rawValue })")
             writer.write("self = value ?? Self.sdkUnknown(rawValue)")
         }
     }
 
     fun generateRawValueEnumBlock() {
         rawValuesBuilder.add("case let .sdkUnknown(s): return s")
-        writer.openBlock("public var rawValue: String {", "}") {
+        writer.openBlock("public var rawValue: \$N {", "}", SwiftTypes.String) {
             writer.write("switch self {")
             writer.write(rawValuesBuilder.joinToString("\n"))
             writer.write("}")
         }
     }
 
     fun generateInitFromDecoderBlock() {
-        writer.openBlock("public init(from decoder: Decoder) throws {", "}") {
+        writer.openBlock("public init(from decoder: \$N) throws {", "}", SwiftTypes.Decoder) {
             writer.write("let container = try decoder.singleValueContainer()")
             writer.write("let rawValue = try container.decode(RawValue.self)")
             writer.write("self = \$enum.name:L(rawValue: rawValue) ?? \$enum.name:L.sdkUnknown(rawValue)")

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/IdempotencyTokenMiddlewareGenerator.kt

@@ -31,7 +31,7 @@ class IdempotencyTokenMiddlewareGenerator(
      * */
     fun renderIdempotencyMiddleware() {
         // TODO: Need to write a unit test for this
-        writer.openBlock("$operationMiddlewareStackName.initializeStep.intercept(position: .before, id: \"IdempotencyTokenMiddleware\") { (context, input, next) -> Result<OperationOutput<$outputShapeName>, SdkError<$outputErrorShapeName>> in", "}") {
+        writer.openBlock("$operationMiddlewareStackName.initializeStep.intercept(position: .before, id: \"IdempotencyTokenMiddleware\") { (context, input, next) -> \$N<\$N<$outputShapeName>, \$N<$outputErrorShapeName>> in", "}", SwiftTypes.Result, ClientRuntimeTypes.Middleware.OperationOutput, ClientRuntimeTypes.Core.SdkError) {
             writer.write("let idempotencyTokenGenerator = context.getIdempotencyTokenGenerator()")
             writer.write("var copiedInput = input")
             writer.openBlock("if input.$idempotentMemberName == nil {", "}") {

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/Middleware.kt

@@ -14,16 +14,17 @@ abstract class Middleware(private val writer: SwiftWriter, shapeSymbol: Symbol,
     open val contextType: Symbol = Symbol
         .builder()
         .name("HttpContext")
+        .namespace(SwiftDependency.CLIENT_RUNTIME.target, ".")
         .addDependency(SwiftDependency.CLIENT_RUNTIME)
         .build()
 
-    open val typesToConformMiddlewareTo: List<String> = mutableListOf("Middleware")
+    open val typesToConformMiddlewareTo: List<Symbol> = mutableListOf(ClientRuntimeTypes.Middleware.Middleware)
 
     open val properties: MutableMap<String, Symbol> = mutableMapOf()
 
     fun getTypeInheritance(): String {
         val separator = if (typesToConformMiddlewareTo.count() == 1) "" else ", "
-        return typesToConformMiddlewareTo.joinToString(separator)
+        return typesToConformMiddlewareTo.joinToString(separator) { it.toString() }
     }
 
     abstract fun generateInit()

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/MiddlewareGenerator.kt

@@ -28,7 +28,7 @@ class MiddlewareGenerator(
     fun generate() {
 
         writer.openBlock("public struct ${middleware.typeName}: ${middleware.getTypeInheritance()} {", "}") {
-            writer.write("public let id: String = \"${middleware.typeName}\"")
+            writer.write("public let id: \$N = \"${middleware.typeName}\"", SwiftTypes.String)
             writer.write("")
             middleware.properties.forEach {
                 val memberName = it.key
@@ -40,8 +40,8 @@ class MiddlewareGenerator(
             writer.write("")
             writer.write("public func handle<H>(context: Context,")
             writer.swiftFunctionParameterIndent {
-                writer.write("  input: ${middleware.inputType.name},")
-                writer.write("  next: H) -> Swift.Result<${middleware.outputType.name}, MError>")
+                writer.write("  input: \$N,", middleware.inputType)
+                writer.write("  next: H) -> \$N<\$L, MError>", SwiftTypes.Result, middleware.outputType)
             }
             writer.write("where H: Handler,")
             writer.write("Self.MInput == H.Input,")
@@ -52,10 +52,10 @@ class MiddlewareGenerator(
                 middleware.renderReturn()
             }
             writer.write("")
-            writer.write("public typealias MInput = ${middleware.inputType.name}")
-            writer.write("public typealias MOutput = ${middleware.outputType.name}")
-            writer.write("public typealias Context = ClientRuntime.${middleware.contextType.name}")
-            writer.write("public typealias MError = ${middleware.errorType.name}")
+            writer.write("public typealias MInput = \$N", middleware.inputType)
+            writer.write("public typealias MOutput = \$L", middleware.outputType)
+            writer.write("public typealias Context = \$N", middleware.contextType)
+            writer.write("public typealias MError = \$L", middleware.errorType)
         }
     }
 }

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/OperationStep.kt

@@ -6,13 +6,13 @@ abstract class OperationStep(outputType: Symbol, outputErrorType: Symbol) {
     abstract val inputType: Symbol
     val outputType: Symbol = Symbol
         .builder()
-        .name("OperationOutput<$outputType>")
+        .name("${ClientRuntimeTypes.Middleware.OperationOutput}<$outputType>")
         .addDependency(SwiftDependency.CLIENT_RUNTIME)
         .build()
 
     val errorType: Symbol = Symbol
         .builder()
-        .name("SdkError<$outputErrorType>")
+        .name("${ClientRuntimeTypes.Core.SdkError}<$outputErrorType>")
         .addDependency(SwiftDependency.CLIENT_RUNTIME)
         .build()
 }

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/ServiceGenerator.kt

@@ -94,7 +94,7 @@ class ServiceGenerator(
             val outputShapeName = symbolProvider.toSymbol(outputShape).name
             val errorTypeName = getOperationErrorShapeName(op)
 
-            return "SdkResult<$outputShapeName, $errorTypeName>"
+            return "${ClientRuntimeTypes.Core.SdkResult}<$outputShapeName, $errorTypeName>"
         }
 
         fun getOperationInputShapeName(symbolProvider: SymbolProvider, opIndex: OperationIndex, op: OperationShape): String {
@@ -183,7 +183,7 @@ class ServiceGenerator(
 
         delegator.useShapeWriter(operationErrorSymbol) { writer ->
             writer.addImport(unknownServiceErrorSymbol)
-            writer.openBlock("public enum $operationErrorName: Swift.Error, Equatable {", "}") {
+            writer.openBlock("public enum $operationErrorName: \$N, \$N {", "}", SwiftTypes.Error, SwiftTypes.Protocols.Equatable) {
                 for (errorShape in errorShapes) {
                     val errorShapeName = symbolProvider.toSymbol(errorShape).name
                     writer.write("case \$L(\$L)", errorShapeName.decapitalize(), errorShapeName)