Discard strict double-wrapping check

We decided not to go with it, as it may dump a lot of error messages to a clueless user's console.

Author: AlexVanGogen

IntelliJ-patches.md

@@ -72,11 +72,7 @@ Some logic related to instrumentation was extracted to separate methods so that
 
 - `kotlinx.coroutines.flow.internal.FlowValueWrapperInternal` -- wrapper class used to create a unique object for the debugger agent
 - `kotlinx.coroutines.flow.internal.FlowValueWrapperInternalKt.wrapInternal` -- returns passed argument by default; the agent instruments it to call `wrapInternalDebuggerCapture` instead
-- `kotlinx.coroutines.flow.internal.FlowValueWrapperInternalKt.wrapInternalDebuggerCaptureX` -- wraps passed arguments into a `FlowValueWrapperInternal`; only used after transformation.
-  `X` may mean `Strict` or `Lenient`. Both methods handle double-wrapping, which is always an error that is hard to investigate if it arises naturally.
-    - `Strict` throws an exception, thus allowing fail-fast strategy
-    - `Lenient` returns its argument without wrapping it again
-  Debugger agent decides which version to use based on IDE settings.
+- `kotlinx.coroutines.flow.internal.FlowValueWrapperInternalKt.wrapInternalDebuggerCapture` -- wraps passed arguments into a `FlowValueWrapperInternal`; only used after transformation.
 - `kotlinx.coroutines.flow.internal.FlowValueWrapperInternalKt.unwrapInternal` -- returns passed argument by default; the agent instruments it to call `unwrapInternalDebuggerCapture` instead
 - `kotlinx.coroutines.flow.internal.FlowValueWrapperInternalKt.unwrapInternalDebuggerCapture` -- unwraps passed argument so it returns the original value; only used after transformation
 - `kotlinx.coroutines.flow.internal.FlowValueWrapperInternalKt.emitInternal(FlowCollector, value)` -- common insertion point for a debugger agent; simplifies instrumentation; the value is always being unwrapped inside

kotlinx-coroutines-core/common/src/flow/internal/FlowValueWrapperInternal.kt

@@ -15,21 +15,8 @@ internal class FlowValueWrapperInternal<T>(val value: T)
 internal fun <T> wrapInternal(value: T): T = value
 internal fun <T> unwrapInternal(value: T): T = value
 
-// debugger agent transforms wrapInternal so it returns wrapInternalDebuggerCaptureX(value) instead of just value.
-// "X" may be Strict or Lenient, debugger agent picks one depending on its arguments.
-// Both versions are aimed at handling double wrapping, which is always an error;
-// a lenient version swallows it, allowing the application to proceed normally
-// at the cost of not working async stack traces in the place;
-// a strict version throws an exception so that the issue could be traced at its earliest point
-
-private fun wrapInternalDebuggerCaptureStrict(value: Any?): Any {
-    if (value is FlowValueWrapperInternal<*>) {
-        throw DoubleWrappingException("Double-wrapping detected; failing fast. This should never happen!")
-    }
-    return FlowValueWrapperInternal(value)
-}
-
-private fun wrapInternalDebuggerCaptureLenient(value: Any?): Any {
+// debugger agent transforms wrapInternal so it returns wrapInternalDebuggerCapture(value) instead of just value.
+private fun wrapInternalDebuggerCapture(value: Any?): Any {
     if (value is FlowValueWrapperInternal<*>) {
         return value
     }
@@ -50,5 +37,3 @@ private fun unwrapInternalDebuggerCapture(value: Any?): Any? {
 internal suspend fun <T> FlowCollector<T>.emitInternal(value: Any?) {
     emit(NULL.unbox(unwrapInternal(value)))
 }
-
-private class DoubleWrappingException(message: String) : RuntimeException(message)