Configuration: Do not auto-advance "Latest Stable" to pre-release version

#KT-25611 Fixed

.bunch

@@ -5,3 +5,4 @@ as31_173
 as32
 182
 as33_as32
+as33c4_182

build-common/src/org/jetbrains/kotlin/incremental/CacheVersion.kt

@@ -35,9 +35,8 @@ class CacheVersion(
         private val whenVersionChanged: CacheVersion.Action,
         private val whenTurnedOn: CacheVersion.Action,
         private val whenTurnedOff: CacheVersion.Action,
-        isEnabled: ()->Boolean
+        private val isEnabled: Boolean
 ) {
-    private val isEnabled by lazy(isEnabled)
 
     private val actualVersion: Int?
         get() = try {
@@ -95,18 +94,18 @@ class CacheVersion(
     }
 }
 
-fun normalCacheVersion(dataRoot: File, enabled: Boolean? = null): CacheVersion =
+fun normalCacheVersion(dataRoot: File, enabled: Boolean): CacheVersion =
         CacheVersion(ownVersion = NORMAL_VERSION,
                      versionFile = File(dataRoot, NORMAL_VERSION_FILE_NAME),
                      whenVersionChanged = CacheVersion.Action.REBUILD_CHUNK,
                      whenTurnedOn = CacheVersion.Action.REBUILD_CHUNK,
                      whenTurnedOff = CacheVersion.Action.CLEAN_NORMAL_CACHES,
-                     isEnabled = { enabled ?: IncrementalCompilation.isEnabled() })
+                     isEnabled = enabled)
 
-fun dataContainerCacheVersion(dataRoot: File, enabled: Boolean? = null): CacheVersion =
+fun dataContainerCacheVersion(dataRoot: File, enabled: Boolean): CacheVersion =
         CacheVersion(ownVersion = DATA_CONTAINER_VERSION,
                      versionFile = File(dataRoot, DATA_CONTAINER_VERSION_FILE_NAME),
                      whenVersionChanged = CacheVersion.Action.REBUILD_ALL_KOTLIN,
                      whenTurnedOn = CacheVersion.Action.REBUILD_ALL_KOTLIN,
                      whenTurnedOff = CacheVersion.Action.CLEAN_DATA_CONTAINER,
-                     isEnabled = { enabled ?: IncrementalCompilation.isEnabled() })
+                     isEnabled = enabled)

build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt

