feat: support Smithy default trait

.changes/d3ec877c-68c6-4c21-881f-8767d1f87e1c.json

@@ -0,0 +1,8 @@
+{
+    "id": "d3ec877c-68c6-4c21-881f-8767d1f87e1c",
+    "type": "feature",
+    "description": "Support Smithy default trait",
+    "issues": [
+        "https://github.com/awslabs/smithy-kotlin/issues/718"
+    ]
+}

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/core/KotlinSymbolProvider.kt

@@ -11,6 +11,7 @@ import software.amazon.smithy.kotlin.codegen.model.*
 import software.amazon.smithy.model.Model
 import software.amazon.smithy.model.knowledge.NullableIndex
 import software.amazon.smithy.model.shapes.*
+import software.amazon.smithy.model.traits.DefaultTrait
 import software.amazon.smithy.model.traits.SparseTrait
 import software.amazon.smithy.model.traits.StreamingTrait
 import java.util.logging.Logger
@@ -79,10 +80,14 @@ class KotlinSymbolProvider(private val model: Model, private val settings: Kotli
 
     override fun doubleShape(shape: DoubleShape): Symbol = numberShape(shape, "Double", "0.0")
 
-    private fun numberShape(shape: Shape, typeName: String, defaultValue: String = "0"): Symbol =
-        createSymbolBuilder(shape, typeName, namespace = "kotlin")
-            .defaultValue(defaultValue)
-            .build()
+    private fun numberShape(shape: Shape, typeName: String, defaultValue: String = "0"): Symbol {
+        val symbol = createSymbolBuilder(shape, typeName, namespace = "kotlin").build()
+        return if (!symbol.properties.containsKey(SymbolProperty.DEFAULT_VALUE_KEY)) {
+            symbol.toBuilder().defaultValue(defaultValue).build()
+        } else {
+            symbol
+        }
+    }
 
     override fun bigIntegerShape(shape: BigIntegerShape?): Symbol = createBigSymbol(shape, "BigInteger")
 
@@ -172,11 +177,22 @@ class KotlinSymbolProvider(private val model: Model, private val settings: Kotli
         val targetShape =
             model.getShape(shape.target).orElseThrow { CodegenException("Shape not found: ${shape.target}") }
 
-        val targetSymbol = if (nullableIndex.isMemberNullable(shape, NullableIndex.CheckMode.CLIENT_ZERO_VALUE_V1_NO_INPUT)) {
+        var targetSymbol = if (nullableIndex.isMemberNullable(shape, NullableIndex.CheckMode.CLIENT)) {
             toSymbol(targetShape).toBuilder().boxed().build()
         } else {
             toSymbol(targetShape)
         }
+
+        targetSymbol = shape.getTrait<DefaultTrait>()?.let {
+            val builder = targetSymbol.toBuilder()
+            val defaultValue = it.getDefaultValue(targetShape)
+            builder.defaultValue(defaultValue)
+            if (defaultValue != "null") {
+                builder.unboxed()
+            }
+            builder.build()
+        } ?: targetSymbol
+
         // figure out if we are referencing an event stream or not.
         // NOTE: unlike blob streams we actually re-use the target (union) shape which is why we can't do this
         // when visiting a unionShape() like we can for blobShape()
@@ -197,6 +213,21 @@ class KotlinSymbolProvider(private val model: Model, private val settings: Kotli
         }
     }
 
+    private fun DefaultTrait.getDefaultValue(targetShape: Shape): String =
+        if (toNode().toString() == "null" || (targetShape is BlobShape && toNode().toString() == "")) {
+            "null"
+        } else if (toNode().isNumberNode) {
+            getDefaultValueForNumber(targetShape, toNode().toString())
+        } else if (toNode().isArrayNode) {
+            "listOf()"
+        } else if (toNode().isObjectNode) {
+            "mapOf()"
+        } else if (toNode().isStringNode) {
+            "\"${toNode()}\""
+        } else {
+            toNode().toString()
+        }
+
     override fun timestampShape(shape: TimestampShape?): Symbol {
         val dependency = KotlinDependency.CORE
         return createSymbolBuilder(shape, "Instant", boxed = true)
@@ -253,6 +284,13 @@ class KotlinSymbolProvider(private val model: Model, private val settings: Kotli
         return builder
     }
 
+    private fun getDefaultValueForNumber(shape: Shape, value: String) = when (shape) {
+        is LongShape -> "${value}L"
+        is FloatShape -> if (value.matches("[0-9]*\\.[0-9]+".toRegex())) "${value}f" else "$value.0f"
+        is DoubleShape -> if (value.matches("[0-9]*\\.[0-9]+".toRegex())) value else "$value.0"
+        else -> value
+    }
+
     /**
      * Creates a symbol builder for the shape with the given type name in a child namespace relative
      * to the root namespace e.g. `relativeNamespace = bar` with a root namespace of `foo` would set

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/model/SymbolExt.kt

@@ -109,6 +109,11 @@ fun Symbol.defaultValue(defaultBoxed: String? = "null"): String? {
  */
 fun Symbol.Builder.boxed(): Symbol.Builder = apply { putProperty(SymbolProperty.BOXED_KEY, true) }
 
+/**
+ * Mark a symbol as not being boxed
+ */
+fun Symbol.Builder.unboxed(): Symbol.Builder = apply { removeProperty(SymbolProperty.BOXED_KEY) }
+
 /**
  * Set the default value used when formatting the symbol
  */

codegen/smithy-kotlin-codegen/src/test/kotlin/software/amazon/smithy/kotlin/codegen/core/SymbolProviderTest.kt

@@ -98,6 +98,246 @@ class SymbolProviderTest {
         else -> typeName
     }
 
+    @Test
+    fun `can read default trait from member`() {
+        val modeledDefault = "5"
+        val expectedDefault = "5L"
+
+        val model = """
+        structure MyStruct {
+           @default($modeledDefault)
+           foo: MyFoo
+        }
+
+        long MyFoo
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals("kotlin", memberSymbol.namespace)
+        assertEquals(expectedDefault, memberSymbol.defaultValue())
+    }
+
+    @Test
+    fun `can read default trait from target`() {
+        val modeledDefault = "2500"
+        val expectedDefault = "2500L"
+
+        val model = """
+        structure MyStruct {
+           @default($modeledDefault)
+           foo: MyFoo
+        }
+
+        @default($modeledDefault)
+        long MyFoo
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals("kotlin", memberSymbol.namespace)
+        assertEquals(expectedDefault, memberSymbol.defaultValue())
+    }
+
+    @Test
+    fun `can override default trait from root-level shape`() {
+        val modeledDefault = "2500"
+        val overriddenDefault = "null"
+
+        val model = """
+        structure MyStruct {
+           @default($overriddenDefault)
+           foo: RootLevelShape
+        }
+
+        @default($modeledDefault)
+        long RootLevelShape
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals("kotlin", memberSymbol.namespace)
+        assertEquals(overriddenDefault, memberSymbol.defaultValue())
+    }
+
+    @ParameterizedTest(name = "{index} ==> ''can default simple {0} type''")
+    @CsvSource(
+        "long,100,100L",
+        "integer,5,5",
+        "short,32767,32767",
+        "float,3.14159,3.14159f",
+        "double,2.71828,2.71828",
+        "byte,10,10",
+        "string,\"hello\",\"hello\"",
+        "blob,\"abcdefg\",\"abcdefg\"",
+        "boolean,true,true",
+        "bigInteger,5,5",
+        "bigDecimal,9.0123456789,9.0123456789",
+        "timestamp,1684869901,1684869901",
+    )
+    fun `can default simple types`(typeName: String, modeledDefault: String, expectedDefault: String) {
+        val model = """
+        structure MyStruct {
+           @default($modeledDefault)
+           foo: Shape
+        }
+
+        @default($modeledDefault)
+        $typeName Shape
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals(expectedDefault, memberSymbol.defaultValue())
+    }
+
+    @Test
+    fun `can default empty string`() {
+        val model = """
+        structure MyStruct {
+           @default("")
+           foo: myString
+        }
+        string myString
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals("\"\"", memberSymbol.defaultValue())
+    }
+
+    @Test
+    fun `can default enum type`() {
+        val model = """
+        structure MyStruct {
+           @default("club")
+           foo: Suit
+        }
+
+        enum Suit {
+            @enumValue("diamond")
+            DIAMOND
+
+            @enumValue("club")
+            CLUB
+
+            @enumValue("heart")
+            HEART
+
+            @enumValue("spade")
+            SPADE
+        }        
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals("\"club\"", memberSymbol.defaultValue())
+    }
+
+    @Test
+    fun `can default int enum type`() {
+        val model = """
+        structure MyStruct {
+           @default(2)
+           foo: Season
+        }
+
+        intEnum Season {
+            SPRING = 1
+            SUMMER = 2
+            FALL = 3
+            WINTER = 4 
+        }        
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals("2", memberSymbol.defaultValue())
+    }
+
+    @ParameterizedTest(name = "{index} ==> ''can default document with {0} type''")
+    @CsvSource(
+        "null,null,null",
+        "boolean,true,true",
+        "boolean,false,false",
+        "string,\"hello\",\"hello\"",
+        "long,100,100",
+        "integer,5,5",
+        "short,32767,32767",
+        "float,3.14159,3.14159",
+        "double,2.71828,2.71828",
+        "byte,10,10",
+        "list,[],listOf()",
+        "map,{},mapOf()",
+    )
+    @Suppress("UNUSED_PARAMETER") // using the first parameter in the test name, but compiler doesn't acknowledge that
+    fun `can default document type`(typeName: String, modeledDefault: String, expectedDefault: String) {
+        val model = """
+        structure MyStruct {
+           @default($modeledDefault)
+           foo: MyDocument
+        }
+
+        document MyDocument
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals(expectedDefault, memberSymbol.defaultValue())
+    }
+
+    @Test
+    fun `can default list type`() {
+        val model = """
+        structure MyStruct {
+           @default([])
+           foo: MyStringList
+        }
+
+        list MyStringList {
+            member: MyString
+        }
+
+        string MyString
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals("listOf()", memberSymbol.defaultValue())
+    }
+
+    @Test
+    fun `can default map type`() {
+        val model = """
+        structure MyStruct {
+           @default({})
+           foo: MyStringToIntegerMap
+        }
+
+        map MyStringToIntegerMap {
+            key: MyString
+            value: MyInteger
+        }
+
+        string MyString
+        integer MyInteger
+        """.prependNamespaceAndService(version = "2").toSmithyModel()
+
+        val provider: SymbolProvider = KotlinCodegenPlugin.createSymbolProvider(model)
+        val member = model.expectShape<MemberShape>("com.test#MyStruct\$foo")
+        val memberSymbol = provider.toSymbol(member)
+        assertEquals("mapOf()", memberSymbol.defaultValue())
+    }
+
     @Test
     fun `can read box trait from member`() {
         val model = """

codegen/smithy-kotlin-codegen/src/test/kotlin/software/amazon/smithy/kotlin/codegen/rendering/StructureGeneratorTest.kt

@@ -379,12 +379,12 @@ class StructureGeneratorTest {
         val expected = """
             public class FooRequest private constructor(builder: Builder) {
                 public val bar: kotlin.String? = requireNotNull(builder.bar) { "A non-null value must be provided for bar" }
-                public val baz: kotlin.Int? = requireNotNull(builder.baz) { "A non-null value must be provided for baz" }
+                public val baz: kotlin.Int = requireNotNull(builder.baz) { "A non-null value must be provided for baz" }
                 public val corge: kotlin.String? = builder.corge
                 public val garply: kotlin.String? = requireNotNull(builder.garply) { "A non-null value must be provided for garply" }
                     .apply { require(isNotBlank()) { "A non-blank value must be provided for garply" } }
                 public val grault: kotlin.String? = requireNotNull(builder.grault) { "A non-null value must be provided for grault" }
-                public val quux: kotlin.Boolean? = requireNotNull(builder.quux) { "A non-null value must be provided for quux" }
+                public val quux: kotlin.Boolean = requireNotNull(builder.quux) { "A non-null value must be provided for quux" }
                 public val qux: kotlin.String? = builder.qux
         """.formatForTest(indent = "")
         generated.shouldContainOnlyOnceWithDiff(expected)