Code improvements after review

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

@@ -125,7 +125,7 @@ public class QualifiedExpressionResolver {
         else {
             Name aliasName = JetPsiUtil.getAliasName(importDirective);
             if (aliasName == null) return JetScope.Empty.INSTANCE$;
-            return new SingleAliasScope(aliasName, descriptors);
+            return new SingleImportScope(aliasName, descriptors);
         }
     }
 

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

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.utils.Printer
 
-class SingleAliasScope(private val aliasName: Name, private val descriptors: Collection<DeclarationDescriptor>) : JetScope {
+class SingleImportScope(private val aliasName: Name, private val descriptors: Collection<DeclarationDescriptor>) : JetScope {
     override fun getClassifier(name: Name)
             = if (name == aliasName) descriptors.filterIsInstance<ClassifierDescriptor>().singleOrNull() else null
 
@@ -48,6 +48,6 @@ class SingleAliasScope(private val aliasName: Name, private val descriptors: Col
     override fun getOwnDeclaredDescriptors(): Collection<DeclarationDescriptor> = emptyList()
 
     override fun printScopeStructure(p: Printer) {
-        p.println(javaClass.getSimpleName())
+        p.println(javaClass.getSimpleName(), ": ", aliasName)
     }
 }

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

@@ -99,23 +99,22 @@ class LazyImportResolver(
                 else {
                     directiveUnderResolve = directive
 
-                    val directiveImportScope: JetScope
-                    val descriptors: Collection<DeclarationDescriptor>
                     try {
                         val resolver = resolveSession.getQualifiedExpressionResolver()
-                        directiveImportScope = resolver.processImportReference(
+                        val directiveImportScope = resolver.processImportReference(
                                 directive, rootScope, packageView.getMemberScope(), traceForImportResolve, mode)
-                        descriptors = if (directive.isAllUnder()) emptyList() else directiveImportScope.getAllDescriptors()
+                        val descriptors = if (directive.isAllUnder()) emptyList() else directiveImportScope.getAllDescriptors()
+
                         if (mode == LookupMode.EVERYTHING) {
                             PlatformTypesMappedToKotlinChecker.checkPlatformTypesMappedToKotlin(packageView.getModule(), traceForImportResolve, directive, descriptors)
                         }
+
+                        importResolveStatus = ImportResolveStatus(mode, directiveImportScope, descriptors)
+                        directiveImportScope
                     }
                     finally {
                         directiveUnderResolve = null
                     }
-
-                    importResolveStatus = ImportResolveStatus(mode, directiveImportScope, descriptors)
-                    directiveImportScope
                 }
             }
         }