Refactor QualifiedExpressionResolver: pass descriptor to check for visibility instead of scope

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

@@ -33,7 +33,7 @@ public class ImportDirectiveProcessor(
     public fun processImportReference(
             importDirective: JetImportDirective,
             scope: JetScope,
-            scopeToCheckVisibility: JetScope,
+            shouldBeVisibleFrom: DeclarationDescriptor,
             trace: BindingTrace,
             lookupMode: QualifiedExpressionResolver.LookupMode
     ): JetScope {
@@ -47,13 +47,13 @@ public class ImportDirectiveProcessor(
         val descriptors = if (importedReference is JetQualifiedExpression) {
             //store result only when we find all descriptors, not only classes on the second phase
             qualifiedExpressionResolver.lookupDescriptorsForQualifiedExpression(
-                    importedReference, scope, scopeToCheckVisibility, trace, lookupMode, lookupMode.isEverything()
+                    importedReference, scope, shouldBeVisibleFrom, trace, lookupMode, lookupMode.isEverything()
             )
         }
         else {
             assert(importedReference is JetSimpleNameExpression)
             qualifiedExpressionResolver.lookupDescriptorsForSimpleNameReference(
-                    importedReference as JetSimpleNameExpression, scope, scopeToCheckVisibility, trace, lookupMode, true, lookupMode.isEverything()
+                    importedReference as JetSimpleNameExpression, scope, shouldBeVisibleFrom, trace, lookupMode, true, lookupMode.isEverything()
             )
         }
 

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

@@ -75,11 +75,11 @@ public class QualifiedExpressionResolver {
     public JetScope processImportReference(
             @NotNull JetImportDirective importDirective,
             @NotNull JetScope scope,
-            @NotNull JetScope scopeToCheckVisibility,
+            @NotNull DeclarationDescriptor shouldBeVisibleFrom,
             @NotNull BindingTrace trace,
             @NotNull LookupMode lookupMode
     ) {
-        return importDirectiveProcessor.processImportReference(importDirective, scope, scopeToCheckVisibility, trace, lookupMode);
+        return importDirectiveProcessor.processImportReference(importDirective, scope, shouldBeVisibleFrom, trace, lookupMode);
     }
 
     @NotNull
@@ -104,13 +104,14 @@ public class QualifiedExpressionResolver {
         // We do not want to resolve the last segment of a user type to a package
         JetScope filteredScope = filterOutPackagesIfNeeded(outerScope, onlyClassifiers);
 
+        DeclarationDescriptor shouldBeVisibleFrom = outerScope.getContainingDeclaration();
         if (qualifier == null) {
-            return lookupDescriptorsForSimpleNameReference(referenceExpression, filteredScope, outerScope, trace,
+            return lookupDescriptorsForSimpleNameReference(referenceExpression, filteredScope, shouldBeVisibleFrom, trace,
                                                            LookupMode.ONLY_CLASSES_AND_PACKAGES,
                                                            false, true);
         }
         Collection<DeclarationDescriptor> declarationDescriptors = lookupDescriptorsForUserType(qualifier, outerScope, trace, false);
-        return lookupSelectorDescriptors(referenceExpression, declarationDescriptors, trace, filteredScope,
+        return lookupSelectorDescriptors(referenceExpression, declarationDescriptors, trace, shouldBeVisibleFrom,
                                          LookupMode.ONLY_CLASSES_AND_PACKAGES, true);
     }
 
@@ -135,7 +136,7 @@ public class QualifiedExpressionResolver {
     public Collection<DeclarationDescriptor> lookupDescriptorsForQualifiedExpression(
             @NotNull JetQualifiedExpression importedReference,
             @NotNull JetScope outerScope,
-            @NotNull JetScope scopeToCheckVisibility,
+            @NotNull DeclarationDescriptor shouldBeVisibleFrom,
             @NotNull BindingTrace trace,
             @NotNull LookupMode lookupMode,
             boolean storeResult
@@ -144,14 +145,14 @@ public class QualifiedExpressionResolver {
         Collection<DeclarationDescriptor> declarationDescriptors;
         if (receiverExpression instanceof JetQualifiedExpression) {
             declarationDescriptors =
-                    lookupDescriptorsForQualifiedExpression((JetQualifiedExpression) receiverExpression, outerScope, scopeToCheckVisibility,
+                    lookupDescriptorsForQualifiedExpression((JetQualifiedExpression) receiverExpression, outerScope, shouldBeVisibleFrom,
                                                             trace, lookupMode, storeResult);
         }
         else {
             assert receiverExpression instanceof JetSimpleNameExpression;
             declarationDescriptors =
                     lookupDescriptorsForSimpleNameReference((JetSimpleNameExpression) receiverExpression, outerScope,
-                                                            scopeToCheckVisibility, trace, lookupMode, true, storeResult);
+                                                            shouldBeVisibleFrom, trace, lookupMode, true, storeResult);
         }
 
         JetExpression selectorExpression = importedReference.getSelectorExpression();
@@ -166,7 +167,7 @@ public class QualifiedExpressionResolver {
             return Collections.emptyList();
         }
 
-        return lookupSelectorDescriptors(selector, declarationDescriptors, trace, scopeToCheckVisibility, lookupMode, storeResult);
+        return lookupSelectorDescriptors(selector, declarationDescriptors, trace, shouldBeVisibleFrom, lookupMode, storeResult);
     }
 
     @NotNull
@@ -174,7 +175,7 @@ public class QualifiedExpressionResolver {
             @NotNull JetSimpleNameExpression selector,
             @NotNull Collection<DeclarationDescriptor> declarationDescriptors,
             @NotNull BindingTrace trace,
-            @NotNull JetScope scopeToCheckVisibility,
+            @NotNull DeclarationDescriptor shouldBeVisibleFrom,
             @NotNull LookupMode lookupMode,
             boolean storeResult
     ) {
@@ -188,7 +189,7 @@ public class QualifiedExpressionResolver {
                 addResultsForClass(results, selector, lookupMode, (ClassDescriptor) declarationDescriptor);
             }
         }
-        return filterAndStoreResolutionResult(results, selector, trace, scopeToCheckVisibility, lookupMode, storeResult);
+        return filterAndStoreResolutionResult(results, selector, trace, shouldBeVisibleFrom, lookupMode, storeResult);
     }
 
     private static void addResultsForClass(
@@ -211,14 +212,14 @@ public class QualifiedExpressionResolver {
     public Collection<DeclarationDescriptor> lookupDescriptorsForSimpleNameReference(
             @NotNull JetSimpleNameExpression referenceExpression,
             @NotNull JetScope outerScope,
-            @NotNull JetScope scopeToCheckVisibility,
+            @NotNull DeclarationDescriptor shouldBeVisibleFrom,
             @NotNull BindingTrace trace,
             @NotNull LookupMode lookupMode,
             boolean packageLevel,
             boolean storeResult
     ) {
         LookupResult lookupResult = lookupSimpleNameReference(referenceExpression, outerScope, lookupMode, packageLevel);
-        return filterAndStoreResolutionResult(Collections.singletonList(lookupResult), referenceExpression, trace, scopeToCheckVisibility,
+        return filterAndStoreResolutionResult(Collections.singletonList(lookupResult), referenceExpression, trace, shouldBeVisibleFrom,
                                               lookupMode, storeResult);
     }
 
@@ -260,7 +261,7 @@ public class QualifiedExpressionResolver {
             @NotNull Collection<LookupResult> lookupResults,
             @NotNull JetSimpleNameExpression referenceExpression,
             @NotNull BindingTrace trace,
-            @NotNull JetScope scopeToCheckVisibility,
+            @NotNull DeclarationDescriptor shouldBeVisibleFrom,
             @NotNull LookupMode lookupMode,
             boolean storeResult
     ) {
@@ -304,7 +305,7 @@ public class QualifiedExpressionResolver {
             }
 
             storeResolutionResult(descriptors, filteredDescriptors, referenceExpression, possibleResolutionScopes, trace,
-                                  scopeToCheckVisibility);
+                                  shouldBeVisibleFrom);
         }
 
         return filteredDescriptors;
@@ -316,7 +317,7 @@ public class QualifiedExpressionResolver {
             @NotNull JetSimpleNameExpression referenceExpression,
             @NotNull Collection<JetScope> possibleResolutionScopes,
             @NotNull BindingTrace trace,
-            @NotNull JetScope scopeToCheckVisibility
+            @NotNull DeclarationDescriptor shouldBeVisibleFrom
     ) {
         assert canBeImportedDescriptors.size() <= descriptors.size();
         assert !possibleResolutionScopes.isEmpty();
@@ -324,7 +325,7 @@ public class QualifiedExpressionResolver {
         JetScope resolutionScope = possibleResolutionScopes.iterator().next();
 
         // A special case - will fill all trace information
-        if (resolveClassPackageAmbiguity(canBeImportedDescriptors, referenceExpression, resolutionScope, trace, scopeToCheckVisibility)) {
+        if (resolveClassPackageAmbiguity(canBeImportedDescriptors, referenceExpression, resolutionScope, trace, shouldBeVisibleFrom)) {
             return;
         }
 
@@ -353,7 +354,7 @@ public class QualifiedExpressionResolver {
             }
 
             if (descriptor instanceof DeclarationDescriptorWithVisibility) {
-                checkVisibility((DeclarationDescriptorWithVisibility) descriptor, trace, referenceExpression, scopeToCheckVisibility);
+                checkVisibility((DeclarationDescriptorWithVisibility) descriptor, trace, referenceExpression, shouldBeVisibleFrom);
             }
         }
 
@@ -379,7 +380,7 @@ public class QualifiedExpressionResolver {
             @NotNull JetSimpleNameExpression referenceExpression,
             @NotNull JetScope resolutionScope,
             @NotNull BindingTrace trace,
-            @NotNull JetScope scopeToCheckVisibility
+            @NotNull DeclarationDescriptor shouldBeVisibleFrom
     ) {
         if (filteredDescriptors.size() == 2) {
             PackageViewDescriptor packageView = null;
@@ -398,7 +399,7 @@ public class QualifiedExpressionResolver {
                 if (packageView.getFqName().equalsTo(DescriptorUtils.getFqName(classDescriptor))) {
                     trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classDescriptor);
                     trace.record(BindingContext.RESOLUTION_SCOPE, referenceExpression, resolutionScope);
-                    checkVisibility(classDescriptor, trace, referenceExpression, scopeToCheckVisibility);
+                    checkVisibility(classDescriptor, trace, referenceExpression, shouldBeVisibleFrom);
                     return true;
                 }
             }
@@ -411,9 +412,9 @@ public class QualifiedExpressionResolver {
             @NotNull DeclarationDescriptorWithVisibility descriptor,
             @NotNull BindingTrace trace,
             @NotNull JetSimpleNameExpression referenceExpression,
-            @NotNull JetScope scopeToCheckVisibility
+            @NotNull DeclarationDescriptor shouldBeVisibleFrom
     ) {
-        if (!Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, descriptor, scopeToCheckVisibility.getContainingDeclaration())) {
+        if (!Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, descriptor, shouldBeVisibleFrom)) {
             Visibility visibility = descriptor.getVisibility();
             if (PsiTreeUtil.getParentOfType(referenceExpression, JetImportDirective.class) != null && !visibility.mustCheckInImports()) {
                 return;

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

@@ -101,7 +101,7 @@ class LazyImportResolver(
                     try {
                         val resolver = resolveSession.getQualifiedExpressionResolver()
                         val directiveImportScope = resolver.processImportReference(
-                                directive, rootScope, packageView.getMemberScope(), traceForImportResolve, mode)
+                                directive, rootScope, packageView, traceForImportResolve, mode)
                         val descriptors = if (directive.isAllUnder()) emptyList() else directiveImportScope.getAllDescriptors()
 
                         if (mode == LookupMode.EVERYTHING) {

idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.di.InjectorForBodyResolve
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -421,14 +420,13 @@ public abstract class ElementResolver protected(
                     val filePackage = resolveSession.getModuleDescriptor().getPackage(fqName)
                                       ?: error("File package should be already resolved and be found")
 
-                    val scope = filePackage.getMemberScope()
                     val descriptors = if (element is JetDotQualifiedExpression) {
                         qualifiedExpressionResolver.lookupDescriptorsForQualifiedExpression(
-                                element, rootPackage.getMemberScope(), scope, trace, QualifiedExpressionResolver.LookupMode.EVERYTHING, false)
+                                element, rootPackage.getMemberScope(), filePackage, trace, QualifiedExpressionResolver.LookupMode.EVERYTHING, false)
                     }
                     else {
                         qualifiedExpressionResolver.lookupDescriptorsForSimpleNameReference(
-                                element as JetSimpleNameExpression, rootPackage.getMemberScope(), scope, trace, QualifiedExpressionResolver.LookupMode.EVERYTHING, false, false)
+                                element as JetSimpleNameExpression, rootPackage.getMemberScope(), filePackage, trace, QualifiedExpressionResolver.LookupMode.EVERYTHING, false, false)
                     }
 
                     return descriptors.firstIsInstanceOrNull<PackageViewDescriptor>()?.getMemberScope()

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

@@ -228,7 +228,7 @@ private class ResolutionFacadeImpl(private val project: Project, private val cac
         val scope = JetModuleUtil.getImportsResolutionScope(moduleDescriptor, !isDefaultImport)
         val resolver = resolveSession.getQualifiedExpressionResolver()
         return resolver.processImportReference(
-                importDirective, scope, scope, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING).getAllDescriptors()
+                importDirective, moduleDescriptor, scope, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING).getAllDescriptors()
     }
 
     override fun <T> get(extension: CacheExtension<T>): T {