update kotlin javascript stdlib if needed

compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java

@@ -215,7 +215,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
 
         List<String> libraryFiles = new SmartList<String>();
         if (!arguments.noStdlib) {
-            libraryFiles.add(0, PathUtil.getKotlinPathsForCompiler().getJsLibJarPath().getAbsolutePath());
+            libraryFiles.add(0, PathUtil.getKotlinPathsForCompiler().getJsStdLibJarPath().getAbsolutePath());
         }
 
         if (arguments.libraryFiles != null) {

compiler/util/src/org/jetbrains/jet/utils/KotlinPaths.java

@@ -40,5 +40,8 @@ public interface KotlinPaths {
     File getAndroidSdkAnnotationsPath();
 
     @NotNull
-    File getJsLibJarPath();
+    File getJsStdLibJarPath();
+
+    @NotNull
+    File getJsStdLibSrcJarPath();
 }

compiler/util/src/org/jetbrains/jet/utils/KotlinPathsFromHomeDir.java

@@ -66,10 +66,16 @@ public class KotlinPathsFromHomeDir implements KotlinPaths {
 
     @Override
     @NotNull
-    public File getJsLibJarPath() {
+    public File getJsStdLibJarPath() {
         return getLibraryFile(PathUtil.JS_LIB_JAR_NAME);
     }
 
+    @Override
+    @NotNull
+    public File getJsStdLibSrcJarPath() {
+        return getLibraryFile(PathUtil.JS_LIB_SRC_JAR_NAME);
+    }
+
     @NotNull
     private File getLibraryFile(@NotNull String fileName) {
         return new File(getLibPath(), fileName);

compiler/util/src/org/jetbrains/jet/utils/LibraryUtils.java

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.utils;
 
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -24,6 +25,7 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.List;
 import java.util.Properties;
 import java.util.jar.Attributes;
 import java.util.jar.JarFile;
@@ -147,4 +149,14 @@ public class LibraryUtils {
     public static boolean isJvmRuntimeLibrary(@NotNull File library) {
         return checkImplTitle(library, TITLE_KOTLIN_JVM_RUNTIME_AND_STDLIB);
     }
+
+    public static VirtualFile getJarFile(@NotNull List<VirtualFile> classesRoots, @NotNull String jarName) {
+        for (VirtualFile root : classesRoots) {
+            if (root.getName().equals(jarName)) {
+                return root;
+            }
+        }
+
+        return null;
+    }
 }

idea/idea-analysis/src/org/jetbrains/jet/plugin/framework/JavaRuntimeDetectionUtil.java

@@ -21,6 +21,7 @@ import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.utils.LibraryUtils;
 import org.jetbrains.jet.utils.PathUtil;
 
 import java.util.List;
@@ -38,16 +39,6 @@ public class JavaRuntimeDetectionUtil {
 
     @Nullable
     public static VirtualFile getRuntimeJar(@NotNull List<VirtualFile> classesRoots) {
-        return getJarFile(classesRoots, PathUtil.KOTLIN_JAVA_RUNTIME_JAR);
+        return LibraryUtils.getJarFile(classesRoots, PathUtil.KOTLIN_JAVA_RUNTIME_JAR);
-    }
-
-    static VirtualFile getJarFile(@NotNull List<VirtualFile> classesRoots, @NotNull String jarName) {
-        for (VirtualFile root : classesRoots) {
-            if (root.getName().equals(jarName)) {
-                return root;
-            }
-        }
-
-        return null;
     }
 }

idea/idea-analysis/src/org/jetbrains/jet/plugin/framework/JsLibraryStdDetectionUtil.java

@@ -21,6 +21,7 @@ import com.intellij.openapi.vfs.StandardFileSystems;
 import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.utils.LibraryUtils;
 
 import java.io.File;
@@ -34,6 +35,16 @@ public class JsLibraryStdDetectionUtil {
             return null;
         }
 
+        VirtualFile jar = getJsStdLibJar(classesRoots);
+        if (jar == null) return null;
+
+        assert JsHeaderLibraryDetectionUtil.isJsHeaderLibraryDetected(classesRoots) : "StdLib should also be detected as headers library";
+
+        return JarUtil.getJarAttribute(VfsUtilCore.virtualToIoFile(jar), Attributes.Name.IMPLEMENTATION_VERSION);
+    }
+
+    @Nullable
+    public static VirtualFile getJsStdLibJar(@NotNull List<VirtualFile> classesRoots) {
         for (VirtualFile root : classesRoots) {
             if (root.getFileSystem().getProtocol() != StandardFileSystems.JAR_PROTOCOL) continue;
 
@@ -41,13 +52,10 @@ public class JsLibraryStdDetectionUtil {
             assert jar != null;
 
             if (LibraryUtils.isKotlinJavascriptStdLibrary(new File(jar.getPath()))) {
-                assert JsHeaderLibraryDetectionUtil.isJsHeaderLibraryDetected(classesRoots) : "StdLib should also be detected as headers library";
+                return jar;
-
-                return JarUtil.getJarAttribute(VfsUtilCore.virtualToIoFile(root), Attributes.Name.IMPLEMENTATION_VERSION);
             }
         }
 
         return null;
-
     }
 }

idea/src/org/jetbrains/jet/plugin/configuration/KotlinJsModuleConfigurator.java

@@ -78,12 +78,12 @@ public class KotlinJsModuleConfigurator extends KotlinWithLibraryConfigurator {
     @NotNull
     @Override
     public File getExistedJarFile() {
-        return assertFileExists(PathUtil.getKotlinPathsForIdeaPlugin().getJsLibJarPath());
+        return assertFileExists(PathUtil.getKotlinPathsForIdeaPlugin().getJsStdLibJarPath());
     }
 
     @Override
     public File getExistedSourcesJarFile() {
-        return getExistedJarFile();
+        return assertFileExists(PathUtil.getKotlinPathsForIdeaPlugin().getJsStdLibSrcJarPath());
     }
 
     @Override

idea/src/org/jetbrains/jet/plugin/framework/JSLibraryStdDescription.java

@@ -87,6 +87,6 @@ public class JSLibraryStdDescription extends CustomLibraryDescriptorWithDefferCo
         KotlinJsModuleConfigurator configurator = (KotlinJsModuleConfigurator) getConfiguratorByName(NAME);
         assert configurator != null : "Cannot find configurator with name " + NAME;
 
-        return createConfiguration(configurator.getExistedJarFile(), configurator.getExistedJarFile());
+        return createConfiguration(configurator.getExistedJarFile(), configurator.getExistedSourcesJarFile());
     }
 }

idea/src/org/jetbrains/jet/plugin/framework/JSLibraryStdPresentationProvider.java

@@ -24,9 +24,11 @@ import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.plugin.JetIcons;
+import org.jetbrains.jet.utils.LibraryUtils;
 import org.jetbrains.jet.utils.PathUtil;
 
 import javax.swing.*;
+import java.util.Arrays;
 import java.util.List;
 
 public class JSLibraryStdPresentationProvider extends LibraryPresentationProvider<LibraryVersionProperties> {
@@ -65,4 +67,14 @@ public class JSLibraryStdPresentationProvider extends LibraryPresentationProvide
 
         return false;
     }
+
+    @Nullable
+    public static VirtualFile getJsStdLibJar(@NotNull Library library) {
+        return JsLibraryStdDetectionUtil.getJsStdLibJar(Arrays.asList(library.getFiles(OrderRootType.CLASSES)));
+    }
+
+    @Nullable
+    public static VirtualFile getJsStdLibSrcJar(@NotNull Library library) {
+        return LibraryUtils.getJarFile(Arrays.asList(library.getFiles(OrderRootType.SOURCES)), PathUtil.JS_LIB_SRC_JAR_NAME);
+    }
 }

idea/src/org/jetbrains/jet/plugin/framework/JavaRuntimePresentationProvider.java

@@ -24,6 +24,7 @@ import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.plugin.JetIcons;
+import org.jetbrains.jet.utils.LibraryUtils;
 import org.jetbrains.jet.utils.PathUtil;
 
 import javax.swing.*;
@@ -54,7 +55,7 @@ public class JavaRuntimePresentationProvider extends LibraryPresentationProvider
 
     @Nullable
     public static VirtualFile getRuntimeSrcJar(@NotNull List<VirtualFile> classesRoots) {
-        return JavaRuntimeDetectionUtil.getJarFile(classesRoots, PathUtil.KOTLIN_JAVA_RUNTIME_SRC_JAR);
+        return LibraryUtils.getJarFile(classesRoots, PathUtil.KOTLIN_JAVA_RUNTIME_SRC_JAR);
     }
 
     @Nullable

idea/src/org/jetbrains/jet/plugin/versions/KotlinRuntimeLibraryUtil.java

@@ -41,7 +41,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.java.AbiVersionUtil;
 import org.jetbrains.jet.plugin.configuration.ConfigureKotlinInProjectUtils;
 import org.jetbrains.jet.plugin.configuration.KotlinJavaModuleConfigurator;
+import org.jetbrains.jet.plugin.framework.JSLibraryStdPresentationProvider;
 import org.jetbrains.jet.plugin.framework.JavaRuntimePresentationProvider;
+import org.jetbrains.jet.plugin.framework.LibraryPresentationProviderUtil;
 import org.jetbrains.jet.utils.KotlinPaths;
 import org.jetbrains.jet.utils.PathUtil;
 
@@ -153,20 +155,30 @@ public class KotlinRuntimeLibraryUtil {
                 assert configurator != null : "Configurator with given name doesn't exists: " + KotlinJavaModuleConfigurator.NAME;
 
                 for (Library library : libraries) {
-                    updateJar(project, JavaRuntimePresentationProvider.getRuntimeJar(library), LibraryJarDescriptor.RUNTIME_JAR);
+                    if (LibraryPresentationProviderUtil.isDetected(JavaRuntimePresentationProvider.getInstance(), library)) {
+                        updateJar(project, JavaRuntimePresentationProvider.getRuntimeJar(library), LibraryJarDescriptor.RUNTIME_JAR);
 
-                    if (configurator.changeOldSourcesPathIfNeeded(library)) {
+                        if (configurator.changeOldSourcesPathIfNeeded(library)) {
-                        configurator.copySourcesToPathFromLibrary(library);
+                            configurator.copySourcesToPathFromLibrary(library);
+                        }
+                        else {
+                            updateJar(project, JavaRuntimePresentationProvider.getRuntimeSrcJar(library), LibraryJarDescriptor.RUNTIME_SRC_JAR);
+                        }
                     }
-                    else {
+                    else if (LibraryPresentationProviderUtil.isDetected(JSLibraryStdPresentationProvider.getInstance(), library)) {
-                        updateJar(project, JavaRuntimePresentationProvider.getRuntimeSrcJar(library), LibraryJarDescriptor.RUNTIME_SRC_JAR);
+                        updateJar(project, JSLibraryStdPresentationProvider.getJsStdLibJar(library), LibraryJarDescriptor.JS_STDLIB_JAR);
+                        updateJar(project, JSLibraryStdPresentationProvider.getJsStdLibSrcJar(library), LibraryJarDescriptor.JS_STDLIB_SRC_JAR);
                     }
                 }
             }
         });
     }
 
