Builders of builders

codegen-client-test/model/constraints.smithy

@@ -0,0 +1 @@
+../../codegen-server-test/model/constraints.smithy

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/rustlang/CargoDependency.kt

@@ -112,6 +112,9 @@ class InlineDependency(
 
         fun unwrappedXmlErrors(runtimeConfig: RuntimeConfig): InlineDependency =
             forRustFile("rest_xml_unwrapped_errors", CargoDependency.smithyXml(runtimeConfig))
+
+        fun constrained(): InlineDependency =
+            forRustFile("constrained")
     }
 }
 

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/rustlang/RustTypes.kt

@@ -148,6 +148,12 @@ sealed class RustType {
         }
     }
 
+    data class MaybeConstrained(override val member: RustType) : RustType(), Container {
+        val runtimeType: RuntimeType = RuntimeType.MaybeConstrained()
+        override val name = runtimeType.name!!
+        override val namespace = runtimeType.namespace
+    }
+
     data class Box(override val member: RustType) : RustType(), Container {
         override val name = "Box"
         override val namespace = "std::boxed"
@@ -237,6 +243,7 @@ fun RustType.render(fullyQualified: Boolean = true): String {
         is RustType.Box -> "${this.name}<${this.member.render(fullyQualified)}>"
         is RustType.Dyn -> "${this.name} ${this.member.render(fullyQualified)}"
         is RustType.Opaque -> this.name
+        is RustType.MaybeConstrained -> "${this.name}<${this.member.render(fullyQualified)}>"
     }
     return "$namespace$base"
 }
@@ -383,10 +390,11 @@ sealed class Attribute {
          * indicates that more fields may be added in the future
          */
         val NonExhaustive = Custom("non_exhaustive")
+        val AllowUnused = Custom("allow(unused)")
         val AllowUnusedMut = Custom("allow(unused_mut)")
-        val AllowDeadCode = Custom("allow(dead_code)")
-        val DocHidden = Custom("doc(hidden)")
         val DocInline = Custom("doc(inline)")
+        val DocHidden = Custom("doc(hidden)")
+        val AllowDeadCode = Custom("allow(dead_code)")
     }
 
     data class Derives(val derives: Set<RuntimeType>) : Attribute() {

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/CodegenDelegator.kt

@@ -149,16 +149,23 @@ open class RustCrate(
     }
 }
 
