Fix building JS module

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

@@ -1,41 +1,34 @@
 package org.jetbrains.jet.plugin.framework;
 
-import com.intellij.ProjectTopics;
+import com.google.common.collect.Lists;
-import com.intellij.openapi.application.*;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.module.ModuleUtilCore;
-import com.intellij.openapi.progress.ProcessCanceledException;
-import com.intellij.openapi.project.DumbService;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.*;
+import com.intellij.openapi.roots.ModuleRootManager;
+import com.intellij.openapi.roots.OrderRootType;
+import com.intellij.openapi.roots.ProjectRootModificationTracker;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.CachedValue;
 import com.intellij.psi.util.CachedValueProvider;
 import com.intellij.psi.util.CachedValuesManager;
-import com.intellij.psi.util.PsiModificationTracker;
-import com.intellij.ui.EditorNotifications;
-import com.intellij.util.Alarm;
 import com.intellij.util.Processor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.plugin.util.ApplicationUtils;
-import org.jetbrains.jet.plugin.versions.KotlinLibrariesNotificationProvider;
 import org.jetbrains.jet.plugin.versions.KotlinRuntimeLibraryUtil;
-import org.jetbrains.jet.utils.KotlinPathsFromHomeDir;
 import org.jetbrains.jet.utils.PathUtil;
+import org.jetbrains.k2js.config.EcmaVersion;
 
