clean up miscellaneous grammar, naming, and code factoring issues

Author: ianbotsf

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

@@ -98,7 +98,6 @@ object RuntimeTypes {
     }
 
     object Core : RuntimeTypePackage(KotlinDependency.CORE) {
-        val Clock = symbol("Clock", "time")
         val ExecutionContext = symbol("ExecutionContext", "operation")
         val ErrorMetadata = symbol("ErrorMetadata")
         val ServiceErrorMetadata = symbol("ServiceErrorMetadata")

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/endpoints/discovery/DefaultEndpointDiscovererGenerator.kt

@@ -36,24 +36,24 @@ class DefaultEndpointDiscovererGenerator(private val ctx: CodegenContext, privat
 
     fun render() {
         delegator.applyFileWriter(symbol) {
+            val service = clientName(ctx.settings.sdkId)
             dokka(
                 """
-                    A class which looks up specific endpoints for ${ctx.settings.sdkId} calls via the `$operationName`
-                    API. These unique endpoints are cached as appropriate to avoid unnecessary latency in subsequent
-                    calls.
+                    A class which looks up specific endpoints for $service calls via the `$operationName` API. These
+                    unique endpoints are cached as appropriate to avoid unnecessary latency in subsequent calls.
                     @param cache An [ExpiringKeyedCache] implementation used to cache discovered hosts
                 """.trimIndent(),
             )
+
             withBlock(
-                "#1L class #2T(#1L val cache: #3T<DiscoveryParams, #4T> = #5T(10.#6T, #7T.System)) : #8T {",
+                "#1L class #2T(#1L val cache: #3T<DiscoveryParams, #4T> = #5T(10.#6T)) : #7T {",
                 "}",
                 ctx.settings.api.visibility,
                 symbol,
                 RuntimeTypes.Core.Collections.ExpiringKeyedCache,
                 RuntimeTypes.Core.Net.Host,
                 RuntimeTypes.Core.Collections.PeriodicSweepCache,
                 KotlinTypes.Time.minutes,
-                RuntimeTypes.Core.Clock,
                 EndpointDiscovererInterfaceGenerator.symbolFor(ctx.settings),
             ) {
                 renderAsEndpointResolver()

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/endpoints/discovery/EndpointDiscoveryIntegration.kt

@@ -62,7 +62,7 @@ class EndpointDiscoveryIntegration : KotlinIntegration {
     override fun customizeMiddleware(
         ctx: ProtocolGenerator.GenerationContext,
         resolved: List<ProtocolMiddleware>,
-    ): List<ProtocolMiddleware> = super.customizeMiddleware(ctx, resolved) + listOf(DiscoveredEndpointErrorMiddleware)
+    ): List<ProtocolMiddleware> = resolved + DiscoveredEndpointErrorMiddleware
 
     override fun enabledForService(model: Model, settings: KotlinSettings): Boolean = isEnabledFor(model, settings)
 

codegen/smithy-kotlin-codegen/src/test/kotlin/software/amazon/smithy/kotlin/codegen/rendering/endpoints/discovery/DefaultEndpointDiscovererGeneratorTest.kt

@@ -12,28 +12,35 @@ import software.amazon.smithy.kotlin.codegen.test.shouldContainOnlyOnceWithDiff
 import software.amazon.smithy.kotlin.codegen.test.toCodegenContext
 
 class DefaultEndpointDiscovererGeneratorTest {
+    private val renderedCodegen: String = run {
+        val model = model()
+        val testCtx = model.newTestContext()
+        val delegator = testCtx.generationCtx.delegator
+        val generator = DefaultEndpointDiscovererGenerator(testCtx.toCodegenContext(), delegator)
+        generator.render()
+
+        delegator.flushWriters()
+        val testManifest = delegator.fileManifest as MockManifest
+        testManifest.expectFileString("/src/main/kotlin/com/test/endpoints/DefaultTestEndpointDiscoverer.kt")
+    }
+
     @Test
     fun testClass() {
-        val actual = render()
-
-        actual.shouldContainOnlyOnceWithDiff(
+        renderedCodegen.shouldContainOnlyOnceWithDiff(
             """
                 /**
-                 * A class which looks up specific endpoints for Test calls via the `getEndpoints`
-                 * API. These unique endpoints are cached as appropriate to avoid unnecessary latency in subsequent
-                 * calls.
+                 * A class which looks up specific endpoints for Test calls via the `getEndpoints` API. These
+                 * unique endpoints are cached as appropriate to avoid unnecessary latency in subsequent calls.
                  * @param cache An [ExpiringKeyedCache] implementation used to cache discovered hosts
                  */
-                public class DefaultTestEndpointDiscoverer(public val cache: ExpiringKeyedCache<DiscoveryParams, Host> = PeriodicSweepCache(10.minutes, Clock.System)) : TestEndpointDiscoverer {
+                public class DefaultTestEndpointDiscoverer(public val cache: ExpiringKeyedCache<DiscoveryParams, Host> = PeriodicSweepCache(10.minutes)) : TestEndpointDiscoverer {
             """.trimIndent(),
         )
     }
 
     @Test
     fun testAsEndpointResolver() {
-        val actual = render()
-
-        actual.shouldContainOnlyOnceWithDiff(
+        renderedCodegen.shouldContainOnlyOnceWithDiff(
             """
                 override fun asEndpointResolver(client: TestClient, delegate: EndpointResolver): EndpointResolver = EndpointResolver { request ->
                     if (client.config.endpointUrl == null) {
@@ -60,26 +67,12 @@ class DefaultEndpointDiscovererGeneratorTest {
 
     @Test
     fun testInvalidate() {
-        val actual = render()
-
-        actual.shouldContainOnlyOnceWithDiff(
+        renderedCodegen.shouldContainOnlyOnceWithDiff(
             """
                 override public suspend fun invalidate(context: ExecutionContext) {
                     context.getOrNull(DiscoveryParamsKey)?.let { cache.invalidate(it) }
                 }
             """.formatForTest(),
         )
     }
-
-    private fun render(): String {
-        val model = model()
-        val testCtx = model.newTestContext()
-        val delegator = testCtx.generationCtx.delegator
-        val generator = DefaultEndpointDiscovererGenerator(testCtx.toCodegenContext(), delegator)
-        generator.render()
-
-        delegator.flushWriters()
-        val testManifest = delegator.fileManifest as MockManifest
-        return testManifest.expectFileString("/src/main/kotlin/com/test/endpoints/DefaultTestEndpointDiscoverer.kt")
-    }
 }

codegen/smithy-kotlin-codegen/src/test/kotlin/software/amazon/smithy/kotlin/codegen/rendering/endpoints/discovery/EndpointDiscoveryTestUtils.kt

@@ -10,11 +10,11 @@ fun model() =
     // language=smithy
     """
         namespace com.test
-
+        
         use aws.protocols#awsJson1_1
         use aws.api#service
         use aws.auth#sigv4
-
+        
         @service(sdkId: "test")
         @sigv4(name: "test")
         @awsJson1_1
@@ -30,7 +30,7 @@ fun model() =
         @error("client")
         @httpError(421)
         structure BadEndpointError { }
-
+        
         @http(method: "GET", uri: "/endpoints")
         operation GetEndpoints {
             input: GetEndpointsInput

runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/collections/ExpiringKeyedCache.kt

@@ -11,7 +11,7 @@ import aws.smithy.kotlin.runtime.util.ExpiringValue
  * [invalidate] methods are `suspend` functions to allow for cross-context synchronization and potentially-expensive
  * value lookup.
  *
- * Values in the cache _may_ expire and are retrieved as [ExpiringValue]. When a value absent/expired in the cache,
+ * Values in the cache _may_ expire and are retrieved as [ExpiringValue]. When a value is absent/expired in the cache,
  * invoking [get] will cause a lookup to occur via the function's `valueLookup` parameter.
  *
  * @param K The type of the keys of this cache
@@ -29,7 +29,7 @@ public interface ExpiringKeyedCache<K, V> {
      * exceptions, fall back to other caches, etc.
      * @param key The key for which to look up a value
      * @param valueLookup A possibly-suspending function which returns the read-through value associated with a given
-     * key. This function is invoked when the cache, for a given key, does not contain a value or the value is expired.
+     * key. This function is invoked when the cache does not contain the given [key] or when the value is expired.
      */
     public suspend fun get(key: K, valueLookup: suspend (K) -> ExpiringValue<V>): V