feat: basic annotation processing

gradle/libs.versions.toml

@@ -11,8 +11,8 @@ coroutines-version = "1.8.1"
 atomicfu-version = "0.24.0"
 
 # smithy-kotlin codegen and runtime are versioned separately
-smithy-kotlin-runtime-version = "1.3.11-SNAPSHOT"
-smithy-kotlin-codegen-version = "0.33.11-SNAPSHOT"
+smithy-kotlin-runtime-version = "1.3.8"
+smithy-kotlin-codegen-version = "0.33.8"
 
 # codegen
 smithy-version = "1.50.0"

hll/dynamodb-mapper/dynamodb-mapper-codegen/src/main/kotlin/aws/sdk/kotlin/hll/dynamodbmapper/codegen/annotations/rendering/HighLevelRenderer.kt

@@ -32,27 +32,7 @@ internal class HighLevelRenderer(
                 is DestinationPackage.Absolute -> dstPkg.pkg
             }
 
-            // Value converters must be generated for any DynamoDbItem which is referenced by another DynamoDbItem
-            val shouldRenderValueConverter = annotatedClasses.any { otherClass ->
-                val annotatedTypeName = annotated.qualifiedName?.asString()
-
-                otherClass.getAllProperties().any { prop ->
-                    val propType = prop.type.resolve()
-
-                    // If the property OR any of its arguments reference the annotated type
-                    (propType.declaration.qualifiedName?.asString() == annotatedTypeName) ||
-                        (
-                            propType.arguments.any { arg ->
-                                val argType = arg.type?.resolve()
-                                argType?.declaration?.qualifiedName?.asString() == annotatedTypeName
-                            }
-                            )
-                }
-            }
-
-            val attributes = codegenAttributes + attributesOf {
-                ShouldRenderValueConverterAttribute to shouldRenderValueConverter
-            }
+            val attributes = codegenAttributes + (SchemaAttributes.ShouldRenderValueConverterAttribute to annotated.shouldRenderValueConverter)
 
             val renderCtx = RenderContext(
                 logger,
@@ -66,6 +46,25 @@ internal class HighLevelRenderer(
             annotation.render()
         }
     }
-}
 
-internal val ShouldRenderValueConverterAttribute: AttributeKey<Boolean> = AttributeKey("ShouldRenderValueConverter")
+    // Value converters must be generated for any DynamoDbItem which is referenced by another DynamoDbItem
+    private val KSClassDeclaration.shouldRenderValueConverter: Boolean
+        get() = annotatedClasses.any { otherClass ->
+            val name = requireNotNull(qualifiedName).asString()
+
+            otherClass.getAllProperties().any { prop ->
+                val propType = prop.type.resolve()
+                val propName = requireNotNull(propType.declaration.qualifiedName).asString()
+
+                // If the property OR any of its arguments reference the annotated type
+                (propName == name) ||
+                    (
+                        propType.arguments.any { arg ->
+                            val argType = arg.type?.resolve()
+                            val argName = requireNotNull(argType?.declaration?.qualifiedName).asString()
+                            argName == name
+                        }
+                        )
+            }
+        }
+}

hll/dynamodb-mapper/dynamodb-mapper-codegen/src/main/kotlin/aws/sdk/kotlin/hll/dynamodbmapper/codegen/annotations/rendering/SchemaAttributes.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package aws.sdk.kotlin.hll.dynamodbmapper.codegen.annotations.rendering
+
+import aws.smithy.kotlin.runtime.collections.AttributeKey
+
+/**
+ * Internal schema code generation attributes
+ */
+internal object SchemaAttributes {
+    /**
+     * Whether a value converter should be generated for the class being processed
+     */
+    internal val ShouldRenderValueConverterAttribute: AttributeKey<Boolean> = AttributeKey("ShouldRenderValueConverter")
+}

hll/dynamodb-mapper/dynamodb-mapper-codegen/src/main/kotlin/aws/sdk/kotlin/hll/dynamodbmapper/codegen/annotations/rendering/SchemaRenderer.kt

@@ -89,6 +89,10 @@ internal class SchemaRenderer(
             renderItemConverter()
         }
 
+        if (ctx.attributes[SchemaAttributes.ShouldRenderValueConverterAttribute]) {
+            renderValueConverter()
+        }
+
         renderSchema()
 
         if (ctx.attributes[AnnotationsProcessorOptions.GenerateGetTableMethodAttribute]) {
@@ -118,33 +122,24 @@ internal class SchemaRenderer(
             }
         }
         blankLine()