-import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
 
 public class KotlinFrameworkDetector {
     private static final Key<CachedValue<Boolean>> IS_KOTLIN_JS_MODULE = Key.create("IS_KOTLIN_JS_MODULE");
@@ -67,36 +60,13 @@ public class KotlinFrameworkDetector {
         return result.getValue();
     }
 
-    private static Boolean checkModuleHasJavaScriptLibrary(final Module module) {
-        final Ref<Boolean> found = Ref.create(Boolean.FALSE);
-
-        ApplicationManager.getApplication().runReadAction(new Runnable() {
-            @Override
-            public void run() {
-                ModuleRootManager.getInstance(module).orderEntries().librariesOnly().forEachLibrary(new Processor<Library>() {
-                    @Override
-                    public boolean process(Library library) {
-                        String libraryName = library.getName();
-                        if (libraryName != null && libraryName.contains(PathUtil.JS_LIB_JAR_NAME)) {
-                            found.set(Boolean.TRUE);
-                            return false;
-                        }
-                        return true;
-                    }
-                });
-            }
-        });
-
-        return found.get();
-    }
-
     public static boolean isJsModule(@NotNull final Module module) {
         CachedValue<Boolean> result = module.getUserData(IS_KOTLIN_JS_MODULE);
         if (result == null) {
             result = CachedValuesManager.getManager(module.getProject()).createCachedValue(new CachedValueProvider<Boolean>() {
                 @Override
                 public Result<Boolean> compute() {
-                    return Result.create(checkModuleHasJavaScriptLibrary(module),
+                    return Result.create(getStandardJavaScriptLibrary(module) != null,
                                          ProjectRootModificationTracker.getInstance(module.getProject()));
                 }
             }, false);
@@ -107,7 +77,72 @@ public class KotlinFrameworkDetector {
         return result.getValue();
     }
 
+    @NotNull
+    private static Collection<Library> getJavaScriptHeadersLibraries(final Module module) {
+        final Collection<Library> headersLibraries = Lists.newArrayList();
+
+        ApplicationManager.getApplication().runReadAction(new Runnable() {
+            @Override
+            public void run() {
+                ModuleRootManager.getInstance(module).orderEntries().librariesOnly().forEachLibrary(new Processor<Library>() {
+                    @Override
+                    public boolean process(Library library) {
+                        if (KotlinJavaScriptHeadersPresentationProvider.getInstance().detect(
+                                Arrays.asList(library.getFiles(OrderRootType.CLASSES))) != null) {
+                            headersLibraries.add(library);
+                        }
+
+                        return true;
+                    }
+                });
+            }
+        });
+
+        return headersLibraries;
+    }
+
+    @Nullable
+    private static Library getStandardJavaScriptLibrary(final Module module) {
+        return ApplicationManager.getApplication().runReadAction(new Computable<Library>() {
+            @Override
+            public Library compute() {
+                for (Library library : getJavaScriptHeadersLibraries(module)) {
+                    String libraryName = library.getName();
+                    if (libraryName != null && libraryName.contains(PathUtil.JS_LIB_JAR_NAME)) {
+                        return library;
+                    }
+                }
+                return null;
+            }
+        });
+    }
+
+    @NotNull
+    public static Pair<List<String>, String> getLibLocationAndTargetForProject(@NotNull Project project) {
+        Module[] modules = ModuleManager.getInstance(project).getModules();
+        for (Module module : modules) {
+            if (isJsModule(module)) {
+                return getLibLocationAndTargetForProject(module);
+            }
+        }
+
+        return Pair.empty();
+    }
+
     public static Pair<List<String>, String> getLibLocationAndTargetForProject(Module module) {
-        return Pair.<List<String>, String>create(new ArrayList<String>(), "ecma3");
+        Library library = getStandardJavaScriptLibrary(module);
+
+        if (library != null) {
+            List<String> pathsToJSLib = Lists.newArrayList();
+            VirtualFile[] files = library.getRootProvider().getFiles(OrderRootType.SOURCES);
+            for (VirtualFile file : files) {
+                pathsToJSLib.add(com.intellij.util.PathUtil.getLocalPath(file));
+            }
+
+            return Pair.create(pathsToJSLib, EcmaVersion.defaultVersion().toString());
+        }
+        else {
+            throw new IllegalStateException("Should be called for JS module only. JS library is expected to be found");
+        }
     }
 }

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

@@ -17,9 +17,7 @@
 package org.jetbrains.jet.plugin.framework;
 
 import com.intellij.framework.library.LibraryVersionProperties;
-import com.intellij.openapi.roots.libraries.LibraryKind;
 import com.intellij.openapi.roots.libraries.LibraryPresentationProvider;
-import com.intellij.openapi.roots.libraries.LibraryProperties;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -30,6 +28,10 @@ import javax.swing.*;
 import java.util.List;
 
 public class KotlinJavaRuntimePresentationProvider extends LibraryPresentationProvider<LibraryVersionProperties> {
+    public static KotlinJavaRuntimePresentationProvider getInstance() {
+        return LibraryPresentationProvider.EP_NAME.findExtension(KotlinJavaRuntimePresentationProvider.class);
+    }
+
     protected KotlinJavaRuntimePresentationProvider() {
         super(JetJavaRuntimeLibraryDescription.KOTLIN_JAVA_RUNTIME_KIND);
     }

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

@@ -22,12 +22,15 @@ 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.PathUtil;
 
 import javax.swing.*;
 import java.util.List;
 
 public class KotlinJavaScriptHeadersPresentationProvider extends LibraryPresentationProvider<LibraryVersionProperties> {
+    public static KotlinJavaScriptHeadersPresentationProvider getInstance() {
+        return LibraryPresentationProvider.EP_NAME.findExtension(KotlinJavaScriptHeadersPresentationProvider.class);
+    }
+
     protected KotlinJavaScriptHeadersPresentationProvider() {
         super(JetJavaScriptLibraryDescription.KOTLIN_JAVASCRIPT_KIND);
     }

idea/src/org/jetbrains/jet/plugin/project/IDEAConfig.java

@@ -18,13 +18,12 @@ package org.jetbrains.jet.plugin.project;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.plugin.framework.KotlinFrameworkDetector;
 import org.jetbrains.k2js.config.EcmaVersion;
 import org.jetbrains.k2js.config.LibrarySourcesConfig;
 
-import java.util.ArrayList;
-
 public final class IDEAConfig extends LibrarySourcesConfig {
     public IDEAConfig(@NotNull Project project) {
-        super(project, "default", new ArrayList<String>(), EcmaVersion.defaultVersion());
+        super(project, "default", KotlinFrameworkDetector.getLibLocationAndTargetForProject(project).first, EcmaVersion.defaultVersion());
     }
 }