WIP Extract configuration logic

TODO
- Readme module.
- iterationFailures unused?
- remove check failure in next commit?
- check if PException was caught on next iteration
- configured shouldn't catch PException
- vanilla `parameterize` docs, and other configuration docs
- merge iterator -> state (vanilla & configured)

Improves performance of unconfigured parameterize, and greatly simplifies core logic
configuration may be dropped later

parameterize-configuration/src/commonMain/kotlin/ConfiguredParameterize.kt

@@ -27,12 +27,12 @@ public inline fun parameterize(
     val state = ConfiguredParameterizeState(configuration)
 
     parameterize {
-        val scope = state.nextIteration() ?: return
+        val scope = state.nextIteration(this) ?: return
 
         try {
             scope.block()
         } catch (failure: Throwable) {
-            state.handleFailure(failure)
+            state.handleThrow(failure)
         }
     }
 

parameterize-configuration/src/commonMain/kotlin/ConfiguredParameterizeState.kt

@@ -22,7 +22,6 @@ import kotlin.coroutines.Continuation
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.coroutines.intrinsics.createCoroutineUnintercepted
 import kotlin.coroutines.resume
-import kotlin.jvm.JvmInline
 import kotlin.reflect.KProperty
 
 @PublishedApi
@@ -32,6 +31,7 @@ internal class ConfiguredParameterizeState(
     private var iterationCount = 0L
     private var skipCount = 0L
     private var failureCount = 0L
+    private var unhandledFailure: Throwable? = null
     private val recordedFailures = mutableListOf<ParameterizeFailure>()
 
     private var breakEarly = false
@@ -47,7 +47,7 @@ internal class ConfiguredParameterizeState(
             return null
         }
 
-        if (currentIterationScope != null) afterEach()
+        if (currentIterationScope != null) afterEach(false)
 
         return ConfiguredParameterizeScope(parameterizeScope).also {
             currentIterationScope = it
@@ -57,71 +57,66 @@ internal class ConfiguredParameterizeState(
     }
 
     @PublishedApi
-    internal fun handleFailure(failure: Throwable): Unit = when {
-        failure is ParameterizeControlFlow -> {
-            afterEach() // Since nextIteration() won't be called again to finalize the iteration
-            throw failure // TODO Could be blocked if afterEach throws
+    internal fun handleThrow(thrown: Throwable): Unit = when {
+        thrown is ParameterizeControlFlow -> {
+            // Counts as skip regardless of what kind of control flow, since either:
+            // - it's a continue this loop for this parameterize loop, meaning it *is* a proper skip;
+            // - or breaks out of this loop, meaning the count *is* inaccurate, but won't be used anyway.
+            skipCount++
+
+            throw thrown // TODO Could be blocked if afterEach throws
         }
 
         else -> {
-            afterEach() // Since the decorator should complete before onFailure is invoked
-
-            val result = handleFailure(configuration.onFailure, failure)
-            breakEarly = result.breakEarly
+            unhandledFailure = thrown
         }
     }
 
     private fun beforeEach() {
-        decoratorCoroutine = DecoratorCoroutine(parameterizeState, configuration)
+        decoratorCoroutine = DecoratorCoroutine(this, configuration)
             .also { it.beforeIteration() }
     }
 
-    private fun afterEach() {
-        val currentIterationScope = checkNotNull(currentIterationScope) { "${::currentIterationScope.name} was null" }
+    private fun afterEach(isLastIteration: Boolean) {
         val decoratorCoroutine = checkNotNull(decoratorCoroutine) { "${::decoratorCoroutine.name} was null" }
 
-        currentIterationScope.iterationCompleted = true
         decoratorCoroutine.afterIteration()
 
         this.currentIterationScope = null
         this.decoratorCoroutine = null
-    }
 
-    fun handleContinue() {
-        skipCount++
+        unhandledFailure?.let { failure ->
+            unhandledFailure = null
+            handleFailure(failure)
+        }
     }
 
-    @JvmInline
-    value class HandleFailureResult(val breakEarly: Boolean)
-
-    fun handleFailure(onFailure: OnFailureScope.(Throwable) -> Unit, failure: Throwable): HandleFailureResult {
+    private fun handleFailure(failure: Throwable) {
         failureCount++
 
-        val scope = OnFailureScope(
+        val onFailureScope = OnFailureScope(
             state = this,
             iterationCount,
             failureCount,
         )
 
-        with(scope) {
-            onFailure(failure)
+        configuration.onFailure(onFailureScope, failure)
 
-            if (recordFailure) {
-                recordedFailures += ParameterizeFailure(failure, parameters)
-            }
-
-            return HandleFailureResult(breakEarly)
+        if (onFailureScope.recordFailure) {
+            recordedFailures += ParameterizeFailure(failure, onFailureScope.parameters)
         }
+
+        breakEarly = onFailureScope.breakEarly
     }
 
-    private fun handleComplete() {
-        afterEach()
+    fun handleComplete() {
+        afterEach(true)
 
         val scope = OnCompleteScope(
             iterationCount,
             skipCount,
             failureCount,
-            completedEarly = hasNextArgumentCombination,
+            completedEarly = false, // TODO hasNextArgumentCombination,
             recordedFailures,
         )
 
@@ -146,7 +141,7 @@ private class ConfiguredParameterizeScope(
  * two separate parts, without needing to wrap the (inlined) [parameterize] block.
  */
 private class DecoratorCoroutine(
-    private val parameterizeState: ParameterizeState,
+    private val parameterizeState: ConfiguredParameterizeState,
     private val configuration: ParameterizeConfiguration
 ) {
     private val scope = DecoratorScope(parameterizeState)
@@ -155,7 +150,7 @@ private class DecoratorCoroutine(
     private var completed = false
 
     private val iteration: suspend DecoratorScope.() -> Unit = {
-        parameterizeState.checkState(continueAfterIteration == null) {
+        check(continueAfterIteration == null) {
             "Decorator must invoke the iteration function exactly once, but was invoked twice"
         }
 

parameterize-configuration/src/commonMain/kotlin/ParameterizeConfiguration.kt

@@ -139,7 +139,7 @@ public class ParameterizeConfiguration internal constructor(
     /** @see Builder.decorator */
     @RestrictsSuspension
     public class DecoratorScope internal constructor(
-        private val parameterizeState: ParameterizeState
+        private val parameterizeState: ConfiguredParameterizeState
     ) {
         private var initializedIsLastIteration = false
 

parameterize-core/src/commonMain/kotlin/ParameterizeState.kt

@@ -44,18 +44,13 @@ internal class ParameterizeState {
      */
     private var lastParameterWithNextArgument: ParameterState? = null
 
-    private var iterationCount = 0L
-    private var skipCount = 0L
-    private var failureCount = 0L
+    private var startedFirstIteration = true
 
     val hasNextArgumentCombination: Boolean
-        get() = lastParameterWithNextArgument != null || iterationCount == 0L
-
-    val isFirstIteration: Boolean
-        get() = iterationCount == 1L
+        get() = lastParameterWithNextArgument != null || !startedFirstIteration
 
     fun startNextIteration() {
-        iterationCount++
+        startedFirstIteration = true
         parameterCount = 0
 
         parameterToIterate = lastParameterWithNextArgument