title: `runBlocking` coroutine builder is not resolved in the project (Other builders are resolved)
body: <p>As the title suggest, the coroutine builder <code>runBlocking</code> is missing in the coroutine liblary I just added in my build.gradle. Funny thing is every other thing appears to be available, <code>GlobalScope</code>, <code>CoroutineScope.launch</code> <code>CoroutineScope.async</code> all present. <code>runBlocking</code> isn't. What am I doing wrong?</p>
  
  <p>here is my <code>build.gradle</code></p>
  
  <pre><code>buildscript {
      ext {
          ktor_version = "1.1.1"
          kotlin_version = "1.3.20-eap-52"
      }
      dependencies {
          classpath "org.jetbrains.kotlin:kotlin-frontend-plugin:0.0.44"
          classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
      }
  }
  
  plugins {
      id 'kotlin-multiplatform' version '1.3.20-eap-100'
  }
  
  repositories {
      maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' }
      maven { url 'https://dl.bintray.com/kotlin/kotlin-js-wrappers' }
      maven { url 'https://dl.bintray.com/kotlinx/kotlinx' }
      maven { url "https://kotlin.bintray.com/kotlinx" }
      jcenter()
      mavenCentral()
  }
  
  group 'books'
  version '0.0.0'
  
  apply plugin: 'maven-publish'
  apply plugin: "org.jetbrains.kotlin.frontend"
  
  kotlin {
      jvm() {
          compilations.all {
              tasks[compileKotlinTaskName].kotlinOptions {
                  jvmTarget = "1.8"
              }
          }
      }
      js() {
          compilations.all {
              tasks[compileKotlinTaskName].kotlinOptions {
                  def optDir = compileKotlinTaskName.contains("Test") ? "test/${project.name}.test.js" : "main/${project.name}.js"
                  kotlinOptions.metaInfo = true
                  kotlinOptions.outputFile = "$project.buildDir.path/js/$optDir"
                  kotlinOptions.sourceMap = true
                  kotlinOptions.moduleKind = 'commonjs'
                  kotlinOptions.main = "call"
              }
          }
      }
      sourceSets {
          commonMain {
              dependencies {
                  implementation kotlin('stdlib-common')
                  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$ktor_version"
              }
          }
          commonTest {
              dependsOn commonMain
              dependencies {
                  implementation kotlin('test-common')
                  implementation kotlin('test-annotations-common')
              }
          }
          jvmMain {
              dependencies {
                  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$ktor_version"
                  implementation kotlin('stdlib-jdk8')
              }
          }
          jvmTest {
              dependsOn jvmMain
              dependencies {
                  implementation kotlin('test')
                  implementation kotlin('test-junit')
              }
          }
          jsMain {
              dependencies {
                  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$ktor_version"
                  implementation kotlin('stdlib-js')
              }
          }
          jsTest {
              dependsOn jsMain
              dependencies {
                  implementation kotlin('test-js')
              }
          }
      }
  }
  
  task runJest(type: Exec) {
      group = "verification"
      commandLine "sh", "runJest.sh"
  }
  
  runJest.dependsOn(jsTest)
  
  task testAll() {
      group = "verification"
      dependsOn(jvmTest, runJest)
  }
  
  kotlinFrontend {
      npm {
          devDependency("karma")
      }
  
      sourceMaps = true
  
      webpackBundle {
          bundleName = "main"
          host = "0.0.0.0"
          contentPath = file("$buildDir.path/resources/main")
      }
  }
  </code></pre>
  
  <p>With that gradle configuration, I have been able to write tests well (Learning TDD) with kotlin-multiplatform. And here is my sample below</p>
  
  <pre><code>import kotlin.test.*
  import com.luge.books.*
  import kotlinx.coroutines.*
  
  class BookTest {
      @BeforeTest
      fun setup() {
          val book = Book()
      }
  
      @Test
      fun testingInstantiation() {
          val book = Book()
          assertEquals(book.year, 1990, "Books do match the year")
      }
  
      @Test
      fun willFail() {
          assertFalse(false)
      }
  
      @Test
      fun testingCoroutines() {
          val job = GlobalScope.launch {
              delay(5000)
              println("Doing stuff")
              assertTrue(false)
          }
      }
  }
  </code></pre>
  
  <p>If you look closely, the test <code>testingCoroutines</code> passes, but since I am launching from the <code>GlobalScope</code>, it just fires and forgets and the test returns without throwing any error. If I incoporate <code>runBlocking</code>, the IDE highlights it with red color (you know, as something it doesn't understant), end even the kotlin compiler shouts, <code>unresolved reference runBlockin</code>. Help please....</p>