smithy-lang · jjant · Nov 30, 2022 · Nov 24, 2022 · Nov 24, 2022 · Nov 24, 2022
@@ -242,6 +242,7 @@ message = """
 
 * The `length` trait on `string` shapes.
 * The `length` trait on `map` shapes.
+* The `length` trait on `list` shapes.
 * The `range` trait on `byte` shapes.
 * The `range` trait on `short` shapes.
 * The `range` trait on `integer` shapes.
@@ -252,7 +253,7 @@ Upon receiving a request that violates the modeled constraints, the server SDK w
 
 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", "smithy-rs#2034", "smithy-rs#2036"]
+references = ["smithy-rs#1199", "smithy-rs#1342", "smithy-rs#1401", "smithy-rs#1998", "smithy-rs#2005", "smithy-rs#2028", "smithy-rs#2034", "smithy-rs#2036"]
 meta = { "breaking" = true, "tada" = true, "bug" = false, "target" = "server" }
 author = "david-perez"
 

@@ -21,6 +21,7 @@ service ConstraintsService {
         QueryParamsTargetingMapOfLengthStringOperation,
         QueryParamsTargetingMapOfListOfLengthStringOperation,
         QueryParamsTargetingMapOfSetOfLengthStringOperation,
+        QueryParamsTargetingMapOfLengthListOfPatternStringOperation,
         QueryParamsTargetingMapOfListOfEnumStringOperation,
 
         QueryParamsTargetingMapOfPatternStringOperation,
@@ -101,6 +102,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,
@@ -225,8 +233,16 @@ structure ConstrainedHttpBoundShapesOperationInputOutput {
     // @httpHeader("X-Length-Set")
     // lengthStringSetHeader: SetOfLengthString,
 
-    @httpHeader("X-Length-List")
-    lengthStringListHeader: ListOfLengthString,
+    @httpHeader("X-List-Length-String")
+    listLengthStringHeader: ListOfLengthString,
+
+    @httpHeader("X-Length-List-Pattern-String")
+    lengthListPatternStringHeader: 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.
+    // @httpHeader("X-Length-Set-Pattern-String")
+    // lengthSetPatternStringHeader: LengthSetOfPatternString,
 
     // 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.
@@ -279,6 +295,9 @@ structure ConstrainedHttpBoundShapesOperationInputOutput {
     @httpQuery("lengthStringList")
     lengthStringListQuery: ListOfLengthString,
 
+    @httpQuery("lengthListPatternString")
+    lengthListPatternStringQuery: 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.
     // @httpQuery("lengthStringSet")
@@ -366,6 +385,11 @@ structure QueryParamsTargetingMapOfSetOfLengthStringOperationInputOutput {
     mapOfSetOfLengthString: MapOfSetOfLengthString
 }
 
+structure QueryParamsTargetingMapOfLengthListOfPatternStringOperationInputOutput {
+    @httpQueryParams
+    mapOfLengthListOfPatternString: MapOfLengthListOfPatternString
+}
+
 structure QueryParamsTargetingMapOfListOfEnumStringOperationInputOutput {
     @httpQueryParams
     mapOfListOfEnumString: MapOfListOfEnumString
@@ -501,6 +525,11 @@ structure ConA {
     // 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.
     // setOfLengthPatternString: SetOfLengthPatternString,
+
+    lengthListOfPatternString: 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.
+    // lengthSetOfPatternString: LengthSetOfPatternString,
 }
 
 map MapOfLengthString {
@@ -561,6 +590,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 {
@@ -706,6 +740,11 @@ set SetOfLengthPatternString {
     member: LengthPatternString
 }
 
+@length(min: 5, max: 9)
+set LengthSetOfPatternString {
+    member: PatternString
+}
+
 list ListOfLengthString {
     member: LengthString
 }
@@ -762,6 +801,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"
+        }
 }
 
 /**

@@ -346,7 +346,7 @@ open class SymbolVisitor(
 
     override fun memberShape(shape: MemberShape): Symbol {
         val target = model.expectShape(shape.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<_>>.
         return handleOptionality(
             handleRustBoxing(toSymbol(target), shape),
             shape,

@@ -590,7 +590,14 @@ class HttpBindingGenerator(
         renderErrorMessage: (String) -> Writable,
     ) {
         val loopVariable = ValueExpression.Reference(safeName("inner"))
-        rustBlock("for ${loopVariable.name} in ${value.asRef()}") {
+        val context = HeaderValueSerializationContext(value, shape)
+        for (customization in customizations) {
+            customization.section(
+                HttpBindingSection.BeforeRenderingHeaderValue(context),
+            )(this)
+        }
+
+        rustBlock("for ${loopVariable.name} in ${context.valueExpression.asRef()}") {
             this.renderHeaderValue(
                 headerName,
                 loopVariable,

@@ -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,
             )
         }

@@ -30,6 +30,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
 
 /**
@@ -58,8 +59,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()
@@ -72,13 +73,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)
@@ -89,11 +90,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()
+                    check(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()
@@ -112,4 +111,16 @@ 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.
+     */
+    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()
+    }
 }
@@ -25,8 +25,8 @@ import software.amazon.smithy.model.traits.LengthTrait
 import software.amazon.smithy.model.traits.PatternTrait
 import software.amazon.smithy.model.traits.RangeTrait
 import software.amazon.smithy.model.traits.RequiredTrait
-import software.amazon.smithy.model.traits.Trait
 import software.amazon.smithy.model.traits.UniqueItemsTrait
+import software.amazon.smithy.rust.codegen.core.smithy.CodegenContext
 import software.amazon.smithy.rust.codegen.core.smithy.isOptional
 import software.amazon.smithy.rust.codegen.core.util.UNREACHABLE
 import software.amazon.smithy.rust.codegen.core.util.hasTrait
@@ -40,14 +40,27 @@ 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 supportedStringConstraintTraits: List<Class<out Trait>> = listOf(LengthTrait::class.java, PatternTrait::class.java)
+val allConstraintTraits = setOf(
+    LengthTrait::class.java,
+    PatternTrait::class.java,
+    RangeTrait::class.java,
+    UniqueItemsTrait::class.java,
+    EnumTrait::class.java,
+    RequiredTrait::class.java,
+)
+
+val supportedStringConstraintTraits = setOf(LengthTrait::class.java, PatternTrait::class.java)
+
+/**
+ * Supported constraint traits for the `list` and `set` shapes.
+ */
+val supportedCollectionConstraintTraits = setOf(
+    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:
@@ -75,6 +88,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, is ShortShape, is LongShape, is ByteShape -> this.hasTrait<RangeTrait>()
     else -> false
 }
@@ -99,6 +113,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, is ShortShape, is LongShape, is ByteShape -> publicConstrainedTypes && this.hasTrait<RangeTrait>()

@@ -108,7 +108,7 @@ class PubCrateConstrainedShapeSymbolProvider(
                     base.toSymbol(shape)
                 } else {
                     val targetSymbol = this.toSymbol(targetShape)
-                    // 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,