Allow injecting methods with generic type parameters in the config object (#3274)

This is a follow-up to #3111. Currently, the injected methods are
limited to taking in concrete types. This PR allows for these methods to
take in generic type parameters as well.

```rust
impl<L, H, M> SimpleServiceConfigBuilder<L, H, M> {
    pub fn aws_auth<C>(config: C) {
        ...
    }
}
```

----

_By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice._

Author: david-perez

codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServiceConfigGenerator.kt

@@ -5,6 +5,7 @@
 
 package software.amazon.smithy.rust.codegen.server.smithy.generators
 
+import software.amazon.smithy.codegen.core.CodegenException
 import software.amazon.smithy.rust.codegen.core.rustlang.RustWriter
 import software.amazon.smithy.rust.codegen.core.rustlang.Writable
 import software.amazon.smithy.rust.codegen.core.rustlang.conditionalBlock
@@ -13,6 +14,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.join
 import software.amazon.smithy.rust.codegen.core.rustlang.rust
 import software.amazon.smithy.rust.codegen.core.rustlang.rustBlockTemplate
 import software.amazon.smithy.rust.codegen.core.rustlang.rustTemplate
+import software.amazon.smithy.rust.codegen.core.rustlang.rustTypeParameters
 import software.amazon.smithy.rust.codegen.core.rustlang.writable
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType
 import software.amazon.smithy.rust.codegen.core.smithy.RuntimeType.Companion.preludeScope
@@ -33,7 +35,7 @@ data class ConfigMethod(
     val docs: String,
     /** The parameters of the method. **/
     val params: List<Binding>,
-    /** In case the method is fallible, the error type it returns. **/
+    /** In case the method is fallible, the concrete error type it returns. **/
     val errorType: RuntimeType?,
     /** The code block inside the method. **/
     val initializer: Initializer,
@@ -104,15 +106,45 @@ data class Initializer(
  * }
  *
  * has two variable bindings. The `bar` name is bound to a `String` variable and the `baz` name is bound to a
- * `u64` variable.
+ * `u64` variable. Both are bindings that use concrete types. Types can also be generic:
+ *
+ * ```rust
+ * fn foo<T>(bar: T) { }
  * ```
  */
-data class Binding(
-    /** The name of the variable. */
-    val name: String,
-    /** The type of the variable. */
-    val ty: RuntimeType,
-)
+sealed class Binding {
+    data class Generic(
+        /** The name of the variable. The name of the type parameter will be the PascalCased variable name. */
+        val name: String,
+        /** The type of the variable. */
+        val ty: RuntimeType,
+        /**
+         * The generic type parameters contained in `ty`. For example, if `ty` renders to `Vec<T>` with `T` being a
+         * generic type parameter, then `genericTys` should be a singleton set containing `"T"`.
+         * You can't use `L`, `H`, or `M` as the names to refer to any generic types.
+         * */
+        val genericTys: Set<String>,
+    ) : Binding()
+
+    data class Concrete(
+        /** The name of the variable. */
+        val name: String,
+        /** The type of the variable. */
+        val ty: RuntimeType,
+    ) : Binding()
+
+    fun name() =
+        when (this) {
+            is Concrete -> this.name
+            is Generic -> this.name
+        }
+
+    fun ty() =
+        when (this) {
+            is Concrete -> this.ty
+            is Generic -> this.ty
+        }
+}
 
 class ServiceConfigGenerator(
     codegenContext: ServerCodegenContext,
@@ -271,10 +303,10 @@ class ServiceConfigGenerator(
             writable {
                 rustTemplate(
                     """
-                    if !self.${it.requiredBuilderFlagName()} {
-                        return #{Err}(${serviceName}ConfigError::${it.requiredErrorVariant()});
-                    }
-                    """,
+                if !self.${it.requiredBuilderFlagName()} {
+                    return #{Err}(${serviceName}ConfigError::${it.requiredErrorVariant()});
+                }
+                """,
                     *codegenScope,
                 )
             }
@@ -303,19 +335,19 @@ class ServiceConfigGenerator(
                         writable {
                             rust(
                                 """
-                                ##[error("service is not fully configured; invoke `${it.name}` on the config builder")]
-                                ${it.requiredErrorVariant()},
-                                """,
+                    ##[error("service is not fully configured; invoke `${it.name}` on the config builder")]
+                    ${it.requiredErrorVariant()},
+                    """,
                             )
                         }
                     }
                 rustTemplate(
                     """
-                    ##[derive(Debug, #{ThisError}::Error)]
-                    pub enum ${serviceName}ConfigError {
-                        #{Variants:W}
-                    }
-                    """,
+                ##[derive(Debug, #{ThisError}::Error)]
+                pub enum ${serviceName}ConfigError {
+                    #{Variants:W}
+                }
+                """,
                     "ThisError" to ServerCargoDependency.ThisError.toType(),
                     "Variants" to variants.join("\n"),
                 )
@@ -327,8 +359,20 @@ class ServiceConfigGenerator(
             writable {
                 val paramBindings =
                     it.params.map { binding ->
-                        writable { rustTemplate("${binding.name}: #{BindingTy},", "BindingTy" to binding.ty) }
+                        writable { rustTemplate("${binding.name()}: #{BindingTy},", "BindingTy" to binding.ty()) }
                     }.join("\n")
+                val genericBindings = it.params.filterIsInstance<Binding.Generic>()
+                val lhmBindings =
+                    genericBindings.filter {
+                        it.genericTys.contains("L") || it.genericTys.contains("H") || it.genericTys.contains("M")
+                    }
+                if (lhmBindings.isNotEmpty()) {
+                    throw CodegenException(
+                        "Injected config method `${it.name}` has generic bindings that use `L`, `H`, or `M` to refer to the generic types. This is not allowed. Invalid generic bindings: $lhmBindings",
+                    )
+                }
+                val paramBindingsGenericTys = genericBindings.flatMap { it.genericTys }.toSet()
+                val paramBindingsGenericsWritable = rustTypeParameters(*paramBindingsGenericTys.toTypedArray())
 
                 // This produces a nested type like: "S<B, S<A, T>>", where
                 // - "S" denotes a "stack type" with two generic type parameters: the first is the "inner" part of the stack
@@ -345,7 +389,7 @@ class ServiceConfigGenerator(
                             rustTemplate(
                                 "#{StackType}<#{Ty}, #{Acc:W}>",
                                 "StackType" to stackType,
-                                "Ty" to next.ty,
+                                "Ty" to next.ty(),
                                 "Acc" to acc,
                             )
                         }
@@ -362,12 +406,12 @@ class ServiceConfigGenerator(
                     writable {
                         rustTemplate(
                             """
-                            ${serviceName}ConfigBuilder<
-                                #{LayersReturnTy:W},
-                                #{HttpPluginsReturnTy:W},
-                                #{ModelPluginsReturnTy:W},
-                            >
-                            """,
+                    ${serviceName}ConfigBuilder<
+                        #{LayersReturnTy:W},
+                        #{HttpPluginsReturnTy:W},
+                        #{ModelPluginsReturnTy:W},
+                    >
+                    """,
                             "LayersReturnTy" to layersReturnTy,
                             "HttpPluginsReturnTy" to httpPluginsReturnTy,
                             "ModelPluginsReturnTy" to modelPluginsReturnTy,
@@ -391,14 +435,15 @@ class ServiceConfigGenerator(
                 docs(it.docs)
                 rustBlockTemplate(
                     """
-                    pub fn ${it.name}(
-                        ##[allow(unused_mut)]
-                        mut self,
-                        #{ParamBindings:W}
-                    ) -> #{ReturnTy:W}
-                    """,
+                pub fn ${it.name}#{ParamBindingsGenericsWritable}(
+                    ##[allow(unused_mut)]
+                    mut self,
+                    #{ParamBindings:W}
+                ) -> #{ReturnTy:W}
+                """,
                     "ReturnTy" to returnTy,
                     "ParamBindings" to paramBindings,
+                    "ParamBindingsGenericsWritable" to paramBindingsGenericsWritable,
                 ) {
                     rustTemplate("#{InitializerCode:W}", "InitializerCode" to it.initializer.code)
 
@@ -412,9 +457,9 @@ class ServiceConfigGenerator(
                     conditionalBlock("Ok(", ")", conditional = it.errorType != null) {
                         val registrations =
                             (
-                                it.initializer.layerBindings.map { ".layer(${it.name})" } +
-                                    it.initializer.httpPluginBindings.map { ".http_plugin(${it.name})" } +
-                                    it.initializer.modelPluginBindings.map { ".model_plugin(${it.name})" }
+                                it.initializer.layerBindings.map { ".layer(${it.name()})" } +
+                                    it.initializer.httpPluginBindings.map { ".http_plugin(${it.name()})" } +
+                                    it.initializer.modelPluginBindings.map { ".model_plugin(${it.name()})" }
                             ).joinToString("")
                         rust("self$registrations")
                     }
@@ -437,9 +482,9 @@ class ServiceConfigGenerator(
         writable {
             rustBlockTemplate(
                 """
-                /// Build the configuration.
-                pub fn build(self) -> #{BuilderBuildReturnTy:W}
-                """,
+            /// Build the configuration.
+            pub fn build(self) -> #{BuilderBuildReturnTy:W}
+            """,
                 "BuilderBuildReturnTy" to builderBuildReturnType(),
             ) {
                 rustTemplate(
@@ -450,12 +495,12 @@ class ServiceConfigGenerator(
                 conditionalBlock("Ok(", ")", isBuilderFallible) {
                     rust(
                         """
-                        super::${serviceName}Config {
-                            layers: self.layers,
-                            http_plugins: self.http_plugins,
-                            model_plugins: self.model_plugins,
-                        }
-                        """,
+                    super::${serviceName}Config {
+                        layers: self.layers,
+                        http_plugins: self.http_plugins,
+                        model_plugins: self.model_plugins,
+                    }
+                    """,
                     )
                 }
             }