Converted JetShortNamesCache to Kotlin

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java

@@ -193,6 +193,7 @@ public class ExpressionTypingUtils {
      * @param scope
      * @return
      */
+    @NotNull
     public static List<CallableDescriptor> canFindSuitableCall(
             @NotNull FqName callableFQN,
             @NotNull JetExpression receiverExpression,

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java

@@ -57,6 +57,7 @@ public class JetFromJavaDescriptorHelper {
     /**
      * Get names that could have jet descriptor equivalents. It could be inaccurate and return more results than necessary.
      */
+    @NotNull
     static Collection<String> getPossiblePackageDeclarationsNames(Project project, GlobalSearchScope scope) {
         Collection<String> result = new ArrayList<String>();
 
@@ -71,6 +72,7 @@ public class JetFromJavaDescriptorHelper {
         return result;
     }
 
+    @NotNull
     static Collection<PsiClass> getCompiledClassesForTopLevelObjects(Project project, GlobalSearchScope scope) {
         Set<PsiClass> jetObjectClasses = Sets.newHashSet();
 

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java

@@ -1,431 +0,0 @@
-/*
- * Copyright 2010-2013 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.jet.plugin.caches;
-
-import com.google.common.base.Function;
-import com.google.common.collect.Collections2;
-import com.google.common.collect.Sets;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Condition;
-import com.intellij.psi.*;
-import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.psi.search.PsiShortNamesCache;
-import com.intellij.util.ArrayUtil;
-import com.intellij.util.Processor;
-import com.intellij.util.containers.ContainerUtil;
-import com.intellij.util.containers.HashSet;
-import com.intellij.util.containers.MultiMap;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.asJava.JavaElementFinder;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTraceContext;
-import org.jetbrains.jet.lang.resolve.ImportPath;
-import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
-import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
-import org.jetbrains.jet.plugin.caches.resolve.IDELightClassGenerationSupport;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
-import org.jetbrains.jet.plugin.stubindex.*;
-
-import java.util.*;
-
-/**
- * Will provide both java elements from kotlin context and some declarations special to kotlin.
- * All those declaration are planned to be used in completion.
- */
-public class JetShortNamesCache extends PsiShortNamesCache {
-
-    @NotNull
-    public static JetShortNamesCache getKotlinInstance(@NotNull Project project) {
-        PsiShortNamesCache[] extensions = Extensions.getArea(project).getExtensionPoint(PsiShortNamesCache.EP_NAME).getExtensions();
-        for (PsiShortNamesCache extension : extensions) {
-            if (extension instanceof JetShortNamesCache) {
-                return (JetShortNamesCache) extension;
-            }
-        }
-        throw new IllegalStateException(JetShortNamesCache.class.getSimpleName() + " is not found for project " + project);
-    }
-
-    private static final PsiMethod[] NO_METHODS = new PsiMethod[0];
-    private static final PsiField[] NO_FIELDS = new PsiField[0];
-    private final Project project;
-
-    public JetShortNamesCache(Project project) {
-        this.project = project;
-    }
-
-    /**
-     * Return kotlin class names from project sources which should be visible from java.
-     */
-    @NotNull
-    @Override
-    public String[] getAllClassNames() {
-        Collection<String> classNames = JetClassShortNameIndex.getInstance().getAllKeys(project);
-
-        // package classes can not be indexed, since they have no explicit declarations
-        IDELightClassGenerationSupport lightClassGenerationSupport = IDELightClassGenerationSupport.getInstanceForIDE(project);
-        Set<String> packageClassShortNames =
-                lightClassGenerationSupport.getAllPossiblePackageClasses(GlobalSearchScope.allScope(project)).keySet();
-        classNames.addAll(packageClassShortNames);
-
-        return ArrayUtil.toStringArray(classNames);
-    }
-
-    /**
-     * Return class names form kotlin sources in given scope which should be visible as Java classes.
-     */
-    @NotNull
-    @Override
-    public PsiClass[] getClassesByName(@NotNull @NonNls String name, @NotNull GlobalSearchScope scope) {
-        List<PsiClass> result = new ArrayList<PsiClass>();
-
-        IDELightClassGenerationSupport lightClassGenerationSupport = IDELightClassGenerationSupport.getInstanceForIDE(project);
-        MultiMap<String, FqName> packageClasses = lightClassGenerationSupport.getAllPossiblePackageClasses(scope);
-
-        // package classes can not be indexed, since they have no explicit declarations
-        Collection<FqName> fqNames = packageClasses.get(name);
-        if (!fqNames.isEmpty()) {
-            for (FqName fqName : fqNames) {
-                PsiClass psiClass = JavaElementFinder.getInstance(project).findClass(fqName.asString(), scope);
-                if (psiClass != null) {
-                    result.add(psiClass);
-                }
-            }
-        }
-
-        // Quick check for classes from getAllClassNames()
-        Collection<JetClassOrObject> classOrObjects = JetClassShortNameIndex.getInstance().get(name, project, scope);
-        if (classOrObjects.isEmpty()) {
-            return result.toArray(new PsiClass[result.size()]);
-        }
-
-        for (JetClassOrObject classOrObject : classOrObjects) {
-            FqName fqName = classOrObject.getFqName();
-            if (fqName != null) {
-                assert fqName.shortName().asString().equals(name) : "A declaration obtained from index has non-matching name:\n" +
-                                                                    "in index: " + name + "\n" +
-                                                                    "declared: " + fqName.shortName() + "(" + fqName + ")";
-                PsiClass psiClass = JavaElementFinder.getInstance(project).findClass(fqName.asString(), scope);
-                if (psiClass != null) {
-                    result.add(psiClass);
-                }
-            }
-        }
-
-        return result.toArray(new PsiClass[result.size()]);
-    }
-
-    @Override
-    public void getAllClassNames(@NotNull HashSet<String> destination) {
-        destination.addAll(Arrays.asList(getAllClassNames()));
-    }
-
-    /**
-     * Get kotlin non-extension top-level function names. Method is allowed to give invalid names - all result should be
-     * checked with getTopLevelFunctionDescriptorsByName().
-     */
-    @NotNull
-    public Collection<String> getAllTopLevelFunctionNames() {
-        Set<String> functionNames = new HashSet<String>();
-        functionNames.addAll(JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().getAllKeys(project));
-        functionNames.addAll(JetFromJavaDescriptorHelper.getPossiblePackageDeclarationsNames(project, GlobalSearchScope.allScope(project)));
-        return functionNames;
-    }
-
-    @NotNull
-    public Collection<String> getAllTopLevelObjectNames() {
-        Set<String> topObjectNames = new HashSet<String>();
-        topObjectNames.addAll(JetTopLevelObjectShortNameIndex.getInstance().getAllKeys(project));
-
-        Collection<PsiClass> classObjects =
-                JetFromJavaDescriptorHelper.getCompiledClassesForTopLevelObjects(project, GlobalSearchScope.allScope(project));
-        topObjectNames.addAll(Collections2.transform(classObjects, new Function<PsiClass, String>() {
-            @Override
-            public String apply(@Nullable PsiClass aClass) {
-                assert aClass != null;
-                return aClass.getName();
-            }
-        }));
-
-        return topObjectNames;
-    }
-
-    @NotNull
-    public Collection<ClassDescriptor> getTopLevelObjectsByName(
-            @NotNull String name,
-            @NotNull JetSimpleNameExpression expression,
-            @NotNull ResolveSessionForBodies resolveSession,
-            @NotNull GlobalSearchScope scope
-    ) {
-        BindingContext context = resolveSession.resolveToElement(expression);
-        JetScope jetScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
-
-        if (jetScope == null) {
-            return Collections.emptyList();
-        }
-
-        Set<ClassDescriptor> result = Sets.newHashSet();
-
-        Collection<JetObjectDeclaration> topObjects = JetTopLevelObjectShortNameIndex.getInstance().get(name, project, scope);
-        for (JetObjectDeclaration objectDeclaration : topObjects) {
-            FqName fqName = objectDeclaration.getFqName();
-            assert fqName != null : "Local object declaration in JetTopLevelShortObjectNameIndex:" + objectDeclaration.getText();
-            result.addAll(ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, fqName, ResolveSessionUtils.SINGLETON_FILTER));
-        }
-
-        for (PsiClass psiClass : JetFromJavaDescriptorHelper
-                .getCompiledClassesForTopLevelObjects(project, GlobalSearchScope.allScope(project))) {
-            String qualifiedName = psiClass.getQualifiedName();
-            if (qualifiedName != null) {
-                FqName fqName = new FqName(qualifiedName);
-                result.addAll(ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, fqName, ResolveSessionUtils.SINGLETON_FILTER));
-            }
-        }
-
-        return result;
-    }
-
-    @NotNull
-    public Collection<FunctionDescriptor> getTopLevelFunctionDescriptorsByName(
-            @NotNull String name,
-            @NotNull JetExpression context /*TODO: to be dropped*/,
-            @NotNull ResolveSessionForBodies resolveSession,
-            @NotNull GlobalSearchScope scope) {
-
-        JetScope jetScope = resolveSession.resolveToElement(context).get(BindingContext.RESOLUTION_SCOPE, context);
-        if (jetScope == null) {
-            return Collections.emptyList();
-        }
-
-        Set<FunctionDescriptor> result = Sets.newHashSet();
-
-        //TODO: this code is temporary and is to be dropped when compiled top level functions are indexed
-        final Name identifier = Name.identifier(name);
-        Collection<FqName> topLevelFunctionFqNames =
-                ContainerUtil.filter(JetFromJavaDescriptorHelper.getTopLevelFunctionFqNames(project, scope, false), new Condition<FqName>() {
-                    @Override
-                    public boolean value(FqName fqName) {
-                        return fqName.lastSegmentIs(identifier);
-                    }
-                });
-        for (FqName fqName : topLevelFunctionFqNames) {
-            JetImportDirective importDirective = new JetPsiFactory(context.getProject()).createImportDirective(new ImportPath(fqName, false));
-            Collection<? extends DeclarationDescriptor> declarationDescriptors = new QualifiedExpressionResolver().analyseImportReference(
-                    importDirective, jetScope, new BindingTraceContext(), resolveSession.getModuleDescriptor());
-            for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) {
-                if (declarationDescriptor instanceof FunctionDescriptor) {
-                    result.add((FunctionDescriptor) declarationDescriptor);
-                }
-            }
-        }
-
-        Set<FqName> affectedPackages = Sets.newHashSet();
-        Collection<JetNamedFunction> jetNamedFunctions = JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().get(name, project, scope);
-        for (JetNamedFunction jetNamedFunction : jetNamedFunctions) {
-            PsiFile containingFile = jetNamedFunction.getContainingFile();
-            if (containingFile instanceof JetFile) {
-                JetFile jetFile = (JetFile) containingFile;
-                affectedPackages.add(jetFile.getPackageFqName());
-            }
-        }
-
-        for (FqName affectedPackage : affectedPackages) {
-            PackageViewDescriptor packageDescriptor = resolveSession.getModuleDescriptor().getPackage(affectedPackage);
-            assert packageDescriptor != null : "There's a function in stub index with invalid package: " + affectedPackage;
-            JetScope memberScope = packageDescriptor.getMemberScope();
-            result.addAll(memberScope.getFunctions(identifier));
-        }
-
-        return result;
-    }
-
-    private Collection<PsiElement> getJetExtensionFunctionsByName(@NotNull String name, @NotNull GlobalSearchScope scope) {
-        HashSet<PsiElement> functions = new HashSet<PsiElement>();
-        functions.addAll(JetTopLevelExtensionFunctionShortNameIndex.getInstance().get(name, project, scope));
-
-        return functions;
-    }
-
-    // TODO: Make it work for properties
-    @NotNull
-    public Collection<DeclarationDescriptor> getJetCallableExtensions(
-            @NotNull final Condition<String> acceptedNameCondition,
-            @NotNull JetSimpleNameExpression expression,
-            @NotNull ResolveSessionForBodies resolveSession,
-            @NotNull GlobalSearchScope searchScope
-    ) {
-        BindingContext context = resolveSession.resolveToElement(expression);
-        JetExpression receiverExpression = PsiUtilPackage.getReceiverExpression(expression);
-        if (receiverExpression == null) {
-            return Collections.emptyList();
-        }
-        JetType expressionType = context.get(BindingContext.EXPRESSION_TYPE, receiverExpression);
-        JetScope scope = context.get(BindingContext.RESOLUTION_SCOPE, receiverExpression);
-
-        if (expressionType == null || scope == null || expressionType.isError()) {
-            return Collections.emptyList();
-        }
-
-        Set<FqName> functionFQNs = extensionFunctionsFromSourceFqNames(acceptedNameCondition, searchScope);
-        functionFQNs.addAll(ContainerUtil.filter(JetFromJavaDescriptorHelper.getTopLevelFunctionFqNames(project, searchScope, true), new Condition<FqName>() {
-            @Override
-            public boolean value(FqName fqName) {
-                return acceptedNameCondition.value(fqName.shortName().asString());
-            }
-        }));
-
-        Collection<DeclarationDescriptor> resultDescriptors = new ArrayList<DeclarationDescriptor>();
-        // Iterate through the function with attempt to resolve found functions
-        for (FqName functionFQN : functionFQNs) {
-            for (CallableDescriptor functionDescriptor : ExpressionTypingUtils.canFindSuitableCall(
-                    functionFQN, receiverExpression, expressionType, scope, resolveSession.getModuleDescriptor())) {
-
-                resultDescriptors.add(functionDescriptor);
-            }
-        }
-
-        return resultDescriptors;
-    }
-
-    @NotNull
-    private Set<FqName> extensionFunctionsFromSourceFqNames(
-            @NotNull Condition<String> acceptedNameCondition,
-            @NotNull GlobalSearchScope searchScope
-    ) {
-        Set<String> extensionFunctionNames = new HashSet<String>(JetTopLevelExtensionFunctionShortNameIndex.getInstance().getAllKeys(project));
-
-        Set<FqName> functionFQNs = new java.util.HashSet<FqName>();
-
-        // Collect all possible extension function qualified names
-        for (String name : extensionFunctionNames) {
-            if (acceptedNameCondition.value(name)) {
-                Collection<PsiElement> extensionFunctions = getJetExtensionFunctionsByName(name, searchScope);
-
-                for (PsiElement extensionFunction : extensionFunctions) {
-                    if (extensionFunction instanceof JetNamedFunction) {
-                        functionFQNs.add(((JetNamedFunction) extensionFunction).getFqName());
-                    }
-                    else if (extensionFunction instanceof PsiMethod) {
-                        FqName functionFQN =
-                                JetFromJavaDescriptorHelper.getJetTopLevelDeclarationFQN((PsiMethod) extensionFunction);
-                        if (functionFQN != null) {
-                            functionFQNs.add(functionFQN);
-                        }
-                    }
-                }
-            }
-        }
-        return functionFQNs;
-    }
-
-    @NotNull
-    public Collection<ClassDescriptor> getJetClassesDescriptors(
-            @NotNull Condition<String> acceptedShortNameCondition,
-            @NotNull KotlinCodeAnalyzer analyzer,
-            @NotNull GlobalSearchScope searchScope
-    ) {
-        Collection<ClassDescriptor> classDescriptors = new ArrayList<ClassDescriptor>();
-
-        for (String fqName : JetFullClassNameIndex.getInstance().getAllKeys(project)) {
-            FqName classFQName = new FqName(fqName);
-            if (acceptedShortNameCondition.value(classFQName.shortName().asString())) {
-                classDescriptors.addAll(getJetClassesDescriptorsByFQName(analyzer, classFQName, searchScope));
-            }
-        }
-
-        return classDescriptors;
-    }
-
-    private Collection<ClassDescriptor> getJetClassesDescriptorsByFQName(
-            @NotNull KotlinCodeAnalyzer analyzer, @NotNull FqName classFQName, @NotNull GlobalSearchScope searchScope) {
-        Collection<JetClassOrObject> jetClassOrObjects = JetFullClassNameIndex.getInstance().get(
-                classFQName.asString(), project, searchScope);
-
-        if (jetClassOrObjects.isEmpty()) {
-            // This fqn is absent in caches, dead or not in scope
-            return Collections.emptyList();
-        }
-
-        // Note: Can't search with psi element as analyzer could be built over temp files
-        return ResolveSessionUtils.getClassDescriptorsByFqName(analyzer, classFQName);
-    }
-
-    @NotNull
-    @Override
-    public PsiMethod[] getMethodsByName(@NonNls @NotNull String name, @NotNull GlobalSearchScope scope) {
-        return NO_METHODS;
-    }
-
-    @NotNull
-    @Override
-    public PsiMethod[] getMethodsByNameIfNotMoreThan(@NonNls @NotNull String name, @NotNull GlobalSearchScope scope, int maxCount) {
-        return NO_METHODS;
-    }
-
-    @NotNull
-    @Override
-    public PsiField[] getFieldsByNameIfNotMoreThan(@NonNls @NotNull String s, @NotNull GlobalSearchScope scope, int i) {
-        return NO_FIELDS;
-    }
-
-    @Override
-    public boolean processMethodsWithName(
-            @NonNls @NotNull String name,
-            @NotNull GlobalSearchScope scope,
-            @NotNull Processor<PsiMethod> processor
-    ) {
-        return ContainerUtil.process(getMethodsByName(name, scope), processor);
-    }
-
-    @NotNull
-    @Override
-    public String[] getAllMethodNames() {
-        return ArrayUtil.EMPTY_STRING_ARRAY;
-    }
-
-    @Override
-    public void getAllMethodNames(@NotNull HashSet<String> set) {
-        set.addAll(JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().getAllKeys(project));
-    }
-
-    @NotNull
-    @Override
-    public PsiField[] getFieldsByName(@NotNull @NonNls String name, @NotNull GlobalSearchScope scope) {
-        return NO_FIELDS;
-    }
-
-    @NotNull
-    @Override
-    public String[] getAllFieldNames() {
-        return ArrayUtil.EMPTY_STRING_ARRAY;
-    }
-
-    @Override
-    public void getAllFieldNames(@NotNull HashSet<String> set) {
-    }
-}

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java

@@ -57,6 +57,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport
 
     private static final Logger LOG = Logger.getInstance(IDELightClassGenerationSupport.class);
 
+    @NotNull
     public static IDELightClassGenerationSupport getInstanceForIDE(@NotNull Project project) {
         return (IDELightClassGenerationSupport) ServiceManager.getService(project, LightClassGenerationSupport.class);
     }

idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/JetClassShortNameIndex.java

@@ -30,6 +30,7 @@ public class JetClassShortNameIndex extends StringStubIndexExtension<JetClassOrO
 
     private static final JetClassShortNameIndex ourInstance = new JetClassShortNameIndex();
 
+    @NotNull
     public static JetClassShortNameIndex getInstance() {
         return ourInstance;
     }

idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelExtensionFunctionShortNameIndex.java

@@ -26,6 +26,7 @@ public class JetTopLevelExtensionFunctionShortNameIndex extends StringStubIndexE
 
     private static final JetTopLevelExtensionFunctionShortNameIndex instance = new JetTopLevelExtensionFunctionShortNameIndex();
 
+    @NotNull
     public static JetTopLevelExtensionFunctionShortNameIndex getInstance() {
         return instance;
     }

idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelNonExtensionFunctionShortNameIndex.java

@@ -30,6 +30,7 @@ public class JetTopLevelNonExtensionFunctionShortNameIndex extends StringStubInd
 
     private static final JetTopLevelNonExtensionFunctionShortNameIndex ourInstance = new JetTopLevelNonExtensionFunctionShortNameIndex();
 
+    @NotNull
     public static JetTopLevelNonExtensionFunctionShortNameIndex getInstance() {
         return ourInstance;
     }

idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelObjectShortNameIndex.java

@@ -30,6 +30,7 @@ public class JetTopLevelObjectShortNameIndex extends StringStubIndexExtension<Je
 
     private static final JetTopLevelObjectShortNameIndex ourInstance = new JetTopLevelObjectShortNameIndex();
 
+    @NotNull
     public static JetTopLevelObjectShortNameIndex getInstance() {
         return ourInstance;
     }

idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.kt

@@ -0,0 +1,296 @@
+/*
+ * Copyright 2010-2014 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.jet.plugin.caches
+
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Condition
+import com.intellij.psi.*
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.search.PsiShortNamesCache
+import com.intellij.util.ArrayUtil
+import com.intellij.util.Processor
+import com.intellij.util.containers.ContainerUtil
+import org.jetbrains.annotations.NonNls
+import org.jetbrains.jet.asJava.JavaElementFinder
+import org.jetbrains.jet.lang.descriptors.*
+import org.jetbrains.jet.lang.psi.*
+import org.jetbrains.jet.lang.psi.psiUtil.*
+import org.jetbrains.jet.lang.resolve.BindingContext
+import org.jetbrains.jet.lang.resolve.BindingTraceContext
+import org.jetbrains.jet.lang.resolve.ImportPath
+import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver
+import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.types.JetType
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils
+import org.jetbrains.jet.plugin.caches.resolve.IDELightClassGenerationSupport
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
+import org.jetbrains.jet.plugin.stubindex.*
+
+import java.util.*
+import com.intellij.util.containers
+
+/**
+ * Will provide both java elements from kotlin context and some declarations special to kotlin.
+ * All those declaration are planned to be used in completion.
+ */
+public class JetShortNamesCache(private val project: Project) : PsiShortNamesCache() {
+    class object {
+        public fun getKotlinInstance(project: Project): JetShortNamesCache {
+            val extensions = Extensions.getArea(project).getExtensionPoint<PsiShortNamesCache>(PsiShortNamesCache.EP_NAME).getExtensions()
+            for (extension in extensions) {
+                if (extension is JetShortNamesCache) {
+                    return extension as JetShortNamesCache
+                }
+            }
+            throw IllegalStateException(javaClass<JetShortNamesCache>().getSimpleName() + " is not found for project " + project)
+        }
+    }
+
+    /**
+     * Return kotlin class names from project sources which should be visible from java.
+     */
+    override fun getAllClassNames(): Array<String> {
+        val classNames = JetClassShortNameIndex.getInstance().getAllKeys(project)
+
+        // package classes can not be indexed, since they have no explicit declarations
+        val lightClassGenerationSupport = IDELightClassGenerationSupport.getInstanceForIDE(project)
+        val packageClassShortNames = lightClassGenerationSupport.getAllPossiblePackageClasses(GlobalSearchScope.allScope(project)).keySet()
+        classNames.addAll(packageClassShortNames)
+
+        return ArrayUtil.toStringArray(classNames)
+    }
+
+    /**
+     * Return class names form kotlin sources in given scope which should be visible as Java classes.
+     */
+    override fun getClassesByName(NonNls name: String, scope: GlobalSearchScope): Array<PsiClass> {
+        val result = ArrayList<PsiClass>()
+
+        val lightClassGenerationSupport = IDELightClassGenerationSupport.getInstanceForIDE(project)
+        val packageClasses = lightClassGenerationSupport.getAllPossiblePackageClasses(scope)
+
+        // package classes can not be indexed, since they have no explicit declarations
+        val fqNames = packageClasses.get(name)
+        if (!fqNames.isEmpty()) {
+            for (fqName in fqNames) {
+                val psiClass = JavaElementFinder.getInstance(project).findClass(fqName.asString(), scope)
+                if (psiClass != null) {
+                    result.add(psiClass)
+                }
+            }
+        }
+
+        // Quick check for classes from getAllClassNames()
+        val classOrObjects = JetClassShortNameIndex.getInstance().get(name, project, scope)
+        if (classOrObjects.isEmpty()) {
+            return result.copyToArray()
+        }
+
+        for (classOrObject in classOrObjects) {
+            val fqName = classOrObject.getFqName()
+            if (fqName != null) {
+                assert(fqName.shortName().asString() == name) { "A declaration obtained from index has non-matching name:\n" + "in index: " + name + "\n" + "declared: " + fqName.shortName() + "(" + fqName + ")" }
+                val psiClass = JavaElementFinder.getInstance(project).findClass(fqName.asString(), scope)
+                if (psiClass != null) {
+                    result.add(psiClass)
+                }
+            }
+        }
+
+        return result.copyToArray()
+    }
+
+    override fun getAllClassNames(destination: containers.HashSet<String>) {
+        destination.addAll(Arrays.asList<String>(*getAllClassNames()))
+    }
+
+    /**
+     * Get kotlin non-extension top-level function names. Method is allowed to give invalid names - all result should be
+     * checked with getTopLevelFunctionDescriptorsByName().
+     */
+    public fun getAllTopLevelFunctionNames(): Collection<String> {
+        return (JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().getAllKeys(project)
+                + JetFromJavaDescriptorHelper.getPossiblePackageDeclarationsNames(project, GlobalSearchScope.allScope(project))).toSet()
+    }
+
+    public fun getAllTopLevelObjectNames(): Collection<String> {
+        return (JetTopLevelObjectShortNameIndex.getInstance().getAllKeys(project)
+                + JetFromJavaDescriptorHelper.getCompiledClassesForTopLevelObjects(project, GlobalSearchScope.allScope(project)).map { it.getName()!! }).toSet()
+    }
+
+    public fun getTopLevelObjectsByName(name: String, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection<ClassDescriptor> {
+        val result = hashSetOf<ClassDescriptor>()
+
+        val topObjects = JetTopLevelObjectShortNameIndex.getInstance().get(name, project, scope)
+        for (objectDeclaration in topObjects) {
+            val fqName = objectDeclaration.getFqName() ?: error("Local object declaration in JetTopLevelShortObjectNameIndex:${objectDeclaration.getText()}")
+            result.addAll(ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, fqName, ResolveSessionUtils.SINGLETON_FILTER))
+        }
+
+        for (psiClass in JetFromJavaDescriptorHelper.getCompiledClassesForTopLevelObjects(project, GlobalSearchScope.allScope(project))) {
+            val qualifiedName = psiClass.getQualifiedName()
+            if (qualifiedName != null) {
+                result.addAll(ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, FqName(qualifiedName), ResolveSessionUtils.SINGLETON_FILTER))
+            }
+        }
+
+        return result
+    }
+
+    public fun getTopLevelFunctionDescriptorsByName(name: String, context: JetExpression /*TODO: to be dropped*/, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection<FunctionDescriptor> {
+
+        val jetScope = resolveSession.resolveToElement(context).get<JetExpression, JetScope>(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf()
+
+        val result = hashSetOf<FunctionDescriptor>()
+
+        //TODO: this code is temporary and is to be dropped when compiled top level functions are indexed
+        val identifier = Name.identifier(name)
+        val topLevelFunctionFqNames = JetFromJavaDescriptorHelper.getTopLevelFunctionFqNames(project, scope, false)
+        for (fqName in topLevelFunctionFqNames) {
+            if (fqName.lastSegmentIs(identifier)) {
+                val importDirective = JetPsiFactory(context.getProject()).createImportDirective(ImportPath(fqName, false))
+                val declarationDescriptors = QualifiedExpressionResolver().analyseImportReference(importDirective, jetScope, BindingTraceContext(), resolveSession.getModuleDescriptor())
+                for (declarationDescriptor in declarationDescriptors) {
+                    if (declarationDescriptor is FunctionDescriptor) {
+                        result.add(declarationDescriptor as FunctionDescriptor)
+                    }
+                }
+            }
+        }
+
+        val affectedPackages = JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().get(name, project, scope)
+                .map { it.getContainingFile() }
+                .filterIsInstance(javaClass<JetFile>())
+                .map { it.getPackageFqName() }
+                .toSet()
+
+        for (affectedPackage in affectedPackages) {
+            val packageDescriptor = resolveSession.getModuleDescriptor().getPackage(affectedPackage)
+                    ?: error("There's a function in stub index with invalid package: $affectedPackage")
+            result.addAll(packageDescriptor.getMemberScope().getFunctions(identifier))
+        }
+
+        return result
+    }
+
+    private fun getJetExtensionFunctionsByName(name: String, scope: GlobalSearchScope): Collection<PsiElement>
+            = JetTopLevelExtensionFunctionShortNameIndex.getInstance().get(name, project, scope)
+
+    // TODO: Make it work for properties
+    public fun getJetCallableExtensions(nameFilter: (String) -> Boolean, expression: JetSimpleNameExpression, resolveSession: ResolveSessionForBodies, searchScope: GlobalSearchScope): Collection<DeclarationDescriptor> {
+        val context = resolveSession.resolveToElement(expression)
+        val receiverExpression = expression.getReceiverExpression() ?: return listOf()
+        val expressionType = context.get<JetExpression, JetType>(BindingContext.EXPRESSION_TYPE, receiverExpression)
+        val scope = context.get<JetExpression, JetScope>(BindingContext.RESOLUTION_SCOPE, receiverExpression)
+
+        if (expressionType == null || scope == null || expressionType.isError()) {
+            return listOf()
+        }
+
+        val functionFQNs = extensionFunctionsFromSourceFqNames(nameFilter, searchScope)
+
+        JetFromJavaDescriptorHelper.getTopLevelFunctionFqNames(project, searchScope, true)
+                .filterTo(functionFQNs) { nameFilter(it.shortName().asString()) }
+
+        // Iterate through the function with attempt to resolve found functions
+        return functionFQNs.flatMap { ExpressionTypingUtils.canFindSuitableCall(it, receiverExpression, expressionType, scope, resolveSession.getModuleDescriptor()) }
+    }
+
+    private fun extensionFunctionsFromSourceFqNames(nameFilter: (String) -> Boolean, searchScope: GlobalSearchScope): HashSet<FqName> {
+        val extensionFunctionNames = HashSet(JetTopLevelExtensionFunctionShortNameIndex.getInstance().getAllKeys(project))
+
+        val functionFQNs = HashSet<FqName>()
+
+        // Collect all possible extension function qualified names
+        for (name in extensionFunctionNames) {
+            if (nameFilter(name)) {
+                val extensionFunctions = getJetExtensionFunctionsByName(name, searchScope)
+
+                for (extensionFunction in extensionFunctions) {
+                    if (extensionFunction is JetNamedFunction) {
+                        functionFQNs.add(extensionFunction.getFqName()!!)
+                    }
+                    else if (extensionFunction is PsiMethod) {
+                        val functionFQN = JetFromJavaDescriptorHelper.getJetTopLevelDeclarationFQN(extensionFunction)
+                        if (functionFQN != null) {
+                            functionFQNs.add(functionFQN)
+                        }
+                    }
+                }
+            }
+        }
+        return functionFQNs
+    }
+
+    public fun getJetClassesDescriptors(acceptedShortNameCondition: (String) -> Boolean, analyzer: KotlinCodeAnalyzer, searchScope: GlobalSearchScope): Collection<ClassDescriptor> {
+        val classDescriptors = ArrayList<ClassDescriptor>()
+
+        for (fqName in JetFullClassNameIndex.getInstance().getAllKeys(project)) {
+            val classFQName = FqName(fqName)
+            if (acceptedShortNameCondition(classFQName.shortName().asString())) {
+                classDescriptors.addAll(getJetClassesDescriptorsByFQName(analyzer, classFQName, searchScope))
+            }
+        }
+
+        return classDescriptors
+    }
+
+    private fun getJetClassesDescriptorsByFQName(analyzer: KotlinCodeAnalyzer, classFQName: FqName, searchScope: GlobalSearchScope): Collection<ClassDescriptor> {
+        val jetClassOrObjects = JetFullClassNameIndex.getInstance().get(classFQName.asString(), project, searchScope)
+
+        if (jetClassOrObjects.isEmpty()) {
+            // This fqn is absent in caches, dead or not in scope
+            return listOf()
+        }
+
+        // Note: Can't search with psi element as analyzer could be built over temp files
+        return ResolveSessionUtils.getClassDescriptorsByFqName(analyzer, classFQName)
+    }
+
+    override fun getMethodsByName(NonNls name: String, scope: GlobalSearchScope): Array<PsiMethod>
+            = array()
+
+    override fun getMethodsByNameIfNotMoreThan(NonNls name: String, scope: GlobalSearchScope, maxCount: Int): Array<PsiMethod>
+            = array()
+
+    override fun getFieldsByNameIfNotMoreThan(NonNls s: String, scope: GlobalSearchScope, i: Int): Array<PsiField>
+            = array()
+
+    override fun processMethodsWithName(NonNls name: String, scope: GlobalSearchScope, processor: Processor<PsiMethod>): Boolean
+            = ContainerUtil.process(getMethodsByName(name, scope), processor)
+
+    override fun getAllMethodNames(): Array<String>
+            = array()
+
+    override fun getAllMethodNames(set: containers.HashSet<String>) {
+        set.addAll(JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().getAllKeys(project))
+    }
+
+    override fun getFieldsByName(NonNls name: String, scope: GlobalSearchScope): Array<PsiField>
+            = array()
+
+    override fun getAllFieldNames(): Array<String>
+            = array()
+
+    override fun getAllFieldNames(set: containers.HashSet<String>) {
+    }
+}

idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt

@@ -166,13 +166,13 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
     private fun addKotlinTopLevelObjects() {
         for (name in shortNamesCache.getAllTopLevelObjectNames()) {
             if (prefixMatcher.prefixMatches(name)) {
-                collector.addDescriptorElements(shortNamesCache.getTopLevelObjectsByName(name, jetReference!!.expression, resolveSession, searchScope))
+                collector.addDescriptorElements(shortNamesCache.getTopLevelObjectsByName(name, resolveSession, searchScope))
             }
         }
     }
 
     private fun addKotlinExtensions() {
-        collector.addDescriptorElements(shortNamesCache.getJetCallableExtensions({ prefixMatcher.prefixMatches(it!!) }, jetReference!!.expression, resolveSession, searchScope))
+        collector.addDescriptorElements(shortNamesCache.getJetCallableExtensions({ prefixMatcher.prefixMatches(it) }, jetReference!!.expression, resolveSession, searchScope))
     }
 
     private fun shouldRunOnlyTypeCompletion(): Boolean {

idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt

@@ -44,7 +44,7 @@ class TypesCompletion(val parameters: CompletionParameters, val resolveSession:
         val namesCache = JetShortNamesCache.getKotlinInstance(project)
         val module = ModuleUtilCore.findModuleForPsiElement(parameters.getOriginalFile()) ?: return
         val searchScope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module)
-        result.addDescriptorElements(namesCache.getJetClassesDescriptors({ prefixMatcher.prefixMatches(it!!) }, resolveSession, searchScope))
+        result.addDescriptorElements(namesCache.getJetClassesDescriptors({ prefixMatcher.prefixMatches(it) }, resolveSession, searchScope))
 
         if (!ProjectStructureUtil.isJsKotlinModule(parameters.getOriginalFile() as JetFile)) {
             addAdaptedJavaCompletion(result)

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

@@ -30,12 +30,12 @@ import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleUtilCore;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Condition;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.PsiShortNamesCache;
 import com.intellij.util.IncorrectOperationException;
+import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -130,7 +130,7 @@ public class AutoImportFix extends JetHintAction<JetSimpleNameExpression> implem
             @NotNull ResolveSessionForBodies resolveSession,
             @NotNull Project project
     ) {
-        JetShortNamesCache namesCache = JetShortNamesCache.getKotlinInstance(project);
+        JetShortNamesCache namesCache = JetShortNamesCache.OBJECT$.getKotlinInstance(project);
 
         Collection<FunctionDescriptor> topLevelFunctions = namesCache.getTopLevelFunctionDescriptorsByName(
                 referenceName, context, resolveSession, searchScope);
@@ -151,11 +151,11 @@ public class AutoImportFix extends JetHintAction<JetSimpleNameExpression> implem
             @NotNull ResolveSessionForBodies resolveSession,
             @NotNull Project project
     ) {
-        JetShortNamesCache namesCache = JetShortNamesCache.getKotlinInstance(project);
+        JetShortNamesCache namesCache = JetShortNamesCache.OBJECT$.getKotlinInstance(project);
         Collection<DeclarationDescriptor> jetCallableExtensions = namesCache.getJetCallableExtensions(
-                new Condition<String>() {
+                new Function1<String, Boolean>() {
                     @Override
-                    public boolean value(String callableExtensionName) {
+                    public Boolean invoke(String callableExtensionName) {
                         return callableExtensionName.equals(referenceName);
                     }
                 },
@@ -216,17 +216,17 @@ public class AutoImportFix extends JetHintAction<JetSimpleNameExpression> implem
 
     private static PsiShortNamesCache getShortNamesCache(@NotNull JetFile jetFile) {
         if (ProjectStructureUtil.isJsKotlinModule(jetFile)) {
-            return JetShortNamesCache.getKotlinInstance(jetFile.getProject());
+            return JetShortNamesCache.OBJECT$.getKotlinInstance(jetFile.getProject());
         }
 
         return PsiShortNamesCache.getInstance(jetFile.getProject());
     }
 
     private static Collection<FqName> getJetClasses(@NotNull final String typeName, @NotNull GlobalSearchScope searchScope, @NotNull Project project, @NotNull KotlinCodeAnalyzer resolveSession) {
-        JetShortNamesCache cache = JetShortNamesCache.getKotlinInstance(project);
+        JetShortNamesCache cache = JetShortNamesCache.OBJECT$.getKotlinInstance(project);
-        Collection<ClassDescriptor> descriptors = cache.getJetClassesDescriptors(new Condition<String>() {
+        Collection<ClassDescriptor> descriptors = cache.getJetClassesDescriptors(new Function1<String, Boolean>() {
             @Override
-            public boolean value(String s) {
+            public Boolean invoke(String s) {
                 return typeName.equals(s);
             }
         }, resolveSession, searchScope);