Stop using isJsProject method

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JavaElementFinder.java

@@ -31,10 +31,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.java.JavaPsiFacadeKotlinHacks;
 import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.util.QualifiedNamesUtil;
 
@@ -252,7 +252,7 @@ public class JavaElementFinder extends PsiElementFinder implements JavaPsiFacade
         
         if (cachedFiles == null) {
             cachedFiles = JetFilesProvider.getInstance(project).allInScope(scope);
-             jetFiles.put(scope, cachedFiles);
+            jetFiles.put(scope, cachedFiles);
         }
 
         return cachedFiles;

idea/src/org/jetbrains/jet/plugin/caches/JetCacheManager.java

@@ -20,6 +20,7 @@ import com.intellij.openapi.components.ProjectComponent;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.search.PsiShortNamesCache;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.project.JsModuleDetector;
 
 /**
@@ -67,8 +68,8 @@ public class JetCacheManager implements ProjectComponent {
         return myCache;
     }
 
-    public PsiShortNamesCache getShortNamesCache() {
-        if (JsModuleDetector.isJsProject(myProject)) {
+    public PsiShortNamesCache getShortNamesCache(@NotNull JetFile jetFile) {
+        if (JsModuleDetector.isJsModule(jetFile)) {
             return myCache;
         }
 

idea/src/org/jetbrains/jet/plugin/completion/JetClassCompletionContributor.java

@@ -94,7 +94,7 @@ public class JetClassCompletionContributor extends CompletionContributor {
             consumer.consume(DescriptorLookupConverter.createLookupElement(bindingContext, jetOnlyClass));
         }
 
-        if (!JsModuleDetector.isJsProject(parameters.getOriginalFile().getProject())) {
+        if (!JsModuleDetector.isJsModule((JetFile)parameters.getOriginalFile())) {
             JavaClassNameCompletionContributor.addAllClasses(
                     parameters,
                     false,
@@ -119,12 +119,14 @@ public class JetClassCompletionContributor extends CompletionContributor {
         }
         else {
             GlobalSearchScope globalSearchScope = GlobalSearchScope.allScope(parameters.getOriginalFile().getProject());
-            PsiShortNamesCache cache = JetCacheManager.getInstance(parameters.getOriginalFile().getProject()).getShortNamesCache();
+            PsiShortNamesCache cache = JetCacheManager.getInstance(parameters.getOriginalFile().getProject()).getShortNamesCache(
+                    (JetFile) parameters.getOriginalFile());
+
             for (String className : cache.getAllClassNames()) {
                 if (result.getPrefixMatcher().prefixMatches(className)) {
                     for (PsiClass aClass : cache.getClassesByName(className, globalSearchScope)) {
                         if (!addAsJetLookupElement(aClass, bindingContext, consumer)) {
-                            assert false;
+                            assert false : "All classes should be possible to add as kotlin classes in JS project";
                         }
                     }
                 }

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

@@ -20,9 +20,12 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ModuleRootManager;
+import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.psi.JetFile;
 
 /**
  * @author Pavel Talanov
@@ -41,6 +44,18 @@ public final class JsModuleDetector {
         return K2JSModuleComponent.getInstance(module).isJavaScriptModule();
     }
 
+    public static boolean isJsModule(@NotNull JetFile file) {
+        VirtualFile virtualFile = file.getOriginalFile().getVirtualFile();
+        if (virtualFile != null) {
+            Module module = ProjectRootManager.getInstance(file.getProject()).getFileIndex().getModuleForFile(virtualFile);
+            if (module != null) {
+                return isJsModule(module);
+            }
+        }
+
+        return false;
+    }
+
     @NotNull
     public static Pair<String, String> getLibLocationAndTargetForProject(@NotNull Project project) {
         Module module = getJSModule(project);

idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java

@@ -155,18 +155,16 @@ public class ImportClassAndFunFix extends JetHintAction<JetSimpleNameExpression>
         final GlobalSearchScope scope = GlobalSearchScope.allScope(file.getProject());
         Set<FqName> possibleResolveNames = Sets.newHashSet();
 
-        possibleResolveNames.addAll(getJavaClasses(referenceName, file.getProject(), scope));
+        possibleResolveNames.addAll(getClassesFromCache(referenceName, file));
 
         // TODO: Do appropriate sorting
         return Lists.newArrayList(possibleResolveNames);
     }
 
-    private static Collection<FqName> getJavaClasses(@NotNull final String typeName,
-            @NotNull Project project,
-            final GlobalSearchScope scope) {
-        PsiShortNamesCache cache = JetCacheManager.getInstance(project).getShortNamesCache();
+    private static Collection<FqName> getClassesFromCache(@NotNull final String typeName, @NotNull JetFile file) {
+        PsiShortNamesCache cache = JetCacheManager.getInstance(file.getProject()).getShortNamesCache(file);
 
-        PsiClass[] classes = cache.getClassesByName(typeName, scope);
+        PsiClass[] classes = cache.getClassesByName(typeName, GlobalSearchScope.allScope(file.getProject()));
 
         Collection<PsiClass> accessibleClasses = Collections2.filter(Lists.newArrayList(classes), new Predicate<PsiClass>() {
             @Override
@@ -190,7 +188,7 @@ public class ImportClassAndFunFix extends JetHintAction<JetSimpleNameExpression>
 
     private static boolean isAccessible(PsiMember member) {
         if (member instanceof JetLightClass) {
-            // TODO: Now light class can't losing accessibility information
+            // TODO: Now light classes losing accessibility information
             JetLightClass lightClass = (JetLightClass) member;
             BindingContext context = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile((JetFile) lightClass.getContainingFile()).getBindingContext();
             ClassDescriptor descriptor = context.get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, lightClass.getFqName());