Auto-merge beta4 with beta4

#KT-10505 Fixed
(cherry picked from commit c1dbfee)

.idea/libraries/junit_4_11.xml

@@ -1,16 +1,16 @@
 <component name="libraryTable">
-  <library name="junit-4.12">
+  <library name="junit-4.11">
     <ANNOTATIONS>
       <root url="file://$PROJECT_DIR$/annotations" />
     </ANNOTATIONS>
     <CLASSES>
       <root url="jar://$PROJECT_DIR$/ideaSDK/lib/hamcrest-core-1.3.jar!/" />
-      <root url="jar://$PROJECT_DIR$/ideaSDK/lib/junit-4.12.jar!/" />
+      <root url="jar://$PROJECT_DIR$/ideaSDK/lib/junit-4.11.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES>
       <root url="jar://$PROJECT_DIR$/dependencies/hamcrest-core-1.3-sources.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/junit-4.12-sources.jar!/" />
+      <root url="jar://$PROJECT_DIR$/dependencies/junit-4.11-sources.jar!/" />
     </SOURCES>
   </library>
 </component>

.idea/runConfigurations/IDEA.xml

@@ -2,7 +2,7 @@
   <configuration default="false" name="IDEA" type="Application" factoryName="Application" singleton="true">
     <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
     <option name="MAIN_CLASS_NAME" value="com.intellij.idea.Main" />
-    <option name="VM_PARAMETERS" value="-Xmx800m -XX:ReservedCodeCacheSize=64m -XX:MaxPermSize=450m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=../system-idea -Didea.config.path=../config-idea -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin -Dkotlin.internal.mode.enabled=true -Didea.additional.classpath=../idea-kotlin-runtime/kotlin-runtime.jar,../idea-kotlin-runtime/kotlin-reflect.jar" />
+    <option name="VM_PARAMETERS" value="-Xmx800m -XX:ReservedCodeCacheSize=64m -XX:MaxPermSize=450m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=../system-idea -Didea.config.path=../config-idea -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin,$PROJECT_DIR$/out/artifacts/KotlinAndroidExtensions -Dkotlin.internal.mode.enabled=true" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$/ideaSDK/bin" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />

.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml

@@ -2,7 +2,7 @@
   <configuration default="false" name="IDEA (No ProcessCanceledException)" type="Application" factoryName="Application" singleton="true">
     <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
     <option name="MAIN_CLASS_NAME" value="com.intellij.idea.Main" />
-    <option name="VM_PARAMETERS" value="-Xmx800m -XX:ReservedCodeCacheSize=64m -XX:MaxPermSize=250m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=../system-idea -Didea.config.path=../config-idea -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin -Didea.ProcessCanceledException=disabled -Dkotlin.internal.mode.enabled=true -Didea.additional.classpath=../idea-kotlin-runtime/kotlin-runtime.jar,../idea-kotlin-runtime/kotlin-reflect.jar" />
+    <option name="VM_PARAMETERS" value="-Xmx800m -XX:ReservedCodeCacheSize=64m -XX:MaxPermSize=250m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=../system-idea -Didea.config.path=../config-idea -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin,$PROJECT_DIR$/out/artifacts/KotlinAndroidExtensions -Didea.ProcessCanceledException=disabled -Dkotlin.internal.mode.enabled=true" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$/ideaSDK/bin" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />

TeamCityRelay.xml

@@ -88,12 +88,5 @@
             origin.version="${relay.origin.version}"
             plugin.subdir="BareKotlin"
             substituted.version="${relay.substitute.version}"/>
-
-        <substitudeVersionInPlugin
-            plugin.jar.name="kotlin-android-extensions"
-            plugin.path="${relay.plugins.dir}/kotlin-android-extensions-plugin-${relay.origin.version}.zip"
-            origin.version="${relay.origin.version}"
-            plugin.subdir="KotlinAndroidExtensions"
-            substituted.version="${relay.substitute.version}"/>
     </target>
 </project>

build.xml

@@ -502,7 +502,7 @@
 
                 <zipgroupfileset dir="${basedir}/lib" includes="*.jar"/>
                 <zipgroupfileset dir="${basedir}/ideaSDK/core" includes="*.jar" excludes="util.jar"/>
-                <zipfileset src="${idea.sdk}/lib/jna-platform.jar"/>
+                <zipfileset src="${idea.sdk}/lib/jna-utils.jar"/>
                 <zipfileset src="${idea.sdk}/lib/oromatcher.jar"/>
                 <zipfileset src="${idea.sdk}/jps/jps-model.jar"/>
                 <zipfileset src="${dependencies.dir}/jline.jar"/>
@@ -969,7 +969,7 @@
     <target name="pack-kotlin-test">
         <pack-runtime-jar jar-name="kotlin-test.jar" implementation-title="${manifest.impl.title.kotlin.test}">
             <jar-content>
-                <fileset dir="${output}/classes/kotlin.test" includes="**/*"/>
+                <fileset dir="${output}/classes/kotlin.test" includes="**/*" excludes="kotlin/internal/OnlyInputTypes*,kotlin/internal"/>
             </jar-content>
         </pack-runtime-jar>
     </target>
@@ -1077,4 +1077,5 @@
     <target name="build-bootstrap-artifacts" depends="dist,zip-compiler"/>
 
     <target name="build-artifacts" depends="dist,zip-compiler,kotlin-for-upsource,zip-test-data"/>
+    <!-- Dummy change to see build in TeamCity dependencies -->
 </project>

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