+val ErrorsModule = RustModule.public("error", documentation = "All error types that operations can return.")
+val OperationsModule = RustModule.public("operation", documentation = "All operations that this crate can perform.")
+val ModelsModule = RustModule.public("model", documentation = "Data structures used by operation inputs/outputs.")
+val InputsModule = RustModule.public("input", documentation = "Input structures for operations.")
+val OutputsModule = RustModule.public("output", documentation = "Output structures for operations.")
+val ConfigModule = RustModule.public("config", documentation = "Client configuration.")
+
 /**
  * Allowlist of modules that will be exposed publicly in generated crates
  */
 val DefaultPublicModules = setOf(
-    RustModule.public("error", documentation = "All error types that operations can return."),
-    RustModule.public("operation", documentation = "All operations that this crate can perform."),
-    RustModule.public("model", documentation = "Data structures used by operation inputs/outputs."),
-    RustModule.public("input", documentation = "Input structures for operations."),
-    RustModule.public("output", documentation = "Output structures for operations."),
-    RustModule.public("config", documentation = "Client configuration."),
+    ErrorsModule,
+    OperationsModule,
+    ModelsModule,
+    InputsModule,
+    OutputsModule,
+    ConfigModule,
 ).associateBy { it.name }
 
 /**

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/ConstraintViolationSymbolProvider.kt

@@ -0,0 +1,119 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.rust.codegen.client.smithy
+
+import software.amazon.smithy.codegen.core.Symbol
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.model.shapes.CollectionShape
+import software.amazon.smithy.model.shapes.MapShape
+import software.amazon.smithy.model.shapes.ServiceShape
+import software.amazon.smithy.model.shapes.Shape
+import software.amazon.smithy.model.shapes.StringShape
+import software.amazon.smithy.model.shapes.StructureShape
+import software.amazon.smithy.model.shapes.UnionShape
+import software.amazon.smithy.rust.codegen.client.rustlang.RustReservedWords
+import software.amazon.smithy.rust.codegen.client.rustlang.RustType
+import software.amazon.smithy.rust.codegen.client.smithy.generators.builderSymbol
+import software.amazon.smithy.rust.codegen.core.util.toSnakeCase
+
+// TODO Move this file to `core` or `server`.
+
+/**
+ * The [ConstraintViolationSymbolProvider] returns, for a given constrained
+ * shape, a symbol whose Rust type can hold information about constraint
+ * violations that may occur when building the shape from unconstrained values.
+ *
+ * So, for example, given the model:
+ *
+ * ```smithy
+ * @pattern("\\w+")
+ * @length(min: 1, max: 69)
+ * string NiceString
+ *
+ * structure Structure {
+ *     @required
+ *     niceString: NiceString
+ * }
+ * ```
+ *
+ * A `NiceString` built from an arbitrary Rust `String` may give rise to at
+ * most two constraint trait violations: one for `pattern`, one for `length`.
+ * Similarly, the shape `Structure` can fail to be built when a value for
+ * `niceString` is not provided.
+ *
+ * Said type is always called `ConstraintViolation`, and resides in a bespoke
+ * module inside the same module as the _public_ constrained type the user is
+ * exposed to. When the user is _not_ exposed to the constrained type, the
+ * constraint violation type's module is a child of the `model` module.
+ *
+ * It is the responsibility of the caller to ensure that the shape is
+ * constrained (either directly or transitively) before using this symbol
+ * provider. This symbol provider intentionally crashes if the shape is not
+ * constrained.
+ */
+class ConstraintViolationSymbolProvider(
+    private val base: RustSymbolProvider,
+    private val model: Model,
+    private val serviceShape: ServiceShape,
+) : WrappingSymbolProvider(base) {
+    private val constraintViolationName = "ConstraintViolation"
+
+    private fun constraintViolationSymbolForCollectionOrMapOrUnionShape(shape: Shape): Symbol {
+        check(shape is CollectionShape || shape is MapShape || shape is UnionShape)
+
+        val symbol = base.toSymbol(shape)
+        val constraintViolationNamespace =
+            "${symbol.namespace.let { it.ifEmpty { "crate::${Models.namespace}" } }}::${
+            RustReservedWords.escapeIfNeeded(
+                shape.contextName(serviceShape).toSnakeCase(),
+            )
+            }"
+        val rustType = RustType.Opaque(constraintViolationName, constraintViolationNamespace)
+        return Symbol.builder()
+            .rustType(rustType)
+            .name(rustType.name)
+            .namespace(rustType.namespace, "::")
+            .definitionFile(symbol.definitionFile)
+            .build()
+    }
+
+    override fun toSymbol(shape: Shape): Symbol {
+        check(shape.canReachConstrainedShape(model, base))
+
+        return when (shape) {
+            is MapShape, is CollectionShape, is UnionShape -> {
+                constraintViolationSymbolForCollectionOrMapOrUnionShape(shape)
+            }
+            is StructureShape -> {
+                val builderSymbol = shape.builderSymbol(base)
+
+                val namespace = builderSymbol.namespace
+                val rustType = RustType.Opaque(constraintViolationName, namespace)
+                Symbol.builder()
+                    .rustType(rustType)
+                    .name(rustType.name)
+                    .namespace(rustType.namespace, "::")
+                    .definitionFile(builderSymbol.definitionFile)
+                    .build()
+            }
+            is StringShape -> {
+                val namespace = "crate::${Models.namespace}::${
+                RustReservedWords.escapeIfNeeded(
+                    shape.contextName(serviceShape).toSnakeCase(),
+                )
+                }"
+                val rustType = RustType.Opaque(constraintViolationName, namespace)
+                Symbol.builder()
+                    .rustType(rustType)
+                    .name(rustType.name)
+                    .namespace(rustType.namespace, "::")
+                    .definitionFile(Models.filename)
+                    .build()
+            }
+            else -> TODO("Constraint traits on other shapes not implemented yet: $shape")
+        }
+    }
+}

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/Constraints.kt

