ImportOptimizer: cleanup code

idea/ide-common/src/org/jetbrains/kotlin/idea/imports/OptimizedImportsBuilder.kt

@@ -49,13 +49,13 @@ class OptimizedImportsBuilder(
         fun resolve(bindingContext: BindingContext): Collection<DeclarationDescriptor>
     }
 
-    data class InputData(
+    class InputData(
         val descriptorsToImport: Set<DeclarationDescriptor>,
         val namesToImport: Map<FqName, Set<Name>>,
         val references: Collection<AbstractReference>
     )
 
-    data class Options(
+    class Options(
         val nameCountToUseStarImport: Int,
         val nameCountToUseStarImportForMembers: Int,
         val isInPackagesToUseStarImport: (FqName) -> Boolean
@@ -106,9 +106,7 @@ class OptimizedImportsBuilder(
 
     private fun tryBuildOptimizedImports(): List<ImportPath>? {
         val importsToGenerate = HashSet<ImportPath>()
-        importRules
+        importRules.filterIsInstance<ImportRule.Add>().mapTo(importsToGenerate) { it.importPath }
-            .filterIsInstance<ImportRule.Add>()
-            .mapTo(importsToGenerate) { it.importPath }
 
         val descriptorsByParentFqName = HashMap<FqName, MutableSet<DeclarationDescriptor>>()
         for (descriptor in data.descriptorsToImport) {
@@ -141,13 +139,11 @@ class OptimizedImportsBuilder(
             val nameCountToUseStar = descriptors.first().nameCountToUseStar()
             val useExplicitImports = fqNames.size < nameCountToUseStar && !options.isInPackagesToUseStarImport(parentFqName)
                     || !starImportPath.isAllowedByRules()
+
             if (useExplicitImports) {
-                fqNames
+                fqNames.filter(this::needExplicitImport).mapTo(importsToGenerate) { ImportPath(it, false) }
-                    .filter(this::needExplicitImport)
-                    .mapTo(importsToGenerate) { ImportPath(it, false) }
             } else {
-                descriptors
+                descriptors.asSequence()
-                    .asSequence()
                     .filterIsInstance<ClassDescriptor>()
                     .map { it.importableFqName!! }
                     .filterTo(classNamesToCheck, this::needExplicitImport)
@@ -183,8 +179,11 @@ class OptimizedImportsBuilder(
                     val element = ref.element
                     val bindingContext = element.analyze()
                     val expressionToAnalyze = getExpressionToAnalyze(element) ?: continue
-                    val newScope =
+                    val newScope = element.getResolutionScope(
-                        element.getResolutionScope(bindingContext, file.getResolutionFacade()).replaceImportingScopes(newFileScope)
+                        bindingContext,
+                        file.getResolutionFacade()
+                    ).replaceImportingScopes(newFileScope)
+
                     val newBindingContext = expressionToAnalyze.analyzeAsReplacement(
                         expressionToAnalyze,
                         bindingContext,
@@ -272,10 +271,12 @@ class OptimizedImportsBuilder(
                 append("\n")
             }
         }
+
         val fileWithImports = KtPsiFactory(originalFile).createAnalyzableFile("Dummy_" + originalFile.name, fileText, originalFile)
         if (file.isScript()) {
             fileWithImports.originalFile = originalFile
         }
+
         return fileWithImports.getFileResolutionScope()
     }
 
@@ -312,12 +313,10 @@ class OptimizedImportsBuilder(
             .filter { it.isNotEmpty() }
     }
 
-    private fun canUseStarImport(descriptor: DeclarationDescriptor, fqName: FqName): Boolean {
+    private fun canUseStarImport(descriptor: DeclarationDescriptor, fqName: FqName): Boolean = when {
-        return when {
+        fqName.parent().isRoot -> false
-            fqName.parent().isRoot -> false
+        (descriptor.containingDeclaration as? ClassDescriptor)?.kind == ClassKind.OBJECT -> false
-            (descriptor.containingDeclaration as? ClassDescriptor)?.kind == ClassKind.OBJECT -> false
+        else -> true
-            else -> true
-        }
     }
 
     private fun needExplicitImport(fqName: FqName): Boolean = hasAlias(fqName) || !isImportedByDefault(fqName)

idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt

@@ -102,6 +102,7 @@ class KotlinImportOptimizer : ImportOptimizer {
                     element.acceptChildren(this)
                 }
             })
+
             size
         } else {
             0
@@ -205,12 +206,14 @@ class KotlinImportOptimizer : ImportOptimizer {
                 get() {
                     val resolvesByNames = reference.resolvesByNames
                     if (reference is KtInvokeFunctionReference) {
-                        val additionalNames = (reference.element.calleeExpression as? KtNameReferenceExpression)
+                        val additionalNames =
-                            ?.mainReference?.resolvesByNames
+                            (reference.element.calleeExpression as? KtNameReferenceExpression)?.mainReference?.resolvesByNames
+
                         if (additionalNames != null) {
                             return resolvesByNames + additionalNames
                         }
                     }
+
                     return resolvesByNames
                 }
 
@@ -223,6 +226,7 @@ class KotlinImportOptimizer : ImportOptimizer {
                         if (reference.getter) "Getter" else "Setter"
                     )
                 }
+
                 else -> reference.toString().replace("DescriptorsImpl", "")
             }
         }

idea/src/org/jetbrains/kotlin/idea/inspections/KotlinUnusedImportInspection.kt

@@ -57,7 +57,7 @@ import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.resolve.ImportPath
 
 class KotlinUnusedImportInspection : AbstractKotlinInspection() {
-    data class ImportData(val unusedImports: List<KtImportDirective>, val optimizerData: OptimizedImportsBuilder.InputData)
+    class ImportData(val unusedImports: List<KtImportDirective>, val optimizerData: OptimizedImportsBuilder.InputData)
 
     companion object {
         fun analyzeImports(file: KtFile): ImportData? {
@@ -128,6 +128,7 @@ class KotlinUnusedImportInspection : AbstractKotlinInspection() {
             if (!KotlinCodeInsightWorkspaceSettings.getInstance(file.project).optimizeImportsOnTheFly) {
                 fixes.add(EnableOptimizeImportsOnTheFlyFix(file))
             }
+
             manager.createProblemDescriptor(
                 it,
                 KotlinBundle.message("unused.import.directive"),