Code improvements after conversion

compiler/frontend/src/org/jetbrains/kotlin/resolve/Importer.kt

@@ -16,14 +16,13 @@
 
 package org.jetbrains.kotlin.resolve
 
-import com.google.common.collect.Lists
-import com.intellij.openapi.util.Pair
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
 import org.jetbrains.kotlin.resolve.scopes.FilteringScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.scopes.WritableScope
+import java.util.ArrayList
 
 public trait Importer {
     public fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap)
@@ -41,17 +40,12 @@ public trait Importer {
         }
 
         protected fun importDeclarationAlias(descriptor: DeclarationDescriptor, aliasName: Name) {
-            if (descriptor is ClassifierDescriptor) {
+            when (descriptor) {
-                fileScope.importClassifierAlias(aliasName, descriptor)
+                is ClassifierDescriptor -> fileScope.importClassifierAlias(aliasName, descriptor)
-            }
+                is PackageViewDescriptor -> fileScope.importPackageAlias(aliasName, descriptor)
-            else if (descriptor is PackageViewDescriptor) {
+                is FunctionDescriptor -> fileScope.importFunctionAlias(aliasName, descriptor)
-                fileScope.importPackageAlias(aliasName, descriptor)
+                is VariableDescriptor -> fileScope.importVariableAlias(aliasName, descriptor)
-            }
+                else -> error("Unknown descriptor")
-            else if (descriptor is FunctionDescriptor) {
-                fileScope.importFunctionAlias(aliasName, descriptor)
-            }
-            else if (descriptor is VariableDescriptor) {
-                fileScope.importVariableAlias(aliasName, descriptor)
             }
         }
 
@@ -73,16 +67,18 @@ public trait Importer {
         private fun createFilteringScope(scope: JetScope, descriptor: PackageViewDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap): JetScope {
             val kotlinAnalogsForClassesInside = platformToKotlinClassMap.mapPlatformClassesInside(descriptor)
             if (kotlinAnalogsForClassesInside.isEmpty()) return scope
-            return FilteringScope(scope) { descriptor -> !kotlinAnalogsForClassesInside.any { it.getName() == descriptor.getName() } }
+            return FilteringScope(scope) { descriptor -> kotlinAnalogsForClassesInside.all { it.getName() != descriptor.getName() } }
         }
     }
 
     public class DelayedImporter(fileScope: WritableScope) : StandardImporter(fileScope) {
         private trait DelayedImportEntry
-        private class AllUnderImportEntry(first: DeclarationDescriptor, second: PlatformToKotlinClassMap?) : Pair<DeclarationDescriptor, PlatformToKotlinClassMap>(first, second), DelayedImportEntry
-        private class AliasImportEntry(first: DeclarationDescriptor, second: Name) : Pair<DeclarationDescriptor, Name>(first, second), DelayedImportEntry
 
-        private val imports = Lists.newArrayList<DelayedImportEntry>()
+        private class AllUnderImportEntry(val first: DeclarationDescriptor, val second: PlatformToKotlinClassMap) : DelayedImportEntry
+
+        private class AliasImportEntry(val first: DeclarationDescriptor, val second: Name) : DelayedImportEntry
+
+        private val imports = ArrayList<DelayedImportEntry>()
 
         override fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) {
             imports.add(AllUnderImportEntry(descriptor, platformToKotlinClassMap))
@@ -95,24 +91,21 @@ public trait Importer {
         public fun processImports() {
             for (anImport in imports) {
                 if (anImport is AllUnderImportEntry) {
-                    val allUnderImportEntry = anImport as AllUnderImportEntry
+                    importAllUnderDeclaration(anImport.first, anImport.second)
-                    importAllUnderDeclaration(allUnderImportEntry.getFirst(), allUnderImportEntry.getSecond())
                 }
                 else {
-                    val aliasImportEntry = anImport as AliasImportEntry
+                    anImport as AliasImportEntry
-                    importDeclarationAlias(aliasImportEntry.getFirst(), aliasImportEntry.getSecond())
+                    importDeclarationAlias(anImport.first, anImport.second)
                 }
             }
         }
     }
 
-    class object {
+    object DoNothingImporter : Importer {
-        public val DO_NOTHING: Importer = object : Importer {
         override fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) {
         }
 
         override fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name) {
         }
     }
-    }
 }

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

@@ -187,7 +187,7 @@ public class KotlinIndicesHelper(
     private fun analyzeImportReference(
             importDirective: JetImportDirective, scope: JetScope, trace: BindingTrace, module: ModuleDescriptor
     ): Collection<DeclarationDescriptor> {
-        return QualifiedExpressionResolver().processImportReference(importDirective, scope, scope, Importer.DO_NOTHING, trace,
+        return QualifiedExpressionResolver().processImportReference(importDirective, scope, scope, Importer.DoNothingImporter, trace,
                                                                     module, LookupMode.EVERYTHING)
     }
 }