Allow to exclude specific types from packages imported by default.

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

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.utils.Printer
 
 class AllUnderImportScope(
         descriptor: DeclarationDescriptor,
-        aliasImportNames: Collection<FqName>
+        excludedImportNames: Collection<FqName>
 ) : BaseImportingScope(null) {
 
     private val scopes: List<ResolutionScope> = if (descriptor is ClassDescriptor) {
@@ -40,12 +40,13 @@ class AllUnderImportScope(
         listOf((descriptor as PackageViewDescriptor).memberScope)
     }
 
-    private val excludedNames = if (aliasImportNames.isEmpty()) { // optimization
+    private val excludedNames: Set<Name> = if (excludedImportNames.isEmpty()) { // optimization
-        emptyList<Name>()
+        emptySet<Name>()
     }
     else {
         val fqName = DescriptorUtils.getFqNameSafe(descriptor)
-        aliasImportNames.mapNotNull { if (it.parent() == fqName) it.shortName() else null }
+        // toSet() is used here instead mapNotNullTo(hashSetOf()) because it results in not keeping empty sets as separate instances
+        excludedImportNames.mapNotNull { if (it.parent() == fqName) it.shortName() else null }.toSet()
     }
 
     override fun getContributedDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<DeclarationDescriptor> {

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

@@ -158,7 +158,7 @@ class QualifiedExpressionResolver(val classifierUsageCheckers: Iterable<Classifi
             importDirective: KtImportDirective,
             moduleDescriptor: ModuleDescriptor,
             trace: BindingTrace,
-            aliasImportNames: Collection<FqName>,
+            excludedImportNames: Collection<FqName>,
             packageFragmentForVisibilityCheck: PackageFragmentDescriptor?
     ): ImportingScope? { // null if some error happened
         val importedReference = importDirective.importedReference ?: return null
@@ -182,7 +182,7 @@ class QualifiedExpressionResolver(val classifierUsageCheckers: Iterable<Classifi
                 return null
             }
 
-            return AllUnderImportScope(packageOrClassDescriptor, aliasImportNames)
+            return AllUnderImportScope(packageOrClassDescriptor, excludedImportNames)
         }
         else {
             return processSingleImport(moduleDescriptor, trace, importDirective, path, lastPart, packageFragmentForCheck)

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt

@@ -58,26 +58,19 @@ class FileScopeFactory(
         val debugName = "LazyFileScope for file " + file.name
         val tempTrace = TemporaryBindingTrace.create(bindingTrace, "Transient trace for default imports lazy resolve")
 
+        infix fun <T> Collection<T>.concat(other: Collection<T>?) =
+                if (other == null || other.isEmpty()) this else this + other
+
         val imports = file.importDirectives
 
         val aliasImportNames = imports.mapNotNull { if (it.aliasName != null) it.importedFqName else null }
 
-        val packageView = moduleDescriptor.getPackage(file.packageFqName)
-        val packageFragment = topLevelDescriptorProvider.getPackageFragment(file.packageFqName)
-                              ?: error("Could not find fragment ${file.packageFqName} for file ${file.name}")
-
-        fun createImportResolver(indexedImports: IndexedImports, trace: BindingTrace)
-                = LazyImportResolver(storageManager, qualifiedExpressionResolver, moduleDescriptor, indexedImports, aliasImportNames, trace, packageFragment)
-
-        val explicitImportResolver = createImportResolver(ExplicitImportsIndexed(imports), bindingTrace)
-        val allUnderImportResolver = createImportResolver(AllUnderImportsIndexed(imports), bindingTrace)
-
         val extraImports = file.originalFile.virtualFile?.let {  vFile ->
             val scriptExternalDependencies = getScriptExternalDependencies(vFile, file.project)
             ktImportsFactory.createImportDirectives(scriptExternalDependencies?.imports?.map { ImportPath(it) }.orEmpty())
         }
 
-        val allImplicitImports = defaultImports + extraImports.orEmpty()
+        val allImplicitImports = defaultImports concat extraImports
 
         val defaultImportsFiltered = if (aliasImportNames.isEmpty()) { // optimization
             allImplicitImports
@@ -85,8 +78,19 @@ class FileScopeFactory(
         else {
             allImplicitImports.filter { it.isAllUnder || it.importedFqName !in aliasImportNames }
         }
+
+        val packageView = moduleDescriptor.getPackage(file.packageFqName)
+        val packageFragment = topLevelDescriptorProvider.getPackageFragment(file.packageFqName)
+                              ?: error("Could not find fragment ${file.packageFqName} for file ${file.name}")
+
+        fun createImportResolver(indexedImports: IndexedImports, trace: BindingTrace, excludedImports: List<FqName>? = null)
+                = LazyImportResolver(storageManager, qualifiedExpressionResolver, moduleDescriptor, indexedImports, aliasImportNames concat excludedImports, trace, packageFragment)
+
+        val explicitImportResolver = createImportResolver(ExplicitImportsIndexed(imports), bindingTrace)
+        val allUnderImportResolver = createImportResolver(AllUnderImportsIndexed(imports), bindingTrace) // TODO: should we count excludedImports here also?
+
         val defaultExplicitImportResolver = createImportResolver(ExplicitImportsIndexed(defaultImportsFiltered), tempTrace)
-        val defaultAllUnderImportResolver = createImportResolver(AllUnderImportsIndexed(defaultImportsFiltered), tempTrace)
+        val defaultAllUnderImportResolver = createImportResolver(AllUnderImportsIndexed(defaultImportsFiltered), tempTrace, moduleDescriptor.excludedImports)
 
         val dummyContainerDescriptor = DummyContainerDescriptor(file, packageFragment)
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt

@@ -75,14 +75,14 @@ class LazyImportResolver(
         val qualifiedExpressionResolver: QualifiedExpressionResolver,
         val moduleDescriptor: ModuleDescriptor,
         val indexedImports: IndexedImports,
-        aliasImportNames: Collection<FqName>,
+        excludedImportNames: Collection<FqName>,
         private val traceForImportResolve: BindingTrace,
         private val packageFragment: PackageFragmentDescriptor
 ) : ImportResolver {
     private val importedScopesProvider = storageManager.createMemoizedFunctionWithNullableValues {
         directive: KtImportDirective ->
             val directiveImportScope = qualifiedExpressionResolver.processImportReference(
-                    directive, moduleDescriptor, traceForImportResolve, aliasImportNames, packageFragment) ?: return@createMemoizedFunctionWithNullableValues null
+                    directive, moduleDescriptor, traceForImportResolve, excludedImportNames, packageFragment) ?: return@createMemoizedFunctionWithNullableValues null
 
             if (!directive.isAllUnder) {
                 PlatformTypesMappedToKotlinChecker.checkPlatformTypesMappedToKotlin(

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt

@@ -49,7 +49,7 @@ class RuntimeModuleData private constructor(val deserialization: Deserialization
             val storageManager = LockBasedStorageManager()
             val builtIns = JvmBuiltIns(storageManager)
             val module = ModuleDescriptorImpl(Name.special("<runtime module for $classLoader>"), storageManager,
-                                              ModuleParameters(listOf(), JavaToKotlinClassMap.INSTANCE), builtIns)
+                                              ModuleParameters(emptyList(), emptyList(), JavaToKotlinClassMap.INSTANCE), builtIns)
 
             val reflectKotlinClassFinder = ReflectKotlinClassFinder(classLoader)
             val deserializedDescriptorResolver = DeserializedDescriptorResolver(RuntimeErrorReporter)

core/descriptors/src/org/jetbrains/kotlin/descriptors/ModuleDescriptor.kt

@@ -49,6 +49,7 @@ interface ModuleDescriptor : DeclarationDescriptor, ModuleParameters {
 
 interface ModuleParameters {
     val defaultImports: List<ImportPath>
+    val excludedImports: List<FqName> get() = emptyList()
     val platformToKotlinClassMap: PlatformToKotlinClassMap
 
     object Empty: ModuleParameters {
@@ -57,8 +58,9 @@ interface ModuleParameters {
     }
 }
 
-fun ModuleParameters(defaultImports: List<ImportPath>, platformToKotlinClassMap: PlatformToKotlinClassMap): ModuleParameters =
+fun ModuleParameters(defaultImports: List<ImportPath>, excludedImports: List<FqName>, platformToKotlinClassMap: PlatformToKotlinClassMap): ModuleParameters =
         object : ModuleParameters {
             override val defaultImports: List<ImportPath> = defaultImports
+            override val excludedImports: List<FqName> get() = excludedImports
             override val platformToKotlinClassMap: PlatformToKotlinClassMap = platformToKotlinClassMap
         }

core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java

@@ -69,6 +69,12 @@ public class ErrorUtils {
                 return emptyList();
             }
 
+            @NotNull
+            @Override
+            public List<FqName> getExcludedImports() {
+                return emptyList();
+            }
+
             @NotNull
             @Override
             public Annotations getAnnotations() {

idea/ide-common/src/org/jetbrains/kotlin/idea/caches/resolve/resolutionApi.kt

@@ -85,5 +85,5 @@ fun ResolutionFacade.resolveImportReference(
     val importDirective = KtPsiFactory(project).createImportDirective(ImportPath(fqName, false))
     val qualifiedExpressionResolver = this.getFrontendService(moduleDescriptor, QualifiedExpressionResolver::class.java)
     return qualifiedExpressionResolver.processImportReference(
-            importDirective, moduleDescriptor, BindingTraceContext(), aliasImportNames = emptyList(), packageFragmentForVisibilityCheck = null)?.getContributedDescriptors() ?: emptyList()
+            importDirective, moduleDescriptor, BindingTraceContext(), excludedImportNames = emptyList(), packageFragmentForVisibilityCheck = null)?.getContributedDescriptors() ?: emptyList()
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt

@@ -136,7 +136,7 @@ class CodeFragmentAnalyzer(
 
         val importScopes = importList.imports.mapNotNull {
             qualifierResolver.processImportReference(it, resolveSession.moduleDescriptor, resolveSession.trace,
-                                                     aliasImportNames = emptyList(), packageFragmentForVisibilityCheck = null)
+                                                     excludedImportNames = emptyList(), packageFragmentForVisibilityCheck = null)
         }
 
         return scopeForContextElement.addImportingScopes(importScopes) to dataFlowInfo

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/SourceNavigationHelper.java

@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptorKt;
+import org.jetbrains.kotlin.descriptors.ModuleParameters;
 import org.jetbrains.kotlin.frontend.di.InjectionKt;
 import org.jetbrains.kotlin.idea.stubindex.KotlinFullClassNameIndex;
 import org.jetbrains.kotlin.idea.stubindex.KotlinSourceFilterScope;
@@ -239,10 +240,12 @@ public class SourceNavigationHelper {
     ) {
 
         TargetPlatform platform = TargetPlatform.Default.INSTANCE;
+        ModuleParameters defaultJvmModuleParameters = JvmPlatform.INSTANCE.getDefaultModuleParameters();
         MutableModuleContext newModuleContext = ContextKt.ContextForNewModule(
                 project, Name.special("<library module>"),
                 ModuleDescriptorKt.ModuleParameters(
-                        JvmPlatform.INSTANCE.getDefaultModuleParameters().getDefaultImports(),
+                        defaultJvmModuleParameters.getDefaultImports(),
+                        defaultJvmModuleParameters.getExcludedImports(),
                         PlatformToKotlinClassMap.EMPTY
                 ),
                 DefaultBuiltIns.getInstance()