Minor code changes after code review

compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/StubInterfaces.kt

@@ -114,10 +114,3 @@ public trait KotlinTypeProjectionStub : StubElement<JetTypeProjection> {
 public trait KotlinUserTypeStub : StubElement<JetUserType> {
     public fun isAbsoluteInRootPackage(): Boolean
 }
-
-public fun StubElement<*>.getContainingFileStub(): PsiFileStub<*> {
-    return if (this is PsiFileStub)
-        this
-    else
-        getParentStub().getContainingFileStub()
-}

idea/ide-common/src/org/jetbrains/kotlin/util/TypeIndexUtil.kt

@@ -18,12 +18,12 @@ package org.jetbrains.kotlin.util
 
 import com.google.common.collect.HashMultimap
 import com.google.common.collect.Multimap
-import com.google.common.collect.Multimaps
 import com.intellij.openapi.util.Key
+import com.intellij.psi.stubs.PsiFileStub
+import com.intellij.psi.stubs.StubElement
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.psi.JetTypeReference
 import org.jetbrains.kotlin.psi.JetUserType
-import org.jetbrains.kotlin.psi.stubs.getContainingFileStub
 
 public fun JetUserType.aliasImportMap(): Multimap<String, String> {
     // we need to access containing file via stub because getPsi() may return null when indexing and getContainingFile() will crash
@@ -69,3 +69,9 @@ public fun JetUserType?.isProbablyNothing(): Boolean {
     return referencedName == "Nothing" || aliasImportMap()[referencedName].contains("Nothing")
 }
 
+private fun StubElement<*>.getContainingFileStub(): PsiFileStub<*> {
+    return if (this is PsiFileStub)
+        this
+    else
+        getParentStub().getContainingFileStub()
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IndexUtils.kt

@@ -22,7 +22,6 @@ import com.intellij.openapi.util.Key
 import com.intellij.psi.stubs.IndexSink
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.stubs.KotlinCallableStubBase
-import org.jetbrains.kotlin.psi.stubs.getContainingFileStub
 import org.jetbrains.kotlin.util.aliasImportMap
 
 fun indexTopLevelExtension<TDeclaration : JetCallableDeclaration>(stub: KotlinCallableStubBase<TDeclaration>, sink: IndexSink) {
@@ -32,7 +31,7 @@ fun indexTopLevelExtension<TDeclaration : JetCallableDeclaration>(stub: KotlinCa
     }
 }
 
-private fun <TDeclaration : JetCallableDeclaration> JetTypeElement.index(declaration: TDeclaration, sink: IndexSink) {
+private fun JetTypeElement.index<TDeclaration : JetCallableDeclaration>(declaration: TDeclaration, sink: IndexSink) {
     fun occurrence(typeName: String) {
         val name = declaration.getName() ?: return
         sink.occurrence(JetTopLevelExtensionsByReceiverTypeIndex.INSTANCE.getKey(),
@@ -43,17 +42,16 @@ private fun <TDeclaration : JetCallableDeclaration> JetTypeElement.index(declara
         is JetUserType -> {
             var referenceName = getReferencedName() ?: return
 
-            if (declaration is JetNamedFunction) {
+            val typeParameter = declaration.getTypeParameters().firstOrNull { it.getName() == referenceName }
-                val typeParameter = declaration.getTypeParameters().firstOrNull { it.getName() == referenceName }
+            if (typeParameter != null) {
-                if (typeParameter != null) {
+                val bound = typeParameter.getExtendsBound()
-                    val bound = typeParameter.getExtendsBound()
+                if (bound != null) {
-                    if (bound != null) {
+                    bound.getTypeElement()?.index(declaration, sink)
-                        bound.getTypeElement()?.index(declaration, sink)
-                        return
-                    }
-                    occurrence("Any")
-                    return
                 }
+                else {
+                    occurrence("Any")
+                }
+                return
             }
 
             occurrence(referenceName)
@@ -68,7 +66,9 @@ private fun <TDeclaration : JetCallableDeclaration> JetTypeElement.index(declara
             occurrence(typeName)
         }
 
-        else -> occurrence("Any")
+        is JetDynamicType -> occurrence("Any")
+
+        else -> error("Unsupported type: $this")
     }
 }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelExtensionsByReceiverTypeIndex.kt

@@ -31,13 +31,14 @@ public class JetTopLevelExtensionsByReceiverTypeIndex private() : StringStubInde
 
     companion object {
         private val KEY = KotlinIndexUtil.createIndexKey<String, JetCallableDeclaration>(javaClass<JetTopLevelExtensionsByReceiverTypeIndex>())
+        private val SEPARATOR = '\n'
 
         public val INSTANCE: JetTopLevelExtensionsByReceiverTypeIndex = JetTopLevelExtensionsByReceiverTypeIndex()
 
-        public fun buildKey(receiverTypeName: String, callableName: String): String = receiverTypeName + "\n" + callableName
+        public fun buildKey(receiverTypeName: String, callableName: String): String = receiverTypeName + SEPARATOR + callableName
 
-        public fun receiverTypeNameFromKey(key: String): String = key.substringBefore('\n', "")
+        public fun receiverTypeNameFromKey(key: String): String = key.substringBefore(SEPARATOR, "")
 
-        public fun callableNameFromKey(key: String): String = key.substringAfter('\n', "")
+        public fun callableNameFromKey(key: String): String = key.substringAfter(SEPARATOR, "")
     }
 }

idea/src/org/jetbrains/kotlin/idea/caches/KotlinIndicesHelper.kt

@@ -102,7 +102,7 @@ public class KotlinIndicesHelper(
     }
 
     private fun possibleReceiverTypeNames(receiverValues: Collection<ReceiverValue>, dataFlowInfo: DataFlowInfo): Set<String> {
-        val result = LinkedHashSet<String>()
+        val result = HashSet<String>()
         for (receiverValue in receiverValues) {
             for (type in SmartCastUtils.getSmartCastVariants(receiverValue, bindingContext, dataFlowInfo)) {
                 result.addTypeNames(type)
@@ -111,6 +111,12 @@ public class KotlinIndicesHelper(
         return result
     }
 
+    private fun MutableCollection<String>.addTypeNames(type: JetType) {
+        val constructor = type.getConstructor()
+        addIfNotNull(constructor.getDeclarationDescriptor()?.getName()?.asString())
+        constructor.getSupertypes().forEach { addTypeNames(it) }
+    }
+
     private fun receiverValues(expression: JetSimpleNameExpression): Collection<Pair<ReceiverValue, CallType>> {
         val receiverPair = ReferenceVariantsHelper.getExplicitReceiverData(expression)
         if (receiverPair != null) {
@@ -125,17 +131,10 @@ public class KotlinIndicesHelper(
         }
         else {
             val resolutionScope = bindingContext[BindingContext.RESOLUTION_SCOPE, expression] ?: return emptyList()
-
             return resolutionScope.getImplicitReceiversWithInstance().map { it.getValue() to CallType.NORMAL }
         }
     }
 
-    private fun MutableCollection<String>.addTypeNames(type: JetType) {
-        val constructor = type.getConstructor()
-        addIfNotNull(constructor.getDeclarationDescriptor()?.getName()?.asString())
-        constructor.getSupertypes().forEach { addTypeNames(it) }
-    }
-
     /**
      * Check that function or property with the given qualified name can be resolved in given scope and called on given receiver
      */

idea/testData/completion/basic/multifile/NotImportedExtensionFunction/NotImportedExtensionFunction.dependency.kt

@@ -7,11 +7,11 @@ fun String.helloWithParams(i : Int) : String {
     return ""
 }
 
-fun String.helloFunPreventAutoInsert() {
-}
-
 fun <T: CharSequence> T.helloFunGeneric() {
 }
 
 fun Int.helloFake() {
 }
+
+fun dynamic.helloDynamic() {
+}

idea/testData/completion/basic/multifile/NotImportedExtensionFunction/NotImportedExtensionFunction.kt

@@ -6,8 +6,7 @@ fun firstFun() {
 }
 
 // EXIST: helloFun
-// EXIST: helloFunPreventAutoInsert
 // EXIST: helloWithParams
 // EXIST: helloFunGeneric
+// EXIST: helloDynamic
 // ABSENT: helloFake
-// NUMBER: 4