@@ -0,0 +1,125 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.rust.codegen.client.smithy
+
+import software.amazon.smithy.codegen.core.SymbolProvider
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.model.neighbor.Walker
+import software.amazon.smithy.model.shapes.CollectionShape
+import software.amazon.smithy.model.shapes.MapShape
+import software.amazon.smithy.model.shapes.MemberShape
+import software.amazon.smithy.model.shapes.Shape
+import software.amazon.smithy.model.shapes.SimpleShape
+import software.amazon.smithy.model.shapes.StringShape
+import software.amazon.smithy.model.shapes.StructureShape
+import software.amazon.smithy.model.shapes.UnionShape
+import software.amazon.smithy.model.traits.EnumTrait
+import software.amazon.smithy.model.traits.LengthTrait
+import software.amazon.smithy.rust.codegen.client.smithy.generators.CodegenTarget
+import software.amazon.smithy.rust.codegen.core.util.UNREACHABLE
+import software.amazon.smithy.rust.codegen.core.util.hasTrait
+
+/**
+ * This file contains utilities to work with constrained shapes.
+ *
+ * TODO Move this file to `core` or `server`.
+ */
+
+/**
+ * We say a shape is _directly_ constrained if:
+ *
+ *     - it has a constraint trait, or;
+ *     - in the case of it being an aggregate shape, one of its member shapes has a constraint trait.
+ *
+ * Note that an aggregate shape whose member shapes do not have constraint traits but that has a member whose target is
+ * a constrained shape is _not_ directly constrained.
+ *
+ * At the moment only a subset of constraint traits are implemented on a subset of shapes; that's why we match against
+ * a subset of shapes in each arm, and check for a subset of constraint traits attached to the shape in the arm's
+ * (with these subsets being smaller than what [the spec] accounts for).
+ *
+ * Note `uniqueItems` is deprecated, so we won't ever implement it.
+ *
+ * [the spec]: https://awslabs.github.io/smithy/1.0/spec/core/constraint-traits.html
+ */
+fun Shape.isDirectlyConstrained(symbolProvider: SymbolProvider) = when (this) {
+    is StructureShape -> {
+        // TODO(https://github.com/awslabs/smithy-rs/issues/1302, https://github.com/awslabs/smithy/issues/1179):
+        //  The only reason why the functions in this file have
+        //  to take in a `SymbolProvider` is because non-`required` blob streaming members are interpreted as
+        //  `required`, so we can't use `member.isOptional` here.
+        this.members().map { symbolProvider.toSymbol(it) }.any { !it.isOptional() }
+    }
+    is MapShape -> this.hasTrait<LengthTrait>()
+    is StringShape -> this.hasTrait<EnumTrait>() || this.hasTrait<LengthTrait>()
+    else -> false
+}
+
+fun Shape.hasPublicConstrainedWrapperTupleType(model: Model, publicConstrainedTypes: Boolean): Boolean = when (this) {
+    is MapShape -> publicConstrainedTypes && this.hasTrait<LengthTrait>()
+    is StringShape -> !this.hasTrait<EnumTrait>() && (publicConstrainedTypes && this.hasTrait<LengthTrait>())
+    is MemberShape -> model.expectShape(this.target).hasPublicConstrainedWrapperTupleType(model, publicConstrainedTypes)
+    else -> false
+}
+
+fun Shape.wouldHaveConstrainedWrapperTupleTypeWerePublicConstrainedTypesEnabled(model: Model) =
+    hasPublicConstrainedWrapperTupleType(model, true)
+
+/**
+ * Helper function to determine whether a shape will map to a _public_ constrained wrapper tuple type.
+ *
+ * This function is used in core code generators, so it takes in a [CoreCodegenContext] that is downcast
+ * to [ServerCodegenContext] when generating servers.
+ */
+fun workingWithPublicConstrainedWrapperTupleType(shape: Shape, coreCodegenContext: CoreCodegenContext) =
+    coreCodegenContext.target == CodegenTarget.SERVER &&
+        shape.hasPublicConstrainedWrapperTupleType(
+            coreCodegenContext.model,
+            (coreCodegenContext as ServerCodegenContext).settings.codegenConfig.publicConstrainedTypes,
+        )
+
+/**
+ * Returns whether a shape's type _name_ contains a non-public type when `publicConstrainedTypes` is `false`.
+ *
+ * For example, a `Vec<crate::model::LengthString>` contains a non-public type, because `crate::model::LengthString`
+ * is `pub(crate)` when `publicConstrainedTypes` is `false`
+ *
+ * Note that a structure shape's type _definition_ may contain non-public types, but its _name_ is always public.
+ *
+ * Note how we short-circuit on `publicConstrainedTypes = true`, but we still require it to be passed in instead of laying
+ * the responsibility on the caller, for API safety usage.
+ */
+fun Shape.typeNameContainsNonPublicType(
+    model: Model,
+    symbolProvider: SymbolProvider,
+    publicConstrainedTypes: Boolean,
+): Boolean = !publicConstrainedTypes && when (this) {
+    is SimpleShape -> wouldHaveConstrainedWrapperTupleTypeWerePublicConstrainedTypesEnabled(model)
+    is MemberShape -> model.expectShape(this.target).typeNameContainsNonPublicType(model, symbolProvider, publicConstrainedTypes)
+    is CollectionShape -> this.canReachConstrainedShape(model, symbolProvider)
+    is MapShape -> this.canReachConstrainedShape(model, symbolProvider)
+    is StructureShape, is UnionShape -> false
+    else -> UNREACHABLE("the above arms should be exhaustive, but we received shape: $this")
+}
+
+fun MemberShape.targetCanReachConstrainedShape(model: Model, symbolProvider: SymbolProvider): Boolean =
+    model.expectShape(this.target).canReachConstrainedShape(model, symbolProvider)
+
+fun MemberShape.hasConstraintTraitOrTargetHasConstraintTrait(model: Model, symbolProvider: SymbolProvider) =
+    this.isDirectlyConstrained(symbolProvider) || (model.expectShape(this.target).isDirectlyConstrained(symbolProvider))
+
+fun Shape.isTransitivelyButNotDirectlyConstrained(model: Model, symbolProvider: SymbolProvider) =
+    !this.isDirectlyConstrained(symbolProvider) && this.canReachConstrainedShape(model, symbolProvider)
+
+fun Shape.canReachConstrainedShape(model: Model, symbolProvider: SymbolProvider) =
+    if (this is MemberShape) {
+        // TODO(https://github.com/awslabs/smithy-rs/issues/1401) Constraint traits on member shapes are not implemented
+        //  yet. Also, note that a walker over a member shape can, perhaps counterintuitively, reach the _containing_ shape,
+        //  so we can't simply delegate to the `else` branch when we implement them.
+        this.targetCanReachConstrainedShape(model, symbolProvider)
+    } else {
+        Walker(model).walkShapes(this).toSet().any { it.isDirectlyConstrained(symbolProvider) }
+    }