Move: Fix ClassCastException on processing of callable references to Java methods

#KT-16809 Fixed

.idea/ant.xml

@@ -3,7 +3,7 @@
   <component name="AntConfiguration">
     <buildFile url="file://$PROJECT_DIR$/compiler/frontend/buildLexer.xml" />
     <buildFile url="file://$PROJECT_DIR$/build.xml">
-      <antCommandLine value="-J-XX:MaxPermSize=100m -J-ea" />
+      <antCommandLine value="-J-ea" />
       <maximumHeapSize value="1024" />
     </buildFile>
     <buildFile url="file://$PROJECT_DIR$/update_dependencies.xml" />

.idea/artifacts/KotlinJpsPlugin.xml

@@ -11,7 +11,6 @@
       <element id="directory" name="META-INF">
         <element id="dir-copy" path="$PROJECT_DIR$/jps-plugin/src/META-INF" />
       </element>
-      <element id="extracted-dir" path="$PROJECT_DIR$/dependencies/cli-parser-1.1.2.jar" path-in-jar="/" />
       <element id="module-output" name="cli-common" />
       <element id="module-output" name="idea-jps-common" />
       <element id="module-output" name="jps-plugin" />

.idea/artifacts/KotlinPlugin.xml

@@ -10,6 +10,7 @@
     <root id="root">
       <element id="directory" name="lib">
         <element id="archive" name="kotlin-plugin.jar">
+          <element id="extracted-dir" path="$PROJECT_DIR$/dependencies/cli-parser-1.1.2.jar" path-in-jar="/" />
           <element id="module-output" name="backend" />
           <element id="module-output" name="frontend" />
           <element id="module-output" name="descriptors" />
@@ -24,6 +25,7 @@
           <element id="module-output" name="js.parser" />
           <element id="module-output" name="cli-common" />
           <element id="module-output" name="idea-jps-common" />
+          <element id="module-output" name="build-common" />
           <element id="module-output" name="preloader" />
           <element id="module-output" name="deserialization" />
           <element id="module-output" name="backend-common" />

.idea/dictionaries/4u7.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="4u7">
+    <words>
+      <w>foldable</w>
+    </words>
+  </dictionary>
+</component>

.idea/dictionaries/Nikolay_Krasko.xml

@@ -2,6 +2,7 @@
   <dictionary name="Nikolay.Krasko">
     <words>
       <w>accessors</w>
+      <w>crossinline</w>
       <w>fqname</w>
       <w>goto</w>
       <w>gradle</w>

.idea/inspectionProfiles/idea_default.xml

@@ -1,7 +1,6 @@
 <component name="InspectionProjectProfileManager">
-  <profile version="1.0" is_locked="false">
+  <profile version="1.0">
     <option name="myName" value="idea.default" />
-    <option name="myLocal" value="false" />
     <inspection_tool class="AbstractMethodCallInConstructor" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="ArchaicSystemPropertyAccess" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="AssignmentToForLoopParameter" enabled="true" level="WARNING" enabled_by_default="true">
@@ -236,10 +235,6 @@
       <scope name="idea openapi" level="WARNING" enabled="true" />
       <scope name="runtime.classes" level="ERROR" enabled="true" />
     </inspection_tool>
-    <inspection_tool class="LoggerInitializedWithForeignClass" enabled="false" level="WARNING" enabled_by_default="false">
-      <option name="loggerClassName" value="org.apache.log4j.Logger,org.slf4j.LoggerFactory,org.apache.commons.logging.LogFactory,java.util.logging.Logger" />
-      <option name="loggerFactoryMethodName" value="getLogger,getLogger,getLog,getLogger" />
-    </inspection_tool>
     <inspection_tool class="LoopToCallChain" enabled="false" level="INFO" enabled_by_default="false" />
     <inspection_tool class="MethodMayBeStatic" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="m_onlyPrivateOrFinal" value="false" />
@@ -347,11 +342,12 @@
         <constraint name="__context__" script="&quot;&quot;" within="" contains="" />
       </searchConfiguration>
     </inspection_tool>
+    <inspection_tool class="SameParameterValue" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="SetReplaceableByEnumSet" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="SetupCallsSuperSetup" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="SetupIsPublicVoidNoArg" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="SimplifiableIfStatement" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="Since15" enabled="true" level="ERROR" enabled_by_default="true">
+    <inspection_tool class="Since15" enabled="false" level="ERROR" enabled_by_default="false">
       <scope name="IDEA Test Sources" level="ERROR" enabled="false" />
     </inspection_tool>
     <inspection_tool class="SocketResource" enabled="true" level="WARNING" enabled_by_default="true">

.idea/kotlinc.xml

@@ -1,5 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="KotlinCommonCompilerArguments">
+    <option name="languageVersion" value="1.1" />
+    <option name="apiVersion" value="1.1" />
+  </component>
   <component name="KotlinCompilerSettings">
     <option name="additionalArguments" value="-version -Xallow-kotlin-package -Xskip-metadata-version-check" />
   </component>

.idea/libraries/cli_parser.xml

@@ -1,11 +0,0 @@
-<component name="libraryTable">
-  <library name="cli-parser">
-    <CLASSES>
-      <root url="jar://$PROJECT_DIR$/dependencies/cli-parser-1.1.2.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES>
-      <root url="jar://$PROJECT_DIR$/dependencies/cli-parser-1.1.2-sources.jar!/" />
-    </SOURCES>
-  </library>
-</component>

.idea/libraries/guava.xml

@@ -4,11 +4,11 @@
       <root url="file://$PROJECT_DIR$/annotations" />
     </ANNOTATIONS>
     <CLASSES>
-      <root url="jar://$PROJECT_DIR$/ideaSDK/lib/guava-17.0.jar!/" />
+      <root url="jar://$PROJECT_DIR$/ideaSDK/lib/guava-19.0.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES>
-      <root url="jar://$PROJECT_DIR$/dependencies/guava-17.0-sources.jar!/" />
+      <root url="jar://$PROJECT_DIR$/dependencies/guava-19.0-sources.jar!/" />
     </SOURCES>
   </library>
 </component>

.idea/libraries/idea_full.xml

@@ -9,7 +9,7 @@
     </CLASSES>
     <JAVADOC />
     <SOURCES>
-      <root url="jar://$PROJECT_DIR$/dependencies/guava-17.0-sources.jar!/" />
+      <root url="jar://$PROJECT_DIR$/dependencies/guava-19.0-sources.jar!/" />
       <root url="jar://$PROJECT_DIR$/dependencies/asm5-src.zip!/" />
       <root url="jar://$PROJECT_DIR$/ideaSDK/sources/sources.jar!/" />
     </SOURCES>

.idea/libraries/intellij_core.xml

@@ -9,7 +9,7 @@
     </CLASSES>
     <JAVADOC />
     <SOURCES>
-      <root url="jar://$PROJECT_DIR$/dependencies/guava-17.0-sources.jar!/" />
+      <root url="jar://$PROJECT_DIR$/dependencies/guava-19.0-sources.jar!/" />
       <root url="jar://$PROJECT_DIR$/dependencies/asm5-src.zip!/" />
       <root url="jar://$PROJECT_DIR$/ideaSDK/sources/sources.jar!/" />
     </SOURCES>

.idea/libraries/intellij_core_analysis.xml

@@ -10,7 +10,7 @@
     <JAVADOC />
     <SOURCES>
       <root url="jar://$PROJECT_DIR$/dependencies/asm5-src.zip!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/guava-17.0-sources.jar!/" />
+      <root url="jar://$PROJECT_DIR$/dependencies/guava-19.0-sources.jar!/" />
       <root url="jar://$PROJECT_DIR$/ideaSDK/sources/sources.jar!/" />
     </SOURCES>
   </library>

.idea/libraries/properties.xml

@@ -5,6 +5,7 @@
     </ANNOTATIONS>
     <CLASSES>
       <root url="jar://$PROJECT_DIR$/ideaSDK/plugins/properties/lib/properties.jar!/" />
+      <root url="jar://$PROJECT_DIR$/ideaSDK/plugins/properties/lib/resources_en.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES>

.idea/libraries/uast_java.xml

@@ -3,11 +3,13 @@
     <CLASSES>
       <root url="jar://$PROJECT_DIR$/dependencies/uast-common.jar!/" />
       <root url="jar://$PROJECT_DIR$/dependencies/uast-java.jar!/" />
+      <root url="jar://$PROJECT_DIR$/dependencies/uast-tests.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES>
       <root url="jar://$PROJECT_DIR$/dependencies/uast-common-sources.jar!/" />
       <root url="jar://$PROJECT_DIR$/dependencies/uast-java-sources.jar!/" />
+      <root url="jar://$PROJECT_DIR$/dependencies/uast-tests-sources.jar!/" />
     </SOURCES>
   </library>
 </component>

.idea/misc.xml

@@ -6,7 +6,6 @@
     </properties>
   </component>
   <component name="EntryPointsManager">
-    <entry_points version="2.0" />
     <list size="1">
       <item index="0" class="java.lang.String" itemvalue="javax.inject.Inject" />
     </list>
@@ -49,7 +48,7 @@
   <component name="ProjectResources">
     <default-html-doctype>http://www.w3.org/1999/xhtml</default-html-doctype>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" default="false" assert-keyword="true" jdk-15="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" default="false" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
   <component name="SuppressABINotification">

.idea/modules.xml

@@ -92,6 +92,7 @@
       <module fileurl="file://$PROJECT_DIR$/plugins/sam-with-receiver/sam-with-receiver-ide/sam-with-receiver-ide.iml" filepath="$PROJECT_DIR$/plugins/sam-with-receiver/sam-with-receiver-ide/sam-with-receiver-ide.iml" />
       <module fileurl="file://$PROJECT_DIR$/core/script.runtime/script.runtime.iml" filepath="$PROJECT_DIR$/core/script.runtime/script.runtime.iml" group="core" />
       <module fileurl="file://$PROJECT_DIR$/compiler/serialization/serialization.iml" filepath="$PROJECT_DIR$/compiler/serialization/serialization.iml" group="compiler" />
+      <module fileurl="file://$PROJECT_DIR$/plugins/source-sections/source-sections-compiler/source-sections-compiler.iml" filepath="$PROJECT_DIR$/plugins/source-sections/source-sections-compiler/source-sections-compiler.iml" group="plugins" />
       <module fileurl="file://$PROJECT_DIR$/compiler/tests-common/tests-common.iml" filepath="$PROJECT_DIR$/compiler/tests-common/tests-common.iml" group="compiler" />
       <module fileurl="file://$PROJECT_DIR$/compiler/tests-ir-jvm/tests-ir-jvm.iml" filepath="$PROJECT_DIR$/compiler/tests-ir-jvm/tests-ir-jvm.iml" group="compiler/ir" />
       <module fileurl="file://$PROJECT_DIR$/plugins/uast-kotlin/uast-kotlin.iml" filepath="$PROJECT_DIR$/plugins/uast-kotlin/uast-kotlin.iml" group="plugins/lint" />

.idea/runConfigurations/All_Jvm_Backend_Tests.xml

@@ -13,7 +13,7 @@
     <option name="MAIN_CLASS_NAME" value="" />
     <option name="METHOD_NAME" value="" />
     <option name="TEST_OBJECT" value="package" />
-    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx900m -XX:MaxPermSize=320m -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=64m  -Djna.nosys=true" />
+    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx1024m -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=64m -Djna.nosys=true" />
     <option name="PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
     <option name="ENV_VARIABLES" />

.idea/runConfigurations/All_Non_Compiler_Tests.xml

@@ -13,7 +13,7 @@
     <option name="MAIN_CLASS_NAME" value="" />
     <option name="METHOD_NAME" value="" />
     <option name="TEST_OBJECT" value="package" />
-    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx1100m -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=128m -Djna.nosys=true" />
+    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx900m -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=128m -Djna.nosys=true" />
     <option name="PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
     <option name="ENV_VARIABLES" />

.idea/runConfigurations/Compiler_Tests.xml

@@ -13,7 +13,7 @@
     <option name="MAIN_CLASS_NAME" value="" />
     <option name="METHOD_NAME" value="" />
     <option name="TEST_OBJECT" value="package" />
-    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx700m -XX:MaxPermSize=300m -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=64m  -Djna.nosys=true" />
+    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx1024m -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=64m -Djna.nosys=true" />
     <option name="PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
     <option name="ENV_VARIABLES" />

.idea/runConfigurations/Java_8_Tests_on_JDK_9.xml

@@ -0,0 +1,28 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Java 8 Tests on JDK 9" type="JUnit" factoryName="JUnit">
+    <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
+      <pattern>
+        <option name="PATTERN" value="org.jetbrains.kotlin.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <module name="compiler-tests-java8" />
+    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
+    <option name="ALTERNATIVE_JRE_PATH" value="9-ea" />
+    <option name="PACKAGE_NAME" value="org.jetbrains.kotlin" />
+    <option name="MAIN_CLASS_NAME" value="" />
+    <option name="METHOD_NAME" value="" />
+    <option name="TEST_OBJECT" value="package" />
+    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=64m -Djna.nosys=true --add-opens java.base/java.lang.reflect=ALL-UNNAMED --add-opens java.desktop/javax.swing=ALL-UNNAMED --add-opens java.base/java.lang=ALL-UNNAMED --add-opens java.base/java.util=ALL-UNNAMED --add-opens java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens java.base/jdk.internal.misc=ALL-UNNAMED --add-opens java.base/java.io=ALL-UNNAMED" />
+    <option name="PARAMETERS" value="" />
+    <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
+    <option name="ENV_VARIABLES" />
+    <option name="PASS_PARENT_ENVS" value="true" />
+    <option name="TEST_SEARCH_SCOPE">
+      <value defaultName="singleModule" />
+    </option>
+    <envs />
+    <patterns />
+    <method />
+  </configuration>
+</component>

ChangeLog.md

@@ -3,6 +3,636 @@
 <!-- Find: ([^\`/\[])(KT-\d+) -->
 <!-- Replace: $1[`$2`](https://youtrack.jetbrains.com/issue/$2) -->
 
+## 1.1.1
+
+### IDE
+- [`KT-16714`](https://youtrack.jetbrains.com/issue/KT-16714) J2K: Write access is allowed from event dispatch thread only
+
+### Compiler
+- [`KT-16801`](https://youtrack.jetbrains.com/issue/KT-16801) Accessors of `@PublishedApi` property gets mangled
+- [`KT-16673`](https://youtrack.jetbrains.com/issue/KT-16673) Potentially problematic code causes exception when work with SAM adapters
+
+### Libraries
+- [`KT-16557`](https://youtrack.jetbrains.com/issue/KT-16557) Correct `SinceKotlin(1.1)` for all declarations in `kotlin.reflect.full`
+
+## 1.1.1-RC
+
+### IDE
+- [`KT-16481`](https://youtrack.jetbrains.com/issue/KT-16481) Kotlin debugger & bytecode fail on select statement blocks (IllegalStateException: More than one package fragment)
+
+### Gradle support
+- [`KT-15783`](https://youtrack.jetbrains.com/issue/KT-15783) Gradle builds don't use incremental compilation due to an error: "Could not connect to kotlin daemon"
+- [`KT-16434`](https://youtrack.jetbrains.com/issue/KT-16434) Gradle plugin does not compile androidTest sources when Jack is enabled
+- [`KT-16546`](https://youtrack.jetbrains.com/issue/KT-16546) Enable incremental compilation in gradle by default
+
+### Compiler
+- [`KT-16184`](https://youtrack.jetbrains.com/issue/KT-16184) AbstractMethodError in Kapt3ComponentRegistrar while compiling from IntelliJ using Kotlin 1.1.0
+- [`KT-16578`](https://youtrack.jetbrains.com/issue/KT-16578) Fix substitutor for synthetic SAM adapters
+- [`KT-16581`](https://youtrack.jetbrains.com/issue/KT-16581) VerifyError when calling default value parameter with jvm-target 1.8
+- [`KT-16583`](https://youtrack.jetbrains.com/issue/KT-16583) Cannot access private file-level variables inside a class init within the same file if a secondary constructor is present
+- [`KT-16587`](https://youtrack.jetbrains.com/issue/KT-16587) AbstractMethodError: Delegates not generated correctly for private interfaces
+- [`KT-16598`](https://youtrack.jetbrains.com/issue/KT-16598) Incorrect error: The feature "bound callable references" is only available since language version 1.1
+- [`KT-16621`](https://youtrack.jetbrains.com/issue/KT-16621) Kotlin compiler doesn't report an error if a class implements Annotation interface but doesn't implement annotationType method
+- [`KT-16441`](https://youtrack.jetbrains.com/issue/KT-16441) `NoSuchFieldError: $$delegatedProperties` when delegating through `provideDelegate` in companion object
+
+### JavaScript support
+- Prohibit function types with receiver as parameter types of external declarations
+- Remove extension receiver for function parameters in `jQuery` declarations
+
+## 1.1
+
+### Compiler exceptions
+- [`KT-16411`](https://youtrack.jetbrains.com/issue/KT-16411) Exception from compiler when try to inline callable reference to class constructor inside object
+- [`KT-16412`](https://youtrack.jetbrains.com/issue/KT-16412) Exception from compiler when try call SAM constructor where argument is callable reference to nested class inside object
+- [`KT-16413`](https://youtrack.jetbrains.com/issue/KT-16413) When we create sam adapter for java.util.function.Function we add incorrect null-check for argument
+
+### Standard library
+- [`KT-6561`](https://youtrack.jetbrains.com/issue/KT-6561) Drop java.util.Collections package from js stdlib
+- `javaClass` extension property is no more deprecated due to migration problems
+
+### IDE
+- [`KT-16329`](https://youtrack.jetbrains.com/issue/KT-16329) Inspection "Calls to staic methods in Java interfaces..." always reports warning undependent of jvm-target
+
+
+## 1.1-RC
+
+### Reflection
+- [`KT-16358`](https://youtrack.jetbrains.com/issue/KT-16358) Incompatibility between kotlin-reflect 1.0 and kotlin-stdlib 1.1 fixed
+
+### Compiler
+
+#### Coroutine support
+- [`KT-15938`](https://youtrack.jetbrains.com/issue/KT-15938) Changed error message for calling suspend function outside of suspendable context
+- [`KT-16092`](https://youtrack.jetbrains.com/issue/KT-16092) Backend crash fixed: "Don't know how to generate outer expression" for destructuring suspend lambda
+- [`KT-16093`](https://youtrack.jetbrains.com/issue/KT-16093) Annotations are retained during reading the binary representation of suspend functions
+- [`KT-16122`](https://youtrack.jetbrains.com/issue/KT-16122) java.lang.VerifyError fixed in couroutines: (String, null, suspend () -> String)
+- [`KT-16124`](https://youtrack.jetbrains.com/issue/KT-16124) Marked as UNSUPPORTED: suspension points in default parameters
+- [`KT-16219`](https://youtrack.jetbrains.com/issue/KT-16219) Marked as UNSUPPORTED: suspend get/set, in/!in operators for
+- [`KT-16145`](https://youtrack.jetbrains.com/issue/KT-16145) Beta-2 coroutine regression fixed (wrong code generation)
+
+#### Kapt3
+- [`KT-15524`](https://youtrack.jetbrains.com/issue/KT-15524) Fix javac error reporting in Kotlin daemon
+- [`KT-15721`](https://youtrack.jetbrains.com/issue/KT-15721) JetBrains nullability annotations are now returned from Element.getAnnotationMirrors()
+- [`KT-16146`](https://youtrack.jetbrains.com/issue/KT-16146) Fixed work in verbose mode
+- [`KT-16153`](https://youtrack.jetbrains.com/issue/KT-16153) Ignore declarations with illegal Java identifiers
+- [`KT-16167`](https://youtrack.jetbrains.com/issue/KT-16167) Fixed compilation error with kapt arguments in build.gradle
+- [`KT-16170`](https://youtrack.jetbrains.com/issue/KT-16170) Stub generator now adds imports for corrected error types to stubs
+- [`KT-16176`](https://youtrack.jetbrains.com/issue/KT-16176) javac's finalCompiler log is now used to determine annotation processing errors
+
+#### Backward compatibility
+- [`KT-16017`](https://youtrack.jetbrains.com/issue/KT-16017) More graceful error message for disabled features
+- [`KT-16073`](https://youtrack.jetbrains.com/issue/KT-16073) Improved backward compatibility mode with version 1.0 on JDK dependent built-ins
+- [`KT-16094`](https://youtrack.jetbrains.com/issue/KT-16094) Compiler considers API availability when compiling language features requiring runtime support
+- [`KT-16171`](https://youtrack.jetbrains.com/issue/KT-16171) Fixed regression "Unexpected container error on Kotlin 1.0 project"
+- [`KT-16199`](https://youtrack.jetbrains.com/issue/KT-16199) Do not import "kotlin.comparisons.*" by default in language version 1.0 mode
+
+#### Various issues
+- [`KT-16225`](https://youtrack.jetbrains.com/issue/KT-16225) enumValues non-reified stub implementation references nonexistent method no more
+- [`KT-16291`](https://youtrack.jetbrains.com/issue/KT-16291) Smart cast works now when getting class of instance
+- [`KT-16380`](https://youtrack.jetbrains.com/issue/KT-16380) Show warning when running the compiler under Java 6 or 7
+
+### JavaScript backend
+- [`KT-16144`](https://youtrack.jetbrains.com/issue/KT-16144) Fixed inlining of functions called through inheritor ("fake" override) from another module
+- [`KT-16158`](https://youtrack.jetbrains.com/issue/KT-16158) Error is not reported now when library path contains JAR file without JS metadata, report warning instead
+- [`KT-16160`](https://youtrack.jetbrains.com/issue/KT-16160) Companion object dispatch receiver translation fixed
+
+### Standard library
+- [`KT-7858`](https://youtrack.jetbrains.com/issue/KT-7858) Add extension function `takeUnless`
+- `javaClass` extension property is deprecated, use `instance::class.java` instead
+- Massive deprecations are coming in JS standard library in `kotlin.dom` and `kotlin.dom.build` packages
+
+### IDE
+
+#### Configuration issues
+- [`KT-15899`](https://youtrack.jetbrains.com/issue/KT-15899) Kotlin facet: language and api version for submodule setup for 1.0 are filled now as 1.0 too
+- [`KT-15914`](https://youtrack.jetbrains.com/issue/KT-15914) Kotlin facet works now with multi-selected modules in Project Settings too
+- [`KT-15954`](https://youtrack.jetbrains.com/issue/KT-15954) Does not suggest to configure kotlin for the module after each new kt-file creation
+- [`KT-16157`](https://youtrack.jetbrains.com/issue/KT-16157) freeCompilerArgs are now imported from Gradle into IDEA
+- [`KT-16206`](https://youtrack.jetbrains.com/issue/KT-16206) Idea no more refuses to compile a kotlin project defined as a maven project
+- [`KT-16312`](https://youtrack.jetbrains.com/issue/KT-16312) Kotlin facet: import from gradle: don't import options which are set implicitly already
+- [`KT-16325`](https://youtrack.jetbrains.com/issue/KT-16325) Kotlin facet: correct configuration after upgrading the IDE plugin
+- [`KT-16345`](https://youtrack.jetbrains.com/issue/KT-16345) Kotlin facet: detect JavaScript if the module has language 1.0 `kotlin-js-library` dependency
+
+#### Coroutine support
+- [`KT-16109`](https://youtrack.jetbrains.com/issue/KT-16109) Error fixed: The -Xcoroutines can only have one value 
+- [`KT-16251`](https://youtrack.jetbrains.com/issue/KT-16251) Fix detection of suspend calls containing extracted parameters
+
+#### Intention actions, inspections and quick-fixes
+
+##### 2017.1 compatibility
+- [`KT-15870`](https://youtrack.jetbrains.com/issue/KT-15870) "Package name does not match containing directory" inspection: fixed throwable "AWT events are not allowed inside write action"
+- [`KT-15924`](https://youtrack.jetbrains.com/issue/KT-15924) Create Test action: fixed throwable "AWT events are not allowed inside write action"
+
+##### Bug fixes
+- [`KT-14831`](https://youtrack.jetbrains.com/issue/KT-14831) Import statement and FQN are not added on converting lambda to reference for typealias
+- [`KT-15545`](https://youtrack.jetbrains.com/issue/KT-15545) Inspection "join with assignment" does not change now execution order for properties
+- [`KT-15744`](https://youtrack.jetbrains.com/issue/KT-15744) Fix: intention to import `sleep` wrongly suggests `Thread.sleep`
+- [`KT-16000`](https://youtrack.jetbrains.com/issue/KT-16000) Inspection "join with assignment" handles initialization with 'this' correctly
+- [`KT-16009`](https://youtrack.jetbrains.com/issue/KT-16009) Auto-import for JDK classes in .kts files
+- [`KT-16104`](https://youtrack.jetbrains.com/issue/KT-16104) Don't insert modifiers (e.g. suspend) before visibility
+
+#### Completion
+- [`KT-16076`](https://youtrack.jetbrains.com/issue/KT-16076) Completion does not insert more FQN kotlin.text.String
+- [`KT-16088`](https://youtrack.jetbrains.com/issue/KT-16088) Completion does not insert more FQN for `kotlin` package
+- [`KT-16110`](https://youtrack.jetbrains.com/issue/KT-16110) Keyword 'suspend' completion inside generic arguments
+- [`KT-16243`](https://youtrack.jetbrains.com/issue/KT-16243) Performance enhanced after variable of type `ArrayList`
+
+#### Various issues
+- [`KT-15291`](https://youtrack.jetbrains.com/issue/KT-15291) 'Find usages' now does not report property access as usage of getter method in Java class with parameter
+- [`KT-15647`](https://youtrack.jetbrains.com/issue/KT-15647) Exception fixed: KDoc link to member of class from different package and module
+- [`KT-16071`](https://youtrack.jetbrains.com/issue/KT-16071) IDEA deadlock fixed: when typing "parse()" in .kt file
+- [`KT-16149`](https://youtrack.jetbrains.com/issue/KT-16149) Intellij Idea 2017.1/Android Studio 2.3 beta3 and Kotlin plugin 1.1-beta2 deadlock fixed
+
+### Coroutine libraries
+- [`KT-15716`](https://youtrack.jetbrains.com/issue/KT-15716) Introduced startCoroutineUninterceptedOrReturn coroutine intrinsic
+- [`KT-15718`](https://youtrack.jetbrains.com/issue/KT-15718) createCoroutine now returns safe continuation
+- [`KT-16155`](https://youtrack.jetbrains.com/issue/KT-16155) Introduced createCoroutineUnchecked intrinsic
+
+
+### Gradle support
+- [`KT-15829`](https://youtrack.jetbrains.com/issue/KT-15829) Gradle Kotlin JS plugin: removed false "Duplicate source root:" warning for kotlin files
+- [`KT-15902`](https://youtrack.jetbrains.com/issue/KT-15902) JS: gradle task output is now considered as source set output
+- [`KT-16174`](https://youtrack.jetbrains.com/issue/KT-16174) Error fixed during IDEA-Gradle synchronization for Kotlin JS
+- [`KT-16267`](https://youtrack.jetbrains.com/issue/KT-16267) JS: fixed regression in 1.1-beta2 for multi-module gradle project
+- [`KT-16274`](https://youtrack.jetbrains.com/issue/KT-16274) Kotlin JS Gradle unexpected compiler error / absolute path to output file
+- [`KT-16322`](https://youtrack.jetbrains.com/issue/KT-16322) Circlet project Gradle import issue fixed
+
+### REPL
+- [`KT-15861`](https://youtrack.jetbrains.com/issue/KT-15861) Use windows line separator in kotlin's JSR implementation
+- [`KT-16126`](https://youtrack.jetbrains.com/issue/KT-16126) Proper `jvmTarget` for REPL compilation
+
+
+## 1.1-Beta2
+
+### Language related changes
+- [`KT-7897`](https://youtrack.jetbrains.com/issue/KT-7897) Do not require to call enum constructor for each entry if all parameters have default values
+- [`KT-8985`](https://youtrack.jetbrains.com/issue/KT-8985) Support T::class.java for T with no non-null upper bound
+- [`KT-10711`](https://youtrack.jetbrains.com/issue/KT-10711) Type inference works now on generics for callable references
+- [`KT-13130`](https://youtrack.jetbrains.com/issue/KT-13130) Support exhaustive when for sealed trees
+- [`KT-15898`](https://youtrack.jetbrains.com/issue/KT-15898) Cannot use type alias to qualify enum entry
+- [`KT-16061`](https://youtrack.jetbrains.com/issue/KT-16061) Smart type inference on callable references in 1.1 mode only
+
+### Reflection
+- [`KT-8384`](https://youtrack.jetbrains.com/issue/KT-8384) Access to the delegate object for a KProperty
+
+### Compiler
+
+#### Coroutine support
+- [`KT-15016`](https://youtrack.jetbrains.com/issue/KT-15016) VerifyError with coroutine: fix processing of uninitialized instances
+- [`KT-15527`](https://youtrack.jetbrains.com/issue/KT-15527) Coroutine compile error: wrong code generated for safe qualified suspension points
+- [`KT-15552`](https://youtrack.jetbrains.com/issue/KT-15552) Accessor implementation of suspended function produces AbstractMethodError
+- [`KT-15715`](https://youtrack.jetbrains.com/issue/KT-15715) Coroutine generate invalid invoke
+- [`KT-15820`](https://youtrack.jetbrains.com/issue/KT-15820) Coroutine Internal Error regression with dispatcher + this@
+- [`KT-15821`](https://youtrack.jetbrains.com/issue/KT-15821) Coroutine internal error regression: Could not inline method call apply
+- [`KT-15824`](https://youtrack.jetbrains.com/issue/KT-15824) Coroutine iterator regression: Object cannot be cast to java.lang.Boolean
+- [`KT-15827`](https://youtrack.jetbrains.com/issue/KT-15827) Show Kotlin Bytecode shows wrong bytecode for suspending functions
+- [`KT-15907`](https://youtrack.jetbrains.com/issue/KT-15907) Bogus error about platform declaration clash with private suspend functions
+- [`KT-15933`](https://youtrack.jetbrains.com/issue/KT-15933) Suspend getValue/setValue/provideDelegate do not work properly
+- [`KT-15935`](https://youtrack.jetbrains.com/issue/KT-15935) Private suspend function in file causes UnsupportedOperationException: Context does not have a "this"
+- [`KT-15963`](https://youtrack.jetbrains.com/issue/KT-15963) Coroutine: runtime error if returned object "equals" does not like comparison to SUSPENDED_MARKER
+- [`KT-16068`](https://youtrack.jetbrains.com/issue/KT-16068) Prohibit inline lambda parameters of suspend function type
+
+#### Diagnostics
+- [`KT-1560`](https://youtrack.jetbrains.com/issue/KT-1560) Report diagnostic for a declaration of extension function which will be always shadowed by member function
+- [`KT-12846`](https://youtrack.jetbrains.com/issue/KT-12846) Forbid vararg of Nothing
+- [`KT-13227`](https://youtrack.jetbrains.com/issue/KT-13227) NO_ELSE_IN_WHEN in when by sealed class instance if is-check for base sealed class is used
+- [`KT-13355`](https://youtrack.jetbrains.com/issue/KT-13355) Type mismatch on inheritance is not reported on abstract class
+- [`KT-15010`](https://youtrack.jetbrains.com/issue/KT-15010) Missing error on an usage of non-constant property in annotation default argument 
+- [`KT-15201`](https://youtrack.jetbrains.com/issue/KT-15201) Compiler is complaining about when statement without null condition even if null is checked before.
+- [`KT-15736`](https://youtrack.jetbrains.com/issue/KT-15736) Report an error on type alias expanded to a nullable type on LHS of a class literal
+- [`KT-15740`](https://youtrack.jetbrains.com/issue/KT-15740) Report error on expression of a nullable type on LHS of a class literal
+- [`KT-15844`](https://youtrack.jetbrains.com/issue/KT-15844) Do not allow to access primary constructor parameters from property with custom getter
+- [`KT-15878`](https://youtrack.jetbrains.com/issue/KT-15878) Extension shadowed by member should not be reported for infix/operator extensions when member is non-infix/operator
+- [`KT-16010`](https://youtrack.jetbrains.com/issue/KT-16010) Do not highlight lambda parameters as unused in 1.0 compatibility mode
+
+#### Kapt
+- [`KT-15675`](https://youtrack.jetbrains.com/issue/KT-15675) Kapt3 does not generate classes annotated with AutoValue
+- [`KT-15697`](https://youtrack.jetbrains.com/issue/KT-15697) If an annotation with AnnotationTarget.PROPERTY is tagged on a Kotlin property, it breaks annotation processing
+- [`KT-15803`](https://youtrack.jetbrains.com/issue/KT-15803) Kotlin 1.0.6 broke Dagger
+- [`KT-15814`](https://youtrack.jetbrains.com/issue/KT-15814) Regression: Kapt is not working in 1.0.6 / 1.1-M04 / 1.1-Beta
+- [`KT-15838`](https://youtrack.jetbrains.com/issue/KT-15838) kapt3 1.1-beta: KaptError: Java file parsing error
+- [`KT-15841`](https://youtrack.jetbrains.com/issue/KT-15841) 1.1-Beta + kapt3 fails to build the project with StackOverflowError
+- [`KT-15915`](https://youtrack.jetbrains.com/issue/KT-15915) Kapt: Kotlin class target directory is cleared before compilation (and after kapt task)
+- [`KT-16006`](https://youtrack.jetbrains.com/issue/KT-16006) Cannot determine if type is an error type during annotation processing
+
+#### Exceptions / Errors
+- [`KT-8264`](https://youtrack.jetbrains.com/issue/KT-8264) Internal compiler error: java.lang.ArithmeticException: BigInteger: modulus not positive
+- [`KT-14547`](https://youtrack.jetbrains.com/issue/KT-14547) NoSuchElementException when compiling callable reference without stdlib in the classpath
+- [`KT-14966`](https://youtrack.jetbrains.com/issue/KT-14966) Regression: VerifyError on access super implementation from delegate 
+- [`KT-15017`](https://youtrack.jetbrains.com/issue/KT-15017) Throwing exception in the end of inline suspend-functions lead to internal compiler error
+- [`KT-15439`](https://youtrack.jetbrains.com/issue/KT-15439) Resolved call is not completed for generic callable reference in if-expression
+- [`KT-15500`](https://youtrack.jetbrains.com/issue/KT-15500) Exception passing freeCompilerArgs to gradle plugin
+- [`KT-15646`](https://youtrack.jetbrains.com/issue/KT-15646) InconsistentDebugInfoException when stepping over `throw`
+- [`KT-15726`](https://youtrack.jetbrains.com/issue/KT-15726) Kotlin compiles invalid bytecode for nested try-catch with return
+- [`KT-15743`](https://youtrack.jetbrains.com/issue/KT-15743) Overloaded Kotlin extensions annotates wrong parameters in java
+- [`KT-15868`](https://youtrack.jetbrains.com/issue/KT-15868) NPE when comparing nullable doubles for equality
+- [`KT-15995`](https://youtrack.jetbrains.com/issue/KT-15995) Can't build project with DataBinding using Kotlin 1.1: incompatible language version
+- [`KT-16047`](https://youtrack.jetbrains.com/issue/KT-16047) Internal Error: org.jetbrains.kotlin.util.KotlinFrontEndException while analyzing expression
+
+#### Type inference issues
+- [`KT-10268`](https://youtrack.jetbrains.com/issue/KT-10268) Wrong type inference related to captured types
+- [`KT-11259`](https://youtrack.jetbrains.com/issue/KT-11259) Wrong type inference for Java 8 Stream.collect.
+- [`KT-12802`](https://youtrack.jetbrains.com/issue/KT-12802) Type inference failed when irrelevant method reference is used
+- [`KT-12964`](https://youtrack.jetbrains.com/issue/KT-12964) Support type inference for callable references from parameter types of an expected function type
+
+#### Smart cast issues
+- [`KT-13468`](https://youtrack.jetbrains.com/issue/KT-13468) Smart cast is broken after assignment of 'if' expression
+- [`KT-14350`](https://youtrack.jetbrains.com/issue/KT-14350) Make smart-cast work as it does in 1.0 when -language-version 1.0 is used
+- [`KT-14597`](https://youtrack.jetbrains.com/issue/KT-14597) When over smartcast enum is broken and breaks all other "when"
+- [`KT-15792`](https://youtrack.jetbrains.com/issue/KT-15792) Wrong smart cast after y = x, x = null, y != null sequence
+
+#### Various issues
+- [`KT-15236`](https://youtrack.jetbrains.com/issue/KT-15236) False positive: Null can not be a value of a non-null type
+- [`KT-15677`](https://youtrack.jetbrains.com/issue/KT-15677) Modifiers and annotations are lost on a (nullable) parenthesized type
+- [`KT-15707`](https://youtrack.jetbrains.com/issue/KT-15707) IDEA unable to parallel compile different projects
+- [`KT-15734`](https://youtrack.jetbrains.com/issue/KT-15734) Nullability is lost during expansion of a type alias
+- [`KT-15748`](https://youtrack.jetbrains.com/issue/KT-15748) Type alias constructor return type should have a corresponding abbreviation
+- [`KT-15775`](https://youtrack.jetbrains.com/issue/KT-15775) Annotations are lost on value parameter types of a function type
+- [`KT-15780`](https://youtrack.jetbrains.com/issue/KT-15780) Treat Map.getOrDefault overrides in Java the same way as in 1.0.x compiler with language version 1.0
+- [`KT-15794`](https://youtrack.jetbrains.com/issue/KT-15794) Refine backward compatibility mode for additional built-ins members from JDK
+- [`KT-15848`](https://youtrack.jetbrains.com/issue/KT-15848) Implement additional annotation processing in the `KotlinScriptDefinitionFromAnnotatedTemplate` for SamWithReceiver plugin
+- [`KT-15875`](https://youtrack.jetbrains.com/issue/KT-15875) Operation has lead to overflow for 'mod' with negative first operand
+- [`KT-15945`](https://youtrack.jetbrains.com/issue/KT-15945) Feature Request: Andrey Breslav to grow a beard.
+
+### JavaScript backend
+
+#### Coroutine support
+- [`KT-15834`](https://youtrack.jetbrains.com/issue/KT-15834) JS: Local delegate in suspend function
+- [`KT-15892`](https://youtrack.jetbrains.com/issue/KT-15892) JS: safe call of suspend functions causes compiler to crash
+
+#### Diagnostics
+- [`KT-14668`](https://youtrack.jetbrains.com/issue/KT-14668) Do not allow declarations in 'kotlin' package or subpackages in JS
+- [`KT-15184`](https://youtrack.jetbrains.com/issue/KT-15184) JS: prohibit `..` operation with `dynamic` on left-hand side
+- [`KT-15253`](https://youtrack.jetbrains.com/issue/KT-15253) JS: no error when use class external class with JsModule in type context when compiling with plain module kind
+- [`KT-15283`](https://youtrack.jetbrains.com/issue/KT-15283) JS: additional restrictions on dynamic
+- [`KT-15961`](https://youtrack.jetbrains.com/issue/KT-15961) Could not implement external open class with function with optional parameter
+
+#### Language feature support
+- [`KT-14035`](https://youtrack.jetbrains.com/issue/KT-14035) JS: support implementing CharSequence
+- [`KT-14036`](https://youtrack.jetbrains.com/issue/KT-14036) JS: use Int16 for Char when it possible and box to our Char otherwise
+- [`KT-14097`](https://youtrack.jetbrains.com/issue/KT-14097) Wrong code generated for enum entry initialization using non-primary no-argument constructor
+- [`KT-15312`](https://youtrack.jetbrains.com/issue/KT-15312) JS: map kotlin.Throwable to JS Error
+- [`KT-15765`](https://youtrack.jetbrains.com/issue/KT-15765) JS: support callable references on built-in and intrinsic functions and properties
+- [`KT-15900`](https://youtrack.jetbrains.com/issue/KT-15900) JS: Support enum entry with empty initializer with vararg constructor
+
+#### Standard library support
+- [`KT-4141`](https://youtrack.jetbrains.com/issue/KT-4141) JS: wrong return type for Date::getTime
+- [`KT-4497`](https://youtrack.jetbrains.com/issue/KT-4497) JS: add String.toInt, String.toDouble etc extension functions, `parseInt` and `parseFloat` are deprecated in favor of these new ones
+- [`KT-15940`](https://youtrack.jetbrains.com/issue/KT-15940) JS: rename all js standard library artifacts (both in maven and in compiler distribution) to `kotlin-stdlib-js.jar`
+- Add `Promise<T>` external declaration to the standard library
+- Types like `Date`, `Math`, `Console`, `Promise`, `RegExp`, `Json` require explicit import from `kotlin.js` package
+
+#### External declarations
+- [`KT-15144`](https://youtrack.jetbrains.com/issue/KT-15144) JS: rename `noImpl` to `definedExternally`
+- [`KT-15306`](https://youtrack.jetbrains.com/issue/KT-15306) JS: allow to use `definedExternally` only inside a body of external declarations
+- [`KT-15336`](https://youtrack.jetbrains.com/issue/KT-15336) JS: allow to inherit external classes from kotlin.Throwable
+- [`KT-15905`](https://youtrack.jetbrains.com/issue/KT-15905) JS: add a way to control qualifier for external declarations inside file
+- Deprecate `@native` annotation, to be removed in 1.1 release.
+
+#### Exceptions / Errors
+- [`KT-10894`](https://youtrack.jetbrains.com/issue/KT-10894) Infinite indexing at projects with JS modules
+- [`KT-14124`](https://youtrack.jetbrains.com/issue/KT-14124) AssertionError: strings file not found on K2JS serialized data
+ 
+#### Various issues
+- [`KT-8211`](https://youtrack.jetbrains.com/issue/KT-8211) JS: generate dummy init for properties w/o initializer to avoid to have different hidden classes for different instances
+- [`KT-12712`](https://youtrack.jetbrains.com/issue/KT-12712) JS: Json should not be a class
+- [`KT-13312`](https://youtrack.jetbrains.com/issue/KT-13312) JS: can't use extension lambda where expected lambda and vice versa
+- [`KT-13632`](https://youtrack.jetbrains.com/issue/KT-13632) Add template kotlin js project under gradle in "New Project" window
+- [`KT-15278`](https://youtrack.jetbrains.com/issue/KT-15278) JS: don't treat property access through dynamic as side effect free
+- [`KT-15285`](https://youtrack.jetbrains.com/issue/KT-15285) JS: take into account as many characteristics from the signature as possible when mangling
+- [`KT-15678`](https://youtrack.jetbrains.com/issue/KT-15678) JS: Generated local variable named 'element' clashes with actual local variable named 'element'
+- [`KT-15755`](https://youtrack.jetbrains.com/issue/KT-15755) JS compiler produces a lot of empty kotlin_file_table files for irrelevant packages
+- [`KT-15770`](https://youtrack.jetbrains.com/issue/KT-15770) Name clash between recursive local functions with same name
+- [`KT-15797`](https://youtrack.jetbrains.com/issue/KT-15797) JS: wrong code for accessing nested class inside js module
+- [`KT-15863`](https://youtrack.jetbrains.com/issue/KT-15863) JS: Extension function reference shifts parameters loosing the receiver
+- [`KT-16049`](https://youtrack.jetbrains.com/issue/KT-16049) JS: drop "-kjsm" command line option, merge the logic into "-meta-info"
+- [`KT-16083`](https://youtrack.jetbrains.com/issue/KT-16083) JS: rename "-library-files" argument to "-libraries" and change separator from comma to system file separator
+
+### Standard Library
+- [`KT-13353`](https://youtrack.jetbrains.com/issue/KT-13353) Add Map.minus(key) and Map.minus(keys) 
+- [`KT-13826`](https://youtrack.jetbrains.com/issue/KT-13826) Add parameter names in function types used in the standard library
+- [`KT-14279`](https://youtrack.jetbrains.com/issue/KT-14279) Make String.matches(Regex) and Regex.matches(String) infix
+- [`KT-15399`](https://youtrack.jetbrains.com/issue/KT-15399) Iterable.average() now returns NaN for an empty collection
+- [`KT-15975`](https://youtrack.jetbrains.com/issue/KT-15975) Move coroutine-related runtime parts to `kotlin.coroutines.experimental` package
+- [`KT-16030`](https://youtrack.jetbrains.com/issue/KT-16030) Move bitwise operations on Byte and Short to `kotlin.experimental` package
+- [`KT-16026`](https://youtrack.jetbrains.com/issue/KT-16026) Classes compiled in 1.1 in 1.0-compatibility mode may contain references to CloseableKt class from 1.1
+
+### IDE
+
+#### Configuration issues
+- [`KT-15621`](https://youtrack.jetbrains.com/issue/KT-15621) Copy compiler options values from project settings on creating a kotlin facet for Kotlin (JVM) project
+- [`KT-15623`](https://youtrack.jetbrains.com/issue/KT-15623) Copy compiler options values from project settings on creating a kotlin facet for Kotlin (JavaScript) project
+- [`KT-15624`](https://youtrack.jetbrains.com/issue/KT-15624) Set option "Use project settings" in newly created Kotlin facet
+- [`KT-15712`](https://youtrack.jetbrains.com/issue/KT-15712) Configuring a project with Maven or Gradle should automatically use stdlib-jre7 or stdlib-jre8 instead of standard stdlib
+- [`KT-15772`](https://youtrack.jetbrains.com/issue/KT-15772) Facet does not pick up api version from maven
+- [`KT-15819`](https://youtrack.jetbrains.com/issue/KT-15819) It would be nice if compileKotlin options are imported into Kotlin facet from gradle/maven
+- [`KT-16015`](https://youtrack.jetbrains.com/issue/KT-16015) Prohibit api-version > language-version in Facet and Project Settings
+
+#### Coroutine support
+- [`KT-14704`](https://youtrack.jetbrains.com/issue/KT-14704) Extract Method should work in coroutines
+- [`KT-15955`](https://youtrack.jetbrains.com/issue/KT-15955) Quick-fix to enable coroutines through Gradle project configuration
+- [`KT-16018`](https://youtrack.jetbrains.com/issue/KT-16018) Hide coroutines intrinsics from import and completion
+- [`KT-16075`](https://youtrack.jetbrains.com/issue/KT-16075) Error:Kotlin: The -Xcoroutines can only have one value
+
+#### Backward compatibility issues
+- [`KT-15134`](https://youtrack.jetbrains.com/issue/KT-15134) Do not suggest using destructuring lambda if this will result in "available since 1.1" error
+- [`KT-15918`](https://youtrack.jetbrains.com/issue/KT-15918) Quick fix "Set module language level to 1.1" should also set API version to 1.1
+- [`KT-15969`](https://youtrack.jetbrains.com/issue/KT-15969) Replace operator with function should use either rem or mod for % depending on language version
+- [`KT-15978`](https://youtrack.jetbrains.com/issue/KT-15978) Type alias from Kotlin 1.1 are suggested in completion even if language level is set to 1.0 in settings
+- [`KT-15979`](https://youtrack.jetbrains.com/issue/KT-15979) Usages of type aliases are not shown as errors in editor if language version is set to 1.0
+- [`KT-16019`](https://youtrack.jetbrains.com/issue/KT-16019) Do not suggest renaming to underscore in 1.0 compatibility mode
+- [`KT-16036`](https://youtrack.jetbrains.com/issue/KT-16036) "Create type alias from usage" quick-fix should not be suggested at language level 1.0
+
+#### Intention actions, inspections and quick-fixes
+
+##### New features
+- [`KT-9912`](https://youtrack.jetbrains.com/issue/KT-9912) Merge ifs intention
+- [`KT-13427`](https://youtrack.jetbrains.com/issue/KT-13427) "Specify type explicitly" should support type aliases
+- [`KT-15066`](https://youtrack.jetbrains.com/issue/KT-15066) "Make private/.." intention on type aliases
+- [`KT-15709`](https://youtrack.jetbrains.com/issue/KT-15709) Add inspection for private primary constructors in data classes as they are accessible via the copy method
+- [`KT-15738`](https://youtrack.jetbrains.com/issue/KT-15738) Intention to add `suspend` modifier to functional type
+- [`KT-15800`](https://youtrack.jetbrains.com/issue/KT-15800) Quick-fix to convert a function to suspending on error when calling suspension inside
+
+##### Bug fixes
+- [`KT-13710`](https://youtrack.jetbrains.com/issue/KT-13710) Import intention action should not appear in import list
+- [`KT-14680`](https://youtrack.jetbrains.com/issue/KT-14680) import statement to type alias reported as unused when using only TA constructor
+- [`KT-14856`](https://youtrack.jetbrains.com/issue/KT-14856) TextView internationalisation intention does not report the problem
+- [`KT-14993`](https://youtrack.jetbrains.com/issue/KT-14993) Keep destructuring declaration parameter on inspection "Remove explicit lambda parameter types"
+- [`KT-14994`](https://youtrack.jetbrains.com/issue/KT-14994) PsiInvalidElementAccessException and incorrect generation on inspection "Specify type explicitly" on destructuring parameter
+- [`KT-15162`](https://youtrack.jetbrains.com/issue/KT-15162) "Remove explicit lambda parameter types" intentions fails with destructuring declaration with KNPE at KtPsiFactory.createLambdaParameterList()
+- [`KT-15311`](https://youtrack.jetbrains.com/issue/KT-15311) "Add Import" intention generates incorrect code
+- [`KT-15406`](https://youtrack.jetbrains.com/issue/KT-15406) Convert to secondary constructor for enum class should put new members after enum values
+- [`KT-15553`](https://youtrack.jetbrains.com/issue/KT-15553) Copy concatenation text to clipboard with Kotlin and string interpolation does not work
+- [`KT-15670`](https://youtrack.jetbrains.com/issue/KT-15670) 'Convert to lambda' quick fix in IDEA leaves single-line comment and } gets commented out
+- [`KT-15873`](https://youtrack.jetbrains.com/issue/KT-15873) Alt+Enter menu isn't shown for deprecated mod function
+- [`KT-15874`](https://youtrack.jetbrains.com/issue/KT-15874) Replace operator with function call replaces % with deprecated mod
+- [`KT-15884`](https://youtrack.jetbrains.com/issue/KT-15884) False positive "Redundant .let call"
+- [`KT-16072`](https://youtrack.jetbrains.com/issue/KT-16072) Intentions to convert suspend lambdas to callable references should not be shown
+
+#### Android support
+- [`KT-13275`](https://youtrack.jetbrains.com/issue/KT-13275) Kotlin Gradle plugin for Android does not work when jackOptions enabled
+- [`KT-15150`](https://youtrack.jetbrains.com/issue/KT-15150) Android: Add quick-fix to generate View constructor convention
+- [`KT-15282`](https://youtrack.jetbrains.com/issue/KT-15282) Issues debugging crossinline Android code
+
+#### KDoc
+- [`KT-14710`](https://youtrack.jetbrains.com/issue/KT-14710) Sample references are not resolved in IDE
+- [`KT-15796`](https://youtrack.jetbrains.com/issue/KT-15796) Import of class referenced only in KDoc not preserved after copy-paste
+
+#### Various issues
+- [`KT-9011`](https://youtrack.jetbrains.com/issue/KT-9011) Shift+Enter should insert curly braces when invoked after class declaration
+- [`KT-11308`](https://youtrack.jetbrains.com/issue/KT-11308) Hide kotlin.jvm.internal package contents from completion and auto-import
+- [`KT-14252`](https://youtrack.jetbrains.com/issue/KT-14252) Completion could suggest constructors available via type aliases
+- [`KT-14722`](https://youtrack.jetbrains.com/issue/KT-14722) Completion list isn't filled up for type alias to object
+- [`KT-14767`](https://youtrack.jetbrains.com/issue/KT-14767) Type alias to annotation class should appear in the completion list
+- [`KT-14859`](https://youtrack.jetbrains.com/issue/KT-14859) "Parameter Info" sometimes does not work properly inside lambda
+- [`KT-15032`](https://youtrack.jetbrains.com/issue/KT-15032) Injected fragment: descriptor was not found for declaration: FUN
+- [`KT-15153`](https://youtrack.jetbrains.com/issue/KT-15153) Support typeAlias extensions in completion and add import
+- [`KT-15786`](https://youtrack.jetbrains.com/issue/KT-15786) NoSuchMethodError: com.intellij.util.containers.UtilKt.isNullOrEmpty
+- [`KT-15883`](https://youtrack.jetbrains.com/issue/KT-15883) Generating equals() and hashCode(): hashCode does not correctly honor variable names with back ticks
+- [`KT-15911`](https://youtrack.jetbrains.com/issue/KT-15911) Kotlin REPL will not launch: "Neither main class nor JAR path is specified"
+
+### J2K
+- [`KT-15789`](https://youtrack.jetbrains.com/issue/KT-15789) Kotlin plugin incorrectly converts for-loops from Java to Kotlin
+
+### Gradle support
+- [`KT-14830`](https://youtrack.jetbrains.com/issue/KT-14830) Kotlin Gradle plugin configuration should not add 'kotlin' source directory by default
+- [`KT-15279`](https://youtrack.jetbrains.com/issue/KT-15279) 'Kotlin not configured message' should not be displayed while gradle sync is in progress
+- [`KT-15812`](https://youtrack.jetbrains.com/issue/KT-15812) Create Kotlin facet on importing gradle project with unchecked option Create separate module per source set
+- [`KT-15837`](https://youtrack.jetbrains.com/issue/KT-15837) Gradle compiler attempts to connect to daemon on address derived from DNS lookup
+- [`KT-15909`](https://youtrack.jetbrains.com/issue/KT-15909) Copy Gradle compiler options to facets in Intellij/AS
+- [`KT-15929`](https://youtrack.jetbrains.com/issue/KT-15929) Gradle project imported with wrong 'target platform'
+
+### Other issues
+- [`KT-15450`](https://youtrack.jetbrains.com/issue/KT-15450) JSR 223 - support eval with bindings
+
+
+## 1.1.0-Beta
+
+### Reflection
+- [`KT-15540`](https://youtrack.jetbrains.com/issue/KT-15540) findAnnotation returns T?, but it throws NoSuchElementException when there is no matching annotation
+- Reflection API in `kotlin-reflect` library is moved to `kotlin.reflect.full` package, declarations in the package `kotlin.reflect` are left deprecated. Please migrate according to the hints provided.
+
+### Compiler
+
+#### Coroutine support
+- [`KT-15379`](https://youtrack.jetbrains.com/issue/KT-15379) Allow invoke on instances of suspend function type inside suspend function
+- [`KT-15380`](https://youtrack.jetbrains.com/issue/KT-15380) Support suspend function type with value parameters
+- [`KT-15391`](https://youtrack.jetbrains.com/issue/KT-15391) Prohibit suspend function type in supertype list
+- [`KT-15392`](https://youtrack.jetbrains.com/issue/KT-15392) Prohibit local suspending function
+- [`KT-15413`](https://youtrack.jetbrains.com/issue/KT-15413) Override regular functions with suspending ones and vice versa
+- [`KT-15657`](https://youtrack.jetbrains.com/issue/KT-15657) Refine dispatchResume convention
+- [`KT-15662`](https://youtrack.jetbrains.com/issue/KT-15662) Prohibit callable references to suspend functions
+
+#### Diagnostics
+- [`KT-9630`](https://youtrack.jetbrains.com/issue/KT-9630) Cannot create extension function on intersection of types
+- [`KT-11398`](https://youtrack.jetbrains.com/issue/KT-11398) Possible false positive for INACCESSIBLE_TYPE
+- [`KT-13593`](https://youtrack.jetbrains.com/issue/KT-13593) Do not report USELESS_ELVIS_RIGHT_IS_NULL for left argument with platform type
+- [`KT-13859`](https://youtrack.jetbrains.com/issue/KT-13859) Wrong error about using unrepeatable annotation when mix implicit and explicit targets
+- [`KT-14179`](https://youtrack.jetbrains.com/issue/KT-14179) Prohibit to use enum entry as type parameter
+- [`KT-15097`](https://youtrack.jetbrains.com/issue/KT-15097) Inherited platform declarations clash: regression under 1.1 when indirectly inheriting from java.util.Map
+- [`KT-15287`](https://youtrack.jetbrains.com/issue/KT-15287) Kotlin runtime 1.1 and runtime 1.0.x:  Overload resolution ambiguity
+- [`KT-15334`](https://youtrack.jetbrains.com/issue/KT-15334) Incorrect "val cannot be reassigned" inside do-while
+- [`KT-15410`](https://youtrack.jetbrains.com/issue/KT-15410) "Protected function call from public-API inline function" for protected constructor call
+
+#### Kapt3
+- [`KT-15145`](https://youtrack.jetbrains.com/issue/KT-15145) Kapt3: Doesn't compile with multiple errors 
+- [`KT-15232`](https://youtrack.jetbrains.com/issue/KT-15232) Kapt3 crash due to java codepage
+- [`KT-15359`](https://youtrack.jetbrains.com/issue/KT-15359) Kapt3 exception while annotation processing (DataBindings AS2.3-beta1)
+- [`KT-15375`](https://youtrack.jetbrains.com/issue/KT-15375) Kapt3 can't find ${env.JDK_18}/lib/tools.jar
+- [`KT-15381`](https://youtrack.jetbrains.com/issue/KT-15381) Unresolved references: R with Kapt3
+- [`KT-15397`](https://youtrack.jetbrains.com/issue/KT-15397) Kapt3 doesn't work with databinding
+- [`KT-15409`](https://youtrack.jetbrains.com/issue/KT-15409) Kapt3 Cannot find the getter for attribute 'android:text' with value type java.lang.String on android.widget.EditText.
+- [`KT-15421`](https://youtrack.jetbrains.com/issue/KT-15421) Kapt3: Substitute types from Psi instead of writing NonExistentClass for generated type names
+- [`KT-15459`](https://youtrack.jetbrains.com/issue/KT-15459) Kapt3 doesn't generate code in test module
+- [`KT-15524`](https://youtrack.jetbrains.com/issue/KT-15524) Kapt3 - Error messages should display associated element information (if available)
+- [`KT-15713`](https://youtrack.jetbrains.com/issue/KT-15713) Kapt3: circular dependencies between Gradke tasks
+
+#### Exceptions / Errors
+- [`KT-11401`](https://youtrack.jetbrains.com/issue/KT-11401) Error type encountered for implicit invoke with function literal argument
+- [`KT-12044`](https://youtrack.jetbrains.com/issue/KT-12044) Assertion "Rewrite at slice LEXICAL_SCOPE" for 'if' with property references 
+- [`KT-14011`](https://youtrack.jetbrains.com/issue/KT-14011) Compiler crash when inlining: lateinit property allRecapturedParameters has not been initialized
+- [`KT-14868`](https://youtrack.jetbrains.com/issue/KT-14868) CCE in runtime while converting Number to Char
+- [`KT-15364`](https://youtrack.jetbrains.com/issue/KT-15364) VerifyError: Bad type on operand stack on ObserverIterator.hasNext
+- [`KT-15373`](https://youtrack.jetbrains.com/issue/KT-15373) Internal error when running TestNG test
+- [`KT-15437`](https://youtrack.jetbrains.com/issue/KT-15437) VerifyError: Bad local variable type on simplest provideDelegate
+- [`KT-15446`](https://youtrack.jetbrains.com/issue/KT-15446) Property reference on an instance of subclass causes java.lang.VerifyError
+- [`KT-15447`](https://youtrack.jetbrains.com/issue/KT-15447) Compiler backend error: "Don't know how to generate outer expression for class"
+- [`KT-15449`](https://youtrack.jetbrains.com/issue/KT-15449) Back-end (JVM) Internal error: Couldn't inline method call
+- [`KT-15464`](https://youtrack.jetbrains.com/issue/KT-15464) Regression: "Supertypes of the following classes cannot be resolved. Please make sure you have the required dependencies in the classpath:"
+- [`KT-15575`](https://youtrack.jetbrains.com/issue/KT-15575) VerifyError: Bad type on operand stack
+
+#### Various issues
+- [`KT-11962`](https://youtrack.jetbrains.com/issue/KT-11962) Super call with default parameters check is generated for top-level function
+- [`KT-11969`](https://youtrack.jetbrains.com/issue/KT-11969) ProGuard issue with private interface methods
+- [`KT-12795`](https://youtrack.jetbrains.com/issue/KT-12795) Write information about sealed class inheritors to metadata
+- [`KT-13718`](https://youtrack.jetbrains.com/issue/KT-13718) ClassFormatError on aspectj instrumentation
+- [`KT-14162`](https://youtrack.jetbrains.com/issue/KT-14162) Support @InlineOnly on inline properties
+- [`KT-14705`](https://youtrack.jetbrains.com/issue/KT-14705) Inconsistent smart casts on when enum subject
+- [`KT-14917`](https://youtrack.jetbrains.com/issue/KT-14917) No way to pass additional java command line options to kontlinc on Windows
+- [`KT-15112`](https://youtrack.jetbrains.com/issue/KT-15112) Compiler hangs on nested lock compilation
+- [`KT-15225`](https://youtrack.jetbrains.com/issue/KT-15225) Scripts: generate classes with names that are valid Java identifiers
+- [`KT-15411`](https://youtrack.jetbrains.com/issue/KT-15411) Unnecessary CHECKCAST bytecode when dealing with null
+- [`KT-15473`](https://youtrack.jetbrains.com/issue/KT-15473) Invalid KFunction byte code signature for callable references
+- [`KT-15582`](https://youtrack.jetbrains.com/issue/KT-15582) Generated bytecode is sometimes incompatible with Java 9
+- [`KT-15584`](https://youtrack.jetbrains.com/issue/KT-15584) Do not mark class files compiled with a release language version as pre-release
+- [`KT-15589`](https://youtrack.jetbrains.com/issue/KT-15589) Upper bound for T in KClass<T> can be implicitly violated using generic function
+- [`KT-15631`](https://youtrack.jetbrains.com/issue/KT-15631) Compiler hang in MethodAnalyzer.analyze() fixed 
+
+### JavaScript backend
+
+#### Coroutine support
+- [`KT-15362`](https://youtrack.jetbrains.com/issue/KT-15362) JS: Regex doesn't work (properly) in coroutine
+- [`KT-15366`](https://youtrack.jetbrains.com/issue/KT-15366) JS: error when calling inline function with optional parameters from another module inside coroutine lambda
+- [`KT-15367`](https://youtrack.jetbrains.com/issue/KT-15367) JS: `for` against iterator with suspend `next` and `hasNext` functions does not work
+- [`KT-15400`](https://youtrack.jetbrains.com/issue/KT-15400) suspendCoroutine is missing in JS BE
+- [`KT-15597`](https://youtrack.jetbrains.com/issue/KT-15597) Support non-tail suspend calls inside named suspend functions 
+- [`KT-15625`](https://youtrack.jetbrains.com/issue/KT-15625) JS: return statement without value surrounded by `try..finally` in suspend lambda causes compiler error
+- [`KT-15698`](https://youtrack.jetbrains.com/issue/KT-15698) Move coroutine intrinsics to kotlin.coroutine.intrinsics package
+
+#### Diagnostics
+- [`KT-14577`](https://youtrack.jetbrains.com/issue/KT-14577) JS: do not report declaration clash when common redeclaration diagnostic applies
+- [`KT-15136`](https://youtrack.jetbrains.com/issue/KT-15136) JS: prohibit inheritance from kotlin Function{N} interfaces
+
+#### Language features support
+- [`KT-12194`](https://youtrack.jetbrains.com/issue/KT-12194) Exhaustiveness check isn't generated for when expressions in JS at all
+- [`KT-15590`](https://youtrack.jetbrains.com/issue/KT-15590) Support increment on inlined properties
+ 
+#### Native / external
+- [`KT-8081`](https://youtrack.jetbrains.com/issue/KT-8081) JS: native inherited class shouldn't require super or primary constructor call
+- [`KT-13892`](https://youtrack.jetbrains.com/issue/KT-13892) JS: restrictions for native (external) functions and properties
+- [`KT-15307`](https://youtrack.jetbrains.com/issue/KT-15307) JS: prohibit inline members inside external declarations
+- [`KT-15308`](https://youtrack.jetbrains.com/issue/KT-15308) JS: prohibit non-abstract members inside external interfaces except nullable properties (with accessors)
+
+#### Exceptions / Errors
+- [`KT-7302`](https://youtrack.jetbrains.com/issue/KT-7302) KotlinJS - Trait with optional parameter causes compilation error
+- [`KT-15325`](https://youtrack.jetbrains.com/issue/KT-15325) JS: ReferenceError: $receiver is not defined
+- [`KT-15357`](https://youtrack.jetbrains.com/issue/KT-15357) JS: `when` expression in primary-from-secondary constructor call
+- [`KT-15435`](https://youtrack.jetbrains.com/issue/KT-15435) Call to 'synchronize' crashes JS backend
+- [`KT-15513`](https://youtrack.jetbrains.com/issue/KT-15513) JS: empty do..while loop crashes compiler
+
+#### Various issues
+- [`KT-4160`](https://youtrack.jetbrains.com/issue/KT-4160) JS: compiler produces wrong code for escaped variable names with characters which Illegal in JS (e.g. spaces)
+- [`KT-7004`](https://youtrack.jetbrains.com/issue/KT-7004) JS: functions named `call` not inlined
+- [`KT-7588`](https://youtrack.jetbrains.com/issue/KT-7588) JS: operators are not inlined
+- [`KT-7733`](https://youtrack.jetbrains.com/issue/KT-7733) JS: Provide overflow behavior for integer arithmetic operations
+- [`KT-8413`](https://youtrack.jetbrains.com/issue/KT-8413) JS: generated wrong code for some float constants
+- [`KT-12598`](https://youtrack.jetbrains.com/issue/KT-12598) JS: comparisons for Enums always translates using strong operator
+- [`KT-13523`](https://youtrack.jetbrains.com/issue/KT-13523) Augmented assignment with array access in LHS is translated incorrectly
+- [`KT-13888`](https://youtrack.jetbrains.com/issue/KT-13888) JS: change how functions optional parameters get translated
+- [`KT-15260`](https://youtrack.jetbrains.com/issue/KT-15260) JS: don't import module more than once
+- [`KT-15475`](https://youtrack.jetbrains.com/issue/KT-15475) JS compiler deletes internal function name in js("") text block
+- [`KT-15506`](https://youtrack.jetbrains.com/issue/KT-15506) JS: invalid evaluation order when passing arguments to function by name
+- [`KT-15512`](https://youtrack.jetbrains.com/issue/KT-15512) JS: wrong result when use break/throw/return in || and && operators
+- [`KT-15569`](https://youtrack.jetbrains.com/issue/KT-15569) js: Wrong code generated when calling an overloaded operator function on an inherited property
+
+### Standard Library
+- [`KEEP-23`](https://github.com/Kotlin/KEEP/blob/master/proposals/stdlib/group-and-fold.md) Operation to group by key and fold each group simultaneously
+- [`KT-15774`](https://youtrack.jetbrains.com/issue/KT-15774) `buildSequence` and `buildIterator` functions with `yield` and `yieldAll` based on coroutines
+- [`KT-6903`](https://youtrack.jetbrains.com/issue/KT-6903) Add `also` extension, which is like `apply`, but with `it` instead of `this` inside lambda.
+- [`KT-7858`](https://youtrack.jetbrains.com/issue/KT-7858) Add extension function `takeIf` to match a value against predicate and return null when it does not match
+- [`KT-11851`](https://youtrack.jetbrains.com/issue/KT-11851) Provide extension `Map.getValue(key: K): V` which throws or returns default when key is not found
+- [`KT-7417`](https://youtrack.jetbrains.com/issue/KT-7417) Add min, max on two numbers to standard library
+- [`KT-13898`](https://youtrack.jetbrains.com/issue/KT-13898) Allow to implement `toArray` in collections as protected and provide protected toArray in AbstractCollection.
+- [`KT-14935`](https://youtrack.jetbrains.com/issue/KT-14935) Array-like list instantiation functions: `List(count) { init }` and `MutableList(count) { init }` 
+- [`KT-15630`](https://youtrack.jetbrains.com/issue/KT-15630) Overloads of mutableListOf, mutableSetOf, mutableMapOf without parameters
+- [`KT-15557`](https://youtrack.jetbrains.com/issue/KT-15557) Iterable<T>.joinTo loses information about each element by calling toString on them by default
+- [`KT-15477`](https://youtrack.jetbrains.com/issue/KT-15477) Introduce Throwable.addSuppressed extension
+- [`KT-15310`](https://youtrack.jetbrains.com/issue/KT-15310) Add dynamic.unsafeCast
+- [`KT-15436`](https://youtrack.jetbrains.com/issue/KT-15436) JS stdlib: org.w3c.fetch.RequestInit has 12 parameters, all required
+- [`KT-15458`](https://youtrack.jetbrains.com/issue/KT-15458) Add print and println to common stdlib
+
+### IDE
+- Project View: Fix presentation of Kotlin files and their members when @JvmName having the same name as the file itself
+
+#### no-arg / all-open
+- [`KT-15419`](https://youtrack.jetbrains.com/issue/KT-15419) IDE build doesn't pick settings of all-open plugin
+- [`KT-15686`](https://youtrack.jetbrains.com/issue/KT-15686) IDE build doesn't pick settings of no-arg plugin
+- [`KT-15735`](https://youtrack.jetbrains.com/issue/KT-15735) Facet loses compiler plugin settings on reopening project, when "Use project settings" = Yes
+
+#### Formatter
+- [`KT-15542`](https://youtrack.jetbrains.com/issue/KT-15542) Formatter doesn't handle spaces around 'by' keyword
+- [`KT-15544`](https://youtrack.jetbrains.com/issue/KT-15544) Formatter doesn't remove spaces around function reference operator
+
+#### Intention actions, inspections and quick-fixes
+
+##### New features
+- Implement quickfix which enables/disables coroutine support in module or project
+- [`KT-5045`](https://youtrack.jetbrains.com/issue/KT-5045) Intention to convert between two comparisons and range check and vice versa
+- [`KT-5629`](https://youtrack.jetbrains.com/issue/KT-5629) Quick-fix to import extension method when arguments of non-extension method do not match
+- [`KT-6217`](https://youtrack.jetbrains.com/issue/KT-6217) Add warning for unused equals expression
+- [`KT-6824`](https://youtrack.jetbrains.com/issue/KT-6824) Quick-fix for applying spread operator where vararg is expected
+- [`KT-8855`](https://youtrack.jetbrains.com/issue/KT-8855) Implement "Create label" quick-fix
+- [`KT-15056`](https://youtrack.jetbrains.com/issue/KT-15056) Implement intention which converts object literal to class
+- [`KT-15068`](https://youtrack.jetbrains.com/issue/KT-15068) Implement intention which rename file according to the top-level class name
+- [`KT-15564`](https://youtrack.jetbrains.com/issue/KT-15564) Add quick-fix for changing primitive cast to primitive conversion method
+
+##### Bug fixes
+- [`KT-14630`](https://youtrack.jetbrains.com/issue/KT-14630) Clearer diagnostic message for platform type inspection
+- [`KT-14745`](https://youtrack.jetbrains.com/issue/KT-14745) KNPE in convert primary constructor to secondary
+- [`KT-14889`](https://youtrack.jetbrains.com/issue/KT-14889) Replace 'if' with elvis operator produces red code if result is referenced in 'if'
+- [`KT-14907`](https://youtrack.jetbrains.com/issue/KT-14907) Quick-fix for missing operator adds infix modifier to created function
+- [`KT-15092`](https://youtrack.jetbrains.com/issue/KT-15092) Suppress inspection "use property access syntax" for some getters and fix completion for them
+- [`KT-15227`](https://youtrack.jetbrains.com/issue/KT-15227) "Replace if with elvis" silently changes semantics
+- [`KT-15412`](https://youtrack.jetbrains.com/issue/KT-15412) "Join declaration and assignment" can break code with smart casts
+- [`KT-15501`](https://youtrack.jetbrains.com/issue/KT-15501) Intention "Add names to call arguments" shouldn't appear when the only argument is a trailing lambda
+
+#### Refactorings (Extract / Pull)
+- [`KT-15611`](https://youtrack.jetbrains.com/issue/KT-15611) Extract Interface/Superclass: Disable const-properties
+- Pull Up: Fix pull-up from object to superclass
+- [`KT-15602`](https://youtrack.jetbrains.com/issue/KT-15602) Extract Interface/Superclass: Disable "Make abstract" for inline/external/lateinit members
+- Extract Interface: Disable inline/external/lateinit members
+- [`KT-12704`](https://youtrack.jetbrains.com/issue/KT-12704), [`KT-15583`](https://youtrack.jetbrains.com/issue/KT-15583) Override/Implement Members: Support all nullability annotations respected by the Kotlin compiler
+- [`KT-15563`](https://youtrack.jetbrains.com/issue/KT-15563) Override Members: Allow overriding virtual synthetic members (e.g. equals(), hashCode(), toString(), etc.) in data classes
+- [`KT-15355`](https://youtrack.jetbrains.com/issue/KT-15355) Extract Interface: Disable "Make abstract" and assume it to be true for abstract members of an interface
+- [`KT-15353`](https://youtrack.jetbrains.com/issue/KT-15353) Extract Superclass/Interface: Allow extracting class with special name (and quotes)
+- [`KT-15643`](https://youtrack.jetbrains.com/issue/KT-15643) Extract Interface/Pull Up: Disable "Make abstract" and assume it to be true for primary constructor parameter when moving to an interface
+- [`KT-15607`](https://youtrack.jetbrains.com/issue/KT-15607) Extract Interface/Pull Up: Disable internal/protected members when moving to an interface
+- [`KT-15640`](https://youtrack.jetbrains.com/issue/KT-15640) Extract Interface/Pull Up: Drop 'final' modifier when moving to an interface
+- [`KT-15639`](https://youtrack.jetbrains.com/issue/KT-15639) Extract Superclass/Interface/Pull Up: Add spaces between 'abstract' modifier and annotations
+- [`KT-15606`](https://youtrack.jetbrains.com/issue/KT-15606) Extract Interface/Pull Up: Warn about private members with usages in the original class
+- [`KT-15635`](https://youtrack.jetbrains.com/issue/KT-15635) Extract Superclass/Interface: Fix bogus visibility warning inside a member when it's being moved as abstract
+- [`KT-15598`](https://youtrack.jetbrains.com/issue/KT-15598) Extract Interface: Red-highlight members inherited from a super-interface when that interface reference itself is not extracted
+- [`KT-15674`](https://youtrack.jetbrains.com/issue/KT-15674) Extract Superclass: Drop inapplicable modifiers when converting property-parameter to ordinary parameter
+
+#### Multi-platform project support
+- [`KT-14908`](https://youtrack.jetbrains.com/issue/KT-14908) Actions (quick-fixes) to create implementations of header elements
+- [`KT-15305`](https://youtrack.jetbrains.com/issue/KT-15305) Do not report UNUSED for header declarations with implementations and vice versa
+- [`KT-15601`](https://youtrack.jetbrains.com/issue/KT-15601) Cannot suppress HEADER_WITHOUT_IMPLEMENTATION
+- [`KT-15641`](https://youtrack.jetbrains.com/issue/KT-15641) Quick-fix "Create header interface implementation" does nothing
+
+#### Android support
+
+- [`KT-12884`](https://youtrack.jetbrains.com/issue/KT-12884) Android Extensions: Refactor / Rename of activity name does not change import extension statement
+- [`KT-14308`](https://youtrack.jetbrains.com/issue/KT-14308) Android Studio randomly hangs due to Java static member import quick-fix lags
+- [`KT-14358`](https://youtrack.jetbrains.com/issue/KT-14358) Kotlin extensions: rename layout file: Throwable: "PSI and index do not match" through KotlinFullClassNameIndex.get()
+- [`KT-15483`](https://youtrack.jetbrains.com/issue/KT-15483) Kotlin lint throws unexpected exceptions in IDE
+
+#### Various issues
+- [`KT-12872`](https://youtrack.jetbrains.com/issue/KT-12872) Don't show "defined in <very long qualifier here>" in quick doc for local variables
+- [`KT-13001`](https://youtrack.jetbrains.com/issue/KT-13001) "Go to Type Declaration" is broken for stdlib types
+- [`KT-13067`](https://youtrack.jetbrains.com/issue/KT-13067) Syntax colouring doesn't work for KDoc tags
+- [`KT-14815`](https://youtrack.jetbrains.com/issue/KT-14815) alt + enter -> "import" over a constructor reference is not working
+- [`KT-14819`](https://youtrack.jetbrains.com/issue/KT-14819) Quick documentation for special Enum functions doesn't work
+- [`KT-15141`](https://youtrack.jetbrains.com/issue/KT-15141) Bogus import popup for when function call cannot be resolved fully
+- [`KT-15154`](https://youtrack.jetbrains.com/issue/KT-15154) IllegalStateException on attempt to convert import statement to * if last added import is to typealias
+- [`KT-15329`](https://youtrack.jetbrains.com/issue/KT-15329) Regex not inspected properly for javaJavaIdentifierStart and javaJavaIdentifierPart
+- [`KT-15383`](https://youtrack.jetbrains.com/issue/KT-15383) Kotlin Scripts can only resolve stdlib functions/classes if they are in a source directory
+- [`KT-15440`](https://youtrack.jetbrains.com/issue/KT-15440) Improve extensions detection in IDEA
+- [`KT-15548`](https://youtrack.jetbrains.com/issue/KT-15548) Kotlin plugin: @Language injections specified in another module are ignored
+- Invoke `StorageComponentContainerContributor` extension for module dependencies container as well (needed for "sam-with-receiver" plugin to work with scripts)
+
+### J2K
+- [`KT-6790`](https://youtrack.jetbrains.com/issue/KT-6790) J2K: Static import of Map.Entry is lost during conversion
+- [`KT-14736`](https://youtrack.jetbrains.com/issue/KT-14736) J2K: Incorrect conversion of back ticks in javadoc {@code} tag
+- [`KT-15027`](https://youtrack.jetbrains.com/issue/KT-15027) J2K: Annotations are set on functions, but not on property accessors
+
+### Gradle support
+
+- [`KT-15376`](https://youtrack.jetbrains.com/issue/KT-15376) Kotlin incremental=true: fixed compatibility with AS 2.3
+- [`KT-15433`](https://youtrack.jetbrains.com/issue/KT-15433) Kotlin daemon swallows exceptions: fixed stack trace reporting
+- [`KT-15682`](https://youtrack.jetbrains.com/issue/KT-15682) Uncheck "Use project settings" option on import Kotlin project from gradle
+
+
 ## 1.1-M04 (EAP-4)
 
 ### Language related changes
@@ -469,6 +1099,23 @@ These artifacts include extensions for the types available in the latter JDKs, s
 ### IDE
 
 - Project View: Fix presentation of Kotlin files and their members when @JvmName having the same name as the file itself
+- [`KT-15611`](https://youtrack.jetbrains.com/issue/KT-15611) Extract Interface/Superclass: Disable const-properties
+- Pull Up: Fix pull-up from object to superclass
+- [`KT-15602`](https://youtrack.jetbrains.com/issue/KT-15602) Extract Interface/Superclass: Disable "Make abstract" for inline/external/lateinit members
+- Extract Interface: Disable inline/external/lateinit members
+- [`KT-12704`](https://youtrack.jetbrains.com/issue/KT-12704), [`KT-15583`](https://youtrack.jetbrains.com/issue/KT-15583) Override/Implement Members: Support all nullability annotations respected by the Kotlin compiler
+- [`KT-15563`](https://youtrack.jetbrains.com/issue/KT-15563) Override Members: Allow overriding virtual synthetic members (e.g. equals(), hashCode(), toString(), etc.) in data classes
+- [`KT-15355`](https://youtrack.jetbrains.com/issue/KT-15355) Extract Interface: Disable "Make abstract" and assume it to be true for abstract members of an interface
+- [`KT-15353`](https://youtrack.jetbrains.com/issue/KT-15353) Extract Superclass/Interface: Allow extracting class with special name (and quotes)
+- [`KT-15643`](https://youtrack.jetbrains.com/issue/KT-15643) Extract Interface/Pull Up: Disable "Make abstract" and assume it to be true for primary constructor parameter when moving to an interface
+- [`KT-15607`](https://youtrack.jetbrains.com/issue/KT-15607) Extract Interface/Pull Up: Disable internal/protected members when moving to an interface
+- [`KT-15640`](https://youtrack.jetbrains.com/issue/KT-15640) Extract Interface/Pull Up: Drop 'final' modifier when moving to an interface
+- [`KT-15639`](https://youtrack.jetbrains.com/issue/KT-15639) Extract Superclass/Interface/Pull Up: Add spaces between 'abstract' modifier and annotations
+- [`KT-15606`](https://youtrack.jetbrains.com/issue/KT-15606) Extract Interface/Pull Up: Warn about private members with usages in the original class
+- [`KT-15635`](https://youtrack.jetbrains.com/issue/KT-15635) Extract Superclass/Interface: Fix bogus visibility warning inside a member when it's being moved as abstract
+- [`KT-15598`](https://youtrack.jetbrains.com/issue/KT-15598) Extract Interface: Red-highlight members inherited from a super-interface when that interface reference itself is not extracted
+- [`KT-15674`](https://youtrack.jetbrains.com/issue/KT-15674) Extract Superclass: Drop inapplicable modifiers when converting property-parameter to ordinary parameter
+- [`KT-15444`](https://youtrack.jetbrains.com/issue/KT-15444) Spring Support: Consider declaration open if it's supplemented with a preconfigured annotation in corresponding compiler plugin
 
 #### Intention actions, inspections and quickfixes
 
@@ -478,6 +1125,7 @@ These artifacts include extensions for the types available in the latter JDKs, s
 - Implement quickfix which enables/disables coroutine support in module or project
 - [`KT-15056`](https://youtrack.jetbrains.com/issue/KT-15056) Implement intention which converts object literal to class
 - [`KT-8855`](https://youtrack.jetbrains.com/issue/KT-8855) Implement "Create label" quick fix
+- [`KT-15627`](https://youtrack.jetbrains.com/issue/KT-15627) Support "Change parameter type" for parameters with type-mismatched default value
 
 ## 1.0.6
 

TeamCityBuild.xml

@@ -145,10 +145,10 @@
     </macrodef>
 
     <target name="printStatistics">
-        <print-file-size-statistic path="${kotlin-home}/lib" file-name="kotlin-runtime.jar"/>
+        <print-file-size-statistic path="${kotlin-home}/lib" file-name="kotlin-stdlib.jar"/>
         <print-file-size-statistic path="${kotlin-home}/lib" file-name="kotlin-reflect.jar"/>
 
-        <print-file-size-statistic path="${kotlin-home}/lib" file-name="kotlin-jslib.jar"/>
+        <print-file-size-statistic path="${kotlin-home}/lib" file-name="kotlin-stdlib-js.jar"/>
         <print-file-size-statistic path="${js.stdlib.output.dir}" file-name="kotlin.js"/>
         <print-file-size-statistic path="${js.stdlib.output.dir}" file-name="${compiled.stdlib.meta.js}"/>
         <print-file-size-statistic path="${js.stdlib.output.dir}" file-name="${compiled.stdlib.js}"/>

ant/src/org/jetbrains/kotlin/ant/Kotlin2JsTask.kt

@@ -22,7 +22,7 @@ import java.io.File
 class Kotlin2JsTask : KotlinCompilerBaseTask() {
     override val compilerFqName = "org.jetbrains.kotlin.cli.js.K2JSCompiler"
 
-    var library: Path? = null
+    var libraries: Path? = null
     var outputPrefix: File? = null
     var outputPostfix: File? = null
     var sourceMap: Boolean = false
@@ -35,15 +35,9 @@ class Kotlin2JsTask : KotlinCompilerBaseTask() {
      */
     var main: String? = null
 
-    fun createLibrary(): Path {
-        val libraryPath = library
-        if (libraryPath == null) {
-            val t = Path(getProject())
-            library = t
-            return t
-        }
-
-        return libraryPath.createPath()
+    fun createLibraries(): Path {
+        val libraryPaths = libraries ?: return Path(getProject()).also { libraries = it }
+        return libraryPaths.createPath()
     }
 
     override fun fillSpecificArguments() {
@@ -51,9 +45,9 @@ class Kotlin2JsTask : KotlinCompilerBaseTask() {
         args.add(output!!.canonicalPath)
 
         // TODO: write test
-        library?.let {
-            args.add("-library-files")
-            args.add(it.list().joinToString(separator = ",") { File(it).canonicalPath })
+        libraries?.let {
+            args.add("-libraries")
+            args.add(it.list().joinToString(File.pathSeparator) { File(it).canonicalPath })
         }
 
         outputPrefix?.let {

ant/src/org/jetbrains/kotlin/ant/KotlinAntTaskUtil.kt

@@ -29,8 +29,8 @@ internal object KotlinAntTaskUtil {
 
     private val libPath: File by lazy {
         // Find path of kotlin-ant.jar in the filesystem and find kotlin-compiler.jar in the same directory
-        val resourcePath = "/" + javaClass.name.replace('.', '/') + ".class"
-        val jarConnection = javaClass.getResource(resourcePath).openConnection() as? JarURLConnection
+        val resourcePath = "/" + this::class.java.name.replace('.', '/') + ".class"
+        val jarConnection = this::class.java.getResource(resourcePath).openConnection() as? JarURLConnection
                             ?: throw UnsupportedOperationException("Kotlin compiler Ant task should be loaded from the JAR file")
         val antTaskJarPath = File(jarConnection.jarFileURL.toURI())
 
@@ -54,7 +54,7 @@ internal object KotlinAntTaskUtil {
         val cached = classLoaderRef.get()
         if (cached != null) return cached
 
-        val myLoader = javaClass.classLoader
+        val myLoader = this::class.java.classLoader
         if (myLoader !is AntClassLoader) return myLoader
 
         val classLoader = ClassPreloadingUtils.preloadClasses(listOf(compilerJar), Preloader.DEFAULT_CLASS_NUMBER_ESTIMATE, myLoader, null)

build-common/src/org/jetbrains/kotlin/build/JvmBuildMetaInfo.kt

@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.build
+
+import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
+import org.jetbrains.kotlin.config.ApiVersion
+import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.config.LanguageVersion
+import org.jetbrains.kotlin.load.java.JvmBytecodeBinaryVersion
+import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion
+
+/**
+ * If you want to add a new field, check its type is supported by [serializeToPlainText], [deserializeFromPlainText]
+ */
+data class JvmBuildMetaInfo(
+        val isEAP: Boolean,
+        val compilerBuildVersion: String,
+        val languageVersionString: String,
+        val apiVersionString: String,
+        val coroutinesEnable: Boolean,
+        val coroutinesWarn: Boolean,
+        val coroutinesError: Boolean,
+        val multiplatformEnable: Boolean,
+        val metadataVersionMajor: Int,
+        val metadataVersionMinor: Int,
+        val metadataVersionPatch: Int,
+        val bytecodeVersionMajor: Int,
+        val bytecodeVersionMinor: Int,
+        val bytecodeVersionPatch: Int,
+        val ownVersion: Int = JvmBuildMetaInfo.OWN_VERSION,
+        val coroutinesVersion: Int = JvmBuildMetaInfo.COROUTINES_VERSION,
+        val multiplatformVersion: Int = JvmBuildMetaInfo.MULTIPLATFORM_VERSION
+) {
+    companion object {
+        const val OWN_VERSION: Int = 0
+        const val COROUTINES_VERSION: Int = 0
+        const val MULTIPLATFORM_VERSION: Int = 0
+
+        fun serializeToString(info: JvmBuildMetaInfo): String =
+                serializeToPlainText(info)
+
+        fun deserializeFromString(str: String): JvmBuildMetaInfo? =
+                deserializeFromPlainText(str)
+    }
+}
+
+fun JvmBuildMetaInfo(args: CommonCompilerArguments): JvmBuildMetaInfo =
+        JvmBuildMetaInfo(isEAP = KotlinCompilerVersion.isPreRelease(),
+                         compilerBuildVersion = KotlinCompilerVersion.VERSION,
+                         languageVersionString = args.languageVersion ?: LanguageVersion.LATEST.versionString,
+                         apiVersionString = args.apiVersion ?: ApiVersion.LATEST.versionString,
+                         coroutinesEnable = args.coroutinesEnable,
+                         coroutinesWarn = args.coroutinesWarn,
+                         coroutinesError = args.coroutinesError,
+                         multiplatformEnable = args.multiPlatform,
+                         metadataVersionMajor = JvmMetadataVersion.INSTANCE.major,
+                         metadataVersionMinor = JvmMetadataVersion.INSTANCE.minor,
+                         metadataVersionPatch = JvmMetadataVersion.INSTANCE.patch,
+                         bytecodeVersionMajor = JvmBytecodeBinaryVersion.INSTANCE.major,
+                         bytecodeVersionMinor = JvmBytecodeBinaryVersion.INSTANCE.minor,
+                         bytecodeVersionPatch = JvmBytecodeBinaryVersion.INSTANCE.patch)

build-common/src/org/jetbrains/kotlin/build/serializationUtils.kt

@@ -0,0 +1,71 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.build
+
+import kotlin.reflect.KClass
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+
+inline fun <reified T : Any> serializeToPlainText(instance: T): String = serializeToPlainText(instance, T::class)
+
+fun <T : Any> serializeToPlainText(instance: T, klass: KClass<T>): String {
+    val lines = ArrayList<String>()
+    for (property in klass.memberProperties) {
+        val value = property.get(instance)
+        if (value != null) {
+            lines.add("${property.name}=$value")
+        }
+    }
+    return lines.joinToString("\n")
+}
+
+inline fun <reified T : Any> deserializeFromPlainText(str: String): T? = deserializeFromPlainText(str, T::class)
+
+fun <T : Any> deserializeFromPlainText(str: String, klass: KClass<T>): T? {
+    val args = ArrayList<Any?>()
+    val properties = str
+            .split("\n")
+            .filter(String::isNotBlank)
+            .associate { it.substringBefore("=") to it.substringAfter("=") }
+
+    val primaryConstructor = klass.primaryConstructor
+                             ?: throw IllegalStateException("${klass.java} does not have primary constructor")
+    for (param in primaryConstructor.parameters.sortedBy { it.index }) {
+        val argumentString = properties[param.name]
+
+        if (argumentString == null) {
+            if (param.type.isMarkedNullable) {
+                args.add(null)
+                continue
+            }
+            else {
+                return null
+            }
+        }
+
+        val argument: Any? = when (param.type.classifier) {
+            Int::class -> argumentString.toInt()
+            Boolean::class -> argumentString.toBoolean()
+            String::class -> argumentString
+            else -> throw IllegalStateException("Unexpected property type: ${param.type}")
+        }
+
+        args.add(argument)
+    }
+
+    return primaryConstructor.call(*args.toTypedArray())
+}

build-common/src/org/jetbrains/kotlin/compilerRunner/ArgumentUtils.java

@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.compilerRunner;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ComparatorUtil;
-import com.sampullara.cli.Argument;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments;
+import org.jetbrains.kotlin.cli.common.parser.com.sampullara.cli.Argument;
 
 import java.lang.reflect.Field;
 import java.util.ArrayList;

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

@@ -24,7 +24,7 @@ import java.io.File
 
 private val NORMAL_VERSION = 8
 private val EXPERIMENTAL_VERSION = 4
-private val DATA_CONTAINER_VERSION = 1
+private val DATA_CONTAINER_VERSION = 2
 
 private val NORMAL_VERSION_FILE_NAME = "format-version.txt"
 private val EXPERIMENTAL_VERSION_FILE_NAME = "experimental-format-version.txt"

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

@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.incremental
 import org.jetbrains.kotlin.cli.common.ExitCode
 import java.io.File
 
-abstract class ICReporter {
-    abstract fun report(message: ()->String)
+interface ICReporter {
+    fun report(message: ()->String)
 
     // used in Gradle plugin
     @Suppress("unused")
-    open fun reportCompileIteration(sourceFiles: Iterable<File>, exitCode: ExitCode) {}
+    fun reportCompileIteration(sourceFiles: Collection<File>, exitCode: ExitCode) {}
 
-    open fun pathsAsString(files: Iterable<File>): String =
+    fun pathsAsString(files: Iterable<File>): String =
             files.map { it.canonicalPath }.joinToString()
 
     fun pathsAsString(vararg files: File): String =

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

@@ -43,7 +43,6 @@ import org.jetbrains.kotlin.serialization.deserialization.TypeTable
 import org.jetbrains.kotlin.serialization.deserialization.supertypes
 import org.jetbrains.kotlin.serialization.jvm.BitEncoding
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
-import org.jetbrains.kotlin.utils.singletonOrEmptyList
 import org.jetbrains.org.objectweb.asm.*
 import java.io.File
 import java.security.MessageDigest
@@ -272,7 +271,7 @@ open class IncrementalCacheImpl<Target>(
                                     ProtoBuf.Class::getPropertyList
                             ) + classData.classProto.enumEntryList.map { classData.nameResolver.getString(it.name) }
 
-                    val companionObjectChanged = createChangeInfo(classFqName.parent(), classFqName.shortName().asString().singletonOrEmptyList())
+                    val companionObjectChanged = createChangeInfo(classFqName.parent(), listOfNotNull(classFqName.shortName().asString()))
                     val companionObjectMembersChanged = createChangeInfo(classFqName, memberNames)
 
                     listOf(companionObjectMembersChanged, companionObjectChanged)
@@ -780,7 +779,7 @@ sealed class ChangeInfo(val fqName: FqName) {
     protected open fun toStringProperties(): String = "fqName = $fqName"
 
     override fun toString(): String {
-        return this.javaClass.simpleName + "(${toStringProperties()})"
+        return this::class.java.simpleName + "(${toStringProperties()})"
     }
 }
 

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

@@ -50,5 +50,5 @@ class LocalFileKotlinClass private constructor(
 
     override fun hashCode(): Int = file.hashCode()
     override fun equals(other: Any?): Boolean = other is LocalFileKotlinClass && file == other.file
-    override fun toString(): String = "$javaClass: $file"
+    override fun toString(): String = "${this::class.java}: $file"
 }

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

@@ -42,7 +42,7 @@ import java.util.*
 
 
 fun Iterable<File>.javaSourceRoots(roots: Iterable<File>): Iterable<File> =
-        filter { it.isJavaFile() }
+        filter(File::isJavaFile)
                 .map { findSrcDirRoot(it, roots) }
                 .filterNotNull()
 
@@ -145,7 +145,7 @@ fun LookupStorage.update(
         filesToCompile: Iterable<File>,
         removedFiles: Iterable<File>
 ) {
-    if (lookupTracker !is LookupTrackerImpl) throw AssertionError("Lookup tracker is expected to be LookupTrackerImpl, got ${lookupTracker.javaClass}")
+    if (lookupTracker !is LookupTrackerImpl) throw AssertionError("Lookup tracker is expected to be LookupTrackerImpl, got ${lookupTracker::class.java}")
 
     removeLookupsFrom(filesToCompile.asSequence() + removedFiles.asSequence())
 

build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMap.kt

@@ -46,7 +46,7 @@ abstract class BasicMap<K : Comparable<K>, V>(
     fun dump(): String {
         return with(StringBuilder()) {
             with(Printer(this)) {
-                println(this@BasicMap.javaClass.simpleName)
+                println(this@BasicMap::class.java.simpleName)
                 pushIndent()
 
                 for (key in storage.keys.sorted()) {

build-common/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt

@@ -131,7 +131,7 @@ object ConstantsMapExternalizer : DataExternalizer<Map<String, Any>> {
                     output.writeByte(Kind.STRING.ordinal)
                     IOUtil.writeString(value, output)
                 }
-                else -> throw IllegalStateException("Unexpected constant class: ${value.javaClass}")
+                else -> throw IllegalStateException("Unexpected constant class: ${value::class.java}")
             }
         }
     }

build-common/test/org/jetbrains/kotlin/build/JvmBuildMetaInfoTest.kt

@@ -0,0 +1,77 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.build
+
+import junit.framework.TestCase
+import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
+import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion
+import org.junit.Assert.assertNotEquals
+import org.junit.Test
+
+class JvmBuildMetaInfoTest : TestCase() {
+    @Test
+    fun testSerialization() {
+        val args = K2JVMCompilerArguments()
+        val info = JvmBuildMetaInfo(args)
+        val actual = JvmBuildMetaInfo.serializeToString(info)
+        val expectedKeys = listOf(
+                "apiVersionString",
+                "bytecodeVersionMajor",
+                "bytecodeVersionMinor",
+                "bytecodeVersionPatch",
+                "compilerBuildVersion",
+                "coroutinesEnable",
+                "coroutinesError",
+                "coroutinesVersion",
+                "coroutinesWarn",
+                "isEAP",
+                "languageVersionString",
+                "metadataVersionMajor",
+                "metadataVersionMinor",
+                "metadataVersionPatch",
+                "multiplatformEnable",
+                "multiplatformVersion",
+                "ownVersion"
+        )
+        assertEquals(expectedKeys, actual.split("\r\n", "\n").map { line -> line.split("=").first() })
+    }
+
+    @Test
+    fun testSerializationDeserialization() {
+        val args = K2JVMCompilerArguments()
+        val info = JvmBuildMetaInfo(args)
+        val serialized = JvmBuildMetaInfo.serializeToString(info)
+        val deserialized = JvmBuildMetaInfo.deserializeFromString(serialized)
+        assertEquals(info, deserialized)
+    }
+
+    @Test
+    fun testEquals() {
+        val args1 = K2JVMCompilerArguments()
+        args1.coroutinesEnable = true
+        val info1 = JvmBuildMetaInfo(args1)
+
+        val args2 = K2JVMCompilerArguments()
+        args2.coroutinesEnable = false
+        val info2 = JvmBuildMetaInfo(args2)
+
+        assertNotEquals(info1, info2)
+        assertEquals(info1, info2.copy(coroutinesEnable = true))
+    }
+}

build-common/test/org/jetbrains/kotlin/build/SerializationUtilsTest.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.build
+
+import junit.framework.TestCase
+import org.junit.Test
+
+class SerializationUtilsTest : TestCase() {
+    data class TestPropertyTypes(
+            val intNull: Int?,
+            val int: Int,
+            val stringNull: String?,
+            val string: String,
+            val boolNull: Boolean?,
+            val bool: Boolean
+    )
+
+    @Test
+    fun testPropertyTypes() {
+        val instance1 = TestPropertyTypes(null, 1, null, "abc", null, false)
+        val deserialized1 = deserializeFromPlainText<TestPropertyTypes>(serializeToPlainText(instance1))
+        assertEquals(instance1, deserialized1)
+
+        val instance2 = TestPropertyTypes(1, 2, "abc", "xyz", true, false)
+        val deserialized2 = deserializeFromPlainText<TestPropertyTypes>(serializeToPlainText(instance2))
+        assertEquals(instance2, deserialized2)
+    }
+
+    data class TestAddedField1(val x: Int)
+    data class TestAddedField2(val x: Int, val y: Int?)
+
+    @Test
+    fun testAddedField() {
+        val testAddedField1 = TestAddedField1(1)
+        val serialized = serializeToPlainText(testAddedField1)
+        val deserialized = deserializeFromPlainText<TestAddedField2>(serialized)
+
+        assertEquals(TestAddedField2(1, null), deserialized)
+    }
+}
+

build-common/test/org/jetbrains/kotlin/incremental/testingUtils/classFilesComparison.kt

@@ -144,7 +144,7 @@ private fun classFileToString(classFile: File): String {
 
             out.write("\n------ string table types proto -----\n${DebugJvmProtoBuf.StringTableTypes.parseDelimitedFrom(input)}")
 
-            if (!classHeader!!.metadataVersion.isCompatible()) {
+            if (!classHeader.metadataVersion.isCompatible()) {
                 error("Incompatible class ($classHeader): $classFile")
             }
 

build-common/test/org/jetbrains/kotlin/incremental/testingUtils/incrementalModificationUtils.kt

@@ -81,8 +81,8 @@ fun getModificationsToPerform(
 
         val rules = mapOf<String, (String, File) -> Modification>(
                 newSuffix to { path, file -> ModifyContent(path, file) },
-                touchSuffix to { path, file -> TouchFile(path, touchPolicy) },
-                deleteSuffix to { path, file -> DeleteFile(path) }
+                touchSuffix to { path, _ -> TouchFile(path, touchPolicy) },
+                deleteSuffix to { path, _ -> DeleteFile(path) }
         )
 
         val modifications = ArrayList<Modification>()
@@ -130,7 +130,7 @@ fun getModificationsToPerform(
 abstract class Modification(val path: String) {
     abstract fun perform(workDir: File, mapping: MutableMap<File, File>)
 
-    override fun toString(): String = "${javaClass.simpleName} $path"
+    override fun toString(): String = "${this::class.java.simpleName} $path"
 }
 
 class ModifyContent(path: String, val dataFile: File) : Modification(path) {

build.xml

@@ -1,4 +1,4 @@
-<project name="Kotlin" default="dist" xmlns:if="ant:if" xmlns:unless="ant:unless">
+<project xmlns:if="ant:if" xmlns:unless="ant:unless" name="Kotlin" default="dist">
     <import file="common.xml" optional="false"/>
     <property file="resources/kotlinManifest.properties"/>
 
@@ -28,7 +28,8 @@
     <property name="protobuf-lite.jar" value="${basedir}/dependencies/protobuf-2.6.1-lite.jar"/>
     <property name="javax.inject.jar" value="${basedir}/lib/javax.inject.jar"/>
 
-    <property name="java.target" value="1.6"/>
+    <property name="java.target" value="1.8"/>
+    <property name="java.target.1.6" value="1.6"/>
 
     <condition property="bootstrap.or.local.build" value="true">
         <or>
@@ -41,9 +42,10 @@
 
     <include file="jslib_files.xml" />
 
+    <property name="compiled.builtins.js" value="builtins.js"/>
     <property name="compiled.stdlib.js" value="stdlib.js"/>
     <property name="compiled.stdlib.meta.js" value="kotlin.meta.js"/>
-    <property name="stdlib.js.dir" value="${basedir}/js/js.translator/testData"/>
+    <property name="stdlib.js.dir" value="${basedir}/js/js.libraries/src/js"/>
 
     <!--
     The compiler produced on the first step of the build (Bootstrap No Tests) is only guaranteed to work against the OLD runtime
@@ -71,7 +73,6 @@
         <fileset dir="${basedir}/lib" includes="**/*.jar"/>
         <fileset dir="${dependencies}" includes="jansi.jar"/>
         <fileset dir="${dependencies}" includes="jline.jar"/>
-        <fileset dir="${dependencies}" includes="cli-parser-1.1.2.jar"/>
         <fileset dir="${basedir}/ideaSDK/jps" includes="jps-model.jar"/>
     </path>
 
@@ -313,6 +314,7 @@
 
     <macrodef name="new-kotlin2js">
         <attribute name="output"/>
+        <attribute name="additionalOptions" default=""/>
         <element name="src"/>
 
         <sequential>
@@ -340,10 +342,10 @@
                 <arg value="@{output}"/>
                 <arg value="-no-stdlib"/>
                 <arg value="-version"/>
-                <arg value="-meta-info"/>
-                <arg value="-kjsm"/>
+                <arg line="@{additionalOptions}"/>
                 <arg line="-main noCall"/>
                 <arg line="-module-kind commonjs"/>
+                <arg value="-Xallow-kotlin-package"/>
             </java>
         </sequential>
     </macrodef>
@@ -366,16 +368,16 @@
             output="${js.stdlib.output.dir}/kotlin.js"
             outputWrapperFile="${stdlib.js.dir}/closure-wrapper.txt">
 
-            <sources dir="${stdlib.js.dir}">
-                <file name="kotlin_lib_ecma5.js"/>
-                <file name="kotlin_lib.js"/>
-                <file name="long.js"/>
-            </sources>
-
-            <sources dir="${js.stdlib.output.dir}">
-                <file name="builtins.js"/>
-                <file name="${compiled.stdlib.js}"/>
-            </sources>
+            <path>
+                <fileset dir="${stdlib.js.dir}">
+                    <include name="**/*.js"/>
+                    <exclude name="externs.js"/>
+                </fileset>
+                <fileset dir="${js.stdlib.output.dir}">
+                    <include name="${compiled.builtins.js}"/>
+                    <include name="${compiled.stdlib.js}"/>
+                </fileset>
+            </path>
 
             <externs dir="${stdlib.js.dir}">
                 <file name="externs.js"/>
@@ -404,9 +406,13 @@
                        byline="true" encoding="UTF-8" />
     </target>
 
-    <target name="js-stdlib">
-        <property environment="env"/>
+    <target name="js-stdlib-preprocess">
         <kotlin-pp src="libraries/stdlib/src" output="${intermediate-sources}/stdlib/js" profile="JS" />
+    </target>
+
+    <target name="js-stdlib" depends="js-stdlib-preprocess">
+        <property environment="env"/>
+        <cleandir dir="${js.stdlib.output.dir}"/>
 
         <!-- We don't want descriptors for built-ins to be serialized, so we compile these files separately. -->
         <new-kotlin2js output="${js.stdlib.output.dir}/tmp-builtins/kotlin.js">
@@ -417,7 +423,7 @@
             </src>
         </new-kotlin2js>
 
-        <new-kotlin2js output="${js.stdlib.output.dir}/tmp/kotlin.js">
+        <new-kotlin2js output="${js.stdlib.output.dir}/tmp/kotlin.js" additionalOptions="-meta-info">
             <src>
                 <union>
                     <fileset refid="kotlin.builtin.files"/>
@@ -426,7 +432,7 @@
             </src>
         </new-kotlin2js>
 
-        <move file="${js.stdlib.output.dir}/tmp-builtins/kotlin.js" tofile="${js.stdlib.output.dir}/builtins.js" />
+        <move file="${js.stdlib.output.dir}/tmp-builtins/kotlin.js" tofile="${js.stdlib.output.dir}/${compiled.builtins.js}" />
         <move file="${js.stdlib.output.dir}/tmp/kotlin.js" tofile="${js.stdlib.output.dir}/${compiled.stdlib.js}" />
         <move file="${js.stdlib.output.dir}/tmp/kotlin" todir="${js.stdlib.output.dir}" />
         <move file="${js.stdlib.output.dir}/tmp/${compiled.stdlib.meta.js}" tofile="${js.stdlib.output.dir}/${compiled.stdlib.meta.js}" />
@@ -449,7 +455,7 @@
             <arg line="js-stdlib-merge" />
         </java>
 
-        <jar jarfile="${kotlin-home}/lib/kotlin-jslib.jar" duplicate="fail">
+        <jar jarfile="${kotlin-home}/lib/kotlin-stdlib-js.jar" duplicate="fail">
             <zipfileset file="${kotlin-home}/build.txt" prefix="META-INF"/>
             <zipfileset dir="${js.stdlib.output.dir}" prefix="">
                 <include name="kotlin.js"/>
@@ -460,7 +466,7 @@
             <manifest>
                 <attribute name="Built-By" value="${manifest.impl.vendor}"/>
                 <attribute name="${manifest.impl.attribute.kotlin.version}" value="${manifest.impl.value.kotlin.version}"/>
-                <attribute name="${manifest.impl.attribute.kotlin.runtime.component}" value="${manifest.impl.value.kotlin.runtime.component.core}"/>
+                <attribute name="${manifest.impl.attribute.kotlin.runtime.component}" value="${manifest.impl.value.kotlin.runtime.component.main}"/>
 
                 <attribute name="Implementation-Vendor" value="${manifest.impl.vendor}"/>
                 <attribute name="Implementation-Title" value="${manifest.impl.title.kotlin.javascript.stdlib}"/>
@@ -468,26 +474,28 @@
                 <attribute name="Specification-Title" value="${manifest.spec.title.kotlin.javascript.lib}"/>
             </manifest>
         </jar>
+        <copy file="${kotlin-home}/lib/kotlin-stdlib-js.jar" tofile="${kotlin-home}/lib/kotlin-jslib.jar" />
     </target>
 
-    <target name="pack-js-stdlib-sources">
-        <jar destfile="${kotlin-home}/lib/kotlin-jslib-sources.jar" duplicate="fail">
+    <target name="pack-js-stdlib-sources" depends="js-stdlib-preprocess">
+        <jar destfile="${kotlin-home}/lib/kotlin-stdlib-js-sources.jar" duplicate="fail">
             <resources refid="js.lib.files" />
             <fileset refid="kotlin.builtin.files" />
 
             <manifest>
                 <attribute name="Built-By" value="${manifest.impl.vendor}"/>
                 <attribute name="${manifest.impl.attribute.kotlin.version}" value="${manifest.impl.value.kotlin.version}"/>
-                <attribute name="${manifest.impl.attribute.kotlin.runtime.component}" value="${manifest.impl.value.kotlin.runtime.component.core}"/>
+                <attribute name="${manifest.impl.attribute.kotlin.runtime.component}" value="${manifest.impl.value.kotlin.runtime.component.main}"/>
 
                 <attribute name="Implementation-Vendor" value="${manifest.impl.vendor}"/>
                 <attribute name="Implementation-Title" value="${manifest.impl.title.kotlin.jvm.runtime.sources}"/>
                 <attribute name="Implementation-Version" value="${build.number}"/>
             </manifest>
         </jar>
+        <copy file="${kotlin-home}/lib/kotlin-stdlib-js-sources.jar" tofile="${kotlin-home}/lib/kotlin-jslib-sources.jar" />
     </target>
 
-    <target name="kotlin-js-stdlib" depends="js-stdlib,pack-js-stdlib-sources"/>
+    <target name="kotlin-js-stdlib" depends="js-stdlib,js-kotlin-test,pack-js-stdlib-sources"/>
 
     <target name="preloader">
         <cleandir dir="${output}/classes/preloader"/>
@@ -581,7 +589,6 @@
                 <zipfileset src="${idea.sdk}/lib/oromatcher.jar"/>
                 <zipfileset src="${idea.sdk}/jps/jps-model.jar"/>
                 <zipfileset src="${dependencies}/jline.jar"/>
-                <zipfileset src="${dependencies}/cli-parser-1.1.2.jar"/>
                 <zipfileset src="${protobuf.jar}"/>
 
                 <manifest>
@@ -612,13 +619,6 @@
     </target>
 
     <target name="compiler">
-        <taskdef resource="proguard/ant/task.properties">
-            <classpath>
-                <pathelement path="${dependencies}/proguard.jar"/>
-                <pathelement path="${dependencies}/proguard-anttask.jar"/>
-            </classpath>
-        </taskdef>
-
         <cleandir dir="${output}/classes/compiler"/>
 
         <javac2 destdir="${output}/classes/compiler" debug="true" debuglevel="lines,vars,source" includeAntRuntime="false"
@@ -640,17 +640,32 @@
               unless:true="${shrink}" />
 
         <sequential if:true="${shrink}">
+            <shrink configuration="${basedir}/compiler/compiler.pro"/>
+        </sequential>
+
+        <pack-compiler-for-maven/>
+    </target>
+
+    <macrodef name="shrink">
+        <attribute name="configuration"/>
+
+        <sequential>
+            <taskdef resource="proguard/ant/task.properties">
+                <classpath>
+                    <pathelement path="${dependencies}/proguard.jar"/>
+                    <pathelement path="${dependencies}/proguard-anttask.jar"/>
+                </classpath>
+            </taskdef>
+
             <available property="rtjar" value="${java.home}/lib/rt.jar" file="${java.home}/lib/rt.jar"/>
             <available property="rtjar" value="${java.home}/../Classes/classes.jar" file="${java.home}/../Classes/classes.jar"/>
 
             <available property="jssejar" value="${java.home}/lib/jsse.jar" file="${java.home}/lib/jsse.jar"/>
             <available property="jssejar" value="${java.home}/../Classes/jsse.jar" file="${java.home}/../Classes/jsse.jar"/>
 
-            <proguard configuration="${basedir}/compiler/compiler.pro"/>
+            <proguard configuration="@{configuration}"/>
         </sequential>
-
-        <pack-compiler-for-maven/>
-    </target>
+    </macrodef>
 
     <macrodef name="pack-compiler-for-maven">
         <sequential>
@@ -751,7 +766,7 @@
                 <attribute name="Built-By" value="${manifest.impl.vendor}"/>
 
                 <attribute name="Implementation-Vendor" value="${manifest.impl.vendor}"/>
-                <attribute name="Implementation-Title" value="${manifest.impl.title.kotlin.daemon-client}"/>
+                <attribute name="Implementation-Title" value="${manifest.impl.title.kotlin.daemon.client}"/>
                 <attribute name="Implementation-Version" value="${build.number}"/>
             </manifest>
         </jar>
@@ -771,6 +786,27 @@
         </jar>
     </target>
 
+    <target name="compiler-client-embeddable">
+        <taskdef name="jarjar" classname="com.tonicsystems.jarjar.JarJarTask" classpath="dependencies/jarjar.jar"/>
+
+        <jarjar jarfile="${output}/kotlin-compiler-client-embeddable-before-shrink.jar">
+            <zipfileset file="${kotlin-home}/build.txt" prefix="META-INF"/>
+            <zipfileset src="${kotlin-home}/lib/kotlin-daemon-client.jar"/>
+            <fileset dir="${output}/classes/compiler"
+                    includes="org/jetbrains/kotlin/daemon/common/** org/jetbrains/kotlin/cli/common/messages/CompilerMessage*  org/jetbrains/kotlin/cli/common/messages/Message*  org/jetbrains/kotlin/cli/common/repl/**"/>
+
+            <manifest>
+                <attribute name="Built-By" value="${manifest.impl.vendor}"/>
+                <attribute name="Implementation-Vendor" value="${manifest.impl.vendor}"/>
+                <attribute name="Implementation-Title" value="${manifest.impl.title.kotlin.compiler.client,embeddable}"/>
+                <attribute name="Implementation-Version" value="${build.number}"/>
+                <attribute name="Class-Path" value="kotlin-stdlib.jar"/>
+            </manifest>
+        </jarjar>
+
+        <shrink configuration="${basedir}/compiler/compiler-client.pro"/>
+    </target>
+
     <target name="android-extensions-compiler">
         <cleandir dir="${output}/classes/android-extensions/android-extensions-compiler"/>
         <javac2 destdir="${output}/classes/android-extensions/android-extensions-compiler" debug="true" debuglevel="lines,vars,source" includeAntRuntime="false">
@@ -863,6 +899,29 @@
         </jar>
     </target>
 
+    <target name="source-sections-compiler-plugin">
+        <cleandir dir="${output}/classes/source-sections-compiler-plugin"/>
+        <javac2 destdir="${output}/classes/source-sections-compiler-plugin" debug="true" debuglevel="lines,vars,source" includeAntRuntime="false">
+            <withKotlin modulename="source-sections">
+                <compilerarg value="-version"/>
+            </withKotlin>
+            <skip pattern="kotlin/Metadata"/>
+            <src>
+                <pathelement path="plugins/source-sections/source-sections-compiler/src"/>
+            </src>
+            <classpath>
+                <pathelement path="${idea.sdk}/core/intellij-core.jar"/>
+                <pathelement path="${kotlin-home}/lib/kotlin-compiler.jar"/>
+            </classpath>
+        </javac2>
+
+        <jar destfile="${kotlin-home}/lib/source-sections-compiler-plugin.jar">
+            <fileset dir="${output}/classes/source-sections-compiler-plugin"/>
+            <zipfileset file="${kotlin-home}/build.txt" prefix="META-INF"/>
+            <fileset dir="${basedir}/plugins/source-sections/source-sections-compiler/src" includes="META-INF/services/**"/>
+        </jar>
+    </target>
+
     <target name="annotation-processing-under-jdk8">
         <property environment="env"/>
 
@@ -1000,7 +1059,7 @@
             </java>
 
             <javac2 srcdir="${toString:src.dirset}" destdir="@{output}" debug="true" debuglevel="lines,vars,source"
-                    includeAntRuntime="false" source="${java.target}" target="${java.target}">
+                    includeAntRuntime="false" source="${java.target.1.6}" target="${java.target.1.6}">
                 <skip pattern="kotlin/Metadata"/>
                 <classpath>
                     <path refid="classpath.path"/>
@@ -1019,13 +1078,13 @@
         <sequential>
             <java classname="org.jetbrains.kotlin.preloading.Preloader" failonerror="true" fork="true" maxmemory="${max.heap.size.for.forked.jvm}">
                 <classpath>
-                    <pathelement location="${kotlin-home}/lib/kotlin-preloader.jar"/>
+                    <pathelement location="${bootstrap.compiler.home}/lib/kotlin-preloader.jar"/>
                 </classpath>
                 <assertions>
                     <enable/>
                 </assertions>
                 <arg value="-cp"/>
-                <arg value="${kotlin-home}/lib/kotlin-compiler.jar"/>
+                <arg value="${bootstrap.compiler.home}/lib/kotlin-compiler.jar"/>
                 <arg value="org.jetbrains.kotlin.preprocessor.PreprocessorCLI"/>
                 <arg value="@{src}"/>
                 <arg value="@{output}"/>
@@ -1035,7 +1094,7 @@
     </macrodef>
 
     <target name="builtins">
-        <new-kotlinc output="${output}/classes/builtins" moduleName="kotlin-builtins">
+        <new-kotlinc output="${output}/classes/builtins" moduleName="kotlin-runtime">
             <src>
                 <include name="core/builtins/src"/>
                 <include name="core/runtime.jvm/src"/>
@@ -1060,18 +1119,37 @@
     </target>
 
     <target name="kotlin-test">
-        <new-kotlinc output="${output}/classes/kotlin-test" moduleName="kotlin-test">
-            <src>
-                <include name="libraries/kotlin.test/shared/src/main/kotlin" />
-                <include name="libraries/kotlin.test/shared/src/main/kotlin.jvm" />
-                <include name="libraries/kotlin.test/junit/src/main/kotlin" />
-            </src>
-            <class-path>
-                <pathelement path="${output}/classes/builtins"/>
-                <pathelement path="libraries/lib/junit-4.11.jar"/>
-                <pathelement path="${output}/builtins"/>
-            </class-path>
-        </new-kotlinc>
+        <path id="kotlin-test-compile-classpath">
+            <pathelement location="${output}/builtins"/>
+            <pathelement location="${output}/classes/builtins"/>
+            <pathelement location="${output}/classes/stdlib"/>
+            <pathelement location="libraries/lib/junit-4.11.jar"/>
+        </path>
+
+        <java classname="org.jetbrains.kotlin.preloading.Preloader" failonerror="true" fork="true" maxmemory="${max.heap.size.for.forked.jvm}">
+            <classpath>
+                <pathelement location="${kotlin-home}/lib/kotlin-preloader.jar"/>
+            </classpath>
+            <assertions>
+                <enable/>
+            </assertions>
+            <arg value="-cp"/>
+            <arg value="${kotlin-home}/lib/kotlin-compiler.jar"/>
+            <arg value="org.jetbrains.kotlin.cli.jvm.K2JVMCompiler"/>
+            <arg value="-d"/>
+            <arg value="${output}/classes/kotlin-test"/>
+            <arg value="-version"/>
+            <arg value="-no-stdlib"/>
+            <arg value="-classpath"/>
+            <arg value="${toString:kotlin-test-compile-classpath}"/>
+            <arg value="-module-name"/>
+            <arg value="kotlin-test"/>
+            <arg value="-Xallow-kotlin-package"/>
+            <arg value="-Xmulti-platform"/>
+            <arg value="libraries/kotlin.test/common/src/main/kotlin"/>
+            <arg value="libraries/kotlin.test/jvm/src/main/kotlin"/>
+            <arg value="libraries/kotlin.test/junit/src/main/kotlin"/>
+        </java>
 
         <pack-runtime-jar jar-name="kotlin-test.jar" implementation-title="${manifest.impl.title.kotlin.test}" runtime-component="Test">
             <jar-content>
@@ -1079,6 +1157,35 @@
             </jar-content>
         </pack-runtime-jar>
     </target>
+    
+    <target name="js-kotlin-test">
+        <java classname="org.jetbrains.kotlin.preloading.Preloader" failonerror="true" fork="true" maxmemory="${max.heap.size.for.forked.jvm}">
+            <classpath>
+                <pathelement location="${kotlin-home}/lib/kotlin-preloader.jar"/>
+            </classpath>
+            <assertions>
+                <enable/>
+            </assertions>
+            <arg value="-cp"/>
+            <arg value="${kotlin-home}/lib/kotlin-compiler.jar"/>
+            <arg value="org.jetbrains.kotlin.cli.js.K2JSCompiler"/>
+            <arg value="-output"/>
+            <arg value="${output}/classes/kotlin-test-js/kotlin-test.js"/>
+            <arg value="-version"/>
+            <arg value="-meta-info"/>
+            <arg line="-main noCall"/>
+            <arg line="-module-kind umd"/>
+            <arg value="-Xmulti-platform"/>
+            <arg value="-Xallow-kotlin-package"/>
+            <arg value="libraries/kotlin.test/common/src/main/kotlin"/>
+            <arg value="libraries/kotlin.test/js/src/main/kotlin"/>
+        </java>
+        <pack-runtime-jar jar-name="kotlin-test-js.jar" implementation-title="${manifest.impl.title.kotlin.test}" runtime-component="TestJs">
+            <jar-content>
+                <fileset dir="${output}/classes/kotlin-test-js" includes="**/*" excludes="kotlin/internal/OnlyInputTypes*,kotlin/internal/InlineOnly*,kotlin/internal"/>
+            </jar-content>
+        </pack-runtime-jar>
+    </target>
 
     <target name="core">
         <new-kotlinc output="${output}/classes/core" moduleName="kotlin-core">
@@ -1118,7 +1225,7 @@
         <attribute name="jar-dir" default="${kotlin-home}/lib"/>
         <attribute name="jar-name"/>
         <attribute name="implementation-title"/>
-        <attribute name="runtime-component" default="${manifest.impl.value.kotlin.runtime.component.core}"/>
+        <attribute name="runtime-component" default="${manifest.impl.value.kotlin.runtime.component.main}"/>
         <element name="jar-content"/>
 
         <sequential>
@@ -1142,7 +1249,7 @@
     </macrodef>
 
     <target name="pack-runtime">
-        <pack-runtime-jar jar-name="kotlin-runtime.jar" implementation-title="${manifest.impl.title.kotlin.jvm.runtime}">
+        <pack-runtime-jar jar-name="kotlin-stdlib.jar" implementation-title="${manifest.impl.title.kotlin.jvm.runtime}">
             <jar-content>
                 <fileset dir="${output}/classes/builtins"/>
                 <fileset dir="${output}/classes/stdlib"/>
@@ -1153,6 +1260,7 @@
                 </zipfileset>
             </jar-content>
         </pack-runtime-jar>
+        <copy file="${kotlin-home}/lib/kotlin-stdlib.jar" tofile="${kotlin-home}/lib/kotlin-runtime.jar"/>
 
         <pack-runtime-jar jar-dir="${output}" jar-name="kotlin-reflect-before-jarjar.jar" implementation-title="${manifest.impl.title.kotlin.jvm.reflect}">
             <jar-content>
@@ -1170,11 +1278,10 @@
             </manifest>
         </jar>
 
-        <delete file="${output}/kotlin-reflect-jarjar.jar" failonerror="false"/>
-
         <sequential if:true="${obfuscate.reflect}">
             <taskdef name="jarjar" classname="com.tonicsystems.jarjar.JarJarTask" classpath="dependencies/jarjar.jar"/>
-            <jarjar jarfile="${output}/kotlin-reflect-jarjar.jar" filesonly="true" filesetmanifest="merge">
+            <delete file="${output}/kotlin-reflect-after-jarjar.jar" failonerror="false"/>
+            <jarjar jarfile="${output}/kotlin-reflect-after-jarjar.jar" filesonly="true" filesetmanifest="merge">
                 <zipfileset src="${output}/kotlin-reflect-before-jarjar.jar"/>
                 <rule pattern="org.jetbrains.kotlin.**" result="kotlin.reflect.jvm.internal.impl.@1"/>
                 <rule pattern="javax.inject.**" result="kotlin.reflect.jvm.internal.impl.javax.inject.@1"/>
@@ -1185,17 +1292,18 @@
                 <compilerarg value="-script"/>
                 <compilerarg value="kotlin/Metadata"/> <!-- Annotation to strip -->
                 <compilerarg value="kotlin/reflect/jvm/internal/impl/.*"/> <!-- Classes to strip from -->
-                <compilerarg value="${output}/kotlin-reflect-jarjar.jar"/>
-                <compilerarg value="${kotlin-home}/lib/kotlin-reflect.jar"/>
+                <compilerarg value="${output}/kotlin-reflect-after-jarjar.jar"/>
+                <compilerarg value="${output}/kotlin-reflect-before-proguard.jar"/>
                 <classpath>
                     <pathelement location="${idea.sdk}/lib/asm-all.jar"/>
                 </classpath>
             </kotlinc>
+
+            <shrink configuration="${basedir}/core/reflection.jvm/reflection.pro"/>
         </sequential>
 
         <sequential unless:true="${obfuscate.reflect}">
             <echo message="Obfuscation of kotlin-reflect is disabled"/>
-            <copy file="${output}/kotlin-reflect-before-jarjar.jar" tofile="${output}/kotlin-reflect-jarjar.jar" overwrite="true"/>
             <copy file="${output}/kotlin-reflect-before-jarjar.jar" tofile="${kotlin-home}/lib/kotlin-reflect.jar" overwrite="true"/>
         </sequential>
     </target>
@@ -1228,7 +1336,7 @@
             </replaceregexp>
         </sequential>
 
-        <pack-runtime-jar jar-name="kotlin-runtime-sources.jar" implementation-title="${manifest.impl.title.kotlin.jvm.runtime.sources}">
+        <pack-runtime-jar jar-name="kotlin-stdlib-sources.jar" implementation-title="${manifest.impl.title.kotlin.jvm.runtime.sources}">
             <jar-content>
                 <fileset dir="${basedir}/core/builtins/native" includes="**/*"/>
                 <fileset dir="${basedir}/core/builtins/src" includes="**/*"/>
@@ -1238,6 +1346,8 @@
                 <fileset dir="${output}/core.src" includes="**/*"/>
             </jar-content>
         </pack-runtime-jar>
+        <copy file="${kotlin-home}/lib/kotlin-stdlib-sources.jar" tofile="${kotlin-home}/lib/kotlin-runtime-sources.jar"/>
+
 
         <pack-runtime-jar jar-dir="${output}" jar-name="kotlin-reflect-sources-for-maven.jar"
                           implementation-title="${manifest.impl.title.kotlin.jvm.reflect.sources}">
@@ -1274,11 +1384,11 @@
             depends="builtins,stdlib,kotlin-test,core,reflection,pack-runtime,pack-runtime-sources,script-runtime,mock-runtime-for-test"/>
 
     <target name="dist"
-            depends="clean,init,prepare-dist,preloader,runner,serialize-builtins,compiler,compiler-sources,ant-tools,runtime,kotlin-js-stdlib,android-extensions-compiler,allopen-compiler-plugin,noarg-compiler-plugin,sam-with-receiver-compiler-plugin,annotation-processing-under-jdk8,daemon-client,kotlin-build-common-test"
+            depends="clean,init,prepare-dist,preloader,runner,serialize-builtins,compiler,compiler-sources,ant-tools,runtime,kotlin-js-stdlib,android-extensions-compiler,allopen-compiler-plugin,noarg-compiler-plugin,sam-with-receiver-compiler-plugin,source-sections-compiler-plugin,annotation-processing-under-jdk8,daemon-client,kotlin-build-common-test"
             description="Builds redistributables from sources"/>
 
     <target name="dist-quick"
-            depends="clean,init,prepare-dist,preloader,serialize-builtins,compiler-quick,ant-tools,runtime,kotlin-js-stdlib,android-extensions-compiler,allopen-compiler-plugin,noarg-compiler-plugin,sam-with-receiver-compiler-plugin,annotation-processing-under-jdk8"
+            depends="clean,init,prepare-dist,preloader,serialize-builtins,compiler-quick,ant-tools,runtime,kotlin-js-stdlib,android-extensions-compiler,allopen-compiler-plugin,noarg-compiler-plugin,sam-with-receiver-compiler-plugin,source-sections-compiler-plugin,annotation-processing-under-jdk8"
             description="Builds everything, but classes are reused from project out dir, doesn't run proguard and javadoc"/>
 
     <target name="dist-quick-compiler-only"

compiler/android-tests/android-module/build.gradle

@@ -5,7 +5,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.1.0'
+        classpath 'com.android.tools.build:gradle:2.2.3'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -64,7 +64,9 @@ android {
 
     dexOptions {
         dexInProcess false
-        javaMaxHeapSize "600m"
+        javaMaxHeapSize "700m"
+        //default is 4 and Total Memory = maxProcessCount * javaMaxHeapSize
+        maxProcessCount 2
     }
 }
 

compiler/android-tests/src/org/jetbrains/kotlin/android/tests/PathManager.java

@@ -16,6 +16,8 @@
 
 package org.jetbrains.kotlin.android.tests;
 
+import org.jetbrains.kotlin.android.tests.download.SDKDownloader;
+
 import java.io.File;
 
 public class PathManager {
@@ -75,7 +77,7 @@ public class PathManager {
     }
 
     public String getGradleBinFolder() {
-        return getDependenciesRoot() + "/gradle-2.12/bin";
+        return getDependenciesRoot() + "/gradle-" + SDKDownloader.GRADLE_VERSION + "/bin";
     }
 
     public String getRootForDownload() {

compiler/android-tests/src/org/jetbrains/kotlin/android/tests/download/SDKDownloader.java

@@ -43,6 +43,7 @@ public class SDKDownloader {
     private static final String SDK_TOOLS = "25.1.1";
     public static final String BUILD_TOOLS = "23.0.3";
     private static final int ANDROID_VERSION = 19;
+    public static final String GRADLE_VERSION = "2.14.1";
 
 
     public SDKDownloader(PathManager pathManager) {
@@ -78,7 +79,7 @@ public class SDKDownloader {
     }
 
     public void downloadGradle() {
-        download("https://services.gradle.org/distributions/gradle-2.12-bin.zip", gradleZipPath);
+        download("https://services.gradle.org/distributions/gradle-" + GRADLE_VERSION + "-bin.zip", gradleZipPath);
     }
 
     private static String getDownloadUrl(String prefix) {

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/AndroidJpsBuildTestCase.java

@@ -29,8 +29,8 @@ public class AndroidJpsBuildTestCase extends BaseKotlinJpsBuildTestCase {
 
     public void doTest() {
         initProject();
-        rebuildAll();
-        makeAll().assertSuccessful();
+        rebuildAllModules();
+        buildAllModules().assertSuccessful();
     }
 
     @Override

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java

@@ -32,8 +32,8 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.idea.KotlinFileType;
-import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.name.NameUtils;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.*;
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase;
@@ -244,6 +244,11 @@ public class CodegenTestsOnAndroidGenerator extends KtUsefulTestCase {
                     continue;
                 }
 
+                //TODO: support LANGUAGE_VERSION
+                if (InTextDirectivesUtils.isDirectiveDefined(fullFileText, "LANGUAGE_VERSION:")) {
+                    continue;
+                }
+
                 //TODO: support multifile facades
                 //TODO: support multifile facades hierarchies
                 if (hasBoxMethod(fullFileText)) {
@@ -279,7 +284,7 @@ public class CodegenTestsOnAndroidGenerator extends KtUsefulTestCase {
     }
 
     private String generateTestName(String fileName) {
-        String result = JvmAbi.sanitizeAsJavaIdentifier(FileUtil.getNameWithoutExtension(StringUtil.capitalize(fileName)));
+        String result = NameUtils.sanitizeAsJavaIdentifier(FileUtil.getNameWithoutExtension(StringUtil.capitalize(fileName)));
 
         int i = 0;
         while (generatedTestNames.contains(result)) {

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.backend.common
 
+import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.backend.common.bridges.findInterfaceImplementation
 import org.jetbrains.kotlin.descriptors.*
@@ -90,7 +91,7 @@ object CodegenUtil {
         else if (traitMember is PropertyDescriptor) {
             for (traitAccessor in traitMember.accessors) {
                 for (inheritedAccessor in (copy as PropertyDescriptor).accessors) {
-                    if (inheritedAccessor.javaClass == traitAccessor.javaClass) { // same accessor kind
+                    if (inheritedAccessor::class.java == traitAccessor::class.java) { // same accessor kind
                         result.put(traitAccessor, inheritedAccessor)
                     }
                 }
@@ -154,4 +155,12 @@ object CodegenUtil {
         }
         return this[slice, whenExpression] == true
     }
+
+    @JvmStatic
+    fun constructFakeFunctionCall(project: Project, referencedFunction: FunctionDescriptor): KtCallExpression {
+        val fakeFunctionCall = StringBuilder("callableReferenceFakeCall(")
+        fakeFunctionCall.append(referencedFunction.valueParameters.map { "p${it.index}" }.joinToString(", "))
+        fakeFunctionCall.append(")")
+        return KtPsiFactory(project).createExpression(fakeFunctionCall.toString()) as KtCallExpression
+    }
 }

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/DataClassMethodGenerator.kt

@@ -103,5 +103,5 @@ abstract class DataClassMethodGenerator(private val declaration: KtClassOrObject
                 .map { bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, it)!! }
 
     private val primaryConstructorParameters: List<KtParameter>
-        get() = (declaration as? KtClass)?.getPrimaryConstructorParameters().orEmpty()
+        get() = (declaration as? KtClass)?.primaryConstructorParameters.orEmpty()
 }

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/commonCoroutineCodegenUtil.kt

@@ -19,12 +19,26 @@ package org.jetbrains.kotlin.backend.common
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.DescriptorEquivalenceForOverrides
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.descriptorUtil.module
 
-val SUSPEND_WITH_CURRENT_CONTINUATION_NAME = Name.identifier("suspendWithCurrentContinuation")
-val CONTINUATION_RESUME_METHOD_NAME = Name.identifier("resume")
+val SUSPEND_COROUTINE_OR_RETURN_NAME = Name.identifier("suspendCoroutineOrReturn")
+val COROUTINE_SUSPENDED_NAME = Name.identifier("COROUTINE_SUSPENDED")
 
-fun FunctionDescriptor.getBuiltInSuspendWithCurrentContinuation() =
-        builtIns.builtInsCoroutinePackageFragment.getMemberScope()
-                .getContributedFunctions(SUSPEND_WITH_CURRENT_CONTINUATION_NAME, NoLookupLocation.FROM_BACKEND)
+val COROUTINES_INTRINSICS_PACKAGE_FQ_NAME = DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME.child(Name.identifier("intrinsics"))
+
+fun FunctionDescriptor.isBuiltInSuspendCoroutineOrReturn(): Boolean {
+    if (name != SUSPEND_COROUTINE_OR_RETURN_NAME) return false
+
+    val originalDeclaration = getBuiltInSuspendCoroutineOrReturn() ?: return false
+
+    return DescriptorEquivalenceForOverrides.areEquivalent(
+            originalDeclaration, this
+    )
+}
+
+fun FunctionDescriptor.getBuiltInSuspendCoroutineOrReturn() =
+        module.getPackage(COROUTINES_INTRINSICS_PACKAGE_FQ_NAME).memberScope
+                .getContributedFunctions(SUSPEND_COROUTINE_OR_RETURN_NAME, NoLookupLocation.FROM_BACKEND)
                 .singleOrNull()

compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java

@@ -18,13 +18,19 @@ package org.jetbrains.kotlin.codegen;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenUtilKt;
 import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.descriptors.annotations.Annotations;
+import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 
+import java.util.LinkedHashMap;
+
 public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDescriptor implements AccessorForCallableDescriptor<FunctionDescriptor> {
     private final FunctionDescriptor calleeDescriptor;
     private final ClassDescriptor superCallTarget;
+    private final String nameSuffix;
 
     public AccessorForFunctionDescriptor(
             @NotNull FunctionDescriptor descriptor,
@@ -36,6 +42,7 @@ public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDe
               Name.identifier("access$" + nameSuffix));
         this.calleeDescriptor = descriptor;
         this.superCallTarget = superCallTarget;
+        this.nameSuffix = nameSuffix;
 
         initialize(DescriptorUtils.getReceiverParameterType(descriptor.getExtensionReceiverParameter()),
                    descriptor instanceof ConstructorDescriptor || CodegenUtilKt.isJvmStaticInObjectOrClass(descriptor)
@@ -46,6 +53,28 @@ public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDe
                    descriptor.getReturnType(),
                    Modality.FINAL,
                    Visibilities.LOCAL);
+
+        setSuspend(descriptor.isSuspend());
+        if (descriptor.getUserData(CoroutineCodegenUtilKt.INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION) != null) {
+            userDataMap = new LinkedHashMap<UserDataKey<?>, Object>();
+            userDataMap.put(
+                    CoroutineCodegenUtilKt.INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION,
+                    descriptor.getUserData(CoroutineCodegenUtilKt.INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION)
+            );
+        }
+    }
+
+    @NotNull
+    @Override
+    protected FunctionDescriptorImpl createSubstitutedCopy(
+            @NotNull DeclarationDescriptor newOwner,
+            @Nullable FunctionDescriptor original,
+            @NotNull Kind kind,
+            @Nullable Name newName,
+            @NotNull Annotations annotations,
+            @NotNull SourceElement source
+    ) {
+        return new AccessorForFunctionDescriptor(calleeDescriptor, newOwner, superCallTarget, nameSuffix);
     }
 
     @NotNull

compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java

@@ -76,9 +76,8 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem
             boolean setterAccessorRequired
     ) {
         super(containingDeclaration, null, Annotations.Companion.getEMPTY(), Modality.FINAL, Visibilities.LOCAL,
-              original.isVar(), Name.identifier("access$" + nameSuffix),
-              Kind.DECLARATION, SourceElement.NO_SOURCE, /* lateInit = */ false, /* isConst = */ false,
-              /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false);
+              original.isVar(), Name.identifier("access$" + nameSuffix), Kind.DECLARATION, SourceElement.NO_SOURCE,
+              false, false, false, false, false, false);
 
         this.calleeDescriptor = original;
         this.superCallTarget = superCallTarget;

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.codegen
 
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument
@@ -31,7 +32,12 @@ abstract class ArgumentGenerator {
      *
      * @see kotlin.reflect.jvm.internal.KCallableImpl.callBy
      */
-    open fun generate(valueArgumentsByIndex: List<ResolvedValueArgument>, actualArgs: List<ResolvedValueArgument>): DefaultCallArgs {
+    open fun generate(
+            valueArgumentsByIndex: List<ResolvedValueArgument>,
+            actualArgs: List<ResolvedValueArgument>,
+            // may be null for a constructor of an object literal
+            calleeDescriptor: CallableDescriptor?
+    ): DefaultCallArgs {
         assert(valueArgumentsByIndex.size == actualArgs.size) {
             "Value arguments collection should have same size, but ${valueArgumentsByIndex.size} != ${actualArgs.size}"
         }
@@ -48,7 +54,8 @@ abstract class ArgumentGenerator {
             }
         }
 
-        val defaultArgs = DefaultCallArgs(valueArgumentsByIndex.size)
+        // Use unwrapped version, because additional synthetic parameters can't have default values
+        val defaultArgs = DefaultCallArgs(calleeDescriptor?.unwrapFrontendVersion()?.valueParameters?.size ?: 0)
 
         for (argumentWithDeclIndex in actualArgsWithDeclIndex) {
             val argument = argumentWithDeclIndex.arg

compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java

@@ -168,6 +168,11 @@ public class AsmUtil {
         return Type.getType(internalName.substring(1));
     }
 
+    @NotNull
+    public static Type getArrayType(@NotNull Type componentType) {
+        return Type.getType("[" + componentType.getDescriptor());
+    }
+
     @Nullable
     public static PrimitiveType asmPrimitiveTypeToLangPrimitiveType(Type type) {
         JvmPrimitiveType jvmPrimitiveType = primitiveTypeByAsmSort.get(type.getSort());
@@ -181,7 +186,7 @@ public class AsmUtil {
 
     public static boolean isAbstractMethod(FunctionDescriptor functionDescriptor, OwnerKind kind, GenerationState state) {
         return (functionDescriptor.getModality() == Modality.ABSTRACT ||
-                (isJvmInterface(functionDescriptor.getContainingDeclaration()) && !state.isJvm8Target()))
+                (isJvmInterface(functionDescriptor.getContainingDeclaration()) && !state.isJvm8TargetWithDefaults()))
                && !isStaticMethod(kind, functionDescriptor);
     }
 
@@ -587,6 +592,10 @@ public class AsmUtil {
         v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "areEqual", "(Ljava/lang/Object;Ljava/lang/Object;)Z", false);
     }
 
+    public static void genIEEE754EqualForNullableTypesCall(InstructionAdapter v, Type left, Type right) {
+        v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "areEqual", "(" + left.getDescriptor() + right.getDescriptor() + ")Z", false);
+    }
+
     public static void numConst(int value, Type type, InstructionAdapter v) {
         if (type == Type.FLOAT_TYPE) {
             v.fconst(value);
@@ -761,6 +770,7 @@ public class AsmUtil {
         if (left == Type.DOUBLE_TYPE || right == Type.DOUBLE_TYPE) return Type.DOUBLE_TYPE;
         if (left == Type.FLOAT_TYPE || right == Type.FLOAT_TYPE) return Type.FLOAT_TYPE;
         if (left == Type.LONG_TYPE || right == Type.LONG_TYPE) return Type.LONG_TYPE;
+        if (left == Type.CHAR_TYPE || right == Type.CHAR_TYPE) return Type.CHAR_TYPE;
         return Type.INT_TYPE;
     }
 

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

@@ -210,7 +210,12 @@ class NumberCompare(
 ) : BranchedValue(left, right, operandType, NumberCompare.getNumberCompareOpcode(opToken)) {
 
     override fun patchOpcode(opcode: Int, v: InstructionAdapter): Int {
-        when (operandType) {
+        // Opcode takes one int operand from the stack
+        assert(opcode in IFEQ..IFLE) {
+            "Opcode for comparing must be in range ${IFEQ..IFLE}, but $opcode was found"
+        }
+
+        return when (operandType) {
             Type.FLOAT_TYPE, Type.DOUBLE_TYPE -> {
                 if (opToken == KtTokens.GT || opToken == KtTokens.GTEQ) {
                     v.cmpl(operandType)
@@ -218,17 +223,19 @@ class NumberCompare(
                 else {
                     v.cmpg(operandType)
                 }
+
+                opcode
             }
             Type.LONG_TYPE -> {
                 v.lcmp()
+
+                opcode
             }
             else -> {
-                return opcode + (IF_ICMPEQ - IFEQ)
+                opcode + (IF_ICMPEQ - IFEQ)
             }
         }
-        return opcode
     }
-
     companion object {
         fun getNumberCompareOpcode(opToken: IElementType): Int {
             return when (opToken) {
@@ -262,4 +269,4 @@ class ObjectCompare(
             }
         }
     }
-}
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java

@@ -17,10 +17,13 @@
 package org.jetbrains.kotlin.codegen;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.calls.model.*;
+import org.jetbrains.kotlin.types.FlexibleTypesKt;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.List;
@@ -53,11 +56,12 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator {
     @Override
     public DefaultCallArgs generate(
             @NotNull List<? extends ResolvedValueArgument> valueArgumentsByIndex,
-            @NotNull List<? extends ResolvedValueArgument> valueArgs
+            @NotNull List<? extends ResolvedValueArgument> valueArgs,
+            @Nullable CallableDescriptor calleeDescriptor
     ) {
         boolean shouldMarkLineNumbers = this.codegen.isShouldMarkLineNumbers();
         this.codegen.setShouldMarkLineNumbers(false);
-        DefaultCallArgs defaultArgs = super.generate(valueArgumentsByIndex, valueArgs);
+        DefaultCallArgs defaultArgs = super.generate(valueArgumentsByIndex, valueArgs, calleeDescriptor);
         this.codegen.setShouldMarkLineNumbers(shouldMarkLineNumbers);
         return defaultArgs;
     }
@@ -84,7 +88,9 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator {
     protected void generateVararg(int i, @NotNull VarargValueArgument argument) {
         ValueParameterDescriptor parameter = valueParameters.get(i);
         Type type = valueParameterTypes.get(i);
-        codegen.genVarargs(argument, parameter.getType());
+        // Upper bound for type of vararg parameter should always have a form of 'Array<out T>',
+        // while its lower bound may be Nothing-typed after approximation
+        codegen.genVarargs(argument, FlexibleTypesKt.upperIfFlexible(parameter.getType()));
         callGenerator.afterParameterPut(type, null, i);
     }
 

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

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
+import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Opcodes.INVOKESPECIAL
 import org.jetbrains.org.objectweb.asm.Opcodes.INVOKESTATIC
 import org.jetbrains.org.objectweb.asm.Type
@@ -35,7 +36,8 @@ class CallableMethod(
         private val invokeOpcode: Int,
         override val dispatchReceiverType: Type?,
         override val extensionReceiverType: Type?,
-        override val generateCalleeType: Type?
+        override val generateCalleeType: Type?,
+        private val isInterfaceMethod: Boolean = Opcodes.INVOKEINTERFACE == invokeOpcode
 ) : Callable {
     fun getValueParameters(): List<JvmMethodParameterSignature> =
             signature.valueParameters
@@ -51,7 +53,13 @@ class CallableMethod(
 
 
     override fun genInvokeInstruction(v: InstructionAdapter) {
-        v.visitMethodInsn(invokeOpcode, owner.internalName, getAsmMethod().name, getAsmMethod().descriptor)
+        v.visitMethodInsn(
+                invokeOpcode,
+                owner.internalName,
+                getAsmMethod().name,
+                getAsmMethod().descriptor,
+                isInterfaceMethod
+        )
     }
 
     fun genInvokeDefaultInstruction(v: InstructionAdapter) {
@@ -61,7 +69,7 @@ class CallableMethod(
 
         val method = getAsmMethod()
 
-        if ("<init>".equals(method.name)) {
+        if ("<init>" == method.name) {
             v.visitMethodInsn(INVOKESPECIAL, defaultImplOwner.internalName, "<init>", defaultMethodDesc, false)
         }
         else {

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java

@@ -77,9 +77,13 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
             }
         }
 
-        generatePrimaryConstructorProperties();
-        generateConstructors();
-        generateDefaultImplsIfNeeded();
+        boolean generateNonClassMembers = shouldGenerateNonClassMembers();
+
+        if (generateNonClassMembers) {
+            generatePrimaryConstructorProperties();
+            generateConstructors();
+            generateDefaultImplsIfNeeded();
+        }
 
         // Generate _declared_ companions
         for (KtObjectDeclaration companion : companions) {
@@ -92,23 +96,30 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
             genSyntheticClassOrObject((SyntheticClassOrObjectDescriptor) companionObjectDescriptor);
         }
 
-        if (!DescriptorUtils.isInterface(descriptor)) {
-            for (DeclarationDescriptor memberDescriptor : DescriptorUtils.getAllDescriptors(descriptor.getDefaultType().getMemberScope())) {
-                if (memberDescriptor instanceof CallableMemberDescriptor) {
-                    CallableMemberDescriptor member = (CallableMemberDescriptor) memberDescriptor;
-                    if (!member.getKind().isReal() && ImplKt.findInterfaceImplementation(member) == null) {
-                        if (member instanceof FunctionDescriptor) {
-                            functionCodegen.generateBridges((FunctionDescriptor) member);
+        if (generateNonClassMembers) {
+            generateBridges();
+        }
+    }
+
+    private void generateBridges() {
+        if (DescriptorUtils.isInterface(descriptor)) {
+            return;
+        }
+        for (DeclarationDescriptor memberDescriptor : DescriptorUtils.getAllDescriptors(descriptor.getDefaultType().getMemberScope())) {
+            if (memberDescriptor instanceof CallableMemberDescriptor) {
+                CallableMemberDescriptor member = (CallableMemberDescriptor) memberDescriptor;
+                if (!member.getKind().isReal() && ImplKt.findInterfaceImplementation(member) == null) {
+                    if (member instanceof FunctionDescriptor) {
+                        functionCodegen.generateBridges((FunctionDescriptor) member);
+                    }
+                    else if (member instanceof PropertyDescriptor) {
+                        PropertyGetterDescriptor getter = ((PropertyDescriptor) member).getGetter();
+                        if (getter != null) {
+                            functionCodegen.generateBridges(getter);
                         }
-                        else if (member instanceof PropertyDescriptor) {
-                            PropertyGetterDescriptor getter = ((PropertyDescriptor) member).getGetter();
-                            if (getter != null) {
-                                functionCodegen.generateBridges(getter);
-                            }
-                            PropertySetterDescriptor setter = ((PropertyDescriptor) member).getSetter();
-                            if (setter != null) {
-                                functionCodegen.generateBridges(setter);
-                            }
+                        PropertySetterDescriptor setter = ((PropertyDescriptor) member).getSetter();
+                        if (setter != null) {
+                            functionCodegen.generateBridges(setter);
                         }
                     }
                 }
@@ -116,6 +127,11 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
         }
     }
 
+    private boolean shouldGenerateNonClassMembers() {
+        return !(myClass instanceof KtClassOrObject) ||
+               state.getGenerateDeclaredClassFilter().shouldGenerateClassMembers((KtClassOrObject) myClass);
+    }
+
     protected void generateConstructors() {
 
     }
@@ -130,7 +146,9 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
 
     protected void generateDeclaration(KtDeclaration declaration) {
         if (declaration instanceof KtProperty || declaration instanceof KtNamedFunction || declaration instanceof KtTypeAlias) {
-            genSimpleMember(declaration);
+            if (shouldGenerateNonClassMembers()) {
+                genSimpleMember(declaration);
+            }
         }
         else if (declaration instanceof KtClassOrObject) {
             if (declaration instanceof KtEnumEntry && !enumEntryNeedSubclass(bindingContext, (KtEnumEntry) declaration)) {

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBuilderFactories.java

@@ -55,20 +55,12 @@ public class ClassBuilderFactories {
             throw new IllegalStateException();
         }
     };
-
-    public static ClassBuilderFactory TEST_KAPT3 = new TestClassBuilderFactory(false) {
-        @NotNull
-        @Override
-        public ClassBuilderMode getClassBuilderMode() {
-            return ClassBuilderMode.KAPT3;
-        }
-    };
     
     public static ClassBuilderFactory TEST = new TestClassBuilderFactory(false);
 
     public static ClassBuilderFactory TEST_WITH_SOURCE_RETENTION_ANNOTATIONS = new TestClassBuilderFactory(true);
     
-    private static class TestClassBuilderFactory implements ClassBuilderFactory {
+    public static class TestClassBuilderFactory implements ClassBuilderFactory {
         private final boolean generateSourceRetentionAnnotations;
 
         public TestClassBuilderFactory(boolean generateSourceRetentionAnnotations) {

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBuilderMode.java

@@ -16,6 +16,8 @@
 
 package org.jetbrains.kotlin.codegen;
 
+import org.jetbrains.annotations.TestOnly;
+
 public class ClassBuilderMode {
     public final boolean generateBodies;
     public final boolean generateMetadata;
@@ -73,4 +75,11 @@ public class ClassBuilderMode {
             /* metadata = */ true,
             /* sourceRetention = */ true,
             /* generateMultiFileFacadePartClasses = */ true);
+
+    @TestOnly
+    public final static ClassBuilderMode LIGHT_ANALYSIS_FOR_TESTS = new ClassBuilderMode(
+            /* bodies = */ false,
+            /* metadata = */ true,
+            /* sourceRetention = */ false,
+            /* generateMultiFileFacadePartClasses = */ true);
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java

@@ -82,7 +82,7 @@ public class ClassFileFactory implements OutputFileCollection {
         return answer;
     }
 
-    void done() {
+    public void done() {
         if (!isDone) {
             isDone = true;
             writeModuleMappings();

compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java

@@ -26,6 +26,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
 import org.jetbrains.kotlin.codegen.context.ClosureContext;
+import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor;
+import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenUtilKt;
 import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil;
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension;
 import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter;
@@ -33,13 +35,11 @@ import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader;
 import org.jetbrains.kotlin.psi.KtElement;
-import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
@@ -62,7 +62,6 @@ import java.util.List;
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConst;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE;
-import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.asmTypeForAnonymousClass;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
@@ -198,7 +197,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         );
     }
 
-    private void generateBridges() {
+    protected void generateBridges() {
         FunctionDescriptor erasedInterfaceFunction;
         if (samType == null) {
             erasedInterfaceFunction = getErasedInvokeFunction(funDescriptor);
@@ -231,9 +230,10 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
 
     @Override
     protected void generateKotlinMetadataAnnotation() {
-        FunctionDescriptor freeLambdaDescriptor = createFreeLambdaDescriptor(funDescriptor);
-        Method method = v.getSerializationBindings().get(METHOD_FOR_FUNCTION, funDescriptor);
-        assert method != null : "No method for " + funDescriptor;
+        FunctionDescriptor frontendFunDescriptor = CodegenUtilKt.unwrapFrontendVersion(funDescriptor);
+        FunctionDescriptor freeLambdaDescriptor = createFreeLambdaDescriptor(frontendFunDescriptor);
+        Method method = v.getSerializationBindings().get(METHOD_FOR_FUNCTION, frontendFunDescriptor);
+        assert method != null : "No method for " + frontendFunDescriptor;
         v.getSerializationBindings().put(METHOD_FOR_FUNCTION, freeLambdaDescriptor, method);
 
         final DescriptorSerializer serializer =
@@ -396,6 +396,9 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         }
         else if (container instanceof PackageFragmentDescriptor) {
             iv.aconst(state.getTypeMapper().mapOwner(descriptor));
+            // Note that this name is not used in reflection. There should be the name of the referenced declaration's module instead,
+            // but there's no nice API to obtain that name here yet
+            // TODO: write the referenced declaration's module name and use it in reflection
             iv.aconst(state.getModuleName());
             iv.invokestatic(REFLECTION, "getOrCreateKotlinPackage",
                             Type.getMethodDescriptor(K_DECLARATION_CONTAINER_TYPE, getType(Class.class), getType(String.class)), false);
@@ -429,7 +432,8 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
             iv.load(0, superClassAsmType);
 
             String superClassConstructorDescriptor;
-            if (superClassAsmType.equals(LAMBDA) || superClassAsmType.equals(FUNCTION_REFERENCE) || superClassAsmType.equals(COROUTINE_IMPL)) {
+            if (superClassAsmType.equals(LAMBDA) || superClassAsmType.equals(FUNCTION_REFERENCE) ||
+                superClassAsmType.equals(CoroutineCodegenUtilKt.COROUTINE_IMPL_ASM_TYPE)) {
                 int arity = calculateArity();
                 iv.iconst(arity);
                 if (shouldHaveBoundReferenceReceiver) {
@@ -466,7 +470,6 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
             @NotNull CalculatedClosure closure,
             @NotNull Type ownerType
     ) {
-        BindingContext bindingContext = typeMapper.getBindingContext();
         List<FieldInfo> args = Lists.newArrayList();
         ClassDescriptor captureThis = closure.getCaptureThis();
         if (captureThis != null) {
@@ -478,23 +481,15 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
             args.add(FieldInfo.createForHiddenField(ownerType, typeMapper.mapType(captureReceiverType), CAPTURED_RECEIVER_FIELD));
         }
 
-        for (DeclarationDescriptor descriptor : closure.getCaptureVariables().keySet()) {
-            if (descriptor instanceof VariableDescriptor && !(descriptor instanceof PropertyDescriptor)) {
-                Type type = typeMapper.getSharedVarType(descriptor);
-                if (type == null && descriptor instanceof LocalVariableDescriptor) {
-                    KotlinType delegateType = JvmCodegenUtil.getPropertyDelegateType((LocalVariableDescriptor) descriptor, bindingContext);
-                    if (delegateType != null) {
-                        type = typeMapper.mapType(delegateType);
-                    }
-                }
-                if (type == null) {
-                    type = typeMapper.mapType((VariableDescriptor) descriptor);
-                }
-                args.add(FieldInfo.createForHiddenField(ownerType, type, "$" + descriptor.getName().asString()));
-            }
-            else if (ExpressionTypingUtils.isLocalFunction(descriptor)) {
-                Type classType = asmTypeForAnonymousClass(bindingContext, (FunctionDescriptor) descriptor);
-                args.add(FieldInfo.createForHiddenField(ownerType, classType, "$" + descriptor.getName().asString()));
+        for (EnclosedValueDescriptor enclosedValueDescriptor : closure.getCaptureVariables().values()) {
+            DeclarationDescriptor descriptor = enclosedValueDescriptor.getDescriptor();
+            if ((descriptor instanceof VariableDescriptor && !(descriptor instanceof PropertyDescriptor)) ||
+                ExpressionTypingUtils.isLocalFunction(descriptor)) {
+                args.add(
+                        FieldInfo.createForHiddenField(
+                                ownerType, enclosedValueDescriptor.getType(), enclosedValueDescriptor.getFieldName()
+                        )
+                );
             }
             else if (descriptor instanceof FunctionDescriptor) {
                 assert captureReceiverType != null;

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

@@ -17,12 +17,8 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.psi.KtDeclarationWithBody
-import org.jetbrains.kotlin.psi.KtParameter
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
 
 class ClosureGenerationStrategy(
         state: GenerationState,
@@ -30,35 +26,8 @@ class ClosureGenerationStrategy(
 ) : FunctionGenerationStrategy.FunctionDefault(state, declaration) {
 
     override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
-        processDestructuringInLambdaParameters(codegen)
+        initializeVariablesForDestructuredLambdaParameters(codegen, codegen.context.functionDescriptor.valueParameters)
 
         super.doGenerateBody(codegen, signature)
     }
-
-    private fun processDestructuringInLambdaParameters(codegen: ExpressionCodegen) {
-        val savedIsShouldMarkLineNumbers = codegen.isShouldMarkLineNumbers
-        // Do not write line numbers until destructuring happens
-        // (otherwise destructuring variables will be uninitialized in the beginning of lambda)
-        codegen.isShouldMarkLineNumbers = false
-
-        for (parameterDescriptor in codegen.context.functionDescriptor.valueParameters) {
-            if (parameterDescriptor !is ValueParameterDescriptorImpl.WithDestructuringDeclaration) continue
-
-            for (entry in parameterDescriptor.destructuringVariables.filterOutDescriptorsWithSpecialNames()) {
-                codegen.myFrameMap.enter(entry, codegen.typeMapper.mapType(entry.type))
-            }
-
-            val destructuringDeclaration =
-                    (DescriptorToSourceUtils.descriptorToDeclaration(parameterDescriptor) as? KtParameter)?.destructuringDeclaration
-                    ?: error("Destructuring declaration for descriptor $parameterDescriptor not found")
-
-            codegen.initializeDestructuringDeclarationVariables(
-                    destructuringDeclaration,
-                    TransientReceiver(parameterDescriptor.type),
-                    codegen.findLocalOrCapturedValue(parameterDescriptor) ?: error("Local var not found for parameter $parameterDescriptor")
-            )
-        }
-
-        codegen.isShouldMarkLineNumbers = savedIsShouldMarkLineNumbers
-    }
 }

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.getSpecialSignatureInfo
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.isBuiltinWithSpecialDescriptorInJvm
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor

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

@@ -54,7 +54,7 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
             contextKind: OwnerKind,
             classOrObject: KtPureClassOrObject
     ) {
-        val methodElement = classOrObject.getPrimaryConstructor() ?: classOrObject
+        val methodElement = classOrObject.primaryConstructor ?: classOrObject
 
         if (generateOverloadsIfNeeded(methodElement, constructorDescriptor, constructorDescriptor, contextKind, classBuilder, memberCodegen)) {
             return
@@ -128,12 +128,14 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
     ) {
         val typeMapper = state.typeMapper
         val isStatic = AsmUtil.isStaticMethod(contextKind, functionDescriptor)
-        val flags = AsmUtil.getCommonCallableFlags(functionDescriptor) or
-                (if (isStatic) Opcodes.ACC_STATIC else 0) or
-                (if (functionDescriptor.modality == Modality.FINAL && functionDescriptor !is ConstructorDescriptor) Opcodes.ACC_FINAL else 0)
-
+        val baseMethodFlags = AsmUtil.getCommonCallableFlags(functionDescriptor) and Opcodes.ACC_VARARGS.inv()
         val remainingParameters = getRemainingParameters(functionDescriptor.original, substituteCount)
-        val signature = typeMapper.mapSignature(functionDescriptor, contextKind, remainingParameters, false)
+        val flags =
+                baseMethodFlags or
+                (if (isStatic) Opcodes.ACC_STATIC else 0) or
+                (if (functionDescriptor.modality == Modality.FINAL && functionDescriptor !is ConstructorDescriptor) Opcodes.ACC_FINAL else 0) or
+                (if (remainingParameters.lastOrNull()?.varargElementType != null) Opcodes.ACC_VARARGS else 0)
+        val signature = typeMapper.mapSignatureWithCustomParameters(functionDescriptor, contextKind, remainingParameters, false)
         val mv = classBuilder.newMethod(OtherOrigin(methodElement, functionDescriptor), flags,
                                         signature.asmMethod.name,
                                         signature.asmMethod.descriptor,
@@ -146,10 +148,7 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
             mv.visitAnnotation(ANNOTATION_TYPE_DESCRIPTOR_FOR_JVMOVERLOADS_GENERATED_METHODS, /* visible = */ false)
         }
 
-        remainingParameters.withIndex().forEach {
-            val annotationCodegen = AnnotationCodegen.forParameter(it.index, mv, memberCodegen, typeMapper)
-            annotationCodegen.genAnnotations(it.value, signature.valueParameters[it.index].asmType)
-        }
+        FunctionCodegen.generateParameterAnnotations(functionDescriptor, mv, signature, remainingParameters, memberCodegen, state)
 
         if (!state.classBuilderMode.generateBodies) {
             FunctionCodegen.generateLocalVariablesForParameters(mv, signature, null, Label(), Label(), remainingParameters, isStatic, typeMapper)
@@ -252,7 +251,7 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
         val classDescriptor = constructorDescriptor.constructedClass
         if (classDescriptor.kind != ClassKind.CLASS) return false
 
-        if (classOrObject.isLocal()) return false
+        if (classOrObject.isLocal) return false
 
         if (CodegenBinding.canHaveOuter(state.bindingContext, classDescriptor)) return false
 
@@ -266,6 +265,6 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
     }
 
     private fun hasSecondaryConstructorsWithNoParameters(klass: KtClass) =
-        klass.getSecondaryConstructors().any { it.valueParameters.isEmpty() }
+        klass.secondaryConstructors.any { it.valueParameters.isEmpty() }
 
 }

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

@@ -33,10 +33,10 @@ abstract class DelegatingClassBuilderFactory(
     abstract override fun newClassBuilder(origin: JvmDeclarationOrigin): DelegatingClassBuilder
 
     override fun asBytes(builder: ClassBuilder?): ByteArray? {
-        return delegate.asBytes((builder as DelegatingClassBuilder).getDelegate())
+        return delegate.asBytes((builder as DelegatingClassBuilder).delegate)
     }
 
     override fun asText(builder: ClassBuilder?): String? {
-        return delegate.asText((builder as DelegatingClassBuilder).getDelegate())
+        return delegate.asText((builder as DelegatingClassBuilder).delegate)
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2016 JetBrains s.r.o.
+ * 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.
@@ -50,8 +50,8 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.codegen.when.SwitchCodegen;
 import org.jetbrains.kotlin.codegen.when.SwitchCodegenUtil;
+import org.jetbrains.kotlin.config.ApiVersion;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor;
@@ -61,6 +61,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor;
+import org.jetbrains.kotlin.load.kotlin.TypeSignatureMappingKt;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
@@ -157,43 +158,18 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         this.v = new InstructionAdapter(mv);
         this.myFrameMap = frameMap;
         this.context = context;
-
-        FunctionDescriptor originalSuspendDescriptor = getOriginalSuspendDescriptor(context);
-        if (originalSuspendDescriptor != null && originalSuspendDescriptor.getReturnType() != null) {
-            this.returnType = getBoxedReturnTypeForSuspend(originalSuspendDescriptor);
-        }
-        else {
-            this.returnType = returnType;
-        }
+        this.returnType = returnType;
 
         this.parentCodegen = parentCodegen;
         this.tailRecursionCodegen = new TailRecursionCodegen(context, this, this.v, state);
     }
 
-    @NotNull
-    private Type getBoxedReturnTypeForSuspend(FunctionDescriptor descriptorForSuspend) {
-        assert descriptorForSuspend.getReturnType() != null : "Uninitialized suspend return type";
-        return AsmUtil.boxType(typeMapper.mapType(descriptorForSuspend.getReturnType()));
-    }
-
     @Nullable
-    private static FunctionDescriptor getOriginalSuspendDescriptor(MethodContext context) {
-        FunctionDescriptor originalCoroutineDescriptor = getOriginalCoroutineDescriptor(context);
-        if (originalCoroutineDescriptor != null) return originalCoroutineDescriptor;
-
-        if (context.getFunctionDescriptor().isSuspend()) {
-            return (FunctionDescriptor) CoroutineCodegenUtilKt.unwrapInitialDescriptorForSuspendFunction(context.getFunctionDescriptor());
-        }
-
-        return null;
-    }
-
-    @Nullable
-    private static FunctionDescriptor getOriginalCoroutineDescriptor(MethodContext context) {
+    private static FunctionDescriptor getOriginalSuspendLambdaDescriptorFromContext(MethodContext context) {
         if ((context.getParentContext() instanceof ClosureContext) &&
             (context.getParentContext().closure != null) &&
-            context.getParentContext().closure.isCoroutine()) {
-            return ((ClosureContext) context.getParentContext()).getCoroutineDescriptor();
+            context.getParentContext().closure.isSuspend()) {
+            return ((ClosureContext) context.getParentContext()).getOriginalSuspendLambdaDescriptor();
         }
 
         return null;
@@ -455,6 +431,16 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return typeMapper.mapType(type);
     }
 
+    @NotNull
+    private Type expressionTypeForBranchingOperation(@Nullable KtExpression expression) {
+        if (context.getFunctionDescriptor().isSuspend() &&
+            !CoroutineCodegenUtilKt.isStateMachineNeeded(context.getFunctionDescriptor(), bindingContext) &&
+            Boolean.TRUE.equals(bindingContext.get(IS_TAIL_EXPRESSION_IN_SUSPEND_FUNCTION, expression))) {
+            return AsmTypes.OBJECT_TYPE;
+        }
+        return expressionType(expression);
+    }
+
     @NotNull
     public Type expressionType(@Nullable KtExpression expression) {
         return CodegenUtilKt.asmType(expression, typeMapper, bindingContext);
@@ -495,7 +481,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     }
 
     /* package */ StackValue generateIfExpression(@NotNull final KtIfExpression expression, final boolean isStatement) {
-        final Type asmType = isStatement ? Type.VOID_TYPE : expressionType(expression);
+        final Type asmType = isStatement ? Type.VOID_TYPE : expressionTypeForBranchingOperation(expression);
         final StackValue condition = gen(expression.getCondition());
 
         final KtExpression thenExpression = expression.getThen();
@@ -587,6 +573,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         blockStackElements.push(new LoopBlockStackElement(breakLabel, continueLabel, targetLabel(expression)));
 
         PseudoInsnsKt.fakeAlwaysFalseIfeq(v, continueLabel);
+        PseudoInsnsKt.fakeAlwaysFalseIfeq(v, breakLabel);
 
         KtExpression body = expression.getBody();
         KtExpression condition = expression.getCondition();
@@ -1531,6 +1518,10 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         }
 
         KotlinType expectedType = bindingContext.getType(expression);
+        if (expectedType == null) {
+            return null;
+        }
+
         return compileTimeValue.toConstantValue(expectedType);
     }
 
@@ -1649,7 +1640,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                 declaration.getContainingFile()
         );
 
-        ClosureCodegen coroutineCodegen = CoroutineCodegen.create(this, descriptor, declaration, cv);
+        ClosureCodegen coroutineCodegen = CoroutineCodegen.createByLambda(this, descriptor, declaration, cv);
         ClosureCodegen closureCodegen = coroutineCodegen != null ? coroutineCodegen : new ClosureCodegen(
                 state, declaration, samType, context.intoClosure(descriptor, this, typeMapper),
                 functionReferenceTarget, strategy, parentCodegen, cv
@@ -1657,6 +1648,14 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         closureCodegen.generate();
 
+        return putClosureInstanceOnStack(closureCodegen, functionReferenceReceiver);
+    }
+
+    @NotNull
+    public StackValue putClosureInstanceOnStack(
+            @NotNull ClosureCodegen closureCodegen,
+            @Nullable StackValue functionReferenceReceiver
+    ) {
         if (closureCodegen.getReifiedTypeParametersUsages().wereUsedReifiedParameters()) {
             ReifiedTypeInliner.putNeedClassReificationMarker(v);
             propagateChildReifiedTypeParametersUsages(closureCodegen.getReifiedTypeParametersUsages());
@@ -1710,7 +1709,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                     ArgumentGenerator argumentGenerator =
                             new CallBasedArgumentGenerator(ExpressionCodegen.this, defaultCallGenerator, valueParameters, mappedTypes);
 
-                    argumentGenerator.generate(valueArguments, valueArguments);
+                    argumentGenerator.generate(valueArguments, valueArguments, null);
                 }
 
                 Collection<ClassConstructorDescriptor> constructors = classDescriptor.getConstructors();
@@ -1748,7 +1747,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         if (captureReceiver != null) {
             StackValue capturedReceiver =
                     functionReferenceReceiver != null ? functionReferenceReceiver :
-                    generateExtensionReceiver(unwrapOriginalLambdaDescriptorForCoroutine(context));
+                    generateExtensionReceiver(unwrapOriginalReceiverOwnerForSuspendFunction(context));
             callGenerator.putCapturedValueOnStack(capturedReceiver, capturedReceiver.type, paramIndex++);
         }
 
@@ -1769,16 +1768,36 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             );
         }
 
-        if (closure.isCoroutine()) {
+        if (closure.isSuspend()) {
             // resultContinuation
-            v.aconst(null);
+            if (closure.isSuspendLambda()) {
+                v.aconst(null);
+            }
+            else {
+                assert context.getFunctionDescriptor().isSuspend() : "Coroutines closure must be created only inside suspend functions";
+                ValueParameterDescriptor continuationParameter = CollectionsKt.last(context.getFunctionDescriptor().getValueParameters());
+                StackValue continuationValue = findLocalOrCapturedValue(continuationParameter);
+
+                assert continuationValue != null : "Couldn't find a value for continuation parameter of " + context.getFunctionDescriptor();
+
+                callGenerator.putCapturedValueOnStack(continuationValue, continuationValue.type, paramIndex++);
+            }
         }
     }
 
     @NotNull
-    private static CallableDescriptor unwrapOriginalLambdaDescriptorForCoroutine(@NotNull MethodContext context) {
-        FunctionDescriptor coroutine = getOriginalSuspendDescriptor(context);
-        if (coroutine != null) return coroutine;
+    private static CallableDescriptor unwrapOriginalReceiverOwnerForSuspendFunction(@NotNull MethodContext context) {
+        FunctionDescriptor originalForDoResume =
+                context.getFunctionDescriptor().getUserData(CoroutineCodegenUtilKt.INITIAL_SUSPEND_DESCRIPTOR_FOR_DO_RESUME);
+
+        if (originalForDoResume != null) {
+            return originalForDoResume;
+        }
+
+        if (context.getFunctionDescriptor().isSuspend()) {
+            return CoroutineCodegenUtilKt.unwrapInitialDescriptorForSuspendFunction(context.getFunctionDescriptor());
+        }
+
         return context.getFunctionDescriptor();
     }
 
@@ -1869,17 +1888,17 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
     @Nullable
     private StackValue getCoroutineInstanceValueForSuspensionPoint(@NotNull ResolvedCall<?> resolvedCall) {
-        CallableDescriptor enclosingSuspendLambdaForSuspensionPoint =
-                bindingContext.get(ENCLOSING_SUSPEND_LAMBDA_FOR_SUSPENSION_POINT, resolvedCall.getCall());
+        FunctionDescriptor enclosingSuspendLambdaForSuspensionPoint =
+                bindingContext.get(ENCLOSING_SUSPEND_FUNCTION_FOR_SUSPEND_FUNCTION_CALL, resolvedCall.getCall());
 
         if (enclosingSuspendLambdaForSuspensionPoint == null) return null;
-        return genCoroutineInstanceByLambda(enclosingSuspendLambdaForSuspensionPoint);
+        return genCoroutineInstanceBySuspendFunction(enclosingSuspendLambdaForSuspensionPoint);
     }
 
-    @NotNull
-    private StackValue genCoroutineInstanceByLambda(@NotNull CallableDescriptor suspendLambda) {
-        ClassDescriptor suspendLambdaClassDescriptor =
-                bindingContext.get(CodegenBinding.CLASS_FOR_CALLABLE, suspendLambda);
+    @Nullable
+    private StackValue genCoroutineInstanceBySuspendFunction(@NotNull FunctionDescriptor suspendFunction) {
+        if (!CoroutineCodegenUtilKt.isStateMachineNeeded(suspendFunction, bindingContext)) return null;
+        ClassDescriptor suspendLambdaClassDescriptor = bindingContext.get(CodegenBinding.CLASS_FOR_CALLABLE, suspendFunction);
         assert suspendLambdaClassDescriptor != null : "Coroutine class descriptor should not be null";
 
         return StackValue.thisOrOuter(this, suspendLambdaClassDescriptor, false, false);
@@ -1900,11 +1919,6 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return asmType(varType);
     }
 
-    private static boolean isSharedVarType(@NotNull Type type) {
-        return type.getSort() == Type.OBJECT && type.getInternalName().startsWith(REF_TYPE_PREFIX);
-    }
-
-
     private void putDescriptorIntoFrameMap(@NotNull KtElement statement) {
         if (statement instanceof KtDestructuringDeclaration) {
             KtDestructuringDeclaration multiDeclaration = (KtDestructuringDeclaration) statement;
@@ -2208,7 +2222,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                     FunctionDescriptor containingFunction =
                             BindingContextUtils.getContainingFunctionSkipFunctionLiterals(descriptor, true).getFirst();
                     //FIRST_FUN_LABEL to prevent clashing with existing labels
-                    return new NonLocalReturnInfo(getReturnTypeForNonLocalReturn(containingFunction), InlineCodegenUtil.FIRST_FUN_LABEL);
+                    return new NonLocalReturnInfo(typeMapper.mapReturnType(containingFunction), InlineCodegenUtil.FIRST_FUN_LABEL);
                 } else {
                     //local
                     return null;
@@ -2220,27 +2234,18 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                 DeclarationDescriptor elementDescriptor = typeMapper.getBindingContext().get(DECLARATION_TO_DESCRIPTOR, element);
                 assert element != null : "Expression should be not null " + expression.getText();
                 assert elementDescriptor != null : "Descriptor should be not null: " + element.getText();
-                return new NonLocalReturnInfo(getReturnTypeForNonLocalReturn(elementDescriptor), expression.getLabelName());
+                return new NonLocalReturnInfo(typeMapper.mapReturnType((CallableDescriptor) elementDescriptor), expression.getLabelName());
             }
         }
         return null;
     }
 
-    @NotNull
-    private Type getReturnTypeForNonLocalReturn(DeclarationDescriptor elementDescriptor) {
-        return (elementDescriptor instanceof AnonymousFunctionDescriptor
-            && ((AnonymousFunctionDescriptor) elementDescriptor).isCoroutine())
-            || (elementDescriptor instanceof FunctionDescriptor && ((FunctionDescriptor) elementDescriptor).isSuspend())
-        ? getBoxedReturnTypeForSuspend((FunctionDescriptor) elementDescriptor)
-        : typeMapper.mapReturnType((CallableDescriptor) elementDescriptor);
-    }
-
     public void returnExpression(KtExpression expr) {
         boolean isBlockedNamedFunction = expr instanceof KtBlockExpression && expr.getParent() instanceof KtNamedFunction;
 
-        FunctionDescriptor originalCoroutineDescriptor = getOriginalCoroutineDescriptor(context);
+        FunctionDescriptor originalSuspendLambdaDescriptor = getOriginalSuspendLambdaDescriptorFromContext(context);
         boolean isVoidCoroutineLambda =
-                originalCoroutineDescriptor != null && typeMapper.mapReturnType(originalCoroutineDescriptor).getSort() == Type.VOID;
+                originalSuspendLambdaDescriptor != null && TypeSignatureMappingKt.hasVoidReturnType(originalSuspendLambdaDescriptor);
 
         // If generating body for named block-bodied function or Unit-typed coroutine lambda, generate it as sequence of statements
         Type typeForExpression =
@@ -2492,14 +2497,14 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     }
 
     public int lookupLocalIndex(DeclarationDescriptor descriptor) {
-        return myFrameMap.getIndex(getParameterSynonymOrThis(descriptor));
-    }
-
-    private DeclarationDescriptor getParameterSynonymOrThis(DeclarationDescriptor descriptor) {
-        if (!(descriptor instanceof ValueParameterDescriptor)) return descriptor;
+        int index = myFrameMap.getIndex(descriptor);
+        if (index != -1) return index;
 
+        if (!(descriptor instanceof ValueParameterDescriptor)) return -1;
         DeclarationDescriptor synonym = bindingContext.get(CodegenBinding.PARAMETER_SYNONYM, (ValueParameterDescriptor) descriptor);
-        return synonym != null ? synonym : descriptor;
+        if (synonym == null) return -1;
+
+        return myFrameMap.getIndex(synonym);
     }
 
     @NotNull
@@ -2590,7 +2595,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         if (!skipPropertyAccessors) {
             if (!couldUseDirectAccessToProperty(propertyDescriptor, true, isDelegatedProperty, context, state.getShouldInlineConstVals())) {
-                propertyDescriptor = context.getAccessorForSuperCallIfNeeded(propertyDescriptor, superCallTarget);
+                propertyDescriptor = context.getAccessorForSuperCallIfNeeded(propertyDescriptor, superCallTarget, state);
 
                 propertyDescriptor = context.accessibleDescriptor(propertyDescriptor, superCallTarget);
 
@@ -2727,6 +2732,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         if (originalIfSamAdapter != null) {
             descriptor = originalIfSamAdapter;
         }
+
+        descriptor = CoroutineCodegenUtilKt.unwrapInitialDescriptorForSuspendFunction(descriptor);
+
         // $default method is not private, so you need no accessor to call it
         return CallUtilKt.usesDefaultArguments(resolvedCall)
                ? descriptor
@@ -2757,7 +2765,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         FunctionDescriptor fd = accessibleFunctionDescriptor(resolvedCall);
         ClassDescriptor superCallTarget = getSuperCallTarget(call);
 
-        fd = context.getAccessorForSuperCallIfNeeded(fd, superCallTarget);
+        fd = context.getAccessorForSuperCallIfNeeded(fd, superCallTarget, state);
 
         Collection<ExpressionCodegenExtension> codegenExtensions = ExpressionCodegenExtension.Companion.getInstances(state.getProject());
         if (!codegenExtensions.isEmpty()) {
@@ -2770,29 +2778,17 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         Callable callable = resolveToCallable(fd, superCallTarget != null, resolvedCall);
 
-
-        StackValue result = callable.invokeMethodWithArguments(resolvedCall, receiver, this);
-
-        if (bindingContext.get(BindingContext.ENCLOSING_SUSPEND_FUNCTION_FOR_SUSPEND_FUNCTION_CALL, resolvedCall.getCall()) != null) {
-            // Suspend function's calls inside another suspend function should behave like they leave values of correct type,
-            // while real methods return java/lang/Object.
-            // NB: They are always in return position at the moment.
-            // If we didn't do this, StackValue.coerce would add proper CHECKCAST that would've failed in case of callee function
-            // returning SUSPENDED marker, which is instance of java/lang/Object.
-            return new OperationStackValue(returnType, ((OperationStackValue) result).getLambda());
-        }
-
-        return result;
+        return callable.invokeMethodWithArguments(resolvedCall, receiver, this);
     }
 
     private StackValue getContinuationParameterFromEnclosingSuspendFunction(@NotNull ResolvedCall<?> resolvedCall) {
-        SimpleFunctionDescriptor enclosingSuspendFunction =
+        FunctionDescriptor enclosingSuspendFunction =
                 bindingContext.get(BindingContext.ENCLOSING_SUSPEND_FUNCTION_FOR_SUSPEND_FUNCTION_CALL, resolvedCall.getCall());
 
         assert enclosingSuspendFunction != null
                 : "Suspend functions may be called either as suspension points or from another suspend function";
 
-        SimpleFunctionDescriptor enclosingSuspendFunctionJvmView =
+        FunctionDescriptor enclosingSuspendFunctionJvmView =
                 bindingContext.get(CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, enclosingSuspendFunction);
 
         assert enclosingSuspendFunctionJvmView != null : "No JVM view function found for " + enclosingSuspendFunction;
@@ -2856,17 +2852,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             @NotNull CallGenerator callGenerator,
             @NotNull ArgumentGenerator argumentGenerator
     ) {
-        boolean isSuspensionPoint = CoroutineCodegenUtilKt.isSuspensionPoint(resolvedCall, bindingContext);
-        if (isSuspensionPoint) {
-            // Inline markers are used to spill the stack before coroutine suspension
-            addInlineMarker(v, true);
-        }
+        boolean isSuspensionPoint = CoroutineCodegenUtilKt.isSuspensionPointInStateMachine(resolvedCall, bindingContext);
         boolean isConstructor = resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor;
-        if (!isConstructor) { // otherwise already
-            receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
-            receiver.put(receiver.type, v);
-            callableMethod.afterReceiverGeneration(v);
-        }
+        putReceiverAndInlineMarkerIfNeeded(callableMethod, resolvedCall, receiver, isSuspensionPoint, isConstructor);
 
         callGenerator.processAndPutHiddenParameters(false);
 
@@ -2874,7 +2862,11 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         assert valueArguments != null : "Failed to arrange value arguments by index: " + resolvedCall.getResultingDescriptor();
 
         DefaultCallArgs defaultArgs =
-                argumentGenerator.generate(valueArguments, new ArrayList<ResolvedValueArgument>(resolvedCall.getValueArguments().values()));
+                argumentGenerator.generate(
+                        valueArguments,
+                        new ArrayList<ResolvedValueArgument>(resolvedCall.getValueArguments().values()),
+                        resolvedCall.getResultingDescriptor()
+                );
 
         if (tailRecursionCodegen.isTailRecursion(resolvedCall)) {
             tailRecursionCodegen.generateTailRecursion(resolvedCall);
@@ -2917,6 +2909,78 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         }
     }
 
+    private void putReceiverAndInlineMarkerIfNeeded(
+            @NotNull Callable callableMethod,
+            @NotNull ResolvedCall<?> resolvedCall,
+            @NotNull StackValue receiver,
+            boolean isSuspensionPoint,
+            boolean isConstructor
+    ) {
+        boolean isSafeCallOrOnStack = receiver instanceof StackValue.SafeCall || receiver instanceof StackValue.OnStack;
+
+        if (isSuspensionPoint && !isSafeCallOrOnStack) {
+            // Inline markers are used to spill the stack before coroutine suspension
+            addInlineMarker(v, true);
+        }
+
+        if (!isConstructor) { // otherwise already
+            receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
+            receiver.put(receiver.type, v);
+
+            // In regular cases we add an inline marker just before receiver is loaded (to spill the stack before a suspension)
+            // But in case of safe call things we get the following bytecode:
+
+            // ---- inlineMarkerBefore()
+            // LOAD $receiver
+            // IFNULL L1
+            // ---- load the rest of the arguments
+            // INVOKEVIRTUAL suspendCall()
+            // ---- inlineMarkerBefore()
+            // GOTO L2
+            // L1
+            // ACONST_NULL
+            // L2
+            // ...
+            //
+            // The problem is that the stack before the call is not restored in case of null receiver.
+            // The solution is to spill stack just after receiver is loaded (after IFNULL) in case of safe call.
+            // But the problem is that we should leave the receiver itself on the stack, so we store it in a temporary variable.
+            if (isSuspensionPoint && isSafeCallOrOnStack) {
+                boolean bothReceivers =
+                        receiver instanceof StackValue.CallReceiver
+                        && ((StackValue.CallReceiver) receiver).getDispatchReceiver().type.getSort() != Type.VOID
+                        && ((StackValue.CallReceiver) receiver).getExtensionReceiver().type.getSort() != Type.VOID;
+                Type firstReceiverType =
+                        bothReceivers
+                        ? ((StackValue.CallReceiver) receiver).getDispatchReceiver().type
+                        : receiver.type;
+
+                Type secondReceiverType = bothReceivers ? receiver.type : null;
+
+                int tmpVarForFirstReceiver = myFrameMap.enterTemp(firstReceiverType);
+                int tmpVarForSecondReceiver = -1;
+
+                if (secondReceiverType != null) {
+                    tmpVarForSecondReceiver = myFrameMap.enterTemp(secondReceiverType);
+                    v.store(tmpVarForSecondReceiver, secondReceiverType);
+                }
+                v.store(tmpVarForFirstReceiver, firstReceiverType);
+
+                addInlineMarker(v, true);
+
+                v.load(tmpVarForFirstReceiver, firstReceiverType);
+                if (secondReceiverType != null) {
+                    v.load(tmpVarForSecondReceiver, secondReceiverType);
+                    myFrameMap.leaveTemp(secondReceiverType);
+                }
+
+                myFrameMap.leaveTemp(firstReceiverType);
+            }
+
+            callableMethod.afterReceiverGeneration(v);
+        }
+    }
+
     @NotNull
     private CallGenerator getOrCreateCallGenerator(
             @NotNull CallableDescriptor descriptor,
@@ -2960,7 +3024,8 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
     @NotNull
     CallGenerator getOrCreateCallGenerator(@NotNull ResolvedCall<?> resolvedCall, @NotNull CallableDescriptor descriptor) {
-        Map<TypeParameterDescriptor, KotlinType> typeArguments = resolvedCall.getTypeArguments();
+        Map<TypeParameterDescriptor, KotlinType> typeArguments = getTypeArgumentsForResolvedCall(resolvedCall, descriptor);
+
         TypeParameterMappings mappings = new TypeParameterMappings();
         for (Map.Entry<TypeParameterDescriptor, KotlinType> entry : typeArguments.entrySet()) {
             TypeParameterDescriptor key = entry.getKey();
@@ -2985,9 +3050,38 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                 );
             }
         }
+
         return getOrCreateCallGenerator(descriptor, resolvedCall.getCall().getCallElement(), mappings, false);
     }
 
+    @NotNull
+    private static Map<TypeParameterDescriptor, KotlinType> getTypeArgumentsForResolvedCall(
+            @NotNull ResolvedCall<?> resolvedCall,
+            @NotNull CallableDescriptor descriptor
+    ) {
+        if (!(descriptor instanceof TypeAliasConstructorDescriptor)) {
+            return resolvedCall.getTypeArguments();
+        }
+
+        TypeAliasConstructorDescriptor typeAliasConstructorDescriptor = (TypeAliasConstructorDescriptor) descriptor;
+        ClassConstructorDescriptor underlyingConstructorDescriptor = typeAliasConstructorDescriptor.getUnderlyingConstructorDescriptor();
+        KotlinType resultingType = typeAliasConstructorDescriptor.getReturnType();
+        List<TypeProjection> typeArgumentsForReturnType = resultingType.getArguments();
+        List<TypeParameterDescriptor> typeParameters = underlyingConstructorDescriptor.getTypeParameters();
+
+        assert typeParameters.size() == typeArgumentsForReturnType.size() :
+                "Type parameters of the underlying constructor " + underlyingConstructorDescriptor +
+                "should correspond to type arguments for the resulting type " + resultingType;
+
+        Map<TypeParameterDescriptor, KotlinType> typeArgumentsMap = Maps.newHashMapWithExpectedSize(typeParameters.size());
+        for (TypeParameterDescriptor typeParameter: typeParameters) {
+            KotlinType typeArgument = typeArgumentsForReturnType.get(typeParameter.getIndex()).getType();
+            typeArgumentsMap.put(typeParameter, typeArgument);
+        }
+
+        return typeArgumentsMap;
+    }
+
 
     @Nullable
     private static Pair<TypeParameterDescriptor, ReificationArgument> extractReificationArgument(@NotNull KotlinType type) {
@@ -3097,7 +3191,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         boolean isSingleton = calleeContainingClass.getKind().isSingleton();
         if (isSingleton) {
             if (calleeContainingClass.equals(context.getThisDescriptor()) &&
-                !CodegenUtilKt.isJvmStaticInObjectOrClass(context.getContextDescriptor())) {
+                !CodegenUtilKt.isJvmStaticInObjectOrClass(context.getFunctionDescriptor())) {
                 return StackValue.local(0, typeMapper.mapType(calleeContainingClass));
             }
             else if (isEnumEntry(calleeContainingClass)) {
@@ -3324,7 +3418,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             @Override
             public Unit invoke(InstructionAdapter v) {
                 KotlinType type = lhs.getType();
-                if (lhs instanceof DoubleColonLHS.Expression && !((DoubleColonLHS.Expression) lhs).isObject()) {
+                if (lhs instanceof DoubleColonLHS.Expression && !((DoubleColonLHS.Expression) lhs).isObjectQualifier()) {
                     JavaClassProperty.INSTANCE.generateImpl(v, gen(receiverExpression));
                 }
                 else {
@@ -3566,18 +3660,43 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
     /*tries to use IEEE 754 arithmetic*/
     private StackValue genEqualsForExpressionsPreferIEEE754Arithmetic(
-            @Nullable KtExpression left,
-            @Nullable KtExpression right,
-            @NotNull IElementType opToken,
+            @Nullable final KtExpression left,
+            @Nullable final KtExpression right,
+            @NotNull final IElementType opToken,
             @NotNull Type leftType,
             @NotNull Type rightType,
-            @Nullable StackValue pregeneratedLeft
+            @Nullable final StackValue pregeneratedLeft
     ) {
-        Type left754Type = calcTypeForIEEE754ArithmeticIfNeeded(left);
-        Type right754Type = calcTypeForIEEE754ArithmeticIfNeeded(right);
-        if (left754Type != null && right754Type != null && left754Type.equals(right754Type)) {
-            leftType = left754Type;
-            rightType = right754Type;
+        assert (opToken == KtTokens.EQEQ || opToken == KtTokens.EXCLEQ) : "Optoken should be '==' or '!=', but: " + opToken;
+
+        final TypeAndNullability left754Type = calcTypeForIEEE754ArithmeticIfNeeded(left);
+        final TypeAndNullability right754Type = calcTypeForIEEE754ArithmeticIfNeeded(right);
+        if (left754Type != null && right754Type != null && left754Type.type.equals(right754Type.type)) {
+            //check nullability cause there is some optimizations in codegen for non-nullable case
+            if (left754Type.isNullable || right754Type.isNullable) {
+                if (state.getLanguageVersionSettings().getApiVersion().compareTo(ApiVersion.KOTLIN_1_1) >= 0) {
+                    return StackValue.operation(Type.BOOLEAN_TYPE, new Function1<InstructionAdapter, Unit>() {
+                        @Override
+                        public Unit invoke(InstructionAdapter v) {
+                            generate754EqualsForNullableTypesViaIntrinsic(v, opToken, pregeneratedLeft, left, left754Type, right, right754Type);
+                            return Unit.INSTANCE;
+                        }
+                    });
+                }
+                else {
+                    return StackValue.operation(Type.BOOLEAN_TYPE, new Function1<InstructionAdapter, Unit>() {
+                        @Override
+                        public Unit invoke(InstructionAdapter v) {
+                            generate754EqualsForNullableTypes(v, opToken, pregeneratedLeft, left, left754Type, right, right754Type);
+                            return Unit.INSTANCE;
+                        }
+                    });
+                }
+            }
+            else {
+                leftType = left754Type.type;
+                rightType = right754Type.type;
+            }
         }
 
         return genEqualsForExpressionsOnStack(
@@ -3587,6 +3706,126 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         );
     }
 
+    private void generate754EqualsForNullableTypesViaIntrinsic(
+            @NotNull InstructionAdapter v,
+            @NotNull IElementType opToken,
+            @Nullable StackValue pregeneratedLeft,
+            @Nullable KtExpression left,
+            @NotNull TypeAndNullability left754Type,
+            @Nullable KtExpression right,
+            @NotNull TypeAndNullability right754Type
+    ) {
+        Type leftType = left754Type.isNullable ? AsmUtil.boxType(left754Type.type) : left754Type.type;
+
+        if (pregeneratedLeft != null)  {
+            StackValue.coercion(pregeneratedLeft, leftType).put(leftType, v);
+        }
+        else {
+            gen(left, leftType);
+        }
+        Type rightType = right754Type.isNullable ? AsmUtil.boxType(right754Type.type) : right754Type.type;
+        gen(right, rightType);
+
+        AsmUtil.genIEEE754EqualForNullableTypesCall(v, leftType, rightType);
+
+        if (opToken == KtTokens.EXCLEQ) {
+            genInvertBoolean(v);
+        }
+    }
+
+    private void generate754EqualsForNullableTypes(
+            @NotNull InstructionAdapter v,
+            @NotNull IElementType opToken,
+            @Nullable StackValue pregeneratedLeft,
+            @Nullable KtExpression left,
+            @NotNull TypeAndNullability left754Type,
+            @Nullable KtExpression right,
+            @NotNull TypeAndNullability right754Type
+    ) {
+        int equals = opToken == KtTokens.EQEQ ? 1 : 0;
+        int notEquals = opToken != KtTokens.EQEQ ? 1 : 0;
+        Label end = new Label();
+        StackValue leftValue = pregeneratedLeft != null ? pregeneratedLeft : gen(left);
+        leftValue.put(leftValue.type, v);
+        leftValue = StackValue.onStack(leftValue.type);
+        Type leftType = left754Type.type;
+        Type rightType = right754Type.type;
+        if (left754Type.isNullable) {
+            leftValue.dup(v, false);
+            Label leftIsNull = new Label();
+            v.ifnull(leftIsNull);
+            StackValue.coercion(leftValue, leftType).put(leftType, v);
+            StackValue nonNullLeftValue = StackValue.onStack(leftType);
+
+            StackValue rightValue = gen(right);
+            rightValue.put(rightValue.type, v);
+            rightValue = StackValue.onStack(rightValue.type);
+            if (right754Type.isNullable) {
+                rightValue.dup(v, false);
+                Label rightIsNotNull = new Label();
+                v.ifnonnull(rightIsNotNull);
+                AsmUtil.pop(v, rightValue.type);
+                AsmUtil.pop(v, nonNullLeftValue.type);
+                v.iconst(notEquals);
+                v.goTo(end);
+                v.mark(rightIsNotNull);
+            }
+
+            StackValue.coercion(rightValue, rightType).put(rightType, v);
+            StackValue nonNullRightValue = StackValue.onStack(rightType);
+            StackValue.cmp(opToken, leftType, nonNullLeftValue, nonNullRightValue).put(Type.BOOLEAN_TYPE, v);
+            v.goTo(end);
+
+            //left is null case
+            v.mark(leftIsNull);
+            AsmUtil.pop(v, leftValue.type);//pop null left
+            rightValue = gen(right);
+            rightValue.put(rightValue.type, v);
+            rightValue = StackValue.onStack(rightValue.type);
+            if (right754Type.isNullable) {
+                Label rightIsNotNull = new Label();
+                v.ifnonnull(rightIsNotNull);
+                v.iconst(equals);
+                v.goTo(end);
+                v.mark(rightIsNotNull);
+                v.iconst(notEquals);
+                //v.goTo(end);
+            }
+            else {
+                AsmUtil.pop(v, rightValue.type);
+                v.iconst(notEquals);
+                //v.goTo(end);
+            }
+
+            v.mark(end);
+            return;
+        }
+        else {
+            StackValue.coercion(leftValue, leftType).put(leftType, v);
+            leftValue = StackValue.onStack(leftType);
+        }
+
+        //right is nullable cause left is not
+        StackValue rightValue = gen(right);
+        rightValue.put(rightValue.type, v);
+        rightValue = StackValue.onStack(rightValue.type);
+
+        rightValue.dup(v, false);
+        Label rightIsNotNull = new Label();
+        v.ifnonnull(rightIsNotNull);
+        AsmUtil.pop(v, rightValue.type);
+        AsmUtil.pop(v, leftValue.type);
+        v.iconst(notEquals);
+        v.goTo(end);
+
+        v.mark(rightIsNotNull);
+        StackValue.coercion(rightValue, rightType).put(rightType, v);
+        StackValue nonNullRightValue = StackValue.onStack(rightType);
+        StackValue.cmp(opToken, leftType, leftValue, nonNullRightValue).put(Type.BOOLEAN_TYPE, v);
+
+        v.mark(end);
+    }
+
     private boolean isIntZero(KtExpression expr, Type exprType) {
         ConstantValue<?> exprValue = getPrimitiveOrStringCompileTimeConstant(expr, bindingContext, state.getShouldInlineConstVals());
         return isIntPrimitive(exprType) && exprValue != null && Integer.valueOf(0).equals(exprValue.getValue());
@@ -3648,12 +3887,12 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         StackValue rightValue;
         Type leftType = expressionType(left);
         Type rightType = expressionType(right);
-        Type left754Type = calcTypeForIEEE754ArithmeticIfNeeded(left);
-        Type right754Type = calcTypeForIEEE754ArithmeticIfNeeded(right);
+        TypeAndNullability left754Type = calcTypeForIEEE754ArithmeticIfNeeded(left);
+        TypeAndNullability right754Type = calcTypeForIEEE754ArithmeticIfNeeded(right);
         Callable callable = resolveToCallable((FunctionDescriptor) resolvedCall.getResultingDescriptor(), false, resolvedCall);
-        boolean is754Arithmetic = left754Type != null && right754Type != null && left754Type.equals(right754Type);
+        boolean is754Arithmetic = left754Type != null && right754Type != null && left754Type.type.equals(right754Type.type);
         if (callable instanceof IntrinsicCallable && ((isPrimitive(leftType) && isPrimitive(rightType)) || is754Arithmetic)) {
-            type = is754Arithmetic ? left754Type : comparisonOperandType(leftType, rightType);
+            type = is754Arithmetic ? left754Type.type : comparisonOperandType(leftType, rightType);
             leftValue = gen(left);
             rightValue = gen(right);
         }
@@ -3665,7 +3904,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return StackValue.cmp(expression.getOperationToken(), type, leftValue, rightValue);
     }
 
-    private Type calcTypeForIEEE754ArithmeticIfNeeded(@Nullable KtExpression expression) {
+    private TypeAndNullability calcTypeForIEEE754ArithmeticIfNeeded(@Nullable KtExpression expression) {
         return CodegenUtilKt.calcTypeForIEEE754ArithmeticIfNeeded(expression, bindingContext, context.getFunctionDescriptor());
     }
 
@@ -4076,6 +4315,8 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     private static ReceiverValue getConstructorReceiver(@NotNull ResolvedCall<?> resolvedCall) {
         CallableDescriptor constructor = resolvedCall.getResultingDescriptor();
         if (constructor.getExtensionReceiverParameter() != null) {
+            // see comment on `withDispatchReceiver` parameter in
+            // org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptorImpl.Companion.createIfAvailable
             assert constructor instanceof TypeAliasConstructorDescriptor :
                     "Only type alias constructor can have an extension receiver: " + constructor;
             return resolvedCall.getExtensionReceiver();
@@ -4265,9 +4506,7 @@ The "returned" value of try expression with no finally is either the last expres
 (or blocks).
          */
 
-        KotlinType jetType = bindingContext.getType(expression);
-        assert jetType != null;
-        final Type expectedAsmType = isStatement ? Type.VOID_TYPE : asmType(jetType);
+        final Type expectedAsmType = isStatement ? Type.VOID_TYPE : expressionTypeForBranchingOperation(expression);
 
         return StackValue.operation(expectedAsmType, new Function1<InstructionAdapter, Unit>() {
             @Override
@@ -4322,6 +4561,9 @@ The "returned" value of try expression with no finally is either the last expres
                     int index = lookupLocalIndex(descriptor);
                     v.store(index, descriptorType);
 
+                    Label catchVariableStart = new Label();
+                    v.mark(catchVariableStart);
+
                     gen(catchBody, expectedAsmType);
 
                     if (!isStatement) {
@@ -4333,8 +4575,8 @@ The "returned" value of try expression with no finally is either the last expres
                     Label clauseEnd = new Label();
                     v.mark(clauseEnd);
 
-                    v.visitLocalVariable(descriptor.getName().asString(), descriptorType.getDescriptor(), null, clauseStart, clauseEnd,
-                                         index);
+                    v.visitLocalVariable(descriptor.getName().asString(), descriptorType.getDescriptor(), null,
+                                         catchVariableStart, clauseEnd, index);
 
                     genFinallyBlockOrGoto(finallyBlockStackElement, i != size - 1 || finallyBlock != null ? end : null, null);
 
@@ -4540,7 +4782,7 @@ The "returned" value of try expression with no finally is either the last expres
         final KtExpression expr = expression.getSubjectExpression();
         final Type subjectType = expressionType(expr);
 
-        final Type resultType = isStatement ? Type.VOID_TYPE : expressionType(expression);
+        final Type resultType = isStatement ? Type.VOID_TYPE : expressionTypeForBranchingOperation(expression);
 
         return StackValue.operation(resultType, new Function1<InstructionAdapter, Unit>() {
             @Override
@@ -4666,7 +4908,8 @@ The "returned" value of try expression with no finally is either the last expres
     public NameGenerator getInlineNameGenerator() {
         NameGenerator nameGenerator = getParentCodegen().getInlineNameGenerator();
         Name name = context.getContextDescriptor().getName();
-        return nameGenerator.subGenerator((name.isSpecial() ? "$special" : name.asString()) + "$$inlined" );
+        String inlinedName = name.isSpecial() ? InlineCodegenUtil.SPECIAL_TRANSFORMATION_NAME : name.asString();
+        return nameGenerator.subGenerator(inlinedName + InlineCodegenUtil.INLINE_CALL_TRANSFORMATION_SUFFIX);
     }
 
     public Type getReturnType() {

compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java

@@ -31,6 +31,8 @@ import org.jetbrains.kotlin.backend.common.bridges.ImplKt;
 import org.jetbrains.kotlin.codegen.annotation.AnnotatedWithOnlyTargetedAnnotations;
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
 import org.jetbrains.kotlin.codegen.context.*;
+import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenUtilKt;
+import org.jetbrains.kotlin.codegen.coroutines.SuspendFunctionGenerationStrategy;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
@@ -99,7 +101,7 @@ public class FunctionCodegen {
     private final Function1<DeclarationDescriptor, Boolean> IS_PURE_INTERFACE_CHECKER = new Function1<DeclarationDescriptor, Boolean>() {
         @Override
         public Boolean invoke(DeclarationDescriptor descriptor) {
-            return JvmCodegenUtil.isAnnotationOrJvm6Interface(descriptor, state);
+            return JvmCodegenUtil.isAnnotationOrJvmInterfaceWithoutDefaults(descriptor, state);
         }
     };
 
@@ -119,17 +121,29 @@ public class FunctionCodegen {
 
     public void gen(@NotNull KtNamedFunction function) {
         SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, function);
+        if (bindingContext.get(CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, functionDescriptor) != null) {
+            functionDescriptor =
+                    (SimpleFunctionDescriptor) bindingContext.get(CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, functionDescriptor);
+        }
+
         if (functionDescriptor == null) {
             throw ExceptionLogger.logDescriptorNotFound("No descriptor for function " + function.getName(), function);
         }
 
-        if (bindingContext.get(CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, functionDescriptor) != null) {
-            functionDescriptor = bindingContext.get(CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, functionDescriptor);
-        }
-
         if (owner.getContextKind() != OwnerKind.DEFAULT_IMPLS || function.hasBody()) {
-            generateMethod(JvmDeclarationOriginKt.OtherOrigin(function, functionDescriptor), functionDescriptor,
-                           new FunctionGenerationStrategy.FunctionDefault(state, function));
+            FunctionGenerationStrategy strategy;
+            if (functionDescriptor.isSuspend()) {
+                strategy = new SuspendFunctionGenerationStrategy(
+                        state,
+                        CoroutineCodegenUtilKt.<FunctionDescriptor>unwrapInitialDescriptorForSuspendFunction(functionDescriptor),
+                        function
+                );
+            }
+            else {
+                strategy = new FunctionGenerationStrategy.FunctionDefault(state, function);
+            }
+
+            generateMethod(JvmDeclarationOriginKt.OtherOrigin(function, functionDescriptor), functionDescriptor, strategy);
         }
 
         generateDefaultIfNeeded(owner.intoFunction(functionDescriptor, true), functionDescriptor, owner.getContextKind(),
@@ -153,6 +167,11 @@ public class FunctionCodegen {
             @NotNull FunctionDescriptor descriptor,
             @NotNull FunctionGenerationStrategy strategy
     ) {
+        if (CoroutineCodegenUtilKt.isSuspendFunctionNotSuspensionView(descriptor)) {
+            generateMethod(origin, CoroutineCodegenUtilKt.getOrCreateJvmSuspendFunctionView(descriptor, bindingContext), strategy);
+            return;
+        }
+
         generateMethod(origin, descriptor, owner.intoFunction(descriptor), strategy);
     }
 
@@ -190,7 +209,11 @@ public class FunctionCodegen {
                                        getThrownExceptions(functionDescriptor, typeMapper));
 
         if (CodegenContextUtil.isImplClassOwner(owner)) {
-            v.getSerializationBindings().put(METHOD_FOR_FUNCTION, functionDescriptor, asmMethod);
+            v.getSerializationBindings().put(
+                    METHOD_FOR_FUNCTION,
+                    CodegenUtilKt.<FunctionDescriptor>unwrapFrontendVersion(functionDescriptor),
+                    asmMethod
+            );
         }
 
         generateMethodAnnotations(functionDescriptor, asmMethod, mv);
@@ -201,14 +224,14 @@ public class FunctionCodegen {
 
         generateBridges(functionDescriptor);
 
-        if (isJvm8InterfaceMember(functionDescriptor, state) && contextKind != OwnerKind.DEFAULT_IMPLS && state.getGenerateDefaultImplsForJvm8()) {
+        if (isJvm8InterfaceWithDefaultsMember(functionDescriptor, state) && contextKind != OwnerKind.DEFAULT_IMPLS && state.getGenerateDefaultImplsForJvm8()) {
             generateDelegateForDefaultImpl(functionDescriptor, origin.getElement());
         }
 
         boolean staticInCompanionObject = CodegenUtilKt.isJvmStaticInCompanionObject(functionDescriptor);
         if (staticInCompanionObject) {
             ImplementationBodyCodegen parentBodyCodegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
-            parentBodyCodegen.addAdditionalTask(new JvmStaticGenerator(functionDescriptor, origin, state, parentBodyCodegen));
+            parentBodyCodegen.addAdditionalTask(new JvmStaticInCompanionObjectGenerator(functionDescriptor, origin, state, parentBodyCodegen));
         }
 
         if (!state.getClassBuilderMode().generateBodies || isAbstractMethod(functionDescriptor, contextKind, state)) {
@@ -233,7 +256,8 @@ public class FunctionCodegen {
         else if (staticInCompanionObject) {
             // native @JvmStatic foo() in companion object should delegate to the static native function moved to the outer class
             mv.visitCode();
-            FunctionDescriptor staticFunctionDescriptor = JvmStaticGenerator.createStaticFunctionDescriptor(functionDescriptor);
+            FunctionDescriptor staticFunctionDescriptor = JvmStaticInCompanionObjectGenerator
+                    .createStaticFunctionDescriptor(functionDescriptor);
             Method accessorMethod =
                     typeMapper.mapAsmMethod(memberCodegen.getContext().accessibleDescriptor(staticFunctionDescriptor, null));
             Type owningType = typeMapper.mapClass((ClassifierDescriptor) staticFunctionDescriptor.getContainingDeclaration());
@@ -311,9 +335,22 @@ public class FunctionCodegen {
             @NotNull JvmMethodSignature jvmSignature,
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
+    ) {
+        generateParameterAnnotations(
+                functionDescriptor, mv, jvmSignature, functionDescriptor.getValueParameters(), innerClassConsumer, state
+        );
+    }
+
+    public static void generateParameterAnnotations(
+            @NotNull FunctionDescriptor functionDescriptor,
+            @NotNull MethodVisitor mv,
+            @NotNull JvmMethodSignature jvmSignature,
+            @NotNull List<ValueParameterDescriptor> valueParameters,
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state
     ) {
         KotlinTypeMapper typeMapper = state.getTypeMapper();
-        Iterator<ValueParameterDescriptor> iterator = functionDescriptor.getValueParameters().iterator();
+        Iterator<ValueParameterDescriptor> iterator = valueParameters.iterator();
         List<JvmMethodParameterSignature> kotlinParameterTypes = jvmSignature.getValueParameters();
 
         for (int i = 0; i < kotlinParameterTypes.size(); i++) {
@@ -419,7 +456,7 @@ public class FunctionCodegen {
             generateFacadeDelegateMethodBody(mv, signature.getAsmMethod(), (MultifileClassFacadeContext) context.getParentContext());
             methodEnd = new Label();
         }
-        else if (OwnerKind.DEFAULT_IMPLS == context.getContextKind() && isJvm8InterfaceMember(functionDescriptor, parentCodegen.state)) {
+        else if (OwnerKind.DEFAULT_IMPLS == context.getContextKind() && isJvm8InterfaceWithDefaultsMember(functionDescriptor, parentCodegen.state)) {
             int flags = AsmUtil.getMethodAsmFlags(functionDescriptor, OwnerKind.DEFAULT_IMPLS, context.getState());
             assert (flags & Opcodes.ACC_ABSTRACT) == 0 : "Interface method with body should be non-abstract" + functionDescriptor;
             Type type = typeMapper.mapOwner(functionDescriptor);
@@ -724,7 +761,7 @@ public class FunctionCodegen {
     public void generateBridges(@NotNull FunctionDescriptor descriptor) {
         if (descriptor instanceof ConstructorDescriptor) return;
         if (owner.getContextKind() == OwnerKind.DEFAULT_IMPLS) return;
-        if (isAnnotationOrJvm6Interface(descriptor.getContainingDeclaration(), state)) return;
+        if (isAnnotationOrJvmInterfaceWithoutDefaults(descriptor.getContainingDeclaration(), state)) return;
 
         // equals(Any?), hashCode(), toString() never need bridges
         if (isMethodOfAny(descriptor)) return;
@@ -883,17 +920,23 @@ public class FunctionCodegen {
         // enum constructors have two additional synthetic parameters which somewhat complicate this task
         AnnotationCodegen.forMethod(mv, memberCodegen, typeMapper).genAnnotations(functionDescriptor, defaultMethod.getReturnType());
 
-        if (state.getClassBuilderMode().generateBodies) {
-            if (this.owner instanceof MultifileClassFacadeContext) {
-                mv.visitCode();
-                generateFacadeDelegateMethodBody(mv, defaultMethod, (MultifileClassFacadeContext) this.owner);
+        if (!state.getClassBuilderMode().generateBodies) {
+            if (this.owner instanceof MultifileClassFacadeContext)
                 endVisit(mv, "default method delegation", getSourceFromDescriptor(functionDescriptor));
-            }
-            else {
-                mv.visitCode();
-                generateDefaultImplBody(owner, functionDescriptor, mv, loadStrategy, function, memberCodegen, defaultMethod);
+            else
                 endVisit(mv, "default method", getSourceFromDescriptor(functionDescriptor));
-            }
+            return;
+        }
+
+        if (this.owner instanceof MultifileClassFacadeContext) {
+            mv.visitCode();
+            generateFacadeDelegateMethodBody(mv, defaultMethod, (MultifileClassFacadeContext) this.owner);
+            endVisit(mv, "default method delegation", getSourceFromDescriptor(functionDescriptor));
+        }
+        else {
+            mv.visitCode();
+            generateDefaultImplBody(owner, functionDescriptor, mv, loadStrategy, function, memberCodegen, defaultMethod);
+            endVisit(mv, "default method", getSourceFromDescriptor(functionDescriptor));
         }
     }
 
@@ -919,8 +962,6 @@ public class FunctionCodegen {
         InstructionAdapter iv = new InstructionAdapter(mv);
         genDefaultSuperCallCheckIfNeeded(iv, functionDescriptor, defaultMethod);
 
-        loadExplicitArgumentsOnStack(OBJECT_TYPE, isStatic, signature, generator);
-
         List<JvmMethodParameterSignature> mappedParameters = signature.getValueParameters();
         int capturedArgumentsCount = 0;
         while (capturedArgumentsCount < mappedParameters.size() &&
@@ -949,7 +990,15 @@ public class FunctionCodegen {
 
                 iv.mark(loadArg);
             }
+        }
 
+        // load arguments after defaults generation to avoid redundant stack normalization operations
+        loadExplicitArgumentsOnStack(OBJECT_TYPE, isStatic, signature, generator);
+
+        for (int index = 0; index < valueParameters.size(); index++) {
+            ValueParameterDescriptor parameterDescriptor = valueParameters.get(index);
+            Type type = mappedParameters.get(capturedArgumentsCount + index).getAsmType();
+            int parameterIndex = frameMap.getIndex(parameterDescriptor);
             generator.putValueIfNeeded(type, StackValue.local(parameterIndex, type));
         }
 
@@ -1086,14 +1135,14 @@ public class FunctionCodegen {
             ClassDescriptor parentClass = getSuperClassDescriptor((ClassDescriptor) descriptor.getContainingDeclaration());
             assert parentClass != null;
             String parentInternalName = typeMapper.mapClass(parentClass).getInternalName();
-            iv.invokespecial(parentInternalName, delegateTo.getName(), delegateTo.getDescriptor());
+            iv.invokespecial(parentInternalName, delegateTo.getName(), delegateTo.getDescriptor(), false);
         }
         else {
-            if (isJvm8InterfaceMember(descriptor, state)) {
+            if (isJvm8InterfaceWithDefaultsMember(descriptor, state)) {
                 iv.invokeinterface(v.getThisName(), delegateTo.getName(), delegateTo.getDescriptor());
             }
             else {
-                iv.invokevirtual(v.getThisName(), delegateTo.getName(), delegateTo.getDescriptor());
+                iv.invokevirtual(v.getThisName(), delegateTo.getName(), delegateTo.getDescriptor(), false);
             }
         }
 
@@ -1222,7 +1271,7 @@ public class FunctionCodegen {
                             iv.invokeinterface(internalName, delegateToMethod.getName(), delegateToMethod.getDescriptor());
                         }
                         else {
-                            iv.invokevirtual(internalName, delegateToMethod.getName(), delegateToMethod.getDescriptor());
+                            iv.invokevirtual(internalName, delegateToMethod.getName(), delegateToMethod.getDescriptor(), false);
                         }
 
                         StackValue stackValue = AsmUtil.genNotNullAssertions(
@@ -1257,6 +1306,6 @@ public class FunctionCodegen {
             @NotNull GenerationState state
     ) {
         assert isInterface(contextClass) : "'processInterface' method should be called only for interfaces, but: " + contextClass;
-        return isJvm8Interface(contextClass, state) ? kind != OwnerKind.DEFAULT_IMPLS : kind == OwnerKind.DEFAULT_IMPLS;
+        return JvmCodegenUtil.isJvm8InterfaceWithDefaults(contextClass, state) ? kind != OwnerKind.DEFAULT_IMPLS : kind == OwnerKind.DEFAULT_IMPLS;
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen;
 import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.backend.common.CodegenUtil;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.*;
@@ -36,6 +37,8 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 
 import java.util.*;
 
+import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject;
+
 public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrategy.CodegenBased {
     private final ResolvedCall<?> resolvedCall;
     private final FunctionDescriptor referencedFunction;
@@ -74,7 +77,7 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
          every argument boils down to calling LOAD with the corresponding index
          */
 
-        KtCallExpression fakeExpression = constructFakeFunctionCall();
+        KtCallExpression fakeExpression = CodegenUtil.constructFakeFunctionCall(state.getProject(), referencedFunction);
         final List<? extends ValueArgument> fakeArguments = fakeExpression.getValueArguments();
 
         final ReceiverValue dispatchReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getDispatchReceiverParameter());
@@ -140,25 +143,17 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
         v.areturn(returnType);
     }
 
-    @NotNull
-    private KtCallExpression constructFakeFunctionCall() {
-        StringBuilder fakeFunctionCall = new StringBuilder("callableReferenceFakeCall(");
-        for (Iterator<ValueParameterDescriptor> iterator = referencedFunction.getValueParameters().iterator(); iterator.hasNext(); ) {
-            ValueParameterDescriptor descriptor = iterator.next();
-            fakeFunctionCall.append("p").append(descriptor.getIndex());
-            if (iterator.hasNext()) {
-                fakeFunctionCall.append(", ");
-            }
-        }
-        fakeFunctionCall.append(")");
-        return (KtCallExpression) KtPsiFactoryKt.KtPsiFactory(state.getProject()).createExpression(fakeFunctionCall.toString());
-    }
-
     private void computeAndSaveArguments(@NotNull List<? extends ValueArgument> fakeArguments, @NotNull ExpressionCodegen codegen) {
         int receivers = (referencedFunction.getDispatchReceiverParameter() != null ? 1 : 0) +
                         (referencedFunction.getExtensionReceiverParameter() != null ? 1 : 0) -
                         (receiverType != null ? 1 : 0);
 
+        if (receivers < 0 &&  referencedFunction instanceof ConstructorDescriptor && isObject(referencedFunction.getContainingDeclaration().getContainingDeclaration())) {
+            //reference to object nested class
+            //TODO: seems problem should be fixed on frontend side (note that object instance are captured by generated class)
+            receivers = 0;
+        }
+
         List<ValueParameterDescriptor> parameters = CollectionsKt.drop(functionDescriptor.getValueParameters(), receivers);
         for (int i = 0; i < parameters.size(); i++) {
             ValueParameterDescriptor parameter = parameters.get(i);

compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java

@@ -29,6 +29,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
 import org.jetbrains.kotlin.backend.common.DataClassMethodGenerator;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
 import org.jetbrains.kotlin.codegen.binding.MutableClosure;
 import org.jetbrains.kotlin.codegen.context.*;
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension;
@@ -87,6 +88,7 @@ import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.
 import static org.jetbrains.kotlin.types.Variance.INVARIANT;
 import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isLocalFunction;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
+import static org.jetbrains.org.objectweb.asm.Type.getObjectType;
 
 public class ImplementationBodyCodegen extends ClassBodyCodegen {
     private static final String ENUM_VALUES_FIELD_NAME = "$VALUES";
@@ -112,7 +114,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             boolean isLocal
     ) {
         super(aClass, context, v, state, parentCodegen);
-        this.classAsmType = typeMapper.mapClass(descriptor);
+        this.classAsmType = getObjectType(typeMapper.classInternalName(descriptor));
         this.isLocal = isLocal;
         delegationFieldsInfo = getDelegationFieldsInfo(myClass.getSuperTypeListEntries());
     }
@@ -126,55 +128,47 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         boolean isAbstract = false;
         boolean isInterface = false;
         boolean isFinal = false;
-        boolean isStatic;
         boolean isAnnotation = false;
         boolean isEnum = false;
 
         ClassKind kind = descriptor.getKind();
 
-        if (kind == ClassKind.OBJECT) {
-            isStatic = isCompanionObject(descriptor);
-            isFinal = true;
+        Modality modality = descriptor.getModality();
+
+        if (modality == Modality.ABSTRACT || modality == Modality.SEALED) {
+            isAbstract = true;
         }
-        else {
-            Modality modality = descriptor.getModality();
 
-            if (modality == Modality.ABSTRACT || modality == Modality.SEALED) {
-                isAbstract = true;
-            }
+        if (kind == ClassKind.INTERFACE) {
+            isAbstract = true;
+            isInterface = true;
+        }
+        else if (kind == ClassKind.ANNOTATION_CLASS) {
+            isAbstract = true;
+            isInterface = true;
+            isAnnotation = true;
+        }
+        else if (kind == ClassKind.ENUM_CLASS) {
+            isAbstract = hasAbstractMembers(descriptor);
+            isEnum = true;
+        }
 
-            if (kind == ClassKind.INTERFACE) {
-                isAbstract = true;
-                isInterface = true;
-            }
-            else if (kind == ClassKind.ANNOTATION_CLASS) {
-                isAbstract = true;
-                isInterface = true;
-                isAnnotation = true;
-            }
-            else if (kind == ClassKind.ENUM_CLASS) {
-                isAbstract = hasAbstractMembers(descriptor);
-                isEnum = true;
-            }
-
-            if (modality != Modality.OPEN && !isAbstract) {
-                // Light-class mode: Do not make enum classes final since PsiClass corresponding to enum is expected to be inheritable from
-                isFinal = !(kind == ClassKind.ENUM_CLASS && !state.getClassBuilderMode().generateBodies);
-            }
-
-            isStatic = !descriptor.isInner();
+        if (modality != Modality.OPEN && !isAbstract) {
+            isFinal = kind == ClassKind.OBJECT ||
+                      // Light-class mode: Do not make enum classes final since PsiClass corresponding to enum is expected to be inheritable from
+                      !(kind == ClassKind.ENUM_CLASS && !state.getClassBuilderMode().generateBodies);
         }
 
         int access = 0;
 
-        if (!state.getClassBuilderMode().generateBodies && !DescriptorUtils.isTopLevelDeclaration(descriptor)) {
+        if (state.getClassBuilderMode() == ClassBuilderMode.LIGHT_CLASSES && !DescriptorUtils.isTopLevelDeclaration(descriptor)) {
             // !ClassBuilderMode.generateBodies means we are generating light classes & looking at a nested or inner class
             // Light class generation is implemented so that Cls-classes only read bare code of classes,
             // without knowing whether these classes are inner or not (see ClassStubBuilder.EMPTY_STRATEGY)
             // Thus we must write full accessibility flags on inner classes in this mode
             access |= getVisibilityAccessFlag(descriptor);
             // Same for STATIC
-            if (isStatic) {
+            if (!descriptor.isInner()) {
                 access |= ACC_STATIC;
             }
         }
@@ -233,7 +227,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
     @Override
     protected void generateDefaultImplsIfNeeded() {
-        if (isInterface(descriptor) && !isLocal && (!isJvm8Interface(descriptor, state) || state.getGenerateDefaultImplsForJvm8())) {
+        if (isInterface(descriptor) && !isLocal && (!JvmCodegenUtil.isJvm8InterfaceWithDefaults(descriptor, state) || state.getGenerateDefaultImplsForJvm8())) {
             Type defaultImplsType = state.getTypeMapper().mapDefaultImpls(descriptor);
             ClassBuilder defaultImplsBuilder =
                     state.getFactory().newVisitor(JvmDeclarationOriginKt.DefaultImpls(myClass.getPsiOrParent(), descriptor), defaultImplsType, myClass.getContainingKtFile());
@@ -331,7 +325,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         for (String kotlinMarkerInterface : kotlinMarkerInterfaces) {
             sw.writeInterface();
-            sw.writeAsmType(Type.getObjectType(kotlinMarkerInterface));
+            sw.writeAsmType(getObjectType(kotlinMarkerInterface));
             sw.writeInterfaceEnd();
         }
 
@@ -1206,9 +1200,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                     }
                 }
                 else if (descriptor instanceof VariableDescriptor) {
-                    if (descriptor.getContainingDeclaration() instanceof ConstructorDescriptor) {
-                        ClassDescriptor classDescriptor =
-                                (ClassDescriptor) descriptor.getContainingDeclaration().getContainingDeclaration();
+                    DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
+                    if (containingDeclaration instanceof ConstructorDescriptor) {
+                        ClassDescriptor classDescriptor = ((ConstructorDescriptor) containingDeclaration).getConstructedClass();
                         if (classDescriptor == ImplementationBodyCodegen.this.descriptor) return;
                     }
                     lookupInContext(descriptor);
@@ -1293,14 +1287,14 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     }
 
     private void generateTraitMethods() {
-        if (isAnnotationOrJvm6Interface(descriptor, state)) return;
+        if (isAnnotationOrJvmInterfaceWithoutDefaults(descriptor, state)) return;
 
         List<FunctionDescriptor> restrictedInheritance = new ArrayList<FunctionDescriptor>();
         for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.getNonPrivateTraitMethods(descriptor).entrySet()) {
             FunctionDescriptor interfaceFun = entry.getKey();
             //skip java 8 default methods
-            if (!CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) && !isJvm8InterfaceMember(interfaceFun, state)) {
-                if (state.isJvm8Target() && !JvmCodegenUtil.isJvm8Interface(interfaceFun.getContainingDeclaration(), state)) {
+            if (!CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) && !isJvm8InterfaceWithDefaultsMember(interfaceFun, state)) {
+                if (state.isJvm8TargetWithDefaults() && !JvmCodegenUtil.isJvm8InterfaceWithDefaults(interfaceFun.getContainingDeclaration(), state)) {
                     restrictedInheritance.add(interfaceFun);
                 }
                 else {
@@ -1593,6 +1587,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         iv.iconst(ordinal);
 
         List<KtSuperTypeListEntry> delegationSpecifiers = enumEntry.getSuperTypeListEntries();
+        ResolvedCall<?> defaultArgumentsConstructorCall = CallUtilKt.getResolvedCall(enumEntry, bindingContext);
+        boolean enumEntryHasSubclass = CodegenBinding.enumEntryNeedSubclass(bindingContext, classDescriptor);
         if (delegationSpecifiers.size() == 1 && !enumEntryNeedSubclass(bindingContext, enumEntry)) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCallWithAssert(delegationSpecifiers.get(0), bindingContext);
 
@@ -1600,6 +1596,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
             codegen.invokeMethodWithArguments(method, resolvedCall, StackValue.none());
         }
+        else if (defaultArgumentsConstructorCall != null && !enumEntryHasSubclass) {
+            codegen.invokeFunction(defaultArgumentsConstructorCall, StackValue.none()).put(Type.VOID_TYPE, iv);
+        }
         else {
             iv.invokespecial(implClass.getInternalName(), "<init>", "(Ljava/lang/String;I)V", false);
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java

@@ -30,10 +30,9 @@ import org.jetbrains.kotlin.codegen.context.MethodContext;
 import org.jetbrains.kotlin.codegen.context.RootContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
-import org.jetbrains.kotlin.config.LanguageFeature;
-import org.jetbrains.kotlin.config.LanguageVersionSettings;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
+import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor;
 import org.jetbrains.kotlin.load.kotlin.*;
 import org.jetbrains.kotlin.psi.Call;
@@ -64,11 +63,11 @@ public class JvmCodegenUtil {
     private JvmCodegenUtil() {
     }
 
-    public static boolean isAnnotationOrJvm6Interface(@NotNull DeclarationDescriptor descriptor, @NotNull GenerationState state) {
-        return isAnnotationOrJvm6Interface(descriptor, state.isJvm8Target());
+    public static boolean isAnnotationOrJvmInterfaceWithoutDefaults(@NotNull DeclarationDescriptor descriptor, @NotNull GenerationState state) {
+        return isAnnotationOrJvmInterfaceWithoutDefaults(descriptor, state.isJvm8Target(), state.isJvm8TargetWithDefaults());
     }
 
-    public static boolean isAnnotationOrJvm6Interface(@NotNull DeclarationDescriptor descriptor, boolean isJvm8Target) {
+    private static boolean isAnnotationOrJvmInterfaceWithoutDefaults(@NotNull DeclarationDescriptor descriptor, boolean isJvm8Target, boolean isJvm8TargetWithDefaults) {
         if (!isJvmInterface(descriptor)) {
             return false;
         }
@@ -80,23 +79,35 @@ public class JvmCodegenUtil {
                 KotlinJvmBinaryClass binaryClass = ((KotlinJvmBinarySourceElement) source).getBinaryClass();
                 assert binaryClass instanceof FileBasedKotlinClass :
                         "KotlinJvmBinaryClass should be subclass of FileBasedKotlinClass, but " + binaryClass;
-                return ((FileBasedKotlinClass) binaryClass).getClassVersion() == Opcodes.V1_6;
+                /*TODO need add some flags to compiled code*/
+                return true || ((FileBasedKotlinClass) binaryClass).getClassVersion() == Opcodes.V1_6;
             }
         }
-        return !isJvm8Target;
+        return !isJvm8TargetWithDefaults;
     }
 
-    public static boolean isJvm8Interface(@NotNull DeclarationDescriptor descriptor, @NotNull GenerationState state) {
-        return isJvm8Interface(descriptor, state.isJvm8Target());
+    public static boolean isJvm8InterfaceWithDefaults(@NotNull DeclarationDescriptor descriptor, @NotNull GenerationState state) {
+        return isJvm8InterfaceWithDefaults(descriptor, state.isJvm8Target(), state.isJvm8TargetWithDefaults());
     }
 
-    public static boolean isJvm8Interface(@NotNull DeclarationDescriptor descriptor, boolean isJvm8Target) {
-        return DescriptorUtils.isInterface(descriptor) && !isAnnotationOrJvm6Interface(descriptor, isJvm8Target);
+    public static boolean isJvm8InterfaceWithDefaults(@NotNull DeclarationDescriptor descriptor, boolean isJvm8Target, boolean isJvm8TargetWithDefaults) {
+        return DescriptorUtils.isInterface(descriptor) && !isAnnotationOrJvmInterfaceWithoutDefaults(descriptor, isJvm8Target, isJvm8TargetWithDefaults);
     }
 
-    public static boolean isJvm8InterfaceMember(@NotNull CallableMemberDescriptor descriptor, @NotNull GenerationState state) {
+    public static boolean isJvm8InterfaceWithDefaultsMember(@NotNull CallableMemberDescriptor descriptor, @NotNull GenerationState state) {
         DeclarationDescriptor declaration = descriptor.getContainingDeclaration();
-        return isJvm8Interface(declaration, state);
+        return isJvm8InterfaceWithDefaults(declaration, state);
+    }
+
+    public static boolean isNonDefaultInterfaceMember(@NotNull CallableMemberDescriptor descriptor, @NotNull GenerationState state) {
+        if (!isJvmInterface(descriptor.getContainingDeclaration())) {
+            return false;
+        }
+        if (descriptor instanceof JavaCallableMemberDescriptor) {
+            return descriptor.getModality() == Modality.ABSTRACT;
+        }
+
+        return !isJvm8InterfaceWithDefaultsMember(descriptor, state);
     }
 
     public static boolean isJvmInterface(DeclarationDescriptor descriptor) {
@@ -115,7 +126,7 @@ public class JvmCodegenUtil {
         return closure.getCaptureThis() == null &&
                     closure.getCaptureReceiverType() == null &&
                     closure.getCaptureVariables().isEmpty() &&
-                    !closure.isCoroutine();
+                    !closure.isSuspend();
     }
 
     private static boolean isCallInsideSameClassAsDeclared(@NotNull CallableMemberDescriptor descriptor, @NotNull CodegenContext context) {

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

@@ -17,22 +17,24 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.builtins.createFunctionType
-import org.jetbrains.kotlin.builtins.isExtensionFunctionType
-import org.jetbrains.kotlin.codegen.coroutines.createJvmSuspendFunctionView
+import org.jetbrains.kotlin.codegen.coroutines.COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME
+import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
 import org.jetbrains.kotlin.coroutines.isSuspendLambda
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
+import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor
 import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
-import org.jetbrains.kotlin.utils.addIfNotNull
 
 class JvmRuntimeTypes(module: ModuleDescriptor) {
     private val kotlinJvmInternalPackage = MutablePackageFragmentDescriptor(module, FqName("kotlin.jvm.internal"))
+    private val kotlinCoroutinesJvmInternalPackage =
+            MutablePackageFragmentDescriptor(module, COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME)
 
     private fun klass(name: String) = lazy { createClass(kotlinJvmInternalPackage, name) }
 
@@ -40,7 +42,7 @@ class JvmRuntimeTypes(module: ModuleDescriptor) {
     private val functionReference: ClassDescriptor by klass("FunctionReference")
     private val localVariableReference: ClassDescriptor by klass("LocalVariableReference")
     private val mutableLocalVariableReference: ClassDescriptor by klass("MutableLocalVariableReference")
-    private val coroutineImplClass by klass("CoroutineImpl")
+    private val coroutineImplClass by lazy { createClass(kotlinCoroutinesJvmInternalPackage, "CoroutineImpl") }
 
     private val propertyReferences: List<ClassDescriptor> by lazy {
         (0..2).map { i -> createClass(kotlinJvmInternalPackage, "PropertyReference$i") }
@@ -50,10 +52,6 @@ class JvmRuntimeTypes(module: ModuleDescriptor) {
         (0..2).map { i -> createClass(kotlinJvmInternalPackage, "MutablePropertyReference$i") }
     }
 
-    private val suspendFunctions: List<ClassDescriptor> by lazy {
-        (0..1).map { i -> createClass(kotlinJvmInternalPackage, "SuspendFunction$i", ClassKind.INTERFACE) }
-    }
-
     private fun createClass(
             packageFragment: PackageFragmentDescriptor,
             name: String,
@@ -70,8 +68,8 @@ class JvmRuntimeTypes(module: ModuleDescriptor) {
     fun getSupertypesForClosure(descriptor: FunctionDescriptor): Collection<KotlinType> {
 
         val actualFunctionDescriptor =
-                if (descriptor.isSuspendLambda)
-                    createJvmSuspendFunctionView(descriptor)
+                if (descriptor.isSuspend)
+                    getOrCreateJvmSuspendFunctionView(descriptor)
                 else
                     descriptor
 
@@ -84,15 +82,13 @@ class JvmRuntimeTypes(module: ModuleDescriptor) {
                 actualFunctionDescriptor.returnType!!
         )
 
-        if (descriptor.isSuspendLambda) {
+        if (descriptor.isSuspend) {
             return mutableListOf<KotlinType>().apply {
                 add(coroutineImplClass.defaultType)
-                add(functionType)
 
-                val parametersNumber =
-                        descriptor.valueParameters.size + (if (functionType.isExtensionFunctionType) 1 else 0)
-
-                addIfNotNull(suspendFunctions.getOrNull(parametersNumber)?.defaultType)
+                if (descriptor.isSuspendLambda) {
+                    add(functionType)
+                }
             }
         }
 

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

@@ -1,101 +0,0 @@
-/*
- * 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.codegen
-
-import org.jetbrains.kotlin.backend.common.CodegenUtil
-import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.psi.KtNamedFunction
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.Synthetic
-import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-
-class JvmStaticGenerator(
-        val descriptor: FunctionDescriptor,
-        val declarationOrigin: JvmDeclarationOrigin,
-        val state: GenerationState,
-        parentBodyCodegen: ImplementationBodyCodegen
-) : Function2<ImplementationBodyCodegen, ClassBuilder, Unit> {
-    private val typeMapper = state.typeMapper
-
-    init {
-        parentBodyCodegen.getContext().accessibleDescriptor(JvmCodegenUtil.getDirectMember(descriptor), null)
-    }
-
-    override fun invoke(codegen: ImplementationBodyCodegen, classBuilder: ClassBuilder) {
-        val staticFunctionDescriptor = createStaticFunctionDescriptor(descriptor)
-
-        val originElement = declarationOrigin.element
-        codegen.functionCodegen.generateMethod(
-                Synthetic(originElement, staticFunctionDescriptor),
-                staticFunctionDescriptor,
-                object : FunctionGenerationStrategy.CodegenBased(state) {
-                    override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
-                        val iv = codegen.v
-                        val classDescriptor = descriptor.containingDeclaration as ClassDescriptor
-                        val singletonValue = StackValue.singleton(classDescriptor, typeMapper)
-                        singletonValue.put(singletonValue.type, iv)
-                        var index = 0
-                        val asmMethod = signature.asmMethod
-                        for (paramType in asmMethod.argumentTypes) {
-                            iv.load(index, paramType)
-                            index += paramType.size
-                        }
-                        if (descriptor is PropertyAccessorDescriptor) {
-                            val propertyValue = codegen.intermediateValueForProperty(descriptor.correspondingProperty, false, null, StackValue.none())
-                            if (descriptor is PropertyGetterDescriptor) {
-                                propertyValue.put(signature.returnType, iv)
-                            }
-                            else {
-                                propertyValue.store(StackValue.onStack(propertyValue.type), iv, true)
-                            }
-                        }
-                        else {
-                            val syntheticOrOriginalMethod = typeMapper.mapToCallableMethod(
-                                    codegen.context.accessibleDescriptor(descriptor, /* superCallTarget = */ null),
-                                    false
-                            )
-                            syntheticOrOriginalMethod.genInvokeInstruction(iv)
-                        }
-                        iv.areturn(asmMethod.returnType)
-                    }
-                }
-        )
-
-        if (originElement is KtNamedFunction) {
-            codegen.functionCodegen.generateOverloadsWithDefaultValues(originElement, staticFunctionDescriptor, descriptor)
-        }
-    }
-
-    companion object {
-        @JvmStatic
-        fun createStaticFunctionDescriptor(descriptor: FunctionDescriptor): FunctionDescriptor {
-            val memberDescriptor = if (descriptor is PropertyAccessorDescriptor) descriptor.correspondingProperty else descriptor
-            val copies = CodegenUtil.copyFunctions(
-                    memberDescriptor,
-                    memberDescriptor,
-                    descriptor.containingDeclaration.containingDeclaration!!,
-                    descriptor.modality,
-                    descriptor.visibility,
-                    CallableMemberDescriptor.Kind.SYNTHESIZED,
-                    false
-            )
-            val staticFunctionDescriptor = copies[descriptor]!!
-            return staticFunctionDescriptor
-        }
-    }
-}

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

@@ -0,0 +1,101 @@
+/*
+ * 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.codegen
+
+import org.jetbrains.kotlin.backend.common.CodegenUtil
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.Synthetic
+import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
+
+class JvmStaticInCompanionObjectGenerator(
+        val descriptor: FunctionDescriptor,
+        val declarationOrigin: JvmDeclarationOrigin,
+        val state: GenerationState,
+        parentBodyCodegen: ImplementationBodyCodegen
+) : Function2<ImplementationBodyCodegen, ClassBuilder, Unit> {
+    private val typeMapper = state.typeMapper
+
+    init {
+        parentBodyCodegen.getContext().accessibleDescriptor(JvmCodegenUtil.getDirectMember(descriptor), null)
+    }
+
+    override fun invoke(codegen: ImplementationBodyCodegen, classBuilder: ClassBuilder) {
+        val staticFunctionDescriptor = createStaticFunctionDescriptor(descriptor)
+
+        val originElement = declarationOrigin.element
+        codegen.functionCodegen.generateMethod(
+                Synthetic(originElement, staticFunctionDescriptor),
+                staticFunctionDescriptor,
+                object : FunctionGenerationStrategy.CodegenBased(state) {
+                    override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
+                        val iv = codegen.v
+                        val classDescriptor = descriptor.containingDeclaration as ClassDescriptor
+                        val singletonValue = StackValue.singleton(classDescriptor, typeMapper)
+                        singletonValue.put(singletonValue.type, iv)
+                        var index = 0
+                        val asmMethod = signature.asmMethod
+                        for (paramType in asmMethod.argumentTypes) {
+                            iv.load(index, paramType)
+                            index += paramType.size
+                        }
+                        if (descriptor is PropertyAccessorDescriptor) {
+                            val propertyValue = codegen.intermediateValueForProperty(descriptor.correspondingProperty, false, null, StackValue.none())
+                            if (descriptor is PropertyGetterDescriptor) {
+                                propertyValue.put(signature.returnType, iv)
+                            }
+                            else {
+                                propertyValue.store(StackValue.onStack(propertyValue.type), iv, true)
+                            }
+                        }
+                        else {
+                            val syntheticOrOriginalMethod = typeMapper.mapToCallableMethod(
+                                    codegen.context.accessibleDescriptor(descriptor, /* superCallTarget = */ null),
+                                    false
+                            )
+                            syntheticOrOriginalMethod.genInvokeInstruction(iv)
+                        }
+                        iv.areturn(asmMethod.returnType)
+                    }
+                }
+        )
+
+        if (originElement is KtNamedFunction) {
+            codegen.functionCodegen.generateOverloadsWithDefaultValues(originElement, staticFunctionDescriptor, descriptor)
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        fun createStaticFunctionDescriptor(descriptor: FunctionDescriptor): FunctionDescriptor {
+            val memberDescriptor = if (descriptor is PropertyAccessorDescriptor) descriptor.correspondingProperty else descriptor
+            val copies = CodegenUtil.copyFunctions(
+                    memberDescriptor,
+                    memberDescriptor,
+                    descriptor.containingDeclaration.containingDeclaration!!,
+                    descriptor.modality,
+                    descriptor.visibility,
+                    CallableMemberDescriptor.Kind.SYNTHESIZED,
+                    false
+            )
+            val staticFunctionDescriptor = copies[descriptor]!!
+            return staticFunctionDescriptor
+        }
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.fileClasses.FileClasses;
@@ -66,7 +67,8 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 import java.util.*;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
-import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvm8InterfaceMember;
+import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvm8InterfaceWithDefaultsMember;
+import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isNonDefaultInterfaceMember;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
@@ -125,7 +127,10 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
 
         generateBody();
 
-        generateSyntheticParts();
+        if (!(element instanceof KtClassOrObject) ||
+            state.getGenerateDeclaredClassFilter().shouldGenerateClassMembers((KtClassOrObject) element)) {
+            generateSyntheticParts();
+        }
 
         if (state.getClassBuilderMode().generateMetadata) {
             generateKotlinMetadataAnnotation();
@@ -236,14 +241,20 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         Annotations annotations = typeAliasDescriptor.getAnnotations();
         if (!isAnnotationsMethodOwner || annotations.getAllAnnotations().isEmpty()) return;
 
-        int flags = ACC_DEPRECATED | ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC;
         String name = JvmAbi.getSyntheticMethodNameForAnnotatedTypeAlias(typeAliasDescriptor.getName());
-        String desc = "()V";
-        Method syntheticMethod = new Method(name, desc);
+        generateSyntheticAnnotationsMethod(typeAliasDescriptor, new Method(name, "()V"), annotations, null);
+    }
 
-        MethodVisitor mv = v.newMethod(JvmDeclarationOriginKt.OtherOrigin(typeAliasDescriptor), flags, syntheticMethod.getName(),
+    protected void generateSyntheticAnnotationsMethod(
+            @NotNull MemberDescriptor descriptor,
+            @NotNull Method syntheticMethod,
+            @NotNull Annotations annotations,
+            @Nullable AnnotationUseSiteTarget allowedTarget
+    ) {
+        int flags = ACC_DEPRECATED | ACC_STATIC | ACC_SYNTHETIC | AsmUtil.getVisibilityAccessFlag(descriptor);
+        MethodVisitor mv = v.newMethod(JvmDeclarationOriginKt.OtherOrigin(descriptor), flags, syntheticMethod.getName(),
                                        syntheticMethod.getDescriptor(), null, null);
-        AnnotationCodegen.forMethod(mv, this, typeMapper).genAnnotations(new AnnotatedSimple(annotations), Type.VOID_TYPE, null);
+        AnnotationCodegen.forMethod(mv, this, typeMapper).genAnnotations(new AnnotatedSimple(annotations), Type.VOID_TYPE, allowedTarget);
         mv.visitCode();
         mv.visitInsn(Opcodes.RETURN);
         mv.visitEnd();
@@ -334,17 +345,19 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     }
 
     private void writeInnerClass(@NotNull ClassDescriptor innerClass) {
-        writeInnerClass(innerClass, typeMapper, v);
+        if (!ErrorUtils.isError(innerClass)) {
+            writeInnerClass(innerClass, typeMapper, v);
+        }
     }
 
     public static void writeInnerClass(@NotNull ClassDescriptor innerClass, @NotNull KotlinTypeMapper typeMapper, @NotNull ClassBuilder v) {
         DeclarationDescriptor containing = innerClass.getContainingDeclaration();
         String outerClassInternalName = null;
         if (containing instanceof ClassDescriptor) {
-            outerClassInternalName = typeMapper.mapClass((ClassDescriptor) containing).getInternalName();
+            outerClassInternalName = typeMapper.classInternalName((ClassDescriptor) containing);
         }
         String innerName = innerClass.getName().isSpecial() ? null : innerClass.getName().asString();
-        String innerClassInternalName = typeMapper.mapClass(innerClass).getInternalName();
+        String innerClassInternalName = typeMapper.classInternalName(innerClass);
         v.visitInnerClass(innerClassInternalName, outerClassInternalName, innerName, calculateInnerClassAccessFlags(innerClass));
     }
 
@@ -377,7 +390,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
             ClassDescriptor classDescriptor = ((ClassContext) outermost).getContextDescriptor();
             if (context instanceof MethodContext) {
                 FunctionDescriptor functionDescriptor = ((MethodContext) context).getFunctionDescriptor();
-                if (isInterface(functionDescriptor.getContainingDeclaration()) && !isJvm8InterfaceMember(functionDescriptor, state)) {
+                if (isInterface(functionDescriptor.getContainingDeclaration()) && !isJvm8InterfaceWithDefaultsMember(functionDescriptor, state)) {
                     return typeMapper.mapDefaultImpls(classDescriptor);
                 }
             }
@@ -491,10 +504,11 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         int indexOfDelegatedProperty = PropertyCodegen.indexOfDelegatedProperty(property);
 
         StackValue delegateValue = PropertyCodegen.invokeDelegatedPropertyConventionMethodWithReceiver(
-                codegen, typeMapper, provideDelegateResolvedCall, indexOfDelegatedProperty, 1, provideDelegateReceiver);
+                codegen, typeMapper, provideDelegateResolvedCall, indexOfDelegatedProperty, 1,
+                provideDelegateReceiver, propertyDescriptor
+        );
 
         propValue.store(delegateValue, codegen.v);
-
     }
 
     protected boolean shouldInitializeProperty(@NotNull KtProperty property) {
@@ -582,7 +596,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         }
         if (delegatedProperties.isEmpty()) return;
 
-        v.newField(NO_ORIGIN, ACC_PRIVATE | ACC_STATIC | ACC_FINAL | ACC_SYNTHETIC, JvmAbi.DELEGATED_PROPERTIES_ARRAY_NAME,
+        v.newField(NO_ORIGIN, ACC_STATIC | ACC_FINAL | ACC_SYNTHETIC, JvmAbi.DELEGATED_PROPERTIES_ARRAY_NAME,
                    "[" + K_PROPERTY_TYPE, null, null);
 
         if (!state.getClassBuilderMode().generateBodies) return;
@@ -771,7 +785,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
                 ((AccessorForCallableDescriptor) accessorDescriptor).getSuperCallTarget() != null
         );
 
-        boolean hasDispatchReceiver = !isStaticDeclaration(functionDescriptor) && !isInterface(functionDescriptor.getContainingDeclaration());
+        boolean hasDispatchReceiver = !isStaticDeclaration(functionDescriptor) && !isNonDefaultInterfaceMember(functionDescriptor, state);
         int reg = hasDispatchReceiver ? 1 : 0;
         boolean accessorIsConstructor = accessorDescriptor instanceof AccessorForConstructorDescriptor;
         if (!accessorIsConstructor && functionDescriptor instanceof ConstructorDescriptor) {

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

@@ -176,7 +176,7 @@ class MultifileClassPartCodegen(
         }
 
         val serializer = DescriptorSerializer.createTopLevel(JvmSerializerExtension(v.serializationBindings, state))
-        val packageProto = serializer.packagePartProto(members).build()
+        val packageProto = serializer.packagePartProto(packageFragment.fqName, members).build()
 
         val extraFlags = if (shouldGeneratePartHierarchy) JvmAnnotationNames.METADATA_MULTIFILE_PARTS_INHERIT_FLAG else 0
 

compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java

@@ -129,7 +129,7 @@ public class PackagePartCodegen extends MemberCodegen<KtFile> {
 
         final DescriptorSerializer serializer =
                 DescriptorSerializer.createTopLevel(new JvmSerializerExtension(v.getSerializationBindings(), state));
-        final ProtoBuf.Package packageProto = serializer.packagePartProto(members).build();
+        final ProtoBuf.Package packageProto = serializer.packagePartProto(element.getPackageFqName(), members).build();
 
         WriteAnnotationUtilKt.writeKotlinMetadata(v, state, KotlinClassHeader.Kind.FILE_FACADE, 0, new Function1<AnnotationVisitor, Unit>() {
             @Override

compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java

@@ -20,7 +20,6 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.codegen.annotation.AnnotatedSimple;
 import org.jetbrains.kotlin.codegen.annotation.AnnotatedWithFakeAnnotations;
 import org.jetbrains.kotlin.codegen.context.*;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
@@ -58,7 +57,8 @@ import java.util.List;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.getDeprecatedAccessFlag;
 import static org.jetbrains.kotlin.codegen.AsmUtil.getVisibilityForBackingField;
-import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.*;
+import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConstOrHasJvmFieldAnnotation;
+import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.FIELD_FOR_PROPERTY;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.SYNTHETIC_METHOD_FOR_PROPERTY;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.isCompanionObject;
@@ -188,7 +188,7 @@ public class PropertyCodegen {
         if (isCompanionObject(descriptor.getContainingDeclaration())) return true;
 
         // Non-const properties from multifile classes have accessors regardless of visibility
-        if (!descriptor.isConst() && JvmFileClassUtilKt.isInsideJvmMultifileClassFile(declaration)) return true;
+        if (isNonConstTopLevelPropertyInMultifileClass(declaration, descriptor)) return true;
 
         // Private class properties have accessors only in cases when those accessors are non-trivial
         if (Visibilities.isPrivate(descriptor.getVisibility())) {
@@ -198,6 +198,15 @@ public class PropertyCodegen {
         return true;
     }
 
+    private static boolean isNonConstTopLevelPropertyInMultifileClass(
+            @NotNull KtProperty declaration,
+            @NotNull PropertyDescriptor descriptor
+    ) {
+        return !descriptor.isConst() &&
+               descriptor.getContainingDeclaration() instanceof PackageFragmentDescriptor &&
+               JvmFileClassUtilKt.isInsideJvmMultifileClassFile(declaration);
+    }
+
     private static boolean areAccessorsNeededForPrimaryConstructorProperty(
             @NotNull PropertyDescriptor descriptor
     ) {
@@ -270,7 +279,7 @@ public class PropertyCodegen {
     }
 
     // Annotations on properties are stored in bytecode on an empty synthetic method. This way they're still
-    // accessible via reflection, and 'deprecated' and 'private' flags prevent this method from being called accidentally
+    // accessible via reflection, and 'deprecated' and 'synthetic' flags prevent this method from being called accidentally
     private void generateSyntheticMethodIfNeeded(@NotNull PropertyDescriptor descriptor, @NotNull Annotations annotations) {
         if (annotations.getAllAnnotations().isEmpty()) return;
 
@@ -278,15 +287,9 @@ public class PropertyCodegen {
         if (!isInterface(contextDescriptor) ||
             (FunctionCodegen.processInterface(contextDescriptor, kind, state) ||
              (kind == OwnerKind.DEFAULT_IMPLS && state.getGenerateDefaultImplsForJvm8()))) {
-            int flags = ACC_DEPRECATED | ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC;
-            Method syntheticMethod = getSyntheticMethodSignature(descriptor);
-            MethodVisitor mv = v.newMethod(JvmDeclarationOriginKt.OtherOrigin(descriptor), flags, syntheticMethod.getName(),
-                                           syntheticMethod.getDescriptor(), null, null);
-            AnnotationCodegen.forMethod(mv, memberCodegen, typeMapper)
-                    .genAnnotations(new AnnotatedSimple(annotations), Type.VOID_TYPE, AnnotationUseSiteTarget.PROPERTY);
-            mv.visitCode();
-            mv.visitInsn(Opcodes.RETURN);
-            mv.visitEnd();
+            memberCodegen.generateSyntheticAnnotationsMethod(
+                    descriptor, getSyntheticMethodSignature(descriptor), annotations, AnnotationUseSiteTarget.PROPERTY
+            );
         }
     }
 
@@ -540,7 +543,7 @@ public class PropertyCodegen {
         StackValue.Property receiver = codegen.intermediateValueForProperty(propertyDescriptor, true, null, StackValue.LOCAL_0);
         return invokeDelegatedPropertyConventionMethodWithReceiver(
                 codegen, typeMapper, resolvedCall, indexInPropertyMetadataArray, propertyMetadataArgumentIndex,
-                receiver
+                receiver, propertyDescriptor
         );
     }
 
@@ -550,9 +553,12 @@ public class PropertyCodegen {
             @NotNull ResolvedCall<FunctionDescriptor> resolvedCall,
             final int indexInPropertyMetadataArray,
             int propertyMetadataArgumentIndex,
-            @Nullable StackValue receiver
+            @Nullable StackValue receiver,
+            @NotNull PropertyDescriptor propertyDescriptor
     ) {
-        final Type owner = getDelegatedPropertyMetadataOwner(codegen, typeMapper);
+        final Type owner = JvmAbi.isPropertyWithBackingFieldInOuterClass(propertyDescriptor) ?
+                           codegen.getState().getTypeMapper().mapOwner(propertyDescriptor)  :
+                           getDelegatedPropertyMetadataOwner(codegen, typeMapper);
 
         codegen.tempVariables.put(
                 resolvedCall.getCall().getValueArguments().get(propertyMetadataArgumentIndex).asElement(),

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

@@ -34,7 +34,7 @@ data class SourceInfo(val source: String, val pathOrCleanFQN: String, val linesI
             val isTopLevel = element is KtFile || (element is KtNamedFunction && element.getParent() is KtFile)
             val cleanedClassFqName = if (!isTopLevel) internalClassName else internalClassName.substringBefore('$')
 
-            return SourceInfo(element.getContainingKtFile().name, cleanedClassFqName, lineNumbers!!)
+            return SourceInfo(element.containingKtFile.name, cleanedClassFqName, lineNumbers!!)
         }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java

@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.org.objectweb.asm.Label;
+import org.jetbrains.org.objectweb.asm.Opcodes;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 
@@ -281,60 +282,29 @@ public abstract class StackValue {
     }
 
     private static void box(Type type, Type toType, InstructionAdapter v) {
-        if (type == Type.BYTE_TYPE || toType.getInternalName().equals(NULLABLE_BYTE_TYPE_NAME) && type == Type.INT_TYPE) {
-            v.cast(type, Type.BYTE_TYPE);
-            v.invokestatic(NULLABLE_BYTE_TYPE_NAME, "valueOf", "(B)L" + NULLABLE_BYTE_TYPE_NAME + ";", false);
-        }
-        else if (type == Type.SHORT_TYPE || toType.getInternalName().equals(NULLABLE_SHORT_TYPE_NAME) && type == Type.INT_TYPE) {
-            v.cast(type, Type.SHORT_TYPE);
-            v.invokestatic(NULLABLE_SHORT_TYPE_NAME, "valueOf", "(S)L" + NULLABLE_SHORT_TYPE_NAME + ";", false);
-        }
-        else if (type == Type.LONG_TYPE || toType.getInternalName().equals(NULLABLE_LONG_TYPE_NAME) && type == Type.INT_TYPE) {
-            v.cast(type, Type.LONG_TYPE);
-            v.invokestatic(NULLABLE_LONG_TYPE_NAME, "valueOf", "(J)L" + NULLABLE_LONG_TYPE_NAME + ";", false);
-        }
-        else if (type == Type.INT_TYPE) {
-            v.invokestatic("java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", false);
-        }
-        else if (type == Type.BOOLEAN_TYPE) {
-            v.invokestatic("java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
-        }
-        else if (type == Type.CHAR_TYPE) {
-            v.invokestatic("java/lang/Character", "valueOf", "(C)Ljava/lang/Character;", false);
-        }
-        else if (type == Type.FLOAT_TYPE) {
-            v.invokestatic("java/lang/Float", "valueOf", "(F)Ljava/lang/Float;", false);
-        }
-        else if (type == Type.DOUBLE_TYPE) {
-            v.invokestatic("java/lang/Double", "valueOf", "(D)Ljava/lang/Double;", false);
+        if (type == Type.INT_TYPE) {
+            if (toType.getInternalName().equals(NULLABLE_BYTE_TYPE_NAME)) {
+                type = Type.BYTE_TYPE;
+            }
+            else if (toType.getInternalName().equals(NULLABLE_SHORT_TYPE_NAME)) {
+                type = Type.SHORT_TYPE;
+            }
+            else if (toType.getInternalName().equals(NULLABLE_LONG_TYPE_NAME)) {
+                type = Type.LONG_TYPE;
+            }
+            v.cast(Type.INT_TYPE, type);
         }
+
+        Type boxedType = AsmUtil.boxType(type);
+        if (boxedType == type) return;
+
+        v.invokestatic(boxedType.getInternalName(), "valueOf", Type.getMethodDescriptor(boxedType, type), false);
+        coerce(boxedType, toType,  v);
     }
 
-    private static void unbox(Type type, InstructionAdapter v) {
-        if (type == Type.INT_TYPE) {
-            v.invokevirtual("java/lang/Number", "intValue", "()I", false);
-        }
-        else if (type == Type.BOOLEAN_TYPE) {
-            v.invokevirtual("java/lang/Boolean", "booleanValue", "()Z", false);
-        }
-        else if (type == Type.CHAR_TYPE) {
-            v.invokevirtual("java/lang/Character", "charValue", "()C", false);
-        }
-        else if (type == Type.SHORT_TYPE) {
-            v.invokevirtual("java/lang/Number", "shortValue", "()S", false);
-        }
-        else if (type == Type.LONG_TYPE) {
-            v.invokevirtual("java/lang/Number", "longValue", "()J", false);
-        }
-        else if (type == Type.BYTE_TYPE) {
-            v.invokevirtual("java/lang/Number", "byteValue", "()B", false);
-        }
-        else if (type == Type.FLOAT_TYPE) {
-            v.invokevirtual("java/lang/Number", "floatValue", "()F", false);
-        }
-        else if (type == Type.DOUBLE_TYPE) {
-            v.invokevirtual("java/lang/Number", "doubleValue", "()D", false);
-        }
+    private static void unbox(Type methodOwner, Type type, InstructionAdapter v) {
+        assert isPrimitive(type) : "Unboxing should be performed to primitive type, but " + type.getClassName();
+        v.invokevirtual(methodOwner.getInternalName(), type.getClassName() + "Value", "()" + type.getDescriptor(), false);
     }
 
     protected void coerceTo(@NotNull Type toType, @NotNull InstructionAdapter v) {
@@ -372,23 +342,12 @@ public abstract class StackValue {
             }
         }
         else if (toType.getSort() == Type.ARRAY) {
-            if (fromType.getSort() == Type.ARRAY &&
-                fromType.getElementType().equals(AsmTypes.JAVA_CLASS_TYPE) && toType.equals(K_CLASS_ARRAY_TYPE)) {
-                wrapJavaClassesIntoKClasses(v);
-            }
-            else {
-                v.checkcast(toType);
-            }
+            v.checkcast(toType);
         }
         else if (toType.getSort() == Type.OBJECT) {
             if (fromType.getSort() == Type.OBJECT || fromType.getSort() == Type.ARRAY) {
                 if (!toType.equals(OBJECT_TYPE)) {
-                    if (fromType.equals(AsmTypes.JAVA_CLASS_TYPE) && toType.equals(AsmTypes.K_CLASS_TYPE)) {
-                        wrapJavaClassIntoKClass(v);
-                    }
-                    else {
-                        v.checkcast(toType);
-                    }
+                    v.checkcast(toType);
                 }
             }
             else {
@@ -396,20 +355,29 @@ public abstract class StackValue {
             }
         }
         else if (fromType.getSort() == Type.OBJECT) {
+            //toType is primitive here
             Type unboxedType = unboxPrimitiveTypeOrNull(fromType);
             if (unboxedType != null) {
-                unbox(unboxedType, v);
+                unbox(fromType, unboxedType, v);
                 coerce(unboxedType, toType, v);
             }
-            else {
-                Type numberType = getType(Number.class);
-                if (toType.getSort() == Type.BOOLEAN || (toType.getSort() == Type.CHAR && !numberType.equals(fromType))) {
-                    coerce(fromType, boxType(toType), v);
+            else if (toType.getSort() == Type.BOOLEAN) {
+                coerce(fromType, BOOLEAN_WRAPPER_TYPE, v);
+                unbox(BOOLEAN_WRAPPER_TYPE, Type.BOOLEAN_TYPE, v);
+            }
+            else if (toType.getSort() == Type.CHAR) {
+                if (fromType.equals(NUMBER_TYPE)) {
+                    unbox(NUMBER_TYPE, Type.INT_TYPE, v);
+                    v.visitInsn(Opcodes.I2C);
                 }
                 else {
-                    coerce(fromType, numberType, v);
+                    coerce(fromType, CHARACTER_WRAPPER_TYPE, v);
+                    unbox(CHARACTER_WRAPPER_TYPE, Type.CHAR_TYPE, v);
                 }
-                unbox(toType, v);
+            }
+            else {
+                coerce(fromType, NUMBER_TYPE, v);
+                unbox(NUMBER_TYPE, toType, v);
             }
         }
         else {
@@ -883,7 +851,7 @@ public abstract class StackValue {
             newReceiver.put(newReceiver.type, v);
             callGenerator.processAndPutHiddenParameters(false);
 
-            defaultArgs = generator.generate(valueArguments, valueArguments);
+            defaultArgs = generator.generate(valueArguments, valueArguments, call.getResultingDescriptor());
         }
 
         private ArgumentGenerator createArgumentGenerator() {
@@ -1211,7 +1179,20 @@ public abstract class StackValue {
                 else {
                     getter.genInvokeInstruction(v);
                 }
-                coerce(getter.getReturnType(), type, v);
+
+                Type typeOfValueOnStack = getter.getReturnType();
+                if (DescriptorUtils.isAnnotationClass(descriptor.getContainingDeclaration())) {
+                    if (this.type.equals(K_CLASS_TYPE)) {
+                        wrapJavaClassIntoKClass(v);
+                        typeOfValueOnStack = K_CLASS_TYPE;
+                    }
+                    else if (this.type.equals(K_CLASS_ARRAY_TYPE)) {
+                        wrapJavaClassesIntoKClasses(v);
+                        typeOfValueOnStack = K_CLASS_ARRAY_TYPE;
+                    }
+                }
+
+                coerce(typeOfValueOnStack, type, v);
 
                 KotlinType returnType = descriptor.getReturnType();
                 if (returnType != null && KotlinBuiltIns.isNothing(returnType)) {
@@ -1378,9 +1359,7 @@ public abstract class StackValue {
             default:
                 PrimitiveType primitiveType = AsmUtil.asmPrimitiveTypeToLangPrimitiveType(type);
                 if (primitiveType == null) throw new UnsupportedOperationException();
-
-                String typeName = primitiveType.getTypeName().getIdentifier();
-                return Type.getObjectType(REF_TYPE_PREFIX + typeName + "Ref");
+                return sharedTypeForPrimitive(primitiveType);
         }
     }
 
@@ -1596,6 +1575,16 @@ public abstract class StackValue {
         public void dup(@NotNull InstructionAdapter v, boolean withReceiver) {
             AsmUtil.dup(v, extensionReceiver.type, dispatchReceiver.type);
         }
+
+        @NotNull
+        public StackValue getDispatchReceiver() {
+            return dispatchReceiver;
+        }
+
+        @NotNull
+        public StackValue getExtensionReceiver() {
+            return extensionReceiver;
+        }
     }
 
     public abstract static class StackValueWithSimpleReceiver extends StackValue {

compiler/backend/src/org/jetbrains/kotlin/codegen/TailRecursionCodegen.java

@@ -20,6 +20,7 @@ import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cfg.TailRecursionKind;
 import org.jetbrains.kotlin.codegen.context.MethodContext;
+import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenUtilKt;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
@@ -65,7 +66,7 @@ public class TailRecursionCodegen {
     }
 
     public void generateTailRecursion(ResolvedCall<?> resolvedCall) {
-        CallableDescriptor fd = resolvedCall.getResultingDescriptor();
+        CallableDescriptor fd = CoroutineCodegenUtilKt.unwrapInitialDescriptorForSuspendFunction(resolvedCall.getResultingDescriptor());
         assert fd instanceof FunctionDescriptor : "Resolved call doesn't refer to the function descriptor: " + fd;
         CallableMethod callable = (CallableMethod) codegen.resolveToCallable((FunctionDescriptor) fd, false, resolvedCall);
 
@@ -73,6 +74,11 @@ public class TailRecursionCodegen {
         if (arguments == null) {
             throw new IllegalStateException("Failed to arrange value arguments by index: " + fd);
         }
+
+        if (((FunctionDescriptor) fd).isSuspend()) {
+            AsmUtil.pop(v, callable.getValueParameters().get(callable.getValueParameters().size() - 1).getAsmType());
+        }
+
         assignParameterValues(fd, callable, arguments);
         if (callable.getExtensionReceiverType() != null) {
             if (resolvedCall.getExtensionReceiver() != fd.getExtensionReceiverParameter().getValue()) {

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CalculatedClosure.java

@@ -44,5 +44,7 @@ public interface CalculatedClosure {
     @NotNull
     List<Pair<String, Type>> getRecordedFields();
 
-    boolean isCoroutine();
+    boolean isSuspend();
+
+    boolean isSuspendLambda();
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java

@@ -100,10 +100,21 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
             @NotNull CallableDescriptor callableDescriptor,
             @NotNull Collection<KotlinType> supertypes,
             @NotNull String name
+    ) {
+        return recordClassForCallable(element, callableDescriptor, supertypes, name, null);
+    }
+
+    @NotNull
+    private ClassDescriptor recordClassForCallable(
+            @NotNull KtElement element,
+            @NotNull CallableDescriptor callableDescriptor,
+            @NotNull Collection<KotlinType> supertypes,
+            @NotNull String name,
+            @Nullable DeclarationDescriptor customContainer
     ) {
         String simpleName = name.substring(name.lastIndexOf('/') + 1);
         ClassDescriptor classDescriptor = new SyntheticClassDescriptorForLambda(
-                correctContainerForLambda(callableDescriptor, element),
+                customContainer != null ? customContainer : correctContainerForLambda(callableDescriptor, element),
                 Name.special("<closure-" + simpleName + ">"),
                 supertypes,
                 element
@@ -289,7 +300,8 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         nameStack.push(name);
 
         if (CoroutineUtilKt.isSuspendLambda(functionDescriptor)) {
-            closure.setCoroutine(true);
+            closure.setSuspend(true);
+            closure.setSuspendLambda();
         }
 
         super.visitLambdaExpression(lambdaExpression);
@@ -415,9 +427,11 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         // working around a problem with shallow analysis
         if (functionDescriptor == null) return;
 
+        String nameForClassOrPackageMember = getNameForClassOrPackageMember(functionDescriptor);
+
         if (functionDescriptor instanceof SimpleFunctionDescriptor && functionDescriptor.isSuspend()) {
             SimpleFunctionDescriptor jvmSuspendFunctionView =
-                    CoroutineCodegenUtilKt.createJvmSuspendFunctionView(
+                    CoroutineCodegenUtilKt.getOrCreateJvmSuspendFunctionView(
                             (SimpleFunctionDescriptor) functionDescriptor
                     );
 
@@ -437,31 +451,53 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
 
             bindingTrace.record(
                     CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW,
-                    (SimpleFunctionDescriptor) functionDescriptor,
+                    functionDescriptor,
                     jvmSuspendFunctionView
             );
+
+            if (CoroutineCodegenUtilKt.containsNonTailSuspensionCalls(functionDescriptor, bindingContext)) {
+                if (nameForClassOrPackageMember != null) {
+                    nameStack.push(nameForClassOrPackageMember);
+                }
+
+                processNamedFunctionWithClosure(function, functionDescriptor, functionDescriptor).setSuspend(true);
+
+                if (nameForClassOrPackageMember != null) {
+                    nameStack.pop();
+                }
+                return;
+            }
         }
 
-        String nameForClassOrPackageMember = getNameForClassOrPackageMember(functionDescriptor);
         if (nameForClassOrPackageMember != null) {
             nameStack.push(nameForClassOrPackageMember);
             super.visitNamedFunction(function);
             nameStack.pop();
         }
         else {
-            String name = inventAnonymousClassName();
-            Collection<KotlinType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
-            ClassDescriptor classDescriptor = recordClassForCallable(function, functionDescriptor, supertypes, name);
-            recordClosure(classDescriptor, name);
-
-            classStack.push(classDescriptor);
-            nameStack.push(name);
-            super.visitNamedFunction(function);
-            nameStack.pop();
-            classStack.pop();
+            processNamedFunctionWithClosure(function, functionDescriptor, null);
         }
     }
 
+    private MutableClosure processNamedFunctionWithClosure(
+            @NotNull KtNamedFunction function,
+            @NotNull FunctionDescriptor functionDescriptor,
+            @Nullable DeclarationDescriptor customContainer
+    ) {
+        String name = inventAnonymousClassName();
+        Collection<KotlinType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
+        ClassDescriptor classDescriptor = recordClassForCallable(function, functionDescriptor, supertypes, name, customContainer);
+        MutableClosure closure = recordClosure(classDescriptor, name);
+
+        classStack.push(classDescriptor);
+        nameStack.push(name);
+        super.visitNamedFunction(function);
+        nameStack.pop();
+        classStack.pop();
+
+        return closure;
+    }
+
     @Nullable
     private String getNameForClassOrPackageMember(@NotNull DeclarationDescriptor descriptor) {
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
@@ -612,8 +648,10 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         int fieldNumber = mappings.size();
 
         assert expression.getSubjectExpression() != null : "subject expression should be not null in a valid when by enums";
-        KotlinType type = bindingContext.getType(expression.getSubjectExpression());
+
+        KotlinType type = WhenChecker.whenSubjectType(expression, bindingContext);
         assert type != null : "should not be null in a valid when by enums";
+
         ClassDescriptor classDescriptor = (ClassDescriptor) type.getConstructor().getDeclarationDescriptor();
         assert classDescriptor != null : "because it's enum";
 

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java

@@ -66,7 +66,7 @@ public class CodegenBinding {
     public static final WritableSlice<VariableDescriptor, VariableDescriptor> LOCAL_VARIABLE_PROPERTY_METADATA =
             Slices.createSimpleSlice();
 
-    public static final WritableSlice<SimpleFunctionDescriptor, SimpleFunctionDescriptor> SUSPEND_FUNCTION_TO_JVM_VIEW =
+    public static final WritableSlice<FunctionDescriptor, FunctionDescriptor> SUSPEND_FUNCTION_TO_JVM_VIEW =
             Slices.createSimpleSlice();
 
     public static final WritableSlice<ValueParameterDescriptor, ValueParameterDescriptor> PARAMETER_SYNONYM =

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen.binding;
 import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.codegen.StackValue;
 import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.types.KotlinType;
@@ -40,7 +41,8 @@ public final class MutableClosure implements CalculatedClosure {
     private Map<DeclarationDescriptor, Integer> parameterOffsetInConstructor;
     private List<Pair<String, Type>> recordedFields;
     private KotlinType captureReceiverType;
-    private boolean isCoroutine;
+    private boolean isSuspend;
+    private boolean isSuspendLambda;
 
     MutableClosure(@NotNull ClassDescriptor classDescriptor, @Nullable ClassDescriptor enclosingClass) {
         this.closureClass = classDescriptor;
@@ -119,15 +121,24 @@ public final class MutableClosure implements CalculatedClosure {
     }
 
     @Override
-    public boolean isCoroutine() {
-        return isCoroutine;
+    public boolean isSuspend() {
+        return isSuspend;
     }
 
-    public void setCoroutine(boolean coroutine) {
-        this.isCoroutine = coroutine;
+    public void setSuspend(boolean suspend) {
+        this.isSuspend = suspend;
     }
 
-    public void recordField(String name, Type type) {
+    @Override
+    public boolean isSuspendLambda() {
+        return isSuspendLambda;
+    }
+
+    public void setSuspendLambda() {
+        isSuspendLambda = true;
+    }
+
+    private void recordField(String name, Type type) {
         if (recordedFields == null) {
             recordedFields = new LinkedList<Pair<String, Type>>();
         }
@@ -135,6 +146,8 @@ public final class MutableClosure implements CalculatedClosure {
     }
 
     public void captureVariable(EnclosedValueDescriptor value) {
+        recordField(value.getFieldName(), value.getType());
+
         if (captureVariables == null) {
             captureVariables = new LinkedHashMap<DeclarationDescriptor, EnclosedValueDescriptor>();
         }

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

@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getParentCall
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.overriddenTreeAsSequence
 import org.jetbrains.kotlin.utils.addIfNotNull
-import org.jetbrains.kotlin.utils.singletonOrEmptyList
 import java.util.*
 
 class BridgeForBuiltinSpecial<out Signature : Any>(
@@ -76,7 +75,7 @@ object BuiltinSpecialBridgesUtil {
         else null
 
         val commonBridges = reachableDeclarations.mapTo(LinkedHashSet<Signature>(), signatureByDescriptor)
-        commonBridges.removeAll(specialBridgesSignaturesInSuperClass + specialBridge?.from.singletonOrEmptyList())
+        commonBridges.removeAll(specialBridgesSignaturesInSuperClass + listOfNotNull(specialBridge?.from))
 
         if (fake) {
             for (overridden in function.overriddenDescriptors.map { it.original }) {

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

@@ -40,7 +40,7 @@ private fun Iterable<PackageParts>.addCompiledParts(state: GenerationState): Lis
     val incrementalCache = state.incrementalCacheForThisTarget ?: return this.toList()
     val moduleMappingData = incrementalCache.getModuleMappingData() ?: return this.toList()
 
-    val mapping = ModuleMapping.create(moduleMappingData, "<incremental>")
+    val mapping = ModuleMapping.create(moduleMappingData, "<incremental>", state.deserializationConfiguration)
 
     incrementalCache.getObsoletePackageParts().forEach { internalName ->
         val qualifier = internalName.substringBeforeLast('/', "").replace('/', '.')

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

@@ -21,30 +21,34 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.codegen.context.FieldOwnerContext
 import org.jetbrains.kotlin.codegen.context.PackageContext
+import org.jetbrains.kotlin.codegen.coroutines.unwrapInitialDescriptorForSuspendFunction
 import org.jetbrains.kotlin.codegen.intrinsics.TypeIntrinsics
 import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers
 import org.jetbrains.kotlin.diagnostics.rendering.RenderingContext
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.SpecialSignatureInfo
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
-import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.psi.KtObjectDeclaration
-import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils.isSubclass
 import org.jetbrains.kotlin.resolve.annotations.hasJvmStaticAnnotation
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfoBefore
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
+import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
 import org.jetbrains.kotlin.serialization.deserialization.PLATFORM_DEPENDENT_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.KotlinType
@@ -267,25 +271,27 @@ private fun CallableDescriptor.isJvmStaticIn(predicate: (DeclarationDescriptor)
 fun Collection<VariableDescriptor>.filterOutDescriptorsWithSpecialNames() = filterNot { it.name.isSpecial }
 
 
-fun calcTypeForIEEE754ArithmeticIfNeeded(expression: KtExpression?, bindingContext: BindingContext, descriptor: DeclarationDescriptor): Type? {
+class TypeAndNullability(@JvmField val type: Type, @JvmField val isNullable: Boolean)
+
+fun calcTypeForIEEE754ArithmeticIfNeeded(expression: KtExpression?, bindingContext: BindingContext, descriptor: DeclarationDescriptor): TypeAndNullability? {
     val ktType = expression.kotlinType(bindingContext) ?: return null
 
     if (KotlinBuiltIns.isDoubleOrNullableDouble(ktType)) {
-        return Type.DOUBLE_TYPE
+        return TypeAndNullability(Type.DOUBLE_TYPE, TypeUtils.isNullableType(ktType))
     }
 
     if (KotlinBuiltIns.isFloatOrNullableFloat(ktType)) {
-        return Type.FLOAT_TYPE
+        return TypeAndNullability(Type.FLOAT_TYPE, TypeUtils.isNullableType(ktType))
     }
 
     val dataFlow = DataFlowValueFactory.createDataFlowValue(expression!!, ktType, bindingContext, descriptor)
     val stableTypes = bindingContext.getDataFlowInfoBefore(expression).getStableTypes(dataFlow)
     return stableTypes.firstNotNullResult {
         if (KotlinBuiltIns.isDoubleOrNullableDouble(it)) {
-            Type.DOUBLE_TYPE
+            TypeAndNullability(Type.DOUBLE_TYPE, TypeUtils.isNullableType(it))
         }
         else if (KotlinBuiltIns.isFloatOrNullableFloat(it)) {
-            Type.FLOAT_TYPE
+            TypeAndNullability(Type.FLOAT_TYPE, TypeUtils.isNullableType(it))
         }
         else {
             null
@@ -339,3 +345,35 @@ fun MemberDescriptor.isToArrayFromCollection(): Boolean {
 
     return isGenericToArray() || isNonGenericToArray()
 }
+
+fun FqName.topLevelClassInternalName() = JvmClassName.byClassId(ClassId(parent(), shortName())).internalName
+fun FqName.topLevelClassAsmType(): Type = Type.getObjectType(topLevelClassInternalName())
+
+fun initializeVariablesForDestructuredLambdaParameters(codegen: ExpressionCodegen, valueParameters: List<ValueParameterDescriptor>) {
+    val savedIsShouldMarkLineNumbers = codegen.isShouldMarkLineNumbers
+    // Do not write line numbers until destructuring happens
+    // (otherwise destructuring variables will be uninitialized in the beginning of lambda)
+    codegen.isShouldMarkLineNumbers = false
+
+    for (parameterDescriptor in valueParameters) {
+        if (parameterDescriptor !is ValueParameterDescriptorImpl.WithDestructuringDeclaration) continue
+
+        for (entry in parameterDescriptor.destructuringVariables.filterOutDescriptorsWithSpecialNames()) {
+            codegen.myFrameMap.enter(entry, codegen.typeMapper.mapType(entry.type))
+        }
+
+        val destructuringDeclaration =
+                (DescriptorToSourceUtils.descriptorToDeclaration(parameterDescriptor) as? KtParameter)?.destructuringDeclaration
+                ?: error("Destructuring declaration for descriptor $parameterDescriptor not found")
+
+        codegen.initializeDestructuringDeclarationVariables(
+                destructuringDeclaration,
+                TransientReceiver(parameterDescriptor.type),
+                codegen.findLocalOrCapturedValue(parameterDescriptor) ?: error("Local var not found for parameter $parameterDescriptor")
+        )
+    }
+
+    codegen.isShouldMarkLineNumbers = savedIsShouldMarkLineNumbers
+}
+
+fun <D : CallableDescriptor> D.unwrapFrontendVersion() = unwrapInitialDescriptorForSuspendFunction()

compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java

@@ -26,23 +26,23 @@ import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.anonymousClass
 
 public class ClosureContext extends ClassContext {
     private final FunctionDescriptor functionDescriptor;
-    private final FunctionDescriptor coroutineDescriptor;
+    private final FunctionDescriptor originalSuspendLambdaDescriptor;
 
     public ClosureContext(
             @NotNull KotlinTypeMapper typeMapper,
             @NotNull FunctionDescriptor functionDescriptor,
             @Nullable CodegenContext parentContext,
             @NotNull LocalLookup localLookup,
-            // original coroutine lambda descriptor having return type T (the type that can be returned within lambda)
-            @Nullable FunctionDescriptor coroutineDescriptor
+            // original suspend lambda descriptor
+            @Nullable FunctionDescriptor originalSuspendLambdaDescriptor
     ) {
         super(typeMapper,
               anonymousClassForCallable(
-                      typeMapper.getBindingContext(), coroutineDescriptor != null ? coroutineDescriptor : functionDescriptor),
+                      typeMapper.getBindingContext(), originalSuspendLambdaDescriptor != null ? originalSuspendLambdaDescriptor : functionDescriptor),
               OwnerKind.IMPLEMENTATION, parentContext, localLookup);
 
         this.functionDescriptor = functionDescriptor;
-        this.coroutineDescriptor = coroutineDescriptor;
+        this.originalSuspendLambdaDescriptor = originalSuspendLambdaDescriptor;
     }
 
     public ClosureContext(
@@ -65,7 +65,7 @@ public class ClosureContext extends ClassContext {
     }
 
     @Nullable
-    public FunctionDescriptor getCoroutineDescriptor() {
-        return coroutineDescriptor;
+    public FunctionDescriptor getOriginalSuspendLambdaDescriptor() {
+        return originalSuspendLambdaDescriptor;
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java

@@ -37,7 +37,7 @@ import org.jetbrains.org.objectweb.asm.Type;
 import java.util.*;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.getVisibilityAccessFlag;
-import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
+import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isNonDefaultInterfaceMember;
 import static org.jetbrains.kotlin.descriptors.annotations.AnnotationUtilKt.isInlineOnlyOrReifiable;
 import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PRIVATE;
 import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PROTECTED;
@@ -340,14 +340,14 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
 
     @NotNull
     public ClosureContext intoCoroutineClosure(
-            // copy of lambda descriptor that have Continuation<Unit> return type (as it's ep)
-            @NotNull FunctionDescriptor funDescriptorReturningContinuation,
-            // original coroutine lambda descriptor having return type T (the type that can be returned within lambda)
-            @NotNull FunctionDescriptor coroutineLambdaDescriptor,
+            // copy of lambda descriptor that has an additional value parameter Continuation<T>
+            @NotNull FunctionDescriptor jvmViewOfSuspendLambda,
+            // original coroutine lambda descriptor
+            @NotNull FunctionDescriptor originalSuspendLambdaDescriptor,
             @NotNull LocalLookup localLookup,
             @NotNull KotlinTypeMapper typeMapper
     ) {
-        return new ClosureContext(typeMapper, funDescriptorReturningContinuation, this, localLookup, coroutineLambdaDescriptor);
+        return new ClosureContext(typeMapper, jvmViewOfSuspendLambda, this, localLookup, originalSuspendLambdaDescriptor);
     }
 
     @Nullable
@@ -391,8 +391,11 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
 
     @SuppressWarnings("unchecked")
     @NotNull
-    public <D extends CallableMemberDescriptor> D getAccessorForSuperCallIfNeeded(@NotNull D descriptor, @Nullable ClassDescriptor superCallTarget) {
-        if (superCallTarget != null && !isJvmInterface(descriptor.getContainingDeclaration())) {
+    public <D extends CallableMemberDescriptor> D getAccessorForSuperCallIfNeeded(
+            @NotNull D descriptor,
+            @Nullable ClassDescriptor superCallTarget,
+            @NotNull GenerationState state) {
+        if (superCallTarget != null && !isNonDefaultInterfaceMember(descriptor, state)) {
             CodegenContext afterInline = getFirstCrossInlineOrNonInlineContext();
             CodegenContext c = afterInline.findParentContextWithDescriptor(superCallTarget);
             assert c != null : "Couldn't find a context for a super-call: " + descriptor;

compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java

@@ -75,7 +75,6 @@ public interface LocalLookup {
                     enclosedValueDescriptor = new EnclosedValueDescriptor(fieldName, d, innerValue, type);
                 }
 
-                closure.recordField(fieldName, type);
                 closure.captureVariable(enclosedValueDescriptor);
 
                 return innerValue;
@@ -115,7 +114,6 @@ public interface LocalLookup {
                 StackValue.StackValueWithSimpleReceiver innerValue = StackValue.field(localType, classType, fieldName, false,
                                                                                       StackValue.LOCAL_0, vd);
 
-                closure.recordField(fieldName, localType);
                 closure.captureVariable(new EnclosedValueDescriptor(fieldName, d, innerValue, localType));
 
                 return innerValue;

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineCodegen.kt

@@ -17,18 +17,21 @@
 package org.jetbrains.kotlin.codegen.coroutines
 
 import com.intellij.util.ArrayUtil
-import org.jetbrains.kotlin.backend.common.CONTINUATION_RESUME_METHOD_NAME
 import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.context.ClosureContext
+import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.coroutines.isSuspendLambda
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtDeclarationWithBody
 import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtFunctionLiteral
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
@@ -37,35 +40,38 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.KotlinTypeFactory
-import org.jetbrains.kotlin.types.typeUtil.asTypeProjection
 import org.jetbrains.kotlin.types.typeUtil.makeNullable
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-import org.jetbrains.kotlin.utils.singletonOrEmptyList
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.commons.Method
 
 
-class CoroutineCodegen(
-        state: GenerationState,
+class CoroutineCodegen private constructor(
+        outerExpressionCodegen: ExpressionCodegen,
         element: KtElement,
         private val closureContext: ClosureContext,
-        strategy: FunctionGenerationStrategy,
-        parentCodegen: MemberCodegen<*>,
         classBuilder: ClassBuilder,
-        private val coroutineLambdaDescriptor: FunctionDescriptor
-) : ClosureCodegen(state, element, null, closureContext, null, strategy, parentCodegen, classBuilder) {
-
+        private val originalSuspendFunctionDescriptor: FunctionDescriptor,
+        private val isSuspendLambda: Boolean
+) : ClosureCodegen(
+        outerExpressionCodegen.state,
+        element, null, closureContext, null,
+        FailingFunctionGenerationStrategy,
+        outerExpressionCodegen.parentCodegen, classBuilder
+) {
     private val classDescriptor = closureContext.contextDescriptor
+    private val builtIns = funDescriptor.builtIns
 
     private lateinit var constructorToUseFromInvoke: Method
 
     // protected fun doResume(result, throwable)
     private val doResumeDescriptor =
             SimpleFunctionDescriptorImpl.create(
-                    classDescriptor, Annotations.EMPTY, Name.identifier("doResume"), CallableMemberDescriptor.Kind.DECLARATION,
+                    classDescriptor, Annotations.EMPTY, Name.identifier(DO_RESUME_METHOD_NAME), CallableMemberDescriptor.Kind.DECLARATION,
                     funDescriptor.source
             ).apply doResume@{
                 initialize(
@@ -75,40 +81,39 @@ class CoroutineCodegen(
                         listOf(
                               ValueParameterDescriptorImpl(
                                       this@doResume, null, 0, Annotations.EMPTY, Name.identifier("data"),
-                                      module.builtIns.nullableAnyType,
+                                      builtIns.nullableAnyType,
                                       /* isDefault = */ false, /* isCrossinline = */ false,
                                       /* isNoinline = */ false,
                                       /* varargElementType = */ null, SourceElement.NO_SOURCE
                               ),
                               ValueParameterDescriptorImpl(
                                       this@doResume, null, 1, Annotations.EMPTY, Name.identifier("throwable"),
-                                      module.builtIns.throwable.defaultType.makeNullable(),
+                                      builtIns.throwable.defaultType.makeNullable(),
                                       /* isDefault = */ false, /* isCrossinline = */ false,
                                       /* isNoinline = */ false,
                                       /* varargElementType = */ null, SourceElement.NO_SOURCE
                               )
                         ),
-                        funDescriptor.builtIns.nullableAnyType,
+                        builtIns.nullableAnyType,
                         Modality.FINAL,
-                        Visibilities.PROTECTED
+                        Visibilities.PUBLIC,
+                        mapOf(INITIAL_SUSPEND_DESCRIPTOR_FOR_DO_RESUME to originalSuspendFunctionDescriptor)
                 )
             }
 
     private val createCoroutineDescriptor =
         funDescriptor.createCustomCopy {
-            setName(Name.identifier("create"))
+            setName(Name.identifier(SUSPEND_FUNCTION_CREATE_METHOD_NAME))
             setReturnType(
-                    KotlinTypeFactory.simpleNotNullType(
-                            Annotations.EMPTY,
-                            funDescriptor.builtIns.continuationClassDescriptor,
-                            listOf(funDescriptor.builtIns.unitType.asTypeProjection())
-                    )
+                    funDescriptor.module.getContinuationOfTypeOrAny(builtIns.unitType)
             )
+            // 'create' method should not inherit initial descriptor for suspend function from original descriptor
+            putUserData(INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION, null)
             setVisibility(Visibilities.PUBLIC)
         }
 
     override fun generateClosureBody() {
-        for (parameter in allLambdaParameters()) {
+        for (parameter in allFunctionParameters()) {
             val fieldInfo = parameter.getFieldInfoForCoroutineLambdaParameter()
             v.newField(
                     OtherOrigin(parameter),
@@ -121,9 +126,17 @@ class CoroutineCodegen(
         generateDoResume()
     }
 
+    override fun generateBridges() {
+        if (!isSuspendLambda) return
+        super.generateBridges()
+    }
+
     override fun generateBody() {
         super.generateBody()
 
+        if (!isSuspendLambda) return
+
+        // create() = ...
         functionCodegen.generateMethod(JvmDeclarationOrigin.NO_ORIGIN, createCoroutineDescriptor,
                                        object : FunctionGenerationStrategy.CodegenBased(state) {
                                            override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
@@ -139,7 +152,7 @@ class CoroutineCodegen(
                                            }
                                        })
 
-        if (allLambdaParameters().size <= 1) {
+        if (allFunctionParameters().size <= 1) {
             val delegate = typeMapper.mapSignatureSkipGeneric(createCoroutineDescriptor).asmMethod
 
             val bridgeParameters = (1..delegate.argumentTypes.size - 1).map { AsmTypes.OBJECT_TYPE } + delegate.argumentTypes.last()
@@ -162,30 +175,21 @@ class CoroutineCodegen(
                 v.thisName,
                 createCoroutineDescriptor.name.identifier,
                 Type.getMethodDescriptor(
-                        AsmTypes.CONTINUATION,
+                        CONTINUATION_ASM_TYPE,
                         *parameterTypes.toTypedArray()
                 ),
                 false
         )
         checkcast(Type.getObjectType(v.thisName))
 
-        // .resume(Unit)
-        StackValue.putUnitInstance(this)
-        invokevirtual(
-                AsmTypes.RESTRICTED_COROUTINE_IMPL.internalName,
-                CONTINUATION_RESUME_METHOD_NAME.identifier,
-                Type.getMethodDescriptor(Type.VOID_TYPE, AsmTypes.OBJECT_TYPE),
-                false
-        )
-
-        loadSuspendMarker()
+        // .doResume(Unit)
+        invokeDoResumeWithUnit(v.thisName)
         areturn(AsmTypes.OBJECT_TYPE)
     }
 
-
     override fun generateConstructor(): Method {
         val args = calculateConstructorParameters(typeMapper, closure, asmType)
-        val argTypes = args.map { it.fieldType }.plus(AsmTypes.CONTINUATION).toTypedArray()
+        val argTypes = args.map { it.fieldType }.plus(CONTINUATION_ASM_TYPE).toTypedArray()
 
         val constructor = Method("<init>", Type.VOID_TYPE, argTypes)
         val mv = v.newMethod(
@@ -205,7 +209,7 @@ class CoroutineCodegen(
             iv.iconst(calculateArity())
             iv.load(argTypes.map { it.size }.sum(), AsmTypes.OBJECT_TYPE)
 
-            val superClassConstructorDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, Type.INT_TYPE, AsmTypes.CONTINUATION)
+            val superClassConstructorDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, Type.INT_TYPE, CONTINUATION_ASM_TYPE)
             iv.invokespecial(superClassAsmType.internalName, "<init>", superClassConstructorDescriptor, false)
 
             iv.visitInsn(Opcodes.RETURN)
@@ -217,6 +221,7 @@ class CoroutineCodegen(
     }
 
     private fun generateCreateCoroutineMethod(codegen: ExpressionCodegen) {
+        assert(isSuspendLambda) { "create method should only be generated for suspend lambdas" }
         val classDescriptor = closureContext.contextDescriptor
         val owner = typeMapper.mapClass(classDescriptor)
 
@@ -233,7 +238,7 @@ class CoroutineCodegen(
             }
 
             // load resultContinuation
-            load(allLambdaParameters().map { typeMapper.mapType(it.type).size }.sum() + 1, AsmTypes.OBJECT_TYPE)
+            load(allFunctionParameters().map { typeMapper.mapType(it.type).size }.sum() + 1, AsmTypes.OBJECT_TYPE)
 
             invokespecial(owner.internalName, constructorToUseFromInvoke.name, constructorToUseFromInvoke.descriptor, false)
 
@@ -242,7 +247,7 @@ class CoroutineCodegen(
 
             // Pass lambda parameters to 'invoke' call on newly constructed object
             var index = 1
-            for (parameter in allLambdaParameters()) {
+            for (parameter in allFunctionParameters()) {
                 val fieldInfoForCoroutineLambdaParameter = parameter.getFieldInfoForCoroutineLambdaParameter()
                 load(index, fieldInfoForCoroutineLambdaParameter.fieldType)
                 AsmUtil.genAssignInstanceFieldFromParam(fieldInfoForCoroutineLambdaParameter, index, this, cloneIndex)
@@ -255,21 +260,36 @@ class CoroutineCodegen(
     }
 
     private fun ExpressionCodegen.initializeCoroutineParameters() {
-        for (parameter in allLambdaParameters()) {
-            val mappedType = typeMapper.mapType(parameter.type)
-            val newIndex = myFrameMap.enter(parameter, mappedType)
+        if (!isSuspendLambda && !originalSuspendFunctionDescriptor.isTailrec) return
+        for (parameter in allFunctionParameters()) {
+            val fieldStackValue =
+                    if (isSuspendLambda)
+                        StackValue.field(
+                                parameter.getFieldInfoForCoroutineLambdaParameter(), generateThisOrOuter(context.thisDescriptor, false)
+                        )
+                    else
+                        closureContext.lookupInContext(parameter, null, state, /* ignoreNoOuter = */ false)
 
-            generateLoadField(parameter.getFieldInfoForCoroutineLambdaParameter())
+            val mappedType = typeMapper.mapType(parameter.type)
+            fieldStackValue.put(mappedType, v)
+
+            val newIndex = myFrameMap.enter(parameter, mappedType)
             v.store(newIndex, mappedType)
         }
+
+        // necessary for proper tailrec codegen
+        val actualMethodStartLabel = Label()
+        v.visitLabel(actualMethodStartLabel)
+        context.setMethodStartLabel(actualMethodStartLabel)
+
+        if (isSuspendLambda) {
+            initializeVariablesForDestructuredLambdaParameters(this, originalSuspendFunctionDescriptor.valueParameters)
+        }
     }
 
-    private fun allLambdaParameters() =
-            coroutineLambdaDescriptor.extensionReceiverParameter.singletonOrEmptyList() + coroutineLambdaDescriptor.valueParameters
-
-    private fun ExpressionCodegen.generateLoadField(fieldInfo: FieldInfo) {
-        StackValue.field(fieldInfo, generateThisOrOuter(context.thisDescriptor, false)).put(fieldInfo.fieldType, v)
-    }
+    private fun allFunctionParameters() =
+            listOfNotNull(originalSuspendFunctionDescriptor.extensionReceiverParameter) +
+            originalSuspendFunctionDescriptor.valueParameters.orEmpty()
 
     private fun ParameterDescriptor.getFieldInfoForCoroutineLambdaParameter() =
             createHiddenFieldInfo(type, COROUTINE_LAMBDA_PARAMETER_PREFIX + (this.safeAs<ValueParameterDescriptor>()?.index ?: ""))
@@ -295,33 +315,81 @@ class CoroutineCodegen(
         )
     }
 
+    override fun generateKotlinMetadataAnnotation() {
+        if (isSuspendLambda) {
+            super.generateKotlinMetadataAnnotation()
+        }
+        else {
+            writeKotlinMetadata(v, state, KotlinClassHeader.Kind.SYNTHETIC_CLASS, 0) {
+                // Do not write method metadata for raw coroutine state machines
+            }
+        }
+    }
+
     companion object {
+        fun shouldCreateByLambda(
+                originalSuspendLambdaDescriptor: CallableDescriptor,
+                declaration: KtElement): Boolean {
+            return (declaration is KtFunctionLiteral && originalSuspendLambdaDescriptor.isSuspendLambda)
+        }
 
         @JvmStatic
-        fun create(
+        fun createByLambda(
                 expressionCodegen: ExpressionCodegen,
-                originalCoroutineLambdaDescriptor: FunctionDescriptor,
+                originalSuspendLambdaDescriptor: FunctionDescriptor,
                 declaration: KtElement,
                 classBuilder: ClassBuilder
         ): ClosureCodegen? {
-            if (declaration !is KtFunctionLiteral) return null
-            if (!originalCoroutineLambdaDescriptor.isSuspendLambda) return null
+            if (!shouldCreateByLambda(originalSuspendLambdaDescriptor, declaration)) return null
 
-            val descriptorWithContinuationReturnType = createJvmSuspendFunctionView(originalCoroutineLambdaDescriptor)
-
-            val state = expressionCodegen.state
             return CoroutineCodegen(
-                    state,
+                    expressionCodegen,
                     declaration,
                     expressionCodegen.context.intoCoroutineClosure(
-                            descriptorWithContinuationReturnType, originalCoroutineLambdaDescriptor, expressionCodegen, state.typeMapper
+                            getOrCreateJvmSuspendFunctionView(originalSuspendLambdaDescriptor, expressionCodegen.state.bindingContext),
+                            originalSuspendLambdaDescriptor, expressionCodegen, expressionCodegen.state.typeMapper
                     ),
-                    FunctionGenerationStrategy.FunctionDefault(state, declaration),
-                    expressionCodegen.parentCodegen, classBuilder,
-                    originalCoroutineLambdaDescriptor
+                    classBuilder,
+                    originalSuspendLambdaDescriptor,
+                    isSuspendLambda = true
+            )
+        }
+
+        fun create(
+                expressionCodegen: ExpressionCodegen,
+                originalSuspendDescriptor: FunctionDescriptor,
+                declaration: KtFunction,
+                state: GenerationState
+        ): CoroutineCodegen {
+            val cv = state.factory.newVisitor(
+                    OtherOrigin(declaration, originalSuspendDescriptor),
+                    CodegenBinding.asmTypeForAnonymousClass(state.bindingContext, originalSuspendDescriptor),
+                    declaration.containingFile
+            )
+
+            return CoroutineCodegen(
+                    expressionCodegen, declaration,
+                    expressionCodegen.context.intoClosure(
+                            originalSuspendDescriptor, expressionCodegen, expressionCodegen.state.typeMapper
+                    ),
+                    cv,
+                    originalSuspendDescriptor,
+                    isSuspendLambda = false
             )
         }
     }
 }
 
 private const val COROUTINE_LAMBDA_PARAMETER_PREFIX = "p$"
+
+private object FailingFunctionGenerationStrategy : FunctionGenerationStrategy() {
+    override fun generateBody(
+            mv: MethodVisitor,
+            frameMap: FrameMap,
+            signature: JvmMethodSignature,
+            context: MethodContext,
+            parentCodegen: MemberCodegen<*>
+    ) {
+        error("This functions must not be called")
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineTransformationClassBuilder.kt

@@ -83,10 +83,7 @@ class CoroutineTransformerMethodVisitor(
 
         // Remove unreachable suspension points
         // If we don't do this, then relevant frames will not be analyzed, that is unexpected from point of view of next steps (e.g. variable spilling)
-        DeadCodeEliminationMethodTransformer().transform(classBuilder.thisName, methodNode)
-        suspensionPoints.removeAll {
-            it.suspensionCallBegin.next == null && it.suspensionCallBegin.previous == null
-        }
+        removeUnreachableSuspensionPointsAndExitPoints(methodNode, suspensionPoints)
 
         processUninitializedStores(methodNode)
 
@@ -105,12 +102,12 @@ class CoroutineTransformerMethodVisitor(
             // tableswitch(this.label)
             insertBefore(firstToInsertBefore,
                          insnListOf(
-                                 *withInstructionAdapter { loadSuspendMarker() }.toArray(),
+                                 *withInstructionAdapter { loadCoroutineSuspendedMarker() }.toArray(),
                                  VarInsnNode(Opcodes.ASTORE, suspendMarkerVarIndex),
                                  VarInsnNode(Opcodes.ALOAD, 0),
                                  FieldInsnNode(
                                          Opcodes.GETFIELD,
-                                         AsmTypes.RESTRICTED_COROUTINE_IMPL.internalName,
+                                         COROUTINE_IMPL_ASM_TYPE.internalName,
                                          COROUTINE_LABEL_FIELD_NAME, Type.INT_TYPE.descriptor
                                  ),
                                  TableSwitchInsnNode(0,
@@ -136,6 +133,22 @@ class CoroutineTransformerMethodVisitor(
 
     }
 
+    private fun removeUnreachableSuspensionPointsAndExitPoints(methodNode: MethodNode, suspensionPoints: MutableList<SuspensionPoint>) {
+        val dceResult = DeadCodeEliminationMethodTransformer().transformWithResult(classBuilder.thisName, methodNode)
+
+        // If the suspension call begin is alive and suspension call end is dead
+        // (e.g., an inlined suspend function call ends with throwing a exception -- see KT-15017),
+        // this is an exit point for the corresponding coroutine.
+        // It doesn't introduce an additional state to the corresponding coroutine's FSM.
+        suspensionPoints.forEach {
+            if (dceResult.isAlive(it.suspensionCallBegin) && dceResult.isRemoved(it.suspensionCallEnd)) {
+                methodNode.instructions.remove(it.suspensionCallBegin)
+            }
+        }
+
+        suspensionPoints.removeAll { dceResult.isRemoved(it.suspensionCallBegin) || dceResult.isRemoved(it.suspensionCallEnd) }
+    }
+
     private fun collectSuspensionPoints(methodNode: MethodNode): MutableList<SuspensionPoint> {
         val suspensionPoints = mutableListOf<SuspensionPoint>()
         val beforeSuspensionPointMarkerStack = Stack<MethodInsnNode>()
@@ -149,12 +162,7 @@ class CoroutineTransformerMethodVisitor(
                 }
 
                 AFTER_SUSPENSION_POINT_MARKER_NAME -> {
-                    suspensionPoints.add(
-                            SuspensionPoint(
-                                suspensionCallBegin = beforeSuspensionPointMarkerStack.pop(),
-                                suspensionCallEnd = methodInsn
-                            )
-                    )
+                    suspensionPoints.add(SuspensionPoint(beforeSuspensionPointMarkerStack.pop(), methodInsn))
                 }
             }
         }
@@ -186,8 +194,8 @@ class CoroutineTransformerMethodVisitor(
 
         for (suspension in suspensionPoints) {
             val suspensionCallBegin = suspension.suspensionCallBegin
-            val suspensionCallEnd = suspension.suspensionCallEnd
-            assert(frames[suspensionCallEnd.next.index()]?.stackSize == 1) {
+
+            assert(frames[suspension.suspensionCallEnd.next.index()]?.stackSize == 1) {
                 "Stack should be spilled before suspension call"
             }
 
@@ -221,6 +229,18 @@ class CoroutineTransformerMethodVisitor(
                             }
 
             for ((index, basicValue) in variablesToSpill) {
+                if (basicValue === StrictBasicValue.NULL_VALUE) {
+                    postponedActions.add {
+                        with(instructions) {
+                            insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
+                                aconst(null)
+                                store(index, AsmTypes.OBJECT_TYPE)
+                            })
+                        }
+                    }
+                    continue
+                }
+
                 val type = basicValue.type
                 val normalizedType = type.normalize()
 
@@ -274,7 +294,7 @@ class CoroutineTransformerMethodVisitor(
         get() {
             assert(suspensionCallEnd.next is LabelNode) {
                 "Next instruction after ${this} should be a label, but " +
-                "${suspensionCallEnd.next.javaClass}/${suspensionCallEnd.next.opcode} was found"
+                "${suspensionCallEnd.next::class.java}/${suspensionCallEnd.next.opcode} was found"
             }
 
             return suspensionCallEnd.next as LabelNode
@@ -295,7 +315,7 @@ class CoroutineTransformerMethodVisitor(
                                  VarInsnNode(Opcodes.ALOAD, 0),
                                  *withInstructionAdapter { iconst(id) }.toArray(),
                                  FieldInsnNode(
-                                         Opcodes.PUTFIELD, AsmTypes.RESTRICTED_COROUTINE_IMPL.internalName, COROUTINE_LABEL_FIELD_NAME,
+                                         Opcodes.PUTFIELD, COROUTINE_IMPL_ASM_TYPE.internalName, COROUTINE_LABEL_FIELD_NAME,
                                          Type.INT_TYPE.descriptor
                                  )
                          )
@@ -401,7 +421,7 @@ private fun InstructionAdapter.generateResumeWithExceptionCheck() {
 
 private fun Type.fieldNameForVar(index: Int) = descriptor.first() + "$" + index
 
-private fun withInstructionAdapter(block: InstructionAdapter.() -> Unit): InsnList {
+inline fun withInstructionAdapter(block: InstructionAdapter.() -> Unit): InsnList {
     val tmpMethodNode = MethodNode()
 
     InstructionAdapter(tmpMethodNode).apply(block)
@@ -430,9 +450,3 @@ private class SuspensionPoint(
 ) {
     lateinit var tryCatchBlocksContinuationLabel: LabelNode
 }
-
-private val DEFAULT_VALUE_OPCODES =
-        setOf(Opcodes.ICONST_0, Opcodes.LCONST_0, Opcodes.FCONST_0, Opcodes.DCONST_0, Opcodes.ACONST_NULL,
-              // GETSTATIC Unit.Instance
-              Opcodes.GETSTATIC)
-

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/SuspendFunctionGenerationStrategy.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2016 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.codegen.coroutines
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.FunctionGenerationStrategy
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
+import org.jetbrains.org.objectweb.asm.Type
+
+class SuspendFunctionGenerationStrategy(
+        state: GenerationState,
+        private val originalSuspendDescriptor: FunctionDescriptor,
+        private val declaration: KtFunction
+) : FunctionGenerationStrategy.CodegenBased(state) {
+
+    override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
+        if (!originalSuspendDescriptor.containsNonTailSuspensionCalls(state.bindingContext)) {
+            return codegen.returnExpression(declaration.bodyExpression)
+        }
+
+        val coroutineCodegen = CoroutineCodegen.create(codegen, originalSuspendDescriptor, declaration, state)
+        coroutineCodegen.generate()
+
+        codegen.putClosureInstanceOnStack(coroutineCodegen, null).put(Type.getObjectType(coroutineCodegen.className), codegen.v)
+
+        with(codegen.v) {
+            invokeDoResumeWithUnit(coroutineCodegen.v.thisName)
+
+            codegen.markLineNumber(declaration, true)
+
+            areturn(AsmTypes.OBJECT_TYPE)
+        }
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/coroutineCodegenUtil.kt

@@ -17,27 +17,31 @@
 package org.jetbrains.kotlin.codegen.coroutines
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.backend.common.SUSPEND_WITH_CURRENT_CONTINUATION_NAME
-import org.jetbrains.kotlin.backend.common.getBuiltInSuspendWithCurrentContinuation
+import org.jetbrains.kotlin.backend.common.COROUTINES_INTRINSICS_PACKAGE_FQ_NAME
+import org.jetbrains.kotlin.backend.common.COROUTINE_SUSPENDED_NAME
+import org.jetbrains.kotlin.backend.common.isBuiltInSuspendCoroutineOrReturn
 import org.jetbrains.kotlin.builtins.isBuiltinFunctionalType
+import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
+import org.jetbrains.kotlin.codegen.topLevelClassAsmType
+import org.jetbrains.kotlin.codegen.topLevelClassInternalName
+import org.jetbrains.kotlin.coroutines.isSuspendLambda
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
-import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtPsiFactory
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
-import org.jetbrains.kotlin.resolve.DescriptorEquivalenceForOverrides
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.model.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.KotlinTypeFactory
 import org.jetbrains.kotlin.types.TypeConstructorSubstitution
 import org.jetbrains.kotlin.types.typeUtil.asTypeProjection
@@ -57,11 +61,35 @@ const val AFTER_SUSPENSION_POINT_MARKER_NAME = "afterSuspensionPoint"
 const val ACTUAL_COROUTINE_START_MARKER_NAME = "actualCoroutineStart"
 
 const val COROUTINE_LABEL_FIELD_NAME = "label"
+const val SUSPEND_FUNCTION_CREATE_METHOD_NAME = "create"
+const val DO_RESUME_METHOD_NAME = "doResume"
+
+@JvmField
+val COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME =
+        DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME.child(Name.identifier("jvm")).child(Name.identifier("internal"))
+
+@JvmField
+val CONTINUATION_ASM_TYPE = DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME.topLevelClassAsmType()
+
+@JvmField
+val COROUTINE_IMPL_ASM_TYPE = COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME.child(Name.identifier("CoroutineImpl")).topLevelClassAsmType()
+
+private val COROUTINES_INTRINSICS_FILE_FACADE_INTERNAL_NAME =
+        COROUTINES_INTRINSICS_PACKAGE_FQ_NAME.child(Name.identifier("IntrinsicsKt")).topLevelClassAsmType()
+
+private val INTERNAL_COROUTINE_INTRINSICS_OWNER_INTERNAL_NAME =
+        COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME.child(Name.identifier("CoroutineIntrinsics")).topLevelClassInternalName()
+
+private val NORMALIZE_CONTINUATION_METHOD_NAME = "normalizeContinuation"
 
 data class ResolvedCallWithRealDescriptor(val resolvedCall: ResolvedCall<*>, val fakeContinuationExpression: KtExpression)
 
 @JvmField
 val INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION = object : FunctionDescriptor.UserDataKey<FunctionDescriptor> {}
+
+@JvmField
+val INITIAL_SUSPEND_DESCRIPTOR_FOR_DO_RESUME = object : FunctionDescriptor.UserDataKey<FunctionDescriptor> {}
+
 // Resolved calls to suspension function contain descriptors as they visible within coroutines:
 // E.g. `fun <V> await(f: CompletableFuture<V>): V` instead of `fun <V> await(f: CompletableFuture<V>, machine: Continuation<V>): Unit`
 // See `createJvmSuspendFunctionView` and it's usages for clarification
@@ -85,12 +113,18 @@ fun ResolvedCall<*>.replaceSuspensionFunctionWithRealDescriptor(
                 )
         )
     }
-    val function = candidateDescriptor as? SimpleFunctionDescriptor ?: return null
+    val function = candidateDescriptor as? FunctionDescriptor ?: return null
     if (!function.isSuspend || function.getUserData(INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION) != null) return null
 
     val newCandidateDescriptor =
-            bindingContext.get(CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, function)
-            ?: createJvmSuspendFunctionView(function)
+            when (function) {
+                is FunctionImportedFromObject ->
+                    getOrCreateJvmSuspendFunctionView(function.callableFromObject, bindingContext).asImportedFromObject()
+                is SimpleFunctionDescriptor ->
+                    getOrCreateJvmSuspendFunctionView(function, bindingContext)
+                else ->
+                    throw AssertionError("Unexpected suspend function descriptor: $function")
+            }
 
     val newCall = ResolvedCallImpl(
             call,
@@ -120,13 +154,36 @@ fun ResolvedCall<*>.replaceSuspensionFunctionWithRealDescriptor(
     return ResolvedCallWithRealDescriptor(newCall, thisExpression)
 }
 
-fun ResolvedCall<*>.isSuspensionPoint(bindingContext: BindingContext) =
-        bindingContext[BindingContext.ENCLOSING_SUSPEND_LAMBDA_FOR_SUSPENSION_POINT, call] != null
+fun ResolvedCall<*>.isSuspensionPointInStateMachine(bindingContext: BindingContext): Boolean {
+    if (resultingDescriptor.safeAs<FunctionDescriptor>()?.isSuspend != true) return false
+    val enclosingSuspendFunction = bindingContext[BindingContext.ENCLOSING_SUSPEND_FUNCTION_FOR_SUSPEND_FUNCTION_CALL, call] ?: return false
+
+    return enclosingSuspendFunction.isStateMachineNeeded(bindingContext)
+}
+
+fun FunctionDescriptor.isStateMachineNeeded(bindingContext: BindingContext) =
+        isSuspendLambda || containsNonTailSuspensionCalls(bindingContext)
+
+fun FunctionDescriptor.containsNonTailSuspensionCalls(bindingContext: BindingContext) =
+        bindingContext[BindingContext.CONTAINS_NON_TAIL_SUSPEND_CALLS, original] == true
+
+fun CallableDescriptor.isSuspendFunctionNotSuspensionView(): Boolean {
+    if (this !is FunctionDescriptor) return false
+    return this.isSuspend && this.getUserData(INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION) == null
+}
 
 // Suspend functions have irregular signatures on JVM, containing an additional last parameter with type `Continuation<return-type>`,
 // and return type Any?
 // This function returns a function descriptor reflecting how the suspend function looks from point of view of JVM
-fun <D : FunctionDescriptor> createJvmSuspendFunctionView(function: D): D {
+@JvmOverloads
+fun <D : FunctionDescriptor> getOrCreateJvmSuspendFunctionView(function: D, bindingContext: BindingContext? = null): D {
+    assert(function.isSuspend) {
+        "Suspended function is expected, but $function was found"
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    bindingContext?.get(CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, function)?.let { return it as D }
+
     val continuationParameter = ValueParameterDescriptorImpl(
             function, null, function.valueParameters.size, Annotations.EMPTY, Name.identifier("\$continuation"),
             // Add j.l.Object to invoke(), because that is the type of parameters we have in FunctionN+1
@@ -170,27 +227,26 @@ fun <D : FunctionDescriptor> D.createCustomCopy(
 }
 
 private fun FunctionDescriptor.getContinuationParameterTypeOfSuspendFunction() =
-        KotlinTypeFactory.simpleType(
-                builtIns.continuationClassDescriptor.defaultType,
-                arguments = listOf(returnType!!.asTypeProjection())
-        )
+        module.getContinuationOfTypeOrAny(returnType!!)
 
-fun FunctionDescriptor.isBuiltInSuspendWithCurrentContinuation(): Boolean {
-    if (name != SUSPEND_WITH_CURRENT_CONTINUATION_NAME) return false
+fun ModuleDescriptor.getContinuationOfTypeOrAny(kotlinType: KotlinType) =
+        module.findContinuationClassDescriptorOrNull(NoLookupLocation.FROM_BACKEND)?.defaultType?.let {
+            KotlinTypeFactory.simpleType(
+                    it,
+                    arguments = listOf(kotlinType.asTypeProjection())
+            )
+        } ?: module.builtIns.nullableAnyType
 
-    val originalDeclaration = getBuiltInSuspendWithCurrentContinuation() ?: return false
 
-    return DescriptorEquivalenceForOverrides.areEquivalent(
-            originalDeclaration, this.getUserData(INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION)
-    )
-}
+fun FunctionDescriptor.isBuiltInSuspendCoroutineOrReturnInJvm() =
+        getUserData(INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION)?.isBuiltInSuspendCoroutineOrReturn() == true
 
-fun createMethodNodeForSuspendWithCurrentContinuation(
+fun createMethodNodeForSuspendCoroutineOrReturn(
         functionDescriptor: FunctionDescriptor,
         typeMapper: KotlinTypeMapper
 ): MethodNode {
-    assert(functionDescriptor.isBuiltInSuspendWithCurrentContinuation()) {
-        "functionDescriptor must be kotlin.coroutines.suspendWithCurrentContinuation"
+    assert(functionDescriptor.isBuiltInSuspendCoroutineOrReturnInJvm()) {
+        "functionDescriptor must be kotlin.coroutines.intrinsics.suspendOrReturn"
     }
 
     val node =
@@ -203,6 +259,15 @@ fun createMethodNodeForSuspendWithCurrentContinuation(
 
     node.visitVarInsn(Opcodes.ALOAD, 0)
     node.visitVarInsn(Opcodes.ALOAD, 1)
+
+    node.visitMethodInsn(
+            Opcodes.INVOKESTATIC,
+            INTERNAL_COROUTINE_INTRINSICS_OWNER_INTERNAL_NAME,
+            NORMALIZE_CONTINUATION_METHOD_NAME,
+            Type.getMethodDescriptor(CONTINUATION_ASM_TYPE, CONTINUATION_ASM_TYPE),
+            false
+    )
+
     node.visitMethodInsn(
             Opcodes.INVOKEINTERFACE,
             typeMapper.mapType(functionDescriptor.valueParameters[0]).internalName,
@@ -216,17 +281,29 @@ fun createMethodNodeForSuspendWithCurrentContinuation(
     return node
 }
 
-fun CallableDescriptor?.unwrapInitialDescriptorForSuspendFunction() =
-        (this as? SimpleFunctionDescriptor)?.getUserData(INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION) ?: this
+@Suppress("UNCHECKED_CAST")
+fun <D : CallableDescriptor?> D.unwrapInitialDescriptorForSuspendFunction(): D =
+        this.safeAs<SimpleFunctionDescriptor>()?.getUserData(INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION) as D ?: this
 
-fun InstructionAdapter.loadSuspendMarker() {
-    getstatic(
-            AsmTypes.COROUTINES_INTRINSICS.internalName, JvmAbi.INSTANCE_FIELD, AsmTypes.COROUTINES_INTRINSICS.descriptor
-    )
-    invokevirtual(
-            AsmTypes.COROUTINES_INTRINSICS.internalName,
-            "getSUSPENDED",
+fun InstructionAdapter.loadCoroutineSuspendedMarker() {
+    invokestatic(
+            COROUTINES_INTRINSICS_FILE_FACADE_INTERNAL_NAME.internalName,
+            "get$COROUTINE_SUSPENDED_NAME",
             Type.getMethodDescriptor(AsmTypes.OBJECT_TYPE),
             false
     )
 }
+
+fun InstructionAdapter.invokeDoResumeWithUnit(thisName: String) {
+    // .doResume(Unit, null)
+    StackValue.putUnitInstance(this)
+
+    aconst(null)
+
+    invokevirtual(
+            thisName,
+            DO_RESUME_METHOD_NAME,
+            Type.getMethodDescriptor(AsmTypes.OBJECT_TYPE, AsmTypes.OBJECT_TYPE, AsmTypes.JAVA_THROWABLE_TYPE),
+            false
+    )
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/processUninitializedStores.kt

@@ -160,7 +160,7 @@ private class UninitializedNewValueMarkerInterpreter : OptimizationBasicInterpre
     val uninitializedValuesToCopyUsages = hashMapOf<AbstractInsnNode, MutableSet<AbstractInsnNode>>()
     override fun newOperation(insn: AbstractInsnNode): BasicValue? {
         if (insn.opcode == Opcodes.NEW) {
-            uninitializedValuesToCopyUsages[insn] = mutableSetOf()
+            uninitializedValuesToCopyUsages.getOrPut(insn) { mutableSetOf() }
             return UninitializedNewValue(insn as TypeInsnNode, insn.desc)
         }
         return super.newOperation(insn)

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/refinedIntTypesAnalysis.kt

@@ -217,7 +217,7 @@ private class VarExpectedTypeFrame(maxLocals: Int) : VarFrame<VarExpectedTypeFra
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
-        if (other?.javaClass != javaClass) return false
+        if (other == null || other::class.java != this::class.java) return false
 
         other as VarExpectedTypeFrame
 

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.codegen.AsmUtil;
 import org.jetbrains.kotlin.codegen.ClassBuilder;
 import org.jetbrains.kotlin.codegen.FieldInfo;
 import org.jetbrains.kotlin.codegen.StackValue;
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
+import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenUtilKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
@@ -66,9 +66,8 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
         createClassReader().accept(new ClassVisitor(InlineCodegenUtil.API, classBuilder.getVisitor()) {
             @Override
             public void visit(int version, int access, @NotNull String name, String signature, String superName, String[] interfaces) {
-                InlineCodegenUtil.assertVersionNotGreaterThanGeneratedOne(version, name, inliningContext.state);
                 classBuilder.defineClass(null, version, access, name, signature, superName, interfaces);
-                if(AsmTypes.COROUTINE_IMPL.getInternalName().equals(superName)) {
+                if(CoroutineCodegenUtilKt.COROUTINE_IMPL_ASM_TYPE.getInternalName().equals(superName)) {
                     inliningContext.setContinuation(true);
                 }
             }
@@ -141,12 +140,12 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
         List<CapturedParamInfo> additionalFakeParams =
                 extractParametersMappingAndPatchConstructor(constructor, allCapturedParamBuilder, constructorParamBuilder,
                                                             transformationInfo, parentRemapper);
-        List<MethodVisitor> deferringMethods = new ArrayList<MethodVisitor>();
+        List<DeferredMethodVisitor> deferringMethods = new ArrayList<DeferredMethodVisitor>();
 
         generateConstructorAndFields(classBuilder, allCapturedParamBuilder, constructorParamBuilder, parentRemapper, additionalFakeParams);
 
         for (MethodNode next : methodsToTransform) {
-            MethodVisitor deferringVisitor = newMethod(classBuilder, next);
+            DeferredMethodVisitor deferringVisitor = newMethod(classBuilder, next);
             InlineResult funResult =
                     inlineMethodAndUpdateGlobalResult(parentRemapper, deferringVisitor, next, allCapturedParamBuilder, false);
 
@@ -161,7 +160,8 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
             deferringMethods.add(deferringVisitor);
         }
 
-        for (MethodVisitor method : deferringMethods) {
+        for (DeferredMethodVisitor method : deferringMethods) {
+            InlineCodegenUtil.removeFinallyMarkers(method.getIntermediate());
             method.visitEnd();
         }
 
@@ -270,7 +270,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
         //TODO for inline method make public class
         transformationInfo.setNewConstructorDescriptor(constructorDescriptor);
         MethodVisitor constructorVisitor = classBuilder.newMethod(
-                NO_ORIGIN, AsmUtil.NO_FLAG_PACKAGE_PRIVATE, "<init>", constructorDescriptor, null, ArrayUtil.EMPTY_STRING_ARRAY
+                NO_ORIGIN, constructor.access, "<init>", constructorDescriptor, null, ArrayUtil.EMPTY_STRING_ARRAY
         );
 
         final Label newBodyStartLabel = new Label();
@@ -311,8 +311,9 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
         }
 
         MethodNode intermediateMethodNode =
-                new MethodNode(AsmUtil.NO_FLAG_PACKAGE_PRIVATE, "<init>", constructorDescriptor, null, ArrayUtil.EMPTY_STRING_ARRAY);
+                new MethodNode(constructor.access, "<init>", constructorDescriptor, null, ArrayUtil.EMPTY_STRING_ARRAY);
         inlineMethodAndUpdateGlobalResult(parentRemapper, intermediateMethodNode, constructor, constructorInlineBuilder, true);
+        InlineCodegenUtil.removeFinallyMarkers(intermediateMethodNode);
 
         AbstractInsnNode first = intermediateMethodNode.instructions.getFirst();
         final Label oldStartLabel = first instanceof LabelNode ? ((LabelNode) first).getLabel() : null;

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.builtins.BuiltInsPackageFragment;
 import org.jetbrains.kotlin.codegen.*;
 import org.jetbrains.kotlin.codegen.context.*;
 import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenUtilKt;
+import org.jetbrains.kotlin.codegen.coroutines.SuspendFunctionGenerationStrategy;
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicArrayConstructorsKt;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
@@ -37,6 +38,7 @@ import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
@@ -201,7 +203,7 @@ public class InlineCodegen extends CallGenerator {
         MethodNode node = nodeAndSmap != null ? nodeAndSmap.getNode() : null;
         throw new CompilationException(
                 "Couldn't inline method call '" + functionDescriptor.getName() + "' into\n" +
-                contextDescriptor + "\n" +
+                DescriptorRenderer.DEBUG_TEXT.render(contextDescriptor) + "\n" +
                 (element != null ? element.getText() : "<no source>") +
                 (generateNodeText ? ("\nCause: " + InlineCodegenUtil.getNodeText(node)) : ""),
                 e, callElement
@@ -238,19 +240,19 @@ public class InlineCodegen extends CallGenerator {
             assert resolvedCall != null : "Resolved call for " + functionDescriptor + " should be not null";
             Map<TypeParameterDescriptor, KotlinType> arguments = resolvedCall.getTypeArguments();
             assert arguments.size() == 1 : "Resolved call for " + functionDescriptor + " should have 1 type argument";
-            KotlinType type = arguments.values().iterator().next();
+
             MethodNode node =
                     InlineCodegenUtil.createSpecialEnumMethodBody(
                             codegen,
                             functionDescriptor.getName().asString(),
-                            type,
+                            arguments.keySet().iterator().next().getDefaultType(),
                             codegen.getState().getTypeMapper()
                     );
             return new SMAPAndMethodNode(node, SMAPParser.parseOrCreateDefault(null, null, "fake", -1, -1));
         }
-        else if (CoroutineCodegenUtilKt.isBuiltInSuspendWithCurrentContinuation(functionDescriptor)) {
+        else if (CoroutineCodegenUtilKt.isBuiltInSuspendCoroutineOrReturnInJvm(functionDescriptor)) {
             return new SMAPAndMethodNode(
-                    CoroutineCodegenUtilKt.createMethodNodeForSuspendWithCurrentContinuation(
+                    CoroutineCodegenUtilKt.createMethodNodeForSuspendCoroutineOrReturn(
                             functionDescriptor, codegen.getState().getTypeMapper()
                     ),
                     SMAPParser.parseOrCreateDefault(null, null, "fake", -1, -1)
@@ -320,7 +322,7 @@ public class InlineCodegen extends CallGenerator {
                 }
             });
 
-            return InlineCodegenUtil.getMethodNode(bytes, asmMethod.getName(), asmMethod.getDescriptor(), classId, state);
+            return InlineCodegenUtil.getMethodNode(bytes, asmMethod.getName(), asmMethod.getDescriptor(), classId);
         }
 
         assert callableDescriptor instanceof DeserializedCallableMemberDescriptor : "Not a deserialized function or proper: " + callableDescriptor;
@@ -347,7 +349,7 @@ public class InlineCodegen extends CallGenerator {
         });
 
 
-        return InlineCodegenUtil.getMethodNode(bytes, asmMethod.getName(), asmMethod.getDescriptor(), containerId, state);
+        return InlineCodegenUtil.getMethodNode(bytes, asmMethod.getName(), asmMethod.getDescriptor(), containerId);
     }
 
     @NotNull
@@ -465,7 +467,9 @@ public class InlineCodegen extends CallGenerator {
                 adapter, infos, ((StackValue.Local) remapper.remap(parameters.getArgsSizeOnStack() + 1).value).index
         );
         removeStaticInitializationTrigger(adapter);
-        removeFinallyMarkers(adapter);
+        if (!InlineCodegenUtil.isFinallyMarkerRequired(codegen.getContext())) {
+            InlineCodegenUtil.removeFinallyMarkers(adapter);
+        }
 
         adapter.accept(new MethodBodyVisitor(codegen.v));
 
@@ -479,9 +483,9 @@ public class InlineCodegen extends CallGenerator {
     @NotNull
     private static CallableMemberDescriptor getLabelOwnerDescriptor(@NotNull MethodContext context) {
         if (context.getParentContext() instanceof ClosureContext &&
-            ((ClosureContext) context.getParentContext()).getCoroutineDescriptor() != null) {
+            ((ClosureContext) context.getParentContext()).getOriginalSuspendLambdaDescriptor() != null) {
             //noinspection ConstantConditions
-            return ((ClosureContext) context.getParentContext()).getCoroutineDescriptor();
+            return ((ClosureContext) context.getParentContext()).getOriginalSuspendLambdaDescriptor();
         }
 
         return context.getContextDescriptor();
@@ -601,6 +605,14 @@ public class InlineCodegen extends CallGenerator {
         else if (expression instanceof KtFunctionLiteral) {
             strategy = new ClosureGenerationStrategy(state, (KtDeclarationWithBody) expression);
         }
+        else if (descriptor.isSuspend() && expression instanceof KtFunction) {
+            strategy =
+                    new SuspendFunctionGenerationStrategy(
+                            state,
+                            CoroutineCodegenUtilKt.<FunctionDescriptor>unwrapInitialDescriptorForSuspendFunction(descriptor),
+                            (KtFunction) expression
+                    );
+        }
         else {
             strategy = new FunctionGenerationStrategy.FunctionDefault(state, (KtDeclarationWithBody) expression);
         }
@@ -1015,25 +1027,6 @@ public class InlineCodegen extends CallGenerator {
         //processor.substituteLocalVarTable(intoNode);
     }
 
-    private void removeFinallyMarkers(@NotNull MethodNode intoNode) {
-        if (InlineCodegenUtil.isFinallyMarkerRequired(codegen.getContext())) return;
-
-        InsnList instructions = intoNode.instructions;
-        AbstractInsnNode curInstr = instructions.getFirst();
-        while (curInstr != null) {
-            if (InlineCodegenUtil.isFinallyMarker(curInstr)) {
-                AbstractInsnNode marker = curInstr;
-                //just to assert
-                getConstant(marker.getPrevious());
-                curInstr = curInstr.getNext();
-                instructions.remove(marker.getPrevious());
-                instructions.remove(marker);
-                continue;
-            }
-            curInstr = curInstr.getNext();
-        }
-    }
-
     @NotNull
     public static SourceMapper createNestedSourceMapper(@NotNull SMAPAndMethodNode nodeAndSmap, @NotNull SourceMapper parent) {
         return new NestedSourceMapper(parent, nodeAndSmap.getSortedRanges(), nodeAndSmap.getClassSMAP().getSourceInfo());

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java

@@ -23,6 +23,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.codegen.AsmUtil;
 import org.jetbrains.kotlin.codegen.ExpressionCodegen;
 import org.jetbrains.kotlin.codegen.MemberCodegen;
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
@@ -38,7 +39,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.fileClasses.FileClasses;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.JvmAbi;
-import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinder;
+import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
@@ -51,6 +52,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions;
 import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.tree.*;
+import org.jetbrains.org.objectweb.asm.util.Printer;
 import org.jetbrains.org.objectweb.asm.util.Textifier;
 import org.jetbrains.org.objectweb.asm.util.TraceMethodVisitor;
 
@@ -60,6 +62,9 @@ import java.io.StringWriter;
 import java.util.List;
 import java.util.ListIterator;
 
+import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.ENUM_TYPE;
+import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.JAVA_CLASS_TYPE;
+
 public class InlineCodegenUtil {
     public static final boolean GENERATE_SMAP = true;
     public static final int API = Opcodes.ASM5;
@@ -77,7 +82,9 @@ public class InlineCodegenUtil {
     private static final String INLINE_MARKER_AFTER_METHOD_NAME = "afterInlineCall";
     private static final String INLINE_MARKER_FINALLY_START = "finallyStart";
     private static final String INLINE_MARKER_FINALLY_END = "finallyEnd";
+    public static final String SPECIAL_TRANSFORMATION_NAME = "$special";
     public static final String INLINE_TRANSFORMATION_SUFFIX = "$inlined";
+    public static final String INLINE_CALL_TRANSFORMATION_SUFFIX = "$" + INLINE_TRANSFORMATION_SUFFIX;
     public static final String INLINE_FUN_THIS_0_SUFFIX = "$inline_fun";
     public static final String INLINE_FUN_VAR_SUFFIX = "$iv";
 
@@ -86,8 +93,7 @@ public class InlineCodegenUtil {
             byte[] classData,
             final String methodName,
             final String methodDescriptor,
-            ClassId classId,
-            final @NotNull GenerationState state
+            ClassId classId
     ) {
         ClassReader cr = new ClassReader(classData);
         final MethodNode[] node = new MethodNode[1];
@@ -97,10 +103,6 @@ public class InlineCodegenUtil {
         lines[1] = Integer.MIN_VALUE;
         //noinspection PointlessBitwiseExpression
         cr.accept(new ClassVisitor(API) {
-            @Override
-            public void visit(int version, int access, @NotNull String name, String signature, String superName, String[] interfaces) {
-                assertVersionNotGreaterThanGeneratedOne(version, name, state);
-            }
 
             @Override
             public void visitSource(String source, String debug) {
@@ -145,16 +147,6 @@ public class InlineCodegenUtil {
         return new SMAPAndMethodNode(node[0], smap);
     }
 
-    public static void assertVersionNotGreaterThanGeneratedOne(int version, String internalName, @NotNull GenerationState state) {
-        // TODO: report a proper diagnostic
-        if (version > state.getClassFileVersion() && !"true".equals(System.getProperty("kotlin.skip.bytecode.version.check"))) {
-            throw new UnsupportedOperationException(
-                    "Cannot inline bytecode of class " + internalName + " which has version " + version + ". " +
-                    "This compiler can only inline Java 1.6 bytecode (version " + Opcodes.V1_6 + ")"
-            );
-        }
-    }
-
     public static void initDefaultSourceMappingIfNeeded(
             @NotNull CodegenContext context, @NotNull MemberCodegen codegen, @NotNull GenerationState state
     ) {
@@ -173,7 +165,7 @@ public class InlineCodegenUtil {
 
     @Nullable
     public static VirtualFile findVirtualFile(@NotNull GenerationState state, @NotNull ClassId classId) {
-        return JvmVirtualFileFinder.SERVICE.getInstance(state.getProject()).findVirtualFileWithHeader(classId);
+        return VirtualFileFinder.SERVICE.getInstance(state.getProject()).findVirtualFileWithHeader(classId);
     }
 
     @Nullable
@@ -399,6 +391,11 @@ public class InlineCodegenUtil {
         return sw.toString().trim();
     }
 
+    @NotNull
+    public static String getInsnOpcodeText(@Nullable AbstractInsnNode node) {
+        return node == null ? "null" : Printer.OPCODES[node.getOpcode()];
+    }
+
     @NotNull
     /* package */ static ClassReader buildClassReaderByInternalName(@NotNull GenerationState state, @NotNull String internalName) {
         //try to find just compiled classes then in dependencies
@@ -460,6 +457,23 @@ public class InlineCodegenUtil {
         }
     }
 
+    public static void removeFinallyMarkers(@NotNull MethodNode intoNode) {
+        InsnList instructions = intoNode.instructions;
+        AbstractInsnNode curInstr = instructions.getFirst();
+        while (curInstr != null) {
+            if (isFinallyMarker(curInstr)) {
+                AbstractInsnNode marker = curInstr;
+                //just to assert
+                getConstant(marker.getPrevious());
+                curInstr = curInstr.getNext();
+                instructions.remove(marker.getPrevious());
+                instructions.remove(marker);
+                continue;
+            }
+            curInstr = curInstr.getNext();
+        }
+    }
+
     public static void addInlineMarker(@NotNull InstructionAdapter v, boolean isStartNotEnd) {
         v.visitMethodInsn(
                 Opcodes.INVOKESTATIC, INLINE_MARKER_CLASS_NAME,
@@ -530,7 +544,7 @@ public class InlineCodegenUtil {
         if (!(containingDeclaration instanceof PackageFragmentDescriptor)) {
             return false;
         }
-        if (!containingDeclaration.getName().equals(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME)) {
+        if (!((PackageFragmentDescriptor) containingDeclaration).getFqName().equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME)) {
             return false;
         }
         if (functionDescriptor.getTypeParameters().size() != 1) {
@@ -548,23 +562,30 @@ public class InlineCodegenUtil {
             @NotNull KotlinType type,
             @NotNull KotlinTypeMapper typeMapper
     ) {
-        boolean isEnumValues = "enumValues".equals(name);
+        boolean isValueOf = "enumValueOf".equals(name);
         Type invokeType = typeMapper.mapType(type);
-        String desc = getSpecialEnumFunDescriptor(invokeType, isEnumValues);
-
+        String desc = getSpecialEnumFunDescriptor(invokeType, isValueOf);
         MethodNode node = new MethodNode(API, Opcodes.ACC_STATIC, "fake", desc, null, null);
-        if (!isEnumValues) {
-            node.visitVarInsn(Opcodes.ALOAD, 0);
-        }
         codegen.putReifiedOperationMarkerIfTypeIsReifiedParameter(type, ReifiedTypeInliner.OperationKind.ENUM_REIFIED, new InstructionAdapter(node));
-        node.visitMethodInsn(Opcodes.INVOKESTATIC, invokeType.getInternalName(), isEnumValues ? "values" : "valueOf", desc, false);
+        if (isValueOf) {
+            node.visitInsn(Opcodes.ACONST_NULL);
+            node.visitVarInsn(Opcodes.ALOAD, 0);
+
+            node.visitMethodInsn(Opcodes.INVOKESTATIC, ENUM_TYPE.getInternalName(), "valueOf",
+                                 Type.getMethodDescriptor(ENUM_TYPE, JAVA_CLASS_TYPE, AsmTypes.JAVA_STRING_TYPE), false);
+        }
+        else {
+            node.visitInsn(Opcodes.ICONST_0);
+            node.visitTypeInsn(Opcodes.ANEWARRAY, ENUM_TYPE.getInternalName());
+        }
         node.visitInsn(Opcodes.ARETURN);
-        node.visitMaxs(isEnumValues ? 2 : 3, isEnumValues ? 0 : 1);
+        node.visitMaxs(isValueOf ? 3 : 2, isValueOf ? 1 : 0);
         return node;
     }
 
-    public static String getSpecialEnumFunDescriptor(@NotNull Type type, boolean isEnumValues) {
-        return (isEnumValues ? "()[" : "(Ljava/lang/String;)") + "L" + type.getInternalName() + ";";
+    @NotNull
+    public static String getSpecialEnumFunDescriptor(@NotNull Type type, boolean isValueOf) {
+        return isValueOf ? Type.getMethodDescriptor(type, AsmTypes.JAVA_STRING_TYPE) : Type.getMethodDescriptor(AsmUtil.getArrayType(type));
     }
 }