smithy-lang · jjant · Nov 30, 2022 · Nov 24, 2022 · Nov 24, 2022 · Nov 24, 2022
@@ -242,14 +242,16 @@ message = """
 
 * The `length` trait on `string` shapes.
 * The `length` trait on `map` shapes.
+* The `length` trait on `list` shapes.
+* The `length` trait on `set` shapes.
 * The `range` trait on `integer` shapes.
 * The `pattern` trait on `string` shapes.
 
 Upon receiving a request that violates the modeled constraints, the server SDK will reject it with a message indicating why.
 
 Unsupported (constraint trait, target shape) combinations will now fail at code generation time, whereas previously they were just ignored. This is a breaking change to raise awareness in service owners of their server SDKs behaving differently than what was modeled. To continue generating a server SDK with unsupported constraint traits, set `codegenConfig.ignoreUnsupportedConstraints` to `true` in your `smithy-build.json`.
 """
-references = ["smithy-rs#1199", "smithy-rs#1342", "smithy-rs#1401", "smithy-rs#2005", "smithy-rs#1998"]
+references = ["smithy-rs#1199", "smithy-rs#1342", "smithy-rs#1401", "smithy-rs#1998", "smithy-rs#2005", "smithy-rs#2028"]
 meta = { "breaking" = true, "tada" = true, "bug" = false, "target" = "server" }
 author = "david-perez"
 

