Introduce "redundant async" inspection #KT-24235 Fixed

idea/testData/inspectionsLocal/coroutines/redundantAsync/.inspection

@@ -0,0 +1 @@
+org.jetbrains.kotlin.idea.inspections.coroutines.RedundantAsyncInspection

idea/testData/inspectionsLocal/coroutines/redundantAsync/simple.kt

@@ -0,0 +1,48 @@
+// WITH_RUNTIME
+
+package kotlinx.coroutines.experimental
+
+interface Deferred<T> {
+    suspend fun await(): T
+}
+
+interface CoroutineContext
+
+object DefaultContext : CoroutineContext
+
+enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED
+}
+
+interface Job
+
+fun <T> async(
+    context: CoroutineContext = DefaultContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    f: suspend () -> T
+): Deferred<T> {
+    TODO()
+}
+
+fun <T> runBlocking(
+    context: CoroutineContext = DefaultContext,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun <T> withContext(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun test(ctx: CoroutineContext) {
+    <caret>async(ctx) { 42 }.await()
+}

idea/testData/inspectionsLocal/coroutines/redundantAsync/simple.kt.after

@@ -0,0 +1,48 @@
+// WITH_RUNTIME
+
+package kotlinx.coroutines.experimental
+
+interface Deferred<T> {
+    suspend fun await(): T
+}
+
+interface CoroutineContext
+
+object DefaultContext : CoroutineContext
+
+enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED
+}
+
+interface Job
+
+fun <T> async(
+    context: CoroutineContext = DefaultContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    f: suspend () -> T
+): Deferred<T> {
+    TODO()
+}
+
+fun <T> runBlocking(
+    context: CoroutineContext = DefaultContext,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun <T> withContext(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun test(ctx: CoroutineContext) {
+    withContext(ctx) { 42 }
+}

idea/testData/inspectionsLocal/coroutines/redundantAsync/simplest.kt

@@ -0,0 +1,48 @@
+// WITH_RUNTIME
+
+package kotlinx.coroutines.experimental
+
+interface Deferred<T> {
+    suspend fun await(): T
+}
+
+interface CoroutineContext
+
+object DefaultContext : CoroutineContext
+
+enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED
+}
+
+interface Job
+
+fun <T> async(
+    context: CoroutineContext = DefaultContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    f: suspend () -> T
+): Deferred<T> {
+    TODO()
+}
+
+fun <T> runBlocking(
+    context: CoroutineContext = DefaultContext,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun <T> withContext(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun test() {
+    <caret>async { 42 }.await()
+}

idea/testData/inspectionsLocal/coroutines/redundantAsync/simplest.kt.after

@@ -0,0 +1,48 @@
+// WITH_RUNTIME
+
+package kotlinx.coroutines.experimental
+
+interface Deferred<T> {
+    suspend fun await(): T
+}
+
+interface CoroutineContext
+
+object DefaultContext : CoroutineContext
+
+enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED
+}
+
+interface Job
+
+fun <T> async(
+    context: CoroutineContext = DefaultContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    f: suspend () -> T
+): Deferred<T> {
+    TODO()
+}
+
+fun <T> runBlocking(
+    context: CoroutineContext = DefaultContext,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun <T> withContext(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun test() {
+    runBlocking { 42 }
+}

idea/testData/inspectionsLocal/coroutines/redundantAsync/withParent.kt

@@ -0,0 +1,49 @@
+// PROBLEM: none
+// WITH_RUNTIME
+
+package kotlinx.coroutines.experimental
+
+interface Deferred<T> {
+    suspend fun await(): T
+}
+
+interface CoroutineContext
+
+object DefaultContext : CoroutineContext
+
+enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED
+}
+
+interface Job
+
+fun <T> async(
+    context: CoroutineContext = DefaultContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    f: suspend () -> T
+): Deferred<T> {
+    TODO()
+}
+
+fun <T> runBlocking(
+    context: CoroutineContext = DefaultContext,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun <T> withContext(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun test(ctx: CoroutineContext) {
+    <caret>async(parent = null) { 42 }.await()
+}

idea/testData/inspectionsLocal/coroutines/redundantAsync/withStartAndContext.kt

@@ -0,0 +1,48 @@
+// WITH_RUNTIME
+
+package kotlinx.coroutines.experimental
+
+interface Deferred<T> {
+    suspend fun await(): T
+}
+
+interface CoroutineContext
+
+object DefaultContext : CoroutineContext
+
+enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED
+}
+
+interface Job
+
+fun <T> async(
+    context: CoroutineContext = DefaultContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    f: suspend () -> T
+): Deferred<T> {
+    TODO()
+}
+
+fun <T> runBlocking(
+    context: CoroutineContext = DefaultContext,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun <T> withContext(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun test(ctx: CoroutineContext) {
+    <caret>async(ctx, CoroutineStart.LAZY) { 42 }.await()
+}

idea/testData/inspectionsLocal/coroutines/redundantAsync/withStartAndContext.kt.after

@@ -0,0 +1,48 @@
+// WITH_RUNTIME
+
+package kotlinx.coroutines.experimental
+
+interface Deferred<T> {
+    suspend fun await(): T
+}
+
+interface CoroutineContext
+
+object DefaultContext : CoroutineContext
+
+enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED
+}
+
+interface Job
+
+fun <T> async(
+    context: CoroutineContext = DefaultContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    f: suspend () -> T
+): Deferred<T> {
+    TODO()
+}
+
+fun <T> runBlocking(
+    context: CoroutineContext = DefaultContext,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun <T> withContext(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun test(ctx: CoroutineContext) {
+    withContext(ctx, CoroutineStart.LAZY) { 42 }
+}

idea/testData/inspectionsLocal/coroutines/redundantAsync/withStartNoContext.kt

@@ -0,0 +1,49 @@
+// PROBLEM: none
+// WITH_RUNTIME
+
+package kotlinx.coroutines.experimental
+
+interface Deferred<T> {
+    suspend fun await(): T
+}
+
+interface CoroutineContext
+
+object DefaultContext : CoroutineContext
+
+enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED
+}
+
+interface Job
+
+fun <T> async(
+    context: CoroutineContext = DefaultContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    f: suspend () -> T
+): Deferred<T> {
+    TODO()
+}
+
+fun <T> runBlocking(
+    context: CoroutineContext = DefaultContext,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun <T> withContext(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    f: suspend () -> T
+) {
+    TODO()
+}
+
+suspend fun test(ctx: CoroutineContext) {
+    <caret>async(start = CoroutineStart.LAZY) { 42 }.await()
+}