~small tweaks

Author: qwwdfsad

kotlinx-coroutines-core/jvm/src/CoroutineContext.kt

@@ -9,10 +9,9 @@ import kotlin.coroutines.*
 import kotlin.coroutines.jvm.internal.CoroutineStackFrame
 
 /**
- * Creates context for the new coroutine. It installs [Dispatchers.Default] when no other dispatcher nor
- * [ContinuationInterceptor] is specified and adds support for
- * copyable thread context [elements][CopyableThreadContextElement] and debugging facilities (optionally, when turned on).
- *
+ * Creates a context for a new coroutine. It installs [Dispatchers.Default] when no other dispatcher or
+ * [ContinuationInterceptor] is specified and adds optional support for debugging facilities (when turned on)
+ * and copyable-thread-local facilities on JVM.
  * See [DEBUG_PROPERTY_NAME] for description of debugging facilities on JVM.
  */
 @ExperimentalCoroutinesApi
@@ -24,7 +23,7 @@ public actual fun CoroutineScope.newCoroutineContext(context: CoroutineContext):
 }
 
 /**
- * Creates context for coroutine builder functions that do not launch a new coroutine, namely [withContext].
+ * Creates a context for coroutine builder functions that do not launch a new coroutine, e.g. [withContext].
  * @suppress
  */
 @InternalCoroutinesApi
@@ -33,13 +32,12 @@ public actual fun CoroutineContext.newCoroutineContext(addedContext: CoroutineCo
      * Fast-path: we only have to copy/merge if 'addedContext' (which typically has one or two elements)
      * contains copyable elements.
      */
-    if (!addedContext.fold(false, hasCopyableElements)) return this + addedContext
+    if (!addedContext.hasCopyableElements()) return this + addedContext
     return foldCopies(this, addedContext, false)
 }
 
-private val hasCopyableElements: (Boolean, CoroutineContext.Element) -> Boolean = { result, it ->
-    result || it is CopyableThreadContextElement<*>
-}
+private fun CoroutineContext.hasCopyableElements(): Boolean =
+    fold(false) { result, it -> result || it is CopyableThreadContextElement<*> }
 
 /**
  * Folds two contexts properly applying [CopyableThreadContextElement] rules when necessary.
@@ -53,8 +51,8 @@ private val hasCopyableElements: (Boolean, CoroutineContext.Element) -> Boolean
  */
 private fun foldCopies(originalContext: CoroutineContext, appendContext: CoroutineContext, isNewCoroutine: Boolean): CoroutineContext {
     // Do we have something to copy left-hand side?
-    val hasElementsLeft = originalContext.fold(false, hasCopyableElements)
-    val hasElementsRight = appendContext.fold(false, hasCopyableElements)
+    val hasElementsLeft = originalContext.hasCopyableElements()
+    val hasElementsRight = appendContext.hasCopyableElements()
 
     // Nothing to fold, so just return the sum of contexts
     if (!hasElementsLeft && !hasElementsRight) {
@@ -126,7 +124,7 @@ internal actual inline fun <T> withContinuationContext(continuation: Continuatio
 internal fun Continuation<*>.updateUndispatchedCompletion(context: CoroutineContext, oldValue: Any?): UndispatchedCoroutine<*>? {
     if (this !is CoroutineStackFrame) return null
     /*
-     * Fast-path to detect whether we have unispatched coroutine at all in our stack.
+     * Fast-path to detect whether we have undispatched coroutine at all in our stack.
      *
      * Implementation note.
      * If we ever find that stackwalking for thread-locals is way too slow, here is another idea:
@@ -137,8 +135,8 @@ internal fun Continuation<*>.updateUndispatchedCompletion(context: CoroutineCont
      *    Both options should work, but it requires more careful studying of the performance
      *    and, mostly, maintainability impact.
      */
-    val potentiallyHasUndispatchedCorotuine = context[UndispatchedMarker] !== null
-    if (!potentiallyHasUndispatchedCorotuine) return null
+    val potentiallyHasUndispatchedCoroutine = context[UndispatchedMarker] !== null
+    if (!potentiallyHasUndispatchedCoroutine) return null
     val completion = undispatchedCompletion()
     completion?.saveThreadContext(context, oldValue)
     return completion

kotlinx-coroutines-core/jvm/src/ThreadContextElement.kt

@@ -80,7 +80,7 @@ public interface ThreadContextElement<S> : CoroutineContext.Element {
 /**
  * A [ThreadContextElement] copied whenever a child coroutine inherits a context containing it.
  *
- * When an API uses a _mutable_ `ThreadLocal` for consistency, a [CopyableThreadContextElement]
+ * When an API uses a _mutable_ [ThreadLocal] for consistency, a [CopyableThreadContextElement]
  * can give coroutines "coroutine-safe" write access to that `ThreadLocal`.
  *
  * A write made to a `ThreadLocal` with a matching [CopyableThreadContextElement] by a coroutine
@@ -97,8 +97,9 @@ public interface ThreadContextElement<S> : CoroutineContext.Element {
  * is in a coroutine:
  *
  * ```
- * class TraceContextElement(private val traceData: TraceData?) : CopyableThreadContextElement<TraceData?, TraceContextElement> {
+ * class TraceContextElement(private val traceData: TraceData?) : CopyableThreadContextElement<TraceData?> {
  *     companion object Key : CoroutineContext.Key<TraceContextElement>
+ *
  *     override val key: CoroutineContext.Key<TraceContextElement> = Key
  *
  *     override fun updateThreadContext(context: CoroutineContext): TraceData? {
@@ -118,7 +119,7 @@ public interface ThreadContextElement<S> : CoroutineContext.Element {
  *         return TraceContextElement(traceThreadLocal.get()?.copy())
  *     }
  *
- *     override fun mergeForChild(overwritingElement: CoroutineContext.Element): CoroutineContext
+ *     override fun mergeForChild(overwritingElement: CoroutineContext.Element): CoroutineContext {
  *         // Merge operation defines how to handle situation when both
  *         // the parent coroutine has an element in the context and
  *         // an element with the same key was also