@@ -23,6 +23,7 @@ import com.intellij.util.io.EnumeratorStringDescriptor
 import gnu.trove.THashSet
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.build.GeneratedJvmClass
+import org.jetbrains.kotlin.config.IncrementalCompilation
 import org.jetbrains.kotlin.incremental.storage.*
 import org.jetbrains.kotlin.inline.inlineFunctionsJvmNames
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
@@ -264,7 +265,7 @@ open class IncrementalJvmCache(
 
     override fun clean() {
         super.clean()
-        normalCacheVersion(targetDataRoot).clean()
+        normalCacheVersion(targetDataRoot, IncrementalCompilation.isEnabledForJvm()).clean()
     }
 
     private inner class ProtoMap(storageFile: File) : BasicStringMap<ProtoMapValue>(storageFile, ProtoMapValueExternalizer) {

build-common/src/org/jetbrains/kotlin/modules/KotlinModuleXmlBuilder.kt

@@ -78,7 +78,7 @@ class KotlinModuleXmlBuilder {
             directoriesToFilterOut: Set<File>) {
         p.println("<!-- Classpath -->")
         for (file in files) {
-            val isOutput = directoriesToFilterOut.contains(file) && !IncrementalCompilation.isEnabled()
+            val isOutput = directoriesToFilterOut.contains(file) && !IncrementalCompilation.isEnabledForJvm()
             if (isOutput) {
                 // For IDEA's make (incremental compilation) purposes, output directories of the current module and its dependencies
                 // appear on the class path, so we are at risk of seeing the results of the previous build, i.e. if some class was

build.gradle.kts

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
 import proguard.gradle.ProGuardTask
 
 buildscript {
-    extra["defaultSnapshotVersion"] = "1.2-SNAPSHOT"
+    extra["defaultSnapshotVersion"] = "1.3-SNAPSHOT"
 
-    kotlinBootstrapFrom(BootstrapOption.TeamCity("1.2.70-dev-491", onlySuccessBootstrap = false))
+    kotlinBootstrapFrom(BootstrapOption.TeamCity("1.3-M1-eap-77", projectExtId = "Kotlin_13M1_Compiler", onlySuccessBootstrap = false))
 
     val mirrorRepo: String? = findProperty("maven.repository.mirror")?.toString()
 
@@ -81,7 +81,7 @@ val defaultSnapshotVersion: String by extra
 val buildNumber by extra(findProperty("build.number")?.toString() ?: defaultSnapshotVersion)
 val kotlinVersion by extra(findProperty("deployVersion")?.toString() ?: buildNumber)
 
-val kotlinLanguageVersion by extra("1.2")
+val kotlinLanguageVersion by extra("1.3")
 
 allprojects {
     group = "org.jetbrains.kotlin"
@@ -307,7 +307,7 @@ allprojects {
 
     configureJvmProject(javaHome!!, jvmTarget!!)
 
-    val commonCompilerArgs = listOfNotNull("-Xallow-kotlin-package", "-Xread-deserialized-contracts", "-Xprogressive".takeIf { hasProperty("test.progressive.mode") })
+    val commonCompilerArgs = listOfNotNull("-Xallow-kotlin-package", "-Xread-deserialized-contracts", "-Xprogressive".takeIf { hasProperty("test.progressive.mode") }, "-XXLanguage:-ReleaseCoroutines")
 
     tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
         kotlinOptions {

buildSrc/gradle.properties.as33c4

@@ -0,0 +1,9 @@
+org.gradle.daemon=true
+org.gradle.parallel=false
+org.gradle.configureondemand=false
+org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx1600m
+
+#buildSrc.kotlin.repo=https://jcenter.bintray.com
+#buildSrc.kotlin.version=1.1.50
+
+intellijUltimateEnabled=false

buildSrc/prepare-deps/intellij-sdk/build.gradle.kts.as33c4

@@ -0,0 +1,298 @@
+
+@file:Suppress("PropertyName")
+
+import org.gradle.api.publish.ivy.internal.artifact.DefaultIvyArtifact
+import org.gradle.api.publish.ivy.internal.publication.DefaultIvyConfiguration
+import org.gradle.api.publish.ivy.internal.publication.DefaultIvyPublicationIdentity
+import org.gradle.api.publish.ivy.internal.publisher.IvyDescriptorFileGenerator
+import java.io.File
+import org.gradle.internal.os.OperatingSystem
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath("com.github.jengelman.gradle.plugins:shadow:${property("versions.shadow")}")
+    }
+}
+
+val intellijUltimateEnabled: Boolean by rootProject.extra
+val intellijRepo: String by rootProject.extra
+val intellijReleaseType: String by rootProject.extra
+val intellijVersion = rootProject.extra["versions.intellijSdk"] as String
+val androidStudioRelease = rootProject.findProperty("versions.androidStudioRelease") as String?
+val androidStudioBuild = rootProject.findProperty("versions.androidStudioBuild") as String?
+val intellijSeparateSdks: Boolean by rootProject.extra
+val installIntellijCommunity = !intellijUltimateEnabled || intellijSeparateSdks
+val installIntellijUltimate = intellijUltimateEnabled
+
+val intellijVersionDelimiterIndex = intellijVersion.indexOfAny(charArrayOf('.', '-'))
+if (intellijVersionDelimiterIndex == -1) {
+    error("Invalid IDEA version $intellijVersion")
+}
+
+val platformBaseVersion = intellijVersion.substring(0, intellijVersionDelimiterIndex)
+
+logger.info("intellijUltimateEnabled: $intellijUltimateEnabled")
+
+logger.info("intellijVersion: $intellijVersion")
+logger.info("androidStudioRelease: $androidStudioRelease")
+logger.info("androidStudioBuild: $androidStudioBuild")
+
+logger.info("intellijSeparateSdks: $intellijSeparateSdks")
+logger.info("installIntellijCommunity: $installIntellijCommunity")
+logger.info("installIntellijUltimate: $installIntellijUltimate")
+
+val studioOs by lazy {
+    when {
+        OperatingSystem.current().isWindows -> "windows"
+        OperatingSystem.current().isMacOsX -> "mac"
+        OperatingSystem.current().isLinux -> "linux"
+        else -> {
+            logger.error("Unknown operating system for android tools: ${OperatingSystem.current().name}")
+            ""
+        }
+    }
+}
+
+repositories {
+    if (androidStudioRelease != null) {
+        ivy {
+            artifactPattern("https://dl.google.com/dl/android/studio/ide-zips/$androidStudioRelease/[artifact]-[revision]-$studioOs.zip")
+            metadataSources {
+                artifact()
+            }
+        }
+        ivy {
+            artifactPattern("https://dl.bintray.com/kotlin/as/[artifact]-[revision].zip")
+            credentials {
+                username = System.getenv("AS_BINTRAY_USER_NAME")
+                password = System.getenv("AS_BINTRAY_API_KEY")
+            }
+            metadataSources {
+                artifact()
+            }
+        }
+    }
+    maven { setUrl("$intellijRepo/$intellijReleaseType") }
+    maven { setUrl("https://plugins.jetbrains.com/maven") }
+//    github returns broken pipe =(
+//    ivy {
+//        artifactPattern("https://raw.github.com/JetBrains/intellij-community/[revision]/lib/src/[artifact].zip")
+//        metadataSources {
+//            artifact()
+//        }
+//    }
+}
+
+val intellij by configurations.creating
+val intellijUltimate by configurations.creating
+val sources by configurations.creating
+val `asm-shaded-sources` by configurations.creating
+val `jps-standalone` by configurations.creating
+val `jps-build-test` by configurations.creating
+val `intellij-core` by configurations.creating
+val `plugins-NodeJS` by configurations.creating
+
+val customDepsRepoDir = File(buildDir, "repo")
+val customDepsOrg: String by rootProject.extra
+val customDepsRevision = intellijVersion
+val customDepsRepoModulesDir = File(customDepsRepoDir, "$customDepsOrg/$customDepsRevision")
+val repoDir = customDepsRepoModulesDir
+
+dependencies {
+    if (androidStudioRelease != null) {
+        intellij("google:android-studio-ide:$androidStudioBuild")
+    } else {
+        if (installIntellijCommunity) {
+            intellij("com.jetbrains.intellij.idea:ideaIC:$intellijVersion")
+        }
+        if (installIntellijUltimate) {
+            intellijUltimate("com.jetbrains.intellij.idea:ideaIU:$intellijVersion")
+        }
+    }
+    sources("com.jetbrains.intellij.idea:ideaIC:$intellijVersion:sources@jar")
+//    if (platformBaseVersion == "182") {
+//        // There is no asm sources for 182 yet
+//        `asm-shaded-sources`("asmsources:asm-src:181@zip")
+//    } else {
+//        `asm-shaded-sources`("asmsources:asm-src:$platformBaseVersion@zip")
+//    }
+    `jps-standalone`("com.jetbrains.intellij.idea:jps-standalone:$intellijVersion")
+    `jps-build-test`("com.jetbrains.intellij.idea:jps-build-test:$intellijVersion")
+    `intellij-core`("com.jetbrains.intellij.idea:intellij-core:$intellijVersion")
+    if (intellijUltimateEnabled) {
+        `plugins-NodeJS`("com.jetbrains.plugins:NodeJS:${rootProject.extra["versions.idea.NodeJS"]}@zip")
+    }
+}
+
+fun Task.configureExtractFromConfigurationTask(sourceConfig: Configuration,
+                                               pathRemap: (String) -> String = { it },
+                                               extractor: (Configuration) -> Any) {
+    dependsOn(sourceConfig)
+    inputs.files(sourceConfig)
+    val targetDir = File(repoDir, sourceConfig.name)
+    outputs.dirs(targetDir)
+    doFirst {
+        project.copy {
+            from(extractor(sourceConfig))
+            into(targetDir)
+            eachFile {
+                path = pathRemap(path)
+            }
+        }
+    }
+}
+
+fun removePathPrefix(path: String): String {
+    if (androidStudioRelease == null) return path
+    val slashes = 2 // if (studioOs == "mac") 2 else 1
+    var result = path
+    repeat(slashes) {
+        result = result.substringAfter('/')
+    }
+    return result
+}
+
+val unzipIntellijSdk by tasks.creating {
+    configureExtractFromConfigurationTask(intellij, pathRemap = { removePathPrefix(it) }) {
+        zipTree(it.singleFile).matching {
+            exclude("**/plugins/Kotlin/**")
+        }
+    }
+}
+
+val unzipIntellijUltimateSdk by tasks.creating {
+    configureExtractFromConfigurationTask(intellijUltimate) {
+        zipTree(it.singleFile).matching {
+            exclude("plugins/Kotlin/**")
+        }
+    }
+}
+
+val unzipIntellijCore by tasks.creating { configureExtractFromConfigurationTask(`intellij-core`) { zipTree(it.singleFile) } }
+
+val unzipJpsStandalone by tasks.creating { configureExtractFromConfigurationTask(`jps-standalone`) { zipTree(it.singleFile) } }
+
+//val copyAsmShadedSources by tasks.creating(Copy::class.java) {
+//    from(`asm-shaded-sources`)
+//    rename(".zip", ".jar")
+//    destinationDir = File(repoDir, `asm-shaded-sources`.name)
+//}
+
+val copyIntellijSdkSources by tasks.creating(ShadowJar::class.java) {
+//    from(copyAsmShadedSources)
+    from(sources)
+    baseName = "ideaIC"
+    version = intellijVersion
+    classifier = "sources"
+    destinationDir = File(repoDir, sources.name)
+}
+
+val copyJpsBuildTest by tasks.creating { configureExtractFromConfigurationTask(`jps-build-test`) { it.singleFile } }
+
+val unzipNodeJSPlugin by tasks.creating { configureExtractFromConfigurationTask(`plugins-NodeJS`) { zipTree(it.singleFile) } }
+
+fun writeIvyXml(moduleName: String, fileName: String, jarFiles: FileCollection, baseDir: File, sourcesJar: File?) {
+    with(IvyDescriptorFileGenerator(DefaultIvyPublicationIdentity(customDepsOrg, moduleName, intellijVersion))) {
+        addConfiguration(DefaultIvyConfiguration("default"))
+        addConfiguration(DefaultIvyConfiguration("sources"))
+        jarFiles.asFileTree.files.forEach {
+            if (it.isFile && it.extension == "jar") {
+                val relativeName = it.toRelativeString(baseDir).removeSuffix(".jar")
+                addArtifact(DefaultIvyArtifact(it, relativeName, "jar", "jar", null).also { it.conf = "default" })
+            }
+        }
+        if (sourcesJar != null) {
+            val sourcesArtifactName = sourcesJar.name.removeSuffix(".jar").substringBefore("-")
+            addArtifact(DefaultIvyArtifact(sourcesJar, sourcesArtifactName, "jar", "sources", "sources").also { it.conf = "sources" })
+        }
+        writeTo(File(customDepsRepoModulesDir, "$fileName.ivy.xml"))
+    }
+}
+
+val prepareIvyXmls by tasks.creating {
+    dependsOn(unzipIntellijCore, unzipJpsStandalone, copyIntellijSdkSources, copyJpsBuildTest/*, copyAsmShadedSources */)
+
+    val intellijSdkDir = File(repoDir, intellij.name)
+    val intellijUltimateSdkDir = File(repoDir, intellijUltimate.name)
+
+    if (installIntellijCommunity) {
+        dependsOn(unzipIntellijSdk)
+        inputs.dir(intellijSdkDir)
+        outputs.file(File(repoDir, "${intellij.name}.ivy.xml"))
+    }
+
+    if (installIntellijUltimate) {
+        dependsOn(unzipIntellijUltimateSdk)
+        inputs.dir(intellijUltimateSdkDir)
+        outputs.file(File(repoDir, "${intellijUltimate.name}.ivy.xml"))
+    }
+
+    val flatDeps = listOf(`intellij-core`, `jps-standalone`, `jps-build-test`, `asm-shaded-sources`)
+    flatDeps.forEach {
+        inputs.dir(File(repoDir, it.name))
+        outputs.file(File(repoDir, "${it.name}.ivy.xml"))
+    }
+    inputs.dir(File(repoDir, sources.name))
+
+    if (intellijUltimateEnabled) {
+        dependsOn(unzipNodeJSPlugin)
+        inputs.dir(File(repoDir, `plugins-NodeJS`.name))
+        outputs.file(File(repoDir, "${`plugins-NodeJS`.name}.ivy.xml"))
+    }
+
+    doFirst {
+        val sourcesFile = if (sources.isEmpty) null else File(repoDir, "${sources.name}/${sources.singleFile.name}")
+
+        if (installIntellijCommunity) {
+            val libDir = File(intellijSdkDir, "lib")
+            writeIvyXml(intellij.name,
+                        intellij.name,
+                        fileTree(libDir).filter {
+                            it.parentFile == libDir && !it.name.startsWith("kotlin-")
+                        },
+                        libDir,
+                        sourcesFile)
+
+            File(intellijSdkDir, "plugins").listFiles { it: File -> it.isDirectory }.forEach {
+                writeIvyXml(it.name, "intellij.plugin.${it.name}", files("$it/lib/"), File(it, "lib"), sourcesFile)
+            }
+        }
+
+        if (installIntellijUltimate) {
+            val libDir = File(intellijUltimateSdkDir, "lib")
+            writeIvyXml(intellij.name, // important! the module name should be "intellij"
+                        intellijUltimate.name,
+                        fileTree(libDir).filter {
+                            it.parentFile == libDir && !it.name.startsWith("kotlin-")
+                        },
+                        libDir,
+                        sourcesFile)
+
+            File(intellijUltimateSdkDir, "plugins").listFiles { it: File -> it.isDirectory }.forEach {
+                writeIvyXml(it.name, "intellijUltimate.plugin.${it.name}", files("$it/lib/"), File(it, "lib"), sourcesFile)
+            }
+        }
+
+        flatDeps.forEach {
+            writeIvyXml(it.name, it.name, files("$repoDir/${it.name}"), File(repoDir, it.name), sourcesFile)
+        }
+
+        if (intellijUltimateEnabled) {
+            val nodeJsBaseDir = "${`plugins-NodeJS`.name}/NodeJS/lib"
+            writeIvyXml("NodeJS", `plugins-NodeJS`.name, files("$repoDir/$nodeJsBaseDir"), File(repoDir, nodeJsBaseDir), sourcesFile)
+        }
+    }
+}
+
+val build by tasks.creating {
+    dependsOn(prepareIvyXmls)
+}
+
+val clean by tasks.creating(Delete::class) {
+    delete(customDepsRepoModulesDir)
+    delete(buildDir)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt

@@ -383,7 +383,7 @@ class MultifileClassCodegenImpl(
         private fun getCompiledPackageFragment(
                 facadeFqName: FqName, state: GenerationState
         ): IncrementalPackageFragmentProvider.IncrementalMultifileClassPackageFragment? {
-            if (!IncrementalCompilation.isEnabled()) return null
+            if (!IncrementalCompilation.isEnabledForJvm()) return null
 
             val packageFqName = facadeFqName.parent()
 

compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java

@@ -646,17 +646,21 @@ public class KotlinTypeMapper {
         List<TypeParameterDescriptor> parameters = classDescriptor.getDeclaredTypeParameters();
         List<TypeProjection> arguments = type.getArguments();
 
-        if (classDescriptor instanceof FunctionClassDescriptor &&
-            ((FunctionClassDescriptor) classDescriptor).getFunctionKind() == FunctionClassDescriptor.Kind.KFunction) {
-            // kotlin.reflect.KFunction{n}<P1, ... Pn, R> is mapped to kotlin.reflect.KFunction<R> on JVM (see JavaToKotlinClassMap).
-            // So for these classes, we need to skip all type arguments except the very last one
-            writeGenericArguments(
-                    signatureVisitor,
-                    Collections.singletonList(CollectionsKt.last(arguments)),
-                    Collections.singletonList(CollectionsKt.last(parameters)),
-                    mode
-            );
-            return;
+        if (classDescriptor instanceof FunctionClassDescriptor) {
+            FunctionClassDescriptor functionClass = (FunctionClassDescriptor) classDescriptor;
+            if (functionClass.hasBigArity() ||
+                functionClass.getFunctionKind() == FunctionClassDescriptor.Kind.KFunction) {
+                // kotlin.reflect.KFunction{n}<P1, ..., Pn, R> is mapped to kotlin.reflect.KFunction<R> (for all n), and
+                // kotlin.Function{n}<P1, ..., Pn, R> is mapped to kotlin.jvm.functions.FunctionN<R> (for n > 22).
+                // So for these classes, we need to skip all type arguments except the very last one
+                writeGenericArguments(
+                        signatureVisitor,
+                        Collections.singletonList(CollectionsKt.last(arguments)),
+                        Collections.singletonList(CollectionsKt.last(parameters)),
+                        mode
+                );
+                return;
+            }
         }
 
         writeGenericArguments(signatureVisitor, arguments, parameters, mode);

compiler/cli/build.gradle.kts

@@ -42,6 +42,14 @@ sourceSets {
     "test" { }
 }
 
+tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
+    kotlinOptions {
+        languageVersion = "1.2"
+        apiVersion = "1.2"
+        freeCompilerArgs += "-Xskip-metadata-version-check"
+    }
+}
+
 testsJar {}
 
 projectTest {

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt

@@ -33,6 +33,7 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
         const val WARN = "warn"
         const val ERROR = "error"
         const val ENABLE = "enable"
+        const val DEFAULT = "default"
     }
 
     @get:Transient
@@ -108,7 +109,7 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
         valueDescription = "{enable|warn|error}",
         description = "Enable coroutines or report warnings or errors on declarations and use sites of 'suspend' modifier"
     )
-    var coroutinesState: String? by FreezableVar(WARN)
+    var coroutinesState: String? by FreezableVar(DEFAULT)
 
     @Argument(
         value = "-Xnew-inference",
@@ -200,7 +201,7 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
             when (coroutinesState) {
                 CommonCompilerArguments.ERROR -> put(LanguageFeature.Coroutines, LanguageFeature.State.ENABLED_WITH_ERROR)
                 CommonCompilerArguments.ENABLE -> put(LanguageFeature.Coroutines, LanguageFeature.State.ENABLED)
-                CommonCompilerArguments.WARN -> {
+                CommonCompilerArguments.WARN, CommonCompilerArguments.DEFAULT -> {
                 }
                 else -> {
                     val message = "Invalid value of -Xcoroutines (should be: enable, warn or error): " + coroutinesState
@@ -293,12 +294,23 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
             )
         }
 
-        return LanguageVersionSettingsImpl(
+        val languageVersionSettings = LanguageVersionSettingsImpl(
             languageVersion,
             ApiVersion.createByLanguageVersion(apiVersion),
             configureAnalysisFlags(collector),
             configureLanguageFeatures(collector)
         )
+
+        if (languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)) {
+            if (coroutinesState != DEFAULT) {
+                collector.report(
+                    CompilerMessageSeverity.STRONG_WARNING,
+                    "-Xcoroutines has no effect: coroutines are enabled anyway in 1.3 and beyond"
+                )
+            }
+        }
+
+        return languageVersionSettings
     }
 
     private fun parseVersion(collector: MessageCollector, value: String?, versionOf: String): LanguageVersion? =

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -307,7 +307,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
     override fun setupPlatformSpecificArgumentsAndServices(
         configuration: CompilerConfiguration, arguments: K2JVMCompilerArguments, services: Services
     ) {
-        if (IncrementalCompilation.isEnabled()) {
+        if (IncrementalCompilation.isEnabledForJvm()) {
             services.get(LookupTracker::class.java)?.let {
                 configuration.put(CommonConfigurationKeys.LOOKUP_TRACKER, it)
             }

compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.metadata.K2MetadataCompiler
+import org.jetbrains.kotlin.config.IncrementalCompilation
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.daemon.report.CompileServicesFacadeMessageCollector
@@ -469,7 +470,7 @@ class CompileServiceImpl(
         }
 
         val workingDir = incrementalCompilationOptions.workingDir
-        val versions = commonCacheVersions(workingDir) +
+        val versions = commonCacheVersions(workingDir, enabled = true) +
                        customCacheVersion(incrementalCompilationOptions.customCacheVersion,
                                           incrementalCompilationOptions.customCacheVersionFileName,
                                           workingDir,
@@ -519,7 +520,7 @@ class CompileServiceImpl(
         }
 
         val workingDir = incrementalCompilationOptions.workingDir
-        val versions = commonCacheVersions(workingDir) +
+        val versions = commonCacheVersions(workingDir, enabled = true) +
                        customCacheVersion(incrementalCompilationOptions.customCacheVersion,
                                           incrementalCompilationOptions.customCacheVersionFileName,
                                           workingDir,

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -417,6 +417,12 @@ interface LanguageSettingsProvider {
         isReleaseCoroutines: Boolean? = null
     ): LanguageVersionSettings
 
+    @Deprecated("Use `getLanguageVersionSettings` method with default parameter instead")
+    fun getLanguageVersionSettings(
+        moduleInfo: ModuleInfo,
+        project: Project
+    ) = getLanguageVersionSettings(moduleInfo, project, null)
+
     fun getTargetPlatform(moduleInfo: ModuleInfo): TargetPlatformVersion
 
     object Default : LanguageSettingsProvider {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.resolve.calls;
@@ -197,7 +186,8 @@ public class ArgumentTypeResolver {
     public KotlinTypeInfo getArgumentTypeInfo(
             @Nullable KtExpression expression,
             @NotNull CallResolutionContext<?> context,
-            @NotNull ResolveArgumentsMode resolveArgumentsMode
+            @NotNull ResolveArgumentsMode resolveArgumentsMode,
+            boolean suspendFunctionTypeExpected
     ) {
         if (expression == null) {
             return TypeInfoFactoryKt.noTypeInfo(context);
@@ -205,7 +195,7 @@ public class ArgumentTypeResolver {
 
         KtFunction functionLiteralArgument = getFunctionLiteralArgumentIfAny(expression, context);
         if (functionLiteralArgument != null) {
-            return getFunctionLiteralTypeInfo(expression, functionLiteralArgument, context, resolveArgumentsMode);
+            return getFunctionLiteralTypeInfo(expression, functionLiteralArgument, context, resolveArgumentsMode, suspendFunctionTypeExpected);
         }
 
         KtCallableReferenceExpression callableReferenceExpression = getCallableReferenceExpressionIfAny(expression, context);
@@ -291,10 +281,11 @@ public class ArgumentTypeResolver {
             @NotNull KtExpression expression,
             @NotNull KtFunction functionLiteral,
             @NotNull CallResolutionContext<?> context,
-            @NotNull ResolveArgumentsMode resolveArgumentsMode
+            @NotNull ResolveArgumentsMode resolveArgumentsMode,
+            boolean suspendFunctionTypeExpected
     ) {
         if (resolveArgumentsMode == SHAPE_FUNCTION_ARGUMENTS) {
-            KotlinType type = getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, true);
+            KotlinType type = getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, true, suspendFunctionTypeExpected);
             return TypeInfoFactoryKt.createTypeInfo(type, context);
         }
         return expressionTypingServices.getTypeInfo(expression, context.replaceContextDependency(INDEPENDENT));
@@ -305,7 +296,8 @@ public class ArgumentTypeResolver {
             @NotNull KtFunction function,
             @NotNull LexicalScope scope,
             @NotNull BindingTrace trace,
-            boolean expectedTypeIsUnknown
+            boolean expectedTypeIsUnknown,
+            boolean suspendFunctionTypeExpected
     ) {
         boolean isFunctionLiteral = function instanceof KtFunctionLiteral;
         if (function.getValueParameterList() == null && isFunctionLiteral) {
@@ -335,7 +327,7 @@ public class ArgumentTypeResolver {
         return expectedTypeIsUnknown && isFunctionLiteral
                ? functionPlaceholders.createFunctionPlaceholderType(parameterTypes, /* hasDeclaredArguments = */ true)
                : FunctionTypesKt.createFunctionType(
-                       builtIns, Annotations.Companion.getEMPTY(), receiverType, parameterTypes, parameterNames, returnType
+                       builtIns, Annotations.Companion.getEMPTY(), receiverType, parameterTypes, parameterNames, returnType, suspendFunctionTypeExpected
                );
     }
 
@@ -371,7 +363,7 @@ public class ArgumentTypeResolver {
 
             CallResolutionContext<?> newContext = context.replaceDataFlowInfo(infoForArguments.getInfo(argument));
             // Here we go inside arguments and determine additional data flow information for them
-            KotlinTypeInfo typeInfoForCall = getArgumentTypeInfo(expression, newContext, resolveArgumentsMode);
+            KotlinTypeInfo typeInfoForCall = getArgumentTypeInfo(expression, newContext, resolveArgumentsMode, false);
             infoForArguments.updateInfo(argument, typeInfoForCall.getDataFlowInfo());
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.resolve.calls
@@ -325,7 +314,7 @@ class CallCompleter(
         // While the expected type is not known, the function literal arguments are not analyzed (to analyze function literal bodies once),
         // but they should be analyzed when the expected type is known (during the call completion).
         ArgumentTypeResolver.getFunctionLiteralArgumentIfAny(expression, context)?.let { functionLiteralArgument ->
-            argumentTypeResolver.getFunctionLiteralTypeInfo(expression, functionLiteralArgument, context, RESOLVE_FUNCTION_ARGUMENTS)
+            argumentTypeResolver.getFunctionLiteralTypeInfo(expression, functionLiteralArgument, context, RESOLVE_FUNCTION_ARGUMENTS, false)
         }
 
         // While the expected type is not known, (possibly overloaded) callable references can have placeholder types

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt

@@ -1,23 +1,13 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.resolve.calls
 
 import com.google.common.collect.Lists
 import org.jetbrains.kotlin.builtins.ReflectionTypes
+import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
@@ -362,7 +352,7 @@ class CandidateResolver(
                 val expectedType = getEffectiveExpectedType(parameterDescriptor, argument, context)
 
                 val newContext = context.replaceDataFlowInfo(infoForArguments.getInfo(argument)).replaceExpectedType(expectedType)
-                val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(expression, newContext, resolveFunctionArgumentBodies)
+                val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(expression, newContext, resolveFunctionArgumentBodies, expectedType.isSuspendFunctionType)
                 val type = typeInfoForCall.type
                 infoForArguments.updateInfo(argument, typeInfoForCall.dataFlowInfo)
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt

@@ -1,25 +1,11 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.resolve.calls
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.builtins.ReflectionTypes
-import org.jetbrains.kotlin.builtins.isBuiltinFunctionalTypeOrSubtype
-import org.jetbrains.kotlin.builtins.isFunctionTypeOrSubtype
+import org.jetbrains.kotlin.builtins.*
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
@@ -261,7 +247,12 @@ class GenericCandidateResolver(
         val dataFlowInfoForArgument = context.candidateCall.dataFlowInfoForArguments.getInfo(valueArgument)
         val newContext = context.replaceExpectedType(expectedType).replaceDataFlowInfo(dataFlowInfoForArgument)
 
-        val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(argumentExpression, newContext, resolveFunctionArgumentBodies)
+        val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(
+            argumentExpression,
+            newContext,
+            resolveFunctionArgumentBodies,
+            expectedType?.isSuspendFunctionType == true
+        )
         context.candidateCall.dataFlowInfoForArguments.updateInfo(valueArgument, typeInfoForCall.dataFlowInfo)
 
         val constraintPosition = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.index)
@@ -435,7 +426,13 @@ class GenericCandidateResolver(
         var expectedType = newSubstitution.buildSubstitutor().substitute(effectiveExpectedType, Variance.IN_VARIANCE)
 
         if (expectedType == null || TypeUtils.isDontCarePlaceholder(expectedType)) {
-            expectedType = argumentTypeResolver.getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, false)
+            expectedType = argumentTypeResolver.getShapeTypeOfFunctionLiteral(
+                functionLiteral,
+                context.scope,
+                context.trace,
+                false,
+                expectedType?.isSuspendFunctionType == true
+            )
         }
         if (expectedType == null || !expectedType.isBuiltinFunctionalTypeOrSubtype || hasUnknownFunctionParameter(expectedType)) {
             return
@@ -463,7 +460,8 @@ class GenericCandidateResolver(
                 .replaceDataFlowInfo(dataFlowInfoForArgument).replaceResolutionResultsCache(temporaryToResolveFunctionLiteral.cache)
                 .replaceContextDependency(INDEPENDENT)
             val type = argumentTypeResolver.getFunctionLiteralTypeInfo(
-                argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS
+                argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS,
+                expectedType.isSuspendFunctionType
             ).type
             if (!mismatch[0]) {
                 constraintSystem.addSubtypeConstraint(type, effectiveExpectedTypeInSystem, position)
@@ -476,8 +474,10 @@ class GenericCandidateResolver(
         val newContext = context.replaceExpectedType(expectedTypeWithEstimatedReturnType).replaceDataFlowInfo(dataFlowInfoForArgument)
             .replaceContextDependency(INDEPENDENT)
         val type =
-            argumentTypeResolver.getFunctionLiteralTypeInfo(argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS)
-                .type
+            argumentTypeResolver.getFunctionLiteralTypeInfo(
+                argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS,
+                expectedType.isSuspendFunctionType
+            ).type
         constraintSystem.addSubtypeConstraint(type, effectiveExpectedTypeInSystem, position)
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/CoroutineInferenceUtil.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.resolve.calls.inference
@@ -178,7 +167,7 @@ class CoroutineInferenceSupport(
         val newContext = context.replaceExpectedType(newExpectedType)
             .replaceDataFlowInfo(context.candidateCall.dataFlowInfoForArguments.getInfo(valueArgument))
             .replaceContextDependency(ContextDependency.INDEPENDENT).replaceTraceAndCache(temporaryForCoroutine)
-        argumentTypeResolver.getFunctionLiteralTypeInfo(argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS)
+        argumentTypeResolver.getFunctionLiteralTypeInfo(argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS, true)
 
         inferenceData.reportInferenceResult(csBuilder)
     }
@@ -260,7 +249,7 @@ class CoroutineInferenceSupport(
         context: CallResolutionContext<*>
     ): KotlinTypeInfo {
         getFunctionLiteralArgumentIfAny(expression, context)?.let {
-            return argumentTypeResolver.getFunctionLiteralTypeInfo(expression, it, context, RESOLVE_FUNCTION_ARGUMENTS)
+            return argumentTypeResolver.getFunctionLiteralTypeInfo(expression, it, context, RESOLVE_FUNCTION_ARGUMENTS, false)
         }
 
         getCallableReferenceExpressionIfAny(expression, context)?.let {

compiler/frontend/src/org/jetbrains/kotlin/resolve/deprecationUtil.kt

@@ -103,6 +103,13 @@ private data class DeprecatedByOverridden(private val deprecations: Collection<D
         "Overrides deprecated member in '${DescriptorUtils.getContainingClass(target)!!.fqNameSafe.asString()}'"
 }
 
+private data class DeprecatedExperimentalCoroutine(
+    override val target: DeclarationDescriptor
+) : Deprecation {
+    override val deprecationLevel: DeprecationLevelValue = DeprecationLevelValue.ERROR
+    override val message: String? = "Experimental coroutine cannot be used with API version 1.3"
+}
+
 private data class DeprecatedByVersionRequirement(
     val versionRequirement: VersionRequirement,
     override val target: DeclarationDescriptor
@@ -304,6 +311,7 @@ class DeprecationResolver(
             }
 
             getDeprecationByVersionRequirement(target)?.let(result::add)
+            getDeprecationByCoroutinesVersion(target)?.let(result::add)
         }
 
         fun addUseSiteTargetedDeprecationIfPresent(annotatedDescriptor: DeclarationDescriptor, useSiteTarget: AnnotationUseSiteTarget?) {
@@ -343,6 +351,11 @@ class DeprecationResolver(
         return result.distinct()
     }
 
+    private fun getDeprecationByCoroutinesVersion(target: DeclarationDescriptor): DeprecatedExperimentalCoroutine? =
+        if (target is DeserializedMemberDescriptor && target.isExperimentalCoroutineInReleaseEnvironment)
+            DeprecatedExperimentalCoroutine(target)
+        else null
+
     private fun getDeprecationByVersionRequirement(target: DeclarationDescriptor): DeprecatedByVersionRequirement? {
         fun createVersion(version: String): MavenComparableVersion? = try {
             MavenComparableVersion(version)

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
  * that can be found in the license/LICENSE.txt file.
  */
 
@@ -118,11 +118,11 @@ internal class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Expre
             val expectedType = context.expectedType
 
             val functionalTypeExpected = expectedType.isBuiltinFunctionalType()
-            val suspendFunctionTypeExpected = expectedType.isSuspendFunctionType()
 
-            val resultType = functionDescriptor.createFunctionType(suspendFunctionTypeExpected)
+            // We forbid anonymous function expressions to suspend type coercion for now, until `suspend fun` syntax is supported
+            val resultType = functionDescriptor.createFunctionType(suspendFunction = false)
 
-            if (components.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) && functionalTypeExpected)
+            if (components.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) && functionalTypeExpected && !expectedType.isSuspendFunctionType)
                 createTypeInfo(resultType, context)
             else
                 components.dataFlowAnalyzer.createCheckedTypeInfo(resultType, context, function)

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.kt

@@ -154,7 +154,7 @@ class PatternMatchingTypingVisitor internal constructor(facade: ExpressionTyping
         }
 
 
-        object None : Subject(null, null, null) {
+        class None : Subject(null, null, null) {
             override fun createDataFlowValue(contextAfterSubject: ExpressionTypingContext, builtIns: KotlinBuiltIns) =
                 DataFlowValue.nullValue(builtIns)
 
@@ -195,7 +195,7 @@ class PatternMatchingTypingVisitor internal constructor(facade: ExpressionTyping
                 )
 
             else ->
-                Subject.None
+                Subject.None()
         }
 
         val contextAfterSubject = run {

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt

@@ -37,7 +37,8 @@ fun makeJsIncrementally(
         messageCollector: MessageCollector = MessageCollector.NONE,
         reporter: ICReporter = EmptyICReporter
 ) {
-    val versions = commonCacheVersions(cachesDir) + standaloneCacheVersion(cachesDir)
+    val isIncremental = IncrementalCompilation.isEnabledForJs()
+    val versions = commonCacheVersions(cachesDir, isIncremental) + standaloneCacheVersion(cachesDir, isIncremental)
     val allKotlinFiles = sourceRoots.asSequence().flatMap { it.walk() }
             .filter { it.isFile && it.extension.equals("kt", ignoreCase = true) }.toList()
 
@@ -47,14 +48,13 @@ fun makeJsIncrementally(
     }
 }
 
-inline fun <R> withJsIC(fn: ()->R): R {
+inline fun <R> withJsIC(fn: () -> R): R {
     val isJsEnabledBackup = IncrementalCompilation.isEnabledForJs()
     IncrementalCompilation.setIsEnabledForJs(true)
 
     try {
-        return withIC { fn() }
-    }
-    finally {
+        return fn()
+    } finally {
         IncrementalCompilation.setIsEnabledForJs(isJsEnabledBackup)
     }
 }
@@ -70,7 +70,7 @@ class IncrementalJsCompilerRunner(
         reporter
 ) {
     override fun isICEnabled(): Boolean =
-        IncrementalCompilation.isEnabled() && IncrementalCompilation.isEnabledForJs()
+        IncrementalCompilation.isEnabledForJs()
 
     override fun createCacheManager(args: K2JSCompilerArguments): IncrementalJsCachesManager =
         IncrementalJsCachesManager(cacheDirectory, reporter)

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt

@@ -56,7 +56,8 @@ fun makeIncrementally(
         messageCollector: MessageCollector = MessageCollector.NONE,
         reporter: ICReporter = EmptyICReporter
 ) {
-    val versions = commonCacheVersions(cachesDir) + standaloneCacheVersion(cachesDir)
+    val isIncremental = IncrementalCompilation.isEnabledForJvm()
+    val versions = commonCacheVersions(cachesDir, isIncremental) + standaloneCacheVersion(cachesDir, isIncremental)
 
     val kotlinExtensions = listOf("kt", "kts")
     val allExtensions = kotlinExtensions + listOf("java")
@@ -86,7 +87,7 @@ object EmptyICReporter : ICReporter {
 }
 
 inline fun <R> withIC(enabled: Boolean = true, fn: ()->R): R {
-    val isEnabledBackup = IncrementalCompilation.isEnabled()
+    val isEnabledBackup = IncrementalCompilation.isEnabledForJvm()
     IncrementalCompilation.setIsEnabled(enabled)
 
     try {
@@ -114,7 +115,7 @@ class IncrementalJvmCompilerRunner(
         localStateDirs = localStateDirs
 ) {
     override fun isICEnabled(): Boolean =
-            IncrementalCompilation.isEnabled()
+            IncrementalCompilation.isEnabledForJvm()
 
     override fun createCacheManager(args: K2JVMCompilerArguments): IncrementalJvmCachesManager =
             IncrementalJvmCachesManager(cacheDirectory, File(args.destination), reporter)

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/cacheVersions.kt

@@ -21,8 +21,8 @@ import java.io.File
 internal const val STANDALONE_CACHE_VERSION = 2
 internal const val STANDALONE_VERSION_FILE_NAME = "standalone-ic-format-version.txt"
 
-fun standaloneCacheVersion(dataRoot: File): CacheVersion =
-        customCacheVersion(STANDALONE_CACHE_VERSION, STANDALONE_VERSION_FILE_NAME, dataRoot, enabled = true)
+fun standaloneCacheVersion(dataRoot: File, enabled: Boolean): CacheVersion =
+        customCacheVersion(STANDALONE_CACHE_VERSION, STANDALONE_VERSION_FILE_NAME, dataRoot, enabled)
 
 fun customCacheVersion(version: Int, fileName: String, dataRoot: File, enabled: Boolean): CacheVersion =
         CacheVersion(ownVersion = version,
@@ -30,8 +30,7 @@ fun customCacheVersion(version: Int, fileName: String, dataRoot: File, enabled:
                 whenVersionChanged = CacheVersion.Action.REBUILD_ALL_KOTLIN,
                 whenTurnedOn = CacheVersion.Action.REBUILD_ALL_KOTLIN,
                 whenTurnedOff = CacheVersion.Action.REBUILD_ALL_KOTLIN,
-                isEnabled = { enabled })
+                isEnabled = enabled)
 
-fun commonCacheVersions(cachesDir: File): List<CacheVersion> =
-        listOf(normalCacheVersion(cachesDir),
-               dataContainerCacheVersion(cachesDir))
+fun commonCacheVersions(cachesDir: File, enabled: Boolean): List<CacheVersion> =
+    listOf(normalCacheVersion(cachesDir, enabled), dataContainerCacheVersion(cachesDir, enabled))

compiler/psi/src/org/jetbrains/kotlin/psi/KtImportsFactory.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.psi;
+
+import com.intellij.openapi.project.Project;
+import kotlin.collections.CollectionsKt;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.resolve.ImportPath;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @deprecated This class is not used in the kotlin plugin/compiler and will be removed soon
+ */
+@Deprecated
+public class KtImportsFactory {
+    @NotNull private final Project project;
+
+    private final Map<ImportPath, KtImportDirective> importsCache = new HashMap<>();
+
+    public KtImportsFactory(@NotNull Project project) {
+        this.project = project;
+    }
+
+    @NotNull
+    private KtImportDirective createImportDirective(@NotNull ImportPath importPath) {
+        KtImportDirective directive = importsCache.get(importPath);
+        if (directive != null) {
+            return directive;
+        }
+
+        KtImportDirective createdDirective = KtPsiFactoryKt.KtPsiFactory(project, false).createImportDirective(importPath);
+        importsCache.put(importPath, createdDirective);
+
+        return createdDirective;
+    }
+
+    @NotNull
+    public Collection<KtImportDirective> createImportDirectives(@NotNull Collection<ImportPath> importPaths) {
+        return CollectionsKt.map(importPaths, this::createImportDirective);
+    }
+
+    @NotNull
+    public Collection<KtImportDirective> createImportDirectivesNotCached(@NotNull Collection<ImportPath> importPaths) {
+        return KtPsiFactoryKt.KtPsiFactory(project, false).createImportDirectives(importPaths);
+    }
+}

compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt

@@ -437,6 +437,19 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m
         }
     }
 
+    @Deprecated("function is not used in the kotlin plugin/compiler and will be removed soon")
+    fun createImportDirectives(paths: Collection<ImportPath>): List<KtImportDirective> {
+        val fileContent = buildString {
+            for (path in paths) {
+                appendImport(path)
+                append('\n')
+            }
+        }
+
+        val file = createFile(fileContent)
+        return file.importDirectives
+    }
+
     fun createPrimaryConstructor(text: String = ""): KtPrimaryConstructor {
         return createClass(if (text.isNotEmpty()) "class A $text" else "class A()").primaryConstructor!!
     }

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/KotlinStubVersions.kt

@@ -28,7 +28,7 @@ object KotlinStubVersions {
     // Binary stub version should be increased if stub format (org.jetbrains.kotlin.psi.stubs.impl) is changed
     //      or changes are made to the core stub building code (org.jetbrains.kotlin.idea.decompiler.stubBuilder).
     // Increasing this version will lead to reindexing of all binary files that are potentially kotlin binaries (including all class files).
-    private const val BINARY_STUB_VERSION = 66
+    private const val BINARY_STUB_VERSION = 67
 
     // Classfile stub version should be increased if changes are made to classfile stub building subsystem (org.jetbrains.kotlin.idea.decompiler.classFile)
     // Increasing this version will lead to reindexing of all classfiles.

compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.serialization
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.isSuspendFunctionType
+import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
 import org.jetbrains.kotlin.builtins.transformSuspendFunctionToRuntimeFunctionType
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.*
@@ -355,8 +356,9 @@ class DescriptorSerializer private constructor(
         return listOfNotNull(
                 extensionReceiverParameter?.type,
                 returnType,
+                *typeParameters.flatMap { it.upperBounds }.toTypedArray(),
                 *valueParameters.map(ValueParameterDescriptor::getType).toTypedArray()
-        ).any { type -> type.contains(UnwrappedType::isSuspendFunctionType) }
+        ).any { type -> type.contains(UnwrappedType::isSuspendFunctionTypeOrSubtype) }
     }
 
     fun typeAliasProto(descriptor: TypeAliasDescriptor): ProtoBuf.TypeAlias.Builder {

compiler/testData/asJava/lightClasses/compilationErrors/SameName.java

@@ -1,8 +1,8 @@
 public final class A {
-    private final int i = 0;
-    private final java.lang.String i$1 = "";
-    private final java.lang.String j = "a";
-    private final java.lang.String j$1 = "b";
+    private final int i;
+    private final java.lang.String i$1;
+    private final java.lang.String j;
+    private final java.lang.String j$1;
 
     public final void f(int i, double s) { /* compiled code */ }
 

compiler/testData/asJava/lightClasses/compilationErrors/SameName.kt

@@ -7,9 +7,9 @@ class A {
     fun g(i: Int, s: Double): Int {}
     fun g(s: Int, i: Double): String {}
 
-    private val i: Int = 0
-    private val i: String = ""
+    private val i: Int = { 0 }()
+    private val i: String = { "" }()
 
-    private val j: String = "a"
-    private val j: String = "b"
+    private val j: String = { "a" }()
+    private val j: String = { "b" }()
 }

compiler/testData/asJava/lightClasses/compilationErrors/TopLevelDestructuring.java

@@ -1,5 +1,5 @@
 public final class TopLevelDestructuringKt {
-    private static final int z = 3;
+    private static final int z;
 
     public static final int getZ() { /* compiled code */ }
 }

compiler/testData/asJava/lightClasses/compilationErrors/TopLevelDestructuring.kt

@@ -4,4 +4,4 @@ data class Pair(val x: Int, val y: Int)
 
 val (x, y) = Pair(1, 2)
 
-val z = 3
+val z = { 3 }()

compiler/testData/asJava/lightClasses/compilationErrors/TraitClassObjectField.java

@@ -6,7 +6,7 @@ public interface TraitClassObjectField {
     static final class Companion {
         @org.jetbrains.annotations.Nullable
         public static final java.lang.String x = "";
-        private static final java.lang.String y = "";
+        private static final java.lang.String y;
 
         private Companion() { /* compiled code */ }
     }

compiler/testData/asJava/lightClasses/compilationErrors/TraitClassObjectField.kt

@@ -3,6 +3,6 @@
 interface TraitClassObjectField {
     companion object {
         const val x: String? = ""
-        private val y: String? = ""
+        private val y: String? = { "" }()
     }
 }

compiler/testData/asJava/lightClasses/nullabilityAnnotations/Class.java

@@ -1,14 +1,14 @@
 public final class Class {
     @org.jetbrains.annotations.Nullable
-    private final java.lang.String nullableVal = "";
+    private final java.lang.String nullableVal;
     @org.jetbrains.annotations.Nullable
     private java.lang.String nullableVar;
     @org.jetbrains.annotations.NotNull
-    private final java.lang.String notNullVal = "";
+    private final java.lang.String notNullVal;
     @org.jetbrains.annotations.NotNull
     private java.lang.String notNullVar;
-    private final java.lang.String privateNN = "";
-    private final java.lang.String privateN = "";
+    private final java.lang.String privateNN;
+    private final java.lang.String privateN;
 
     @org.jetbrains.annotations.NotNull
     public final java.lang.String notNull(@org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ }

compiler/testData/asJava/lightClasses/nullabilityAnnotations/Class.kt

@@ -13,10 +13,10 @@ class Class {
     @Nullable fun nullableWithN(): String? = ""
     @NotNull fun nullableWithNN(): String? = ""
 
-    val nullableVal: String? = ""
-    var nullableVar: String? = ""
-    val notNullVal: String = ""
-    var notNullVar: String = ""
+    val nullableVal: String? = { "" }()
+    var nullableVar: String? = { "" }()
+    val notNullVal: String = { "" }()
+    var notNullVar: String = { "" }()
 
     val notNullValWithGet: String
         @[Nullable] get() = ""
@@ -32,6 +32,6 @@ class Class {
         @[NotNull] get() = ""
         @[NotNull] set(v) {}
 
-    private val privateNN: String = ""
-    private val privateN: String? = ""
+    private val privateNN: String = { "" }()
+    private val privateN: String? = { "" }()
 }

compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassObjectField.java

@@ -1,7 +1,7 @@
 public final class ClassObjectField {
     @org.jetbrains.annotations.Nullable
-    private static final java.lang.String x = "";
-    private static final java.lang.String y = "";
+    private static final java.lang.String x;
+    private static final java.lang.String y;
     public static final ClassObjectField.Companion Companion;
 
     public ClassObjectField() { /* compiled code */ }

compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassObjectField.kt

@@ -2,7 +2,7 @@
 
 class ClassObjectField {
     companion object {
-        val x: String? = ""
-        private val y: String? = ""
+        val x: String? = { "" }()
+        private val y: String? = { "" }()
     }
 }

compiler/testData/asJava/lightClasses/nullabilityAnnotations/FileFacade.java

@@ -1,14 +1,14 @@
 public final class FileFacadeKt {
     @org.jetbrains.annotations.Nullable
-    private static final java.lang.String nullableVal = "";
+    private static final java.lang.String nullableVal;
     @org.jetbrains.annotations.Nullable
     private static java.lang.String nullableVar;
     @org.jetbrains.annotations.NotNull
-    private static final java.lang.String notNullVal = "";
+    private static final java.lang.String notNullVal;
     @org.jetbrains.annotations.NotNull
     private static java.lang.String notNullVar;
-    private static final java.lang.String privateNn = "";
-    private static final java.lang.String privateN = "";
+    private static final java.lang.String privateNn;
+    private static final java.lang.String privateN;
 
     @org.jetbrains.annotations.NotNull
     public static final java.lang.String notNull(@org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ }

compiler/testData/asJava/lightClasses/nullabilityAnnotations/FileFacade.kt

@@ -12,10 +12,10 @@ fun nullable(a: String?): String? = ""
 @Nullable fun nullableWithN(): String? = ""
 @NotNull fun nullableWithNN(): String? = ""
 
-val nullableVal: String? = ""
-var nullableVar: String? = ""
-val notNullVal: String = ""
-var notNullVar: String = ""
+val nullableVal: String? = { "" }()
+var nullableVar: String? = { "" }()
+val notNullVal: String = { "" }()
+var notNullVar: String = { "" }()
 
 val notNullValWithGet: String
     @[Nullable] get() = ""
@@ -31,6 +31,6 @@ var nullableVarWithGetSet: String?
     @NotNull get() = ""
     @NotNull set(v) {}
 
-private val privateNn: String = ""
-private val privateN: String? = ""
+private val privateNn: String = { "" }()
+private val privateN: String? = { "" }()
 private fun privateFun(a: String, b: String?): String? = null

compiler/testData/asJava/lightClasses/nullabilityAnnotations/IntOverridesAny.java

@@ -1,5 +1,5 @@
 public final class C implements Tr {
-    private final int v = 1;
+    private final int v;
 
     @org.jetbrains.annotations.NotNull
     public java.lang.Integer foo() { /* compiled code */ }

compiler/testData/asJava/lightClasses/nullabilityAnnotations/IntOverridesAny.kt

@@ -7,5 +7,5 @@ interface Tr {
 
 class C: Tr {
     override fun foo() = 1
-    override val v = 1
+    override val v = { 1 }()
 }

compiler/testData/asJava/lightClasses/object/SimpleObject.java

@@ -1,7 +1,10 @@
 public final class A {
-    private static final int c = 1;
+    private static final int c;
     @org.jetbrains.annotations.NotNull
     private static java.lang.String v;
+    public static final int cc = 1;
+    @org.jetbrains.annotations.NotNull
+    public static final java.lang.String cv = "A";
     public static final pack.A INSTANCE;
 
     public final int getC() { /* compiled code */ }

compiler/testData/asJava/lightClasses/object/SimpleObject.kt

@@ -3,7 +3,10 @@
 package pack
 
 object A {
-    val c = 1
-    var v = "A"
+    val c = { 1 }()
+    var v = { "A" }()
     fun f() = 3
+
+    const val cc = 1
+    const val cv = "A"
 }

compiler/testData/asJava/lightClasses/publicField/CompanionObject.java

@@ -1,7 +1,7 @@
 public final class C {
     @kotlin.jvm.JvmField
     @org.jetbrains.annotations.NotNull
-    public static final java.lang.String foo = "A";
+    public static final java.lang.String foo;
     public static final C.Companion Companion;
 
     public C() { /* compiled code */ }

compiler/testData/asJava/lightClasses/publicField/CompanionObject.kt

@@ -2,6 +2,6 @@
 
 class C {
     companion object {
-        @[kotlin.jvm.JvmField] public val foo: String = "A"
+        @[kotlin.jvm.JvmField] public val foo: String = { "A" }()
     }
 }

compiler/testData/asJava/lightClasses/publicField/Simple.java

@@ -1,7 +1,7 @@
 public final class C {
     @kotlin.jvm.JvmField
     @org.jetbrains.annotations.NotNull
-    public final java.lang.String foo = "A";
+    public final java.lang.String foo;
 
     public C() { /* compiled code */ }
 }

compiler/testData/asJava/lightClasses/publicField/Simple.kt

@@ -1,5 +1,5 @@
 // C
 
 class C {
-    @[kotlin.jvm.JvmField] public val foo: String = "A"
+    @[kotlin.jvm.JvmField] public val foo: String = { "A" }()
 }

compiler/testData/asJava/lightClasses/script/InnerClasses.java

@@ -2,7 +2,7 @@ public class InnerClasses extends kotlin.script.templates.standard.ScriptTemplat
     public InnerClasses(java.lang.String[] p) { /* compiled code */ }
 
     public static final class Bar {
-        private final int b = 0;
+        private final int b;
         private final int a;
 
         public final int getB() { /* compiled code */ }

compiler/testData/asJava/lightClasses/script/InnerClasses.kts

@@ -1,7 +1,7 @@
 // InnerClasses
 
 class Bar(val a: Int) {
-    val b: Int = 0
+    val b: Int = { 0 }()
 
     fun getAPlusB() = a + b
 

compiler/testData/builtin-classes/default/kotlin.txt

@@ -39,6 +39,10 @@ public final class Boolean : kotlin.Comparable<kotlin.Boolean> {
     public final operator fun not(): kotlin.Boolean
     public final infix fun or(/*0*/ other: kotlin.Boolean): kotlin.Boolean
     public final infix fun xor(/*0*/ other: kotlin.Boolean): kotlin.Boolean
+
+    @kotlin.SinceKotlin(version = "1.3") public companion object Companion {
+        /*primary*/ private constructor Companion()
+    }
 }
 
 public final class BooleanArray {
@@ -117,6 +121,10 @@ public final class Byte : kotlin.Number, kotlin.Comparable<kotlin.Byte> {
             public final fun <get-MAX_VALUE>(): kotlin.Byte
         public const final val MIN_VALUE: kotlin.Byte
             public final fun <get-MIN_VALUE>(): kotlin.Byte
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -155,12 +163,20 @@ public final class Char : kotlin.Comparable<kotlin.Char> {
             public final fun <get-MAX_LOW_SURROGATE>(): kotlin.Char
         public const final val MAX_SURROGATE: kotlin.Char
             public final fun <get-MAX_SURROGATE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val MAX_VALUE: kotlin.Char
+            public final fun <get-MAX_VALUE>(): kotlin.Char
         public const final val MIN_HIGH_SURROGATE: kotlin.Char
             public final fun <get-MIN_HIGH_SURROGATE>(): kotlin.Char
         public const final val MIN_LOW_SURROGATE: kotlin.Char
             public final fun <get-MIN_LOW_SURROGATE>(): kotlin.Char
         public const final val MIN_SURROGATE: kotlin.Char
             public final fun <get-MIN_SURROGATE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val MIN_VALUE: kotlin.Char
+            public final fun <get-MIN_VALUE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -475,6 +491,10 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int> {
             public final fun <get-MAX_VALUE>(): kotlin.Int
         public const final val MIN_VALUE: kotlin.Int
             public final fun <get-MIN_VALUE>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -561,6 +581,10 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long> {
             public final fun <get-MAX_VALUE>(): kotlin.Long
         public const final val MIN_VALUE: kotlin.Long
             public final fun <get-MIN_VALUE>(): kotlin.Long
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -673,6 +697,10 @@ public final class Short : kotlin.Number, kotlin.Comparable<kotlin.Short> {
             public final fun <get-MAX_VALUE>(): kotlin.Short
         public const final val MIN_VALUE: kotlin.Short
             public final fun <get-MIN_VALUE>(): kotlin.Short
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 

compiler/testData/builtin-classes/java6/kotlin.txt

@@ -40,6 +40,10 @@ public final class Boolean : kotlin.Comparable<kotlin.Boolean>, java.io.Serializ
     public final operator fun not(): kotlin.Boolean
     public final infix fun or(/*0*/ other: kotlin.Boolean): kotlin.Boolean
     public final infix fun xor(/*0*/ other: kotlin.Boolean): kotlin.Boolean
+
+    @kotlin.SinceKotlin(version = "1.3") public companion object Companion {
+        /*primary*/ private constructor Companion()
+    }
 }
 
 public final class BooleanArray : kotlin.Any, kotlin.Cloneable, java.io.Serializable {
@@ -119,6 +123,10 @@ public final class Byte : kotlin.Number, kotlin.Comparable<kotlin.Byte>, java.io
             public final fun <get-MAX_VALUE>(): kotlin.Byte
         public const final val MIN_VALUE: kotlin.Byte
             public final fun <get-MIN_VALUE>(): kotlin.Byte
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -158,12 +166,20 @@ public final class Char : kotlin.Comparable<kotlin.Char>, java.io.Serializable {
             public final fun <get-MAX_LOW_SURROGATE>(): kotlin.Char
         public const final val MAX_SURROGATE: kotlin.Char
             public final fun <get-MAX_SURROGATE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val MAX_VALUE: kotlin.Char
+            public final fun <get-MAX_VALUE>(): kotlin.Char
         public const final val MIN_HIGH_SURROGATE: kotlin.Char
             public final fun <get-MIN_HIGH_SURROGATE>(): kotlin.Char
         public const final val MIN_LOW_SURROGATE: kotlin.Char
             public final fun <get-MIN_LOW_SURROGATE>(): kotlin.Char
         public const final val MIN_SURROGATE: kotlin.Char
             public final fun <get-MIN_SURROGATE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val MIN_VALUE: kotlin.Char
+            public final fun <get-MIN_VALUE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -489,6 +505,10 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int>, java.io.S
             public final fun <get-MAX_VALUE>(): kotlin.Int
         public const final val MIN_VALUE: kotlin.Int
             public final fun <get-MIN_VALUE>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -576,6 +596,10 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long>, java.io
             public final fun <get-MAX_VALUE>(): kotlin.Long
         public const final val MIN_VALUE: kotlin.Long
             public final fun <get-MIN_VALUE>(): kotlin.Long
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -689,6 +713,10 @@ public final class Short : kotlin.Number, kotlin.Comparable<kotlin.Short>, java.
             public final fun <get-MAX_VALUE>(): kotlin.Short
         public const final val MIN_VALUE: kotlin.Short
             public final fun <get-MIN_VALUE>(): kotlin.Short
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 

compiler/testData/builtin-classes/java8/kotlin.txt

@@ -40,6 +40,10 @@ public final class Boolean : kotlin.Comparable<kotlin.Boolean>, java.io.Serializ
     public final operator fun not(): kotlin.Boolean
     public final infix fun or(/*0*/ other: kotlin.Boolean): kotlin.Boolean
     public final infix fun xor(/*0*/ other: kotlin.Boolean): kotlin.Boolean
+
+    @kotlin.SinceKotlin(version = "1.3") public companion object Companion {
+        /*primary*/ private constructor Companion()
+    }
 }
 
 public final class BooleanArray : kotlin.Any, kotlin.Cloneable, java.io.Serializable {
@@ -119,6 +123,10 @@ public final class Byte : kotlin.Number, kotlin.Comparable<kotlin.Byte>, java.io
             public final fun <get-MAX_VALUE>(): kotlin.Byte
         public const final val MIN_VALUE: kotlin.Byte
             public final fun <get-MIN_VALUE>(): kotlin.Byte
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -158,12 +166,20 @@ public final class Char : kotlin.Comparable<kotlin.Char>, java.io.Serializable {
             public final fun <get-MAX_LOW_SURROGATE>(): kotlin.Char
         public const final val MAX_SURROGATE: kotlin.Char
             public final fun <get-MAX_SURROGATE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val MAX_VALUE: kotlin.Char
+            public final fun <get-MAX_VALUE>(): kotlin.Char
         public const final val MIN_HIGH_SURROGATE: kotlin.Char
             public final fun <get-MIN_HIGH_SURROGATE>(): kotlin.Char
         public const final val MIN_LOW_SURROGATE: kotlin.Char
             public final fun <get-MIN_LOW_SURROGATE>(): kotlin.Char
         public const final val MIN_SURROGATE: kotlin.Char
             public final fun <get-MIN_SURROGATE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val MIN_VALUE: kotlin.Char
+            public final fun <get-MIN_VALUE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -491,6 +507,10 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int>, java.io.S
             public final fun <get-MAX_VALUE>(): kotlin.Int
         public const final val MIN_VALUE: kotlin.Int
             public final fun <get-MIN_VALUE>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -578,6 +598,10 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long>, java.io
             public final fun <get-MAX_VALUE>(): kotlin.Long
         public const final val MIN_VALUE: kotlin.Long
             public final fun <get-MIN_VALUE>(): kotlin.Long
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -691,6 +715,10 @@ public final class Short : kotlin.Number, kotlin.Comparable<kotlin.Short>, java.
             public final fun <get-MAX_VALUE>(): kotlin.Short
         public const final val MIN_VALUE: kotlin.Short
             public final fun <get-MIN_VALUE>(): kotlin.Short
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 

compiler/testData/builtin-classes/newMethods/kotlin.txt

@@ -40,6 +40,10 @@ public final class Boolean : kotlin.Comparable<kotlin.Boolean>, java.io.Serializ
     public final operator fun not(): kotlin.Boolean
     public final infix fun or(/*0*/ other: kotlin.Boolean): kotlin.Boolean
     public final infix fun xor(/*0*/ other: kotlin.Boolean): kotlin.Boolean
+
+    @kotlin.SinceKotlin(version = "1.3") public companion object Companion {
+        /*primary*/ private constructor Companion()
+    }
 }
 
 public final class BooleanArray : kotlin.Any, kotlin.Cloneable, java.io.Serializable {
@@ -119,6 +123,10 @@ public final class Byte : kotlin.Number, kotlin.Comparable<kotlin.Byte>, java.io
             public final fun <get-MAX_VALUE>(): kotlin.Byte
         public const final val MIN_VALUE: kotlin.Byte
             public final fun <get-MIN_VALUE>(): kotlin.Byte
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -158,12 +166,20 @@ public final class Char : kotlin.Comparable<kotlin.Char>, java.io.Serializable {
             public final fun <get-MAX_LOW_SURROGATE>(): kotlin.Char
         public const final val MAX_SURROGATE: kotlin.Char
             public final fun <get-MAX_SURROGATE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val MAX_VALUE: kotlin.Char
+            public final fun <get-MAX_VALUE>(): kotlin.Char
         public const final val MIN_HIGH_SURROGATE: kotlin.Char
             public final fun <get-MIN_HIGH_SURROGATE>(): kotlin.Char
         public const final val MIN_LOW_SURROGATE: kotlin.Char
             public final fun <get-MIN_LOW_SURROGATE>(): kotlin.Char
         public const final val MIN_SURROGATE: kotlin.Char
             public final fun <get-MIN_SURROGATE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val MIN_VALUE: kotlin.Char
+            public final fun <get-MIN_VALUE>(): kotlin.Char
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -489,6 +505,10 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int>, java.io.S
             public final fun <get-MAX_VALUE>(): kotlin.Int
         public const final val MIN_VALUE: kotlin.Int
             public final fun <get-MIN_VALUE>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -576,6 +596,10 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long>, java.io
             public final fun <get-MAX_VALUE>(): kotlin.Long
         public const final val MIN_VALUE: kotlin.Long
             public final fun <get-MIN_VALUE>(): kotlin.Long
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 
@@ -689,6 +713,10 @@ public final class Short : kotlin.Number, kotlin.Comparable<kotlin.Short>, java.
             public final fun <get-MAX_VALUE>(): kotlin.Short
         public const final val MIN_VALUE: kotlin.Short
             public final fun <get-MIN_VALUE>(): kotlin.Short
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BITS: kotlin.Int
+            public final fun <get-SIZE_BITS>(): kotlin.Int
+        @kotlin.SinceKotlin(version = "1.3") public const final val SIZE_BYTES: kotlin.Int
+            public final fun <get-SIZE_BYTES>(): kotlin.Int
     }
 }
 

compiler/testData/cli/jvm/apiVersionInvalid.out

@@ -1,3 +1,3 @@
 error: unknown API version: 239.42
-Supported API versions: 1.0, 1.1, 1.2, 1.3 (EXPERIMENTAL)
+Supported API versions: 1.0, 1.1, 1.2, 1.3
 COMPILATION_ERROR

compiler/testData/cli/jvm/coroutinesEnable.out

@@ -1 +1,2 @@
+warning: -Xcoroutines has no effect: coroutines are enabled anyway in 1.3 and beyond
 OK

compiler/testData/cli/jvm/coroutinesError.out

@@ -1,4 +1,2 @@
-compiler/testData/cli/jvm/coroutines.kt:1:1: error: the feature "coroutines" is experimental and disabled (see: https://kotlinlang.org/docs/diagnostics/experimental-coroutines)
-suspend fun simple() = 5
-^
-COMPILATION_ERROR
+warning: -Xcoroutines has no effect: coroutines are enabled anyway in 1.3 and beyond
+OK

compiler/testData/cli/jvm/coroutinesErrorAndEnable.out

@@ -1,2 +1,3 @@
 warning: argument -Xcoroutines is passed multiple times. Only the last value will be used: enable
-OK
+warning: -Xcoroutines has no effect: coroutines are enabled anyway in 1.3 and beyond
+OK

compiler/testData/cli/jvm/coroutinesWarn.out

@@ -1,4 +1,2 @@
-compiler/testData/cli/jvm/coroutines.kt:1:1: warning: the feature "coroutines" is experimental (see: https://kotlinlang.org/docs/diagnostics/experimental-coroutines)
-suspend fun simple() = 5
-^
-OK
+warning: -Xcoroutines has no effect: coroutines are enabled anyway in 1.3 and beyond
+OK

compiler/testData/cli/jvm/languageVersionInvalid.out

@@ -1,3 +1,3 @@
 error: unknown language version: 239.42
-Supported language versions: 1.0, 1.1, 1.2, 1.3 (EXPERIMENTAL)
+Supported language versions: 1.0, 1.1, 1.2, 1.3
 COMPILATION_ERROR

compiler/testData/cli/jvm/releaseCoroutinesApiVersion1.2.out

@@ -1,4 +1,3 @@
-warning: language version 1.3 is experimental, there are no backwards compatibility guarantees for new language and library features
 compiler/testData/cli/jvm/releaseCoroutinesApiVersion1.2.kt:1:1: error: unsupported [cannot use release coroutines with api version less than 1.3]
 suspend fun dummy() {}
 ^

compiler/testData/codegen/box/binaryOp/overflowChar.kt

@@ -1,10 +1,11 @@
 fun box(): String {
-    val c1: Char = 0.toChar()
+    val c1: Char = Char.MIN_VALUE
     val c2 = c1 - 1
-    if (c2 < c1) return "fail: 0.toChar() - 1 should overflow to positive."
+    if (c2 < c1) return "fail: Char.MIN_VALUE - 1 should overflow to positive."
 
-    val c3 = c2 + 1
-    if (c3 > c2) return "fail: FFFF.toChar() + 1 should overflow to zero."
+    val c3: Char = Char.MAX_VALUE
+    val c4 = c3 + 1
+    if (c4 > c3) return "fail: Char.MAX_VALUE + 1 should overflow to zero."
 
     return "OK"
 }

compiler/testData/codegen/box/callableReference/function/getArityViaFunctionImpl.kt

@@ -10,7 +10,7 @@ import kotlin.test.assertEquals
 import kotlin.jvm.internal.FunctionBase
 
 fun test(f: Function<*>, arity: Int) {
-    assertEquals(arity, (f as FunctionBase).getArity())
+    assertEquals(arity, (f as FunctionBase).arity)
 }
 
 fun foo(s: String, i: Int) {}

compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/getArityViaFunctionImpl.kt

@@ -16,7 +16,7 @@ suspend fun builder(c: suspend () -> Unit) {
 }
 
 fun test(f: Function<*>, arity: Int) {
-    assertEquals(arity, (f as FunctionBase).getArity())
+    assertEquals(arity, (f as FunctionBase).arity)
 }
 
 suspend fun foo(s: String, i: Int) {}

compiler/testData/codegen/box/functions/bigArity/callFromJava.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: +FunctionTypesWithBigArity
+// WITH_RUNTIME
+// TARGET_BACKEND: JVM
+// FILE: J.java
+
+import kotlin.jvm.functions.FunctionN;
+
+public class J {
+    public static String test() {
+        return KKt.call(new FunctionN<String>() {
+            @Override
+            public String invoke(Object... args) {
+                if (args.length != getArity()) throw new IllegalArgumentException("Incorrect arity: " + args.length);
+
+                return ((A) args[5]).getMessage() +
+                        ((A) args[28]).getMessage();
+            }
+
+            @Override
+            public int getArity() {
+                return 30;
+            }
+        });
+    }
+}
+
+// FILE: K.kt
+
+class A(val message: String)
+
+fun call(f: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A) -> String): String {
+    val a = A("XXX")
+    return f(a, a, a, a, a, A("O"), a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, A("K"), a)
+}
+
+fun box(): String = J.test()

compiler/testData/codegen/box/functions/bigArity/callWithIncorrectNumberOfArguments.kt

@@ -1,7 +1,6 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
 // WITH_RUNTIME
 // TARGET_BACKEND: JVM
-// IGNORE_BACKEND: JVM, JVM_IR
 // FILE: J.java
 
 // import kotlin.jvm.functions.Arity;

compiler/testData/codegen/box/functions/bigArity/function255.kt

@@ -1,6 +1,5 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
 // IGNORE_BACKEND: JS_IR
-// IGNORE_BACKEND: JVM, JVM_IR
 
 class A(val value: Int) {
     // for (i in 1..254) { print("p${"%03d".format(i)}: A, "); if (i % 10 == 0) println() }; println()

compiler/testData/codegen/box/functions/bigArity/instanceOfCallableReference.kt

@@ -1,6 +1,5 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
 // IGNORE_BACKEND: JS_IR, JS
-// IGNORE_BACKEND: JVM, JVM_IR
 
 class A
 

compiler/testData/codegen/box/functions/bigArity/invokeCallableReference.kt

@@ -1,5 +1,4 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
-// IGNORE_BACKEND: JVM, JVM_IR
 
 class A
 

compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt

@@ -1,5 +1,4 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
-// IGNORE_BACKEND: JVM, JVM_IR
 
 class A(val value: Int)
 

compiler/testData/codegen/box/functions/bigArity/javaLambda.kt

@@ -1,7 +1,6 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
 // WITH_RUNTIME
 // TARGET_BACKEND: JVM
-// IGNORE_BACKEND: JVM, JVM_IR
 // FILE: J.java
 
 // import kotlin.jvm.functions.Arity;

compiler/testData/codegen/box/functions/bigArity/subclass.kt

@@ -2,7 +2,6 @@
 
 // Implementing function interface is prohibited in JavaScript
 // IGNORE_BACKEND: JS_IR, JS
-// IGNORE_BACKEND: JVM, JVM_IR
 
 class A(val value: String)
 

compiler/testData/codegen/box/javaInterop/notNullAssertions/functionWithBigArity.kt

@@ -1,6 +1,5 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
 // TARGET_BACKEND: JVM
-// IGNORE_BACKEND: JVM, JVM_IR
 // WITH_RUNTIME
 // FILE: Test.java
 

compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToCharMinValue.kt

@@ -1,7 +1,7 @@
 // IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
-const val M = 0.toChar()
+const val M = Char.MIN_VALUE
 
 fun box(): String {
     var count = 0

compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToCharMinValueReversed.kt

@@ -1,7 +1,7 @@
 // IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
-const val M = 0.toChar()
+const val M = Char.MIN_VALUE
 
 fun box(): String {
     var count = 0

compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToCharMaxValue.kt

@@ -1,5 +1,5 @@
 // IGNORE_BACKEND: JS_IR
-const val M = 0xFFFF.toChar()
+const val M = Char.MAX_VALUE
 
 fun box(): String {
     var count = 0

compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToCharMaxValueReversed.kt

@@ -1,7 +1,7 @@
 // IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
-const val M = 0xFFFF.toChar()
+const val M = Char.MAX_VALUE
 
 fun box(): String {
     var count = 0

compiler/testData/codegen/box/reflection/call/bigArity.kt

@@ -1,6 +1,5 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
 // IGNORE_BACKEND: JS_IR, JS, NATIVE
-// IGNORE_BACKEND: JVM, JVM_IR
 // WITH_REFLECT
 
 class A {

compiler/testData/codegen/box/reflection/classes/nestedClasses.kt

@@ -48,15 +48,14 @@ fun box(): String {
     assertEquals(listOf("Entry"), nestedNames(MutableMap::class))
 
     // Primitives
-    for (primitive in listOf(Byte::class, Double::class, Float::class, Int::class, Long::class, Short::class, Char::class)) {
+    for (primitive in listOf(Byte::class, Double::class, Float::class, Int::class, Long::class, Short::class, Char::class, Boolean::class)) {
         assertEquals(listOf("Companion"), nestedNames(primitive))
     }
-    assertEquals(emptyList<String>(), nestedNames(Boolean::class))
 
     // Primitive arrays
     for (primitiveArray in listOf(
-            ByteArray::class, DoubleArray::class, FloatArray::class, IntArray::class,
-            LongArray::class, ShortArray::class, CharArray::class, BooleanArray::class
+        ByteArray::class, DoubleArray::class, FloatArray::class, IntArray::class,
+        LongArray::class, ShortArray::class, CharArray::class, BooleanArray::class
     )) {
         assertEquals(emptyList<String>(), nestedNames(primitiveArray))
     }

compiler/testData/codegen/box/reflection/parameters/bigArity.kt

@@ -1,6 +1,5 @@
 // !LANGUAGE: +FunctionTypesWithBigArity
 // IGNORE_BACKEND: JS_IR, JS, NATIVE
-// IGNORE_BACKEND: JVM, JVM_IR
 // WITH_REFLECT
 
 import kotlin.test.assertEquals

compiler/testData/codegen/box/unsignedTypes/boxConstValOfUnsignedType.kt

@@ -1,5 +1,5 @@
 // WITH_UNSIGNED
-// IGNORE_BACKEND: JVM_IR, JS_IR, JS
+// IGNORE_BACKEND: JVM_IR, JS_IR
 
 const val maxUByte: UByte = 0xFFu
 

compiler/testData/codegen/box/unsignedTypes/checkBasicUnsignedLiterals.kt

@@ -1,8 +1,8 @@
-// IGNORE_BACKEND: JVM_IR
 // WITH_UNSIGNED
-// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM_IR, JS_IR
 
 fun box(): String {
+    val good = 42.toUInt()
     val u1 = 1u
     val u2 = 2u
     val u3 = u1 + u2

compiler/testData/codegen/box/unsignedTypes/iterateOverListOfBoxedUnsignedValues.kt

@@ -1,7 +1,6 @@
 // WITH_UNSIGNED
 // IGNORE_BACKEND: JVM_IR
 // IGNORE_BACKEND: JS_IR
-// IGNORE_BACKEND: JS
 
 fun box(): String {
     var sum = 0u

compiler/testData/codegen/box/unsignedTypes/unsignedLiteralsForMaxLongValue.kt

@@ -0,0 +1,10 @@
+// WITH_UNSIGNED
+// IGNORE_BACKEND: JVM_IR, JS_IR
+
+fun box(): String {
+    val maxULong = 0xFFFF_FFFF_FFFF_FFFFuL
+    val zero = 0uL
+    if (zero >= maxULong) return "Fail"
+
+    return "OK"
+}

compiler/testData/codegen/box/unsignedTypes/unsignedLiteralsWithSignedOverflow.kt

@@ -1,6 +1,5 @@
-// IGNORE_BACKEND: JVM_IR
 // WITH_UNSIGNED
-// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM_IR, JS_IR
 
 fun box(): String {
     val u1: UByte = 255u

compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/library/experimental.kt

@@ -0,0 +1,27 @@
+suspend fun dummy() {}
+
+class C {
+    suspend fun dummy() = "OK"
+}
+
+class WithNested {
+    class Nested {
+        suspend fun dummy() = "OK"
+    }
+}
+
+class WithInner {
+    inner class Inner {
+        suspend fun dummy() = "OK"
+    }
+}
+
+val c: suspend () -> Unit = {}
+
+class WithTypeParameter<T: suspend() -> Unit> {}
+
+fun returnsSuspend() : suspend() -> Unit = {}
+
+fun builder(c: suspend () -> Unit) {}
+
+fun <T: suspend () -> Unit> withTypeParameter() = {}

compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/output.txt

@@ -0,0 +1,29 @@
+warning: language version 1.3 is experimental, there are no backwards compatibility guarantees for new language and library features
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:2:5: error: using 'c: suspend () -> Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    c()
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:3:5: error: using 'constructor WithTypeParameter<T : suspend () -> Unit>()' is an error. Experimental coroutine cannot be used with API version 1.3
+    WithTypeParameter<suspend () -> Unit>()
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:4:5: error: using 'returnsSuspend(): suspend () -> Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    returnsSuspend()
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:5:5: error: using 'builder(suspend () -> Unit): Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    builder {}
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:6:5: error: using 'withTypeParameter(): () -> Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    withTypeParameter<suspend () -> Unit>()
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:8:5: error: using 'dummy(): Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    dummy()
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:9:9: error: using 'dummy(): String' is an error. Experimental coroutine cannot be used with API version 1.3
+    C().dummy()
+        ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:10:25: error: using 'dummy(): String' is an error. Experimental coroutine cannot be used with API version 1.3
+    WithNested.Nested().dummy()
+                        ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:11:25: error: using 'dummy(): String' is an error. Experimental coroutine cannot be used with API version 1.3
+    WithInner().Inner().dummy()
+                        ^
+COMPILATION_ERROR

compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt

@@ -0,0 +1,12 @@
+suspend fun callRelease() {
+    c()
+    WithTypeParameter<suspend () -> Unit>()
+    returnsSuspend()
+    builder {}
+    withTypeParameter<suspend () -> Unit>()
+
+    dummy()
+    C().dummy()
+    WithNested.Nested().dummy()
+    WithInner().Inner().dummy()
+}

compiler/testData/compileKotlinAgainstKotlin/coroutines/builder.kt

@@ -1,5 +1,7 @@
 // FILE: A.kt
 // LANGUAGE_VERSION: 1.2
+// TODO: Unmute when automatic conversion experimental <-> release will be implemented
+// IGNORE_BACKEND: JVM, JS, NATIVE, JVM_IR, JS_IR
 import kotlin.coroutines.experimental.*
 
 fun builder1(c: suspend () -> String): String {
@@ -39,11 +41,11 @@ fun ok(continuation: Continuation<String>): Any? {
 }
 
 fun box(): String {
-    if (builder1(::ok) != "OK") return "FAIL 1"
-    if (builder1 { cont: Continuation<String> -> "OK" } != "OK") return "FAIL 2"
-    if (builder1(fun (cont: Continuation<String>): Any? = "OK") != "OK") return "FAIL 3"
-
-    if (builder2 { cont: Continuation<String> -> this + "K" } != "OK") return "FAIL 5"
-    if (builder2(fun String.(cont: Continuation<String>): Any? = this + "K") != "OK") return "FAIL 6"
+//    if (builder1(::ok) != "OK") return "FAIL 1"
+//    if (builder1 { cont: Continuation<String> -> "OK" } != "OK") return "FAIL 2"
+//    if (builder1(fun (cont: Continuation<String>): Any? = "OK") != "OK") return "FAIL 3"
+//
+//    if (builder2 { cont: Continuation<String> -> this + "K" } != "OK") return "FAIL 5"
+//    if (builder2(fun String.(cont: Continuation<String>): Any? = this + "K") != "OK") return "FAIL 6"
     return "OK"
 }

compiler/testData/compileKotlinAgainstKotlin/coroutines/lambda.kt

@@ -1,5 +1,7 @@
 // FILE: A.kt
 // LANGUAGE_VERSION: 1.2
+// TODO: Unmute when automatic conversion experimental <-> release will be implemented
+// IGNORE_BACKEND: JVM, JS, NATIVE, JVM_IR, JS_IR
 
 val dummy1: suspend () -> String = { "OK" }
 val dummy2: suspend String.() -> String = { this + "K" }
@@ -10,17 +12,17 @@ val dummy3: suspend String.(String) -> String = { s -> this + s }
 import kotlin.coroutines.experimental.*
 
 fun box(): String {
-    val continuation = object : Continuation<String> {
-        override val context = EmptyCoroutineContext
-        override fun resume(value: String) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    }
-    if (dummy1(continuation) != "OK") return "FAIL 1"
-    if ("O".dummy2(continuation) != "OK") return "FAIL 2"
-    if ("O".dummy3("K", continuation) != "OK") return "FAIL 3"
+//    val continuation = object : Continuation<String> {
+//        override val context = EmptyCoroutineContext
+//        override fun resume(value: String) {
+//        }
+//
+//        override fun resumeWithException(exception: Throwable) {
+//            throw exception
+//        }
+//    }
+//    if (dummy1(continuation) != "OK") return "FAIL 1"
+//    if ("O".dummy2(continuation) != "OK") return "FAIL 2"
+//    if ("O".dummy3("K", continuation) != "OK") return "FAIL 3"
     return "OK"
 }

compiler/testData/compileKotlinAgainstKotlin/coroutines/receiver.kt

@@ -1,5 +1,7 @@
 // FILE: A.kt
 // LANGUAGE_VERSION: 1.2
+// TODO: Unmute when automatic conversion experimental <-> release will be implemented
+// IGNORE_BACKEND: JVM, JS, NATIVE, JVM_IR, JS_IR
 import kotlin.coroutines.experimental.*
 
 fun (suspend () -> String).builder(): String {
@@ -25,8 +27,8 @@ fun ok(continuation: Continuation<String>): Any? {
 }
 
 fun box(): String {
-    if ((::ok).builder() != "OK") return "FAIL 1"
-    if (({ cont: Continuation<String> -> "OK" }).builder() != "OK") return "FAIL 2"
-    if ((fun (cont: Continuation<String>): Any? = "OK").builder() != "OK") return "FAIL 3"
+//    if ((::ok).builder() != "OK") return "FAIL 1"
+//    if (({ cont: Continuation<String> -> "OK" }).builder() != "OK") return "FAIL 2"
+//    if ((fun (cont: Continuation<String>): Any? = "OK").builder() != "OK") return "FAIL 3"
     return "OK"
 }

compiler/testData/compileKotlinAgainstKotlin/coroutines/simple.kt

@@ -1,5 +1,7 @@
 // FILE: A.kt
 // LANGUAGE_VERSION: 1.2
+// TODO: Unmute when automatic conversion experimental <-> release will be implemented
+// IGNORE_BACKEND: JVM, JS, NATIVE, JVM_IR, JS_IR
 
 suspend fun dummy() = "OK"
 
@@ -29,19 +31,19 @@ class WithInner {
 import kotlin.coroutines.experimental.*
 
 fun box(): String {
-    val continuation = object : Continuation<String> {
-        override val context = EmptyCoroutineContext
-        override fun resume(value: String) {
-        }
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    }
-    if (dummy(continuation) != "OK") return "FAIL 1"
-    if ("O".dummy(continuation) != "OK") return "FAIL 2"
-    if ("O".dummy("K", continuation) != "OK") return "FAIL 3"
-    if (C().dummy(continuation) != "OK") return "FAIL 4"
-    if (WithNested.Nested().dummy(continuation) != "OK") return "FAIL 5"
-    if (WithInner().Inner().dummy(continuation) != "OK") return "FAIL 6"
+//    val continuation = object : Continuation<String> {
+//        override val context = EmptyCoroutineContext
+//        override fun resume(value: String) {
+//        }
+//        override fun resumeWithException(exception: Throwable) {
+//            throw exception
+//        }
+//    }
+//    if (dummy(continuation) != "OK") return "FAIL 1"
+//    if ("O".dummy(continuation) != "OK") return "FAIL 2"
+//    if ("O".dummy("K", continuation) != "OK") return "FAIL 3"
+//    if (C().dummy(continuation) != "OK") return "FAIL 4"
+//    if (WithNested.Nested().dummy(continuation) != "OK") return "FAIL 5"
+//    if (WithInner().Inner().dummy(continuation) != "OK") return "FAIL 6"
     return "OK"
 }

compiler/testData/diagnostics/tests/inference/coerceFunctionLiteralToSuspend.kt

@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun fail1(c: suspend () -> Unit) {}
+
+fun fail2(c: () -> Unit) {}
+
+fun success1(c: suspend () -> Unit) {}
+
+fun test1() {
+    fail1(<!TYPE_MISMATCH!>fun () {}<!>)
+    fun fail2(c: suspend () -> Unit) {}
+    fail2(<!TYPE_MISMATCH!>fun () {}<!>)
+    fun success1(c: () -> Unit) {}
+    success1(fun() {})
+}
+
+suspend fun fail3(c: suspend () -> Unit) {}
+
+suspend fun fail4(c: () -> Unit) {}
+
+suspend fun success2(c: suspend () -> Unit) {}
+
+suspend fun test2() {
+    fail3(<!TYPE_MISMATCH!>fun () {}<!>)
+    fun fail4(c: suspend () -> Unit) {}
+    fail4(<!TYPE_MISMATCH!>fun () {}<!>)
+    fun success2(c: () -> Unit) {}
+    success2(fun() {})
+}

compiler/testData/diagnostics/tests/inference/coerceFunctionLiteralToSuspend.txt

@@ -0,0 +1,10 @@
+package
+
+public fun fail1(/*0*/ c: suspend () -> kotlin.Unit): kotlin.Unit
+public fun fail2(/*0*/ c: () -> kotlin.Unit): kotlin.Unit
+public suspend fun fail3(/*0*/ c: suspend () -> kotlin.Unit): kotlin.Unit
+public suspend fun fail4(/*0*/ c: () -> kotlin.Unit): kotlin.Unit
+public fun success1(/*0*/ c: suspend () -> kotlin.Unit): kotlin.Unit
+public suspend fun success2(/*0*/ c: suspend () -> kotlin.Unit): kotlin.Unit
+public fun test1(): kotlin.Unit
+public suspend fun test2(): kotlin.Unit

compiler/testData/diagnostics/tests/inference/lambdaInValInitializerWithAnonymousFunctions.kt

@@ -1,10 +1,9 @@
-// !WITH_NEW_INFERENCE
 typealias SuspendFn = suspend () -> Unit
 
-val test1f: suspend () -> Unit = fun () {}
-val test2f: suspend Any.() -> Unit = fun Any.() {}
+val test1f: suspend () -> Unit = <!TYPE_MISMATCH!>fun () {}<!>
+val test2f: suspend Any.() -> Unit = <!TYPE_MISMATCH!>fun Any.() {}<!>
 
 // This is a bug in the old inference and should be fixed in new inference
 // see "Fix anonymous function literals handling in type checker" for more deatils
-val test3f: suspend Any.(Int) -> Int = <!OI;TYPE_MISMATCH!>fun (k: Int) = k + 1<!>
-val test4f: SuspendFn = <!OI;TYPE_MISMATCH!>fun Any.() {}<!>
+val test3f: suspend Any.(Int) -> Int = <!TYPE_MISMATCH!>fun (k: Int) = k + 1<!>
+val test4f: SuspendFn = <!TYPE_MISMATCH!>fun Any.() {}<!>

compiler/testData/diagnostics/testsWithStdLib/annotations/explicitMetadata.kt

@@ -1,5 +1,3 @@
-// !DIAGNOSTICS: -INVISIBLE_MEMBER -INVISIBLE_REFERENCE -EXPOSED_PARAMETER_TYPE
-
 <!EXPLICIT_METADATA_IS_DISALLOWED!>@Metadata<!>
 class A
 

compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.kt

@@ -24,14 +24,14 @@ fun builder(c: <!UNSUPPORTED!>suspend<!> () -> Unit) {}
 }
 
 fun test2() {
-    kotlin.coroutines.experimental.buildSequence<Int> {
-        yield(1<!NO_VALUE_FOR_PARAMETER!>)<!>
+    kotlin.coroutines.experimental.<!DEPRECATION_ERROR, UNSUPPORTED!>buildSequence<!><Int> {
+        <!DEPRECATION_ERROR!>yield<!>(1)
     }
     kotlin.sequences.<!UNRESOLVED_REFERENCE!>buildSequence<!><Int> {
         <!UNRESOLVED_REFERENCE!>yield<!>(1)
     }
 }
 
-<!UNSUPPORTED!>suspend<!> fun test3(): Unit = <!TYPE_MISMATCH!>kotlin.coroutines.experimental.<!NO_VALUE_FOR_PARAMETER, TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>suspendCoroutine<!> <!TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>_<!> -> Unit }<!><!>
+<!UNSUPPORTED!>suspend<!> fun test3(): Unit = kotlin.coroutines.experimental.<!DEPRECATION_ERROR!>suspendCoroutine<!> { _ -> Unit }
 
 <!UNSUPPORTED!>suspend<!> fun test4(): Unit = kotlin.coroutines.<!UNRESOLVED_REFERENCE!>suspendCoroutine<!> { <!CANNOT_INFER_PARAMETER_TYPE!>_<!> -> Unit }

compiler/testData/loadJava/compiledJava/IntrinsicCompanionObject.java

@@ -6,5 +6,6 @@ public interface IntrinsicCompanionObject {
     void testInt(IntCompanionObject i);
     void testChar(CharCompanionObject c);
     void testString(StringCompanionObject s);
+    void testBoolean(BooleanCompanionObject b);
     void testEnum(EnumCompanionObject e);
 }