Minor: remove unused parameter

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

@@ -34,8 +34,7 @@ public class ImportDirectiveProcessor(
             importDirective: JetImportDirective,
             moduleDescriptor: ModuleDescriptor,
             trace: BindingTrace,
-            lookupMode: QualifiedExpressionResolver.LookupMode,
-            allowClassesFromDefaultPackage: Boolean
+            lookupMode: QualifiedExpressionResolver.LookupMode
     ): JetScope {
         if (importDirective.isAbsoluteInRootPackage()) {
             trace.report(Errors.UNSUPPORTED.on(importDirective, "TypeHierarchyResolver")) // TODO

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

@@ -76,10 +76,9 @@ public class QualifiedExpressionResolver {
             @NotNull JetImportDirective importDirective,
             @NotNull ModuleDescriptor moduleDescriptor,
             @NotNull BindingTrace trace,
-            @NotNull LookupMode lookupMode,
-            boolean allowClassesFromDefaultPackage
+            @NotNull LookupMode lookupMode
     ) {
-        return importDirectiveProcessor.processImportReference(importDirective, moduleDescriptor, trace, lookupMode, allowClassesFromDefaultPackage);
+        return importDirectiveProcessor.processImportReference(importDirective, moduleDescriptor, trace, lookupMode);
     }
 
     @NotNull

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

@@ -76,10 +76,10 @@ class LazyFileScope private constructor(
             val packageFragment = resolveSession.getPackageFragment(file.getPackageFqName())
                     .sure { "Could not find fragment ${file.getPackageFqName()} for file ${file.getName()}" }
 
-            val aliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(imports), traceForImportResolve, true)
-            val allUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(imports), traceForImportResolve, true)
-            val defaultAliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(defaultImports), traceForDefaultImportResolve, false)
-            val defaultAllUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(defaultImports), traceForDefaultImportResolve, false)
+            val aliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(imports), traceForImportResolve)
+            val allUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(imports), traceForImportResolve)
+            val defaultAliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(defaultImports), traceForDefaultImportResolve)
+            val defaultAllUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(defaultImports), traceForDefaultImportResolve)
 
             val scopeChain = ArrayList<JetScope>()
 

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

@@ -67,8 +67,7 @@ class LazyImportResolver(
         val resolveSession: ResolveSession,
         val moduleDescriptor: ModuleDescriptor,
         val indexedImports: IndexedImports,
-        private val traceForImportResolve: BindingTrace,
-        private val includeRootPackageClasses: Boolean
+        private val traceForImportResolve: BindingTrace
 ) {
     private val importedScopesProvider = resolveSession.getStorageManager().createMemoizedFunction {
         directive: JetImportDirective -> ImportDirectiveResolveCache(directive)
@@ -99,7 +98,7 @@ class LazyImportResolver(
                     try {
                         val resolver = resolveSession.getQualifiedExpressionResolver()
                         val directiveImportScope = resolver.processImportReference(
-                                directive, moduleDescriptor, traceForImportResolve, mode, includeRootPackageClasses)
+                                directive, moduleDescriptor, traceForImportResolve, mode)
                         val descriptors = if (directive.isAllUnder()) emptyList() else directiveImportScope.getAllDescriptors()
 
                         if (mode == LookupMode.EVERYTHING) {

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

@@ -35,7 +35,10 @@ import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingTraceContext
+import org.jetbrains.kotlin.resolve.ImportPath
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.utils.keysToMap
@@ -222,12 +225,12 @@ private class ResolutionFacadeImpl(private val project: Project, private val cac
         return cache.getLazyResolveSession(file).getScopeProvider().getFileScope(file)
     }
 
-    override fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName, isDefaultImport: Boolean): Collection<DeclarationDescriptor> {
+    override fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName): Collection<DeclarationDescriptor> {
         val importDirective = JetPsiFactory(project).createImportDirective(ImportPath(fqName, false))
         val resolveSession = cache.getLazyResolveSession(moduleDescriptor)
         val resolver = resolveSession.getQualifiedExpressionResolver()
         return resolver.processImportReference(
-                importDirective, moduleDescriptor, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING, !isDefaultImport).getAllDescriptors()
+                importDirective, moduleDescriptor, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING).getAllDescriptors()
     }
 
     override fun <T> get(extension: CacheExtension<T>): T {

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

@@ -38,7 +38,7 @@ public trait ResolutionFacade {
 
     public fun getFileTopLevelScope(file: JetFile): JetScope
 
-    public fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName, isDefaultImport: Boolean = false): Collection<DeclarationDescriptor>
+    public fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName): Collection<DeclarationDescriptor>
 
     public fun findModuleDescriptor(element: JetElement): ModuleDescriptor
 

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

@@ -34,9 +34,9 @@ public fun JetDeclaration.resolveToDescriptor(): DeclarationDescriptor {
     return getResolutionFacade().resolveToDescriptor(this)
 }
 
-public fun JetFile.resolveImportReference(fqName: FqName, isDefaultImport: Boolean = false): Collection<DeclarationDescriptor> {
+public fun JetFile.resolveImportReference(fqName: FqName): Collection<DeclarationDescriptor> {
     val facade = getResolutionFacade()
-    return facade.resolveImportReference(facade.findModuleDescriptor(this), fqName, isDefaultImport)
+    return facade.resolveImportReference(facade.findModuleDescriptor(this), fqName)
 }
 
 //NOTE: the difference between analyze and analyzeFully is 'intentionally' unclear