+    }
 
-        // If necessary, render a ValueConverter which is a wrapper over the ItemConverter
+    /**
+     * Render a [ValueConverter] for the current class by wrapping the generated/user-provided [ItemConverter]
+     * with our [ItemToValueConverter]
+     */
+    private fun renderValueConverter() {
         // TODO Offer alternate serialization options besides AttributeValue.M?
-        if (ctx.attributes[ShouldRenderValueConverterAttribute]) {
-            withBlock(
-                "#Lobject #L : #T {",
-                "}",
-                ctx.attributes.visibility,
-                "${className}ValueConverter",
-                MapperTypes.Values.valueConverter(classType),
-            ) {
-                write(
-                    "override fun convertFrom(to: #T): #T = #T.fromItem(to.asM().#T())",
-                    MapperTypes.AttributeValue,
-                    classType,
-                    itemConverter,
-                    MapperTypes.Model.toItem,
-                )
-                write(
-                    "override fun convertTo(from: #1T): #2T = #2T.M(#3T.toItem(from))",
-                    classType,
-                    MapperTypes.AttributeValue,
-                    itemConverter,
-                )
-            }
-            blankLine()
-        }
+        write(
+            "#Lval #L : #T = #T.#T(#T)",
+            ctx.attributes.visibility,
+            "${className}ValueConverter",
+            MapperTypes.Values.valueConverter(classType),
+            itemConverter,
+            TypeRef("aws.sdk.kotlin.hll.mapping.core.converters", "andThenTo"),
+            MapperTypes.Values.ItemToValueConverter,
+        )
+        blankLine()
     }
 
     private fun renderAttributeDescriptor(prop: KSPropertyDeclaration) {
@@ -160,108 +155,121 @@ internal class SchemaRenderer(
             }
 
             // converter
-            write("#T", prop.type.resolve().valueConverter)
+            prop.type.resolve().renderValueConverter(this)
+            write("")
         }
     }
 