@@ -21,6 +21,7 @@ service ConstraintsService {
         QueryParamsTargetingMapOfLengthStringOperation,
         QueryParamsTargetingMapOfListOfLengthStringOperation,
         QueryParamsTargetingMapOfSetOfLengthStringOperation,
+        QueryParamsTargetingMapOfLengthListOfPatternStringOperation,
         QueryParamsTargetingMapOfListOfEnumStringOperation,
 
         QueryParamsTargetingMapOfPatternStringOperation,
@@ -98,6 +99,13 @@ operation QueryParamsTargetingMapOfSetOfLengthStringOperation {
     errors: [ValidationException]
 }
 
+@http(uri: "/query-params-targeting-map-of-length-list-of-pattern-string-operation", method: "POST")
+operation QueryParamsTargetingMapOfLengthListOfPatternStringOperation {
+    input: QueryParamsTargetingMapOfLengthListOfPatternStringOperationInputOutput,
+    output: QueryParamsTargetingMapOfLengthListOfPatternStringOperationInputOutput,
+    errors: [ValidationException]
+}
+
 @http(uri: "/query-params-targeting-map-of-list-of-enum-string-operation", method: "POST")
 operation QueryParamsTargetingMapOfListOfEnumStringOperation {
     input: QueryParamsTargetingMapOfListOfEnumStringOperationInputOutput,
@@ -303,6 +311,11 @@ structure QueryParamsTargetingMapOfSetOfLengthStringOperationInputOutput {
     mapOfSetOfLengthString: MapOfSetOfLengthString
 }
 
+structure QueryParamsTargetingMapOfLengthListOfPatternStringOperationInputOutput {
+    @httpQueryParams
+    mapOfLengthListOfPatternString: MapOfLengthListOfPatternString
+}
+
 structure QueryParamsTargetingMapOfListOfEnumStringOperationInputOutput {
     @httpQueryParams
     mapOfListOfEnumString: MapOfListOfEnumString
@@ -450,6 +463,11 @@ map MapOfSetOfLengthString {
     value: ListOfLengthString
 }
 
+map MapOfLengthListOfPatternString {
+    key: PatternString,
+    value: LengthListOfPatternString
+}
+
 // TODO(https://github.com/awslabs/smithy-rs/issues/1401): a `set` shape is
 //  just a `list` shape with `uniqueItems`, which hasn't been implemented yet.
 // map MapOfSetOfRangeInteger {
@@ -564,6 +582,11 @@ list ListOfLengthPatternString {
     member: LengthPatternString
 }
 
+@length(min:12, max: 39)
+list LengthListOfPatternString {
+    member: PatternString
+}
+
 structure ConB {
     @required
     nice: String,

@@ -325,7 +325,23 @@ fun RustType.isCopy(): Boolean = when (this) {
 enum class Visibility {
     PRIVATE,
     PUBCRATE,
-    PUBLIC
+    PUBLIC;
+
+    companion object {
+        fun publicIf(condition: Boolean, ifNot: Visibility): Visibility =
+            if (condition) {
+                PUBLIC
+            } else {
+                ifNot
+            }
+    }
+
+    fun toRustQualifier(): String =
+        when (this) {
+            PRIVATE -> ""
+            PUBCRATE -> "pub(crate)"
+            PUBLIC -> "pub"
+        }
 }
 
 /**

@@ -62,8 +62,8 @@ sealed class JsonSerializerSection(name: String) : Section(name) {
         JsonSerializerSection("ServerError")
 
     /** Manipulate the serializer context for a map prior to it being serialized. **/
-    data class BeforeIteratingOverMap(val shape: MapShape, val context: JsonSerializerGenerator.Context<MapShape>) :
-        JsonSerializerSection("BeforeIteratingOverMap")
+    data class BeforeIteratingOverMapOrCollection(val shape: Shape, val context: JsonSerializerGenerator.Context<Shape>) :
+        JsonSerializerSection("BeforeIteratingOverMapOrCollection")
 
     /** Manipulate the serializer context for a non-null member prior to it being serialized. **/
     data class BeforeSerializingNonNullMember(val shape: Shape, val context: JsonSerializerGenerator.MemberContext) :
@@ -90,7 +90,7 @@ class JsonSerializerGenerator(
     private val jsonName: (MemberShape) -> String,
     private val customizations: List<JsonSerializerCustomization> = listOf(),
 ) : StructuredDataSerializerGenerator {
-    data class Context<T : Shape>(
+    data class Context<out T : Shape>(
         /** Expression that retrieves a JsonValueWriter from either a JsonObjectWriter or JsonArrayWriter */
         val writerExpression: String,
         /** Expression representing the value to write to the JsonValueWriter */
@@ -455,6 +455,9 @@ class JsonSerializerGenerator(
 
     private fun RustWriter.serializeCollection(context: Context<CollectionShape>) {
         val itemName = safeName("item")
+        for (customization in customizations) {
+            customization.section(JsonSerializerSection.BeforeIteratingOverMapOrCollection(context.shape, context))(this)
+        }
         rustBlock("for $itemName in ${context.valueExpression.asRef()}") {
             serializeMember(MemberContext.collectionMember(context, itemName))
         }
@@ -464,7 +467,7 @@ class JsonSerializerGenerator(
         val keyName = safeName("key")
         val valueName = safeName("value")
         for (customization in customizations) {
-            customization.section(JsonSerializerSection.BeforeIteratingOverMap(context.shape, context))(
+            customization.section(JsonSerializerSection.BeforeIteratingOverMapOrCollection(context.shape, context))(
                 this,
             )
         }

@@ -27,6 +27,7 @@ import software.amazon.smithy.rust.codegen.core.smithy.locatedIn
 import software.amazon.smithy.rust.codegen.core.smithy.rustType
 import software.amazon.smithy.rust.codegen.core.smithy.symbolBuilder
 import software.amazon.smithy.rust.codegen.core.util.hasTrait
+import software.amazon.smithy.rust.codegen.core.util.orNull
 import software.amazon.smithy.rust.codegen.core.util.toPascalCase
 
 /**
@@ -55,8 +56,8 @@ class ConstrainedShapeSymbolProvider(
 ) : WrappingSymbolProvider(base) {
     private val nullableIndex = NullableIndex.of(model)
 
-    private fun publicConstrainedSymbolForMapShape(shape: Shape): Symbol {
-        check(shape is MapShape)
+    private fun publicConstrainedSymbolForMapOrCollectionShape(shape: Shape): Symbol {
+        check(shape is MapShape || shape is CollectionShape)
 
         val rustType = RustType.Opaque(shape.contextName(serviceShape).toPascalCase())
         return symbolBuilder(shape, rustType).locatedIn(ModelsModule).build()
@@ -69,13 +70,13 @@ class ConstrainedShapeSymbolProvider(
                 //  (constraint trait precedence).
                 val target = model.expectShape(shape.target)
                 val targetSymbol = this.toSymbol(target)
-                // Handle boxing first so we end up with `Option<Box<_>>`, not `Box<Option<_>>`.
+                // Handle boxing first, so we end up with `Option<Box<_>>`, not `Box<Option<_>>`.
                 handleOptionality(handleRustBoxing(targetSymbol, shape), shape, nullableIndex, base.config().nullabilityCheckMode)
             }
             is MapShape -> {
                 if (shape.isDirectlyConstrained(base)) {
                     check(shape.hasTrait<LengthTrait>()) { "Only the `length` constraint trait can be applied to maps" }
-                    publicConstrainedSymbolForMapShape(shape)
+                    publicConstrainedSymbolForMapOrCollectionShape(shape)
                 } else {
                     val keySymbol = this.toSymbol(shape.key)
                     val valueSymbol = this.toSymbol(shape.value)
@@ -86,11 +87,9 @@ class ConstrainedShapeSymbolProvider(
                 }
             }
             is CollectionShape -> {
-                // TODO(https://github.com/awslabs/smithy-rs/issues/1401) Both arms return the same because we haven't
-                //  implemented any constraint trait on collection shapes yet.
                 if (shape.isDirectlyConstrained(base)) {
-                    val inner = this.toSymbol(shape.member)
-                    symbolBuilder(shape, RustType.Vec(inner.rustType())).addReference(inner).build()
+                    assert(constrainedCollectionCheck(shape)) { "Only the `length` constraint trait can be applied to lists" }
+                    publicConstrainedSymbolForMapOrCollectionShape(shape)
                 } else {
                     val inner = this.toSymbol(shape.member)
                     symbolBuilder(shape, RustType.Vec(inner.rustType())).addReference(inner).build()
@@ -107,4 +106,18 @@ class ConstrainedShapeSymbolProvider(
             else -> base.toSymbol(shape)
         }
     }
+
+    /**
+     * Checks that the collection:
+     *  - Has at least 1 supported constraint applied to it, and
+     *  - That it has no unsupported constraints applied.
+     *
+     * This check is relatively expensive, so we only run it on `assert`s.
+     */
+    private fun constrainedCollectionCheck(shape: CollectionShape): Boolean {
+        val supportedConstraintTraits = supportedCollectionConstraintTraits.mapNotNull { shape.getTrait(it).orNull() }.toSet()
+        val allConstraintTraits = allConstraintTraits.mapNotNull { shape.getTrait(it).orNull() }.toSet()
+
+        return supportedConstraintTraits.isNotEmpty() && allConstraintTraits.subtract(supportedConstraintTraits).isEmpty()
+    }
 }
@@ -37,15 +37,28 @@ import software.amazon.smithy.rust.codegen.core.util.hasTrait
  * we support it or not_.
  */
 fun Shape.hasConstraintTrait() =
-    hasTrait<LengthTrait>() ||
-        hasTrait<EnumTrait>() ||
-        hasTrait<UniqueItemsTrait>() ||
-        hasTrait<PatternTrait>() ||
-        hasTrait<RangeTrait>() ||
-        hasTrait<RequiredTrait>()
+    allConstraintTraits.any(this::hasTrait)
+
+val allConstraintTraits = setOf(
+    LengthTrait::class.java,
+    PatternTrait::class.java,
+    RangeTrait::class.java,
+    UniqueItemsTrait::class.java,
+    EnumTrait::class.java,
+    RequiredTrait::class.java,
+)
 
 val supportedStringConstraintTraits: List<Class<out Trait>> = listOf(LengthTrait::class.java, PatternTrait::class.java)
 
+/**
+ * Supported constraint traits for the `list` and `set` shapes.
+ */
+val supportedCollectionConstraintTraits: List<Class<out Trait>> = listOf(
+    LengthTrait::class.java,
+    // TODO(https://github.com/awslabs/smithy-rs/issues/1670): Not yet supported.
+    // UniqueItemsTrait::class.java
+)
+
 /**
  * We say a shape is _directly_ constrained if:
  *
@@ -72,6 +85,7 @@ fun Shape.isDirectlyConstrained(symbolProvider: SymbolProvider): Boolean = when
 
     is MapShape -> this.hasTrait<LengthTrait>()
     is StringShape -> this.hasTrait<EnumTrait>() || supportedStringConstraintTraits.any { this.hasTrait(it) }
+    is CollectionShape -> supportedCollectionConstraintTraits.any { this.hasTrait(it) }
     is IntegerShape -> this.hasTrait<RangeTrait>()
     else -> false
 }
@@ -96,6 +110,7 @@ fun MemberShape.targetCanReachConstrainedShape(model: Model, symbolProvider: Sym
     model.expectShape(this.target).canReachConstrainedShape(model, symbolProvider)
 
 fun Shape.hasPublicConstrainedWrapperTupleType(model: Model, publicConstrainedTypes: Boolean): Boolean = when (this) {
+    is CollectionShape -> publicConstrainedTypes && supportedCollectionConstraintTraits.any(this::hasTrait)
     is MapShape -> publicConstrainedTypes && this.hasTrait<LengthTrait>()
     is StringShape -> !this.hasTrait<EnumTrait>() && (publicConstrainedTypes && supportedStringConstraintTraits.any(this::hasTrait))
     is IntegerShape -> publicConstrainedTypes && this.hasTrait<RangeTrait>()

@@ -43,6 +43,9 @@ import software.amazon.smithy.rust.codegen.core.smithy.transformers.RecursiveSha
 import software.amazon.smithy.rust.codegen.core.util.CommandFailed
 import software.amazon.smithy.rust.codegen.core.util.hasTrait
 import software.amazon.smithy.rust.codegen.core.util.runCommand
+import software.amazon.smithy.rust.codegen.server.smithy.generators.CollectionConstraintViolationGenerator
+import software.amazon.smithy.rust.codegen.server.smithy.generators.CollectionTraitInfo
+import software.amazon.smithy.rust.codegen.server.smithy.generators.ConstrainedCollectionGenerator
 import software.amazon.smithy.rust.codegen.server.smithy.generators.ConstrainedIntegerGenerator
 import software.amazon.smithy.rust.codegen.server.smithy.generators.ConstrainedMapGenerator
 import software.amazon.smithy.rust.codegen.server.smithy.generators.ConstrainedStringGenerator
@@ -278,11 +281,14 @@ open class ServerCodegenVisitor(
     override fun setShape(shape: SetShape) = collectionShape(shape)
 
     private fun collectionShape(shape: CollectionShape) {
-        if (shape.isReachableFromOperationInput() && shape.canReachConstrainedShape(
+        val renderUnconstrainedList =
+            shape.isReachableFromOperationInput() && shape.canReachConstrainedShape(
                 model,
                 codegenContext.symbolProvider,
             )
-        ) {
+        val isDirectlyConstrained = shape.isDirectlyConstrained(codegenContext.symbolProvider)
+
+        if (renderUnconstrainedList) {
             logger.info("[rust-server-codegen] Generating an unconstrained type for collection shape $shape")
             rustCrate.withModule(UnconstrainedModule) unconstrainedModuleWriter@{
                 rustCrate.withModule(ModelsModule) modelsModuleWriter@{
@@ -295,9 +301,30 @@ open class ServerCodegenVisitor(
                 }
             }
 
-            logger.info("[rust-server-codegen] Generating a constrained type for collection shape $shape")
-            rustCrate.withModule(ConstrainedModule) {
-                PubCrateConstrainedCollectionGenerator(codegenContext, this, shape).render()
+            if (!isDirectlyConstrained) {
+                logger.info("[rust-server-codegen] Generating a constrained type for collection shape $shape")
+                rustCrate.withModule(ConstrainedModule) {
+                    PubCrateConstrainedCollectionGenerator(codegenContext, this, shape).render()
+                }
+            }
+        }
+
+        val constraintsInfo = CollectionTraitInfo.fromShape(shape)
+        if (isDirectlyConstrained) {
+            rustCrate.withModule(ModelsModule) {
+                ConstrainedCollectionGenerator(
+                    codegenContext,
+                    this,
+                    shape,
+                    constraintsInfo,
+                    if (renderUnconstrainedList) codegenContext.unconstrainedShapeSymbolProvider.toSymbol(shape) else null,
+                ).render()
+            }
+        }
+
+        if (isDirectlyConstrained || renderUnconstrainedList) {
+            rustCrate.withModule(ModelsModule) {
+                CollectionConstraintViolationGenerator(codegenContext, this, shape, constraintsInfo).render()
             }
         }
     }
@@ -308,21 +335,22 @@ open class ServerCodegenVisitor(
                 model,
                 codegenContext.symbolProvider,
             )
+        val isDirectlyConstrained = shape.isDirectlyConstrained(codegenContext.symbolProvider)
+
         if (renderUnconstrainedMap) {
             logger.info("[rust-server-codegen] Generating an unconstrained type for map $shape")
             rustCrate.withModule(UnconstrainedModule) {
                 UnconstrainedMapGenerator(codegenContext, this, shape).render()
             }
 
-            if (!shape.isDirectlyConstrained(codegenContext.symbolProvider)) {
+            if (!isDirectlyConstrained) {
                 logger.info("[rust-server-codegen] Generating a constrained type for map $shape")
                 rustCrate.withModule(ConstrainedModule) {
                     PubCrateConstrainedMapGenerator(codegenContext, this, shape).render()
                 }
             }
         }
 
-        val isDirectlyConstrained = shape.isDirectlyConstrained(codegenContext.symbolProvider)
         if (isDirectlyConstrained) {
             rustCrate.withModule(ModelsModule) {
                 ConstrainedMapGenerator(