-    private static void updateJar(@NotNull Project project, @Nullable VirtualFile fileToReplace, @NotNull LibraryJarDescriptor libraryJarDescriptor) {
+    private static void updateJar(
+            @NotNull Project project,
+            @Nullable VirtualFile fileToReplace,
+            @NotNull LibraryJarDescriptor libraryJarDescriptor
+    ) {
         if (fileToReplace == null && !libraryJarDescriptor.shouldExists) {
             return;
         }
@@ -176,6 +188,8 @@ public class KotlinRuntimeLibraryUtil {
         switch (libraryJarDescriptor) {
             case RUNTIME_JAR: runtimePath = paths.getRuntimePath(); break;
             case RUNTIME_SRC_JAR: runtimePath = paths.getRuntimeSourcesPath(); break;
+            case JS_STDLIB_JAR: runtimePath = paths.getJsStdLibJarPath(); break;
+            case JS_STDLIB_SRC_JAR: runtimePath = paths.getJsStdLibSrcJarPath(); break;
         }
 
         if (!runtimePath.exists()) {
@@ -217,7 +231,9 @@ public class KotlinRuntimeLibraryUtil {
 
     private enum LibraryJarDescriptor {
         RUNTIME_JAR(PathUtil.KOTLIN_JAVA_RUNTIME_JAR, true),
-        RUNTIME_SRC_JAR(PathUtil.KOTLIN_JAVA_RUNTIME_SRC_JAR, false);
+        RUNTIME_SRC_JAR(PathUtil.KOTLIN_JAVA_RUNTIME_SRC_JAR, false),
+        JS_STDLIB_JAR(PathUtil.JS_LIB_JAR_NAME, true),
+        JS_STDLIB_SRC_JAR(PathUtil.JS_LIB_SRC_JAR_NAME, false);
 
         @NotNull public final String jarName;
         private final boolean shouldExists;

idea/src/org/jetbrains/jet/plugin/versions/KotlinUpdatePluginComponent.kt

@@ -51,7 +51,8 @@ class KotlinUpdatePluginComponent : ApplicationComponent {
             requestFullJarUpdate(ideaPluginPaths.getRuntimePath())
             requestFullJarUpdate(ideaPluginPaths.getRuntimeSourcesPath())
 
-            requestFullJarUpdate(ideaPluginPaths.getJsLibJarPath())
+            requestFullJarUpdate(ideaPluginPaths.getJsStdLibJarPath())
+            requestFullJarUpdate(ideaPluginPaths.getJsStdLibSrcJarPath())
 
             requestFullJarUpdate(ideaPluginPaths.getJdkAnnotationsPath())
             requestFullJarUpdate(ideaPluginPaths.getAndroidSdkAnnotationsPath())

idea/src/org/jetbrains/jet/plugin/versions/OutdatedKotlinRuntimeNotification.java

@@ -24,7 +24,6 @@ import com.intellij.notification.Notification;
 import com.intellij.notification.NotificationListener;
 import com.intellij.notification.NotificationType;
 import com.intellij.notification.Notifications;
-import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.libraries.Library;
@@ -37,6 +36,7 @@ import com.intellij.util.text.VersionComparatorUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.plugin.JetPluginUtil;
+import org.jetbrains.jet.plugin.framework.JSLibraryStdPresentationProvider;
 import org.jetbrains.jet.plugin.framework.JavaRuntimePresentationProvider;
 import org.jetbrains.jet.plugin.framework.LibraryPresentationProviderUtil;
 
@@ -155,12 +155,16 @@ public class OutdatedKotlinRuntimeNotification extends AbstractProjectComponent
         List<VersionedLibrary> outdatedLibraries = Lists.newArrayList();
 
         for (Library library : KotlinRuntimeLibraryUtil.findKotlinLibraries(project)) {
-            LibraryVersionProperties javaRuntimeProperties =
+            LibraryVersionProperties libraryVersionProperties =
                     LibraryPresentationProviderUtil.getLibraryProperties(JavaRuntimePresentationProvider.getInstance(), library);
-            if (javaRuntimeProperties == null) {
+            if (libraryVersionProperties == null) {
+                libraryVersionProperties =
+                        LibraryPresentationProviderUtil.getLibraryProperties(JSLibraryStdPresentationProvider.getInstance(), library);
+            }
+            if (libraryVersionProperties == null) {
                 continue;
             }
-            String libraryVersion = javaRuntimeProperties.getVersionString();
+            String libraryVersion = libraryVersionProperties.getVersionString();
 
             boolean isOutdated = "snapshot".equals(libraryVersion)
                                  || libraryVersion == null

idea/tests/org/jetbrains/jet/plugin/configuration/ConfigureKotlinTest.java

@@ -264,7 +264,7 @@ public class ConfigureKotlinTest extends PlatformTestCase {
     }
 
     private static String getPathToExistentJsJar() {
-        return PathUtil.getKotlinPathsForDistDirectory().getJsLibJarPath().getParent();
+        return PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath().getParent();
     }
 
     @Override

js/js.frontend/src/org/jetbrains/k2js/config/LibrarySourcesConfigWithCaching.java

@@ -39,7 +39,7 @@ import java.util.List;
 
 public class LibrarySourcesConfigWithCaching extends LibrarySourcesConfig {
     public static final List<String> JS_STDLIB =
-            Arrays.asList(PathUtil.getKotlinPathsForDistDirectory().getJsLibJarPath().getAbsolutePath());
+            Arrays.asList(PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath().getAbsolutePath());
 
     private static List<JetFile> jsLibFiles;
     private static AnalysisResult result;

libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt

@@ -138,8 +138,8 @@ class NoInternalVisibilityInStdLibTest {
             val configuration = CompilerConfiguration()
             val environment = JetCoreEnvironment.createForProduction(it, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
             val project = environment.getProject()
-            val pathToJsStdlibJar = KOTLIN_ROOT_PATH + PathUtil.getKotlinPathsForDistDirectory().getJsLibJarPath().path
+            val pathToJsStdlibJar = KOTLIN_ROOT_PATH + PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath().path
-            val config = LibrarySourcesConfig(project, "testModule", listOf("@", pathToJsStdlibJar), EcmaVersion.defaultVersion(), false, false)
+            val config = LibrarySourcesConfig(project, "testModule", listOf(pathToJsStdlibJar), EcmaVersion.defaultVersion(), false, false)
 
             TopDownAnalyzerFacadeForJS.analyzeFiles(listOf(), { true }, config).moduleDescriptor
         }