-    private val KSType.valueConverter: Type
-        get() = when {
-            this.isEnum -> MapperTypes.Values.Scalars.enumConverter(Type.from(this))
-
-            // Assuming other classes have also been annotated with DynamoDbItem, and they are codegenerated in the same package
-            this.isUserClass -> TypeRef(ctx.pkg, "${this.declaration.simpleName.asString()}ValueConverter")
-
-            else -> when (this.declaration.qualifiedName?.asString()) {
-                "aws.smithy.kotlin.runtime.time.Instant" -> MapperTypes.Values.SmithyTypes.DefaultInstantConverter
-                "aws.smithy.kotlin.runtime.net.url.Url" -> MapperTypes.Values.SmithyTypes.UrlConverter
-                "aws.smithy.kotlin.runtime.content.Document" -> MapperTypes.Values.SmithyTypes.DefaultDocumentConverter
-
-                "kotlin.Boolean" -> MapperTypes.Values.Scalars.BooleanConverter
-                "kotlin.String" -> MapperTypes.Values.Scalars.StringConverter
-                "kotlin.CharArray" -> MapperTypes.Values.Scalars.CharArrayConverter
-                "kotlin.Char" -> MapperTypes.Values.Scalars.CharConverter
-                "kotlin.Byte" -> MapperTypes.Values.Scalars.ByteConverter
-                "kotlin.ByteArray" -> MapperTypes.Values.Scalars.ByteArrayConverter
-                "kotlin.Short" -> MapperTypes.Values.Scalars.ShortConverter
-                "kotlin.Int" -> MapperTypes.Values.Scalars.IntConverter
-                "kotlin.Long" -> MapperTypes.Values.Scalars.LongConverter
-                "kotlin.Double" -> MapperTypes.Values.Scalars.DoubleConverter
-                "kotlin.Float" -> MapperTypes.Values.Scalars.FloatConverter
-                "kotlin.UByte" -> MapperTypes.Values.Scalars.UByteConverter
-                "kotlin.UInt" -> MapperTypes.Values.Scalars.UIntConverter
-                "kotlin.UShort" -> MapperTypes.Values.Scalars.UShortConverter
-                "kotlin.ULong" -> MapperTypes.Values.Scalars.ULongConverter
-
-                "kotlin.collections.Set" -> this.singleArgument().setValueConverter
-
-                "kotlin.collections.List" -> {
-                    val listElementConverter = this.singleArgument().valueConverter
-                    MapperTypes.Values.Collections.listConverter(listElementConverter)
+    /**
+     * Renders a ValueConverter for the [KSType].
+     *
+     * Note: The ValueConverter(s) will be rendered without a newline in order to support deep recursion.
+     * Callers are responsible for adding a newline after the top-level invocation of this function.
+     */
+    private fun KSType.renderValueConverter(writer: SchemaRenderer) {
+        writer.apply {
+            val ksType = this@renderValueConverter
+            val type = Type.from(ksType).copy(genericArgs = listOf())
+
+            when {
+                isEnum -> writeInline("#T()", MapperTypes.Values.Scalars.enumConverter(type))
+
+                // FIXME Handle multi-module codegen rather than assuming nested classes will be in the same [ctx.pkg]
+                isUserClass -> writeInline("#T", TypeRef(ctx.pkg, "${declaration.simpleName.asString()}ValueConverter"))
+
+                type == Types.Kotlin.Collections.List -> {
+                    val listElementType = singleArgument()
+                    writeInline("#T(", MapperTypes.Values.Collections.ListConverter)
+                    listElementType.renderValueConverter(this)
+                    writeInline(")")
                 }
 
-                "kotlin.collections.Map" -> {
+                type == Types.Kotlin.Collections.Map -> {
                     check(arguments.size == 2) { "Expected map type ${declaration.qualifiedName?.asString()} to have 2 arguments, got ${arguments.size}" }
 
-                    val (keyType, valueType) = arguments
-                        .map {
-                            checkNotNull(it.type?.resolve()) {
-                                "Failed to resolved argument type for $it"
-                            }
-                        }
-
-                    val keyConverter = keyType.mapKeyConverter
-                    val valueConverter = valueType.valueConverter
+                    val (keyType, valueType) = arguments.map {
+                        checkNotNull(it.type?.resolve()) { "Failed to resolved argument type for $it" }
+                    }
 
-                    MapperTypes.Values.Collections.mapConverter(keyConverter, valueConverter)
+                    writeInline("#T(#T, ", MapperTypes.Values.Collections.MapConverter, keyType.mapKeyConverter)
+                    valueType.renderValueConverter(this)
+                    writeInline(")")
                 }
 
-                else -> error("Unsupported attribute type $this")
+                else -> writeInline(
+                    "#T",
+                    when (type) {
+                        Types.Smithy.Instant -> MapperTypes.Values.SmithyTypes.DefaultInstantConverter
+                        Types.Smithy.Url -> MapperTypes.Values.SmithyTypes.UrlConverter
+                        Types.Smithy.Document -> MapperTypes.Values.SmithyTypes.DefaultDocumentConverter
+
+                        Types.Kotlin.Boolean -> MapperTypes.Values.Scalars.BooleanConverter
+                        Types.Kotlin.String -> MapperTypes.Values.Scalars.StringConverter
+                        Types.Kotlin.CharArray -> MapperTypes.Values.Scalars.CharArrayConverter
+                        Types.Kotlin.Char -> MapperTypes.Values.Scalars.CharConverter
+                        Types.Kotlin.Byte -> MapperTypes.Values.Scalars.ByteConverter
+                        Types.Kotlin.ByteArray -> MapperTypes.Values.Scalars.ByteArrayConverter
+                        Types.Kotlin.Short -> MapperTypes.Values.Scalars.ShortConverter
+                        Types.Kotlin.Int -> MapperTypes.Values.Scalars.IntConverter
+                        Types.Kotlin.Long -> MapperTypes.Values.Scalars.LongConverter
+                        Types.Kotlin.Double -> MapperTypes.Values.Scalars.DoubleConverter
+                        Types.Kotlin.Float -> MapperTypes.Values.Scalars.FloatConverter
+                        Types.Kotlin.UByte -> MapperTypes.Values.Scalars.UByteConverter
+                        Types.Kotlin.UInt -> MapperTypes.Values.Scalars.UIntConverter
+                        Types.Kotlin.UShort -> MapperTypes.Values.Scalars.UShortConverter
+                        Types.Kotlin.ULong -> MapperTypes.Values.Scalars.ULongConverter
+
+                        Types.Kotlin.Collections.Set -> singleArgument().setValueConverter
+                        else -> error("Unsupported attribute type $this")
+                    },
+                )
             }
         }
+    }
 
     private val KSType.mapKeyConverter: Type
-        get() = when (val name = this.declaration.qualifiedName?.asString()) {
+        get() = when (val type = Type.from(this)) {
             // String
-            "kotlin.CharArray" -> MapperTypes.Values.Scalars.CharArrayToStringConverter
-            "kotlin.Char" -> MapperTypes.Values.Scalars.CharToStringConverter
-            "kotlin.String" -> MapperTypes.Values.Scalars.StringToStringConverter
+            Types.Kotlin.ByteArray -> MapperTypes.Values.Scalars.CharArrayToStringConverter
+            Types.Kotlin.Char -> MapperTypes.Values.Scalars.CharToStringConverter
+            Types.Kotlin.String -> MapperTypes.Values.Scalars.StringToStringConverter
 
             // Number
-            "kotlin.Byte" -> MapperTypes.Values.Scalars.ByteToStringConverter
-            "kotlin.Double" -> MapperTypes.Values.Scalars.DoubleToStringConverter
-            "kotlin.Float" -> MapperTypes.Values.Scalars.FloatToStringConverter
-            "kotlin.Int" -> MapperTypes.Values.Scalars.IntToStringConverter
-            "kotlin.Long" -> MapperTypes.Values.Scalars.LongToStringConverter
-            "kotlin.Short" -> MapperTypes.Values.Scalars.ShortToStringConverter
-            "kotlin.UByte" -> MapperTypes.Values.Scalars.UByteToStringConverter
-            "kotlin.UInt" -> MapperTypes.Values.Scalars.UIntToStringConverter
-            "kotlin.ULong" -> MapperTypes.Values.Scalars.ULongToStringConverter
-            "kotlin.UShort" -> MapperTypes.Values.Scalars.UShortToStringConverter
+            Types.Kotlin.Byte -> MapperTypes.Values.Scalars.ByteToStringConverter
+            Types.Kotlin.Double -> MapperTypes.Values.Scalars.DoubleToStringConverter
+            Types.Kotlin.Float -> MapperTypes.Values.Scalars.FloatToStringConverter
+            Types.Kotlin.Int -> MapperTypes.Values.Scalars.IntToStringConverter
+            Types.Kotlin.Long -> MapperTypes.Values.Scalars.LongToStringConverter
+            Types.Kotlin.Short -> MapperTypes.Values.Scalars.ShortToStringConverter
+            Types.Kotlin.UByte -> MapperTypes.Values.Scalars.UByteToStringConverter
+            Types.Kotlin.UInt -> MapperTypes.Values.Scalars.UIntToStringConverter
+            Types.Kotlin.ULong -> MapperTypes.Values.Scalars.ULongToStringConverter
+            Types.Kotlin.UShort -> MapperTypes.Values.Scalars.UShortToStringConverter
 
             // Boolean
-            "kotlin.Boolean" -> MapperTypes.Values.Scalars.BooleanToStringConverter
-            else -> error("Unsupported key type: $name")
+            Types.Kotlin.Boolean -> MapperTypes.Values.Scalars.BooleanToStringConverter
+            else -> error("Unsupported key type: $type")
         }
 
     private fun KSType.singleArgument(): KSType = checkNotNull(arguments.single().type?.resolve()) {
         "Failed to resolve single argument type for ${this.declaration.qualifiedName?.asString()}"
     }
 
     private val KSType.setValueConverter: Type
-        get() = when (this.declaration.qualifiedName?.asString()) {
-            "kotlin.String" -> MapperTypes.Values.Collections.StringSetConverter
-            "kotlin.Char" -> MapperTypes.Values.Collections.CharSetConverter
-            "kotlin.CharArray" -> MapperTypes.Values.Collections.CharArraySetConverter
-            "kotlin.Byte" -> MapperTypes.Values.Collections.ByteSetConverter
-            "kotlin.Double" -> MapperTypes.Values.Collections.DoubleSetConverter
-            "kotlin.Float" -> MapperTypes.Values.Collections.FloatSetConverter
-            "kotlin.Int" -> MapperTypes.Values.Collections.IntSetConverter
-            "kotlin.Long" -> MapperTypes.Values.Collections.LongSetConverter
-            "kotlin.Short" -> MapperTypes.Values.Collections.ShortSetConverter
-            "kotlin.UByte" -> MapperTypes.Values.Collections.UByteSetConverter
-            "kotlin.UInt" -> MapperTypes.Values.Collections.UIntSetConverter
-            "kotlin.ULong" -> MapperTypes.Values.Collections.ULongSetConverter
-            "kotlin.UShort" -> MapperTypes.Values.Collections.UShortSetConverter
+        get() = when (Type.from(this)) {
+            Types.Kotlin.String -> MapperTypes.Values.Collections.StringSetConverter
+            Types.Kotlin.Char -> MapperTypes.Values.Collections.CharSetConverter
+            Types.Kotlin.CharArray -> MapperTypes.Values.Collections.CharArraySetConverter
+            Types.Kotlin.Byte -> MapperTypes.Values.Collections.ByteSetConverter
+            Types.Kotlin.Double -> MapperTypes.Values.Collections.DoubleSetConverter
+            Types.Kotlin.Float -> MapperTypes.Values.Collections.FloatSetConverter
+            Types.Kotlin.Int -> MapperTypes.Values.Collections.IntSetConverter
+            Types.Kotlin.Long -> MapperTypes.Values.Collections.LongSetConverter
+            Types.Kotlin.Short -> MapperTypes.Values.Collections.ShortSetConverter
+            Types.Kotlin.UByte -> MapperTypes.Values.Collections.UByteSetConverter
+            Types.Kotlin.UInt -> MapperTypes.Values.Collections.UIntSetConverter
+            Types.Kotlin.ULong -> MapperTypes.Values.Collections.ULongSetConverter
+            Types.Kotlin.UShort -> MapperTypes.Values.Collections.UShortSetConverter
             else -> error("Unsupported set element $this")
         }
 
@@ -316,11 +324,12 @@ internal class SchemaRenderer(
             schemaName,
         )
     }
-
-    private val KSType.isUserClass: Boolean
-        get() = listOf("kotlin", "java", "aws.smithy.kotlin", "aws.sdk.kotlin").none { declaration.packageName.asString().startsWith(it) }
 }
 
+@OptIn(KspExperimental::class)
+private val KSType.isUserClass: Boolean
+    get() = declaration.isAnnotationPresent(DynamoDbItem::class)
+
 private val KSPropertyDeclaration.typeName: String
     get() = checkNotNull(getter?.returnType?.resolve()?.declaration?.qualifiedName?.asString()) { "Failed to determine type name for $this" }
 

hll/dynamodb-mapper/dynamodb-mapper-codegen/src/main/kotlin/aws/sdk/kotlin/hll/dynamodbmapper/codegen/model/MapperTypes.kt

@@ -46,10 +46,11 @@ internal object MapperTypes {
 
     object Values {
         fun valueConverter(value: Type) = TypeRef(Pkg.Hl.Values, "ValueConverter", genericArgs = listOf(value))
+        val ItemToValueConverter = TypeRef(Pkg.Hl.Values, "ItemToValueConverter")
 
         object Collections {
-            fun listConverter(elementConverter: Type) = TypeRef(Pkg.Hl.CollectionValues, "ListConverter", args = listOf(elementConverter))
-            fun mapConverter(keyConverter: Type, valueConverter: Type) = TypeRef(Pkg.Hl.CollectionValues, "MapConverter", args = listOf(keyConverter, valueConverter))
+            val ListConverter = TypeRef(Pkg.Hl.CollectionValues, "ListConverter")
+            val MapConverter = TypeRef(Pkg.Hl.CollectionValues, "MapConverter")
 
             val StringSetConverter = TypeRef(Pkg.Hl.CollectionValues, "StringSetConverter")
             val CharSetConverter = TypeRef(Pkg.Hl.CollectionValues, "CharSetConverter")
@@ -69,7 +70,7 @@ internal object MapperTypes {
         }
 
         object Scalars {
-            fun enumConverter(enumType: Type) = TypeRef(Pkg.Hl.ScalarValues, "EnumConverter()", genericArgs = listOf(enumType))
+            fun enumConverter(enumType: Type) = TypeRef(Pkg.Hl.ScalarValues, "EnumConverter", genericArgs = listOf(enumType))
 
             val BooleanConverter = TypeRef(Pkg.Hl.ScalarValues, "BooleanConverter")
             val StringConverter = TypeRef(Pkg.Hl.ScalarValues, "StringConverter")