@@ -51,7 +51,7 @@ public class InterfaceImplBodyCodegen(
 
     override fun generateDeclaration() {
         v.defineClass(
-                myClass, V1_6, ACC_PUBLIC or ACC_FINAL,
+                myClass, V1_6, ACC_PUBLIC or ACC_FINAL or ACC_SUPER,
                 typeMapper.mapDefaultImpls(descriptor).internalName,
                 null, "java/lang/Object", ArrayUtil.EMPTY_STRING_ARRAY
         )

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

@@ -297,8 +297,8 @@ public class MultifileClassCodegen(
     }
 
     companion object {
-        private val FACADE_CLASS_ATTRIBUTES = Opcodes.ACC_PUBLIC or Opcodes.ACC_FINAL
-        private val OPEN_FACADE_CLASS_ATTRIBUTES = Opcodes.ACC_PUBLIC
+        private val FACADE_CLASS_ATTRIBUTES = Opcodes.ACC_PUBLIC or Opcodes.ACC_FINAL or Opcodes.ACC_SUPER
+        private val OPEN_FACADE_CLASS_ATTRIBUTES = Opcodes.ACC_PUBLIC or Opcodes.ACC_SUPER
 
         private fun getOnlyPackageFragment(packageFqName: FqName, files: Collection<KtFile>, bindingContext: BindingContext): PackageFragmentDescriptor? {
             val fragments = SmartList<PackageFragmentDescriptor>()

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

@@ -46,7 +46,7 @@ public class MultifileClassPartCodegen(
 
     override fun generateDeclaration() {
         v.defineClass(element, Opcodes.V1_6,
-                      Opcodes.ACC_FINAL or Opcodes.ACC_SYNTHETIC,
+                      Opcodes.ACC_FINAL or Opcodes.ACC_SYNTHETIC or Opcodes.ACC_SUPER,
                       filePartType.internalName,
                       null,
                       "java/lang/Object",

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

@@ -63,7 +63,7 @@ public class PackagePartCodegen extends MemberCodegen<KtFile> {
     @Override
     protected void generateDeclaration() {
         v.defineClass(element, V1_6,
-                      ACC_PUBLIC | ACC_FINAL,
+                      ACC_PUBLIC | ACC_FINAL | ACC_SUPER,
                       packagePartType.getInternalName(),
                       null,
                       "java/lang/Object",

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

@@ -86,7 +86,7 @@ public class SamWrapperCodegen {
         ClassBuilder cv = state.getFactory().newVisitor(JvmDeclarationOriginKt.OtherOrigin(erasedInterfaceFunction), asmType, file);
         cv.defineClass(file,
                        V1_6,
-                       ACC_FINAL,
+                       ACC_FINAL | ACC_SUPER,
                        asmType.getInternalName(),
                        null,
                        OBJECT_TYPE.getInternalName(),

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

@@ -88,7 +88,7 @@ public class ScriptCodegen extends MemberCodegen<KtScript> {
 
         v.defineClass(scriptDeclaration,
                       V1_6,
-                      ACC_PUBLIC,
+                      ACC_PUBLIC | ACC_SUPER,
                       classType.getInternalName(),
                       null,
                       "java/lang/Object",

compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java

@@ -47,7 +47,7 @@ public class MappingClassesForWhenByEnumCodegen {
         cb.defineClass(
                 srcFile,
                 V1_6,
-                ACC_FINAL | ACC_SYNTHETIC | ACC_PUBLIC,
+                ACC_PUBLIC | ACC_FINAL | ACC_SUPER | ACC_SYNTHETIC,
                 mappingsClass.getInternalName(),
                 null,
                 OBJECT_TYPE.getInternalName(),

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLIConfigurationKeys.java

@@ -26,6 +26,8 @@ public class CLIConfigurationKeys {
             CompilerConfigurationKey.create("message collector");
     public static final CompilerConfigurationKey<List<CompilerPlugin>> COMPILER_PLUGINS =
             CompilerConfigurationKey.create("compiler plugins");
+    public static final CompilerConfigurationKey<Boolean> REPORT_PERF =
+            CompilerConfigurationKey.create("enable perf");
 
     private CLIConfigurationKeys() {
     }

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

@@ -59,6 +59,7 @@ public open class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
 
         val configuration = CompilerConfiguration()
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageSeverityCollector)
+        configuration.put(CLIConfigurationKeys.REPORT_PERF, arguments.reportPerf)
 
         if (IncrementalCompilation.isEnabled()) {
             val incrementalCompilationComponents = services.get(javaClass<IncrementalCompilationComponents>())

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

@@ -28,8 +28,8 @@ import com.intellij.mock.MockApplication
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.extensions.Extensions
-import com.intellij.openapi.extensions.ExtensionsArea
+import com.intellij.openapi.extensions.*
+import com.intellij.openapi.fileTypes.ContentBasedFileSubstitutor
 import com.intellij.openapi.fileTypes.FileTypeExtensionPoint
 import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
@@ -43,14 +43,13 @@ import com.intellij.psi.FileContextProvider
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.augment.PsiAugmentProvider
 import com.intellij.psi.compiled.ClassFileDecompilers
-import com.intellij.psi.impl.JavaClassSupersImpl
 import com.intellij.psi.impl.PsiElementFinderImpl
 import com.intellij.psi.impl.PsiTreeChangePreprocessor
 import com.intellij.psi.impl.compiled.ClsCustomNavigationPolicy
+import com.intellij.psi.impl.compiled.ClsStubBuilderFactory
 import com.intellij.psi.impl.file.impl.JavaFileManager
 import com.intellij.psi.meta.MetaDataContributor
 import com.intellij.psi.stubs.BinaryFileStubBuilders
-import com.intellij.psi.util.JavaClassSupers
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.asJava.JavaElementFinder
 import org.jetbrains.kotlin.asJava.KtLightClassForFacade
@@ -342,10 +341,12 @@ public class KotlinCoreEnvironment private constructor(
         }
 
         private fun registerAppExtensionPoints() {
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ContentBasedFileSubstitutor.EP_NAME, javaClass<ContentBasedFileSubstitutor>())
             CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), BinaryFileStubBuilders.EP_NAME, javaClass<FileTypeExtensionPoint<Any>>())
             CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), FileContextProvider.EP_NAME, javaClass<FileContextProvider>())
             //
             CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), MetaDataContributor.EP_NAME, javaClass<MetaDataContributor>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClsStubBuilderFactory.EP_NAME, javaClass<ClsStubBuilderFactory<*>>())
             CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), PsiAugmentProvider.EP_NAME, javaClass<PsiAugmentProvider>())
             CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), JavaMainMethodProvider.EP_NAME, javaClass<JavaMainMethodProvider>())
             //
@@ -385,7 +386,6 @@ public class KotlinCoreEnvironment private constructor(
                 registerFileType(KotlinFileType.INSTANCE, KotlinParserDefinition.STD_SCRIPT_SUFFIX)
                 registerParserDefinition(KotlinParserDefinition())
                 getApplication().registerService(javaClass<KotlinBinaryClassCache>(), KotlinBinaryClassCache())
-                getApplication().registerService(javaClass<JavaClassSupers>(), javaClass<JavaClassSupersImpl>())
             }
         }
 
@@ -407,7 +407,6 @@ public class KotlinCoreEnvironment private constructor(
         private fun registerProjectServicesForCLI(projectEnvironment: JavaCoreProjectEnvironment) {
             with (projectEnvironment.getProject()) {
                 registerService(javaClass<CoreJavaFileManager>(), ServiceManager.getService(this, javaClass<JavaFileManager>()) as CoreJavaFileManager)
-
                 val cliLightClassGenerationSupport = CliLightClassGenerationSupport(this)
                 registerService(javaClass<LightClassGenerationSupport>(), cliLightClassGenerationSupport)
                 registerService(javaClass<CliLightClassGenerationSupport>(), cliLightClassGenerationSupport)

compiler/container/container.iml

@@ -11,7 +11,7 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="kotlin-runtime" level="project" />
     <orderEntry type="library" name="intellij-core" level="project" />
-    <orderEntry type="library" scope="TEST" name="junit-4.12" level="project" />
+    <orderEntry type="library" name="junit-4.11" level="project" />
     <orderEntry type="library" exported="" name="javax.inject" level="project" />
     <orderEntry type="library" scope="TEST" name="kotlin-test" level="project" />
   </component>

compiler/container/src/org/jetbrains/kotlin/container/Cache.kt

@@ -20,9 +20,11 @@ import com.intellij.util.containers.ContainerUtil
 import java.lang.reflect.*
 import java.util.ArrayList
 import java.util.LinkedHashSet
+import java.util.concurrent.ConcurrentHashMap
 
 private object ClassTraversalCache {
-    private val cache = ContainerUtil.createConcurrentWeakKeySoftValueMap<Class<*>, ClassInfo>()
+    private val cache = ContainerUtil.createConcurrentWeakKeySoftValueMap<Class<*>, ClassInfo>(
+            100, 0.75f, Runtime.getRuntime().availableProcessors(), ContainerUtil.canonicalStrategy())
 
     fun getClassInfo(c: Class<*>): ClassInfo {
         val classInfo = cache.get(c)

compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/CompilerCallbackServicesFacadeServer.kt

@@ -16,8 +16,10 @@
 
 package org.jetbrains.kotlin.daemon.client
 
+import com.intellij.openapi.progress.ProcessCanceledException
 import org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade
 import org.jetbrains.kotlin.daemon.common.LoopbackNetworkInterface
+import org.jetbrains.kotlin.daemon.common.RmiFriendlyCompilationCancelledException
 import org.jetbrains.kotlin.daemon.common.SOCKET_ANY_FREE_PORT
 import org.jetbrains.kotlin.incremental.components.LookupInfo
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -80,6 +82,13 @@ class CompilerCallbackServicesFacadeServer(
     override fun lookupTracker_isDoNothing(): Boolean = lookupTracker_isDoNothing
 
     override fun compilationCanceledStatus_checkCanceled() {
-        compilationCancelledStatus!!.checkCanceled()
+        try {
+            compilationCancelledStatus!!.checkCanceled()
+        }
+        catch (e: ProcessCanceledException) {
+            // avoid passing exceptions that may have different serialVersionUID on across rmi border
+            // TODO: doublecheck whether we need to distinguish different cancellation exceptions
+            throw RmiFriendlyCompilationCancelledException()
+        }
     }
 }

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/CompilerCallbackServicesFacade.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.daemon.common
 import org.jetbrains.kotlin.incremental.components.LookupInfo
 import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto
 import org.jetbrains.kotlin.modules.TargetId
+import java.io.Serializable
 import java.rmi.Remote
 import java.rmi.RemoteException
 
@@ -81,7 +82,13 @@ interface CompilerCallbackServicesFacade : Remote {
 
     // ----------------------------------------------------
     // CompilationCanceledStatus
-    @Throws(RemoteException::class)
+    @Throws(RemoteException::class, RmiFriendlyCompilationCancelledException::class)
     fun compilationCanceledStatus_checkCanceled(): Unit
 }
 
+
+class RmiFriendlyCompilationCancelledException: Exception(), Serializable {
+    companion object {
+        private val serialVersionUID: Long = 8228357578L // just a random number, but should never be changed to avoid deserialization problems
+    }
+}

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

@@ -484,7 +484,7 @@ class CompileServiceImpl(
     }
 
     private fun clearJarCache() {
-        ZipHandler.clearFileAccessorCache()
+//        ZipHandler.clearFileAccessorCache()
         val classloader = javaClass.classLoader
         // TODO: replace the following code with direct call to CoreJarFileSystem.<clearCache> as soon as it will be available (hopefully in 15.02)
         try {

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

@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.progress.CompilationCanceledStatus
 import org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade
 import org.jetbrains.kotlin.daemon.common.DummyProfiler
 import org.jetbrains.kotlin.daemon.common.Profiler
+import org.jetbrains.kotlin.daemon.common.RmiFriendlyCompilationCancelledException
+import org.jetbrains.kotlin.progress.CompilationCanceledException
 import java.util.concurrent.TimeUnit
 
 val CANCELED_STATUS_CHECK_THRESHOLD_NS = TimeUnit.MILLISECONDS.toNanos(100)
@@ -30,7 +32,12 @@ class RemoteCompilationCanceledStatusClient(val facade: CompilerCallbackServices
         val curNanos = System.nanoTime()
         if (curNanos - lastChecked > CANCELED_STATUS_CHECK_THRESHOLD_NS) {
             profiler.withMeasure(this) {
-                facade.compilationCanceledStatus_checkCanceled()
+                try {
+                    facade.compilationCanceledStatus_checkCanceled()
+                }
+                catch (e: RmiFriendlyCompilationCancelledException) {
+                    throw CompilationCanceledException()
+                }
             }
             lastChecked = curNanos
         }

compiler/frontend/src/org/jetbrains/kotlin/cfg/WhenChecker.java

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.cfg;
 
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
@@ -285,6 +286,6 @@ public final class WhenChecker {
     }
 
     public static void checkReservedPrefix(@NotNull BindingTrace trace, @NotNull KtWhenExpression expression) {
-        KtPsiUtilKt.checkReservedPrefixWord(trace, expression.getWhenKeyword(), "sealed", "sealed when");
+        KtPsiUtilKt.checkReservedPrefixWord(trace, expression.getWhenKeyword(), "sealed", TokenSet.EMPTY, "sealed when");
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -420,6 +420,8 @@ public interface Errors {
 
     DiagnosticFactory0<KtParameter> USELESS_VARARG_ON_PARAMETER = DiagnosticFactory0.create(WARNING);
 
+    DiagnosticFactory0<KtDeclaration> MULTIPLE_VARARG_PARAMETERS = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+
     // Named parameters
 
     DiagnosticFactory0<KtParameter> DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE = DiagnosticFactory0.create(ERROR, PARAMETER_DEFAULT_VALUE);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -234,6 +234,7 @@ public class DefaultErrorMessages {
 
         MAP.put(ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE, "An anonymous function is not allowed to specify default values for its parameters");
         MAP.put(USELESS_VARARG_ON_PARAMETER, "Vararg on this parameter is useless");
+        MAP.put(MULTIPLE_VARARG_PARAMETERS, "Declarations with multiple vararg-parameters are prohibited");
 
         MAP.put(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, "Projections are not allowed on type arguments of functions and properties");
         MAP.put(SUPERTYPE_NOT_INITIALIZED, "This type has a constructor, and thus must be initialized here");

compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java

@@ -241,11 +241,15 @@ public interface KtTokens {
     TokenSet OPERATIONS = TokenSet.create(AS_KEYWORD, AS_SAFE, IS_KEYWORD, IN_KEYWORD, DOT, PLUSPLUS, MINUSMINUS, EXCLEXCL, MUL, PLUS,
                                           MINUS, EXCL, DIV, PERC, LT, GT, LTEQ, GTEQ, EQEQEQ, EXCLEQEQEQ, EQEQ, EXCLEQ, ANDAND, OROR,
                                           SAFE_ACCESS, ELVIS,
-            //            MAP, FILTER,
                                           RANGE, EQ, MULTEQ, DIVEQ, PERCEQ, PLUSEQ, MINUSEQ,
                                           NOT_IN, NOT_IS,
                                           IDENTIFIER);
 
+    TokenSet BINARY_OPERATIONS = TokenSet.create(AS_KEYWORD, AS_SAFE, IS_KEYWORD, IN_KEYWORD, MUL, PLUS,
+                                                 MINUS, DIV, PERC, LT, GT, LTEQ, GTEQ, EQEQEQ, EXCLEQEQEQ, EQEQ, EXCLEQ, ANDAND, OROR,
+                                                 ELVIS, RANGE, EQ, MULTEQ, DIVEQ, PERCEQ, PLUSEQ, MINUSEQ,
+                                                 NOT_IN, NOT_IS);
+
     TokenSet AUGMENTED_ASSIGNMENTS = TokenSet.create(PLUSEQ, MINUSEQ, MULTEQ, PERCEQ, DIVEQ);
     TokenSet ALL_ASSIGNMENTS = TokenSet.create(EQ, PLUSEQ, MINUSEQ, MULTEQ, PERCEQ, DIVEQ);
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java

@@ -24,6 +24,7 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiWhiteSpace;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.codeInsight.CommentUtilCore;
 import com.intellij.util.containers.ContainerUtil;
@@ -608,9 +609,21 @@ public class KtPsiUtil {
         return prev;
     }
 
+    /**
+     * Example:
+     *      code: async* {}
+     *      element = "{}"
+     *      word = "async"
+     *      suffixTokens = [+, -, *, /, %]
+     *
+     *      result = async
+     */
     @Nullable
-    public static PsiElement getPreviousWord(@NotNull PsiElement element, @NotNull String word) {
+    public static PsiElement getPreviousWord(@NotNull PsiElement element, @NotNull String word, @NotNull TokenSet suffixTokens) {
         PsiElement prev = prevLeafIgnoringWhitespaceAndComments(element);
+        if (prev != null && suffixTokens.contains(prev.getNode().getElementType())) {
+            prev = PsiTreeUtil.prevLeaf(prev, false);
+        }
         if (prev != null && prev.getNode().getElementType() == KtTokens.IDENTIFIER && word.equals(prev.getText())) {
             return prev;
         }

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt

@@ -23,6 +23,7 @@ import com.intellij.psi.PsiParameter
 import com.intellij.psi.PsiParameterList
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.stubs.StubElement
+import com.intellij.psi.tree.TokenSet
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
@@ -434,8 +435,8 @@ fun canPlaceAfterSimpleNameEntry(element: PsiElement?): Boolean {
     return !BAD_NEIGHBOUR_FOR_SIMPLE_TEMPLATE_ENTRY_PATTERN.matches(entryText)
 }
 
-fun checkReservedPrefixWord(sink: DiagnosticSink, element: PsiElement, word: String, message: String) {
-    KtPsiUtil.getPreviousWord(element, word)?.let {
+fun checkReservedPrefixWord(sink: DiagnosticSink, element: PsiElement, word: String, suffixTokens: TokenSet, message: String) {
+    KtPsiUtil.getPreviousWord(element, word, suffixTokens)?.let {
         sink.report(Errors.UNSUPPORTED.on(it, message))
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtEnumEntrySuperClassReferenceExpressionElementType.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.psi.stubs.elements
 
+import com.intellij.psi.PsiElement
 import com.intellij.psi.stubs.StubElement
 import com.intellij.psi.stubs.StubInputStream
 import com.intellij.psi.stubs.StubOutputStream

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

@@ -130,6 +130,7 @@ class DeclarationsChecker(
         declaration.checkTypeReferences()
         modifiersChecker.checkModifiersForDeclaration(declaration, constructorDescriptor)
         identifierChecker.checkDeclaration(declaration, trace)
+        checkVarargParameters(declaration, constructorDescriptor)
     }
 
     private fun checkModifiersAndAnnotationsInPackageDirective(file: KtFile) {
@@ -323,11 +324,13 @@ class DeclarationsChecker(
         else if (aClass is KtEnumEntry) {
             checkEnumEntry(aClass, classDescriptor)
         }
+
         for (memberDescriptor in classDescriptor.declaredCallableMembers) {
             if (memberDescriptor.kind != CallableMemberDescriptor.Kind.DECLARATION) continue
             val member = DescriptorToSourceUtils.descriptorToDeclaration(memberDescriptor) as? KtFunction
             if (member != null && memberDescriptor is FunctionDescriptor) {
                 checkFunctionExposedType(member, memberDescriptor)
+                checkVarargParameters(member, memberDescriptor)
             }
         }
     }
@@ -650,7 +653,16 @@ class DeclarationsChecker(
                 trace.report(IMPLICIT_NOTHING_RETURN_TYPE.on(nameIdentifier ?: function))
             }
         }
+
         checkFunctionExposedType(function, functionDescriptor)
+        checkVarargParameters(function, functionDescriptor)
+    }
+
+    private fun checkVarargParameters(declaration: KtDeclaration, callableDescriptor: CallableDescriptor) {
+        val numberOfVarargParameters = callableDescriptor.valueParameters.count { it.varargElementType != null }
+        if (numberOfVarargParameters > 1) {
+            trace.report(MULTIPLE_VARARG_PARAMETERS.on(declaration))
+        }
     }
 
     private fun checkFunctionExposedType(function: KtFunction, functionDescriptor: FunctionDescriptor) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt

@@ -88,17 +88,9 @@ class OverloadingConflictResolver(private val builtIns: KotlinBuiltIns) {
             CandidateCallWithArgumentMapping.create(candidateCall) { it.arguments.filter { it.getArgumentExpression() != null } }
         }
 
-        val (varargCandidates, regularCandidates) = conflictingCandidates.partition { it.resultingDescriptor.hasVarargs }
-        val mostSpecificRegularCandidates = regularCandidates.selectMostSpecificCallsWithArgumentMapping(discriminateGenericDescriptors)
+        val mostSpecificCandidates = conflictingCandidates.selectMostSpecificCallsWithArgumentMapping(discriminateGenericDescriptors)
 
-        return when {
-            mostSpecificRegularCandidates.size > 1 ->
-                null
-            mostSpecificRegularCandidates.size == 1 ->
-                mostSpecificRegularCandidates.single()
-            else ->
-                varargCandidates.selectMostSpecificCallsWithArgumentMapping(discriminateGenericDescriptors).singleOrNull()
-        }
+        return mostSpecificCandidates.singleOrNull()
     }
 
     private fun <D : CallableDescriptor, K> Collection<CandidateCallWithArgumentMapping<D, K>>.selectMostSpecificCallsWithArgumentMapping(
@@ -139,7 +131,7 @@ class OverloadingConflictResolver(private val builtIns: KotlinBuiltIns) {
 
     /**
      * Returns `true` if `d1` is definitely not less specific than `d2`,
-     * `false` if `d1` is definitely less specific than `d2` or undecided.
+     * `false` otherwise.
      */
     private fun <D : CallableDescriptor, K> compareCallsWithArgumentMapping(
             call1: CandidateCallWithArgumentMapping<D, K>,
@@ -160,6 +152,11 @@ class OverloadingConflictResolver(private val builtIns: KotlinBuiltIns) {
             return it
         }
 
+        val hasVarargs1 = call1.resultingDescriptor.hasVarargs
+        val hasVarargs2 = call2.resultingDescriptor.hasVarargs
+        if (hasVarargs1 && !hasVarargs2) return false
+        if (!hasVarargs1 && hasVarargs2) return true
+
         assert(call1.argumentsCount == call2.argumentsCount) {
             "$call1 and $call2 have different number of explicit arguments"
         }

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

@@ -109,6 +109,9 @@ internal class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Expre
         if (!function.hasBody() && !function.hasModifier(KtTokens.EXTERNAL_KEYWORD)) {
             context.trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor))
         }
+        if (functionDescriptor.valueParameters.count { it.varargElementType != null } > 1) {
+            context.trace.report(MULTIPLE_VARARG_PARAMETERS.on(function))
+        }
 
         if (isStatement) {
             return createTypeInfo(components.dataFlowAnalyzer.checkStatementType(function, context), context)
@@ -159,7 +162,7 @@ internal class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Expre
     }
 
     private fun checkReservedAsync(context: ExpressionTypingContext, expression: PsiElement) {
-        checkReservedPrefixWord(context.trace, expression, "async", "async block/lambda. Use 'async() { ... }' or 'async(fun...)'")
+        checkReservedPrefixWord(context.trace, expression, "async", KtTokens.BINARY_OPERATIONS, "async block/lambda. Use 'async() { ... }' or 'async(fun...)'")
     }
 
     private fun createFunctionLiteralDescriptor(

compiler/testData/codegen/bytecodeText/superFlagInMultiFileFacade.kt

@@ -0,0 +1,13 @@
+@file:kotlin.jvm.JvmMultifileClass
+@file:kotlin.jvm.JvmName("Test")
+
+fun foo() {
+
+}
+
+
+/*ACC_PUBLIC ACC_FINAL ACC_SUPER */
+// 1 access flags 0x31
+
+/*ACC_SYNTHETIC ACC_FINAL ACC_SUPER */
+// 1 access flags 0x1030

compiler/testData/compileKotlinAgainstCustomBinaries/incompleteHierarchyInJava/output.txt

@@ -4,4 +4,4 @@ error: supertypes of the following classes cannot be resolved. Please make sure
 compiler/testData/compileKotlinAgainstCustomBinaries/incompleteHierarchyInJava/source.kt:5:22: error: unresolved reference: foo
 fun bar() = SubSub().foo()
                      ^
-COMPILATION_ERROR
+COMPILATION_ERROR

compiler/testData/compileKotlinAgainstCustomBinaries/incompleteHierarchyInKotlin/output.txt

@@ -4,4 +4,4 @@ error: supertypes of the following classes cannot be resolved. Please make sure
 compiler/testData/compileKotlinAgainstCustomBinaries/incompleteHierarchyInKotlin/source.kt:5:22: error: unresolved reference: foo
 fun bar() = SubSub().foo()
                      ^
-COMPILATION_ERROR
+COMPILATION_ERROR

compiler/testData/diagnostics/tests/ReservedAsync.kt

@@ -6,6 +6,7 @@ infix fun Any.async(f: () -> Unit) = f()
 
 fun test(foo: Any) {
     <!UNSUPPORTED!>async<!> {  }
+    `async` {  }
     <!UNSUPPORTED!>async<!> /**/ {  }
     foo <!UNSUPPORTED!>async<!> {  }
 
@@ -15,7 +16,30 @@ fun test(foo: Any) {
     foo async ({ })
 
     foo <!UNSUPPORTED!>async<!> fun () {}
+    foo `async` fun () {}
     foo async (fun () {})
 
     async (fun () {})
+}
+
+object async {
+    operator fun plus(f: () -> Unit) = f()
+    operator fun minus(f: () -> Unit) = f()
+    operator fun times(f: () -> Unit) = f()
+    operator fun div(f: () -> Unit) = f()
+    operator fun mod(f: () -> Unit) = f()
+}
+
+fun test() {
+    <!UNSUPPORTED!>async<!>+ {}
+    <!UNSUPPORTED!>async<!>- {}
+    <!UNSUPPORTED!>async<!>* {}
+    <!UNSUPPORTED!>async<!>/ {}
+    <!UNSUPPORTED!>async<!>% {}
+
+    async + {}
+    async - {}
+    async * {}
+    async / {}
+    async % {}
 }

compiler/testData/diagnostics/tests/ReservedAsync.txt

@@ -1,5 +1,18 @@
 package
 
 public fun async(/*0*/ f: () -> kotlin.Unit): kotlin.Unit
+public fun test(): kotlin.Unit
 public fun test(/*0*/ foo: kotlin.Any): kotlin.Unit
 public infix fun kotlin.Any.async(/*0*/ f: () -> kotlin.Unit): kotlin.Unit
+
+public object async {
+    private constructor async()
+    public final operator fun div(/*0*/ f: () -> kotlin.Unit): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final operator fun minus(/*0*/ f: () -> kotlin.Unit): kotlin.Unit
+    public final operator fun mod(/*0*/ f: () -> kotlin.Unit): kotlin.Unit
+    public final operator fun plus(/*0*/ f: () -> kotlin.Unit): kotlin.Unit
+    public final operator fun times(/*0*/ f: () -> kotlin.Unit): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.kt

@@ -33,11 +33,6 @@ annotation class Ann8(val p1: Array<String>,
                       val p3: Array<MyEnum>,
                       val p4: Array<Ann1>)
 
-annotation class Ann9(vararg val p1: String,
-                      vararg val p2: <!INVALID_TYPE_OF_ANNOTATION_MEMBER!>Class<*><!>,
-                      vararg val p3: MyEnum,
-                      vararg val p4: Ann1,
-                      vararg val p5: Int)
 
 // INCORRECT
 annotation class InAnn1(val p1: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>Int?<!>,
@@ -64,6 +59,11 @@ annotation class InAnn10(val p1: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>String?<!
 annotation class InAnn11(val p1: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>Ann1?<!>)
 annotation class InAnn12(val p1: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>MyEnum?<!>)
 
+annotation class InAnn13<!MULTIPLE_VARARG_PARAMETERS!>(vararg val p1: String,
+                        vararg val p2: <!INVALID_TYPE_OF_ANNOTATION_MEMBER!>Class<*><!>,
+                        vararg val p3: MyEnum,
+                        vararg val p4: Ann1,
+                        vararg val p5: Int)<!>
 
 enum class MyEnum {
     A

compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt

@@ -83,18 +83,6 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    public final annotation class Ann9 : kotlin.Annotation {
-        public constructor Ann9(/*0*/ vararg p1: kotlin.String /*kotlin.Array<out kotlin.String>*/, /*1*/ vararg p2: java.lang.Class<*> /*kotlin.Array<out java.lang.Class<*>>*/, /*2*/ vararg p3: test.MyEnum /*kotlin.Array<out test.MyEnum>*/, /*3*/ vararg p4: test.Ann1 /*kotlin.Array<out test.Ann1>*/, /*4*/ vararg p5: kotlin.Int /*kotlin.IntArray*/)
-        public final val p1: kotlin.Array<out kotlin.String>
-        public final val p2: kotlin.Array<out java.lang.Class<*>>
-        public final val p3: kotlin.Array<out test.MyEnum>
-        public final val p4: kotlin.Array<out test.Ann1>
-        public final val p5: kotlin.IntArray
-        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-    }
-
     public final annotation class InAnn1 : kotlin.Annotation {
         public constructor InAnn1(/*0*/ p1: kotlin.Int?, /*1*/ p3: kotlin.Short?, /*2*/ p4: kotlin.Long?, /*3*/ p5: kotlin.Double?, /*4*/ p6: kotlin.Float?, /*5*/ p7: kotlin.Char?, /*6*/ p8: kotlin.Boolean?)
         public final val p1: kotlin.Int?
@@ -133,6 +121,18 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
+    public final annotation class InAnn13 : kotlin.Annotation {
+        public constructor InAnn13(/*0*/ vararg p1: kotlin.String /*kotlin.Array<out kotlin.String>*/, /*1*/ vararg p2: java.lang.Class<*> /*kotlin.Array<out java.lang.Class<*>>*/, /*2*/ vararg p3: test.MyEnum /*kotlin.Array<out test.MyEnum>*/, /*3*/ vararg p4: test.Ann1 /*kotlin.Array<out test.Ann1>*/, /*4*/ vararg p5: kotlin.Int /*kotlin.IntArray*/)
+        public final val p1: kotlin.Array<out kotlin.String>
+        public final val p2: kotlin.Array<out java.lang.Class<*>>
+        public final val p3: kotlin.Array<out test.MyEnum>
+        public final val p4: kotlin.Array<out test.Ann1>
+        public final val p5: kotlin.IntArray
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
     public final annotation class InAnn4 : kotlin.Annotation {
         public constructor InAnn4(/*0*/ p1: kotlin.Array<kotlin.Int>, /*1*/ p2: kotlin.Array<kotlin.Int>?)
         public final val p1: kotlin.Array<kotlin.Int>

compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.kt

@@ -0,0 +1,27 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED
+<!MULTIPLE_VARARG_PARAMETERS!>fun test(vararg x1: Int, vararg x2: Int)<!> {
+    <!MULTIPLE_VARARG_PARAMETERS!>fun test2(vararg x1: Int, vararg x2: Int)<!> {
+        class LocalClass<!MULTIPLE_VARARG_PARAMETERS!>(vararg x1: Int, vararg x2: Int)<!> {
+            <!MULTIPLE_VARARG_PARAMETERS!>constructor(vararg x1: Int, vararg x2: Int, xx: Int)<!> {}
+        }
+        <!MULTIPLE_VARARG_PARAMETERS!>fun test3(vararg x1: Int, vararg x2: Int)<!> {}
+    }
+}
+
+<!MULTIPLE_VARARG_PARAMETERS!>fun Any.test(vararg x1: Int, vararg x2: Int, vararg x3: Int)<!> {}
+
+interface I {
+    <!MULTIPLE_VARARG_PARAMETERS!>fun test(vararg x1: Int, vararg x2: Int)<!>
+}
+
+abstract class C<!MULTIPLE_VARARG_PARAMETERS!>(vararg x1: Int, vararg x2: Int, b: Boolean)<!> {
+    <!MULTIPLE_VARARG_PARAMETERS!>fun test(vararg x1: Int, vararg x2: Int)<!> {}
+
+    <!MULTIPLE_VARARG_PARAMETERS!>abstract fun test2(vararg x1: Int, vararg x2: Int)<!>
+
+    class CC<!MULTIPLE_VARARG_PARAMETERS!>(vararg x1: Int, vararg x2: Int, b: Boolean)<!> {
+        <!MULTIPLE_VARARG_PARAMETERS!>constructor(vararg x1: Int, vararg x2: Int)<!> {}
+        <!MULTIPLE_VARARG_PARAMETERS!>fun test(vararg x1: Int, vararg x2: Int)<!> {}
+    }
+}
+

compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.txt

@@ -0,0 +1,29 @@
+package
+
+public fun test(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+public fun kotlin.Any.test(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/, /*2*/ vararg x3: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+
+public abstract class C {
+    public constructor C(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/, /*2*/ b: kotlin.Boolean)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun test(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+    public abstract fun test2(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class CC {
+        public constructor CC(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/)
+        public constructor CC(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/, /*2*/ b: kotlin.Boolean)
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final fun test(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public interface I {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun test(/*0*/ vararg x1: kotlin.Int /*kotlin.IntArray*/, /*1*/ vararg x2: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/declarationChecks/valVarFunctionParameter.kt

@@ -1,11 +1,11 @@
-fun f(
+<!MULTIPLE_VARARG_PARAMETERS!>fun f(
         <!VAL_OR_VAR_ON_FUN_PARAMETER!>val<!> a: Int,
         <!VAL_OR_VAR_ON_FUN_PARAMETER!>var<!> b: Int,
         c: Int,
         vararg <!VAL_OR_VAR_ON_FUN_PARAMETER!>var<!> d: Int,
         vararg <!VAL_OR_VAR_ON_FUN_PARAMETER!>val<!> e: Int,
         vararg f: Int
-) {
+)<!> {
     
     
     a + b + c + d[0] + e[0] + f[0] // to avoid 'unused parameter'

compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnTypeIn.kt

@@ -1,4 +1,4 @@
-// FILE: InOut.k
+// FILE: InOut.kt
 interface In<in T>
 
 // FILE: J1.java

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10472.kt

@@ -0,0 +1,13 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+interface A<T>
+interface B<T> : A<T>
+
+fun <T> foo(vararg t: T) = Wrong
+fun <T> foo(t: A<T>) = Wrong
+fun <T> foo(t: B<T>) = Right
+
+fun test(b: B<Int>): Right = foo(b)

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10472.txt

@@ -0,0 +1,32 @@
+package
+
+public fun </*0*/ T> foo(/*0*/ t: A<T>): Wrong
+public fun </*0*/ T> foo(/*0*/ t: B<T>): Right
+public fun </*0*/ T> foo(/*0*/ vararg t: T /*kotlin.Array<out T>*/): Wrong
+public fun test(/*0*/ b: B<kotlin.Int>): Right
+
+public interface A</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B</*0*/ T> : A<T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public object Right {
+    private constructor Right()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public object Wrong {
+    private constructor Wrong()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/lineNumber/custom/callWithReceiver.kt

@@ -12,4 +12,4 @@ fun foo() {
      .bar()
 }
 
-// 2 3 1 7 8 9 8 9 11 12 11 12 17 13
+// 2 3 1 7 8 9 11 12 16 13

compiler/testData/lineNumber/custom/chainCall.kt

@@ -12,4 +12,4 @@ fun foo() {
         .bar()
 }
 
-// 2 3 1 7 8 9 8 9 11 12 11 17 12 17 13
+// 2 3 1 7 8 9 11 16 12 16 13

compiler/testData/lineNumber/custom/compileTimeConstant.kt

@@ -3,4 +3,4 @@ fun foo() {
             42
 }
 
-// 2 3 2 4
+// 3 2 4

compiler/testData/lineNumber/custom/functionCallWithDefault.kt

@@ -9,4 +9,4 @@ fun foo(i: Int = 1) {
 inline fun bar(i: Int = 1) {
 }
 
-// 2 3 9 10 4 7 6 10 9 10
+// 2 3 9 4 7 6 10 9 10

compiler/testData/lineNumber/custom/functionCallWithInlinedLambdaParam.kt

@@ -13,4 +13,4 @@ inline fun foo(f: () -> Unit) {
     f()
 }
 
-// 2 12 13 3 4 14 6 12 13 7 8 14 9 12 13 14
+// 2 12 3 4 6 12 7 8 9 12 13 14

compiler/testData/lineNumber/custom/ifThenElse.kt

@@ -12,4 +12,4 @@ fun foo() {
     }
 }
 
-// 2 3 5 6 8 9 11 8 13
+// 2 3 5 8 9 11 8 13

compiler/testData/lineNumber/custom/tryCatchExpression.kt

@@ -12,4 +12,4 @@ fun foo() {
     }
 }
 
-// 2 3 5 6 8 9 11 8 13
+// 2 3 5 8 9 11 8 13

compiler/testData/lineNumber/custom/tryCatchFinally.kt

@@ -16,4 +16,4 @@ fun foo() {
     }
 }
 
-// 2 3 7 5 7 8 10 11 15 13 15 10 17
+// 2 3 7 5 7 10 11 15 13 15 10 17

compiler/testData/lineNumber/custom/tryFinally.kt

@@ -12,4 +12,4 @@ fun foo() {
     }
 }
 
-// 2 3 5 6 8 9 11 8 13
+// 2 3 5 8 9 11 8 13

compiler/testData/lineNumber/custom/when.kt

@@ -12,4 +12,4 @@ fun foo(x: Int) {
     }
 }
 
-// 2 3 4 5 6 8 9 10 11 8 13
+// 3 4 5 9 10 11 8 13

compiler/testData/lineNumber/custom/whenSubject.kt

@@ -12,4 +12,4 @@ fun foo(x: Int) {
     }
 }
 
-// 2 3 4 5 6 8 9 10 11 8 13
+// 2 3 4 5 8 9 10 11 8 13

compiler/testData/loadJava/compiledJava/InnerClassTypeMultipleGeneric.txt

@@ -2,7 +2,7 @@ package test
 
 public open class InnerClassTypeMultipleGeneric {
     public constructor InnerClassTypeMultipleGeneric()
-    public open fun staticType(): test.InnerClassTypeMultipleGeneric.Outer<kotlin.Char!, kotlin.Boolean!>.Inner<kotlin.Byte!>!
+    public open fun staticType(): test.InnerClassTypeMultipleGeneric.Outer<[ERROR : Unresolved Java type parameter: E1]!, [ERROR : Unresolved Java type parameter: E2]!>.Inner<kotlin.Byte!>!
 
     public open inner class BaseOuter</*0*/ H1 : kotlin.Any!, /*1*/ H2 : kotlin.Any!> {
         public constructor BaseOuter</*0*/ H1 : kotlin.Any!, /*1*/ H2 : kotlin.Any!>()
@@ -16,7 +16,7 @@ public open class InnerClassTypeMultipleGeneric {
         public constructor Outer</*0*/ E1 : kotlin.Any!, /*1*/ E2 : kotlin.Any!>()
         public open fun bar(): test.InnerClassTypeMultipleGeneric.BaseOuter<kotlin.Int!, E1!>.BaseInner<java.lang.Class<*>!, kotlin.CharSequence!>!
 
-        public open inner class Inner</*0*/ E3 : kotlin.Any!> /*captured type parameters: /*1*/ E1 : kotlin.Any!, /*2*/ E2 : kotlin.Any!*/ : test.InnerClassTypeMultipleGeneric.BaseOuter<E2!, E3!>.BaseInner<kotlin.Double!, kotlin.String!> {
+        public open inner class Inner</*0*/ E3 : kotlin.Any!> /*captured type parameters: /*1*/ E1 : kotlin.Any!, /*2*/ E2 : kotlin.Any!*/ : test.InnerClassTypeMultipleGeneric.BaseOuter<kotlin.Int!, E1!>.BaseInner<kotlin.Double!, kotlin.String!> {
             public constructor Inner</*0*/ E3 : kotlin.Any!>()
         }
     }

compiler/testData/writeFlags/class/accessFlags/defaultImpls.kt

@@ -0,0 +1,11 @@
+
+interface Test {
+    fun a() {
+
+    }
+}
+
+
+// TESTED_OBJECT_KIND: class
+// TESTED_OBJECTS: Test$DefaultImpls
+// FLAGS: ACC_PUBLIC, ACC_FINAL, ACC_SUPER

compiler/testData/writeFlags/class/accessFlags/mappingWhen.kt

@@ -0,0 +1,19 @@
+
+enum class BigEnum {
+    ITEM1,
+    ITEM2
+}
+
+fun bar1(x : BigEnum) : String {
+    when (x) {
+        BigEnum.ITEM1 -> return "123"
+        BigEnum.ITEM2-> return "456"
+    }
+
+    return "-1";
+
+}
+
+// TESTED_OBJECT_KIND: class
+// TESTED_OBJECTS: MappingWhenKt$WhenMappings
+// FLAGS: ACC_PUBLIC, ACC_SYNTHETIC, ACC_FINAL, ACC_SUPER

compiler/testData/writeFlags/class/accessFlags/simpleFilePackageFacade.kt

@@ -0,0 +1,7 @@
+fun foo() {
+
+}
+
+// TESTED_OBJECT_KIND: class
+// TESTED_OBJECTS: SimpleFilePackageFacadeKt
+// FLAGS: ACC_PUBLIC, ACC_FINAL, ACC_SUPER

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -4224,6 +4224,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("mulitpleVarargParameters.kt")
+            public void testMulitpleVarargParameters() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("MultiDeclarationErrors.kt")
             public void testMultiDeclarationErrors() throws Exception {
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt");
@@ -13736,6 +13742,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                     doTest(fileName);
                 }
 
+                @TestMetadata("kt10472.kt")
+                public void testKt10472() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10472.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("numberOfDefaults.kt")
                 public void testNumberOfDefaults() throws Exception {
                     String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/numberOfDefaults.kt");

compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java

@@ -305,6 +305,12 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest {
         doTest(fileName);
     }
 
+    @TestMetadata("superFlagInMultiFileFacade.kt")
+    public void testSuperFlagInMultiFileFacade() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeText/superFlagInMultiFileFacade.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("topLevelFunWithDefaultArgs.kt")
     public void testTopLevelFunWithDefaultArgs() throws Exception {
         String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeText/topLevelFunWithDefaultArgs.kt");

compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java

@@ -93,6 +93,18 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
                 KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
+            @TestMetadata("defaultImpls.kt")
+            public void testDefaultImpls() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeFlags/class/accessFlags/defaultImpls.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("mappingWhen.kt")
+            public void testMappingWhen() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeFlags/class/accessFlags/mappingWhen.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("objectLiteral.kt")
             public void testObjectLiteral() throws Exception {
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeFlags/class/accessFlags/objectLiteral.kt");
@@ -122,6 +134,12 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeFlags/class/accessFlags/publicInterface.kt");
                 doTest(fileName);
             }
+
+            @TestMetadata("simpleFilePackageFacade.kt")
+            public void testSimpleFilePackageFacade() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeFlags/class/accessFlags/simpleFilePackageFacade.kt");
+                doTest(fileName);
+            }
         }
 
         @TestMetadata("compiler/testData/writeFlags/class/deprecatedFlag")

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstInlineKotlinTest.kt

@@ -33,7 +33,10 @@ public abstract class AbstractCompileKotlinAgainstInlineKotlinTest : AbstractCom
         try {
             val sourceFiles = factory1.getInputFiles() + factory2.getInputFiles()
             InlineTestUtil.checkNoCallsToInline(allGeneratedFiles.filterClassFiles(), sourceFiles)
-            checkSMAP(sourceFiles, allGeneratedFiles.filterClassFiles())
+
+            if (getTestName(true) != "smap") {
+                checkSMAP(sourceFiles, allGeneratedFiles.filterClassFiles())
+            }
         }
         catch (e: Throwable) {
             System.out.println(factory1.createText() + "\n" + factory2.createText())

compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java

@@ -20,6 +20,7 @@ import com.intellij.testFramework.TestDataPath;
 import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.Ignore;
 import org.junit.runner.RunWith;
 
 import java.io.File;
@@ -3206,7 +3207,8 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD
         }
 
         @TestMetadata("InnerClassTypeMultipleGeneric.java")
-        public void testInnerClassTypeMultipleGeneric() throws Exception {
+        @Ignore
+        public void ignoreTestInnerClassTypeMultipleGeneric() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/InnerClassTypeMultipleGeneric.java");
             doTest(fileName);
         }

core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt

@@ -24,3 +24,4 @@ object BuiltInSerializerProtocol : SerializerExtensionProtocol(
         BuiltInsProtoBuf.propertyAnnotation, BuiltInsProtoBuf.enumEntryAnnotation, BuiltInsProtoBuf.compileTimeValue,
         BuiltInsProtoBuf.parameterAnnotation, BuiltInsProtoBuf.typeAnnotation, BuiltInsProtoBuf.typeParameterAnnotation
 )
+

eval4j/eval4j.iml

@@ -10,6 +10,7 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="kotlin-runtime" level="project" />
     <orderEntry type="library" name="asm" level="project" />
-    <orderEntry type="library" scope="TEST" name="junit-4.12" level="project" />
+    <orderEntry type="library" scope="TEST" name="junit-4.11" level="project" />
   </component>
-</module>
+</module>
+

generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt

@@ -700,7 +700,6 @@ fun main(args: Array<String>) {
             model("debugger/tinyApp/src/stepping/stepIntoAndSmartStepInto", testMethod = "doSmartStepIntoTest", testClassName = "SmartStepInto")
             model("debugger/tinyApp/src/stepping/stepInto", testMethod = "doStepIntoTest", testClassName = "StepIntoOnly")
             model("debugger/tinyApp/src/stepping/stepOut", testMethod = "doStepOutTest")
-            model("debugger/tinyApp/src/stepping/stepOver", testMethod = "doStepOverTest")
             model("debugger/tinyApp/src/stepping/filters", testMethod = "doStepIntoTest")
             model("debugger/tinyApp/src/stepping/custom", testMethod = "doCustomTest")
         }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/KotlinBundle.properties

@@ -263,6 +263,7 @@ suppress.warning.for=Suppress ''{0}'' for {1} {2}
 
 reflection.not.found=Reflection not found in the classpath
 add.reflection.to.classpath=Add kotlin-reflect.jar to the classpath
+add.test.to.classpath=Add kotlin-test.jar to the classpath
 
 # Kotlin Compiler Settings Tab
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/JarUserDataManager.kt

@@ -100,7 +100,6 @@ public object JarUserDataManager {
 
     private fun storeUserData(counter: JarBooleanPropertyCounter, localJarFile: VirtualFile,
                               hasFileWithProperty: Boolean?, timestamp: Long? = null) {
-        assert(localJarFile.isInLocalFileSystem)
         assert((timestamp == null) == (hasFileWithProperty == null)) { "Using empty timestamp is only allowed for storing not counted value" }
 
         localJarFile.putUserData(counter.key,

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ClsJavaStubByVirtualFileCache.kt

@@ -31,7 +31,9 @@ import java.io.IOException
 public class ClsJavaStubByVirtualFileCache {
     private class CachedJavaStub(val modificationStamp: Long, val javaFileStub: PsiJavaFileStubImpl)
 
-    private val cache = ContainerUtil.createConcurrentWeakKeySoftValueMap<VirtualFile, CachedJavaStub>()
+    private val cache = ContainerUtil.createConcurrentWeakKeySoftValueMap<VirtualFile, CachedJavaStub>(
+            100, 0.75f, Runtime.getRuntime().availableProcessors(), ContainerUtil.canonicalStrategy<VirtualFile>()
+    )
 
     public fun get(classFile: VirtualFile): PsiJavaFileStubImpl? {
         val cached = cache.get(classFile)

idea/idea-analysis/src/org/jetbrains/kotlin/idea/configuration/MainFunctionGutterVisitor.kt

@@ -0,0 +1,43 @@
+/*
+ * 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.idea.configuration
+
+import com.intellij.lang.annotation.AnnotationHolder
+import com.intellij.openapi.editor.markup.GutterIconRenderer
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.idea.KotlinIcons
+import org.jetbrains.kotlin.idea.MainFunctionDetector
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtVisitorVoid
+import org.jetbrains.kotlin.resolve.BindingContext
+import javax.swing.Icon
+
+class MainFunctionGutterVisitor(val holder: AnnotationHolder, val bindingContext: BindingContext) : KtVisitorVoid() {
+    override fun visitNamedFunction(function: KtNamedFunction) {
+        if (MainFunctionDetector(bindingContext).isMain(function)) {
+            function.nameIdentifier?.let { nameIdentifier ->
+                holder.createInfoAnnotation(nameIdentifier, "Run configuration from here").gutterIconRenderer = MainGutterIconRenderer(nameIdentifier)
+            }
+        }
+    }
+}
+
+class MainGutterIconRenderer(val nameIdentifier: PsiElement) : GutterIconRenderer() {
+    override fun getIcon(): Icon = KotlinIcons.LAUNCH
+    override fun hashCode(): Int = nameIdentifier.hashCode()
+    override fun equals(other: Any?): Boolean = other is MainGutterIconRenderer && other.nameIdentifier == nameIdentifier
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/KotlinDecompiledFileViewProvider.kt

@@ -36,17 +36,7 @@ class KotlinDecompiledFileViewProvider(
 ) : SingleRootFileViewProvider(manager, file, physical, KotlinLanguage.INSTANCE) {
     val content : LockedClearableLazyValue<String> = LockedClearableLazyValue(Any()) {
         val psiFile = createFile(manager.getProject(), file, KotlinFileType.INSTANCE)
-        val text = psiFile?.getText() ?: ""
-
-        DebugUtil.startPsiModification("Invalidating throw-away copy of file that was used for getting text")
-        try {
-            (psiFile as? PsiFileImpl)?.markInvalidated()
-        }
-        finally {
-            DebugUtil.finishPsiModification()
-        }
-
-        text
+        psiFile?.getText() ?: ""
     }
 
     override fun createFile(project: Project, file: VirtualFile, fileType: FileType): PsiFile? {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinPsiChecker.kt

@@ -41,6 +41,8 @@ import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.idea.actions.internal.KotlinInternalMode
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult
+import org.jetbrains.kotlin.idea.configuration.MainFunctionGutterVisitor
+import org.jetbrains.kotlin.idea.kdoc.KDocHighlightingVisitor
 import org.jetbrains.kotlin.idea.quickfix.QuickFixes
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt

@@ -82,7 +82,9 @@ class OverridesCompletion(
                 AllIcons.Gutter.ImplementingMethod
             else
                 AllIcons.Gutter.OverridingMethod
-            val icon = RowIcon(baseIcon, additionalIcon)
+            val icon = RowIcon(2)
+            icon.setIcon(baseIcon, 0)
+            icon.setIcon(additionalIcon, 1)
 
             val baseClassDeclaration = DescriptorToSourceUtilsIde.getAnyDeclaration(position.project, baseClass)
             val baseClassIcon = KotlinDescriptorIconProvider.getIcon(baseClass, baseClassDeclaration, 0)

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinFunctionInsertHandler.kt

@@ -25,6 +25,7 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager
+import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject
 import org.jetbrains.kotlin.idea.core.formatter.KotlinCodeStyleSettings
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtTypeArgumentList
@@ -73,10 +74,10 @@ sealed class KotlinFunctionInsertHandler : KotlinCallableInsertHandler() {
             val startOffset = context.startOffset
             val element = context.file.findElementAt(startOffset) ?: return
 
-            addArguments(context, element)
+            addArguments(context, element, item)
         }
 
-        private fun addArguments(context : InsertionContext, offsetElement : PsiElement) {
+        private fun addArguments(context: InsertionContext, offsetElement: PsiElement, item: LookupElement) {
             val completionChar = context.getCompletionChar()
             if (completionChar == '(') { //TODO: more correct behavior related to braces type
                 context.setAddCompletionChar(false)
@@ -122,6 +123,12 @@ sealed class KotlinFunctionInsertHandler : KotlinCallableInsertHandler() {
                 offset += 2
             }
 
+            // insert additional brackets for reserved syntax: "async {}"
+            if (insertLambda && (item.`object` as? DeclarationLookupObject)?.name?.identifier == "async") {
+                document.insertString(offset, "()")
+                offset += 2
+            }
+
             var openingBracketOffset = chars.indexOfSkippingSpace(openingBracket, offset)
             var closeBracketOffset = openingBracketOffset?.let { chars.indexOfSkippingSpace(closingBracket, it + 1) }
             var inBracketsShift = 0

idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/AsyncSimple.kt

@@ -0,0 +1,7 @@
+fun async(a: () -> Unit) {}
+
+fun test() {
+    asy<caret>
+}
+
+// ELEMENT: async

idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/AsyncSimple.kt.after

@@ -0,0 +1,7 @@
+fun async(a: () -> Unit) {}
+
+fun test() {
+    async() { <caret> }
+}
+
+// ELEMENT: async

idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/AsyncWithoutLambda.kt

@@ -0,0 +1,7 @@
+fun async (p: Int, a: () -> Unit) {}
+
+fun test() {
+    asy<caret>
+}
+
+// ELEMENT: async

idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/AsyncWithoutLambda.kt.after

@@ -0,0 +1,7 @@
+fun async (p: Int, a: () -> Unit) {}
+
+fun test() {
+    async(<caret>)
+}
+
+// ELEMENT: async

idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/FromFooToAsync.kt

@@ -0,0 +1,10 @@
+fun asyFoo(a: () -> Unit) {}
+
+fun async(a: () -> Unit) {}
+
+fun test() {
+    asy<caret>Foo {  }
+}
+
+// ELEMENT: async
+// CHAR: '\t'

idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/FromFooToAsync.kt.after

@@ -0,0 +1,10 @@
+fun asyFoo(a: () -> Unit) {}
+
+fun async(a: () -> Unit) {}
+
+fun test() {
+    async() {  }
+}
+
+// ELEMENT: async
+// CHAR: '\t'

idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/FromFooToAsync2.kt

@@ -0,0 +1,10 @@
+fun asyFoo(p: Int, a: () -> Unit) {}
+
+fun async(q: Int, a: () -> Unit) {}
+
+fun test() {
+    asy<caret>Foo(5) {  }
+}
+
+// ELEMENT: async
+// CHAR: '\t'

idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/FromFooToAsync2.kt.after

@@ -0,0 +1,10 @@
+fun asyFoo(p: Int, a: () -> Unit) {}
+
+fun async(q: Int, a: () -> Unit) {}
+
+fun test() {
+    async(<caret>5) {  }
+}
+
+// ELEMENT: async
+// CHAR: '\t'

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java

@@ -378,6 +378,39 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion
             String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt");
             doTest(fileName);
         }
+
+        @TestMetadata("idea/idea-completion/testData/handlers/basic/highOrderFunctions/async")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Async extends AbstractBasicCompletionHandlerTest {
+            public void testAllFilesPresentInAsync() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions/async"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("AsyncSimple.kt")
+            public void testAsyncSimple() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/AsyncSimple.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("AsyncWithoutLambda.kt")
+            public void testAsyncWithoutLambda() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/AsyncWithoutLambda.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("FromFooToAsync.kt")
+            public void testFromFooToAsync() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/FromFooToAsync.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("FromFooToAsync2.kt")
+            public void testFromFooToAsync2() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/highOrderFunctions/async/FromFooToAsync2.kt");
+                doTest(fileName);
+            }
+        }
     }
 
     @TestMetadata("idea/idea-completion/testData/handlers/basic/override")

idea/idea-js/src/org/jetbrains/kotlin/idea/js/KotlinJavaScriptHandler.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.idea.js
+
+import com.intellij.openapi.vfs.impl.ArchiveHandler
+import com.intellij.openapi.vfs.impl.ArchiveHandler.EntryInfo
+import com.intellij.util.ArrayUtil
+import gnu.trove.THashMap
+import org.jetbrains.kotlin.serialization.js.forEachFile
+import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
+
+public open class KotlinJavaScriptHandler(path: String) : ArchiveHandler(path) {
+
+    override fun createEntriesMap(): Map<String, EntryInfo> {
+        val map = THashMap<String, EntryInfo>()
+        map.put("", createRootEntry())
+
+        for(metadata in KotlinJavascriptMetadataUtils.loadMetadata(getFile())) {
+            val moduleName = metadata.moduleName
+            metadata.forEachFile {
+                filePath, fileContent -> getOrCreate(moduleName + "/" + filePath, false, map, fileContent)
+            }
+        }
+
+        return map
+    }
+
+    private fun getOrCreate(
+            entryPath: String,
+            isDirectory: Boolean,
+            map: MutableMap<String, EntryInfo>,
+            content: ByteArray = ArrayUtil.EMPTY_BYTE_ARRAY
+    ): EntryInfo {
+        val info = map[entryPath]
+        if (info != null) return info
+
+        val path = splitPath(entryPath)
+        val parentInfo = getOrCreate(path.first, true, map)
+        val newInfo = JsMetaEntryInfo(parentInfo, path.second, isDirectory, content)
+        map[entryPath] = newInfo
+
+        return newInfo
+    }
+
+    override fun contentsToByteArray(relativePath: String): ByteArray {
+        val entryInfo = getEntryInfo(relativePath)
+        return if (entryInfo is JsMetaEntryInfo) entryInfo.content else ArrayUtil.EMPTY_BYTE_ARRAY
+    }
+
+    private class JsMetaEntryInfo(
+            parent: EntryInfo,
+            shortName: String,
+            isDirectory: Boolean,
+            val content: ByteArray
+    ) : EntryInfo(shortName, isDirectory, ArchiveHandler.DEFAULT_LENGTH, ArchiveHandler.DEFAULT_TIMESTAMP, parent)
+}

idea/idea-repl/src/org/jetbrains/kotlin/console/KotlinConsoleRunner.kt

@@ -167,7 +167,8 @@ public class KotlinConsoleRunner(
         val placeholderAttrs = TextAttributes()
         placeholderAttrs.foregroundColor = ReplColors.PLACEHOLDER_COLOR
         placeholderAttrs.fontType = Font.ITALIC
-        editor.setPlaceholderAttributes(placeholderAttrs)
+
+//        editor.setPlaceholderAttributes(placeholderAttrs)
     }
 
     private fun disableCompletion(consoleView: LanguageConsoleView) {
@@ -180,7 +181,7 @@ public class KotlinConsoleRunner(
         fun configureEditorGutter(editor: EditorEx, color: Color, iconWithTooltip: IconWithTooltip): RangeHighlighter {
             editor.settings.isLineMarkerAreaShown = true // hack to show gutter
             editor.settings.isFoldingOutlineShown = true
-            editor.gutterComponentEx.setPaintBackground(true)
+//            editor.gutterComponentEx.setPaintBackground(true)
             val editorColorScheme = editor.colorsScheme
             editorColorScheme.setColor(EditorColors.GUTTER_BACKGROUND, color)
             editor.colorsScheme = editorColorScheme

idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinLightCodeInsightFixtureTestCase.kt

@@ -30,7 +30,6 @@ import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess
 import com.intellij.testFramework.LightProjectDescriptor
 import com.intellij.testFramework.LoggedErrorProcessor
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import org.apache.log4j.Logger
 import org.jetbrains.kotlin.idea.actions.internal.KotlinInternalMode
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils
@@ -58,7 +57,7 @@ public abstract class KotlinLightCodeInsightFixtureTestCase : LightCodeInsightFi
         invalidateLibraryCache(project)
 
         LoggedErrorProcessor.setNewInstance(object : LoggedErrorProcessor() {
-            override fun processError(message: String?, t: Throwable?, details: Array<out String>?, logger: Logger) {
+            override fun processError(message: String?, t: Throwable?, details: Array<out String>?, logger: org.apache.log4j.Logger) {
                 exceptions.addIfNotNull(t)
                 super.processError(message, t, details, logger)
             }
@@ -71,14 +70,7 @@ public abstract class KotlinLightCodeInsightFixtureTestCase : LightCodeInsightFi
         KotlinInternalMode.enabled = kotlinInternalModeOriginalValue
         VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory())
 
-        unInvalidateBuiltinsAndStdLib(getProject()) {
-            super.tearDown()
-        }
-
-        if (exceptions.isNotEmpty()) {
-            exceptions.forEach { it.printStackTrace() }
-            throw AssertionError("Exceptions in other threads happened")
-        }
+        super.tearDown()
     }
 
     override fun getProjectDescriptor(): LightProjectDescriptor

idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinLightPlatformCodeInsightFixtureTestCase.kt

@@ -40,8 +40,6 @@ public abstract class KotlinLightPlatformCodeInsightFixtureTestCase: LightPlatfo
         KotlinInternalMode.enabled = kotlinInternalModeOriginalValue
         VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory())
 
-        unInvalidateBuiltinsAndStdLib(getProject()) {
-            super.tearDown()
-        }
+        super.tearDown()
     }
 }

idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinLightProjectDescriptor.java

@@ -25,7 +25,7 @@ import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 
-public class KotlinLightProjectDescriptor extends LightProjectDescriptor {
+public class KotlinLightProjectDescriptor implements LightProjectDescriptor {
     protected KotlinLightProjectDescriptor() {
     }
     

idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/testUtils.kt

@@ -73,17 +73,22 @@ public fun Module.configureAs(kind: ModuleKind) {
 }
 
 public fun KtFile.dumpTextWithErrors(): String {
+    return diagnosticsHeader() + getText()
+}
+
+public fun KtFile.diagnosticsHeader(): String {
     val diagnostics = analyzeFullyAndGetResult().bindingContext.getDiagnostics()
     val errors = diagnostics.filter { it.getSeverity() == Severity.ERROR }
-    if (errors.isEmpty()) return getText()
-    val header = errors.map { "// ERROR: " + DefaultErrorMessages.render(it).replace('\n', ' ') }.joinToString("\n", postfix = "\n")
-    return header + getText()
+    if (errors.isEmpty()) return ""
+    return errors.map { "// ERROR: " + DefaultErrorMessages.render(it).replace('\n', ' ') }.joinToString("\n", postfix = "\n")
 }
 
 public fun closeAndDeleteProject(): Unit =
     ApplicationManager.getApplication().runWriteAction() { LightPlatformTestCase.closeAndDeleteProject() }
 
 public fun unInvalidateBuiltinsAndStdLib(project: Project, runnable: RunnableWithException) {
+    val fileManager = (PsiManager.getInstance(project) as PsiManagerEx).getFileManager()
+
     val stdLibViewProviders = HashSet<KotlinDecompiledFileViewProvider>()
     val vFileToViewProviderMap = ((PsiManager.getInstance(project) as PsiManagerEx).fileManager as FileManagerImpl).vFileToViewProviderMap
     for ((file, viewProvider) in vFileToViewProviderMap) {
@@ -94,11 +99,11 @@ public fun unInvalidateBuiltinsAndStdLib(project: Project, runnable: RunnableWit
 
     runnable.run()
 
-    // Base tearDown() invalidates builtins and std-lib files. Restore them with brute force.
+    // Restore mapping between PsiFiles and VirtualFiles dropped in FileManager.cleanupForNextTest(),
+    // otherwise built-ins psi elements will become invalid in next test.
     fun unInvalidateFile(file: PsiFileImpl) {
-        val field = javaClass<PsiFileImpl>().getDeclaredField("myInvalidated")!!
-        field.setAccessible(true)
-        field.set(file, false)
+        val provider = file.getViewProvider();
+        fileManager.setViewProvider(provider.getVirtualFile(), provider);
     }
 
     stdLibViewProviders.forEach {

idea/src/META-INF/gradle.xml

@@ -3,7 +3,9 @@
     <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinAndroidGradleModuleConfigurator"/>
     <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleModuleConfigurator"/>
   </extensions>
+  <!--
   <extensions defaultExtensionNs="org.jetbrains.plugins.gradle">
       <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJavaFrameworkSupportProvider"/>
   </extensions>
+  -->
 </idea-plugin>

idea/src/META-INF/plugin.xml

@@ -6,7 +6,7 @@
   <version>@snapshot@</version>
   <vendor url="http://www.jetbrains.com">JetBrains s.r.o.</vendor>
 
-  <idea-version since-build="143.379.11" until-build="144.9999"/>
+  <idea-version since-build="141.1009.5" until-build="141.9999999"/>
 
   <depends optional="true" config-file="junit.xml">JUnit</depends>
   <depends optional="true" config-file="gradle.xml">org.jetbrains.plugins.gradle</depends>
@@ -501,17 +501,12 @@
     <debuggerClassFilterProvider implementation="org.jetbrains.kotlin.idea.debugger.filter.KotlinDebuggerInternalClassesFilterProvider"/>
     <debugger.nodeRenderer implementation="org.jetbrains.kotlin.idea.debugger.render.KotlinClassWithDelegatedPropertyRenderer"/>
     <debugger.sourcePositionProvider implementation="org.jetbrains.kotlin.idea.debugger.KotlinSourcePositionProvider"/>
-    <debugger.sourcePositionHighlighter implementation="org.jetbrains.kotlin.idea.debugger.KotlinSourcePositionHighlighter"/>
     <debugger.frameExtraVarsProvider implementation="org.jetbrains.kotlin.idea.debugger.KotlinFrameExtraVariablesProvider"/>
     <debugger.extraSteppingFilter implementation="org.jetbrains.kotlin.idea.ExtraSteppingFilter"/>
     <xdebugger.settings implementation="org.jetbrains.kotlin.idea.debugger.KotlinDebuggerSettings"/>
     <xdebugger.breakpointType implementation="org.jetbrains.kotlin.idea.debugger.breakpoints.KotlinFieldBreakpointType"/>
-    <xdebugger.breakpointType implementation="org.jetbrains.kotlin.idea.debugger.breakpoints.KotlinLineBreakpointType" order="first"/>
     <debugger.syntheticProvider implementation="org.jetbrains.kotlin.idea.debugger.filter.KotlinSyntheticTypeComponentProvider"/>
-    <debugger.javaBreakpointHandlerFactory implementation="org.jetbrains.kotlin.idea.debugger.breakpoints.KotlinFieldBreakpointHandlerFactory"/>
-    <debugger.javaBreakpointHandlerFactory implementation="org.jetbrains.kotlin.idea.debugger.breakpoints.KotlinLineBreakpointHandlerFactory"/>
-    <debugger.jvmSteppingCommandProvider implementation="org.jetbrains.kotlin.idea.debugger.stepping.KotlinSteppingCommandProvider"/>
-    <debugger.simplePropertyGetterProvider implementation="org.jetbrains.kotlin.idea.debugger.stepping.KotlinSimpleGetterProvider"/>
+    <debugger.javaBreakpointHandlerFactory implementation="org.jetbrains.kotlin.idea.debugger.breakpoints.KotlinBreakpointHandlerFactory"/>
 
     <codeInsight.implementMethod language="kotlin" implementationClass="org.jetbrains.kotlin.idea.core.overrideImplement.ImplementMembersHandler"/>
     <codeInsight.overrideMethod language="kotlin" implementationClass="org.jetbrains.kotlin.idea.core.overrideImplement.OverrideMembersHandler"/>

idea/src/org/jetbrains/kotlin/idea/KotlinPluginUpdater.kt

@@ -95,7 +95,7 @@ class KotlinPluginUpdater(val propertiesComponent: PropertiesComponent) : Dispos
 
             for (host in RepositoryHelper.getPluginHosts().filterNotNull()) {
                 val plugins = try {
-                    RepositoryHelper.loadPlugins(host, null)
+                    RepositoryHelper.loadPlugins(host, null, null)
                 }
                 catch(e: Exception) {
                     LOG.info("Checking custom plugin reposityory $host failed", e)

idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt

@@ -62,7 +62,7 @@ public class ShowExpressionTypeAction : AnAction() {
         }
 
         if (type != null) {
-            HintManager.getInstance().showInformationHint(editor, renderTypeHint(type))
+            HintManager.getInstance().showInformationHint(editor, "<html>" + DescriptorRenderer.HTML.renderType(type) + "</html>")
         }
     }
 

idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateActionBase.kt

@@ -18,9 +18,6 @@ package org.jetbrains.kotlin.idea.actions.generate
 
 import com.intellij.codeInsight.CodeInsightActionHandler
 import com.intellij.codeInsight.actions.CodeInsightAction
-import com.intellij.lang.ContextAwareActionHandler
-import com.intellij.openapi.actionSystem.DataContext
-import com.intellij.openapi.actionSystem.Presentation
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
@@ -30,21 +27,6 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
 abstract class KotlinGenerateActionBase() : CodeInsightAction(), CodeInsightActionHandler {
-    override fun update(
-            presentation: Presentation,
-            project: Project,
-            editor: Editor,
-            file: PsiFile,
-            dataContext: DataContext,
-            actionPlace: String?
-    ) {
-        super.update(presentation, project, editor, file, dataContext, actionPlace)
-        val actionHandler = handler
-        if (actionHandler is ContextAwareActionHandler && presentation.isEnabled) {
-            presentation.isEnabled = actionHandler.isAvailableForQuickList(editor, file, dataContext)
-        }
-    }
-
     override fun isValidForFile(project: Project, editor: Editor, file: PsiFile): Boolean {
         if (file !is KtFile || file.isCompiled) return false
 

idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinExpressionTypeProvider.kt

@@ -1,41 +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.idea.codeInsight
-
-import com.intellij.lang.ExpressionTypeProvider
-import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.idea.actions.ShowExpressionTypeAction
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.psi.KtFunction
-import org.jetbrains.kotlin.psi.KtStatementExpression
-import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
-
-class KotlinExpressionTypeProvider : ExpressionTypeProvider<KtExpression>() {
-    override fun getExpressionsAt(elementAt: PsiElement): List<KtExpression> =
-            elementAt.parentsWithSelf.filterIsInstance<KtExpression>().filterNot { it.shouldSkip() }.toArrayList()
-
-    private fun KtExpression.shouldSkip(): Boolean {
-        return this is KtStatementExpression && this !is KtFunction
-    }
-
-    override fun getInformationHint(element: KtExpression): String {
-        val type = ShowExpressionTypeAction.typeByExpression(element) ?: return "Type is unknown"
-        return ShowExpressionTypeAction.renderTypeHint(type)
-    }
-
-    override fun getErrorHint(): String = "No expression found"
-}

idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java

@@ -40,18 +40,25 @@ public class KotlinParenthesesSurrounder extends KotlinExpressionSurrounder {
 
     @Nullable
     @Override
-    public TextRange surroundExpression( @NotNull Project project, @NotNull Editor editor, @NotNull KtExpression expression) {
-        KtParenthesizedExpression parenthesizedExpression = (KtParenthesizedExpression) KtPsiFactoryKt
-                .KtPsiFactory(expression).createExpression("(a)");
-        KtExpression expressionWithoutParentheses = parenthesizedExpression.getExpression();
-        assert expressionWithoutParentheses != null : "JetExpression should exists for " + parenthesizedExpression.getText() + " expression";
-        expressionWithoutParentheses.replace(expression);
-
-        expression = (KtExpression) expression.replace(parenthesizedExpression);
+    public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull KtExpression expression) {
+        expression = surroundWithParentheses(expression);
 
         CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(expression);
 
         int offset = expression.getTextRange().getEndOffset();
         return new TextRange(offset, offset);
     }
+
+    @NotNull
+    public static KtExpression surroundWithParentheses(@NotNull KtExpression expression) {
+        KtParenthesizedExpression parenthesizedExpression =
+                (KtParenthesizedExpression) KtPsiFactoryKt.KtPsiFactory(expression).createExpression("(a)");
+
+        KtExpression expressionWithoutParentheses = parenthesizedExpression.getExpression();
+        assert expressionWithoutParentheses != null : "JetExpression should exists for " + parenthesizedExpression.getText() + " expression";
+        expressionWithoutParentheses.replace(expression);
+
+        expression = (KtExpression) expression.replace(parenthesizedExpression);
+        return expression;
+    }
 }

idea/src/org/jetbrains/kotlin/idea/configuration/GradleKotlinJavaFrameworkSupportProvider.kt

@@ -27,6 +27,7 @@ import org.jetbrains.plugins.gradle.frameworkSupport.BuildScriptDataBuilder
 import org.jetbrains.plugins.gradle.frameworkSupport.GradleFrameworkSupportProvider
 import javax.swing.Icon
 
+/*
 public class GradleKotlinJavaFrameworkSupportProvider() : GradleFrameworkSupportProvider() {
     override fun getFrameworkType(): FrameworkTypeEx = object : FrameworkTypeEx("KOTLIN") {
         override fun getIcon(): Icon = KotlinIcons.FILE
@@ -60,3 +61,4 @@ public class GradleKotlinJavaFrameworkSupportProvider() : GradleFrameworkSupport
                 .addBuildscriptDependencyNotation(KotlinWithGradleConfigurator.CLASSPATH.replace("\$kotlin_version", kotlinVersion))
     }
 }
+*/

idea/src/org/jetbrains/kotlin/idea/configuration/KotlinMavenImporter.kt

@@ -16,11 +16,14 @@
 
 package org.jetbrains.kotlin.idea.configuration
 
-import com.intellij.openapi.components.*
-import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider
+import com.intellij.openapi.components.PersistentStateComponent
+import com.intellij.openapi.components.State
+import com.intellij.openapi.components.Storage
+import com.intellij.openapi.components.StoragePathMacros
 import com.intellij.openapi.module.Module
 import org.jdom.Element
 import org.jetbrains.idea.maven.importing.MavenImporter
+import org.jetbrains.idea.maven.importing.MavenModifiableModelsProvider
 import org.jetbrains.idea.maven.importing.MavenRootModelAdapter
 import org.jetbrains.idea.maven.model.MavenPlugin
 import org.jetbrains.idea.maven.project.MavenProject
@@ -37,10 +40,10 @@ private val KotlinPluginArtifactId = "kotlin-maven-plugin"
 private val KotlinPluginSourceDirsConfig = "sourceDirs"
 
 class KotlinMavenImporter : MavenImporter(KotlinPluginGroupId, KotlinPluginArtifactId) {
-    override fun preProcess(module: Module, mavenProject: MavenProject, changes: MavenProjectChanges, modifiableModelsProvider: IdeModifiableModelsProvider) {
+    override fun preProcess(module: Module, mavenProject: MavenProject, changes: MavenProjectChanges, modifiableModelsProvider: MavenModifiableModelsProvider) {
     }
 
-    override fun process(modifiableModelsProvider: IdeModifiableModelsProvider,
+    override fun process(modifiableModelsProvider: MavenModifiableModelsProvider,
                          module: Module,
                          rootModel: MavenRootModelAdapter,
                          mavenModel: MavenProjectsTree,

idea/src/org/jetbrains/kotlin/idea/configuration/KotlinWithGradleConfigurator.java

@@ -22,6 +22,7 @@ import com.intellij.openapi.application.Result;
 import com.intellij.openapi.command.WriteCommandAction;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.DependencyScope;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -33,6 +34,7 @@ import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.idea.KotlinPluginUtil;
 import org.jetbrains.kotlin.idea.framework.ui.ConfigureDialogWithModulesAndVersion;
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
 import org.jetbrains.plugins.gradle.util.GradleConstants;
@@ -104,6 +106,83 @@ public abstract class KotlinWithGradleConfigurator implements KotlinProjectConfi
         }
     }
 
+    public static void addKotlinLibraryToModule(final Module module, final DependencyScope scope, final String groupId, final String artifactId, final String version) {
+        String gradleFilePath = getDefaultPathToBuildGradleFile(module);
+        final GroovyFile gradleFile = getBuildGradleFile(module.getProject(), gradleFilePath);
+
+        if (gradleFile != null && canConfigureFile(gradleFile)) {
+            new WriteCommandAction(gradleFile.getProject()) {
+                @Override
+                protected void run(@NotNull Result result) {
+                    String groovyScope;
+                    switch (scope) {
+                        case COMPILE:
+                            groovyScope = "compile";
+                            break;
+                        case TEST:
+                            if (KotlinPluginUtil.isAndroidGradleModule(module)) {
+                                // TODO we should add testCompile or androidTestCompile
+                                groovyScope = "compile";
+                            }
+                            else {
+                                groovyScope = "testCompile";
+                            }
+                            break;
+                        case RUNTIME:
+                            groovyScope = "runtime";
+                            break;
+                        case PROVIDED:
+                            groovyScope = "compile";
+                            break;
+                        default:
+                            groovyScope = "compile";
+                    }
+
+                    String dependencyString = String.format(
+                            "%s \"%s:%s:%s\"",
+                            groovyScope, groupId, artifactId, version);
+
+                    GrClosableBlock dependenciesBlock = getDependenciesBlock(gradleFile);
+                    addLastExpressionInBlockIfNeeded(dependencyString, dependenciesBlock);
+
+                    CodeInsightUtilCore.forcePsiPostprocessAndRestoreElement(gradleFile);
+                }
+            }.execute();
+
+            VirtualFile virtualFile = gradleFile.getVirtualFile();
+            if (virtualFile != null) {
+                showInfoNotification(gradleFile.getProject(), virtualFile.getPath() + " was modified");
+            }
+        }
+    }
+
+    @Nullable
+    public static String getKotlinStdlibVersion(@NotNull Module module) {
+        String gradleFilePath = getDefaultPathToBuildGradleFile(module);
+        GroovyFile gradleFile = getBuildGradleFile(module.getProject(), gradleFilePath);
+
+        if (gradleFile == null) return null;
+
+        String versionProperty = "$kotlin_version";
+        GrClosableBlock block = getBuildScriptBlock(gradleFile);
+        if (block.getText().contains("ext.kotlin_version = ")) {
+            return versionProperty;
+        }
+
+        GrStatement[] dependencies = getDependenciesBlock(gradleFile).getStatements();
+        String stdlibArtifactPrefix = "org.jetbrains.kotlin:kotlin-stdlib:";
+        for (GrStatement dependency : dependencies) {
+            String dependencyText = dependency.getText();
+            int startIndex = dependencyText.indexOf(stdlibArtifactPrefix) + stdlibArtifactPrefix.length();
+            int endIndex = dependencyText.length() - 1;
+            if (startIndex != -1 && endIndex != -1) {
+                return dependencyText.substring(startIndex, endIndex);
+            }
+        }
+
+        return null;
+    }
+
     private void addElements(@NotNull GroovyFile file, @NotNull String version) {
         GrClosableBlock buildScriptBlock = getBuildScriptBlock(file);
         addFirstExpressionInBlockIfNeeded(VERSION.replace(VERSION_TEMPLATE, version), buildScriptBlock);
@@ -180,7 +259,7 @@ public abstract class KotlinWithGradleConfigurator implements KotlinProjectConfi
     protected void changeGradleFile(@NotNull final GroovyFile groovyFile, @NotNull final String version) {
         new WriteCommandAction(groovyFile.getProject()) {
             @Override
-            protected void run(Result result) {
+            protected void run(@NotNull Result result) {
                 addElements(groovyFile, version);
 
                 CodeInsightUtilCore.forcePsiPostprocessAndRestoreElement(groovyFile);
@@ -258,7 +337,6 @@ public abstract class KotlinWithGradleConfigurator implements KotlinProjectConfi
         if (allExpressions != null) {
             for (GrMethodCallExpression expression : allExpressions) {
                 GrExpression invokedExpression = expression.getInvokedExpression();
-                if (invokedExpression == null) continue;
                 if (expression.getClosureArguments().length == 0) continue;
 
                 String expressionText = invokedExpression.getText();
@@ -293,7 +371,7 @@ public abstract class KotlinWithGradleConfigurator implements KotlinProjectConfi
         if (applyStatement == null) return null;
         for (GrApplicationStatement callExpression : applyStatement) {
             GrExpression invokedExpression = callExpression.getInvokedExpression();
-            if (invokedExpression != null && invokedExpression.getText().equals("apply")) {
+            if (invokedExpression.getText().equals("apply")) {
                 return callExpression;
             }
         }